Spring学习笔记（二）——依赖注入与自动装配、基于注解的配置、基于java的配置

超、凢脫俗 2022-01-22 10:17 258阅读 0赞

*  参考文档：[传送门1][1][ 传送门2][_2]
 *  说明：第一个文档是W3School中的Spring学习文档，比较粗略。第二个文档是Spring官方的文档，非常详细，对自己英语水平不自信的话使用浏览器的翻译插件查看。
 *  写在前面：本文是个人学习总结，笔记内容都来自于以上两个文档，笔记大部分采用了问答的方式来梳理文档中复杂的知识体系，属个人习惯，不喜勿喷。
 *  这是学习笔记的第二篇，本文通篇都在介绍Spring环境下的依赖注入方法，不管是基于构造方法，setter方法，自动装配还是注解配置的DI，其目的都是为beans之间建立正确的联系。

### 文章目录 ###

*  依赖注入
 *   *  基于构造方法的依赖注入
     *   *  c-namespace
     *  基于setter方法的依赖注入
     *   *  内部bean
         *  p-namespace
     *  循环依赖的解决方法
     *  注入集合类
     *  注入null
 *  自动装配
 *   *  byName自动装配
     *  byType自动装配
     *  constructor自动装配
 *  基于注解的容器配置
 *   *  @Required
     *  @Autowired
     *  @Qualifier
     *  JSR-250 注释
 *  Spring基于java的配置

# 依赖注入 #

*  *什么叫做依赖注入（ DI）？*

> ——Spring框架的核心功能之一就是**通过依赖注入的方式来管理Bean之间的依赖关系**。bean之间的依赖通过构造函数参数，工厂方法的参数或在构造对象实例后在对象实例上设置的属性来定义。依赖注入（DI）是一个过程，通过这个过程，Spring的IoC容器在实例化bean的时候为它注入这些依赖项，达到控制反转（IoC）的目的。

*  *DI有什么优势？*

> ——使用DI原则的代码更清晰，当对象提供其依赖项时，解耦更有效。该对象不查找其依赖项，也不知道依赖项的位置或类。因此，单元测试也会变得更加方便。

*  *依赖注入有几种方式？分别是什么？*

> ——两种。一种是**基于构造方法的依赖注入**，另一种是**基于setter方法的依赖注入**。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>依赖注入类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>Constructor-based dependency injection</td> 
   <td>当容器调用带有多个参数的构造函数类时，实现基于构造函数的 DI，每个代表在其他类中的一个依赖关系。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>Setter-based dependency injection</td> 
   <td>基于 setter 方法的 DI 是通过在调用无参数的构造函数或无参数的静态工厂方法实例化 bean 之后容器调用 beans 的 setter 方法来实现的。</td> 
  </tr> 
 </tbody> 
</table>

*  *两种注入方式应该如何选择？*

> ——it is a good rule of thumb to use constructors for mandatory dependencies and setter methods or configuration methods for optional dependencies.  
> ——将**构造函数的依赖注入用于强制依赖项**和将**setter方法注入用于可选依赖项**的配置是一个良好的经验法则。

## 基于构造方法的依赖注入 ##

这是一个普通的POJO，不依赖于容器特定的接口，基类或注释，仅提供 一个有参构造方法。

1.  最简单的情况

SimpleBeanA 类的依赖项是SimpleBeanB类：

package com.xx.DI_demo;
    
    public class SimpleBeanA {
        
    
        private SimpleBeanB simpleBeanB;
    
        public SimpleBeanA(SimpleBeanB simpleBeanB) {
        
            this.simpleBeanB = simpleBeanB;
        }
    }

在Beans.xml中为其注入依赖：

1.  特殊情况：类的构造参数中有java基础类型导致参数类型无法识别

比如这个类的构造参数是String类型和int类型：

