記事ディレクトリ

1。概要
2. 基本的なユースケース - SpringMVC 基本アプリケーション
3. プロセス原理
4. リクエストとレスポンス
5.RESTスタイル
6.SSM連携（キー）
7. インターセプター
8. 実行プロセス
ガソリンスタンドの知識（ポイント）

1。概要

メモの要約:

意味: SpringMVC: Spring MVC は、Java ベースのWeb アプリケーションを構築するための Spring Framework のモジュールです。SpringMVCは、プレゼンテーション層のフレームワーク技術であり、プレゼンテーション。

MVC: アプリケーションを 3 つの主要なコンポーネント (モデル、ビュー、およびコントローラー)に分割する設計パターン

特徴：

軽量

疎結合

高度にカスタマイズ可能

テストが簡単

他のテクノロジーを統合する

RESTful サポート

1.1 意味

Spring MVC は、Java ベースの Web アプリケーションを構築するための Spring Framework のモジュールです。MVC (Model-View-Controller) 設計パターンに基づいた開発手法を提供し、開発者が柔軟でスケーラブルな Web アプリケーションを構築できるようにします。

Spring MVCは、リクエストとレスポンスを対応するプロセッサ(Controller)にディスパッチすることでWebリクエストを処理し、処理結果をユーザーに提示します。疎結合設計を採用しているため、開発者はアプリケーションのビジネスロジックとユーザーインターフェイスを分離でき、コードの編成と保守性が向上します。

画像-20230814221014724

例証します:

SpringMVC は、MVC モデルを実装する Java ベースの軽量 Web フレームワークです。

アドバンテージ

使いやすく、開発も便利 (サーブレットと比較して)

高い柔軟性

SpringMVC、バックエンドサーバーのプレゼンテーション層を置き換えるサーブレット開発

画像-20230527102146297

例証します:

SpringMVCの実行方法はサーブレット開発よりも簡潔です

1.2MVC設計パターン

画像-20230814102502858

MVC は、アプリケーションを 3 つの主要コンポーネント (モデル、ビュー、コントローラー) に分割するソフトウェア設計パターンです。このパターンの目標は、アプリケーションのロジック、データ、プレゼンテーションを分離して、コードの保守性、再利用性、および柔軟性を向上させることです。

モデル: モデルは、アプリケーションのデータとビジネスロジックを表します。データの読み取り、保存、検証、ビジネスルールの処理を処理します。モデルはビューと直接対話せず、コントローラーを介してデータを渡します。
ビュー: ビューは、モデルデータをユーザーに表示する役割を果たします。これは通常、Web ページ、グラフィカルインターフェイス、コマンドラインインターフェイスなどのユーザーインターフェイスの一部です。ビューはコントローラーからデータを受け取り、それをユーザーに提示します。
コントローラー: コントローラーはユーザーのリクエストを処理し、それに応じてモデルとビューを更新します。ユーザー入力(ボタンのクリック、フォームの送信など) を受け取り、その入力に基づいて適切なモデルロジックを呼び出してデータを更新し、更新されたデータを表示のためにビューに送信します。

MVC パターンの中心的な考え方は、アプリケーションのさまざまな機能部分を分離し、それらを独立させて置き換え可能にすることです。この分離により、コードの理解、保守、拡張が容易になります。また、開発者は互いに干渉することなく、モデル、ビュー、コントローラーのさまざまな部分を同時に作業できるため、チームワークも促進されます。MVC パターンは、Spring MVC、Ruby on Rails などの Web 開発フレームワークを含む、さまざまなソフトウェア開発フレームワークやテクノロジで広く使用されています。

1.3SpringMVCの機能

Spring MVC は、Spring フレームワークの一部である Java ベースの Web フレームワークで、柔軟でスケーラブルなWeb アプリケーションの開発に使用されます。Spring MVC のいくつかの機能を次に示します。

軽量: Spring MVC は POJO ベースの開発モデルを採用しており、特定のアプリケーションサーバーに依存しないため、非常に軽量です。
疎結合: Spring MVC は Spring フレームワークと緊密に統合されており、依存関係注入やアスペクト指向プログラミングなどの Spring の機能を使用してコンポーネント間の疎結合を実現します。
高度なカスタマイズ性: Spring MVC は豊富な構成オプションと拡張可能なインターフェースを提供し、開発者は特定のアプリケーション要件を満たすニーズに応じてさまざまなコンポーネントをカスタマイズおよび構成できます。
テストが簡単: Spring MVC は MVC 設計パターンを採用してビジネスロジック、データ処理、ユーザーインターフェイスを分離し、単体テストと統合テストを容易にします。
強力なリクエスト処理: Spring MVC は柔軟で強力なリクエスト処理メカニズムを提供し、リクエストのマッピング、パラメータのバインディング、データの検証、ビューの解析などをアノテーションと構成ファイルを通じて簡単に定義できます。
多様なビューテクノロジ: Spring MVC は、JSP、Thymeleaf、Freemark、Velocity などを含むさまざまなビューテクノロジをサポートしています。開発者は、プロジェクトのニーズに応じて適切なビューテクノロジを選択できます。
他のテクノロジーの統合: Spring MVC は、セキュリティの認証と認可を実装する Spring Security、データベースにアクセスする Spring Data、構成を簡素化する Spring Boot など、他のテクノロジーやフレームワークとシームレスに統合できます。
RESTful サポート: Spring MVC は RESTful スタイル開発に対する優れたサポートを提供し、RESTful スタイル API の作成と管理を容易にします。

全体として、Spring MVC には柔軟性、カスタマイズ性、テスト容易性という利点があり、Web アプリケーション開発に推奨されるフレームワークの 1 つとなっています。

2. 基本的なユースケース - SpringMVC 基本アプリケーション

メモの要約:

ステップ

インポートservlet-api、spring-webmvc依存関係座標

SpringMVCコントローラクラスの作成（サーブレット機能に相当）

設定ファイルクラスの作成

Servlet コンテナを初期化して SpringMVC 環境をロードし、SpringMVC テクノロジーによって処理されるリクエストを設定します。

説明:AbstractDispatcherServletInitializerこのクラスを継承し、3 つの抽象メソッドをオーバーライドし、AnnotationConfigWebApplicationContextSpringMVC コントローラーのファイルをロードします。

原理：

詳細については次のセクションを参照してください

注釈の使用法:

@Controller: SpringMVCのコアコントローラBeanを設定する

@RequestMapping: 現在のコントローラーメソッドリクエストのアクセスパスを設定します。

@ResponseBody: 現在のコントローラーメソッドの応答内容を現在の戻り値に設定します。解析する必要はありません。

@Configuration: クラスをSpring 構成クラスとして識別します。通常、アプリケーションの構成情報を定義するために他のアノテーションと組み合わせて使用されます。

@ComponentScan:指定されたパッケージ内のコンポーネント (クラス、インターフェース、アノテーションなどを含む) をスキャンし、それらを Spring Bean として登録するようにSpring に指示します。

ステップ 1: SpringMVC テクノロジーを使用するには、まず SpringMVC 座標とサーブレット座標をインポートする必要があります

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

例証します:

SpringMVC 座標では、リクエスト処理、ルーティング、データバインディング、ビュー解析など、Spring MVC が提供する関数や機能を使用できます。

サーブレット座標を導入すると、サーブレットコンテナの機能をプロジェクトに統合でき、プロジェクトでHTTP リクエストを処理し、レスポンスを生成できるようになります。

ステップ2: SpringMVCコントローラクラスの作成(サーブレット機能に相当)

//定义表现层控制器bean
@Controller
public class UserController {
    
    

    //设置映射路径为/save，即外部访问路径
    @RequestMapping("/save")
    //设置当前操作返回结果为指定json数据（本质上是一个字符串信息）
    @ResponseBody
    public String save() {
    
    
        System.out.println("user save ...");
        return "{'info':'springmvc'}";
    }

    //设置映射路径为/delete，即外部访问路径
    @RequestMapping("/delete")
    @ResponseBody
    public String delete() {
    
    
        System.out.println("user save ...");
        return "{'info':'springmvc'}";
    }
}

補充:

名前: @コントローラー
タイプ: クラスアノテーション

場所: SpringMVC コントローラークラス定義の上

役割： SpringMVCのコアコントローラBeanの設定
例：
@Controller
public class UserController {
         
         
}
名前: @RequestMapping
タイプ: メソッドのアノテーション

場所: SpringMVC コントローラーのメソッド定義の上

機能: 現在のコントローラーのメソッド要求アクセスパスを設定します。
例：
@RequestMapping("/save")
public void save(){
         
         
    System.out.println("user save ...");
}
関連するプロパティ

値 (デフォルト): リクエストのアクセスパス
名前: @ResponseBody
タイプ: メソッドのアノテーション

場所: SpringMVC コントローラーのメソッド定義の上

機能: 現在のコントローラーメソッドの応答内容を現在の戻り値に設定します。解析する必要はありません。
例：
@RequestMapping("/save")
@ResponseBody
public String save(){
         
         
    System.out.println("user save ...");
    return "{'info':'springmvc'}";
}

ステップ 3: 構成ファイルクラスを作成する

//springmvc配置类，本质上还是一个spring配置类
@Configuration
@ComponentScan("love.ljtxy.controller")
public class SpringMvcConfig {
    
    
}

例証します:

SpringMVC 環境 (Spring 環境と同じ) を初期化し、対応する Bean をロードするように SpringMVC を設定します。

知らせ：

ここでは、コントローラー層を Bean に変更するだけでよく、パッケージをスキャンするための追加の機器は必要ありません。

ステップ 4: サーブレットコンテナを初期化して SpringMVC 環境をロードし、SpringMVC テクノロジによって処理されるリクエストを設定する

//web容器配置类
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    
    
    //加载springmvc配置类，产生springmvc容器（本质还是spring容器）
    protected WebApplicationContext createServletApplicationContext() {
    
    
        //初始化WebApplicationContext对象
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        //加载指定配置类
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }

    //设置由springmvc控制器处理的请求映射路径
    protected String[] getServletMappings() {
    
    
        return new String[]{
    
    "/"};
    }

    //加载spring配置类
    protected WebApplicationContext createRootApplicationContext() {
    
    
        return null;
    }
}

例証します:

サーブレットコンテナの起動用の構成クラスを定義し、そこにスプリング構成をロードします

3. プロセス原理

メモの要約:

サーバーの初期化プロセスを開始します

Webコンテナの初期化

サーブレットコンテナの初期化

SpringMVC設定クラスのロード

@ComponentScanに対応するBeanをロードする

制御層Beanのロード

リクエストの処理

単一リクエストのプロセス

リクエストの送信

リクエスト配布

リクエストの解析

メソッドの配布

メソッドの実行

メソッド戻り値処理

注釈の使用法:

@ComponentScan: 指定されたパッケージとそのサブパッケージ内のクラスを自動的にスキャンし、それらをSpring コンポーネントとして識別します。依存関係の注入、自動アセンブリ

excludeFilters:スキャンパスにロードされた Bean を除外します。カテゴリ (タイプ) と特定の項目 (クラス) を指定する必要があります。

includeFilters:指定された Beanをロードします。カテゴリ (タイプ) と特定の項目 (クラス) を指定する必要があります。

3.1 概要

SpringMVCの起動では、処理が大きく2種類に分けられ、1つは起動サーバの初期化処理と呼ばれ、もう1つはシングルリクエスト処理と呼ばれます。

サーバーの初期化プロセスを開始します
1. サーバーが起動し、ServletContainersInitConfig クラスを実行して、Web コンテナを初期化します。
2. createServletApplicationContextメソッドを実行してWebApplicationContextオブジェクトを作成します。
3. SpringMvcConfigをロードする
4. @ComponentScan を実行して、対応する Bean をロードします
5. UserController をロードします。各 @RequestMapping 名は特定のメソッドに対応します
6. getServletMappings メソッドを実行し、すべてのリクエストが SpringMVC を通過することを定義します
単一リクエストのプロセス
1. リクエストの送信 localhost/save
2. Web コンテナは、すべてのリクエストが SpringMVC を経由していることを検出し、リクエストを SpringMVC に渡して処理します。
3. リクエストのパスを解析/保存
4. 対応するメソッド save() は、/save のマッチングによって実行されます。
5. save()を実行する
6. @ResponseBody が save() メソッドの戻り値をそのままレスポンスボディとしてリクエスタに返していることが検出されます。

