基于注解的方式

1、在 classpath 中扫描组件

• 组件扫描（component scanning）：Spring 能够从 classpath 下自动扫描，侦测和实例化具有特定注解的组件。

• 特定组件包括：

  • @Component：基本注解，标识了一个受 Spring 管理的组件
  • @Respository：标识持久层组件
  • @Service：标识服务层(业务层)组件
  • @Controller：标识表现层组件
• 对于扫描到的组件， Spring 有默认的命名策略：使用非限定类名，第一个字母小写；也可以在注解中通过 value 属性值标识组件的名称。

• 当在组件类上使用了特定的注解之后，还需要在 Spring 的配置文件中声明 <context:component-scan> ：

  • base-package 属性指定一个需要扫描的基类包，Spring 容器将会扫描这个基类包里及其子包中的所有类。
  • 当需要扫描多个包时，可以使用逗号分隔。

  • 如果仅希望扫描特定的类而非基包下的所有类，可使用 resource-pattern 属性过滤特定的类，示例：

    <context:component-scan
        base-package="com.spring.beans"
        resource-pattern="autowire/*.class"/>

  • <context:include-filter> 子节点表示要包含的目标类
  • <context:exclude-filter> 子节点表示要排除在外的目标类
  • <context:component-scan> 下可以拥有若干个<context:include-filter> 和 <context:exclude-filter> 子节点。

  • context:include-filter过滤器有五种type：

    • annotation-指定扫描使用某个注解的类
    • assignable-指定扫描某个接口派生出来的类

• 代码：

  java 代码：

  @Component
  public class TestObject {
  
  }
  
  public interface UserRepository {
  
      void save();
  
  }
  
  @Repository("userRepository")
  public class UserRepositoryImpl implements UserRepository {
      @Override
      public void save() {
          System.out.println("UserRepository save ...");
      }
  }
  
  @Service
  public class UserService {
  
      public void add() {
          System.out.println("UserService add...");
      }
  
  }
  
  @Controller
  public class UserController {
  
      public void execute() {
          System.out.println("UserController execute...");
      }
  
  }
  
  public class Main11 {
  
      public static void main(String[] args) {
  
          ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-annotation.xml");
  
          TestObject to = (TestObject) ctx.getBean("testObject");
          System.out.println(to);
  
          UserController userController = (UserController) ctx.getBean("userController");
          System.out.println(userController);
  
          UserService userService = (UserService) ctx.getBean("userService");
          System.out.println(userService);
  
          UserRepositoryImpl userRepository = (UserRepositoryImpl) ctx.getBean("userRepository");
          System.out.println(userRepository);
  
      }
  
  }

  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.xsd
                          http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  
      <!-- 指定 Spring IOC 容器扫描包 -->
      <!-- 可以通过 resource-pattern 指定扫描的资源 -->
      <!--
      <context:component-scan
              base-package="com.spring.beans.annotation"
              resource-pattern="service/*.class"/>
      -->
  
      <!-- context:exclude-filter 子节点指定排除哪些指定表达式的组件 -->
      <!-- context:include-filter 子节点指定包含哪些表达式的组件，该子节点需要 use-default-filters 配合使用 -->
      <context:component-scan
              base-package="com.spring.beans.annotation"
              use-default-filters="true">
          <!--
          <context:exclude-filter type="annotation"
                                  expression="org.springframework.stereotype.Repository"/>
          -->
          <!--
          <context:include-filter type="annotation"
                                  expression="org.springframework.stereotype.Repository"/>
          -->
          <!--
          <context:exclude-filter type="assignable"
                                  expression="com.spring.beans.annotation.repository.UserRepository"/>
          -->
          <context:include-filter type="assignable"
                                  expression="com.spring.beans.annotation.repository.UserRepository"/>
      </context:component-scan>
  
  </beans>

2、组件装配

​ <context:component-scan> 元素还会自动注册 AutowiredAnnotationBeanPostProcessor 实例，该实例可以自动装配具有 @Autowired 和 @Resource、@Inject 注解的属性。

