この記事では、Spring の入門から習得までを学習します。

1. Springフレームワークの概要

1. 春の紹介

Spring は、最も人気のあるエンタープライズ レベルの Java アプリケーション開発フレームワークであり、世界中の何百万もの開発者が、パフォーマンスが高く、テストが容易で、再利用可能なコードを作成するために使用されています。

Spring Framework は、もともと Rod Johnson によって書かれ、2003 年 6 月に Apache 2.0 ライセンスの下で最初にリリースされたオープンソース Java プラットフォームです。

Spring は軽量のフレームワークであり、その基本バージョンのサイズはわずか約 2 MB です

Spring フレームワークのコア機能は、任意の Java アプリケーションの開発に使用できますが、Java EE プラットフォーム上で Web アプリケーションを構築するには拡張機能が必要です。Spring Framework の目標は、POJO ベースのプログラミング モデルを有効にすることで、J2EE 開発を容易にし、適切なプログラミングの実践を促進することです。

2. Spring 3 層アーキテクチャ

3. スプリングの利点

4. Spring の技術的利点

• **非侵入型:** Spring に基づいて開発されたアプリケーションのオブジェクトは Spring の API に依存しない可能性があります。

•**制御の反転:**IOC——制御の反転。Spring がオブジェクトを作成する権利を指します。Spring を使用する前は、オブジェクトを新しいコードで自分で作成していました。そしてSpringを使用した後。オブジェクトの作成は Spring フレームワークに与えられます。

•**依存関係の注入: **DI——依存関係の注入は、依存オブジェクトを設定するために setXX メソッドを手動で呼び出す必要がなく、構成を通じて割り当てられることを意味します。

•**アスペクト指向プログラミング:**アスペクト指向プログラミング—AOP

•**コンテナ:**Springはアプリケーションオブジェクトのライフサイクルを含み、管理するためコンテナです。

• **コンポーネント化: **Spring は、単純なコンポーネント構成の組み合わせを複雑なアプリケーションに実装します。これらのオブジェクトは、XML および Java アノテーションを使用して Spring で組み合わせることができます。

•**ワンストップ:**IOC と AOP に基づいて、さまざまなエンタープライズ アプリケーション用のオープンソース フレームワークと優れたサードパーティ ライブラリを統合できます (実際、Spring 自体もプレゼンテーション層用の SpringMVC とプレゼンテーション層用の Spring JDBC も提供しています)。永続化レイヤー)

5. Spring の主要な概念

依存関係の注入 (DI):

Spring で最も認識されているテクニックは、制御の反転の依存性注入 (DI) パターンです。制御の反転 (IoC) はさまざまな方法で表現できる一般的な概念であり、依存関係の注入は制御の反転の具体的な一例にすぎません。

複雑な Java アプリケーションを作成する場合、アプリケーション クラスは他の Java クラスからできる限り独立して、これらのクラスの再利用可能性を高める必要があります。単体テストの場合は、他のクラスから独立してテストできます。依存関係の注入 (またはワイヤリングと呼ばれることもあります) は、これらのクラスを結合し、同時に独立した状態に保つのに役立ちます。

アスペクト指向プログラミング (AOP):

Spring Framework の重要なコンポーネントは、アスペクト指向プログラミング (AOP) フレームワークです。プログラム内の複数のポイントにまたがる機能は横断的関心事として知られており、概念的にはアプリケーションのビジネス ロジックから独立しています。いくつか例を挙げると、ロギング、宣言的トランザクション、セキュリティ、キャッシュなどの側面に関するさまざまな一般的な良い例があります。

OOP のモジュール性の主要な単位はクラスであり、AOP のモジュール性の主要な単位はアスペクトです。AOP は、横断的な懸念事項を、影響を受けるオブジェクトから分離するのに役立ちます。一方、依存関係注入は、アプリケーション オブジェクトを相互に分離するのに役立ちます。

2. 春のアーキテクチャ

1.コアコンテナ

1. spring-core モジュールは、 IoC や依存関係注入機能など、フレームワークの基本的な構成要素を提供します。
2. spring-beans モジュールは、コード化されたシングルトンの必要性を排除し、実際のコード化されたロジックから構成と依存関係を分離するファクトリ パターンの微妙な実装である BeanFactory を提供します。
3. コンテキスト モジュールは、コア モジュールと Bean モジュールに基づいて構築されます。コンテキスト モジュールは、Bean モジュールを継承し、国際化 (例: リソース バンドルの使用)、イベント伝播、リソースの読み込み、コンテキストの透過的な作成 (例: サーブレット コンテナ経由) などを追加します。機能。
4. spring-expression モジュールは、実行時にオブジェクト グラフをクエリおよび操作するための強力な式言語を提供します。これは、JSP2.1 仕様で定義されている統一式言語の拡張であり、属性値の設定と取得、属性の割り当て、メソッドの呼び出し、配列コレクションとインデックスの内容へのアクセス、論理算術演算、名前付き変数、およびアクセスをサポートしています。 Spring IoC コンテナから名前でオブジェクトを取得し、リストの投影、選択、集約もサポートします。

2. データアクセス - 統合

• JDBC モジュール: 面倒な JDBC コーディングとデータベース ベンダー固有のエラー コードの解析を排除する JDBC 抽象化レイヤーを提供します。

• ORM モジュール: JPA、JDO、Hibernate などの一般的なオブジェクト リレーショナル マッピング API との統合を提供します。このモジュールを通じて、これらの ORM フレームワークを、前述のトランザクション管理などの Spring の他の機能と統合できます。

• OXM モジュール: JAXB、Castor、XML Beans、JiBX、XStream などの OXM 実装のサポートを提供します。

• JMS モジュール: メッセージを生成および消費するための関数が含まれています。Spring 4.1 以降、spring-messaging モジュールが統合されています。

トランザクション モジュール: 特別なインターフェイス クラスとすべての POJO を実装するためのプログラムおよび宣言型トランザクション管理をサポートします。

3. Webアプリケーションサービス

• Web モジュール: マルチパート (マルチパート) ファイルのアップロード機能、サーブレット リスナーを使用した IoC コンテナの初期化など、基本的な Web 指向の機能と Web 指向のアプリケーション コンテキストを提供します。これには、HTTP クライアントと Spring Remoting の Web 関連部分も含まれます。

• Web-MVC モジュール: Web アプリケーションに Model View Control (MVC) および REST Web サービスの実装を提供します。Spring の MVC フレームワークは、ドメイン モデル コードを Web フォームから完全に分離でき、Spring フレームワークの他のすべての機能と統合できます。