画像-20230814103709269

例証します:

作成されたWebApplicationContextオブジェクトは、大きなサーブレットリクエストの ServletContext に配置されます。

3.2 SpringMVC と Spring の Bean ロード制御

com.itheima パッケージの下には、config、コントローラーなどのさまざまな Bean が含まれています。SpringMVC はコントローラー層の開発のみを制御し、Spring は config、service、dao 層の開発を制御します。ただし、このときに Spring のパッケージのスキャン範囲をパッケージの下に指定すると、 Springが誤ってSpringMVC Beanをロードしてcom.itheimaしまいます。

画像-20230530073206117

例証します:

Spring によって制御される Bean をロードするときに、SpringMVC によって制御される Bean を除外します。これにより、機能が異なるために Spring が誤って Bea を SpringMVC にロードすることを回避する方法の問題が解決されます。

補足：

Spring MVC関連 Bean (プレゼンテーション層Bean)

春に管理された豆

ビジネスBean（サービス）

機能Bean (DataSourceなど)

SpringMVC関連のBeanローディング制御

SpringMVC によってロードされる Bean に対応するパッケージはすべて com.itheima.controller パッケージ内にあります。

Spring関連のBeanローディング制御

方法1: Spring によってロードされる Bean のスキャン範囲を com.itheima に設定し、コントローラーパッケージ内の Bean を除外します。

方法 2: Spring によってロードされる Bean のスキャン範囲を、サービスパッケージ、dao パッケージなどの正確な範囲に設定します。

方法 3: Spring 環境と SpringMVC 環境を区別せず、同じ環境にロードする

3.3ServletContainersInitConfig.クラス

/**
 * Web容器配置类
 */
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    
    

    /**
     * 返回Spring应用程序的根配置类
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
    
    
        return new Class[]{
    
    SpringConfig.class};
    }

    /**
     * 返回Servlet的配置类
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
    
    
        return new Class[]{
    
    SpringMvcConfig.class};
    }

    /**
     * 返回DispatcherServlet的映射路径
     */
    @Override
    protected String[] getServletMappings() {
    
    
        return new String[]{
    
    "/"};
    }
}

知らせ：

getServletConfigClasses メソッドを使用する場合は、対応する戻り値 (SpringMvcConfig.class制御層の構成) を構成する必要があります。

3.4SpringConfig.クラス

@Configuration
@ComponentScan(value = "love.ljtxy",
        excludeFilters = @ComponentScan.Filter(
                type = FilterType.ANNOTATION,
                classes = Controller.class
        ))
public class SpringConfig {
    
    
}

例証します:

名前: @ComponentScan

タイプ: クラスアノテーション

属性

excludeFilters:スキャンパスにロードされた Bean を除外します。カテゴリ (タイプ) と特定の項目 (クラス) を指定する必要があります。

includeFilters:指定されたBean をロードします。カテゴリ (タイプ) と特定の項目 (クラス) を指定する必要があります。

詳細：

このアノテーションは @ComponentScan 内にあるため、@Filter内部アノテーションとして直接使用.できます。

3.5SpringMvcConfig.クラス

//springmvc配置类，本质上还是一个spring配置类
@Configuration
@ComponentScan("love.ljtxy.controller")
public class SpringMvcConfig {
    
    

}

例証します:

controllerここで必要なのは、レイヤーのパッケージのみをスキャンするように SpringMVC コントロールを構成することだけです。SpringMVC の設定は Spring のコントロール層を置き換えるためです。

4. リクエストとレスポンス

メモの要約:

リクエストマッピングパス: @RequestMapping: 現在のコントローラーメソッドリクエストアクセスパスを設定します。クラスに設定されている場合は、現在のコントローラーメソッドリクエストアクセスパスのプレフィックスを均一に設定します。

リクエスト方法:

リクエストパラメータの取得

ポストリクエストパラメータ

リクエスト後の中国語文字化け処理
// AbstractAnnotationConfigDispatcherServletInitializer 是 Spring Framework 中的一个类，它用于配置和初始化基于注解的 Spring MVC 应用程序
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer{
     
     
    // 配字符编码过滤器
    protected Filter[] getServletFilters() {
     
     
        CharacterEncodingFilter filter = new CharacterEncodingFilter(); //添加过滤器
        filter.setEncoding("utf-8"); //指定过滤器字符集
        return new Filter[]{
     
     filter};
    }
}
リクエストパラメータ

通常のパラメータ -同じ名前:設定は必要ありません

通常のパラメータ -名前が異なります。**@RequestParam を使用してパラメータ関係をバインドする必要があります**

POJOパラメータ (キーポイント):追加の設定なしでパラメータを直接受け取るために、POJO タイプの仮パラメータを定義します。エンティティクラスの属性名は一貫している必要があることに注意してください。通常形式のパラメータバインディングに適しています。

ネストされたPOJO パラメータ: リクエストパラメータ名は仮パラメータのオブジェクト属性名と同じであり、ネストされた POJO 属性パラメータはオブジェクトの階層関係に従って受け取ることができます。

配列パラメータ:複数のパラメータを受け取る配列型パラメータを定義します。通常形式のパラメータバインディングに適しています。

コレクションは通常のパラメーターを保存します。たとえば、@RequestParam はパラメーターの関係をバインドします。@RequestParam List<String> likes
Jsonデータを渡す

座標をインポートします:
<dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-databind</artifactId>
 <version>2.9.0</version>
</dependency>
リクエストパラメータを設定する

json データの自動変換のサポートを有効にする
@Configuration
@ComponentScan("com.itheima.controller")
@EnableWebMvc // 在SpringMVC中需要开启Json数据自动类型转换，与SpringBoot不同
public class SpringMvcConfig {
       
       
}
Json オブジェクトを渡す: POJO タイプのパラメーターを定義し、アノテーションを使用して@RequestBodyパラメーターを受け取ります。JSON データを処理するときに使用されます。！

Json 配列を渡す: json 配列データはコレクションのジェネリックプロパティと同じ名前を持ち、パラメーターを受け取るために List 型パラメーターを定義します。JSON データを扱うときに使用してください。！

日付型パラメータの受け渡し:
@DateTimeFormat (pattern = “yyyy - MM-dd”): 日付と時刻のデータ形式を設定します

注釈の説明:

@RequestParam :リクエストパラメータとプロセッサメソッドパラメータの間の関係をバインドします。フォーム間のデータ処理によく使用されます。

@EnableWebMvc : SpringMVCの複数の補助機能を有効にする

@RequestBody :リクエストのリクエスト本文に含まれるデータをリクエストパラメータに渡します。このアノテーションは、プロセッサメソッドごとに 1 回のみ使用できます。Json間のデータ処理によく使用されます。

応答：

応答ページ: "page.jsp" を返します。

応答データ:

テキストデータ: 「応答テキスト」を返します。

Json データ: **@ResponseBody** を使用して、応答をJson 形式に設定します。最下層は、型コンバーター HttpMessageConverter インターフェースを使用してさまざまな実装クラスに対応させ、変換を実行します。

4.1 リクエストマッピングパス

@Controller
@RequestMapping("/user")
public class UserController {
    
    
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
    
    
        System.out.println("user save ...");
        return "{'module':'user save'}";
    }
}

例証します:

名前: @RequestMapping

タイプ: メソッドアノテーションクラスアノテーション

場所: SpringMVC コントローラーのメソッド定義の上

機能: 現在のコントローラメソッドリクエストアクセスパスを設定します。設定されている場合、現在のコントローラメソッドリクエストアクセスパスプレフィックスをクラスに均一に設定します。

属性

値 (デフォルト): リクエストのアクセスパス、またはアクセスパスのプレフィックス

4.2 リクエスト方法

1.リクエストパラメータの取得

画像-20230530082533259

2.ポストリクエストパラメータ

画像-20230530082552044

4.3 リクエスト後の中国語文字化け処理

// AbstractAnnotationConfigDispatcherServletInitializer 是 Spring Framework 中的一个类，它用于配置和初始化基于注解的 Spring MVC 应用程序
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer{
    
    
    // 配字符编码过滤器
    protected Filter[] getServletFilters() {
    
    
        CharacterEncodingFilter filter = new CharacterEncodingFilter(); //添加过滤器
        filter.setEncoding("utf-8"); //指定过滤器字符集
        return new Filter[]{
    
    filter};
    }
}

例証します:

サーブレットリクエストと同様に、SpringMVC でフィルタを追加する必要があります。レスポンスリクエストにはリクエスト文字を含むフィルタを追加する必要があります。

詳細：

Web コンテナにフィルタを追加し、文字セットを指定する Spring-web パッケージには専用の文字フィルタが用意されています。

補充:

より詳しい参考：AbstractAnnotationConfigDispatcherServletInitializer_Yanの分析魔王ブログ - CSDNブログ

4.4 リクエストパラメータ

リクエストパラメーターは、サーバーに何をすべきかを指示するか、必要なデータを提供するために、クライアント (ブラウザー、モバイルアプリなど) からサーバーに送信されるデータです。

4.4.1 通常のパラメータ - 同じ名前

パラメータの受け渡しには URL アドレスが使用されます。アドレスパラメータ名は仮パラメータの変数名と同じです。仮パラメータを定義することでパラメータを受け取ることができます。

画像-20230530083541992

@RequestMapping("/commonParam")
@ResponseBody
public String commonParam(String name ,int age){
    
    
    System.out.println("普通参数传递 name ==> "+name);
    System.out.println("普通参数传递 age ==> "+age);
    return "{'module':'common param'}";
}

4.4.2 通常のパラメータ - 異なる名前

リクエストパラメータ名は正式なパラメータ変数名とは異なるため、 @RequestParam を使用してパラメータ関係をバインドします。

画像-20230530083618242

@RequestMapping("/commonParamDifferentName")
@ResponseBody
public String commonParamDifferentName(@RequestParam("name")String userName , int age){
    
    
    System.out.println("普通参数传递 userName ==> "+userName);
    System.out.println("普通参数传递 age ==> "+age);
    return "{'module':'common param different name'}";
}

詳細：

リクエストパラメータ名が正式なパラメータ変数名と異なる場合は、 @RequestParam を使用してパラメータ関係をバインドする必要があります。同じ場合は指定する必要はありません

補充:

名前: @RequestParam

タイプ: 仮パラメータアノテーション

位置: SpringMVC コントローラーメソッドの仮パラメータ定義の前

機能:リクエストパラメータとプロセッサメソッドパラメータ間の関係をバインドします。

パラメータ:

required: 必須パラメータかどうか

defaultValue: パラメータのデフォルト値

4.4.3POJOパラメータ（ポイント）

リクエストパラメータ名は仮パラメータオブジェクトのプロパティ名と同じで、POJO型パラメータを定義することでパラメータを受け取ることができます。通常形式のパラメータバインディングに適しています

画像-20230530083936860

@RequestMapping("/pojoParam")
@ResponseBody
public String pojoParam(User user){
    
    
    System.out.println("pojo参数传递 user ==> "+user);
    return "{'module':'pojo param'}";
}

例証します:

PoJoのパラメータ受け渡しを利用する場合、オブジェクト内の属性名に該当する値であれば、渡す値を受け取ることができます。

詳細：

PoJoパラメータを使用してパラメータを渡す場合、SpringMVCフレームワークはまずPoJoの種類に応じてコンストラクタメソッドを取得し、オブジェクトを作成してからパラメータのsetメソッドに従って渡します。

4.4.4 ネストされたPOJOパラメータ

リクエストパラメータ名は仮パラメータのオブジェクト属性名と同じであり、オブジェクトの階層関係に従ってネストされたPOJO属性パラメータを受け取ることができます。

画像-20230530084152345

@RequestMapping("/pojoContainPojoParam")
@ResponseBody
public String pojoContainPojoParam(User user){
    
    
    System.out.println("pojo嵌套pojo参数传递 user ==> "+user);
    return "{'module':'pojo contain pojo param'}";
}

4.4.5 配列パラメータ

リクエストパラメータ名が仮パラメータのオブジェクト属性名と同じで、リクエストパラメータが複数ある場合、配列型パラメータを定義することでパラメータを受け取ることができます。

画像-20230530084413567