• 使用 @Autowired 注解自动装配具有兼容类型的单个 Bean 属性

  • 构造器，普通字段(即使是非 public )，一切具有参数的方法都可以应用 @Autowired 注解

  • 默认情况下，所有使用 @Autowired 注解的属性都需要被设置。当 Spring 找不到匹配的 Bean 装配属性时，会抛出异常，若某一属性允许不被设置，可以设置 @Autowired 注解的 required 属性为 false

    @Repository("userRepository")
    public class UserRepositoryImpl implements UserRepository {
    
        @Autowired(required=false)
        private TestObject testObject;
    
        @Override
        public void save() {
            System.out.println("UserRepository save ...");
            System.out.println(testObject);
        }
    
    }

  • 默认情况下，当 IOC 容器里存在多个类型兼容的 Bean 时，通过类型的自动装配将无法工作，此时可以在 @Qualifier 注解里提供 Bean 的名称。Spring 允许对方法的入参标注 @Qualifier 已指定注入 Bean 的名称 ，也可以在声明 bean 的时候 bean 的名字跟这个属性的字段名相一致

    @Service
    public class UserService {
    
        private UserRepository userRepository;
    
    //    @Autowired
    //    @Qualifier("userRepository")
    //    public void setUserRepository(UserRepository userRepository) {
    //        this.userRepository = userRepository;
    //    }
    
        @Autowired
        public void setUserRepository(@Qualifier("userRepository") UserRepository userRepository) {
            this.userRepository = userRepository;
        }
    
        public void add() {
            System.out.println("UserService add...");
            userRepository.save();
        }
    
    }

  • @Autowired 注解也可以应用在数据类型的属性上，此时 Spring 将会把所有匹配的 Bean 进行自动装配。
  • @Autowired 注解也可以应用在集合属性上，此时 Spring 读取该集合的类型信息，然后自动装配所有与之兼容的 Bean。
  • @Autowired 注解用在 java.util.Map 上时，若该 Map 的键值为 String，那么 Spring 将自动装配与之 Map 值类型兼容的 Bean，此时 Bean 的名称作为键值。

• 使用 @Resource 或 @Inject 自动装配 Bean

  • Spring 还支持 @Resource 和 @Inject 注解，这两个注解和 @Autowired 注解的功用类似
  • @Resource 注解需要提供一个 Bean 名称的属性，若该属性为空，则自动采用标注处的变量或方法名作为 Bean 的名称
  • @Inject 和 @Autowired 注解一样也是按类型匹配注入的 Bean，但没有 required 属性
  • 建议使用 @Autowired 注解

泛型依赖注入

配置 bean

主要内容：

• 配置形式：基于 XML 文件的方式；基于注解的方式（基于注解配置 bean ；基于注解来装配 bean 的属性）。
• Bean 的配置方式：通过全类名（反射）、通过工厂方法（静态工厂方法&实例工厂方法）、FactoryBean。
• IOC 容器 BeanFactory & ApplicationContext 概述。
• 依赖注入的方式：属性注入；构造器注入。
• 注入属性值细节。
• 自动装配。
• bean 之间的关系：继承；依赖。
• bean 的作用域：singleton；prototype；WEB 环境作用域。
• 使用外部属性文件。
• spEL。
• IOC 容器中 Bean 的生命周期。
• Spring 4.x 新特性：泛型依赖注入。

基于 XML 文件的方式：

1、在 Spring 的 IOC 容器里配置 Bean

• 在 xml 文件中通过 bean节点来配置 bean。

  <!--
      配置 bean
      class：bean 的全类名，通反射的方式在 IOC 容器中创建 Bean，所以要求 Bean 中必须有无参构造方法
      id：标识容器中的 bean，id唯一。
  -->
  <bean id="helloWorld" class="com.spring.beans.HelloWorld">
          <property name="name" value="Spring"/>
  </bean>

• id：Bean 的名称。

  • 在 IOC 容器中必须是唯一的
  • 若 id 没有指定，Spring 自动将权限定性类名作为 Bean 的名字
  • id 可以指定多个名字，名字直渐可用逗号、分号、或空格分隔

2、Spring 容器

• 在 Spring IOC 容器读取 Bean 配置创建 Bean 实例之前，必须对它进行实例化。只有在容器实例化后，才可以从 IOC 容器里获取 Bean 实例并使用。

• Spring 提供了两种类型的 IOC 容器实现。

  • BeanFactory：IOC 容器的基本实现。
  • ApplicationContext：提供了更多的高级特性，是 BeanFactory 的子接口。

  • BeanFactory 是 Spring 框架的基础设施，面向 Spring 本身；

    ApplicationContext 面向使用 Spring 框架的开发者，几乎所有的应用场合都直接使用 ApplicationContext 而非底层的 BeanFactory。

  • 无论使用何种方式，配置文件时都相同的。

• ApplicationContext

  • ApplicationContext 的主要实现类：

    — ClassPathXmlApplicationContext：从类路径下加载配置文件

    — FileSystemXmlApplicationContext：从文件系统中加载配置文件

  • ConfigurableApplicationContext 扩展于 ApplicationContext，新增两个主要方法：refresh() 和 close()，让 ApplicationContext 具有启动、刷新和关闭上下文的能力
  • ApplicationContext 在初始化上下文时就实例化所有单例的 Bean。
  • WebApplicationContext 是专门为 WEB 应用而准备的，它允许从相对于 WEB 根目录的路径中完成初始化工作。