package com.xx.DI_demo;
    
    public class SimpleBeanC {
        
        private String name;
        private int age;
    
        public SimpleBeanC(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    }

那么你就需要在Beans.xml中指定构造参数的类型（type）和值（value）：

1.  正确的参数匹配

观察下面这个类，它的构造函数中有两个类型一样的参数：

package com.xx.DI_demo;
    
    public class SimpleBeanD {
        
        private int width;
        private int length;
    
        public SimpleBeanD(int width, int length) {
        
            this.width = width;
            this.length = length;
        }
    }

问题是：怎么在Beans.xml中配置是的参数能正确匹配上？

为了解决这个问题，constructor-arg 标签给我们提供了许多属性来定位一个参数：

*  **type** \- 参数类型
 *  **index** \- 参数索引，从0开始
 *  **name** \- 参数名

还有两个属性用来赋值：

*  ref - 引用一个bean
 *  value - 直接赋值

举例：

### c-namespace ###

Spring 3.1中引入的c-namespace允许使用内联属性来配置构造函数参数，而不是嵌套constructor-arg元素。

使用c方法可以解决构造参数众多时的代码庞杂问题。

*  示例：

注意要给beans加上c命名空间的支持：

xmlns:c="http://www.springframework.org/schema/c"

标准的格式是 `c:变量名=值` ，如果要表示引用，则使用格式`c:变量名-ref="bean id"`。

## 基于setter方法的依赖注入 ##

当容器调用一个无参的构造函数或一个无参的静态 factory 方法来初始化你的 bean 后，通过容器在你的 bean 上调用setter函数，基于setter函数的 DI 就完成了。

这种方法默认使用的是bean的无参构造方法。

综上，我们的POJO必须有无参构造方法，所有成员的get和set方法：

package com.xx.DI_demo;
    
    public class SimpleBeanE {
        
        private SimpleBeanF simpleBeanF;
    
        public SimpleBeanE() {
        
        }
    
        public SimpleBeanF getSimpleBeanF() {
        
            return simpleBeanF;
        }
    
        public void setSimpleBeanF(SimpleBeanF simpleBeanF) {
        
            this.simpleBeanF = simpleBeanF;
        }
    }

Beans.xml

*  *基于构造函数注入和基于设值函数注入中的 Beans.xml 文件的区别?*

> ——唯一的区别就是在基于构造函数注入中，我们使用的是〈bean〉标签中的〈constructor-arg〉元素，而在基于设值函数的注入中，我们使用的是〈bean〉标签中的〈property〉元素。

### 内部bean ###

和java中的内部类相似，用的不多，直接上代码：

不需要使用ref，而且其他Bean也可以引用simpleBeanF。

### p-namespace ###

虽然使用property标签可以快速的完成DI，但是当bean中有非常多的属性需要DI时，使用property就显得非常麻烦。这个时候可以考虑p空间的注入方式：

1.  步骤一：在beans标签上添加命名空间：

xmlns:p="http://www.springframework.org/schema/p"

1.  步骤二：注入依赖

标准的格式是 `p:变量名=值` ，如果要表示引用，则使用格式`p:变量名-ref="bean id"`。

## 循环依赖的解决方法 ##

*  *什么叫循环依赖？*

> ——A依赖B，B又依赖A。那么容器初始化时就会抛出`BeanCurrentlyInCreationException`的异常。注意，循环依赖在是使用构造函数DI的前提下发生的。

*  *如何解决？*

> ——使用setter方法来DI。

## 注入集合类 ##

如果你想在xml中传递Java Collection 类型 List、Set、Map 和 Properties给构造方法或者给属性赋值的话，Spring提供了四种类型的集合的配置元素：

1.  `<list>`
2.  `<set>`
3.  `<map>`
4.  `<props>`

使用示例：

<bean id="moreComplexObject" class="example.ComplexObject">
        
        <property name="adminEmails">
            <props>
                <prop key="administrator">administrator@example.org</prop>
                <prop key="support">support@example.org</prop>
                <prop key="development">development@example.org</prop>
            </props>
        </property>
        
        <property name="someList">
            <list>
                <value>a list element followed by a reference</value>
                <ref bean="myDataSource" />
            </list>
        </property>
        
        <property name="someMap">
            <map>
                <entry key="an entry" value="just some string"/>
                <entry key ="a ref" value-ref="myDataSource"/>
            </map>
        </property>
        
        <property name="someSet">
            <set>
                <value>just some string</value>
                <ref bean="myDataSource" />
            </set>
        </property>
    </bean>

## 注入null ##

*  正确的注入null

*  错误的注入null

相当于给属性赋了空字符串的值而不是null。

# 自动装配 #

我们已经介绍了使用`<bean>`元素来声明 bean 和通过使用 XML 配置文件中的`<constructor-arg>`和`<property>`元素来注入依赖 。

Spring 容器可以在不使用`<constructor-arg>`和`<property>`元素的情况下**自动装配**相互协作的 bean 之间的关系，这有助于减少编写一个大的基于 Spring 的应用程序的 XML 配置的数量。

*  *如何理解自动装配？*

> ——自动装配的目的也是为bean注入依赖，只要我们定义bean是遵守一定的规范，容器就可以自动的为它注入所需要的依赖项。

*  *java中有几种装配机制？分别是什么？*

> ——Spring中bean有三种装配机制，分别是：
> 
> 1.  在xml中显示配置；
> 2.  在java中显示配置；
> 3.  隐式的bean发现机制和自动装配。

*  *如何启动自动装配？*

> ——使用`<bean>`元素的 autowire 属性为一个 bean 定义指定自动装配模式。

*  *自动装配有几种模式？分别是什么？*

> ——五种。

<table> 
 <thead> 
  <tr> 
   <th>模式</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>no</td> 
   <td>这是默认的设置，它意味着没有自动装配。</td> 
  </tr> 
  <tr> 
   <td><strong>byName</strong></td> 
   <td>由<strong>属性名</strong>自动装配。Spring 容器看到在 XML 配置文件中 bean 的自动装配的属性设置为 byName。然后尝试匹配，并且将它的属性与在配置文件中被定义为相同名称的 beans 的属性进行连接。</td> 
  </tr> 
  <tr> 
   <td><strong>byType</strong></td> 
   <td>由<strong>属性数据类型</strong>自动装配。Spring 容器看到在 XML 配置文件中 bean 的自动装配的属性设置为 byType。然后如果它的类型匹配配置文件中的一个确切的 bean 名称，它将尝试匹配和连接属性的类型。如果存在不止一个这样的 bean，则一个致命的异常将会被抛出。</td> 
  </tr> 
  <tr> 
   <td><strong>constructor</strong></td> 
   <td><strong>类似于 byType，但该类型适用于构造函数参数类型</strong>。如果在容器中没有一个构造函数参数类型的 bean，则一个致命错误将会发生。</td> 
  </tr> 
  <tr> 
   <td>autodetect</td> 
   <td>Spring首先尝试通过 constructor 使用自动装配来连接，如果它不执行，Spring 尝试通过 byType 来自动装配。</td> 
  </tr> 
 </tbody> 
</table>

使用byType和constructor模式可以连接数组和集合类。

*  *自动装配有什么局限性？*

> ——使用自动装配有一定的局限性和缺陷：
> 
> 1.  显式依赖项property和constructor-arg设置始终覆盖自动装配。
> 2.  不能自动装配简单属性，比如int，String，等等。
> 3.  自动装配不如显式装配精确，所以如果可能的话尽可能使用显式装配。
> 4.  可能无法为可能从Spring容器生成文档的工具提供连接信息

## byName自动装配 ##

这种模式由**属性名称**指定自动装配。步骤大概分为三步：

1.  在 XML 配置文件中 beans 的 auto-wire 属性设置为 byName。
2.  容器将在 bean 的属性与配置文件中定义为**相同名称**的 bean 进行匹配和连接。
3.  如果找到匹配项，它将注入这些 beans，否则，它将抛出异常。

我们按照这个思路来测试：

1.  SimpleBeanA 的依赖项是SimpleBeanB ，提供setter方法和无参构造方法。写一个测试方法打印一下属性simpleBeanB看看是否能自动装配上。

package com.xx.DI_demo;
    
    public class SimpleBeanA {
        
    
        private SimpleBeanB simpleBeanB;
    
        public SimpleBeanA() {
        
        }
    
        public SimpleBeanB getSimpleBeanB() {
        
            return simpleBeanB;
        }
    
        public void setSimpleBeanB(SimpleBeanB simpleBeanB) {
        
            this.simpleBeanB = simpleBeanB;
        }
    
        public void doTest() {
        
            System.out.println("this is A -- " + this.simpleBeanB);
        }
    }

1.  Beans.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
            https://www.springframework.org/schema/beans/spring-beans.xsd">
    	
    	
    	
        <bean id="simpleBeanA" class="com.xx.DI_demo.SimpleBeanA" autowire="byName"/>
        
        <bean id="simpleBeanB" class="com.xx.DI_demo.SimpleBeanB"/>
    
    </beans>

1.  测试类：

package com.xx.main;
    
    import com.xx.DI_demo.SimpleBeanA;
    import org.springframework.context.support.AbstractApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test_DI_Autowire {
        
    
        public static void main(String[] args) {
        
    
            AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
    
            SimpleBeanA beanA = context.getBean(SimpleBeanA.class);
    		
            beanA.doTest();
    		// 关闭容器
            context.registerShutdownHook();
        }
    }

1.  程序执行结果：

this is A -- com.xx.DI_demo.SimpleBeanB@25bbe1b6

1.  结论：

我们使用自动装配byName模式，自动的为beanA注入了依赖。

## byType自动装配 ##

这种模式由属性类型指定自动装配。

1.  在 XML 配置文件中 beans 的 autowire 属性设置为 byType。
2.  如果beand的依赖项的 type 恰好与配置文件中 beans 名称中的一个相匹配，它将尝试匹配和连接它的属性。
3.  如果找到匹配项，它将注入这些 beans，否则，它将抛出异常。

这里不再一一演示，我们看一下Beans.xml是如何配置的就可以：

同样的，SimpleBeanA的依赖项是SimpleBeanB，那么容器也会自动装配。

## constructor自动装配 ##

这种模式与 byType 非常相似，但它应用于构造器参数。

1.  在 XML 配置文件中 beans 的 autowire 属性设置为 constructor。
2.  容器尝试把bean的构造函数的参数与配置文件中 beans 名称中的一个进行匹配和连线。
3.  如果找到匹配项，它会注入这些 bean，否则，它会抛出异常。

使用这种自动装配要求我们的bean**提供有参构造方法**。

*  Beans.xml：

# 基于注解的容器配置 #

*  *Annotation or XML ?*

> ——Spring2.5开始支持注解配置容器，这是一种颇具争议性的机制，长久以来，Annotation Or XML? 的问题一致没有一个标准的答案。二者各有各的优劣，基于注解的配置代码量少，效率高，但是基于XML的配置可见性高，更利于管理。Spring对这两者机制完美的支持，你甚至可以混合使用它们。至于到底使用哪种方法来支持你的项目，应该由开发者自己的偏好决定。不过，按照现阶段的发展趋势，使用注解配置的开发者越来越多，也越来越被人们认可。

*  *注解和XML的配置混合使用要注意什么？*

> ——一般不建议二种配置方式混合使用，但是，如果你非要这样做，那么就要注意，注解配置会先于XML配置执行，也就是说，基于注解的配置有可能会被XML的配置覆盖掉。

*  *如何开启注解配置？*

> ——注解配置默认不开启，想使用的haul需要在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"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">
    	
    	
        <context:annotation-config/>
        
        <context:component-scan base-package="包名"/>
    
    </beans>

> 配置后，你就可以开始注解你的代码，表明 Spring 应该自动连接值到属性，方法和构造函数。`<context:annotation-config/>`**仅查找在定义它的同一应用程序上下文中的bean上的注释**。

*  *几个重要的注解*

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>注解</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>@Required</td> 
   <td>@Required 注解应用于 bean 属性的 setter 方法。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>@Autowired</td> 
   <td>@Autowired 注解可以应用到 bean 属性的 setter 方法，非 setter 方法，构造函数和属性。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>@Qualifier</td> 
   <td>通过指定确切的将被连线的 bean，@Autowired 和 @Qualifier 注解组合使用可以用来去歧。</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>JSR-250 Annotations</td> 
   <td>Spring 支持 JSR-250 的基础的注解，其中包括了 @Resource，@PostConstruct 和 @PreDestroy 注解。</td> 
  </tr> 
 </tbody> 
</table>

## @Required ##

**@Required 注解应用于 bean 属性的 setter 方法。它表明受影响的 bean 属性在配置时必须放在 XML 配置文件中，否则容器就会抛出一个`BeanInitializationException` 异常。**

示例：

package com.xx.DI_demo;
    
    import org.springframework.beans.factory.annotation.Required;
    
    public class SimpleBeanA {
        
    
        private SimpleBeanB simpleBeanB;
    
        public SimpleBeanA() {
        
        }
        
        
        public SimpleBeanB getSimpleBeanB() {
        
            return simpleBeanB;
        }
        
    	@Required
        public void setSimpleBeanB(SimpleBeanB simpleBeanB) {
        
            this.simpleBeanB = simpleBeanB;
        }
    }

**@Required注释从Spring Framework 5.1开始正式被弃用，被后置处理器所取代。**

## @Autowired ##

@Autowired 注解可以应用到 bean 属性的 setter 方法，非 setter 方法，构造函数和属性。

1.  *Setter 方法中的 @Autowired*

> 当 Spring遇到一个在 setter 方法中使用的 @Autowired 注释，它会执行 byType 自动装配。

1.  *属性中的 @Autowired*

> 在属性中使用 @Autowired 注释表示这个属性是必须配置的，而且省去setter方法，容器执行 byType 自动装配。

1.  *构造函数中的 @Autowired*

> 构造函数中的参数会被自动装配（byType）

1.  *普通方法中的 @Autowired*

> 方法中的形式参数会被自动装配（byType）

问题汇总：

*  *可以混合注解吗？*

> ——可以。但是重复了的属性注解没有必要这么做。一个实例：

public class MovieRecommender {
        
    
        private final CustomerPreferenceDao customerPreferenceDao;
    
        @Autowired
        private MovieCatalog movieCatalog;
    
        @Autowired
        public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {
        
            this.customerPreferenceDao = customerPreferenceDao;
        }
    
        // ...
    }

*  *在数组和集合类类型的属性上使用@Autowired会发生什么？*

> ——**容器中符合类型的所有bean都会被自动装配**。实例：

SimpleBeanH

package com.xx.DI_demo;
    
    import org.springframework.beans.factory.annotation.Autowired;
    
    import java.util.Arrays;
    
    public class SimpleBeanH {
        
    
        // 注释属性不需要再提供setter方法
        @Autowired
        private SimpleBeanI[] simpleBeanI;
    
        public SimpleBeanH() {
        
        }
    
        public void doTest() {
        
            System.out.println("this is h -- " + this);
        }
    
        @Override
        public String toString() {
        
            return "SimpleBeanH{" +
                    "simpleBeanI=" + Arrays.toString(simpleBeanI) +
                    '}';
        }
    }

Beans.xml：配置了两个SimpleBeanI类型的bean

<?xml version="1.0" encoding="UTF-8" ?>
    <beans
            xmlns="http://www.springframework.org/schema/beans"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
            xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    
    
        <context:annotation-config/>
        <context:component-scan base-package="com.xx.DI_demo"/>
    </beans>

测试类

package com.xx.main;
    
    import com.xx.DI_demo.SimpleBeanH;
    import org.springframework.context.support.AbstractApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test_DI_Autowire {
        
    
        public static void main(String[] args) {
        
    
            AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
    
            SimpleBeanH bean = context.getBean(SimpleBeanH.class);
    
            bean.doTest();
            
            context.registerShutdownHook();
        }
    }

程序运行结果

this is h -- SimpleBeanH{simpleBeanI=[com.xx.DI_demo.SimpleBeanI@9a7504c, com.xx.DI_demo.SimpleBeanI@2c039ac6]}

结论：打印出了两个SimpleBeanI类型的对象，符合预期猜测。这种情况同样适用于集合。

*  *@Autowired和@Required的联系？*

> ——@Autowired 注释意味着依赖是必须的，它类似于 @Required 注释。然而，你可以使用`@Autowired 的 （required=false）` 选项关闭默认行为。

@Autowired(required=false)
    public void setAge(Integer age) {
        
       this.age = age;
    }

*  如果容器中有多个类型匹配的bean，如何装配？

> ——@Autowired默认的装配模式是byType，如果匹配到了多个bean，就会根据byName模式再次匹配，如果匹配不到就会报错。

示例：

Beans.xml中我们配置了多个SimpleBeanI类型的bean，其中一个名叫simpleBeanI1，一个名叫simpleBeanI2：

<?xml version="1.0" encoding="UTF-8" ?>
    <beans
            xmlns="http://www.springframework.org/schema/beans"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
            xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    
    
        <context:annotation-config/>
    
        <bean id="simpleBeanH" class="com.xx.DI_demo.SimpleBeanH" ></bean>
    
        <bean id="simpleBeanI1" class="com.xx.DI_demo.SimpleBeanI" ></bean>
    
        <bean id="simpleBeanI2" class="com.xx.DI_demo.SimpleBeanI" ></bean>
    
    </beans>

SimpleBeanH 依赖于SimpleBeanI ，这里的属性名是simpleBeanI（容器中没有）

package com.xx.DI_demo;
    
    import org.springframework.beans.factory.annotation.Autowired;
    
    public class SimpleBeanH {
        
    
        // 注释属性不需要再提供setter方法
        @Autowired
        private SimpleBeanI simpleBeanI;
    
        public SimpleBeanH() {
        
        }
    
        public void doTest() {
        
            System.out.println("this is h -- " + this);
        }
    
        @Override
        public String toString() {
        
            return "SimpleBeanH{" +
                    "simpleBeanI=" + simpleBeanI +
                    '}';
        }
    }

测试类：

package com.xx.main;
    
    import com.xx.DI_demo.SimpleBeanA;
    import com.xx.DI_demo.SimpleBeanH;
    import org.springframework.context.support.AbstractApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test_DI_Autowire {
        
    
        public static void main(String[] args) {
        
    
            AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
    
            SimpleBeanH bean = context.getBean(SimpleBeanH.class);
    
            bean.doTest();
    
            context.registerShutdownHook();
        }
    }

运行结果：报错  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MjM4MTQy_size_16_color_FFFFFF_t_70]