• **Web-Socket モジュール:** は、WebSocket ベースのサポートを提供し、Web アプリケーションのクライアントとサーバー間の 2 つの通信方法を提供します。

• **Web-Portlet モジュール:** ポートレット環境の MVC 実装を提供し、spring-webmvc モジュールの機能を反映します。

4. その他のモジュール

• AOP モジュール: アスペクト指向 (アスペクト) プログラミング実装を提供します。メソッド インターセプタとエントリ ポイントを定義してコードを明確に分離できるため、関数を実装するコードが完全に分離されます。ソースレベルのメタデータを使用すると、.Net プロパティと同様の方法で動作情報をコードに組み込むことができます。

• Aspects モジュール: 強力で成熟したアスペクト指向プログラミング (AOP) フレームワークである AspectJ との統合を提供します。

•インストルメンテーション モジュール: クラス インストルメンテーションのサポートと、特定のアプリケーション サーバーでのクラス ローダーの実装を提供します。

•**メッセージング モジュール:** アプリケーションで使用する WebSocket サブプロトコルとして STOMP のサポートを提供します。また、WebSocket クライアントからの STOMP メッセージをルーティングおよび処理するための注釈付きプログラミング モデルもサポートしています。

•**テストモジュール:** JUnit または TestNG フレームワークを使用した Spring コンポーネントのテストをサポートします。

3. Spring プロジェクトをビルドする

1. アイデア構築の手順

2. Spring 依存関係を導入する

<!-- spring核心包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.13</version>
        </dependency>

<!-- junt单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>

3. スプリングコンテナをテストする

リソースディレクトリに spring.xml 設定ファイルを作成します。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- User类的对象就交给Spring管理了 -->
    <bean id="user" class="com.huawei.SpringDemo2023.User" />

</beans>

テスト用に text/java ディレクトリにテスト クラスを作成します。

//单元测试注解，代表可以直接运行该方法测试，需要依赖Junit类库
    @Test
    public void test1(){
    
    

        /**
         * 测试从Spring容器中取得指定的实例
         * 1.加载Spring配置文件
         * 2.取出Bean容器中的实例
         * 3.调用类中的方法
         */
        //1.加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        //2.取出Bean容器中的实例
        User user = (User)context.getBean("user");
        //3.调用方法
        user.say();

    }

4. Spring-IOC コンテナ

1. IOCコンテナとは何ですか?

はじめに:

Spring コンテナは Spring フレームワークの中心です。コンテナーはオブジェクトを作成し、それらを接続し、構成し、作成から破棄までのライフサイクル全体を管理します。Spring コンテナーは、依存関係注入 (DI) を使用して、アプリケーションを構成するコンポーネントを管理します。これらのオブジェクトは Spring Bean と呼ばれます

技術的特徴:

IOC コンテナは、オブジェクトを作成できる依存関係注入機能を備えたコンテナであり、アプリケーション内のオブジェクトのインスタンス化、検索、構成と、オブジェクト間の依存関係の確立を担当します。通常、新しいインスタンスはプログラマによって制御され、「制御の反転」とは、新しいインスタンスの作業がプログラマではなく Spring コンテナによって行われることを意味します。BeanFactory は、Spring の IOC コンテナの実際の代表です。

2. Spring が提供する 2 つの IOC コンテナ

知らせ：

ApplicationContext コンテナには BeanFactory コンテナのすべての機能が含まれているため、一般に BeanFactory の使用は推奨されません。BeanFactory は、データ量と速度が重要なモバイル デバイスやアプレット ベースのアプリケーションなどの軽量アプリケーションでも引き続き使用できます。

1.BeanFactroyコンテナ

概要：

これは最も単純なコンテナであり、その主な機能は依存関係注入 (DI) のサポートを提供することです。このコンテナ インターフェイスは org.springframework.beans.factory.BeanFactory で定義されます。

Spring には、BeanFactory インターフェースの実装が多数あります。その中で、最もよく使用されるのは XmlBeanFactory クラスです。コンテナーは XML ファイルから構成メタデータを読み取り、これらのメタデータから構成済みのシステムまたはアプリケーションを生成します。

コンテナ設定をロードする方法の例:

/**
         * BeanFactory创建实例步骤
         * 1.创建工厂类，加载Bean.xml配置文件
         * 2.通过工厂的方法获取指定对象实例
         * 3.实例对象调用方法
         */
        //1.创建工厂类，加载Bean.xml配置文件
        XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("Bean.xml"));
        //2.通过工厂的方法获取指定对象实例
        User user = (User) factory.getBean("user");
        //3.实例对象调用方法
        user.say();

2.Spring ApplicationContext 容器

概要：

アプリケーション コンテキストは、 BeanFactory のサブインターフェイスであり、Spring コンテキストとも呼ばれます。

Application Context は Spring の上位レベルのコンテナーです。BeanFactory と同様に、構成ファイルで定義された Bean をロードし、すべての Bean をまとめて、要求があったときに Bean を割り当てることができます。ApplicationContext には BeanFactory の機能がすべて含まれており、一般的には BeanFactory よりも ApplicationContext の方が優れています。

Applicationcontext コンテナは、ioc コンテナをロードするための 3 つの実装を提供します。

• ClassPathXmlApplicationContext : このコンテナは、定義された Bean を XML ファイルからロードします。ここでは、XML ファイルのフルパスを指定する必要はありません。コンテナは CLASSPATH から Bean 設定ファイルを検索するため、CLASSPATH 環境変数を正しく設定するだけです。

• FileSystemXmlApplicationContext : このコンテナは、定義された Bean を XML ファイルからロードします。ここでは、コンストラクター XML ファイルへのフルパスを指定する必要があります。

• WebXmlApplicationContext : このコンテナは、Web アプリケーションのスコープ内の XML ファイルで定義された Bean をロードします。

1. ClassPathXmlApplicationContext がコンテナをロードします

//1. 加载配置文件，初始化容器
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        //2. 通过同期的getBean方法获取容器中创建的对象
        User user = (User) context.getBean("user");
        System.out.println("2. 从容器中获取对象");
        user.say();

2. FileSystemXmlApplicationContext ロードコンテナ

/**
*第一步生成工厂对象。加载完指定路径下 bean 配置文件后，利用框架提供的 FileSystemXmlApplicationContext *API 去生成工厂 bean
*/
ApplicationContext context = new FileSystemXmlApplicationContext
            ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml");