• getBean() 方法

  参数有两种

  • 参数是 Bean 的 id；

    利用 id 定位到 IOC 容器中的 bean

    HelloWorld helloWorld = (HelloWorld) ctx.getBean("helloWorld");

• 参数是 类名.class；

  利用类型返回 IOC 容器中的 Bean，但要求 IOC 容器中只能有一个该类型的 Bean

  HelloWorld helloWorld = ctx.getBean(HelloWorld.class);

3、依赖注入的方式

• 属性注入

  • 属性注入即通过 setter 方法注入 Bean 的属性值或依赖的对象
  • 属性注入使用 <property> 元素，使用 name 属性指定 Bean 的属性名称，value 属性或 <value> 子节点指定属性值

  • 属性注入是实际应用中最常用的注入方式

    <bean id="helloWorld" class="com.spring.beans.HelloWorld">
            <property name="name" value="Spring"/>
    </bean>

• 构造方法注入

  • 通过构造方法注入 Bean 的属性值或依赖的对象，它保证了 Bean 实例在实例化后就可以使用。

  • 构造器注入在 <constructor-arg> 元素里生命属性

    <constructor-arg> 中没有 name 属性

    public class Car {
    
        private String brand;
        private String corp;
        private double price;
        private int maxSpeed;
    
        @Override
        public String toString() {
            return "Car{" +
                    "brand='" + brand + '\'' +
                    ", corp='" + corp + '\'' +
                    ", price=" + price +
                    ", maxSpeed=" + maxSpeed +
                    '}';
        }
    
        public Car(String brand, String corp, double price) {
            this.brand = brand;
            this.corp = corp;
            this.price = price;
        }
    
        public Car(String brand, String corp, int maxSpeed) {
            this.brand = brand;
            this.corp = corp;
            this.maxSpeed = maxSpeed;
        }
    }

    <!--<bean id="car" class="com.spring.beans.Car">
        <constructor-arg value="Audi" index="0"/>
        <constructor-arg value="ShangHai" index="1"/>
        <constructor-arg value="300000" index="2"/>
    </bean>-->
    
    <bean id="car" class="com.spring.beans.Car">
        <constructor-arg value="Audi" type="java.lang.String"/>
        <constructor-arg value="ShangHai" type="java.lang.String"/>
        <constructor-arg value="300000" type="double"/>
    </bean>
    
    <bean id="car2" class="com.spring.beans.Car">
        <constructor-arg value="BaoMa" type="java.lang.String"/>
        <constructor-arg value="ShangHai" type="java.lang.String"/>
        <constructor-arg value="300000" type="int"/>
    </bean>

    其中 index 表示构造函数中参数的位置，type 表示类型。以区分重载的构造函数。

• 工厂方法注入（很少使用，不推荐）

4、注入属性值的细节

• 字面值：可用字符串表示的值，可以通过 <value> 元素标签或 value 属性进行注入。

  <bean id="car2" class="com.spring.beans.Car">
      <constructor-arg value="BaoMa" type="java.lang.String"/>
      <constructor-arg value="ShangHai" type="java.lang.String"/>
      <constructor-arg type="int">
          <value>250</value>
      </constructor-arg>
  </bean>

• 基本数据类型及其封装类、String 等类型都可以采取字面值注入方式。

• 若字面值中包含特殊字符，可以使用 <![CDATA[]]> 把字面值包裹起来。

  <bean id="car2" class="com.spring.beans.Car">
      <constructor-arg value="BaoMa" type="java.lang.String"/>
      <constructor-arg type="java.lang.String">
          <value><![CDATA[<ShangHai^>]]></value>
      </constructor-arg>
      <constructor-arg type="int">
          <value>250</value>
      </constructor-arg>
  </bean>

5、引用其它 Bean

• 组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能，要使 Bean 能够相互访问，就必须在 Bean 配置文件中指定对 Bean 的引用。

• 在 Bean 的配置文件中，可以通过 <ref> 或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用。

  <bean id="person" class="com.spring.beans.Person">
      <property name="name" value="Tom"/>
      <property name="age" value="24"/>
      <!--<property name="car" ref="car2"/>-->
      <property name="car">
          <ref bean="car2"/>
      </property>
  </bean>