@RequestMapping("/arrayParam")
@ResponseBody
public String arrayParam(String[] likes){
    
    
    System.out.println("数组参数传递 likes ==> "+ Arrays.toString(likes));
    return "{'module':'array param'}";
}

4.4.6 共通パラメータを保存するコレクション

リクエストパラメータ名が仮パラメータ収集オブジェクト名と同じで、リクエストパラメータが複数ある場合、 @RequestParam によってパラメータ関係がバインドされます。

画像-20230530084449696

@RequestMapping("/listParam")
@ResponseBody
public String listParam(@RequestParam List<String> likes){
    
    
    System.out.println("集合参数传递 likes ==> "+ likes);
    return "{'module':'list param'}";
}

知らせ：

コレクションを使用して通常のパラメータを保存する場合、SpringMVC フレームワークはコレクションを PoJo オブジェクトとして渡します。また、コレクションには構築メソッドがないため、エラーが報告されます。

この時点で、@RequestParamアノテーションを追加した後、SpringMVC フレームワークはリクエストに含まれるパラメーターをコレクションに直接入れます。

4.4.7 Json データを渡す基本的な使用例の手順

ステップ 1: json データ変換関連の座標を追加する

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.0</version>
</dependency>

ステップ 2: json データの送信を設定する (リクエスト本文に json データを追加)

画像-20230530090141109

ステップ 3: json データの自動変換のサポートを有効にする

@Configuration
@ComponentScan("com.itheima.controller")
@EnableWebMvc // 在SpringMVC中需要开启Json数据自动类型转换，与SpringBoot不同
public class SpringMvcConfig {
    
    
}

例証します:

@EnableWebMvc アノテーションは強力です。このアノテーションは複数の機能を統合しています。ここではその一部、つまりjson データの自動型変換のみを使用します。

補充:

名前: @EnableWebMvc

タイプ: 構成クラスのアノテーション

場所: SpringMVC 構成クラス定義の上

機能: SpringMVC の複数の補助機能を有効にする

ステップ 4: JSON データを受信するように設定する

@RequestMapping("/listParamForJson")
@ResponseBody
public String listParamForJson(@RequestBody List<String> likes){
    
    
    System.out.println("list common(json)参数传递 list ==> "+likes);
    return "{'module':'list common for json param'}";
}

例証します:

名前: @RequestBody

タイプ: 仮パラメータアノテーション

位置: SpringMVC コントローラーメソッドの仮パラメータ定義の前

機能:リクエストのリクエストボディに含まれるデータをリクエストパラメータに渡します。このアノテーションは、プロセッサメソッドごとに 1 回のみ使用できます。

4.4.8 Json オブジェクトを渡す (強調)

jsonデータは仮パラメータオブジェクトと同じプロパティ名を持ち、POJO型パラメータを定義することでパラメータを受け取ることができます。JSONデータを処理するときに使用されます

画像-20230530090604255

前提：

jsonデータ変換関連の座標を追加

json データの自動変換のサポートを有効にする

@RequestMapping("/pojoParamForJson")
@ResponseBody
public String pojoParamForJson(@RequestBody User user){
    
    
    System.out.println("pojo(json)参数传递 user ==> "+user);
    return "{'module':'pojo for json param'}";
}

4.4.9 Json配列を渡す

json配列データはコレクションのジェネリックプロパティと同名なので、パラメータを受け取るList型パラメータを定義します。

画像-20230530090734676

@RequestMapping("/listPojoParamForJson")
@ResponseBody
public String listPojoParamForJson(@RequestBody List<User> list){
    
    
    System.out.println("list pojo(json)参数传递 list ==> "+list);
    return "{'module':'list pojo for json param'}";
}

注: 次の前提条件が必要です。

jsonデータ変換関連の座標を追加

json データの自動変換のサポートを有効にする

4.5 日付型パラメータの転送

日付型データの形式はシステムごとに異なります。
- 2088-08-18
- 2088/08/18
- 2088/08/18
仮パラメータを受信する場合、日付形式に応じて異なる受信方法を設定する

@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,
                        @DateTimeFormat(pattern = "yyyy-MM-dd") Date date1,
                        @DateTimeFormat(pattern = "yyyy/MM/dd HH:mm:ss")Date date2){
    
    
    System.out.println("参数传递 date ==> "+date);
    System.out.println("参数传递 date(yyyy-MM-dd) ==> "+date1);
    System.out.println("参数传递 date(yyyy/MM/dd HH:mm:ss) ==> "+date2);
    return "{'module':'data param'}";
}

例証します:

聞く：

http://localhost/dataParam?date=2088/08/08&date1=2088-08-18&date2=2088/08/28 8:08:08

補充:

名前: @DateTimeFormat

タイプ: 仮パラメータアノテーション

位置: SpringMVC コントローラーメソッドパラメーターの前

機能:日付と時刻のデータ形式を設定します。

属性:

パターン: 日付と時刻の形式文字列

注: 型変換機能は構成クラスで有効にする必要があります

名前: @EnableWebMvc

機能: 型に応じて対応する型コンバーターを照合することは、このアノテーションの機能の 1 つです。

拡張機能: パラメーターはアノテーションを通じて渡され、内部作業は実際には Converter インターフェースを通じて実装されます。

コンバーターインターフェース
public interface Converter<S, T> {
       
       
    @Nullable
    T convert(S var1);
}
リクエストパラメータの年齢データ（文字列→整数）

jsonデータをオブジェクトへ（json→POJO）

日付形式変換（文字列→日付）
Convert にはデータ型を変換するための実装クラスが多数あります

4.6 応答

4.6.1 概要

応答は、リクエストに必要なデータまたは操作の実行結果を提供するためにサーバーからクライアントに返されるメッセージです。

応答カテゴリ:

応答ページ
応答データ
- テキストデータ
- jsonデータ

4.6.2 応答ページ（理解）

@RequestMapping("/toPage")
public String toPage(){
    
    
    return "page.jsp";
}

4.6.3 応答テキストデータ（理解）

@RequestMapping("/toText")
@ResponseBody
public String toText(){
    
    
    return "response text";
}

補充:

名前: @ResponseBody

タイプ: メソッドのアノテーション

場所: SpringMVC コントローラーのメソッド定義の上

機能: 現在のコントローラーの戻り値を応答本文として設定します。

知らせ：

@ResponseBody を使用してコンテンツに応答する場合は、以下を追加する必要があります

4.6.4 Jsonデータへの応答（Jsonへのオブジェクト）

@RequestMapping("/toJsonPOJO")
@ResponseBody
public User toJsonPOJO(){
    
    
    User user = new User();
    user.setName("赵云");
    user.setAge(41);
    return user;
}

補充:

型コンバーター HttpMessageConverter インターフェース

public interface HttpMessageConverter<T> {
       
       
   boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);
   boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);
   List<MediaType> getSupportedMediaTypes();
   T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
         throws IOException, HttpMessageNotReadableException;
   void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
         throws IOException, HttpMessageNotWritableException;
}

@ResponseBody アノテーションを使用してコンテンツに応答する場合、Converter インターフェースではなく、新しいインターフェースを通じて変換されますHttpMessageConverter接口。

4.6.5 Jsonデータへの応答（オブジェクトコレクションをJson配列に変換）

@RequestMapping("/toJsonList")
@ResponseBody
public List<User> toJsonList(){
    
    
    User user1 = new User();
    user1.setName("赵云");
    user1.setAge(41);
    User user2 = new User();
    user2.setName("master 赵云");
    user2.setAge(40);
    List<User> userList = new ArrayList<User>();
    userList.add(user1);
    userList.add(user2);
    return userList;
}

5.RESTスタイル

メモの要約:

概要: REST (Representational State Transfer) は、リソースのステータスとリソース間の対話に焦点を当てたソフトウェアアーキテクチャスタイルです。

HTTP リクエストアクションの設定 (動詞): @RequestMapping(value = “xxx”、method = RequestMethod.POST )

リクエストパラメータ（パス変数）を設定します： @RequestMapping( value = “/users/{id}” , method = xxxx)
RESTfulな迅速な開発:
@RestController: 現在のコントローラークラスを RESTful スタイルに設定します。これは、@Controller アノテーションと @ResponseBody アノテーションを組み合わせた関数と同等です。
@RestController
public class BookController {
         
         
}
@GetMapping @PostMapping @PutMapping @DeleteMapping: 現在のコントローラーメソッドのリクエストアクセスパスとリクエストアクションを設定します。
@GetMapping("/{id}")
public String getById(@PathVariable Integer id){
         
         }

5.1 概要

REST (Representational State Transfer) は、ネットワークアプリケーション用の分散システムを設計するために使用されるソフトウェアアーキテクチャスタイルです。これは主に、リソースのステータスとリソース間の対話に焦点を当てており、統合インターフェイスと HTTP プロトコルのさまざまなメソッドを使用して実現されます。

伝統的なスタイルのリソース説明フォーム

http://localhost/user/getById?id=1

http://localhost/user/saveUser
RESTスタイル記述フォーム

http://localhost/user/1

http://ローカルホスト/ユーザー

アドバンテージ：

リソースへのアクセス動作を非表示にするアドレスからはリソースに対してどのような操作が行われているかを知ることはできません。
書き方の簡略化

REST スタイルの概要

画像-20230530150231874

5.2 HTTPリクエストアクションの設定（動詞）

@RequestMapping(value = "/users", method = RequestMethod.POST)
@ResponseBody
public String save(@RequestBody User user){
    
    
    System.out.println("user save..." + user);
    return "{'module':'user save'}";
}

@RequestMapping(value = "/users" ,method = RequestMethod.PUT)
@ResponseBody
public String update(@RequestBody User user){
    
    
    System.out.println("user update..."+user);
    return "{'module':'user update'}";
}

補充:

名前: @RequestMapping

タイプ: メソッドのアノテーション

場所: SpringMVC コントローラーのメソッド定義の上

機能: 現在のコントローラーのメソッド要求アクセスパスを設定します。

属性

値 (デフォルト): リクエストのアクセスパス

メソッド: http リクエストアクション、標準アクション (GET/POST/PUT/DELETE)

5.3 リクエストパラメータ（パス変数）の設定

@RequestMapping(value = "/users/{id}" ,method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id){
    
    
    System.out.println("user delete..." + id);
    return "{'module':'user delete'}";
}

補充:

名称：@PathVariable

タイプ: 仮パラメータアノテーション

位置: SpringMVC コントローラーメソッドの仮パラメータ定義の前

機能: パスパラメーターとプロセッサメソッドの仮パラメーターの間の関係をバインドします。パスパラメーター名と仮パラメーター名の間に 1 対 1 の対応が必要です。

5.4RESTfulな迅速な開発

名前: @RestController

タイプ: クラスアノテーション
位置: SpringMVC に基づく RESTful 開発コントローラークラス定義の上
機能: 現在のコントローラークラスを RESTful スタイルに設定します。これは、 @Controller アノテーションと @ResponseBody アノテーションを組み合わせた関数と同等です。

例：

@RestController
public class BookController {
      
      
}

名前：@GetMapping @PostMapping @PutMapping @DeleteMapping

タイプ: メソッドのアノテーション
場所: SpringMVC に基づく RESTful 開発コントローラーメソッド定義の上
機能: 現在のコントローラーメソッドのリクエストアクセスパスとリクエストアクションを設定します。それぞれリクエストアクションに対応します。たとえば、@GetMapping は GET リクエストに対応します。

例：

@GetMapping("/{id}")
public String getById(@PathVariable Integer id){
      
      
    System.out.println("book getById..."+id);
    return "{'module':'book getById'}";
}

属性: 値 (デフォルト): リクエストのアクセスパス

5.5 RESTful ページに基づく基本的なケースとデータの対話

ステップ 0: 基本環境の構築

画像-20230530194836763

ステップ 1: SpringMVC コントローラーを作成し、 PostMan を介してインターフェース機能をテストする

例証します:

同じ基本用例-SpringMVC基础应用プロセスですが、ここでは示しません。

ステップ 2:静的リソースのアクセス許可を設定する

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    
    
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
    
    
        //当访问/pages/????时候，走/pages目录下的内容
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }
}

例証します:

Web リソースにアクセスする場合、ステップ 0 の ServletContainersInitConfig クラスは getServletMappings メソッドをインターセプト/およびパスとして設定しているため、webapp ディレクトリ内の静的リソースにアクセスすると、リクエストは SpringMVC によってインターセプトされます。
protected String[] getServletMappings() {
     
     
return new String[]{
     
     "/"};
}
この時点では、多くの処理メソッドがあり、新しいクラスを作成し、WebMvcConfigurationSupport を継承し、addResourceHandlers メソッドをオーバーライドしてリソースハンドラーを追加できます。リソースを処理するときは、リソースディレクトリ/xx/**へのアクセスされたパスの下のリソースにアクセスするだけです。/xx/

知らせ：

このリクエストが構成されている場合、この構成をロードするには SpringMVC をロードする必要があります

ステップ 3:リソース要求構成をロードする

//springmvc配置类，本质上还是一个spring配置类
@Configuration
@ComponentScan({
    
    "love.ljtxy.controller","love.ljtxy.config"})
@EnableWebMvc
public class SpringMvcConfig {
    
    

}

例証します:

この時点で、新しいスキャンクラスを追加します。

6.SSM連携（キー）

注の概要: このセクションが中心です。詳細については各セクションを確認してください。

6.1 概要

メモの要約:

意味: SSM フレームワークは、Spring、Spring MVC、および Mybatis フレームワークを統合したものであり、標準の MVC パターンです。標準の SSM フレームワークには、dao 層 (マッパー)、サービス層、コントローラー層、およびビュー層の 4 つの層があります。

永続層: dao 層 (マッパー) 層は主にデータ永続層の作業を担当し、データベースとの通信を担当するいくつかのタスクはここにカプセル化されています。

ビジネス層: サービス層サービス層は主に、ビジネスモジュールの論理アプリケーション設計を担当します。

プレゼンテーション層: コントローラー層 (ハンドラー層)。特定のビジネスモジュールプロセスの制御を担当します。

ビュー層: ビュー層は主にコントロール層と統合されており、主にフロントエンドJSP ページのプレゼンテーションを担当します。

関係相互作用図:

SSM フレームワークは、Spring、Spring MVC、mybatis フレームワークを統合したもので、標準的な MVC パターンです。標準の SSM フレームワークには、dao 層 (マッパー)、サービス層、コントローラー層、およびビュー層の 4 つの層があります。Spring を使用してビジネスオブジェクト管理を実装し、Spring MVC を使用してリクエストの転送とビュー管理を担当し、mybatis をデータオブジェクトの永続化エンジンとして使用します。

1) 永続層: dao 層 (マッパー) 層
機能: 主にデータ永続層の作業を実行し、データベースとの接続を担当するいくつかのタスクがここにカプセル化されます。

Dao 層は最初にインターフェイスを設計し、次に Spring 構成ファイルでインターフェイスの実装クラスを定義します。
その後、モジュール内でインターフェイスを呼び出してデータビジネスを処理できます。(インターフェースの実装クラスがどのクラスであるかは気にしなくなります)
データソースの構成とデータベース接続に関連するパラメーターは、Spring 構成ファイルで構成されます。

2) ビジネス層: サービス層
機能: サービス層は主にビジネスモジュールの論理アプリケーション設計を担当します。

最初にインターフェイスを設計し、次に実際のクラスを設計し、その実装の関連付けを Spring 構成ファイルで構成します。(ビジネスロジック層の実装では、独自に定義したDaoインターフェースを具体的に呼び出す必要があります。) このようにして、アプリケーション内でServiceインターフェースを呼び出して業務処理を行うことができます。
Daoを確立したら、サービス層を確立しますが、サービス層はDao層のインターフェースを呼び出すだけでなく、コントローラー層にインターフェースを提供する必要があるため、コントローラー層の下位に存在する必要があります。各モデルにはサービスインターフェイスがあり、各インターフェイスは独自のビジネス処理メソッドをカプセル化します。

3) プレゼンテーション層: コントローラー層 (ハンドラー層) の役割: 特定のビジネスモジュールプロセス
の制御を担当します。

設定は Spring の設定ファイルでも行われます。
サービス層が提供するインターフェースを呼び出してビジネスプロセスを制御します。
異なるビジネスプロセスには異なるコントローラーがあり、特定の開発では、プロセスを抽象化して要約し、再利用可能なサブユニットプロセスモジュールを設計できます。

4) ビュー層
機能: これは主に制御層と密接に統合されており、主にフロントエンド JSP ページのプレゼンテーションを担当します。

6.2 統合構成

メモの要約:

ステップ 1: 依存関係をインポートする

ステップ 2: 基本的なディレクトリ構造を作成する

ステップ 3: JdbcConfig クラスを作成する

データソースとしてDruidDataSourceを作成する

DataSourceTransactionManager をトランザクションマネージャーとして作成します

ステップ 4: MyBatisConfig クラスを作成する

SqlSessionFactoryインスタンスを作成するために SqlSessionFactoryBean を構成する

MyBatis のMapper インターフェイスを自動的にスキャンして登録するように MapperScannerConfigurer を構成します。

ステップ 5: ServletConfig クラスを作成する

Springコンテナの構成に使用されるSpringのルート構成クラスを取得します。

SpringMVCコンテナの構成に使用されるSpringMVC構成クラスを取得します。

DispatcherServletのマッピングパスを取得する

ステップ 6: SpringConfig クラスを作成する

指定されたパッケージの下のコンポーネントと Bean をスキャンします

jdbc.propertiesプロパティファイルをロードします。

JdbcConfig および MyBatisConfig 構成クラスをインポートする

オープントランザクション

ステップ 7: SpringMvcConfig クラスを作成する

コントローラーコンポーネントが含まれているパッケージをスキャンします

Spring MVC 機能を有効にする

詳細については、このセクションを参照してください

ステップ 1: 依存関係をインポートする

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.6</version>
</dependency>

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.15.0</version>
</dependency>

例証します:

これらは通常の SSM 統合の依存関係の一部です。そのうち、javax.servlet-api はサーブレットリクエストの相互作用の依存関係、spring-webmvc は制御層の置換の依存関係、mybatis と mybatis-spring は SpringMVC の統合 MyBatis の依存関係、druid と spring-jdbc は次のとおりです。 Spring はデータソース操作の依存関係を提供し、jackson-core は応答データと受信データの変換に使用されます。

ステップ 2: 基本的なディレクトリ構造を作成する

画像-20230531074500917

ステップ 3: JdbcConfig クラスを作成する

public class JdbcConfig {
    
    
    // 注入jdbc.driver配置项的值
    @Value("${jdbc.driver}")
    private String driver;
    // 注入jdbc.url配置项的值
    @Value("${jdbc.url}")
    private String url;
    // 注入jdbc.username配置项的值
    @Value("${jdbc.username}")
    private String username;
    // 注入jdbc.password配置项的值
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource() {
    
    
        // 创建DruidDataSource作为数据源
        DruidDataSource dataSource = new DruidDataSource();
        // 配置数据源的驱动类
        dataSource.setDriverClassName(driver);
        // 配置数据源的URL
        dataSource.setUrl(url);
        // 配置数据源的用户名
        dataSource.setUsername(username);
        // 配置数据源的密码
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
    
    
        // 创建DataSourceTransactionManager作为事务管理器
        DataSourceTransactionManager ds = new DataSourceTransactionManager();
        // 设置事务管理器使用的数据源
        ds.setDataSource(dataSource);
        return ds;
    }
}

例証します:

上記の注入操作により、設定ファイル内のデータベース接続に関連する属性値を対応するフィールドに注入できます。このようにして、データソースを使用する必要がある他のコンポーネントは依存関係注入を通じてデータソース Bean を取得できるため、操作とトランザクション管理のためのデータベース接続を取得できます。

ステップ 4: MyBatisConfig クラスを作成する

public class MyBatisConfig {
    
    

    /**
     * 配置SqlSessionFactoryBean，用于创建SqlSessionFactory实例
     * @param dataSource 数据源
     * @return SqlSessionFactoryBean实例
     */
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
    
    
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setTypeAliasesPackage("love.ljtxy.entity"); // 设置实体类的别名包路径
        return factoryBean;
    }

    /**
     * 配置MapperScannerConfigurer，用于自动扫描并注册MyBatis的Mapper接口
     * @return MapperScannerConfigurer实例
     */
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
    
    
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("love.ljtxy.mapper"); // 设置Mapper接口的包路径
        return msc;
    }
}

例証します:

この設定クラスを Spring 設定ファイルに導入すると、MyBatis の関連設定が完了し、アプリケーションがデータベース操作に MyBatis を簡単に使用できるようになります。

ステップ 5: ServletConfig クラスを作成する

public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    
    

    /**
     * 获取Spring的根配置类，用于配置Spring容器
     * @return 根配置类数组
     */
    protected Class<?>[] getRootConfigClasses() {
    
    
        return new Class[]{
    
    SpringConfig.class};
    }

    /**
     * 获取SpringMVC的配置类，用于配置SpringMVC容器
     * @return SpringMVC配置类数组
     */
    protected Class<?>[] getServletConfigClasses() {
    
    
        return new Class[]{
    
    SpringMvcConfig.class};
    }

    /**
     * 获取DispatcherServlet的映射路径
     * @return 映射路径数组
     */
    protected String[] getServletMappings() {
    
    
        return new String[]{
    
    "/"};
    }
}

例証します:

Web コンテナの起動時に Servlet 構成クラスを自動的にロードすることで、Spring および SpringMVC コンテナの初期化と構成が完了し、アプリケーションが Web リクエストを処理して対応する処理を実行できるようになります。

補充:

SpringMVCコンテナはSpringコンテナにアクセスできます。Spring コンテナは SpringMVC コンテナにアクセスできません。ここでは Spring MVC の IOC コンテナの親コンテナとして Spring の IOC コンテナが設定されているため

ステップ 6: SpringConfig クラスを作成する

@Configuration
@ComponentScan("love.ljtxy.service") // 扫描指定包下的组件和Bean
@PropertySource("classpath:jdbc.properties") // 加载jdbc.properties属性文件
@Import({
    
    JdbcConfig.class, MyBatisConfig.class}) // 导入JdbcConfig和MyBatisConfig配置类
@EnableTransactionManagement //开启事务
public class SpringConfig {
    
    
}

知らせ：

@EnableTransactionManagementSpring がトランザクションを使用する場合、アノテーションを使用してトランザクションを有効にする必要があります

例証します:

これらの構成を通じて、Spring コンテナは、指定されたパッケージパスでコンポーネントと Bean をロードして管理でき、必要に応じて他の構成クラスをインポートして、柔軟な構成とアセンブリを実現できます。

補充:

@Importアノテーションは Spring Framework のメタアノテーションであり、複数の構成クラスの機能を組み合わせるために、他の構成クラスを現在の構成クラスにインポートするために使用されます。アノテーションを介して@Import、他の構成クラスを Bean 定義として Spring コンテナにロードできます。

アノテーションを使用すると@PropertySource、プロパティファイル内の属性値を簡単に管理およびロードすることができるため、構成クラス内の属性値がより柔軟で構成可能になります。

ステップ 7: SpringMvcConfig クラスを作成する

@Configuration
@ComponentScan("love.ljtxy.controller") // 扫描控制器组件所在的包
@EnableWebMvc // 启用Spring MVC功能
public class SpringMvcConfig {
    
    
}

例証します:

上記の構成により、Spring MVC は指定されたパッケージ内のコントローラークラスを自動的にスキャンし、アノテーションベースのリクエストマッピング、パラメーター解析、ビュー解析などの機能を提供し、Web アプリケーションの開発をより便利かつ効率的にすることができます。

6.3 機能モジュールの開発

メモの要約:

ステップ 1: エンティティクラスを作成する

ステップ 2: Dao レイヤーインターフェイスを作成する

@Insert、、、、注釈は、 SQL ステートメントとメソッド@Updateを関連付けます。@Delete@Select

アノテーション内の SQL ステートメントは、プレースホルダーを使用して#{propertyName}オブジェクトの属性値を参照し、動的パラメーターバインディングを実装します。

ステップ 3: サービスインターフェイスの書き込み

一般に、サービスインターフェイス層を作成するときは、名前と意味を知っておく必要があります。

一般的に、インターフェイスを作成するときは、このサービスの操作結果を返す必要があります。

ステップ 4: サービスインターフェイス実装層を作成する