//第二步利用第一步生成的上下文中的 getBean() 方法得到所需要的 bean。 这个方法通过配置文件中的 bean ID 来返回一个真正的对象。
      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
//来调用任何方法
      obj.getMessage();

3. Beanの範囲

Spring で Bean を定義するときは、Bean のスコープのオプションを宣言する必要があります。

Spring フレームワークは、シングルトン、プロトタイプ、リクエスト、セッション、グローバル セッションの 5 つのスコープをサポートします。

Spring設定ファイルの設定方法

<bean id="user" scope="prototype" class="com.huawei.SpringDemo2023.User" />

4. Bean のライフサイクル

Beanのライフサイクルは、Beanの定義 - Beanの初期化 - Beanの使用 - Beanの破棄 と表すことができます。

1. Bean の遅延ロード

Lazy-init=true が設定されている場合、Bean は遅延ロード モードにあり、Bean が使用されるときに初期化されることを意味します。

2 つの値があります: true、false (デフォルト) true は、Bean が遅延ロードされ、コンテナーが初期化されるときに初期化されないことを意味します。

<bean id="user" lazy-init="false" class="com.huawei.SpringDemo2023.User" />

2. Bean の init-method メソッド (初期化コールバック) と destroy-method メソッド (破壊コールバック)

1. init-methodメソッドを初期化する

実装 1: クラスに InitializingBean インターフェイスを実装させ、afterPropertiesSet メソッドを書き直す

spring.xml 設定ファイルでは、対応する Bean タグでinit-method 属性を設定する必要はありません。

Bean クラス

public class User implements InitializingBean {
    
    

    private String name;

    public User(){
    
    
        System.out.println("我被实例了！");
    }

    public void say(){
    
    
        System.out.println("我被调用了！");
    }

    /**
     * 初始化回调-在对象创建完成之后
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
    
    
        System.out.println("init初始化-afterPropertiesSet()");
    }
}

テスト

//1. 加载配置文件，初始化容器
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

実装 2 (推奨): Bean タグで init-method メソッドを構成します。

非侵入的な構成方法

スプリング構成ファイル内

<bean id="user" init-method="userInit"  class="com.huawei.SpringDemo2023.User" />

BeanクラスにuserInitメソッドを定義する

public class User{
    
    

    private String name;

    public User(){
    
    
        System.out.println("我被实例了！");
    }

    public void say(){
    
    
        System.out.println("我被调用了！");
    }

    /**
     * 初始化回调-在对象创建完成之后
     * @throws Exception
     */
    public void userInit(){
    
    
        System.out.println("userInit调用！");
    }
}

2. Bean 破棄コールバック -destroy メソッド

実装 1: DisposableBean インターフェースを実装し、destroy メソッドを書き直す

public class User implements DisposableBean {
    
    

    private String name;

    public User(){
    
    
        System.out.println("我被实例了！");
    }

    public void say(){
    
    
        System.out.println("我被调用了！");
    }

    /**
     * 当对象销毁时回到
     * @throws Exception
     */
    @Override
    public void destroy() throws Exception {
    
    
        System.out.println("destroy-调用");
    }
}

実装 2: 構成ファイルを追加する

<bean id="user" destroy-method="userDes" class="com.huawei.SpringDemo2023.User" />

Bean クラス

public class User{
    
    

    private String name;

    public User(){
    
    
        System.out.println("我被实例了！");
    }

    public void say(){
    
    
        System.out.println("我被调用了！");
    }

    /**
     * 当对象销毁时回到
     * @throws Exception
     */
    public void userDes(){
    
    
        System.out.println("userDes-调用");
    }
}

テスト

//1. 加载配置文件，初始化容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

        // registerShutdownHook 方法是关闭所有bean，触发销毁
        context.registerShutdownHook();

3. プリプロセッサークラスとポストプロセッサークラス

効果：

コンテナ内のBeanによって呼び出されたinit-methodメソッドがコールバックされる場合、メソッド呼び出しの前後にオペレーションを追加します

実装プロセス

プリプロセッサおよびポストプロセッサクラスを作成する

package com.huawei.SpringDemo2023;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * 前后置处理器类
 * 2023/2/9
 */
public class MyBeanPostProcessor implements BeanPostProcessor {
    
    

    /**
     * 前置处理器
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    
    
        System.out.println("-----------1.前置处理器--------------");
        System.out.println("bean："+bean);
        System.out.println("beanName："+bean);

        return bean;
    }

    /**
     * 后置处理器
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    
    
        System.out.println("-----------2.后置处理器--------------");
        System.out.println("bean："+bean);
        System.out.println("beanName："+bean);
        return bean;
    }

}

Spring でプリプロセッサ クラスとポストプロセッサ クラスのインスタンスを構成する

 <!-- User类的对象就交给Spring管理了 -->
    <bean id="user" init-method="userInit" class="com.huawei.SpringDemo2023.User" />
    <bean id="stu" init-method="initStu" class="com.huawei.SpringDemo2023.Student" />

    <!--    前后置处理器类 -->
    <bean id="myBeanPostProcessor" class="com.huawei.SpringDemo2023.MyBeanPostProcessor" />

注: プリプロセッサとポストプロセッサのトリガーは、init メソッドが定義されていない場合でもトリガーされ、そのタイミングはコンストラクターの呼び出しの前後になります。

プリプロセッサ クラスとポストプロセッサ クラスの実装が複数ある場合は、Ordered インターフェイスを実装し、getOrder メソッドを実装します。

1. getOrderメソッドを書き換えた後、戻り値が小さいほど実行優先度が高くなります。

2. 実行優先度は同じ Spring 設定ファイルによれば、Bean が設定されている順序が優先されます。

/**
 * 前后置处理器类
 * 2023/2/9
 */
public class MyBeanPostProcessor implements BeanPostProcessor, Ordered {
    
    

    /**
     * 前置处理器
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    
    
        System.out.println("-----------1.MyBeanPostProcessor-前置处理器--------------");

        return bean;
    }

    /**
     * 后置处理器
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    
    
        System.out.println("-----------2.MyBeanPostProcessor-后置处理器--------------");
        return bean;
    }

    /**
     * 执行先后的顺序 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
     * @return
     */
    @Override
    public int getOrder() {
    
    
        return 800;// 值越小执行优先级越高
    }
}

4. Bean プロパティの注入

Bean クラスの set メソッドを呼び出してプロパティを挿入します。

<!-- User类的对象就交给Spring管理了 -->
    <bean id="user" class="com.huawei.SpringDemo2023.User" >
        <property name="name" value="cxk" />
    </bean>

public class User{
    
    