• 也可以在属性或构造器里包含 Bean 的声明，这样的 Bean 称为內部 Bean。

  在属性内使用內部 Bean：

  <bean id="person" class="com.spring.beans.Person">
      <property name="name" value="Tom"/>
      <property name="age" value="24"/>
      <!--<property name="car" ref="car2"/>-->
      <!--<property name="car">-->
      <!--    <ref bean="car2"/>-->
      <!--</property>-->
      <property name="car">
          <bean class="com.spring.beans.Car">
              <constructor-arg value="Ford"/>
              <constructor-arg value="ChangAn"/>
              <constructor-arg value="200000" type="double"/>
          </bean>
      </property>
  </bean>

  在构造器内使用內部 Bean：

  public Person() {
  
  }
  
  public Person(String name, int age, Car car) {
      this.name = name;
      this.age = age;
      this.car = car;
  }

  <bean id="person2" class="com.spring.beans.Person">
      <constructor-arg value="Jerry"/>
      <constructor-arg value="25"/>
      <constructor-arg ref="car"/>
  </bean>

  ！注意：当 Bean实例仅仅给一个特定的属性使用时，可以将其声明为內部 Bean。內部 Bean 声明直接包含在 <property> 或 <constructor-arg> 元素里，不需要设置任何 id 或 name 属性。內部 Bean 不能使用在其他任何地方。

6、注入参数详解：null 值和级联属性

• 可以使用专用的 <null/> 元素标签为 Bean 的字符串或其它对象类型的属性注入 bull 值

  <bean id="person2" class="com.spring.beans.Person">
      <constructor-arg value="Jerry"/>
      <constructor-arg value="25"/>
      <!--<constructor-arg ref="car"/>-->
      <constructor-arg><null/></constructor-arg>
  </bean>

• 和 Struts、Hiberante 等框架一样，Spring 支持级联属性的配置

  <bean id="person2" class="com.spring.beans.Person">
      <constructor-arg value="Jerry"/>
      <constructor-arg value="25"/>
      <!--<constructor-arg ref="car"/>-->
      <!--<constructor-arg><null/></constructor-arg>-->
      <constructor-arg ref="car2"/>
      <property name="car.maxSpeed" value="250"/>
  </bean>

  ！注意：属性需要先初始化后才可以为级联属性赋值，否则会有异常，和 Struts2 不同。

7、集合属性

• 在 Spring 中可以通过一组内置的 xml 标签（例如：<list> , <set> , <map> ）来配置集合属性。
• 配置 Java.util.List 类型的属性，需要指定 <list> 标签，在标签里包含一些元素。这些标签可以通过 <value> 指定简单的常量值，通过<ref> 指定对其他 Bean 的引用。通过 <bean> 指定内置 Bean 定义。通过 <null/> 指定空元素。甚至可以内嵌其他集合。
• 数组的定义和 List 一样，都使用 <list> 。

• 配置 java.util.Set 需要使用 <set> 标签，定义元素的方法与 List 一样。

  <!-- 使用 list 节点为 List 类型的属性赋值 -->
  <bean id="person3" class="com.spring.beans.collections.Person">
      <property name="name" value="Mike"/>
      <property name="age" value="27"/>
      <property name="cars">
          <list>
              <ref bean="car"/>
              <ref bean="car2"/>
          </list>
      </property>
  </bean>
  <!-- 使用 list 节点为 List 类型的属性赋值(內部 Bean) -->
  <bean id="person3" class="com.spring.beans.collections.Person">
      <property name="name" value="Mike"/>
      <property name="age" value="27"/>
      <property name="cars">
          <list>
              <ref bean="car"/>
              <ref bean="car2"/>
              <bean class="com.spring.beans.Car">
                  <constructor-arg value="Ford"/>
                  <constructor-arg value="ChangAn"/>
                  <constructor-arg value="200000" type="double"/>
              </bean>
          </list>
      </property>
  </bean>

• Java.util.Map 通过 <map> 标签定义，<map> 标签里可以使用多个 <entry> 作为子标签。每个条目包含一个键和一个值。
• 必须在 <key> 标签里定义键
• 因为键和值的类型没有限制，所以可以自由地为它们指定 <value> ，<ref> ，<bean> 或 <null> 元素。
• 可以将 Map 的键和值作为 <entry> 的属性定义；简单常量使用 key 和 value 来定义；Bean 引用通过 key-ref 和 value-ref 属性定义

