spring 笔记简单概述

骑猪看日落 2022-05-16 09:29 168阅读 0赞

spring系列教程

[https://spring.io/docs/reference][https_spring.io_docs_reference]

![70][]

**Spring框架文档版本5.1.0.RC2**

[https://docs.spring.io/spring/docs/5.1.0.RC2/spring-framework-reference/][https_docs.spring.io_spring_docs_5.1.0.RC2_spring-framework-reference]

**这部分参考文档涵盖了Spring Framework绝对不可或缺的所有技术。 **

*主要涉及到 IOC 和  DI及bean  的注入和 一些注解 ，介绍的很详细 ，我后面的文章主要是参考这个，*

*ps 回过头来看发现自己写的很垃圾。大家最好参考 官方文档*

[https://docs.spring.io/spring/docs/5.1.0.RC2/spring-framework-reference/core.html\#spring-core][https_docs.spring.io_spring_docs_5.1.0.RC2_spring-framework-reference_core.html_spring-core]

**Spring Web MVC ** *讲的也很好  主要是映射那块和注解*

[https://docs.spring.io/spring/docs/5.1.0.RC2/spring-framework-reference/web.html\#spring-web][https_docs.spring.io_spring_docs_5.1.0.RC2_spring-framework-reference_web.html_spring-web]

**Spring Framework事务管理 ** *也很好讲到了 与jdbc hibernate 的集成*

[https://docs.spring.io/spring/docs/5.1.0.RC2/spring-framework-reference/data-access.html\#spring-data-tier][https_docs.spring.io_spring_docs_5.1.0.RC2_spring-framework-reference_data-access.html_spring-data-tier]

**这是4.3.18 的教程 ，是spring系列的集成**

[https://docs.spring.io/spring/docs/4.3.18.RELEASE/spring-framework-reference/htmlsingle/][https_docs.spring.io_spring_docs_4.3.18.RELEASE_spring-framework-reference_htmlsingle]

![70 1][]

# 1  什么是spring #

    Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架  
分层： 一站式，每一个层都提供的解决方案  
web层：struts，spring-MVC  
service层：spring  
dao层：hibernate，mybatis ， jdbcTemplate  --> spring-data

# 2 spring由来  #

Spring是java平台上的一个开源应用框架。它的第一个版本是由Rod Johnson写出来的

Rod在他的Expert One-On-One Java EE Design and Development(**Java****企业应用设计与开发的专家一对一**)一书中

首次发布了这个框架。

该框架也可以移植到.NET的环境下。

Spring的框架首次在2003年6月的Apache 2.0的使用许可中发布。

# 3 spring核心 #

Spring的核心是**控制反转（****IoC****）**和**面向切面（****AOP****）**

Spring 最认同的技术是控制反转的**依赖注入（****DI****）**模式。

**控制反转（****IoC****）是一个通用的概念，它可以用许多不同的方式去表达，依赖注入仅仅是控制反转的一个具体的例子。**

Spring 框架的一个关键组件是面向方面的程序设计（AOP）框架。

有各种各样常见的很好的关于方面的例子，比如日志记录、声明性事务、安全性，和缓存等等。

# 4  spring优点 #

1.  方便解耦，简化开发  （高内聚低耦合）
    
     *  Spring就是一个大工厂（容器），可以将所有对象创建和依赖关系维护，交给Spring管理
     *  spring工厂是用于生成bean
2.  AOP编程的支持
    
     *  Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
3.  声明式事务的支持
    
     *  只需要通过配置就可以完成对事务的管理，而无需手动编程
4.  方便程序的测试
    
     *  Spring对Junit4支持，可以通过注解方便的测试Spring程序
5.  方便集成各种优秀框架
    
     *  Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持
6.  降低JavaEE API的使用难度
    
     *  Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低

# 5 spring体系结构  #

![70 2][]

**核心容器：beans****、core****、context****、SpringExpression**

**核心容器：**

核心容器提供 Spring 框架的基本功能。

核心容器的主要组件是 **BeanFactory**，它是工厂模式的实现。

BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开

。

#  6 入门案例：IoC #

**1****、创建源文件**

**2****、创建 bean** **的配置文件  ** **只能配置可实例化的类，不能配置接口和抽象类**

你需要创建一个 Bean 的配置文件，该文件是一个 XML 文件，并且作为粘合 bean 的粘合剂即类。这个文件需要在 **src** 目录下创建

Beans.xml 用于给不同的 bean 分配唯一的 ID，并且控制不同值的对象的创建，而不会影响 Spring 的任何源文件。

当 Spring 应用程序被加载到内存中时，框架利用了上面的配置文件来创建所有已经定义的 beans，并且按照 标签的定义为它们分配一个唯一的 ID。你可以使用 标签来传递在创建对象时使用不同变量的值。

**3****、运行程序**

*  第一步是我们使用框架 API **ClassPathXmlApplicationContext()** 来创建应用程序的上下文。

这个 API 加载 beans 的配置文件并最终基于所提供的 API，它处理创建并初始化所有的对象，即在配置文件中提到的 beans。

*  第二步是使用已创建的上下文的 **getBean()**** **方法来获得所需的 bean。这个方法使用 bean 的 ID 返回一个最终可以转换为实际对象的通用对象。一旦有了对象，你就可以使用这个对象调用任何类的方法。

##  6.1  导入jar 包 ##

4 + 1  ： 4个核心（beans、core、context、expression） + 1个依赖（commons-loggins...jar）

![70 3][]

![70 4][]

## 6.2 接口+目标类 ##

1.  提供UserService接口和实现类
2.  获得UserService实现类的实例

之前开发中，直接new一个对象即可。

学习spring之后，**将由****Spring****创建对象实例\--> IoC** **控制反转（Inverse of  Control****）**

之后需要实例对象时，从spring工厂（容器）中获得，需要将实现类的全限定名称配置到xml文件中

**UserService****接口**

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> public interface UserService { &nbsp;&nbsp; public void addUser(); } </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> UserService实现类 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> public class UserServiceImpl implements UserService { &nbsp;&nbsp; @Override &nbsp;&nbsp; public void addUser() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("a_ico add user"); &nbsp;&nbsp; } } </td> 
 </tr> 
 </tbody> 
</table>

## 6.3 配置文件  ##

1.  位置：任意，开发中一般在classpath下（src）
2.  名称：任意，beans.xml开发中常用applicationContext.xml
3.  内容：添加schema约束

约束文件位置：spring-framework-3.2.0.RELEASE\\docs\\spring-framework-reference\\html\\ **xsd-config.html**

![70 5][]

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; xsi:schemaLocation="http://www.springframework.org/schema/beans &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;http://www.springframework.org/schema/beans/spring-beans.xsd"&gt; &nbsp;&nbsp;&nbsp; &lt;!-- 配置service &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;bean&gt; 配置需要创建的对象 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; id ：用于之后从spring容器获得实例时使用的 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; class ：需要创建实例的全限定类名 &nbsp;&nbsp;&nbsp; --&gt; &nbsp;&nbsp;&nbsp; &lt;bean id="userServiceId" class="domain.UserServiceImpl"&gt;&lt;/bean&gt;//包名.类名 &lt;/beans&gt; </td> 
 </tr> 
 </tbody> 
</table>

问题

The constructor ClassPathXmlApplicationContext(String) refers to the missing type

1） 这是指该构造函数缺少了BeanException异常包。

The constructor ClassPathXmlApplicationContext(String) refers to the missing type BeanException;

所以我们添加了org.springframework.beans-3.0.4.RELEASE.jar注：其中context包依赖beans包。

##  6.4 测试 ##

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> @Test &nbsp;&nbsp;&nbsp; public void demo02(){ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; //从spring容器获得 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; //1 获得容器 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“beans.xml”); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; //2获得内容 --不需要自己new，都是从spring容器获得 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; UserService userService = (UserService) applicationContext.getBean("userServiceId"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; userService.addUser(); &nbsp;&nbsp;&nbsp; } </td> 
 </tr> 
 </tbody> 
</table>

# 7   spring IoC 容器 #

**Spring** **容器是** **Spring** **框架的核心**

容器将创建对象，把它们连接在一起，配置它们，并管理他们的整个生命周期从创建到销毁。

**Spring** **容器使用依赖注入（****DI****）来管理组成一个应用程序的组件**。这些对象被称为 Spring Beans

通过阅读配置元数据提供的指令，容器知道对哪些对象进行实例化，配置和组装。

配置元数据可以通过 XML，Java 注释或 Java 代码来表示。

下图是 Spring 如何工作的高级视图。

**Spring IoC** **容器利用** **Java** **的** **POJO** **类和配置元数据来生成完全配置和可执行的系统或应用程序。**

![70 6][]

## 7.1 核心api ##

api整体了解，之后不使用，在学习过程需要

![70 7][]

1.  BeanFactory ：这是一个工厂，用于生成任意bean。

采取延迟加载，第一次getBean时才会初始化Bean

1.  **ApplicationContext**：是BeanFactory的子接口，功能更强大。（国际化处理、事件传递、Bean自动装配、各种不同应用层的Context实现）。当配置文件被加载，就进行对象实例化。

ApplicationContext 包含 BeanFactory 所有的功能，一般情况下，相对于 BeanFactory，ApplicationContext 会被推荐使用。

1.  **WebXmlApplicationContext**

**ClassPathXmlApplicationContex**t 用于加载classpath（类路径、src）下的xml

加载xml运行时位置 --> /WEB-INF/classes/...xml

**FileSystemXmlApplicationContext** 用于加载指定盘符下的xml

加载xml运行时位置 --> /WEB-INF/...xml

通过java web ServletContext.getRealPath() 获得具体盘符

ApplicationContext context = new FileSystemXmlApplicationContext ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml");

# 8 bean  #

## 8.1 bean 定义 ##

被称作 bean 的对象是构成应用程序的支柱也是由 Spring IoC 容器管理的。

bean 是一个被**实例化**，组装，并通过 Spring IoC 容器所管理的对象。

这些 bean 是由用容器提供的配置元数据创建的，bean 定义包含称为配置元数据的信息，

## 8.2 bean元素id和name属性的区别 ##

在spring容器中添加以下配置：

bean节点中Id和name的区别：

1. 区别一：
 
 1. id:指定唯一实例引用
 2. name:可以指定多个实例引用，例如name=“名称1,名称2”
2. 区别二：
 
 1. id ：id的命名要满足XML对ID属性命名规范
 
 1. 例如：必须以字母开始，可以使用字母、数字、连字符、下划线、句话、冒号
 2. name:如果Bean的名称中含有特殊字符，就需要使用name属性
 
 1. 例如：<bean name="\# boy " class="cn.itcast.ioc.Boy"/>
 2. 因为name属性可以相同，所以后出现Bean会覆盖之前出现的同名的Bean

总结：项目开发的时候，**强烈要求用****id**，因为id可以表示惟一引用。

## 8.3 bean作用域 ##

当在 Spring 中定义一个 bean 时，你必须声明该 bean 的作用域的选项。

Spring 框架支持以下五个作用域，

如果你使用 web-aware ApplicationContext 时，其中三个是可用的。

![70 8][]

1.  作用域：用于确定spring创建bean实例个数
2.  取值：

singleton 单例，默认值。

**prototype** 多例，每执行一次getBean将获得一个实例。例如：struts整合spring，配置action多例。

1.  配置信息

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> &lt;bean id="" class=""&nbsp; scope=""&gt; </td> 
 </tr> 
 </tbody> 
</table>

![70 9][]

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> &lt;bean id="userServiceId" class="com.scope.UserServiceImpl" &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; scope="prototype" &gt;&lt;/bean&gt; </td> 
 </tr> 
 </tbody> 
</table>

### 8.3.1 singleton 作用域 ###

如果作用域设置为 singleton，那么 Spring IoC 容器刚好创建一个由该 bean 定义的对象的实例。

该单一实例将存储在这种单例 bean 的高速缓存中，以及针对该 bean 的所有后续的请求和引用都返回缓存对象。

**默认作用域是始终是** **singleton****，**

但是当仅仅需要 bean 的一个实例时，你可以在 bean 的配置文件中设置作用域的属性为 singleton，如下所示：

<**bean** id="..." class="..." scope="singleton">

</**bean**>

### 8.3.2 prototype 作用域 ###

如果作用域设置为 prototype，

那么每次特定的 bean 发出请求时 Spring IoC 容器就创建对象的新的 Bean 实例。

一般说来，满状态的 bean 使用 prototype 作用域和没有状态的 bean 使用 singleton 作用域。

# 9 Bean 生命周期 #

理解 Spring bean 的生命周期很容易。

当一个 bean 被实例化时，它可能需要执行一些初始化使它转换成可用状态。

同样，当 bean 不再需要，并且从容器中移除时，可能需要做一些清除工作。

为了定义安装和拆卸一个 bean，我们只要声明带有**init-method** 和/或 **destroy-method** 参数。

init-method 属性指定一个方法，在实例化 bean 时，立即调用该方法。

同样，destroy-method 指定一个方法，只有从容器中移除 bean 之后，才能调用该方法。

## 9.1 初始化回调 ##

**第一种：***org.springframework.beans.factory.InitializingBean* 接口指定一个单一的方法：

void afterPropertiesSet() throws Exception;

因此，你可以简单地实现上述接口和初始化工作可以在afterPropertiesSet() 方法中执行，如下所示：

public class ExampleBean implements InitializingBean {   public void afterPropertiesSet() { 
    // do some initialization work }}

初始化在构造方法之后

**第二种：在基于 XML 的配置元数据的情况下，你可以使用 init-method 属性来指定带有 void 无参数方法的名称。**

例如：

下面是类的定义：

public class ExampleBean {    public void init() {       // do some initialization work   }}

如果同时配置上面两种，顺序为构造---》接口---》xml配置

## 9.2  销毁回调 ##

**第一种 *org.springframework.beans.factory.DisposableBean* 接口指定一个单一的方法：**

void destroy() throws Exception;

因此，你可以简单地实现上述接口并且结束工作可以在 destroy() 方法中执行，如下所示：

public class ExampleBean implements DisposableBean {
       public void destroy() {
          // do some destruction work
       }
    }

**第二种 在基于 XML 的配置元数据的情况下，你可以使用 destroy-method 属性来指定带有 void 无参数方法的名称。例如：**

下面是类的定义

public class ExampleBean {
       public void destroy() {
          // do some destruction work
       }
    }

如果你在非 web 应用程序环境中使用 Spring 的 IoC 容器；

例如在丰富的客户端桌面环境中；那么在 JVM 中你要注册关闭 hook。这样做可以确保正常关闭，为了让所有的资源都被释放，可以在单个 beans 上调用 destroy 方法。

建议你不要使用 InitializingBean 或者 DisposableBean 的回调方法，因为 XML 配置在命名方法上提供了极大的灵活性。

## 9.3 实例 ##

**这里是 HelloWorld.java 的文件的内容：**

package com.tutorialspoint;
    
    public class HelloWorld {
       private String message;
    
       public void setMessage(String message){
          this.message  = message;
       }
       public void getMessage(){
          System.out.println("Your Message : " + message);
       }
       public void init(){
          System.out.println("Bean is going through init.");
       }
       public void destroy(){
          System.out.println("Bean will destroy now.");
       }
    }

**下面是 MainApp.java 文件的内容。**  
在这里，你需要注册一个在 AbstractApplicationContext 类中声明的关闭 hook 的 registerShutdownHook() 方法。它将确保正常关闭，并且调用相关的 destroy 方法。

package com.tutorialspoint;
    import org.springframework.context.support.AbstractApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class MainApp {
       public static void main(String[] args) {
          AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
          HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
          obj.getMessage();
          context.registerShutdownHook();
       }
    }

**下面是 init 和 destroy 方法必需的配置文件 Beans.xml 文件：**

一旦你创建源代码和 bean 配置文件完成后，我们就可以运行该应用程序。如果你的应用程序一切都正常，将输出以下信息：  
Bean is going through init.  
Your Message : Hello World!  
Bean will destroy now.

如果两种同时配置，接口优先级大于xml配置

## 9.4  默认的初始化和销毁方法 ##

如果你有太多具有相同名称的初始化或者销毁方法的 Bean，那么你不需要在每一个bean中配置。

框架使用 元素中的 **default-init-method** 和 **default-destroy-method** 属性提供了灵活地配置这种情况，如下所示：

<**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-3.0.xsd"

** ****default-init-method****=****"init"**

**default-destroy-method****=****"destroy"**>

`  `<**bean** id="..." class="...">

`      `

`  `</**bean**>

</**beans**>

# 10 Bean 后置处理器 #

**BeanPostProcessor** 接口定义回调方法，你可以实现该方法来提供自己的实例化逻辑，依赖解析逻辑等。

你也可以在 Spring 容器通过插入一个或多个 BeanPostProcessor 的实现来完成实例化，配置和初始化一个bean之后实现一些自定义逻辑回调方法。

你可以配置多个 BeanPostProcesso r接口，通过设置 BeanPostProcessor 实现的 **Ordered** 接口提供的**order** 属性来控制这些 BeanPostProcessor 接口的执行顺序。

BeanPostProcessor 可以对 bean（或对象）实例进行操作，这意味着 Spring IoC 容器实例化一个 bean 实例，然后 BeanPostProcessor 接口进行它们的工作。

**ApplicationContext** 会自动检测由 **BeanPostProcessor** 接口的实现定义的 bean，**注册这些** **bean** **为后置处理器**，**然后通过在容器中创建** **bean****，在适当的时候调用它。**

这里是 **HelloWorld.java**** **文件的内容：

package com.tutorialspoint;
    public class HelloWorld {
       private String message;
       public void setMessage(String message){
          this.message  = message;
       }
       public void getMessage(){
          System.out.println("Your Message : " + message);
       }
       public void init(){
          System.out.println("Bean is going through init.");
       }
       public void destroy(){
          System.out.println("Bean will destroy now.");
       }
    }

这是实现 BeanPostProcessor 的非常简单的例子，它在**任何** **bean** **的初始化的之前和之后输入该 bean** **的名称**。

你可以在初始化 bean 的之前和之后实现更复杂的逻辑，因为你有两个访问内置 bean 对象的后置处理程序的方法。

这里是 **InitHelloWorld.java** 文件的内容：

package com.tutorialspoint;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    import org.springframework.beans.BeansException;
    public class InitHelloWorld implements BeanPostProcessor {
       public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
          System.out.println("BeforeInitialization : " + beanName);
          return bean;  // you can return any other object as well
       }
       public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
          System.out.println("AfterInitialization : " + beanName);
          return bean;  // you can return any other object as well
       }
    }

下面是 **MainApp.java** 文件的内容。在这里，你需要注册一个在 AbstractApplicationContext 类中声明的关闭 hook 的 **registerShutdownHook()** 方法。它将确保正常关闭，并且调用相关的 destroy 方法。

package com.tutorialspoint;
    import org.springframework.context.support.AbstractApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class MainApp {
       public static void main(String[] args) {
          AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
          HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
          obj.getMessage();
          context.registerShutdownHook();
       }
    }

下面是 init 和 destroy 方法需要的配置文件 **Beans.xml** 文件：

将后处理的实现类注册给spring

一旦你创建源代码和 bean 配置文件完成后，我们就可以运行该应用程序。如果你的应用程序一切都正常，将输出以下信息：

`BeforeInitialization``: helloWorld`

`Bean`**is**`going through``init``.`

`AfterInitialization``: helloWorld`

`Your Message : Hello World!`

`Bean will destroy now.`

**Bean****后置处理器执行在bean****的初始化最前后****，即构造之后（紧挨），不是销毁之后**

问题1：后处理bean作用某一个目标类，还是所有目标类？

所有

问题2：如何只作用一个？

通过“参数2”beanName进行控制

# 11 Bean 定义继承 #

bean 定义可以包含很多的配置信息，包括构造函数的参数，属性值，容器的具体信息例如初始化方法，静态工厂方法名，等等。

子 bean 的定义继承父定义的配置数据。子定义可以根据需要重写一些值，或者添加其他值。

Spring Bean 定义的继承与 Java 类的继承无关，但是继承的概念是一样的。你可以定义一个父 bean 的定义作为模板和其他子 bean 就可以从父 bean 中继承所需的配置。

当你使用基于 XML 的配置元数据时，**通过使用父属性，指定父** **bean** **作为该属性的值来表明子** **bean** **的定义。**

下面是配置文件 **Beans.xml**，在该配置文件中我们定义有两个属性 *message1* 和 *message2* 的 “helloWorld” bean。然后，使用 **parent** 属性把 “helloIndia” bean 定义为 “helloWorld” bean 的孩子。这个子 bean 继承 *message2* 的属性，重写 *message1* 的属性，并且引入一个属性 *message3*。

**Bean 定义模板**

你可以创建一个 Bean 定义模板，不需要花太多功夫它就可以被其他子 bean 定义使用。

在定义一个 Bean 定义模板时，你不应该指定**类**的属性，而应该指定带 **true** 值的**抽象**属性，如下所示：

父 bean 自身不能被实例化，因为它是不完整的，而且它也被明确地标记为抽象的。

当一个定义是抽象的，它仅仅作为一个纯粹的模板 bean 定义来使用的，充当子定义的父定义使用。

# 12 装配Bean和属性依赖注入 #

## 12.1 使用构造方法实例化 ##

1.  在spring容器中配置

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" &nbsp;&nbsp; &nbsp;&nbsp; xmlns:p="http://www.springframework.org/schema/p" &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"&gt; &nbsp;&nbsp; &lt;!--2&nbsp; 第一种方式 默认构造 --&gt; &nbsp;&nbsp; &lt;bean id="demo1User" class="cn.demo1.User"&gt;&lt;/bean&gt; &lt;/beans&gt; </td> 
 </tr> 
 </tbody> 
</table>

1.  测试

1.  对比

相当于：User user = new User(); //直接创建实例

先简单说下后面详解

## 12.2 使用静态工程方法实例化 ##

不用指定factorybean**直接用class****指定静态工厂类**

定义使用静态工厂方法创建的bean时，您可以使用该`class` 属性来指定包含`static`工厂方法的类和一个`factory-method`指定工厂方法名称的属性。

1.  在spring容器中配置

<table style="margin-left:21pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" &nbsp;&nbsp; &nbsp;&nbsp; xmlns:p="http://www.springframework.org/schema/p" &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"&gt; &nbsp; &nbsp;&nbsp; &lt;!-- 第二种方式 静态工厂方法 ， 没有工厂的实例对象--&gt; &nbsp;&nbsp; &lt;bean id="demo2User" class="cn.demo2.Demo2BeanFactory" factory-method="getDemo2Bean"&gt;&lt;/bean&gt; &nbsp;&nbsp; &lt;/beans&gt; </td> 
 </tr> 
 </tbody> 
</table>

1.  提供工厂类

<table style="margin-left:21pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> package cn.demo2; public class Demo2BeanFactory { &nbsp;&nbsp; public Demo2BeanFactory(){ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("demo2 不执行"); &nbsp;&nbsp; } &nbsp;&nbsp; /** &nbsp;&nbsp; &nbsp;* 必须提供 static方法 &nbsp;&nbsp; &nbsp;* @return &nbsp;&nbsp; &nbsp;*/ &nbsp;&nbsp; public static User getDemo2Bean(){ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return new User(); &nbsp;&nbsp; } } </td> 
 </tr> 
 </tbody> 
</table>

1.  测试

<table style="margin-left:21pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> public static void main(String[] args) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; User user = (User)applicationContext.getBean("demo2User"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println(user); &nbsp;&nbsp; } </td> 
 </tr> 
 </tbody> 
</table>

1.  对比

相当于： User user = BeanFatory.getUserBean();      //通过工厂的静态方法获得需要的内容

## 12.3 使用实例工程方法 ##

与通过静态工厂方法的实例化类似，使用实例工厂方法实例化从容器调用现有bean的非静态方法来创建新bean。要使用此机制，请将该`class`属性保留为空，并在`factory-bean`属性中指定包含要调用以创建对象的实例方法的当前（或父/祖先）容器中的bean的名称。

使用`factory-method`属性设置工厂方法本身的名称。

一个工厂类也可以持有多种工厂方法，如下所示：

<bean  id = “serviceLocator”  class = “examples.DefaultServiceLocator” > 
     <！ - 注入此定位器bean所需的任何依赖关系 - > 
 </ bean>
 
 “bean  id = ”clientService“ 
     factory-bean = ”serviceLocator“ 
     factory-method = ”createClientServiceInstance“ />
 
 <bean  id = “accountService” 
     factory-bean = “serviceLocator” 
     factory-method = “createAccountServiceInstance” />

public  class DefaultServiceLocator {
    
        private  static ClientService clientService = new ClientServiceImpl（）;
        private  static AccountService accountService = new AccountServiceImpl（）;
    
        private DefaultServiceLocator（）{}
    
        public ClientService createClientServiceInstance（）{
             return clientService;
        }
    
        public AccountService createAccountServiceInstance（）{
             return accountService;
        }
    
    }

这种方法表明工厂bean本身可以通过依赖注入（DI）进行管理和配置。

在Spring文档中，*工厂**bean*是指在Spring容器中配置的bean，它将通过实例或 静态工厂方法创建对象 。相比之下， `FactoryBean`（注意大写）是指Spring特定的 `FactoryBean`。

**第二个例子**

1.  在Spring容器的配置

<table style="margin-left:21pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" &nbsp;&nbsp; &nbsp;&nbsp; xmlns:p="http://www.springframework.org/schema/p" &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"&gt; &nbsp;&nbsp; &lt;!-- 第三种方式 实例工厂方法 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; * 先实例工厂 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; * 通过实例工厂执行具体的方法 &nbsp;&nbsp; &nbsp;--&gt; &nbsp;&nbsp; &lt;bean id="demo3BeanFactory" class="cn.demo3.Demo3BeanFactory"&gt;&lt;/bean&gt; &nbsp;&nbsp; &lt;bean id="demo3User" factory-bean="demo3BeanFactory" factory-method="getDemo2Bean"&gt;&lt;/bean&gt; &lt;/beans&gt; </td> 
 </tr> 
 </tbody> 
</table>

1.  提供工厂类

<table style="margin-left:21pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> package cn.demo3; public class Demo3BeanFactory { &nbsp;&nbsp; &nbsp;&nbsp; public Demo3BeanFactory(){ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; //System.out.println("demo3 执行"); &nbsp;&nbsp; } &nbsp; &nbsp;&nbsp; /** &nbsp;&nbsp; &nbsp;* 非静态方法 &nbsp;&nbsp; &nbsp;* @return &nbsp;&nbsp; &nbsp;*/ &nbsp;&nbsp; public User getDemo2Bean(){ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return new User(); &nbsp;&nbsp; } &nbsp; } </td> 
 </tr> 
 </tbody> 
</table>

1.  测试

<table style="margin-left:21pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> &nbsp;&nbsp; public static void main(String[] args) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; User user = (User)applicationContext.getBean("demo3User"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println(user); &nbsp;&nbsp; } </td> 
 </tr> 
 </tbody> 
</table>

1.  对比

相当于：

BeanFactory factory = new BeanFactory();          //先创建工厂

User user = factory.getUserBean();                     //在通过工厂的实例对象，执行非静态方法获得具体内容

## 12.3  Bean种类 ##

**普通bean**：之前操作的都是普通bean。<bean id="" class="A"> ，spring直接创建A实例，并返回

**bean****工厂**：不是bean，在spring中一般指的是DefaultListableBeanFactory对象，管理和维护spring中所有的bean

**工厂bean(自己可以创建)**：一种特殊的bean，在xml文件中配置的，用来生成新的bean的加工厂，通过getObject()方法可以获取其生产的新bean，如果想获取该工厂bean本身，需要使用类似于getBean("&" + beanName)的样式。

## 12.4 依赖注入 ##

*依赖注入*（DI）是一个过程，

容器在创建bean时*注入*这些依赖项。这个过程基本上是反向的，

通过DI原理，代码更清晰，当对象具有依赖关系时，解耦更有效。对象不查找其依赖关系，并且不知道依赖关系的位置或类。因此，您的类变得更容易测试，特别是当依赖关系在接口或抽象基类上时，允许在单元测试中使用存根或模拟实现。

DI存在两种主要的变体：基于构造函数的依赖注入和基于Setter的依赖注入。

### 12.4.1 基于构造函数的依赖注入 ###

**私有化属性并在构造中初始化属性**

public class SimpleMovieLister {
        // the SimpleMovieLister has a dependency on a MovieFinder
        private MovieFinder movieFinder;
        // a constructor so that the Spring container can inject a MovieFinder
        public SimpleMovieLister(MovieFinder movieFinder) {
            this.movieFinder = movieFinder;
        }
        // business logic that actually uses the injected MovieFinder is omitted...
    }

** 构造函数参数解析:**

使用参数的类型进行构造函数参数解析匹配。如果在bean定义的构造函数参数中不存在潜在的歧义，那么在bean定义中定义构造函数参数的顺序就是当bean被实例化时这些参数被提供给适当构造函数的顺序。

package x.y;
    public class Foo {
        public Foo(Bar bar, Baz baz) {
            // ...
        }
    }

没有潜在的歧义存在，假设`Bar`和`Baz`类与继承无关。因此，以下配置工作正常，您不需要在`<constructor-arg/>` 元素中明确指定构造函数参数索引和/或类型。

bean> 
 <bean id = “foo” class = “xyFoo” > 
 <constructor-arg ref = “bar” /> 
 <constructor-arg ref = “baz” /> 
 </ bean>
 <bean id = “bar” class = “xyBar” />
 <bean id = “baz” class = “xyBaz” /> 
 </ beans>

当引用另一个bean时，该类型是已知的，并且可以进行匹配（如前面的示例所示）。

当使用简单类型时，例如 `<value>true</value>`，Spring无法确定值的类型，因此无法通过类型匹配，无需帮助。考虑下面的类：

package examples;
    
    public class ExampleBean {
        // Number of years to calculate the Ultimate Answer
        private int years;
        // The Answer to Life, the Universe, and Everything
        private String ultimateAnswer;
        public ExampleBean(int years, String ultimateAnswer) {
            this.years = years;
            this.ultimateAnswer = ultimateAnswer;
        }
    }

在上述情况下，如果使用该属性显式指定构造函数参数的类型，则容器*可以*使用与简单类型匹配的类型`type`

使用该`index`属性来明确指定构造函数参数的索引

除了解决多个简单值的歧义之外，指定索引会解析构造函数具有两个相同类型参数的歧义。请注意， *索引为**0*。

您还可以使用构造函数参数名称进行值消除歧义：

请记住，为了使这项工作成功，您的代码必须在启用调试标志的情况下进行编译，以便Spring可以从构造函数中查找参数名称。如果您无法使用调试标志（或不想）编译代码，则可以使用 [@ConstructorProperties][ConstructorProperties] JDK注释来明确命名构造函数参数。然后样本类必须如下所示：

package examples;
    
    public class ExampleBean {
        // Fields omitted
        @ConstructorProperties({"years", "ultimateAnswer"})
        public ExampleBean(int years, String ultimateAnswer) {
            this.years = years;
            this.ultimateAnswer = ultimateAnswer;
        }
    }

**最后，如果你想要向一个对象传递一个引用，你需要使用** **标签的**** ****ref**** ****属性，**

**如果你想要直接传递值，那么你应该使用如上所示的**** ****value**** ****属性。**

### 12.4.2 基于设值函数的依赖注入 ###

**私有属性，需要提供注入属性的set****方法，、get****方法不是必须(****尽量有)**

当容器调用一个无参的构造函数或一个无参的静态 factory 方法来初始化你的 bean 后，

通过**容器**在你的 bean 上调用设值函数，基于设值函数的 DI 就完成了。

*基于**Setter**的* DI通过在调用无参数构造函数或无参数`static`工厂方法来实例化bean之后，通过容器调用bean的setter方法来实现。

以下示例显示一个只能使用纯setter注入进行依赖注入的类。这个类是常规Java。它是一个POJO，它不依赖容器特定的接口，基类或注释。

public class SimpleMovieLister {
        // the SimpleMovieLister has a dependency on the MovieFinder
        private MovieFinder movieFinder;
        // a setter method so that the Spring container can inject a MovieFinder
        public void setMovieFinder(MovieFinder movieFinder) {
            this.movieFinder = movieFinder;
        }
        // business logic that actually uses the injected MovieFinder is omitted...
    }

在这里，你需要检查设值函数方法的名称转换。

要设置一个变量 **spellChecker**，我们使用**setSpellChecker()** 方法，该方法与 Java POJO 类非常相似

<!-- setter方法注入

\* 普通数据

<property name="" value="值"> name需要与属性名一致

等效

<value>值

\* 引用数据

等效

### 12.4.3 区别 ###

你应该注意定义在基于构造函数注入和基于设值函数注入中的 Beans.xml 文件的区别。

唯一的区别就是在基于构造函数注入中，我们使用的是 标签**constructor-arg**中的 元素，

而在基于设值函数的注入中，我们使用的是 标签**property**中的 元素。

第二个你需要注意的点是，如果你要把一个引用传递给一个对象，那么你需要使用 标签的 **ref** 属性，而如果你要直接传递一个值，那么你应该使用 **value** 属性。

## 12.5  注入内部bean ##

**注入内部** **Beans**

正如你所知道的 Java 内部类是在其他类的范围内被定义的，

同理，**inner beans** 是在其他 bean 的范围内定义的 bean。因此在 或 元素内 元素被称为**内部****bean**，如下所示。

这里是 **TextEditor.java** 文件的内容：

package com.tutorialspoint;
    public class TextEditor {
       private SpellChecker spellChecker;
       // a setter method to inject the dependency.
       public void setSpellChecker(SpellChecker spellChecker) {
          System.out.println("Inside setSpellChecker." );
          this.spellChecker = spellChecker;
       }  
       // a getter method to return spellChecker
       public SpellChecker getSpellChecker() {
          return spellChecker;
       }
       public void spellCheck() {
          spellChecker.checkSpelling();
       }
    }

下面是另一个依赖的类文件 **SpellChecker.java** 内容：

package com.tutorialspoint;
    public class SpellChecker {
       public SpellChecker(){
          System.out.println("Inside SpellChecker constructor." );
       }
       public void checkSpelling(){
          System.out.println("Inside checkSpelling." );
       }   
    }

下面是 **MainApp.java** 文件的内容：

package com.tutorialspoint;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class MainApp {
       public static void main(String[] args) {
          ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
          TextEditor te = (TextEditor) context.getBean("textEditor");
          te.spellCheck();
       }
    }

下面是使用**内部** **bean** 为基于 setter 注入进行配置的配置文件 **Beans.xml** 文件：

一旦你创建源代码和 bean 配置文件完成后，我们就可以运行该应用程序。如果你的应用程序一切都正常，将输出以下信息：

## 12.6 注入集合 ##

### 12.6.1 ###

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:521pt;"> &lt;!-- &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 集合的注入都是给&lt;property&gt;添加子标签 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 数组：&lt;array&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; List：&lt;list&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Set：&lt;set&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Map：&lt;map&gt; ，map存放k/v 键值对，使用&lt;entry&gt;描述 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Properties：&lt;props&gt;&nbsp; &lt;prop key=""&gt;&lt;/prop&gt;&nbsp; 【】 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 普通数据：&lt;value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 引用数据：&lt;ref&gt; &nbsp;&nbsp;&nbsp; --&gt; &nbsp;&nbsp;&nbsp; &lt;bean id="collDataId" class="" &gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;property name="arrayData"&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;array&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;value&gt;DS&lt;/value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;value&gt;DZD&lt;/value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;value&gt;屌丝&lt;/value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;value&gt;屌中屌&lt;/value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/array&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/property&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;property name="listData"&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;list&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;value&gt;于嵩楠&lt;/value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;value&gt;曾卫&lt;/value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;value&gt;杨煜&lt;/value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;value&gt;曾小贤&lt;/value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/list&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/property&gt; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;property name="setData"&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;set&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;value&gt;停封&lt;/value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;value&gt;薄纸&lt;/value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;value&gt;关系&lt;/value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/set&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/property&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;property name="mapData"&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;map&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;entry key="jack" value="杰克"&gt;&lt;/entry&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;entry&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;key&gt;&lt;value&gt;rose&lt;/value&gt;&lt;/key&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;value&gt;肉丝&lt;/value&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/entry&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/map&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/property&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;property name="propsData"&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;props&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;prop key="高富帅"&gt;嫐&lt;/prop&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;prop key="白富美"&gt;嬲&lt;/prop&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;prop key="男屌丝"&gt;挊&lt;/prop&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/props&gt; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/property&gt; &nbsp;&nbsp;&nbsp; &lt;/bean&gt; </td> 
 </tr> 
 </tbody> 
</table>

### 12.6.2注入 Bean 引用作为集合元素 ###

下面的 Bean 定义将帮助你理解如何注入 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"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 
 <bean id="..." class="...">
 
 <property name="addressList">
 <list>
 <ref bean="address1"/>
 <ref bean="address2"/>
 <value>Pakistan</value>
 </list>
 </property>
 
 <property name="addressSet">
 <set>
 <ref bean="address1"/>
 <ref bean="address2"/>
 <value>Pakistan</value>
 </set>
 </property>
 
 <property name="addressMap">
 <map>
 <entry key="one" value="INDIA"/>
 <entry key ="two" value-ref="address1"/>
 <entry key ="three" value-ref="address2"/>
 </map>
 </property>
 </bean>
 </beans>

为了使用上面的 bean 定义，你需要定义 setter 方法，它们应该也能够是用这种方式来处理引用。

## 12.7   注入 null 和空字符串的值 ##

如果你需要传递一个空字符串作为值，那么你可以传递它，如下所示：

前面的例子相当于 Java 代码：exampleBean.setEmail("")。

如果你需要传递一个 NULL 值，那么你可以传递它，如下所示：

前面的例子相当于 Java 代码：exampleBean.setEmail(null)。

![70 10][]

## 12.9 使用依赖 ##

如果一个bean是另一个bean的依赖，通常意味着一个bean被设置为另一个的属性。通常，您可以使用基于XML的配置元数据中的`<ref/>` 元素来实现此目的。

但是，有时bean之间的依赖关系较少; 例如，需要触发类中的静态初始化器，例如**数据库驱动程序注册**。

在`depends-on`使用此元素的bean初始化之前，该属性可以显式强制一个或多个bean进行初始化。

以下示例使用该`depends-on`属性来表示对单个bean的依赖关系：

要表示对多个bean的依赖，请提供一个bean名称列表作为`depends-on`属性的值，并使用逗号，空格和分号作为有效的分隔符：

## 12.10 Lazy初始化的bean ##

默认情况下，`ApplicationContext`实现在初始化过程的一部分中热切地创建和配置所有 单例 bean。通常，这种预实例化是可取的，因为配置或周围环境中的错误被立即发现，而不是几个小时甚至几天。当发生这种情况是*不*理想的，你可以通过标记bean定义为延迟初始化，防止单豆的预实例化。一个lazy初始化的bean告诉IoC容器在首次请求时创建一个bean实例，而不是在启动时。

在XML中，此行为由 元素`lazy-init`上的属性控制`<bean/>`; 例如：

“bean  id = ”lazy“  class = ”com.foo.ExpensiveToCreateBean“  lazy-init = ”true“ /> 
 <bean  name = ”not.lazy“  class = ”com.foo.AnotherBean“ />

当前面的配置被一个消耗时`ApplicationContext`，命名的bean `lazy`在`ApplicationContext`启动时不会被预先实例化，而`not.lazy`bean是热切地预先实例化的。

**但是，当一个惰性初始化的****bean****是一个*不被*惰性初始化的单例****bean****的依赖项时**** ****，它**`ApplicationContext`**会在启动时创建懒惰初始化的****bean****，因为它必须满足单例的依赖性****。**

lazy初始化的bean被注入到其他不是懒惰初始化的单例bean中。

您还可以通过使用元素`default-lazy-init`上的属性来控制容器级别的延迟初始化 `<beans/>`; 例如：

# 13 bean自动装配 #

下列自动装配模式，它们可用于指示 Spring 容器为来使用自动装配进行依赖注入。

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

<table style="width:524.25pt;"> 
 <tbody> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;width:123.75pt;"> 模式 </td> 
 <td style="background-color:#ffffff;border-color:#cccccc;"> 描述 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;"> no </td> 
 <td style="background-color:#ffffff;"> 这是默认的设置，它意味着没有自动装配，你应该使用显式的bean引用来连线。你不用为了连线做特殊的事。在依赖注入章节你已经看到这个了。 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;"> <a href="https://www.w3cschool.cn/wkspring/fwdz1mmb.html" rel="nofollow">byName</a> </td> 
 <td style="background-color:#ffffff;"> 由属性名自动装配。Spring 容器看到在 XML 配置文件中 bean 的自动装配的属性设置为 byName。然后尝试匹配，并且将它的属性与在配置文件中被定义为相同名称的 beans 的属性进行连接。 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;"> <a href="https://www.w3cschool.cn/wkspring/8dhy1mmd.html" rel="nofollow">byType</a> </td> 
 <td style="background-color:#ffffff;"> 由属性数据类型自动装配。Spring 容器看到在 XML 配置文件中 bean 的自动装配的属性设置为 byType。然后如果它的类型匹配配置文件中的一个确切的 bean 名称，它将尝试匹配和连接属性的类型。如果存在不止一个这样的 bean，则一个致命的异常将会被抛出。 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;"> <a href="https://www.w3cschool.cn/wkspring/jtlb1mmf.html" rel="nofollow">constructor</a> </td> 
 <td style="background-color:#ffffff;"> 类似于 byType，但该类型适用于构造函数参数类型。如果在容器中没有一个构造函数参数类型的 bean，则一个致命错误将会发生。 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;"> autodetect </td> 
 <td style="background-color:#ffffff;"> Spring首先尝试通过 constructor 使用自动装配来连接，如果它不执行，Spring 尝试通过 byType 来自动装配。 </td> 
 </tr> 
 </tbody> 
</table>

可以使用 **byType** 或者 **constructor** 自动装配模式来连接数组和其他类型的集合。

1.  **自动装配的局限性**

当自动装配始终在同一个项目中使用时，它的效果最好。如果通常不使用自动装配，它可能会使开发人员混淆的使用它来连接只有一个或两个 bean 定义。

不过，自动装配可以显著减少需要指定的属性或构造器参数，但你应该在使用它们之前考虑到自动装配的局限性和缺点。

1.  **自动装配 ‘byName’**

这种模式由属性名称指定自动装配。

Spring 容器看作 beans，在 XML 配置文件中 beans 的 ***auto-wire* **属性设置为 *byName*。

然后，它尝试将它的属性与配置文件中定义为相同名称的 beans 进行匹配和连接。

如果找到匹配项，它将注入这些 beans，否则，它将抛出异常。

例如，在配置文件中，如果一个 bean 定义设置为自动装配 *byName*，并且它包含 *spellChecker* 属性（即，它有一个 *setSpellChecker(...)* 方法），那么 Spring 就会查找定义名为 *spellChecker* 的 bean，并且用它来设置这个属性。

你仍然可以使用 <property> 标签连接其余的属性。下面的例子将说明这个概念。

这里是 **TextEditor.java** 文件的内容：

package com.tutorialspoint;
    public class TextEditor {
       private SpellChecker spellChecker;
       private String name;
       public void setSpellChecker( SpellChecker spellChecker ){
          this.spellChecker = spellChecker;
       }
       public SpellChecker getSpellChecker() {
          return spellChecker;
       }
       public void setName(String name) {
          this.name = name;
       }
       public String getName() {
          return name;
       }
       public void spellCheck() {
          spellChecker.checkSpelling();
       }
    }

下面是另一个依赖类文件 **SpellChecker.java** 的内容：

package com.tutorialspoint;
    public class SpellChecker {
       public SpellChecker() {
          System.out.println("Inside SpellChecker constructor." );
       }
       public void checkSpelling() {
          System.out.println("Inside checkSpelling." );
       }   
    }

下面是 **MainApp.java** 文件的内容：

package com.tutorialspoint;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class MainApp {
       public static void main(String[] args) {
          ApplicationContext context = 
                 new ClassPathXmlApplicationContext("Beans.xml");
          TextEditor te = (TextEditor) context.getBean("textEditor");
          te.spellCheck();
       }
    }

下面是在正常情况下的配置文件 **Beans.xml** 文件：

**但是，如果你要使用自动装配** **“byName”****，那么你的** **XML** **配置文件将成为如下：**

一旦你完成了创建源代码和 bean 的配置文件，我们就可以运行该应用程序。如果你的应用程序一切都正常，它将打印下面的消息：

Inside SpellChecker constructor.
    Inside checkSpelling.

**[https://www.w3cschool.cn/wkspring/fwdz1mmb.html][https_www.w3cschool.cn_wkspring_fwdz1mmb.html]**

# 14 注解配置 #

从 Spring 2.5 开始就可以使用**注解**来配置依赖注入。而不是采用 XML 来描述一个 bean 连线，你可以使用相关类，方法或字段声明的注解，将 bean 配置移动到组件类本身。

在 XML 注入之前进行注解注入，因此后者的配置将通过两种方式的属性连线被前者重写。

注解连线在默认情况下在 Spring 容器中不打开。因此，在可以使用基于注解的连线之前，我们将需要在我们的 Spring 配置文件中启用它。

所以如果你想在 Spring 应用程序中使用的任何注解，可以考虑到下面的配置文件。

添加3个context约束并打开注解

一般我们只需配置包扫描

<context:component-scan base-package="domain"></c ontext:component-scan>
 <?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
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 <context:annotation-config/>
 
 </beans>

一旦 被配置后，你就可以开始注解你的代码，表明 Spring 应该自动连接值到属性，方法和构造函数。让我们来看看几个重要的注解，并且了解它们是如何工作的：

<table style="width:524.25pt;"> 
 <tbody> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;"> 序号 </td> 
 <td style="background-color:#ffffff;border-color:#cccccc;"> 注解 &amp; 描述 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;"> 1 </td> 
 <td style="background-color:#ffffff;"> <a href="https://www.w3cschool.cn/wkspring/9sle1mmh.html" rel="nofollow">@Required</a> @Required 注解应用于 bean 属性的 setter 方法。 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;"> 2 </td> 
 <td style="background-color:#ffffff;"> <a href="https://www.w3cschool.cn/wkspring/rw2h1mmj.html" rel="nofollow">@Autowired</a> @Autowired 注解可以应用到 bean 属性的 setter 方法，非 setter 方法，构造函数和属性。 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;"> 3 </td> 
 <td style="background-color:#ffffff;"> <a href="https://www.w3cschool.cn/wkspring/knqr1mm2.html" rel="nofollow">@Qualifier</a> 通过指定确切的将被连线的 bean，@Autowired 和 @Qualifier 注解可以用来删除混乱。 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;"> 4 </td> 
 <td style="background-color:#ffffff;"> <a href="https://www.w3cschool.cn/wkspring/lmsq1mm4.html" rel="nofollow">JSR-250 Annotations</a> Spring 支持 JSR-250 的基础的注解，其中包括了 @Resource，@PostConstruct 和 @PreDestroy 注解。 </td> 
 </tr> 
 </tbody> 
</table>

## 14.1 **@Required 注释** ##

Spring @Required 注释

请注意， 对setter方法使用@Required注释可以用于使属性成为必需的依赖关系。

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

下面显示的是一个使用 @Required 注释的示例。

下面是 **Student.java** 文件的内容：

package com.tutorialspoint;
    import org.springframework.beans.factory.annotation.Required;
    public class Student {
       private Integer age;
       private String name;
       @Required
       public void setAge(Integer age) {
          this.age = age;
       }
       public Integer getAge() {
          return age;
       }
       @Required
       public void setName(String name) {
          this.name = name;
       }
       public String getName() {
          return name;
       }
    }

下面是 **MainApp.java** 文件的内容：

package com.tutorialspoint;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class MainApp {
       public static void main(String[] args) {
          ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
          Student student = (Student) context.getBean("student");
          System.out.println("Name : " + student.getName() );
          System.out.println("Age : " + student.getAge() );
       }
    }

下面是配置文件 **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"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 <context:annotation-config/>
 
 <bean id="student" class="com.tutorialspoint.Student">
 <property name="name" value="Zara" />
 
 
 </bean>
 </beans>

一旦你已经完成的创建了源文件和 bean 配置文件，让我们运行一下应用程序。

如果你的应用程序一切都正常的话，这将引起 *BeanInitializationException* 异常，并且会输出一下错误信息和其他日志消息：

Property 'age' is required for bean 'student'

下一步，在你按照如下所示从 “age” 属性中删除了注释，你可以尝试运行上面的示例：

现在上面的示例将产生如下结果：

Name : Zara  
Age : 11

## 14.2 @Autowired 注释 ##

**@Autowired** 注释对在哪里和如何完成自动连接提供了更多的细微的控制。

@Autowired 注释可以在 setter 方法中被用于自动连接 bean，就像 @Autowired 注释，容器，一个属性或者任意命名的可能带有多个参数的方法。

**@Autowired顾名思义，就是自动装配，其作用是为了消除代码Java代码里面的getter/setter与bean属性中的property。当然，getter看个人需求，如果私有属性需要对外提供的话，应当予以保留。**

### 14.2.1 Setter 方法中的 @Autowired ###

你可以在 XML 文件中的 setter 方法中使用 **@Autowired** 注释来**除去****元素**。

当 Spring遇到一个在 setter 方法中使用的 @Autowired 注释，它会在方法中试图执行 **byType** 自动连接。

这里是 **TextEditor.java** 文件的内容：

package com.tutorialspoint;
    import org.springframework.beans.factory.annotation.Autowired;
    public class TextEditor {
       private SpellChecker spellChecker;
       @Autowired
       public void setSpellChecker( SpellChecker spellChecker ){
          this.spellChecker = spellChecker;
       }
       public SpellChecker getSpellChecker( ) {
          return spellChecker;
       }
       public void spellCheck() {
          spellChecker.checkSpelling();
       }
    }

下面是另一个依赖的类文件 **SpellChecker.java** 的内容：

下面是 **MainApp.java** 文件的内容：

下面是配置文件 **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"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 <context:annotation-config/>
 
 <bean id="textEditor" class="com.tutorialspoint.TextEditor"> </bean>
 
 <bean id="spellChecker" class="com.tutorialspoint.SpellChecker"> </bean>
 </beans>

一旦你已经完成的创建了源文件和 bean 配置文件，让我们运行一下应用程序。如果你的应用程序一切都正常的话，这将会输出以下消息：

![70 11][]

### 14.2.2 属性中的 @Autowired ###

你可以在属性中使用 **@Autowired** 注释来除去 setter 方法。(get方法不是必须)

当时使用 为自动连接属性传递的时候，Spring 会将这些传递过来的值或者引用自动分配给那些属性。

所以利用在属性中 @Autowired 的用法，你的**TextEditor.java** 文件将变成如下所示：

package com.tutorialspoint;
    import org.springframework.beans.factory.annotation.Autowired;
    public class TextEditor {
       @Autowired
       private SpellChecker spellChecker;
       public TextEditor() {
          System.out.println("Inside TextEditor constructor." );
       }  
       public SpellChecker getSpellChecker( ){
          return spellChecker;
       }  
       public void spellCheck(){
          spellChecker.checkSpelling();
       }
    }

下面是配置文件 **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"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 <context:annotation-config/>
 
 <bean id="textEditor" class="com.tutorialspoint.TextEditor"> </bean>
 
 <bean id="spellChecker" class="com.tutorialspoint.SpellChecker"></bean>
 </beans>

一旦你在源文件和 bean 配置文件中完成了上面两处改变，让我们运行一下应用程序。如果你的应用程序一切都正常的话，这将会输出以下消息：

![70 12][]

### 14.2.3  构造函数中的 @Autowired ###

你也可以在构造函数中使用 @Autowired

You can apply the `@Autowired` annotation to constructors:。

一个**构造函数** @Autowired 说明当创建 bean 时，即使在 XML 文件中没有使用 元素配置 bean ，构造函数也会被自动连接。

即不用再写set和get方法

让我们检查一下下面的示例。

这里是 **TextEditor.java** 文件的内容：

package com.tutorialspoint;
    import org.springframework.beans.factory.annotation.Autowired;
    public class TextEditor {
       private SpellChecker spellChecker;
       @Autowired
       public TextEditor(SpellChecker spellChecker){
          System.out.println("Inside TextEditor constructor." );
          this.spellChecker = spellChecker;
       }
       public void spellCheck(){
          spellChecker.checkSpelling();
       }
    }

下面是配置文件 **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"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 <context:annotation-config/>
 
 <bean id="textEditor" class="com.tutorialspoint.TextEditor"></bean>
 
 <bean id="spellChecker" class="com.tutorialspoint.SpellChecker"></bean>
 </beans>

一旦你在源文件和 bean 配置文件中完成了上面两处改变，让我们运行一下应用程序。如果你的应用程序一切都正常的话，这将会输出以下消息：

![70 13][]

### 14.2.4 @Autowired 的（required=false）选项 ###

默认情况下，@Autowired 注释意味着依赖是必须的，

Dependency annotations: \{@org.springframework.beans.factory.annotation.Autowired(required=true)\}

然而，你可以使用 @Autowired 的 **（****required=false****）** 选项关闭默认行为。

每个类只有一个注释构造函数可以被标记为必需，但是可以注释多个非必需的构造函数。

在这种情况下，每个候选者都被考虑，Spring使用最可靠的构造函数，它的依赖关系可以被满足，也就是具有最大参数数量的构造函数。

## 14.3  @Qualifier 注释不常用 ##

[http://www.cnblogs.com/smileLuckBoy/p/5801678.html][http_www.cnblogs.com_smileLuckBoy_p_5801678.html]

可能会有这样一种情况，当你创建多个具有相同类型的 bean 时，并且想要用一个属性只为它们其中的一个进行装配，

在这种情况下，你可以使用 **@Qualifier** 注释和 **@Autowired** 注释通过指定哪一个真正的 bean 将会被装配来消除混乱。下面显示的是使用 @Qualifier 注释的一个示例。

这里是 **Student.java** 文件的内容：

package com.tutorialspoint;
    public class Student {
       private Integer age;
       private String name;
       public void setAge(Integer age) {
          this.age = age;
       }   
       public Integer getAge() {
          return age;
       }
       public void setName(String name) {
          this.name = name;
       }  
       public String getName() {
          return name;
       }
    }

这里是 **Profile.java** 文件的内容：

package com.tutorialspoint;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    public class Profile {
       @Autowired
       @Qualifier("student1")
       private Student student;
       public Profile(){
          System.out.println("Inside Profile constructor." );
       }
       public void printAge() {
          System.out.println("Age : " + student.getAge() );
       }
       public void printName() {
          System.out.println("Name : " + student.getName() );
       }
    }

下面是 **MainApp.java** 文件的内容：

package com.tutorialspoint;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class MainApp {
       public static void main(String[] args) {
          ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
          Profile profile = (Profile) context.getBean("profile");
          profile.printAge();
          profile.printName();
       }
    }

考虑下面配置文件 **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"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 <context:annotation-config/>
 
 <bean id="profile" class="com.tutorialspoint.Profile"></bean>
 
 <bean id="student1" class="com.tutorialspoint.Student">
 <property name="name" value="Zara" />
 <property name="age" value="11"/>
 </bean>
 
 <bean id="student2" class="com.tutorialspoint.Student">
 <property name="name" value="Nuha" />
 <property name="age" value="2"/>
 </bean>
 </beans>

一旦你在源文件和 bean 配置文件中完成了上面两处改变，让我们运行一下应用程序。如果你的应用程序一切都正常的话，这将会输出以下消息：

Inside Profile constructor.Age : 11 Name : Zara

[https_spring.io_docs_reference]: https://spring.io/docs/reference
[70]: /images/20220516/65adc77fcd934a128a0b4c8732d836eb.png
[https_docs.spring.io_spring_docs_5.1.0.RC2_spring-framework-reference]: https://docs.spring.io/spring/docs/5.1.0.RC2/spring-framework-reference/
[https_docs.spring.io_spring_docs_5.1.0.RC2_spring-framework-reference_core.html_spring-core]: https://docs.spring.io/spring/docs/5.1.0.RC2/spring-framework-reference/core.html#spring-core
[https_docs.spring.io_spring_docs_5.1.0.RC2_spring-framework-reference_web.html_spring-web]: https://docs.spring.io/spring/docs/5.1.0.RC2/spring-framework-reference/web.html#spring-web
[https_docs.spring.io_spring_docs_5.1.0.RC2_spring-framework-reference_data-access.html_spring-data-tier]: https://docs.spring.io/spring/docs/5.1.0.RC2/spring-framework-reference/data-access.html#spring-data-tier
[https_docs.spring.io_spring_docs_4.3.18.RELEASE_spring-framework-reference_htmlsingle]: https://docs.spring.io/spring/docs/4.3.18.RELEASE/spring-framework-reference/htmlsingle/
[70 1]: /images/20220516/14a8d704401c4da7bc3d5fbd7b79514e.png
[70 2]: /images/20220516/da5e54b3b58d4556bbc8f91b24a84f70.png
[70 3]: /images/20220516/dfce5efe0825480d964faa99be1affe5.png
[70 4]: /images/20220516/d6b51f1207414b13a91565e0b1434166.png
[70 5]: /images/20220516/6042bfd8c26448cd922793a97f33f5fa.png
[70 6]: /images/20220516/06ea6968614b49a1a27af4663ed84bce.png
[70 7]: /images/20220516/acf14c88101b467fa69b5bafcfc8f618.png
[70 8]: /images/20220516/3b9b5584275a4c40b3f76469210c2e03.png
[70 9]: /images/20220516/a5708e038c8f44bba0ad7881b8d37fa0.png
[ConstructorProperties]: http://download.oracle.com/javase/6/docs/api/java/beans/ConstructorProperties.html
[70 10]: /images/20220516/be8c4fba87574b66a717b861719c80f1.png
[https_www.w3cschool.cn_wkspring_fwdz1mmb.html]: https://www.w3cschool.cn/wkspring/fwdz1mmb.html
[70 11]: /images/20220516/308f23c3b36d48fc905a57190089f70e.png
[70 12]: /images/20220516/6c15187bdc2e479888d09d48103cefcb.png
[70 13]: /images/20220516/ba9e8f322ba3464c9d4a20ec9218f3e7.png
[http_www.cnblogs.com_smileLuckBoy_p_5801678.html]: http://www.cnblogs.com/smileLuckBoy/p/5801678.html