一般に、Service 実装クラスを作成した後、Service 層のメソッドをテストできます。

ステップ 5: サービス層をテストする

@RunWithアノテーションはテストランナー (テストランナー) を指定するために使用され、テストの実行時に特定のランナーを使用してテストを実行するように JUnit に指示します。

@ContextConfigurationアノテーションは、Spring コンテナの構成情報を指定し、テストを実行する前にどの構成をロードするかを JUnit に指示するために使用されます。

プレゼンテーション層の作成

ステップ 1: エンティティクラスを作成する

@Date
public class Book {
    
    
    private Integer id;
    private String type;
    private String name;
    private String description;
}

ステップ 2: Dao レイヤーインターフェイスを作成する

public interface BookDao {
    
    

    // 插入书籍
    @Insert("insert into tbl_book (type, name, description) values (#{type}, #{name}, #{description})")
    public void save(Book book);

    // 更新书籍
    @Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")
    public void update(Book book);

    // 删除书籍
    @Delete("delete from tbl_book where id = #{id}")
    public void delete(Integer id);

    // 根据ID查询书籍
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);

    // 获取所有书籍
    @Select("select * from tbl_book")
    public List<Book> getAll();
}

例証します:

これらのメソッドは、MyBatis のアノテーションメソッドを使用して、対応する SQL ステートメントを指定し、@Insert、@Update、@Deleteおよびアノテーションを通じて@SelectSQL ステートメントをメソッドに関連付けます。アノテーション内の SQL ステートメントは、プレースホルダーを使用して#{propertyName}オブジェクトの属性値を参照し、動的パラメーターバインディングを実装します。

これらのメソッドを使用すると、書籍の挿入、書籍情報の更新、書籍の削除、単一の書籍のクエリ、すべての書籍のリストの取得などのデータベース操作を簡単に実行できます。

ステップ 3: サービスインターフェイスの書き込み

@Transactional
public interface BookService {
    
    

    /**
     * 保存
     *
     * @param book
     * @return
     */
    public boolean saveBookInfo(Book book);

    /**
     * 修改
     *
     * @param book
     * @return
     */
    public boolean updateBookInfo(Book book);

    /**
     * 按id删除
     *
     * @param id
     * @return
     */
    public boolean deleteBookInfo(Integer id);

    /**
     * 按id查询
     *
     * @param id
     * @return
     */
    public Book getBookInfo(Integer id);

    /**
     * 查询全部
     *
     * @return
     */
    public List<Book> getBookAllInfo();
}

知らせ：

  		当Spring使用了事务时，需要使用注解`@Transactional`来启用事务。若还需要对@Transactional做其余的配置，可以根据需求来进行决定

例証します:

一般に、サービスインターフェイス層を作成するときは、名前と意味を知っておく必要があります。

一般的に、インターフェイスを作成するときは、このサービスの操作結果を返す必要があります。

ステップ 4: サービスインターフェイス実装層を作成する

@Service
public class BookServiceImpl implements BookService {
    
    
    @Autowired
    private BookDao bookDao;

    public boolean save(Book book) {
    
    
        bookDao.save(book);
        return true;
    }

    public boolean update(Book book) {
    
    
        bookDao.update(book);
        return true;
    }

    public boolean delete(Integer id) {
    
    
        bookDao.delete(id);
        return true;
    }

    public Book getById(Integer id) {
    
    
        return bookDao.getById(id);
    }

    public List<Book> getAll() {
    
    
        return bookDao.getAll();
    }
}

例証します:

一般に、サービス実装クラスを作成した後、サービス層のメソッドをテストできます。

ステップ 5: サービス層をテストする

@RunWith(SpringJUnit4ClassRunner.class) // 注解指定了运行测试的类为SpringJUnit4ClassRunner，这样就能够在测试过程中启动Spring容器。
@ContextConfiguration(classes = SpringConfig.class) //注解指定了使用哪个配置类来加载Spring容器。
public class BookServiceTest {
    
    

    @Autowired
    private BookService bookService;

    @Test
    public void testGetById(){
    
    
        // 测试根据ID获取图书信息的方法
        Book book = bookService.getById(1);
        System.out.println(book);
    }

    @Test
    public void testGetAll(){
    
    
        // 测试获取所有图书信息的方法
        List<Book> all = bookService.getAll();
        System.out.println(all);
    }
}

補充:

@RunWithアノテーションはテストランナー (テストランナー) を指定するために使用され、テストの実行時に特定のランナーを使用してテストを実行するように JUnit に指示します。

@ContextConfigurationアノテーションは、Spring コンテナの構成情報を指定し、テストを実行する前にどの構成をロードするかを JUnit に指示するために使用されます。

ステップ 6: プレゼンテーション層を作成する

@RestController
@RequestMapping("/books")
public class BookController {
    
    

    @Autowired
    private BookService bookService;

    @PostMapping
    public boolean save(@RequestBody Book book) {
    
    
        return bookService.save(book);
    }

    @PutMapping
    public boolean update(@RequestBody Book book) {
    
    
        return bookService.update(book);
    }

    @DeleteMapping("/{id}")
    public boolean delete(@PathVariable Integer id) {
    
    
        return bookService.delete(id);
    }

    @GetMapping("/{id}")
    public Book getById(@PathVariable Integer id) {
    
    
        return bookService.getById(id);
    }

    @GetMapping
    public List<Book> getAll() {
    
    
        return bookService.getAll();
    }
}

6.4 プレゼンテーション層のデータのカプセル化

メモの要約:

概要: コントローラー (Controller) とビュー (View) 間のデータ転送と対話。

ステップ 1: 統合データの戻り結果クラスを設定する

フロントエンドはデータ形式を受け取ります - 結果モデルクラスを作成し、データをデータ属性にカプセル化します

フロントエンド受信データ形式 - 特別なメッセージをメッセージ (msg) 属性にカプセル化する

フロントエンドはデータ形式を受け取り、操作結果をコード属性にカプセル化します。
ステップ 2: 統合データの戻りステータスコードを設定する
//状态码
public class Code {
       
       
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
}
ステップ 3: プレゼンテーション層クラスを最適化する

各コントローラーメソッドの戻り値を統一する

プレゼンテーション層 (プレゼンテーション層) では、データのカプセル化とは、コントローラー (Controller) とビュー (View) の間のデータ転送と対話を容易にするために、要求データと応答データを適切にカプセル化および変換することを指します。

ステップ 1: 統合データの戻り結果クラスを設定する

@Date
public class Result {
    
    
    //描述统一格式中的数据
    private Object data;
    //描述统一格式中的编码，用于区分操作，可以简化配置0或1表示成功失败
    private Integer code;
    //描述统一格式中的消息，可选属性
    private String msg;

    public Result() {
    
    
    }

    public Result(Integer code,Object data) {
    
    
        this.data = data;
        this.code = code;
    }

    public Result(Integer code, Object data, String msg) {
    
    
        this.data = data;
        this.code = code;
        this.msg = msg;
    }
}

例証します:

Result クラスのフィールドは固定ではなく、必要に応じて増減できますが、運用を容易にするためにいくつかの構築方法が用意されています。

フロントエンドはデータ形式を受け取ります - 結果モデルクラスを作成し、データをデータ属性にカプセル化します

フロントエンド受信データ形式 - 特別なメッセージをメッセージ (msg) 属性にカプセル化する

フロントエンドはデータ形式を受け取り、操作結果をコード属性にカプセル化します。

ステップ 2: 統合データの戻りステータスコードを設定する

//状态码
public class Code {
    
    
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;

    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
}

ステップ 3: プレゼンテーション層クラスを最適化する

//统一每一个控制器方法返回值
@RestController
@RequestMapping("/books")
public class BookController {
    
    

    @Autowired
    private BookService bookService;

    @PostMapping
    public Result save(@RequestBody Book book) {
    
    
        boolean flag = bookService.save(book);
        return new Result(flag ? Code.SAVE_OK:Code.SAVE_ERR,flag);
    }

    @PutMapping
    public Result update(@RequestBody Book book) {
    
    
        boolean flag = bookService.update(book);
        return new Result(flag ? Code.UPDATE_OK:Code.UPDATE_ERR,flag);
    }

    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) {
    
    
        boolean flag = bookService.delete(id);
        return new Result(flag ? Code.DELETE_OK:Code.DELETE_ERR,flag);
    }

    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
    
    
        Book book = bookService.getById(id);
        Integer code = book != null ? Code.GET_OK : Code.GET_ERR;
        String msg = book != null ? "" : "数据查询失败，请重试！";
        return new Result(code,book,msg);
    }

    @GetMapping
    public Result getAll() {
    
    
        List<Book> bookList = bookService.getAll();
        Integer code = bookList != null ? Code.GET_OK : Code.GET_ERR;
        String msg = bookList != null ? "" : "数据查询失败，请重试！";
        return new Result(code,bookList,msg);
    }
}

例証します:

一般に、ビジネスロジックの処理はプレゼンテーション層に実装でき、そこで演算結果の返却処理を設定できます。

6.5例外ハンドラ

メモの要約:

概要: 例外ハンドラーは、アプリケーションで発生する例外をキャッチして処理するためのメカニズムです。

統合プロセス:

ステップ 1: 新しい例外処理クラスを作成する

@RestControllerAdviceグローバル例外処理のアノテーションです。アプリケーション全体で例外をキャッチして処理し、処理結果を統一された形式でクライアントに返すことができます。

@ExceptionHandler(Exception.class)アノテーションは、例外処理メソッドを識別し、キャッチして処理する例外のタイプを指定するために使用されます。ここでは、Exception型の例外をキャッチします。

注釈の説明:

@RestControllerAdvice: は、グローバル例外処理のアノテーションです。REST スタイルで開発されたコントローラークラスを強化する

@ExceptionHandler:指定された例外の処理計画を設定します。この機能はコントローラーメソッドと同等です。例外が発生すると、元のコントローラーの実行が終了し、現在のメソッドの実行に転送されます。

例外ハンドラーは、アプリケーションで発生する例外をキャッチして処理するためのメカニズムです。Java Web アプリケーションでは、通常、例外ハンドラーを使用して、コントローラー (Controller) で発生した例外をキャプチャし、必要に応じて適切な処理と応答を実行します。

異常現象の一般的な場所と一般的なトリガーは次のとおりです。

フレームワーク内で例外がスローされました: 不正な使用が原因です
データ層によってスローされた例外: 外部サーバーの障害が原因 (例: サーバーアクセスタイムアウト)
ビジネス層によってスローされる例外: ビジネスロジックの記述エラーによって発生します (例: ビジネス記述操作の走査により、インデックス例外が発生するなど)。
プレゼンテーション層によってスローされる例外: データ収集、検証、その他のルールによって発生します (例: データ型の不一致によって発生する例外)。
ツールクラスによってスローされる例外: 十分に堅牢ではないツールクラスの書き方が緩いことが原因で発生します (たとえば、解放する必要がある接続が長期間解放されていないなど)。

ステップ 1: 新しい例外処理クラスを作成する

コントローラーパッケージの下に、新しい ProjectExceptionAdvice クラスを作成します。

@RestControllerAdvice
public class ProjectExceptionAdvice {
    
    

    /**
     * 全局异常处理方法
     * @param ex 异常对象
     * @return 自定义的结果对象
     */
    @ExceptionHandler(Exception.class)
    public Result doException(Exception ex){
    
    
        return new Result(666,null);
    }
}

例証します:

@RestControllerAdviceグローバル例外処理のアノテーションです。アプリケーション全体で例外をキャッチして処理し、処理結果を統一された形式でクライアントに返すことができます。

@ExceptionHandler(Exception.class)アノテーションは、例外処理メソッドを識別し、キャッチして処理する例外のタイプを指定するために使用されます。ここでは、Exceptionタイプの例外をキャッチします。

補充:

名前: @RestControllerAdvice
タイプ: クラスアノテーション

位置: REST スタイルで開発されたコントローラー拡張クラス定義の上

機能: Rest スタイルで開発されたコントローラークラスを強化します。
例：
@RestControllerAdvice
public class ProjectExceptionAdvice {
         
         }
例証します:

このアノテーションには @ResponseBody アノテーションと @Component アノテーションが付属しており、対応する関数が付属します。
名前: @ExceptionHandler
タイプ: メソッドのアノテーション