    private String name;

    public User(){
    
    
        System.out.println("我被实例了！");
    }

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        System.out.println("user-set方法调用-value:"+name);
        this.name = name;
    }
}

5. Bean定義の継承

    <!-- 定义一个抽象模板 -->
    <bean id="templateA" abstract="true">
        <property name="name" value="123"></property>
    </bean>

    <!-- bean类通过parent属性继承  -->
    <bean id="user" class="com.huawei.SpringDemo2023.User" parent="templateA" >
		<!-- <property name="name" value="cxk" />-->
    </bean>

5. Spring 依存性の注入

1. コンストラクターによって挿入されるメソッド

注入されたクラス

public class TestEditor {
    
    
	// 需要spring注入的对象
    private SpellChecker spellChecker;

    public TestEditor(){
    
    
        System.out.println("TestEditor-实例化:无参构造器");
    }
	//通过有参构造器将要注入的对象创建的责任抛出（给springioc容器来操作）
    public TestEditor(SpellChecker spellChecker) {
    
    
        System.out.println("TestEditor-实例化:"+spellChecker);
        this.spellChecker = spellChecker;
    }

    public void testDI(){
    
    
        this.spellChecker.aa();
    }

}

注入するクラス

public class SpellChecker {
    
    

    public void aa(){
    
    
        System.out.println("SpellChecker-AA");
    }

}

Spring 構成 - コンストラクター インジェクション

<!-- 准备需要注入对象的实例 -->
   <bean id="spellChecker" class="com.huawei.SpringDemo2023.SpellChecker" />

    <!-- 要注入实例的类 -->
    <bean id="testEditor" class="com.huawei.SpringDemo2023.TestEditor">
        <!-- 将要注入的实例放入TestEditor类的有参构造器的第一个参数,如果有多个参数根据标签顺序注入 -->
        <!-- 当TestEditor加载时就会自动调用有参构造器，进行对象注入 -->
        <constructor-arg ref="spellChecker" />
    </bean>

1. コンストラクタの基本データ型またはString型の注入方法

オブジェクトへの参照を渡したい場合は、タグの ref 属性を使用する必要があります。値を直接渡したい場合は、上記のように value 属性を使用する必要があります。

型は type 属性によって区別され、基本データ型は名前を直接書き込み、参照型は完全修飾名を書き込みます。

2. インデックス属性値は、挿入されるパラメータの順序を制御します。

インデックス値は 0 から始まります。たとえば、0 は最初のパラメータを表します。

2.セッターメソッドによる注入

設定ファイル

<!-- 准备需要注入对象的实例 -->
   <bean id="spellChecker" class="com.huawei.SpringDemo2023.SpellChecker" />

    <!-- 要注入实例的类 -->
    <bean id="testEditor" class="com.huawei.SpringDemo2023.TestEditor">
        <!-- 调用了spellChecker对应的setter方法实现注入 -->
       <property name="spellChecker" ref="spellChecker" />
    </bean>

注入するクラス

public class TestEditor {
    
    

    private SpellChecker spellChecker;

    public SpellChecker getSpellChecker() {
    
    
        return spellChecker;
    }

    //setter方法就是提供给外部实现参数注入的方法
    public void setSpellChecker(SpellChecker spellChecker) {
    
    
        System.out.println("setter方法调用！");
        this.spellChecker = spellChecker;
    }

    public void testDI(){
    
    
        this.spellChecker.aa();
    }

}

3.p-namespaceメソッドインジェクション

新旧のやり方の比較

昔のやり方:

新しい方法:

<!-- namespace方法会根据被注入的类自动调用构造器注入或setter方法注入 -->
<bean id="testEditor" class="com.huawei.SpringDemo2023.TestEditor"
   p:spellChecker-ref="spellChecker"
/>

4. 内部 Bean インジェクション

Bean タグ設定インスタンスの注入メソッドは、インスタンスを注入する必要があるときに記述されます。

Setter メソッドの内部 Bean インジェクション

コンストラクター内での Bean インジェクション

<bean id="testEditor" class="com.huawei.SpringDemo2023.TestEditor" >
    <constructor-arg name="cxk">
        <bean class="com.huawei.SpringDemo2023.SpellChecker" />
    </constructor-arg>
</bean>

5. コレクションの注入

コレクションの注入は内部 Bean の注入に似ています

注射ケースは4種類：

注入されたクラス

1. リストインジェクション

2. 注入を設定する

3.マップインジェクション

4.プロパティの注入

5. コレクションへの混合データインジェクション（インスタンスインジェクションコレクション）

6. SpringBeanの自動アセンブリ

Spring コンテナは、 要素を使用せずに連携する Bean 間の関係を自動配線できます。これは、大規模な Spring ベースのアプリケーション用に作成される XML 構成の量を削減するのに役立ちます。

1. 自動組立モード

次の自動ワイヤリング パターンは、依存関係の注入に自動ワイヤリングを使用するように Spring コンテナに指示するために使用できます。要素の autowire 属性を使用して、Bean 定義の autowire モードを指定できます。

1.1 名前によるアセンブリモード

このモードは、自動配線のプロパティ名によって指定されます。Spring コンテナは、XML 構成ファイルで auto-wire 属性が byName に設定されている Bean として認識されます。次に、そのプロパティを、構成ファイルで定義されている同じ名前の Bean と照合して接続しようとします。一致するものが見つかった場合は、それらの Bean が注入され、一致しない場合は例外がスローされます。

注入するクラス

public class TestEditor {
    
    

    private SpellChecker cxk;

    public SpellChecker getCxk() {
    
    
        return cxk;
    }
    
    // byName方法只会使用setter方法实现注入
    public void setCxk(SpellChecker cxk) {
    
    
        this.cxk = cxk;
    }
}

構成

<!-- 准备需要注入对象的实例 -->
<bean id="cxk" class="com.huawei.SpringDemo2023.SpellChecker" />

<bean id="testEditor" class="com.huawei.SpringDemo2023.TestEditor" autowire="byName"></bean>

1.2 タイプ別アセンブリモード

このモードは、自動配線のプロパティ名によって指定されます。Spring コンテナは、XML 構成ファイルで autowire 属性が byType に設定されている Bean として認識されます。次に、そのプロパティを、構成ファイルで定義されている同じ名前の Bean と照合して接続しようとします。一致するものが見つかった場合は、それらの Bean が注入され、一致しない場合は例外がスローされます。

注入するクラス