修改Beans.xml，把其中的一个SimpleBeanI的bean的名字改为和SimpleBeanH中的属性名一致，使得byName装配正常执行：

this is h -- SimpleBeanH{simpleBeanI=com.xx.DI_demo.SimpleBeanI@60285225}

我们接下来介绍的注解@Qualifier就是专门来解决这个问题的。

## @Qualifier ##

可能会有这样一种情况，当你创建多个具有相同类型的 bean 时，并且想要用一个属性只为它们其中的一个进行装配，在这种情况下，你可以使用 @Qualifier 注释和 @Autowired 注释通过指定哪一个真正的 bean 将会被装配来消除混乱。

还是上面的例子，我们修改SimpleBeanH使用@Qualifier(“bean name”)的方法就可解决：

package com.xx.DI_demo;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    
    public class SimpleBeanH {
        
    
        // 注释属性不需要再提供setter方法
        @Autowired
        @Qualifier("simpleBeanI2")		// 注意这里
        private SimpleBeanI simpleBeanI;
    
        public SimpleBeanH() {
        
        }
    
        public void doTest() {
        
            System.out.println("this is h -- " + this);
        }
    
        @Override
        public String toString() {
        
            return "SimpleBeanH{" +
                    "simpleBeanI=" + simpleBeanI +
                    '}';
        }
    }