• 使用 <props> 定义 java.util.Properties，该标签使用多个 <prop> 作为子标签。每个 <prop> 标签必须定义 key 属性。

  <!-- 使用 map 节点及 map 的 entry 子节点配置 Map 类型的成员变量 -->
  <bean id="newPerson" class="com.spring.beans.collections.NewPerson">
      <property name="name" value="Rose"/>
      <property name="age" value="28"/>
      <property name="cars">
          <map>
              <entry key="AA" value-ref="car"/>
              <entry key="BB" value-ref="car2"/>
          </map>
      </property>
  </bean>
  
  <!-- 使用 props 和 prop 子节点来为 Properties 属性赋值 -->
  <bean id="dataSource" class="com.spring.beans.collections.DataSource">
      <property name="properties">
          <props>
              <prop key="user">root</prop>
              <prop key="password">1234</prop>
              <prop key="jdbcUel">jdbc:mysql:///test</prop>
              <prop key="driverClass">com.mysql.jdbc.Driver</prop>
          </props>
      </property>
  </bean>

8、使用 utility schema 定义集合

• 使用基本的集合标签定义集合时，不能将集合作为独立的 Bean 定义，导致其他 Bean 无法引用该集合，所以无法在不同 Bean 之间共享集合。

  <!-- 配置独立的集合 bean，以供多个 bean 进行引用，需要导入 util 命名空间 -->
  <util:list id="cars">
      <ref bean="car"/>
      <ref bean="car2"/>
  </util:list>
  <bean id="person4" class="com.spring.beans.collections.Person">
      <property name="name" value="Jack"/>
      <property name="age" value="29"/>
      <property name="cars" ref="cars"/>
  </bean>

• 可以使用 util schema 里的集合标签定义独立的集合 Bean 。需要注意的是，必须在 <beans> 根元素里添加 util schema 定义。

9、使用 p 命名空间

• 为了简化 XML 文件的配置，越来越多的 XML 文件采用属性而非子元素配置信息。
• Spring 从 2.5 版本开始引用了一个新的 p 命名空间，可以通过 <bean> 元素属性的方式配置 Bean 的属性。

• 使用 p 命名空间后，基于 XML 的配置方式将进一步简化。

  <!-- 通过 p 命名空间为 bean 的属性赋值，需要先导入 p 命名空间，相对于传统的配置方式更加的简洁 -->
  <bean id="person5" class="com.spring.beans.collections.Person" p:name="Queen" p:age="30" p:cars-ref="cars"/>

10、XML 配置里的 Bean 自动装配

• Spring IOC 容器可以自动装配 Bean。需要做的仅仅是在 <bean> 的 autowire 属性里指定自动装配的模式
• byType（根据类型自动装配）：若 IOC 容器中有多个与目标 Bean 类型一致的 Bean。在这种情况下，Spring 将无法判定哪个 Bean 最合适该属性，所以不能执行自动装配。
• byName（根据名称自动装配）：必须将目标 Bean 的名称和属性名设置的完全相同。

• constructor（通过构造器自动装配）：当 Bean 中存在多个构造器时，此种自动装配方式将会很复杂，不推荐使用。

  <bean id="address" class="com.spring.beans.autowire.Address" p:city="Beijing" p:street="HuiLongGuan"/>
  
  <bean id="car" class="com.spring.beans.autowire.Car" p:brand="Audi" p:price="300000"/>
  
  <!--手工装配-->
  <bean id="person" class="com.spring.beans.autowire.Person" p:name="Tom" p:address-ref="address" p:car-ref="car"/>
  
  <!--自动装配-->
  <!--byName: 根据名字自动装配，要求 xml 文件里的 bean 的 id 与当前 bean 的 setter 风格的属性名进行自动装配，若有匹配的，则进行自动装配；若没有匹配的，则不装配。-->
  <bean id="person" class="com.spring.beans.autowire.Person" autowire="byName"/>
  <!--byType: 根据 bean 的类型和当前 bean 的属性的类型进行自动装配，若 IOC 容器中有一个以上的类型匹配的 bean，则抛异常。-->
  <bean id="person" class="com.spring.beans.autowire.Person" autowire="byType"/>

XML 配置里的 Bean 自动装配的缺点

• 在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配 Bean 的所有属性。然而，若只希望装配个别属性时，autowire 属性就不够灵活了。
• autowire 属性要么根据类型自动装配，要么根据名称自动装配，不能两者兼而有之。
• 一般情况下，在实际的项目中很少使用自动装配功能，因为和自动装配功能所带来的好处比起来，明确清晰的配置文档更有说服力。

11、bean 之间的关系