場所: 例外処理専用のコントローラーメソッドの上

機能:指定された例外の処理計画を設定します。この機能はコントローラメソッドと同等です。例外が発生すると、元のコントローラの実行が終了し、現在のメソッドに転送されて実行されます。
例：
@RestControllerAdvice
public class ProjectExceptionAdvice {
         
         
    @ExceptionHandler(Exception.class)
    public Result doException(Exception ex){
         
         
        return new Result(666,null);
    }
このタイプのメソッドでは、処理されるさまざまな例外に応じて、対応する例外を処理する複数のメソッドを作成できます。

6.6 プロジェクト例外処理

メモの要約:

概要: プロジェクト例外処理とは、開発プロセス中のさまざまな異常な状況を捕捉、処理し、フィードバックを提供するメカニズムを指します。

解決：

BusinessException:不規則なユーザー操作が原因で発生します

SystemException: 予期されるコード操作例外

その他の例外 (例外):予期しない例外

ステップ

ステップ 1: プロジェクトのシステムレベルの例外をカスタマイズする

RuntimeException ランタイム例外クラスを継承する

SystemException(Integer code, String message)、SystemException(Integer code, String message, Throwable Cause) など、業務に応じた構築メソッドを実装してください。

ステップ 2: プロジェクトのビジネスレベルの例外をカスタマイズする

RuntimeException ランタイム例外クラスを継承する

BusinessException(Integer code, String message)、BusinessException(Integer code, String message, Throwable Cause) など、ビジネスに応じて構築メソッドを実装します。

ステップ 3: 例外コーディングのカスタマイズ (連続追加)

ステップ 4: カスタム例外をトリガーする

ステップ 5: 例外をインターセプトして処理する (重要なポイント)

プロジェクトの例外処理計画を定義し、@ExceptionHandlerこのアノテーションを使用して例外を処理します。

プロジェクト例外処理とは、開発プロセス中のさまざまな異常な状況を捕捉、処理し、フィードバックを提供するメカニズムを指します。例外処理の目的は、システムの安定性と信頼性を確保して、優れたユーザーエクスペリエンスを提供することです。

プロジェクト例外処理計画

ビジネス例外
- 対応するメッセージをユーザーに送信して、標準化された操作を思い出させる
システム例外
- ユーザーを安心させるために固定メッセージを送信する
- 保守を思い出させるために、運用および保守担当者に特定のメッセージを送信します。
- ロギング
その他の例外（例外）
- ユーザーを安心させるために固定メッセージを送信する
- 特定のメッセージをプログラマに送信して、メンテナンスを思い出させます（予想される範囲内）
- ロギング

ステップ 1: プロジェクトのシステムレベルの例外をカスタマイズする

//自定义异常处理器，用于封装异常信息，对异常进行分类
public class SystemException extends RuntimeException{
    
    
    private Integer code;

    public Integer getCode() {
    
    
        return code;
    }

    public void setCode(Integer code) {
    
    
        this.code = code;
    }

    public SystemException(Integer code, String message) {
    
    
        super(message);
        this.code = code;
    }

    // Throwable为异常报错的对象
    public SystemException(Integer code, String message, Throwable cause) {
    
    
        super(message, cause);
        this.code = code;
    }
}

例証します:

システムレベルの例外は、プログラマのエラーによって引き起こされるエラーによって引き起こされる可能性があります。

メンバー変数の場合code、コードの Set メソッドを実装するだけで済みます。後で使用する場合は、このオブジェクトのコードを取得するだけで済みます。

ステップ 2: プロジェクトのビジネスレベルの例外をカスタマイズする

//自定义异常处理器，用于封装异常信息，对异常进行分类
public class BusinessException extends RuntimeException{
    
    
    private Integer code;

    public Integer getCode() {
    
    
        return code;
    }

    public void setCode(Integer code) {
    
    
        this.code = code;
    }

    public BusinessException(Integer code, String message) {
    
    
        super(message);
        this.code = code;
    }

    // Throwable为异常报错的对象
    public BusinessException(Integer code, String message, Throwable cause) {
    
    
        super(message, cause);
        this.code = code;
    }
}

例証します:

システムレベルの例外は、オペレーティングシステムの問題またはデータベース接続の失敗によって発生する可能性があります。

ステップ 3: 例外コーディングのカスタマイズ (連続追加)

public static final Integer SYSTEM_ERR = 50001;
public static final Integer SYSTEM_TIMEOUT_ERR = 50002;
public static final Integer SYSTEM_UNKNOW_ERR = 59999;

public static final Integer BUSINESS_ERR = 60002;

ステップ 4: カスタム例外をトリガーする

画像-20230531135942393

例証します:

シミュレーションにより、例外の分類とスローのみ

ステップ 5: 例外をインターセプトして処理する

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {
    
    
    // 用于处理用户操作不当而导致的异常
    @ExceptionHandler(BusinessException.class)
    public Result doBusinessException(BusinessException ex){
    
    
        return new Result(ex.getCode(),null,ex.getMessage());
    }

    //@ExceptionHandler用于设置当前处理器类对应的异常类型
    @ExceptionHandler(SystemException.class)
    public Result doSystemException(SystemException ex){
    
    
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex对象发送给开发人员
        return new Result(ex.getCode(),null,ex.getMessage());
    }

    //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
    @ExceptionHandler(Exception.class)
    public Result doOtherException(Exception ex){
    
    
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex对象发送给开发人员
        return new Result(Code.SYSTEM_UNKNOW_ERR,null,"系统繁忙，请稍后再试！");
    }
}

ステップ 6: 例外ハンドラーの効果の比較

画像-20230531140236636

例証します:

ソフトウェアシステムは、リソースアクセスが正常または異常の場合に正確なプロンプトを作成できることがわかります。

7. インターセプター

メモの要約:

概要：

定義: インターセプターは、Web 開発で一般的に使用されるテクノロジーであり、リクエストの処理中にリクエストをインターセプトして処理するために使用されます。

機能: 指定されたメソッドの呼び出しの前後にプリセットコードを実行し、元のメソッドの実行を防ぎます。

インターセプターとフィルターの違い:

持ち物が違う

ブロックの内容が違います

……

基本的な使用例:

ステップ 1: インターセプター Bean を宣言し、HandlerInterceptorインターフェースを実装します (注: Bean をスキャンしてロードします)。

ステップ 2: 構成クラスを定義する

方法 1: 構成クラスを定義し、WebMvcConfigurationSupport を継承し、 addInterceptor メソッドを実装します (注: スキャンして構成をロードします)

方法 2:標準インターフェイス webMvcConfigurerを実装して開発を簡素化する (注: より煩雑です)

補充:

静的リソースマッピングの構成: addResourceHandlers、addResourceLocations

動的リソースのインターセプターを構成する: addInterceptors、addPathPatterns

インターセプタパラメータ:

前処理:リクエストをインターセプトする前に行われるいくつかの処理

後処理:リクエストのインターセプト後に行われる一部の処理

インターセプターのワークフロー:

インターセプター: 単一インターセプター処理

インターセプトチェーン: 複数のインターセプター処理

7.1 概要

7.1.1 定義

インターセプターは、Web 開発で一般的に使用されるテクノロジーであり、リクエスト処理中にリクエストをインターセプトして処理するために使用されます。インターセプターは、リクエストがコントローラーに入る前または後に、ロギング、認可検証、リクエストパラメーターの前処理などのカスタムロジックを実行できます。

画像-20230603105043433

7.1.2 機能

指定されたメソッド呼び出しの前後にプリセットコードを実行し、元のメソッドの実行を防ぎます。機能は次のとおりです。

権限の検証: インターセプターは、ユーザーがログインしているかどうか、操作を実行する権限があるかどうかなどを確認するなど、ユーザーの権限を検証するために使用できます。権限の検証が失敗した場合は、リクエストを中断するか、対応する処理を実行できます。
ロギング: インターセプタを使用して、リクエストされた URL、リクエストパラメータ、リクエスト時間などを含むリクエストのログ情報を記録し、その後の統計分析、エラーのトラブルシューティング、その他の作業を容易にすることができます。
リクエストパラメーターの前処理: インターセプターは、パラメーターの正確性とセキュリティを確保するために、パラメーターの検証、フォーマット、暗号化、その他の操作など、リクエストがコントローラーに入る前にリクエストパラメーターを前処理できます。
例外処理: インターセプターを使用して、コントローラーでスローされた例外をキャプチャし、統合エラーメッセージページを返す、例外ログを記録するなどの統合例外処理を実行できます。
リクエストの応答処理: インターセプターは、リクエストの処理が完了した後、応答ヘッダー情報の設定、応答内容の変更など、応答を処理できます。
キャッシュ制御: インターセプターを使用して、応答のキャッシュ時間の設定、キャッシュの有効性の検証など、応答のキャッシュ戦略を制御できます。

通常、実際の開発では、トークンのアクセス許可にはインターセプターが使用されることが多いです。

7.1.3 インターセプターとフィルターの違い

インターセプターとフィルターはどちらも、Web 開発でリクエストを処理するために使用されるコンポーネントですが、次のような違いがあります。

アプリケーションのスコープが異なります:インターセプターは Spring MVC フレームワーク用であり、メソッドベースのインターセプトであり、コントローラー内のリクエスト処理メソッドのみをインターセプトできます。フィルタはサーブレット仕様によって定義されており、URL パターンのインターセプトに基づいており、静的リソースやサーブレットリクエストを含むすべてのリクエストをインターセプトできます。
実行順序は異なります。インターセプターはプロセッサ (コントローラー) の前または後に実行され、リクエストを前処理または後処理できます。フィルタは、リクエストがサーブレットコンテナに入る前または後に実行され、リクエストをフィルタリング、変更、またはパッケージ化できます。
さまざまな機能: インターセプターは主に、アクセス許可の検証、ロギング、例外処理などのリクエストのビジネスロジックを処理するために使用されます。フィルタは主に、文字エンコード変換、リクエストのパッケージ化、リクエストパラメータの処理など、リクエストのフィルタリングと変更に使用されます。
設定方法が異なります。インターセプタの設定はSpring MVCの設定ファイルで実行され、インターセプタの順序とパスの一致ルールは手動で設定する必要があります。フィルタの構成はweb.xmlファイルで実行され、フィルタのインターセプトパスと順序は URL パターンを構成することによって指定されます。
異なる所有権:フィルターはサーブレットテクノロジーに属し、インターセプターは SpringMVC テクノロジーに属します
異なるインターセプトコンテンツ: フィルターはすべてのアクセスを強化し、インターセプターはspringMVC アクセスのみを強化します

画像-20230603105732011

一般に、インターセプタはより柔軟で洗練されており、ビジネスロジックの処理に適しており、フィルタはより汎用的で、リクエストのフィルタリングと変更に適しています。これを使用する場合、特定のニーズに応じてインターセプターまたはフィルターを選択し、対応する機能を実装できます。

7.2 基本的なユースケースインターセプターの実装

ステップ 1: インターセプターを定義する

インターセプタBeanを宣言し、HandlerInterceptorインタフェースを実装する

知らせ：

Bean をスキャンしてロードし、@Component注釈を忘れずに追加してください

@Component //拦截器
//定义拦截器类，实现HandlerInterceptor接口
//注意当前类必须受Spring容器控制
public class ProjectInterceptor implements HandlerInterceptor {
    
    
    @Override
    //原始方法调用前执行的内容
    //返回值类型可以拦截控制的执行，true放行，false终止
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
        System.out.println("preHandle..."+contentType);
        return true;
    }

    @Override
    //原始方法调用后执行的内容
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    
    
        System.out.println("postHandle...");
    }

    @Override
    //原始方法调用完成后执行的内容
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    
    
        System.out.println("afterCompletion...");
    }
}

例証します:

一般に、インターセプタはプレゼンテーション層の処理に使用されるため、コントローラパッケージの下に配置されます。

ステップ 2: 構成クラスを定義する

方法 1: 構成クラスを定義し、継承しWebMvcConfigurationSupport、 addInterceptor メソッドを実装します (注: 構成をロードするにはスキャンします)

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    
    
    @Autowired
    private ProjectInterceptor projectInterceptor;

    /**
     * 配置静态资源映射
     */
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
    
    
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
    }

    /**
     * 配置动态资源的拦截器
     */
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
    
    
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
    }
}