你也可以在Beans.xml中指定primary属性，容器会优先匹配它，也可以解决这个问题，但推荐使用上面的方法：

<?xml version="1.0" encoding="UTF-8" ?>
    <beans
            xmlns="http://www.springframework.org/schema/beans"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
            xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    
    
        <context:annotation-config/>
    
        <bean id="simpleBeanH" class="com.xx.DI_demo.SimpleBeanH" ></bean>
    	
    	
        <bean id="simpleBeanI" class="com.xx.DI_demo.SimpleBeanI" primary="true"></bean>
    
        <bean id="simpleBeanI2" class="com.xx.DI_demo.SimpleBeanI" ></bean>
    
    </beans>

## JSR-250 注释 ##

Spring还使用基于 JSR-250 注释，它包括 @PostConstruct， @PreDestroy 和 @Resource 注释。

@Resource注释的用法和@Autowired类似，你可以在字段中或者 setter 方法中使用 @Resource 注释，不同的是，它遵循的是byName的自动装配模式。

@PostConstruct 和 @PreDestroy 注释分别来替代我们初始化回调方法 init-method 和销毁回调方法 destroy-method。

示例：

package com.xx.helloworld
    
    import javax.annotation.*;
    
    public class HelloWorld {
        
       private String message;
       
       public void setMessage(String message){
        
          this.message  = message;
       }
       
       public String getMessage(){
        
          System.out.println("Your Message : " + message);
          return message;
       }
       
       @PostConstruct
       public void init(){
        
          System.out.println("Bean is going through init.");
       }
       
       @PreDestroy
       public void destroy(){
        
          System.out.println("Bean will destroy now.");
       }
    }