• 继承 Bean 的配置

  • Spring 允许继承 bean 的配置，被继承的 bean 称为父 bean。继承这个父 bean 的 bean 称为子 bean。
  • 子 Bean 从父 Bean中继承配置，包括 Bean 的属性配置

  • 子 Bean 也可以覆盖从父 Bean 继承过来的配置

    <bean id="address" class="com.spring.beans.autowire.Address" p:city="Beijing^" p:street="WuDaoKou"/>
    
    <!--bean 配置的继承：使用 bean 的 parent 属性指定继承哪个 bean 配置-->
    <!-- 三种例子 -->
    <bean id="address2" parent="address"/>
    <bean id="address2" p:street="DaZhongSi" parent="address"/>
    <bean id="address2" p:city="Beijing" p:street="DaZhongSi" parent="address"/>

  • 父 Bean 可以作为配置模板，也可以作为 Bean 实例。若只想把父 Bean 作为模板，可以设置 <bean> 的 abstract 属性为 true，这样 Spring 将不会实例化这个 Bean。

    <!-- abstract = true 时，该 bean 称为抽象 bean。这样的 bean 不能被 IOC 容器实例化，只用来被继承配置 -->
    <bean id="address" class="com.spring.beans.autowire.Address" p:city="Beijing^" p:street="WuDaoKou" abstract="true"/>

  • 并不是 <bean> 元素里的所有属性都会被继承。比如：autowire，abstract等。

  • 也可以忽略父 Bean 的 class 属性，让子 Bean 指定自己的类，而共享相同的属性配置。但此时 abstract 必须设为 true。

    <!-- 若某一个 bean 的 class 属性没有指定，则该 bean 必须是一个抽象 bean -->
    <bean id="address" abstract="true" p:city="Beijing^" p:street="WuDaoKou"/>
    
    <!--bean 配置的继承：使用 bean 的 parent 属性指定继承哪个 bean 配置-->
    <bean id="address2" class="com.spring.beans.autowire.Address" parent="address"/>

• 依赖 Bean 的配置

  • Spring 允许用户通过 depends-on 属性设定 Bean 前置依赖的 Bean，前置依赖的 Bean 会在本 Bean 实例化之前创建好。
  • 如果前置依赖于多个 Bean，则可以通过逗号，空格或的方式配置 Bean 的名称。

  • 在实际应用中实例化某个 bean 时，经常要在实例化该 bean 之前实例化另外一个 bean，因此产生了依赖关系。

    <!--要求再配置 Person 时，必须有一个关联的 Car。-->
    <bean id="person" class="com.spring.beans.autowire.Person"
          p:name="Tom" p:address-ref="address2" depends-on="car"/>
    <bean id="car" class="com.spring.beans.autowire.Car"
          p:brand="Audi" p:price="300000"/>

    注意：depends-on = ” car ” 只是指定了在获取 person 的 bean 时，要现在 IOC 容器中能获取 car 的 bean，但是并不是说就把 car 的 bean 注入到了 person 的 bean 中了，要想 person 用有 car 的 bean，需要在 person 的 bean 的配置中获取 car 的 bean。

12、bean 的作用域

• 使用 bean 的 scope 属性来配置 bean 的作用域

• singleton：默认值，容器初始化时创建 bean 实例，在整个容器的生命周期内只创建这一个 bean. 单例的。

  <bean id="car"
        class="com.spring.beans.autowire.Car"
        scope="singleton">
      <property name="brand" value="Audi"/>
      <property name="price" value="300000"/>
  </bean>

• prototype：原型的，容器初始化时不创建 bean 的实例，而在每次请求时都创建一个新的 bean 实例，并返回。

  <bean id="car"
        class="com.spring.beans.autowire.Car"
        scope="prototype">
      <property name="brand" value="Audi"/>
      <property name="price" value="300000"/>
  </bean>

13、使用外部属性文件

• 在配置文件里配置 bean 时，有时需要在 bean 的配置里混入系统部署的细节信息(例如：文件路径，数据源配置信息等)。而这些部署细节实际上需要和 bean 的配置相分离。
• Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器，这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中。可以在 bean 配置文件里使用形式为 ${var} 的变量， PropertyPlaceholderConfigurer 从属性文件里加载属性，并使用这些属性来替换变量。

• Spring 还允许在属性文件中使用 ${propName}，以实现属性之间的相互吸引。

  xml 文件：

  <!--导入属性文件-->
  <context:property-placeholder location="db.properties"/>
  
  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
      <!--使用外部化属性文件的属性-->
      <property name="user" value="${user}"/>
      <property name="password" value="${password}"/>
      <property name="driverClass" value="${driverClass}"/>
      <property name="jdbcUrl" value="${jdbcUrl}"/>
  </bean>

  properties 文件：

  user=root
  password=jie13727507037
  driverClass=com.mysql.cj.jdbc.Driver
  jdbcUrl=jdbc:mysql:///text?serverTimezone=UTC

  注意：mysql-connector-java 5版本之后的 driverClass 使用 com.mysql.cj.jdbc.Driver，同时还要在 jdbcUrl 后面加上 ?serverTimezone=UTC。