public class TestEditor {
    
    

    private SpellChecker cxk;

    public SpellChecker getCxk() {
    
    
        return cxk;
    }

    // byType方法只会使用setter方法实现注入
    public void setCxk(SpellChecker cxk) {
    
    
        System.out.println("setter");
        this.cxk = cxk;
    }
}

構成

!-- 准备需要注入对象的实例 -->
<bean id="xxx" class="com.huawei.SpringDemo2023.SpellChecker" />

<bean id="testEditor" class="com.huawei.SpringDemo2023.TestEditor" autowire="byType"></bean>

1.3 アセンブリモードコンストラクター

このパターンは byType に非常に似ていますが、コンストラクターのパラメーターに適用されます。Spring コンテナは、XML 構成ファイルで autowire 属性がコンストラクターに設定されている Bean として認識されます。次に、コンストラクターのパラメーターを構成ファイル内の Bean 名の 1 つと照合して接続しようとします。一致するものが見つかった場合はそれらの Bean を注入し、一致しない場合は例外をスローします。

注入するクラス

public class TestEditor {
    
    

    private SpellChecker cxk;

    // constructor方法只会使用构造器方法实现注入
    public TestEditor(SpellChecker cxk) {
    
    
        System.out.println("构造器");
        this.cxk = cxk;
    }
}

構成

<!-- 准备需要注入对象的实例 -->
    <bean id="xxx" class="com.huawei.SpringDemo2023.SpellChecker" />

    <bean id="testEditor" class="com.huawei.SpringDemo2023.TestEditor" autowire="constructor"></bean>

7. Spring アノテーションベースの構成

目的: XML での複雑な構成を軽減する

1. 使い方 - アノテーションの導入

<!-- 将所有Spring关于依赖注入的注解类实例化存放到ioc容器汇总 -->
    <context:annotation-config />

2. 共通の注釈

1. @Required アノテーション

必須の検証アノテーションである @Required アノテーションは、Bean プロパティの setter メソッドに適用されます。これは、影響を受ける Bean プロパティを構成時に XML 構成ファイルに配置する必要があることを示します。そうでない場合、コンテナは BeanInitializationException をスローします。

Spring バージョン 5.3.9、注釈は非推奨になりました。入力されなかった場合、エラーは報告されません

注入するクラス

public class TestEditor {
    
    

    private SpellChecker cxk;

    
    public SpellChecker getCxk() {
    
    
        return cxk;
    }
    
    // 只能用于setter方法上
    @Required
    public void setCxk(SpellChecker cxk) {
    
    
        this.cxk = cxk;
    }
}

2. @Autowired アノテーション

@Autowired アノテーションを使用すると、自動配線がどこでどのように行われるかをより詳細に制御できます。

@Autowired アノテーションを使用すると、 @Autowired アノテーション、コンテナ、プロパティ、または複数のパラメータを取ることができる任意の名前のメソッドなどのセッター メソッドで Bean をオートワイヤリングできます。

注: 1. このアノテーションはデフォルトで @Required アノテーションと同様の機能を持ち、必須の検証があります。

2. コンストラクタが値を渡す必要があり、Spring に注入するインスタンスがない場合に備えて、Spring インスタンス オブジェクトはコンストラクタを呼び出す必要があるため、注入されるクラスでは、パラメータなしのコンストラクタを提供するために、できる限りパラメータ化されたコンストラクタを提供します。 UnsatisfiedDependencyException がスローされます

@Autowired (required=false) 不要な検証

1. setterメソッドで使用する

// 使用setter方法注入，装配方法根据byType规则装配
    @Autowired
    public void setCxk(SpellChecker cxk) {
    
    
        System.out.println("setter:"+cxk);
        this.cxk = cxk;
    }

2. 属性での使用

プロパティで @Autowired アノテーションを使用して、セッター メソッドを削除できます。自動接続属性転送を使用する場合、Spring はこれらの渡された値または参照をそれらの属性に自動的に割り当てます。

// 如果有构造器，则采用构造器的方式进行注入，如果没有则直接根据类型注入到属性中不调用setter方法
// 装配模式依旧使用bytype方法匹配
@Autowired
private SpellChecker cxk;

3. コンストラクターで使用する

コンストラクターで @Autowired を使用することもできます。コンストラクター @Autowired は、Bean が XML ファイル内の要素で構成されていない場合でも、Bean の作成時にコンストラクターが自動的に接続されることを示します。

// 注入方式使用构造器注入，匹配规则使用byType方法匹配
@Autowired
public TestEditor(SpellChecker cxk) {
    
    
    System.out.println("构造器："+cxk);
    this.cxk = cxk;
}

3. 修飾子アノテーション - @Autowired アノテーション付き

役割: @Autowired アノテーションの自動配線は、Bean の ID または名前による選択注入に基づいています。

スプリング構成ファイル

<bean id="textEditor" class="com.huawei.SpringDemo2023.TestEditor"></bean>

    <bean id="j1" class="com.huawei.SpringDemo2023.SpellChecker" >
        <property name="name" value="高启强" />
    </bean>

    <bean id="j2" class="com.huawei.SpringDemo2023.SpellChecker" >
        <property name="name" value="高启盛" />
    </bean>

注入するクラス

public class TestEditor {
    
    

    @Autowired // 在byType的基础上选择
    @Qualifier("j1")// 选择bean的name或id
    private SpellChecker cxk;


    public void test(){
    
    
        System.out.println(this.cxk.getName());
    }

}

4. Spring-JSR250 アノテーション

1.@PostConstruct@PreDestroy

public class TestEditor {
    
    

    private SpellChecker cxk;

    /**
     * 替代了init-method配置，描述初始化回调方法
     */
    @PostConstruct
    public void testInit(){
    
    
        System.out.println("初始化！");
    }

    /**
     * 替代了destroy-method配置，描述销毁回调方法
     */
    @PreDestroy
    public void testDestory(){
    
    
        System.out.println("销毁！");
    }

}

2. @Resourceアノテーション

1. 名前属性の定義

Bean ID または名前によるワイヤリングアセンブリ

<!-- 将所有Spring关于依赖注入的注解类实例化存放到ioc容器汇总 -->
<context:annotation-config />

<bean id="textEditor" class="com.huawei.SpringDemo2023.TestEditor"></bean>

<bean id="j1" class="com.huawei.SpringDemo2023.SpellChecker" >
    <property name="name" value="高启盛" />
</bean>

public class TestEditor {
    
    

    @Resource(name="j1")
    private SpellChecker cxk;