# Spring基于java的配置 #

如何使用 XML 配置文件来配置 Spring bean我们基本上已经掌握了，你可以使用基于java的配置完全的代替。

上篇博文已经提到了几个注释，比如@Configuration、@Bean、@Import 、 @Scope等等。

我们自己写一个基于java的配置来用一下它们，更详细的使用以后写：

*  配置类

package com.xx.config;
    
    import com.xx.DI_demo.SimpleBeanH;
    import com.xx.DI_demo.SimpleBeanI;
    import org.springframework.context.annotation.*;
    
    @Configuration      // 相当于<beans>
    @ComponentScan(basePackages = "com.xx")       // 启动组件扫描
    @Import(ServiceConfig.class)       // 引入别的配置，就可以引用其中的bean
    public class MyAppConfig {
        
    
        // 使用@Bean注解的方法相当于一个bean,bean的id|name就是方法名
        // 可以指定生命周期回调方法
        @Bean(initMethod = "myInit", destroyMethod = "myDestroy")
        public SimpleBeanH simpleBeanH() {
        
            // 使用有参构造方法，就相当于DI，通过这种方法表达beans之间的依赖性
            return new SimpleBeanH(simpleBeanI());
        }
    
        // SimpleBeanH类依赖于simpleBeanI
        @Bean
        @Scope("prototype")     //@Scope用来指定作用域
        public SimpleBeanI simpleBeanI() {
        
            return new SimpleBeanI();
        }
    
    }