14、Spring 表达式语言：SpEL

Spring 表达式语言（简称 SpEL ）：是一个支持运行时查询和操作对象图的强大表达式语言。
语法类似于 EL：SpEL 使用 #{...} 作为定界符，所有在大括号中的字符都将被认为是 SpEL。
SpEL 为 bean 的属性进行动态赋值提供了便利。

通过 SpEL 可以实现：

• 赋字面值，如：int string Boolean double等类型的值

  <bean id="address" class="com.spring.beans.spel.Address">
      <!--使用 spel 为属性赋一个字面值-->
      <property name="city" value="#{'BeiJing'}"/>
      <property name="street" value="WuDaoKou"/>
  </bean>

• 通过 bean 的 id 对 bean 进行引用

  • 引用其他对象

• 调用方法以及引用对象中的属性

  • 引用其他对象的属性
  • 调用其他方法，还可以链式操作

  • 调用静态方法或静态属性：通过 T() 调用一个类的静态方法，它将返回一个 Class Object，然后再调用相应的方法或属性

    <bean id="car" class="com.spring.beans.spel.Car">
        <property name="brand" value="Audi"/>
        <property name="price" value="500000"/>
        <!--使用 spel 引用类的静态属性-->
        <property name="tyrePerimeter" value="#{T(java.lang.Math).PI * 80}"/>
    </bean>

• 计算表达式的值

  • 算术运算符：+，-，*，/，%，^；
  • 加号还可以用作字符串连接
  • 比较运算符：<，>，==，<=，>=；
  • 逻辑运算符：and，or，not
  • if-else（相当于三目运算符）运算符：?:(temary), ?:(Elvis)
  • if-else（相当于三目运算符）的变体
  • 正则表达式：matches

• 正则表达式的匹配

  <bean id="person" class="com.spring.beans.spel.Person">
  
      <!--<property name="car" ref="car"/>-->
      <!--使用 spel 来引用其他的 bean-->
      <property name="car" value="#{car}"/>
      <!--使用 spel 来引用其他 bean 的属性-->
      <property name="city" value="#{address.city}"/>
      <!--在 spel 中使用运算符-->
      <property name="info" value="#{car.price > 300000 ? '金领' : '白领'}"/>
      <property name="name" value="Tom"/>
  </bean>

15、IOC 容器中 Bean 的生命周期方法

• Spring IOC 容器可以管理 Bean 的生命周期，Spring 允许在 Bean 生命周期的特定点执行定制的任务。

• Spring IOC 容器对 Bean 的生命周期进行管理的过程：

  • 通过构造器或工厂方法创建 Bean 实例
  • 为 Bean 的属性设置值和其他 Bean 的引用
  • 调用 Bean 的初始化方法
  • Bean 可以使用了
  • 当容器关闭时，调用 Bean 的销毁方法

• 在 Bean 的声明里设置 init-method 和 destroy-method 属性，为 Bean 指定初始化和销毁方法。

  xml 代码：

  <bean id="car" class="com.spring.beans.cycle.Car"
        init-method="init" destroy-method="destroy">
      <property name="brand" value="Audi"/>
  </bean>

  java 代码：

  public static void main(String[] args) {
  
      //将 ctx 转换成 ClassPathXmlApplicationContext 类型才有关闭 IOC 容器的 close() 方法
      ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans-cycle.xml");
  
      Car car = (Car) ctx.getBean("car");
      System.out.println(car);
  
      //关闭 IOC 容器
      ctx.close();
  }

创建 bean 的后置处理器

• Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理。
• Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理，而非单一实例。其典型应用是：检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性。

• 对 Bean 后置处理器而言，需要实现 Interface BeanPostProcessor 接口。在初始化方法被调用前后，Spring 将把每个 Bean 实例分别传递给上述接口的一下两个方法：

  • public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            return null;
    }

  • public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            return null;
    }

• Spring IOC 容器对 Bean 的生命周期进行管理的过程：

  • 通过构造器或工厂方法创建 Bean 实例
  • 为 Bean 的属性设置值和其他 Bean 的引用
  • 将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
  • 调用 Bean 的初始化方法
  • 将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization 方法
  • Bean 可以使用了
  • 当容器关闭时，调用 Bean 的销毁方法

  <!--
      实现 BeanPostProcessor 接口，并具体提供两个方法
      Object postProcessBeforeInitialization(Object bean, String beanName)：init-method 之前被调用
      Object postProcessAfterInitialization(Object bean, String beanName)：init-method 之后被调用
      的实现
  
      bean：bean实例本身
      beanName：IOC 容器中配置的 bean 的名字
      返回值：是实际上返回给用户的那个 bean，注意可以在以上两个方法中修改返回的 bean，甚至返回一个新的 bean
  -->
  <!-- 配置 bean 的后置处理器：不需要配置 id，IOC 容器自动识别是一个 BeanPostProcessor -->
  <bean class="com.spring.beans.cycle.MyBeanPostProcessor"/>