    public TestEditor(){
    
    
        System.out.println("构造器：无参");
    }

    public TestEditor(SpellChecker cxk){
    
    
        System.out.println("构造器：有参"+cxk);
        this.cxk = cxk;
    }

    public SpellChecker getCxk() {
    
    
        return cxk;
    }

    public void setCxk(SpellChecker cxk) {
    
    
        System.out.println("setter");
        this.cxk = cxk;
    }
}

2.型属性の定義

タイプ別の自動配線

public class TestEditor {
    
    

    // 注入的实例类型是SpellChecker类型以及子类
    @Resource(type = SpellChecker.class)
    private SpellChecker cxk;

    public TestEditor(){
    
    
        System.out.println("构造器：无参");
    }

    public TestEditor(SpellChecker cxk){
    
    
        System.out.println("构造器：有参"+cxk);
        this.cxk = cxk;
    }

    public SpellChecker getCxk() {
    
    
        return cxk;
    }

    public void setCxk(SpellChecker cxk) {
    
    
        System.out.println("setter");
        this.cxk = cxk;
    }
}

3. 2つの属性を同時に使用可能

まずタイプで区別し、次に名前で接続します

@Resource(name = "j1",type = SpellChecker.class)
private SpellChecker cxk;

5. @Configuration および @Bean アノテーション

@Configuration: これが Bean インスタンスを構成するクラスであることを識別します (クラス宣言上)

@Bean: インスタンス オブジェクトを返すメソッドを識別します (メソッド宣言で)。

役割: クラスとメソッドを使用して、XML によるコンテナーの構成方法を置き換えます。

注: クラスのメソッド構成を使用すると、spring.xml ファイルに Bean タグを記述せずにインスタンスをロードできます。

構成クラス

package com.huawei.SpringDemo2023;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 容器配置类
 * 2023/2/10
 */
// 描述当前类是一个描述ioc容器配置的类---》等同于spring.xml配置文件
    // 想要获取当前类中的bean配置需要加载当前配置类
@Configuration
public class MyConfig {
    
    

    // <bean id="getSpellCheckerJ1" class="om.huawei.SpringDemo2023.SpellChecker" />
    // 被添加@Bean注解的方法返回值实例将添加到ioc容器中
    @Bean
    public SpellChecker getSpellCheckerJ1(){
    
    
        SpellChecker spellChecker = new SpellChecker();
        spellChecker.setName("高启盛");
        return spellChecker;
    }

}

テスト

/**
 * 测试工具类
 * 2023/2/8
 */
public class TextClass {
    
    

    @Test
    public void text1(){
    
    

        //ApplicationContext
        System.out.println("1. 容器加载");
        //1. 加载配置类，初始化容器
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);

        //传统的方法通过名称获取，此时传递的是方法的名称
        SpellChecker bean = (SpellChecker) context.getBean("getSpellCheckerJ1");

        // 通过bean方法的返回值类型获取实例
        //SpellChecker bean = context.getBean(SpellChecker.class);

        System.out.println(bean.getName());

    }

}

複数構成クラスの登録方法

6. @Import アノテーション

@import アノテーション、別の構成クラスのコンテンツをインポートしてマージします

注: このアノテーションは構成クラス宣言でのみ使用できます。

構成クラス-1

@Configuration
@Import(MyConfig2.class)// config2导入到当前配置类
public class MyConfig {
    
    

    // <bean id="getSpellCheckerJ1" class="om.huawei.SpringDemo2023.SpellChecker" />
    // 被添加@Bean注解的方法返回值实例将添加到ioc容器中
    @Bean
    public SpellChecker getSpellCheckerJ1(){
    
    
        SpellChecker spellChecker = new SpellChecker();
        spellChecker.setName("高启盛");
        return spellChecker;
    }

}

構成クラス-2

@Configuration
public class MyConfig2 {
    
    

    @Bean
    public SpellChecker getSpellCheckerJ2(){
    
    
        SpellChecker spellChecker = new SpellChecker();
        spellChecker.setName("蔡徐坤");
        return spellChecker;
    }

}

テスト

@Test
public void text1(){
    
    

    //ApplicationContext
    System.out.println("1. 容器加载");
    //1. 加载配置类，初始化容器
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);

    //传统的方法通过名称获取，此时传递的是方法的名称
    SpellChecker bean = (SpellChecker) context.getBean("getSpellCheckerJ2");

    // 通过bean方法的返回值类型获取实例
    //SpellChecker bean = context.getBean(SpellChecker.class);

    System.out.println(bean.getName());

}

7. @Beanは宣言サイクル機能を設定可能

8. @Scopeアノテーション - Beanスコープアノテーション

デフォルトのスコープは単一インスタンスです。

ただし、 @Scope アノテーションを使用してこのメ​​ソッドをオーバーライドできます。

@Scope("prototype") マルチインスタンスでは、IOC コンテナーが作成を開始するときに、オブジェクトを作成してコンテナーに配置しません。必要なときに、コンテナーからオブジェクトを取得する必要があります。作成されます。

@Scope("singleton") 単一インスタンスの IOC コンテナが起動すると、オブジェクトを作成するメソッドが呼び出され、その後コンテナ (マップ内) から同じオブジェクトを取得するたびにメソッドが呼び出されます。

@Scope("request") は同じリクエストを持つインスタンスを作成します

@Scope("session") は同じセッションでインスタンスを作成します

8.Spring-AOP

各クラスには同じビジネス コードがあり、AOP で解決できます。

AOP（Aspect Orient Programming）、直訳するとアスペクト指向プログラミングです。AOP は、オブジェクト指向プログラミング (OOP) を補完するプログラミングのアイデアです。オブジェクト指向プログラミングはプログラムをさまざまなレベルのオブジェクトに抽象化しますが、アスペクト指向プログラミングはプログラムをさまざまな側面に抽象化します。

AOP を使用する理由

次のシナリオを想像してください。開発中に複数のモジュール間に特定のコードが繰り返し存在します。通常、これにどのように対処すればよいでしょうか? 明らかに、「コピー＆ペースト」に頼る人はいないでしょう。従来のプロセス指向プログラミングでは、このコードをメソッドに抽象化し、必要に応じてこのメソッドを呼び出します。これにより、このコードを変更する必要がある場合は、このメソッドのみを変更するだけで済みます。ただし、要件は常に変化します。ある日、新しい要件が追加され、さらに変更を加える必要があります。別のメソッドを抽象化し、必要に応じてこのメソッドを個別に呼び出す必要があります。さもなければ、このメソッドはもう必要ありません。 . 、このメソッドが呼び出されるすべての場所を削除する必要があります。実際、AOP を使用すると、複数の場所で同じ変更が含まれる問題を解決できます。