*  SimpleBeanH

package com.xx.DI_demo;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    
    public class SimpleBeanH {
        
    	
        // 注释属性不需要再提供setter方法
        private SimpleBeanI simpleBeanI;
    
        public SimpleBeanH(SimpleBeanI simpleBeanI) {
        
            this.simpleBeanI = simpleBeanI;
        }
    
        public void doTest() {
        
            System.out.println("this is h -- " + this);
        }
    
        @Override
        public String toString() {
        
            return "SimpleBeanH{" +
                    "simpleBeanI=" + simpleBeanI +
                    '}';
        }
    
        private void myInit() {
        
            System.out.println("init...");
        }
    
        private void myDestroy() {
        
            System.out.println("myDestroy...");
        }
    }

*  测试类：

package com.xx.main;
    
    import com.xx.DI_demo.SimpleBeanH;
    import com.xx.config.MyAppConfig;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    public class Test_Annotation {
        
        public static void main(String[] args) {
        
    
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    
            // 加载配置，可以加载多个配置，与之类似
            context.register(MyAppConfig.class);
    
            context.refresh();
    
            SimpleBeanH bean = context.getBean(SimpleBeanH.class);
    
            bean.doTest();
          
        }
    }

*  运行结果

init...
    this is h -- SimpleBeanH{simpleBeanI=com.xx.DI_demo.SimpleBeanI@351d0846}
    myDestroy...

*  如果把bean的作用域设置为prototype（原型）那么关闭容器后不会调用销毁方法，因为此时容器并不会自动销毁这个bean的对象，而把它交给了开发者管理。练习时要注意。

[1]: https://www.w3cschool.cn/wkspring/
[_2]: https://docs.spring.io/spring/docs/current/spring-framework-reference/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MjM4MTQy_size_16_color_FFFFFF_t_70]: /images/20220122/da4a0a715e4347ffbabba676c3380212.png