16、通过工厂方法配置 Bean

通过调用静态工厂方法创建 Bean

• 调用静态工厂方法创建 Bean 是将对象创建的过程封装到静态方法中。当客户端需要对象时，只需要简单地调用静态方法，而不需要关心创建对象的细节。

• 要声明通过静态方法创建的 Bean， 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类，同时在 factory-method 属性里指定工厂方法的名称。最后，使用 <constructor-arg> 元素为该方法传递方法参数。

  /**
   * 静态工厂方法：直接调用某一个类的静态方法就可以返回 bean 的实例
   */
  public class StaticCarFactory {
  
      private static Map<String, Car> cars = new HashMap<String, Car>();
  
      static {
          cars.put("audi", new Car("audi", 300000));
          cars.put("ford", new Car("ford", 400000));
      }
  
      //静态工厂方法：
      public static Car getCar(String name) {
          return cars.get(name);
      }
  
  }

  <!--通过静态工厂方法来配置 bean， 注意不是配置静态工厂方法实例，而是配置 bean 实例-->
  <!--
      class 属性：指向静态工厂方法的全类名
      factory-method：指向静态工厂方法的名字
      constructor-arg：如果工厂方法需要传入参数，则使用 constructor-arg 来配置参数
  -->
  <bean id="car1"
        class="com.spring.beans.factory.StaticCarFactory"
        factory-method="getCar">
      <constructor-arg value="ford"/>
  </bean>

通过调用实例工厂方法创建 Bean

• 实例工厂方法：将对象的创建过程封装到另外一个对象实例的方法里。当客户端需要请求对象时，只需要简单的调用该实例方法而不需要关心对象的创建细节。

• 要声明通过实例工厂方法创建的 Bean

  • 在 bean 的 factory-bean 属性里指定拥有该工厂方法的 bean
  • 在 factory-method 属性里指定该工厂方法的名称
  • 使用 constructor-arg 元素为工厂方法传递方法参数

  /**
   * 实例工厂方法：实例工厂的方法，即先需要创建工厂本身，再调用工厂的实例方法来返回 bean 的实例
   */
  public class InstanceCarFactory {
  
      private Map<String, Car> cars = null;
  
      public InstanceCarFactory() {
          cars = new HashMap<String, Car>();
          cars.put("audi", new Car("audi", 300000));
          cars.put("ford", new Car("ford", 00000));
      }
  
      public Car getCar(String brand) {
          return cars.get(brand);
      }
  
  }

  <!--配置工厂的实例-->
  <bean id="carFactory" class="com.spring.beans.factory.InstanceCarFactory"/>
  
  <!--通过实例工厂方法来配置 bean-->
  <!--
      factory-bean：指向实例工厂方法的bean
      factory-method：指向实例工厂方法的名字
      constructor-arg：如果工厂方法需要传入参数，则使用 constructor-arg 来配置参数
  -->
  <bean id="car2" factory-bean="carFactory" factory-method="getCar">
      <constructor-arg value="audi"/>
  </bean>

17、通过 FactoryBean 配置 Bean

CarFactoryBean 实现 FactoryBean 接口：

package com.spring.beans.factorybean;

import org.springframework.beans.factory.FactoryBean;

//自定义的 FactoryBean 需要实现 FactoryBean 接口
public class CarFactoryBean implements FactoryBean<Car> {

    private String brand;

    public void setBrand(String brand) {
        this.brand = brand;
    }

    //返回 bean 的对象
    @Override
    public Car getObject() throws Exception {
        return new Car(brand, 500000);
    }

    /**
     * 返回的 bean 的类型
     */
    @Override
    public Class<?> getObjectType() {
        return Car.class;
    }

    //该 bean 是否为单例的
    @Override
    public boolean isSingleton() {
        return true;
    }

}

FactoryBean 的 xml 文件：

<!--
    通过 FactoryBean 来配置 Bean 的实例
    class：指向 FactoryBean 的全类名
    property：配置 FactoryBean 的属性

    但实际返回的实例却是 FactoryBean 的 getObject() 方法返回的实例！
-->
<bean id="car" class="com.spring.beans.factorybean.CarFactoryBean">
    <property name="brand" value="BMW"/>
</bean>