AOP の用語

AOP の世界における属性用語:

アドバイス: AOP フレームワークでの処理が強化されました。アドバイスでは、アスペクトがいつ実行されるか、および強化処理を実行する方法について説明します。

結合ポイント: 結合ポイントは、アスペクトを挿入できるアプリケーション実行プロセス内のポイントを表します。このポイントは、メソッド呼び出しまたはスローされる例外です。Spring AOP では、ジョインポイントは常にメソッド呼び出しです。

PointCut: 強化処理のための結合点を挿入できます。

アスペクト: アスペクトはアドバイスとポイントカットの組み合わせです。

イントロダクション: イントロダクションにより、既存のクラスに新しいメソッドまたはプロパティを追加できるようになります。

ウィービング：対象オブジェクトに拡張処理を加えて拡張オブジェクトを作成する処理がウィービングです。

4. 構成 AOP を使用する

<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.9.8.RC3</version>
</dependency>

1. XML構成方式によるAOPを実現

1.AOP設定を開く

<!-- AOP配置 -->
    <aop:config>
        ...
</aop:config>

2. セクションを定義する

アスペクトは AOP 全体の独立したビジネス ロジックであり、クラスによって記述される必要があります。

構成

<aop:config>
    <!-- 描述一个切面(包含：连接点、通知的配置) -->
   <aop:aspect id="testAspect" ref="myAspect1"></aop:aspect>
</aop:config>

<!-- 配置切面的类 -->
<bean id="myAspect1" class="com.huawei.SpringDemo2023.aop.TestAspect" />

麺

package com.huawei.SpringDemo2023.aop;

/**
 * 描述切面功能类
 * 配置通知方法
 * 2023/2/10
 */
public class TestAspect {
    
    

   ... 

}

3. カットポイントを定義する

要点は、どのメソッドまたはどのクラスがアクセスされたときに aop 操作がいつトリガーされるかを定義することです

ポイントカット式:

メソッド式は * 記号で始まり、メソッドの戻り値の型を気にしないことを示します。次に、完全修飾クラス名とメソッド名を指定しました。メソッド パラメーター リストの場合、メソッドの入力パラメーターが何であっても、... マークカットを使用して任意の再生メソッドを選択します。複数の一致の間では、リンク記号 &&、||、! を使用できます。「そして」、「または」、「そうでない」の関係を表現します。ただし、XML ファイル構成を使用する場合、これらの記号は特別な意味を持つため、「and」、「or」、「not」を使用して表します。

構成例:

<!-- AOP配置 -->
    <aop:config>
        <!-- 描述一个切面(包含：连接点、通知的配置) -->
        <aop:aspect id="testAspect" ref="myAspect1">
            <!-- 描述一个切点 -->
            <aop:pointcut id="cut1" expression="execution(* com.huawei.SpringDemo2023.aop.Cat.catSay(..))" />
        </aop:aspect>
    </aop:config>

4. 通知を定義する

通知機能: AOP を通じて、呼び出し前、呼び出し後、戻り、例外のコールバック関数を強化します。

使用規則:

事前通知: メソッドが呼び出される前に呼び出されます。必ず呼び出す必要があります。

事後通知: メソッドが呼び出された後に呼び出されます (戻り値が返される前に呼び出されます)。必ず呼び出す必要があります。

例外後の通知: ポイントカットメソッド例外のみがトリガーされ、例外発生後は復帰後に通知は呼び出されません。

復帰後の通知: ポイントカットメソッドが正常な値を返した場合のみトリガーされ、例外が発生した場合はトリガーされません。

サラウンド通知: メソッドは、事後前通知、例外通知、および戻り後の通知を実装し、ターゲット メソッドが呼び出されるかどうかを制御し、メソッドの戻り値を変更し、複雑なシナリオで AOP 通知に適用できます。

サラウンド通知を使用します。他の種類の通知は使用しないことをお勧めします

通知タイプ:

通知する	キーワードを特定する	説明する
予告	前に	メソッドが実行される前の実行アドバイス。
通知を投稿する	後	アドバイスは、結果に関係なく、メソッドの実行後に実行されます。
帰国時に通知	帰国後	メソッドの実行後、アドバイスはメソッドが正常に完了した場合にのみ実行できます。
例外がスローされたときに通知する	投げた後	メソッドの実行後、アドバイスは、メソッドが終了して例外をスローした場合にのみ実行できます。
サラウンド通知	その周り	アドバイスは、アドバイス メソッドの呼び出しの前後に実行されます。

通知コールバック メソッドはアスペクトの定義に属し、アスペクト クラスで定義する必要があります。

アスペクトクラス: 通知メソッドを定義する

package com.huawei.SpringDemo2023.aop;

/**
 * 描述切面功能类
 * 配置通知方法
 * 2023/2/10
 */
public class TestAspect {
    
    

    /**
     * 前置通知
     */
    public void beforeAdvice(){
    
    
        System.out.println("----1.前置通知");
    }

    /**
     * 后置通知
     */
    public void afterAdvice(){
    
    
        System.out.println("----2.后置通知");
    }

}

通知を構成する (例として事前通知と事後通知を使用)

<!-- AOP配置 -->
    <aop:config>
        <!-- 描述一个切面(包含：连接点、通知的配置) -->
        <aop:aspect id="testAspect" ref="myAspect1">
            <!-- 描述一个切点 -->
            <aop:pointcut id="cut1" expression="execution(* com.huawei.SpringDemo2023.aop.Cat.catSay(..))" />
            <!-- 配置通知 -->
            <!-- 1.前置通知 -->
            <aop:before pointcut-ref="cut1" method="beforeAdvice" />
            <!-- 2.后置通知 -->
            <aop:after pointcut-ref="cut1" method="afterAdvice" />
        </aop:aspect>
    </aop:config>

1. 帰国時の通知

XML設定

<!-- 3.返回后通知 returning 定义一个接收方法返回值的形参，如果方法没有返回值注入null，有返回值注入方法的返回值 -->
<aop:after-returning pointcut-ref="cut1" method="afterReturning" returning="retValue" />

アスペクトクラスの通知設定

/**
     * 返回后通知
     * retValue： 接收方法的返回值
     * 返回后通知只能得到切点方法的返回值，但是无法修改
     */
    public void afterReturning(Object retValue){
    
    
        System.out.println("---2.1 返回后通知");
    }

