配置 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>