例証します:

以上の構成により、静的リソースへのアクセスと指定パスへのインターセプタ設定が実現されます。

インターセプタを追加し、インターセプトされたアクセスパスを設定します。変数パラメータを通じて複数のパスを設定できます。

方法 2: 標準インターフェイスを実装してwebMvcConfigurer開発を簡素化する (注: より煩雑になります)

@Configuration
@ComponentScan({
    
    "com.itheima.controller"})
@EnableWebMvc
//实现WebMvcConfigurer接口可以简化开发，但具有一定的侵入性
public class SpringMvcConfig implements WebMvcConfigurer {
    
    
    @Autowired
    private ProjectInterceptor projectInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
    
    
        //配置多拦截器
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
    }
}

例証します:

WebMvcConfigurer インターフェイスを実装すると、WebMvcConfigurationSupport 構成クラスを継承してリソースインターセプトを実装する効果も得られます。

知らせ：

WebMvcConfigurer インターフェイスを実装してインターセプタを実装することは、非常に煩雑です。

7.3 インターセプタパラメータ

7.3.1 前処理

前処理とは、リクエストをインターセプトする前に行われる処理です。

@Component
//定义拦截器类，实现HandlerInterceptor接口
//注意当前类必须受Spring容器控制
public class ProjectInterceptor implements HandlerInterceptor {
    
    
    @Override
    //原始方法调用前执行的内容
    //返回值类型可以拦截控制的执行，true放行，false终止
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
        String contentType = request.getHeader("Content-Type");
        HandlerMethod hm = (HandlerMethod)handler;
        System.out.println("preHandle..."+contentType);
        return true;
    }
}

例証します:

リクエストヘッダー内の情報はリクエストから取得でき、簡単に操作できるように取り出すことができます。

補充:

パラメータ:

リクエスト: リクエストオブジェクト

応答: 応答オブジェクト

handler: 呼び出されるハンドラーオブジェクトは本質的にメソッドオブジェクトであり、メソッドオブジェクトをリフレクションテクノロジで再パッケージ化します。

戻り値

戻り値は false であり、インターセプトされたプロセッサは実行されません。

7.3.2 後処理

public void postHandle(HttpServletRequest request,
                       HttpservletResponse response,
                       object handler,
                       ModelAndview modelAndView) throws Exception {
    
    
    System.out.println( "postHandle..." );
}

補充:

modelAndView: プロセッサの実行が完了して結果が返された場合、対応するデータとページ情報を読み取って調整できます。

7.4 インターセプターのワークフロー (重要なポイント)

7.4.1基本的なプロセス

画像-20230531144547904

例証します:

インターセプターがない場合、リクエストはプレゼンテーション層を介してインターセプトを行いません。

インターセプターがある場合、リクエストは、元のメソッド呼び出し前に実行されたコンテンツ、元のメソッド呼び出し後に実行されたコンテンツ、および元のメソッド呼び出しの完了後に実行されたコンテンツをインターセプトします。

傍受処理後の応答が True の場合は解放を意味し、応答が False の場合はリクエストの内容が傍受されたことを意味します

7.4.2 インターセプトチェーン

画像-20230531154459978

例証します:

3 番目のインターセプタが False を返した場合、最初と 2 番目のインターセプトのポストプロセッサのみが実行されます。

2 番目のインターセプターが False を返した場合、最初にインターセプトされたポストプロセッサーのみが実行されます。

最初のインターセプターが False を返した場合、インターセプトされたポストプロセッサーはどれも実行されません。

8. 実行プロセス

メモの要約:

このセクションはより複雑です。学習のために外部ノートを参照できます: springmvc ノート (シリコンバレー)_入力方法がわからないブログ 314-CSDN ブログ

8.1 SpringMVC の共通コンポーネント

DispatcherServlet : DispatcherServlet は、 Spring MVC フレームワークのフロントエンドコントローラーです。すべての HTTP リクエストを受信し、そのリクエストを対応するプロセッサに配布して処理する役割を果たします。DispatcherServlet は Spring MVC フレームワークのコアコンポーネントであり、リクエスト処理プロセスのすべての側面をディスパッチします。
HandlerMapping : HandlerMapping は、リクエストの URL パスに従って特定のプロセッサ (コントローラー) にマッピングし、リクエストに対応するプロセッサを決定するプロセッサマッパーの実装です。HandlerMapping は、URL パスに基づく、注釈に基づくなど、さまざまなマッピング戦略に従って構成できます。
ハンドラー: ハンドラーはプロセッサーを意味し、コントローラーとも呼ばれます。これはビジネスロジックの特定の実行者であり、リクエストを処理し、処理結果を返す責任を負います。Spring MVC では、Handler はメソッドを通じてリクエストを処理する通常の POJO クラスにすることができます。
HandlerAdapter : HandlerAdapter は、プロセッサメソッドを実行し、リクエストを正しく処理できるようにリクエストパラメータを調整するために使用されるプロセッサアダプタです。HandlerAdapter は、プロセッサの種類と処理メソッドのパラメータの種類に基づいて、プロセッサメソッドを実行する適切なアダプタを選択します。
ViewResolver : ViewResolver は、処理結果を最終ビューにレンダリングするビューリゾルバーです。プロセッサから返された論理ビュー名に基づいて、ThymeleafView、InternalResourceView、RedirectView などの特定のビューオブジェクトを解析します。ViewResolver は、モデルデータをビューに渡し、最終的にユーザーに表示する役割を果たします。
View : View はviewを意味し、最終的な処理結果をユーザーに表示する役割を果たします。ビューには、HTML ページ、JSON データ、XML ドキュメントなどが含まれます。Spring MVC では、通常、ビューはテンプレートエンジンを通じてレンダリングされ、モデルデータがテンプレートに入力されて最終ビューが生成されます。

画像-20230602102312053

これらのコンポーネントは連携して、リクエストの処理とレスポンスの生成を完了します。DispatcherServlet はリクエストを受信するフロントエンドコントローラーとして機能し、HandlerMapping はリクエストに対応するプロセッサを決定し、HandlerAdapter はプロセッサメソッドを実行し、ViewResolver はビューを解析し、View は最終的なレンダリングを担当します。この処理フローはSpring MVCフレームワークの中核となる仕組みであり、これらのコンポーネントを構成して組み合わせることで、さまざまなリクエスト処理やビュー描画ロジックを柔軟に実装できます。

8.2DispatcherServletの初期化処理

DispatcherServlet は本質的にはサーブレットであるため、当然サーブレットのライフサイクルに従います。したがって、巨視的に見ると、これはスケジューリングのためのサーブレットのライフサイクルです。

画像-20230602094211246

例証します:

1. GenericServlet クラスは Service インターフェイスを実装し、Init メソッドをオーバーライドします。

画像-20230602112204665

例証します:

Servler はインターフェイスであるため、GenericServlet クラスは Service インターフェイスを実装し、Init メソッドをオーバーライドします。

HttpServlet クラスは GenericServlet と継承関係があるため、GenericServlet クラスの 2 つの init メソッドは HttpServlet クラスに残ります。

2. HttpServlet クラスは、GenericServlet クラスの init メソッドをオーバーライドしません。

画像-20230602112719365

例証します:

HttpServlet クラスは GenericServlet クラスを継承しますが、GenericServlet クラスの init メソッドをオーバーライドしません。

3. HttpServletBean クラスは、GenericServlet クラスの init メソッドをオーバーライドし、initServletBean メソッドを呼び出します。

画像-20230602112804189

例証します:

HttpServletBean クラスは、GenericServlet クラスの init メソッドをオーバーライドします。

画像-20230602113308369

例証します:

init メソッドでは、HttpServletBean クラスが重要なメソッドである initServletBean メソッドを呼び出して、ServletBean を初期化します。

4. FrameworkServler クラスは、HttpServletBean クラスの initServletBean メソッドをオーバーライドします。

画像-20230602113741285

例証します:

FrameworkServler クラスは、initServletBean メソッドで SpringMVC IOC コンテナ初期化メソッド this.initWebApplicationContext(); を呼び出します。

5. FrameworkServler クラスで、initWebApplicationContext メソッドが呼び出されます。

画像-20230602114621108

例証します:

このメソッドを初めて実行するときは、作成された WebApplicationContext が空であるため、 this.createWebApplicationContext(rootContext); このメソッドが呼び出され、WebApplicationContext が作成されます。

5.1. FrameworkServler クラスで、createWebApplicationContext メソッドを呼び出して WebApplicationContext を作成します。

画像-20230602114841908

画像-20230602191454335

例証します:

FrameworkServler クラスの wac.setParent(parent); メソッドを呼び出して、Spring IOC コンテナを Spring MVC の親コンテナとして設定します

5.2 FrameworkServler クラスで、this.onRefresh(wac) および this.getServletContext().setAttribute(attrName, wac); メソッドを呼び出します。

画像-20230602192539137

例証します:

this.onRefresh(wac) メソッドを呼び出すと、サブクラス DispatcherServlet クラスの OnRefresh メソッドが実行され、ストラテジーが初期化されます。

this.getServletContext().setAttribute(attrName, wac); メソッドを呼び出して、アプリケーションドメインで webApplicationContext オブジェクトを共有します

6. DispatcherServler クラスでは、FrameworkServler クラスの onRefresh メソッドがオーバーライドされます。

画像-20230602193437015

画像-20230602193510752

例証します:

内部で初期化されたさまざまなコンテナは、DispatcherServlet の初期化時に実際にロードされます。

8.3DispatcherServletサービスプロセス

1. GenericServlet クラスは Service インターフェイスを実装し、この Service メソッドを継承します。

画像-20230602194934369

例証します:

GenericServlet クラスでは、Service インターフェイスのサービスメソッドはオーバーライドされず、直接継承されます。

2. HttpServlet クラスでは、GenericServlet クラスの Service メソッドが書き換えられます。

画像-20230602195300896

例証します:

HttpServlet クラスの Service メソッドで、ServletRequest オブジェクトと ServletResponse オブジェクトをサブクラス HttpServletRequest と HttpServletRequest、および HttpServletResponse オブジェクトに変換します。

3. HttpServletクラスのserviceメソッドでリクエストを振り分けます。

画像-20230602195750111

例証します:

異なる機能に応じて異なるメソッドが実行されます

4. HttpServletBean では、HttpServlet クラス内のサービスメソッドおよび do で始まるメソッドは書き換えられません。

画像-20230602195928441

例証します:

HttpServletクラスでは、HttpServletクラス内のserviceメソッドとdoで始まるメソッドは書き換えられません。

5. FramesServlet クラスでは、このクラスの this.processRequest メソッドがとにかく実行されます。

画像-20230602200359274

例証します:

HttpServiceBean クラスはサービスメソッドを実装していないため、super.service(request,response) メソッドは、HttpServiceBean クラスではなく、HttpServlet のサービスメソッドを実行します。

画像-20230602200529945

例証します:

重要なメソッド doService は、FramesServlet クラスの processRequest メソッドに実装されています。

画像-20230602200606022

例証します:

FramesServlet クラスの doService メソッドでは、doService が抽象クラスメソッドであることがわかります。したがって、このメソッドを FramesServlet クラスのサブクラスに実装する方法を確認する必要があります。

6. DispatcherServlet クラスでは、最終的に this.doDispatch(request, response); メソッドが実行されてサービスが処理されます。

画像-20230602201202436

8.4DisPatcheServletがリクエストを処理するコンポーネントを呼び出すプロセス

1. DispatcherServlet クラスで、mappedHandler = this.getHandler(processedRequest); を通じて処理実行チェーンに値を割り当てます。

画像-20230603100700034

例証します:

行 472ではHandlerExecutionChain mappedHandler = null;、mappedHandler は実行チェーンと呼ばれ、コントローラーメソッド (プロセッサ)、インターセプターコレクション、インターセプターインデックスが含まれます。

画像-20230603101506491

例証します:

HandlerAdapter はコントローラーのメソッドを呼び出すために使用されます

画像-20230603101946004

例証します:

ha.handle メソッドは、リクエストメソッドのパラメータタイプ、リクエストヘッダー、リクエスト Cookie を処理するためにアダプタで使用されます。

画像-20230603102443189

例証します:

DispatcherServler クラスの doDispatch メソッドには、ビューをレンダリングするメソッドがないことがわかります。実際、 this.processDispatchResult メソッドは後続のステップを処理するために使用されるメソッドであり、このメソッドではビューが引き続き処理されます。

8.5 実行プロセス（理解）

追加予定……

ガソリンスタンドの知識（ポイント）

1. @RequestBody と @RequestParam の違い

違い
- @RequestParam は、URL アドレスパラメーターとフォームパラメーターを受け取るために使用されます [application/x-www-form-urlencoded]
- @RequestBody は json データを受信するために使用されます [application/json]
応用
- その後の開発では主にjson形式のデータを送信するようになり、@RequestBodyが広く使われるようになりました。
- 非 JSON 形式でデータを送信する場合は、@RequestParam を使用してリクエストパラメーターを受け取ります。

2. Idea で、クラス関係継承図を開きます。

ショートカットキー: Ctrl+H

画像-20230530141253472

3. @RequestBody @RequestParam @PathVariable の違い

違い
- @RequestParam は、URL アドレスパラメーターまたはフォームパラメーターを受け取るために使用されます。
- @RequestBody は json データを受信するために使用されます
- @PathVariable はパスパラメータを受け取るために使用され、{パラメータ名} を使用してパスパラメータを記述します
応用
- その後の開発では、複数のリクエストパラメータを送信する場合はjson形式が主流となり、@RequestBodyが広く使われるようになりました。
- 非 JSON 形式でデータを送信する場合は、@RequestParam を使用してリクエストパラメーターを受け取ります。
- 開発には RESTful を使用します。パラメーターの数が 1 など少ない場合、@PathVariable を使用してリクエストパス変数を受け取ることができます。これは通常、id 値を渡すために使用されます。

4. @RestControllerAdvice と @ControllerAdvice の違い

@RestControllerAdviceとは@ControllerAdviceSpring MVC のグローバル例外処理とグローバルデータバインディングに使用されるアノテーションであり、それらの違いは次のとおりです。

@RestControllerAdvice@ControllerAdviceとを組み合わせたアノテーションで@ResponseBody、グローバル例外処理とグローバルデータバインディングのコントローラーエンハンサーを表し、結果を JSON 形式でクライアントに返します。
@ControllerAdvice@Controllerは、グローバル例外処理およびグローバルデータバインディング用のコントローラーエンハンサーであり、またはの@RestController注釈が付けられたすべてのコントローラークラスに適用できます。
アノテーションを使用するクラスは、@RestControllerAdviceメソッドにおよびアノテーションを使用して@ExceptionHandler、グローバル例外処理、データバインディング、および前処理を実装できます。@InitBinder@ModelAttribute
アノテーションを使用するクラスは、@ControllerAdviceメソッドにおよびアノテーションを使用して@ExceptionHandler、グローバル例外処理、データバインディング、および前処理を実装できます。ただし、返された結果は、アノテーションまたはその他の方法を使用して JSON 形式に変換する必要があります。@InitBinder@ModelAttribute@ResponseBody

要約すると、主な違いは返される結果の形式です。@RestControllerAdviceアノテーション付きクラスによって返される結果は JSON 形式でクライアントに直接返されますが、@ControllerAdviceアノテーション付きクラスは@ResponseBodyアノテーションまたは他のメソッドを使用して結果を JSON 形式に変換してクライアントに返す必要があります。

5.SpringMVC は ant スタイルのパスをサポートします

? : 任意の 1 文字を表します

*: 0 個以上の任意の文字を示します

**: ディレクトリの 1 つ以上の階層を示します。

注: を使用する場合、// xxx メソッドのみを使用できます。

6.Model、Map、ModelMap、ModelAndViewの関係

画像-20230601084245953

7.AbstractAnnotationConfigDispatcherServletInitializer と AbstractDispatcherServletInitializer

AbstractAnnotationConfigDispatcherServletInitializerおよびは、AbstractDispatcherServletInitializerDispatcherServlet の設定と初期化に使用される Spring MVC の抽象クラスです。

AbstractAnnotationConfigDispatcherServletInitializer：
- AbstractAnnotationConfigDispatcherServletInitializerから継承された抽象クラスですAbstractDispatcherServletInitializer。
- このクラスは、Java 構成に基づいて DispatcherServlet を構成および初期化するために使用されます。
- このクラスを継承し、その抽象メソッドを実装することで、RootConfig および ServletConfig 関連のクラスや、サーブレットのマッピングパスなどを設定できます。
- これは、AnnotationConfigWebApplicationContext構成クラスをロードし、それを DispatcherServlet に関連付けるために使用されます。
AbstractDispatcherServletInitializer：
- AbstractDispatcherServletInitializer抽象クラスであり、WebApplicationInitializerインターフェースの実装クラスです。
- このクラスは、従来の XML 構成に基づいて DispatcherServlet を構成および初期化するために使用されます。
- DispatcherServlet の作成と登録、サーブレットのマッピングパスの設定などに使用できます。
- このクラスを継承し、抽象メソッドを実装することで、RootConfig と ServletConfig の関連する XML 設定ファイルのパスを設定できます。

概要: AbstractAnnotationConfigDispatcherServletInitializerDispatcherServlet の抽象クラスは Java 構成に基づいて構成および初期化されますAbstractDispatcherServletInitializerが DispatcherServlet の抽象クラスは従来の XML 構成に基づいて構成および初期化されます。これらは DispatcherServlet を構成および初期化するためのさまざまな方法を提供し、開発者が好みやプロジェクトのニーズに応じて適切な方法を選択できるようにします。

8.@RequestHeaderアノテーション（強調）

@RequestHeaderアノテーションは、リクエストヘッダーの値をメソッドパラメーターにバインドするために使用されます。これを使用して、特定のリクエストヘッダーの値を取得することも、すべてのリクエストヘッダーの値を取得することもできます。このアノテーションは、メソッドパラメーター、メソッド、およびクラスレベルのハンドラーメソッドに適用できます。

特定のリクエストヘッダーの値を取得する

@GetMapping("/example")
public void exampleMethod(@RequestHeader("User-Agent") String userAgent) {
    
    
    // 处理方法逻辑
}

すべてのリクエストヘッダーの値を取得します

@GetMapping("/init2")
public void init2(@RequestHeader Map<String, String> headerMap) {
    
    
    
    // 使用Map接收所有的请求头
    System.out.println(headerMap);
    // js中使用header名为addressList,使用map接收后需要使用addresslist
    System.out.println(headerMap.get("addresslist"));  
    
}

9. @CookieValue アノテーション（強調）

@CookieValueアノテーションは、Cookie の値をメソッドのパラメータにバインドするために使用されます。特定の Cookie の値を取得することも、すべての Cookie の値を取得することもできます。このアノテーションは、メソッドパラメーター、メソッド、およびクラスレベルのハンドラーメソッドに適用できます。

特定のリクエストヘッダーの値を取得する

@GetMapping("/example")
public void exampleMethod(@CookieValue("sessionId") String sessionId) {
    
    
    // 处理方法逻辑
}

すべてのリクエストヘッダーの値を取得します

@GetMapping("/example")
public void exampleMethod(@CookieValue Map<String, String> cookies) {
    
    
    // 处理方法逻辑
    for (Map.Entry<String, String> entry : cookies.entrySet()) {
    
    
        String cookieName = entry.getKey();
        String cookieValue = entry.getValue();
        // 处理每个Cookie的逻辑
    }
}

10.HttpServletコンテナがWebクライアントのリクエスト処理に応答する

1) Web クライアントは、HTTP リクエストをサーブレットコンテナに送信します。

2) サーブレットコンテナは Web クライアントの Http リクエストを解析します。

3) サーブレットコンテナは HttpRequest オブジェクトを作成し、このオブジェクトに Http リクエスト情報をカプセル化します。

4) サーブレットコンテナは HttpResponse オブジェクトを作成します。

5) Servlet コンテナは HttpServlet のサービスメソッドを呼び出しますが、このメソッドではリクエストの Method に基づいて doGet を実行するか doPost を実行するかを決定し、HttpRequest オブジェクトと HttpResponse オブジェクトがパラメータとして HttpServlet オブジェクトに渡されます。サービス方法。

6) HttpServlet は、HttpRequest の関連メソッドを呼び出して、HTTP 要求情報を取得します。

7) HttpServlet は、HttpResponse の関連メソッドを呼び出して応答データを生成します。

8) サーブレットコンテナは、HttpServlet の応答結果を Web クライアントに渡します。

研究メモ: ダークホース プログラマー SpringMVC

記事ディレクトリ

1。概要

1.1 意味

1.2MVC設計パターン

1.3SpringMVCの機能

2. 基本的なユースケース - SpringMVC 基本アプリケーション

3. プロセス原理

3.1 概要

3.2 SpringMVC と Spring の Bean ロード制御

3.3ServletContainersInitConfig.クラス

3.4SpringConfig.クラス

3.5SpringMvcConfig.クラス

4. リクエストとレスポンス

4.1 リクエストマッピングパス

4.2 リクエスト方法

4.3 リクエスト後の中国語文字化け処理

4.4 リクエストパラメータ

4.4.1 通常のパラメータ - 同じ名前

4.4.2 通常のパラメータ - 異なる名前

4.4.3POJOパラメータ（ポイント）

4.4.4 ネストされたPOJOパラメータ

4.4.5 配列パラメータ

4.4.6 共通パラメータを保存するコレクション

4.4.7 Json データを渡す基本的な使用例の手順

4.4.8 Json オブジェクトを渡す (強調)

4.4.9 Json配列を渡す

4.5 日付型パラメータの転送

4.6 応答

4.6.1 概要

4.6.2 応答ページ（理解）

4.6.3 応答テキストデータ（理解）

4.6.4 Jsonデータへの応答（Jsonへのオブジェクト）

4.6.5 Jsonデータへの応答（オブジェクトコレクションをJson配列に変換）

5.RESTスタイル

5.1 概要

5.2 HTTPリクエストアクションの設定（動詞）

5.3 リクエストパラメータ（パス変数）の設定

5.4RESTfulな迅速な開発

5.5 RESTful ページに基づく基本的なケースとデータの対話

6.SSM連携（キー）

6.1 概要

6.2 統合構成

ステップ 1: 依存関係をインポートする

ステップ 2: 基本的なディレクトリ構造を作成する

ステップ 3: JdbcConfig クラスを作成する

ステップ 4: MyBatisConfig クラスを作成する

ステップ 5: ServletConfig クラスを作成する

ステップ 6: SpringConfig クラスを作成する

ステップ 7: SpringMvcConfig クラスを作成する

6.3 機能モジュールの開発

ステップ 1: エンティティ クラスを作成する

ステップ 2: Dao レイヤー インターフェイスを作成する

ステップ 3: サービス インターフェイスの書き込み

ステップ 4: サービス インターフェイス実装層を作成する

ステップ 5: サービス層をテストする

ステップ 6: プレゼンテーション層を作成する

6.4 プレゼンテーション層のデータのカプセル化

ステップ 1: 統合データの戻り結果クラスを設定する

ステップ 2: 統合データの戻りステータス コードを設定する

ステップ 3: プレゼンテーション層クラスを最適化する

6.5例外ハンドラ

ステップ 1: 新しい例外処理クラスを作成する

6.6 プロジェクト例外処理

ステップ 1: プロジェクトのシステムレベルの例外をカスタマイズする

ステップ 2: プロジェクトのビジネスレベルの例外をカスタマイズする

ステップ 3: 例外コーディングのカスタマイズ (連続追加)

ステップ 4: カスタム例外をトリガーする

ステップ 5: 例外をインターセプトして処理する

7. インターセプター

7.1 概要

7.1.1 定義

7.1.2 機能

7.1.3 インターセプターとフィルターの違い

7.2 基本的なユースケースインターセプターの実装

ステップ 1: インターセプターを定義する

ステップ 2: 構成クラスを定義する

7.3 インターセプタパラメータ

7.3.1 前処理

7.3.2 後処理

研究メモ: ダークホースプログラマー SpringMVC

ステップ 1: エンティティクラスを作成する

ステップ 2: Dao レイヤーインターフェイスを作成する

ステップ 3: サービスインターフェイスの書き込み

ステップ 4: サービスインターフェイス実装層を作成する

ステップ 2: 統合データの戻りステータスコードを設定する