2. 例外後の通知

XML設定

<!-- 4.异常后通知 throwing 定义一个接收异常对象的形参 -->
            <aop:after-throwing pointcut-ref="cut1" method="afterThrowing" throwing="ex" />

アスペクト構成

/**
     * 异常后通知
     * ex: 切点方法异常抛出后，抛出的异常对象
     */
    public void afterThrowing(Throwable ex){
    
    
        System.out.println(ex);
        System.out.println("--2.2 异常后通知");
    }

3. サラウンド通知

XML設定

<!-- 配置通知 -->
<aop:around pointcut-ref="cut1" method="around" />

アスペクトクラスに設定されたサラウンドアドバイスメソッド

public Object around(ProceedingJoinPoint point){
    
    

        System.out.println("---1.前置通知");
        try {
    
    
            Object obj = point.proceed();// 让切点方法执行,obj是切入点方法的返回值，如果没有返回值则返回null
            System.out.println("---2.1 返回后通知");
        } catch (Throwable e) {
    
    
            System.out.println("---2.2异常后通知");
        }
        System.out.println("---2.后置通知");

        return "哈哈哈哈";// 返回值返回的就是切点调用方法的返回值，可以通过自定义的方法改变返回值
    }

5. メソッドを呼び出して AOP をトリガーする

ポイントカットが入るターゲットクラスを定義します

public class Cat {
    
    

    public void catSay(){
    
    
        System.out.println("喵！！！！");
    }

    public void catSay(String name){
    
    
        System.out.println("喵2！！！！"+name);
    }

}

cat の catSay メソッドが呼び出されたときに aop がトリガーされるかどうかをテストします。

この時点でのポイントカット式は次のようになります:execution(* com.huawei.SpringDemo2023.aop.Cat.catSay(…))

 @Test
    public void text1(){
    
    

        //ApplicationContext
        System.out.println("1. 容器加载");
        //1. 加载配置类，初始化容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

        Cat bean = context.getBean(Cat.class);

        bean.catSay();

    }

9. アノテーション設定に基づくパッケージクラスの自動スキャン

使用理由:

前の例では、XML Bean 定義を使用してコンポーネントを構成しました。やや大きなプロジェクトでは、通常、数百のコンポーネントが存在します。これらのコンポーネントが XML Bean 定義を使用して構成されている場合、構成ファイルのサイズが明らかに増大し、検索や保守が不便になります。

Spring2.5 では、自動コンポーネント スキャン メカニズムが導入されています。これにより、クラスパスの下で **@Component、@Service、@Controller、@Repository アノテーション** でマークされたクラスを検索し、管理のためにこれらのクラスを Spring コンテナに組み込むことができます。 。

1. 設定方法と使用方法

1. パッケージの自動スキャンを有効にする

<context:component-scan base-package="cn.itcast" />この構成は、この構成によって登録された context:annotation-config/processors を含む、注釈の解析と処理のための複数のプロセッサを暗黙的に登録します。つまり、<context と記述した場合:component-scan base-package="cn.itcast" /> 構成の場合、context:annotation-config/configuration を記述する必要はありません。base-package はスキャンする必要があるパッケージ (サブパッケージを含む) です。XML でこのタグを設定すると、Spring はベースパックまたはサブパッケージの下の Java ファイルを自動的にスキャンできるようになり、@Component @Controller@Service およびその他のアノテーションを持つクラスをスキャンする場合は、これらのクラスを Bean として登録します

<!-- bean自动注入实例的扫描注解开启 -->
    <!-- 扫描com.huawei.SpringDemo2023的所有子包以及类带有@Component、@Service、@Controller、@Repository的类添加实例到ioc容器 -->
    <!-- 该配置自动将所有Spring关于依赖注入的注解都自动开启了 <context:annotation-config/> -->
    <!-- use-default-filters属性默认为true代表自动扫描报下所有带有@Component、@Service、@Controller、@Repository的类 -->
    <context:component-scan base-package="com.huawei.SpringDemo2023" />

2. インスタンスを自動的に作成し、ioc コンテナに追加する必要があるクラス宣言にアノテーションを追加します。

ノート：

一般的な共通コンポーネント: @Component

コントローラー層クラス: @Controller

ビジネス実装層クラス: @Service

場合：

@Component
public class Cat {
    
    

    public void catSay(){
    
    
        System.out.println("喵！！！！");
    }


    public void catSay(String name){
    
    
        System.out.println("喵2！！！！"+name);
    }

}

コンテナから入手する

System.out.println("1. 容器加载");
        //1. 加载配置类，初始化容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

        Cat bean = context.getBean(Cat.class);

        bean.catSay();

2. (include-filter)/filter (exclude-filter) スキャンタグ設定を指定します

さらに、context:component-scan は 2 つのサブタグも提供します (1) context:include-filter (2) context:exclude-filter これら 2 つのサブタグを説明する前に、context:component-scan の用途について話しましょう。 default-filters 属性。デフォルトは true です。これは、指定されたパッケージ内の @Component でマークされたすべてのクラス (サブアノテーション @Service、@Repository などを含む) がスキャンされ、Bean として登録されることを意味します。

1. context:include-filter

このスキャンの粒度が大きすぎることがわかります。指定されたパッケージの下のコントローラーのみをスキャンしたい場合はどうすればよいでしょうか? この時点で、サブタグ context:incluce-filter

ケースの実装:

<context:component-scan base-package="com.huawei.*" use-default-filters="false">  
	<context:include-filter type="annotation"expression="org.springframework.stereotype.Controller"/>   
</context:component-scan> 

知らせ：

ここで注意してください: use-default-filters="false" を追加すると、デフォルトで true になり、@Controller によってアノテーションが付けられていないクラスが Bean としてスキャンされる可能性があるため、スキャン アノテーションを指定するには use-default- を追加する必要があります。フィルター = "false" 設定。

2.context:除外フィルター

なお、私が参加したプロジェクトでは、base-packageで指定したパッケージ内の一部のサブパッケージにはアノテーションが含まれていないことが確認できたので、スキャンする必要はありません。フィルタリングし、このパッケージをスキャンする必要がないことを示します

ケースの実装:

<context:component-scan base-package="com.huawei.*" use-default-filters="false">  
	<context:exclude-filter type="annotation"expression="org.springframework.stereotype.Controller"/>   
</context:component-scan> 

3. まとめ

<context:exclude-filter>指定的不扫描
<context:include-filter>指定的扫描