Spring-11 ， bean的生命周期

bean的生命周期

Spring IOC容器管理应用中所需要使用到的bean，包括他们的创建，初始化和管理这些对象。

Spring IOC容器管理这些bean，bean的生命周期包括：

1. IOC容器通过构造器或者工厂方法等创建bean实例。

2. 为bean的属性赋值或者引用其他的bean

3. 调用bean的初始化方法（bean的init-method属性指定初始化方法）

4. 使用bean

5. 容器关闭时，调用bean的销毁方法（bean的destroy-method属性指定销毁方法）

新建一个类

Car.java

package com.tuxianchao.spring.beanCycle;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Car {
private String brand;

public static void main(String[] args) {

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beanCycle.xml");
Car car = (Car) ctx.getBean("car");
System.out.println(car);
// 关闭IOC容器
ctx.close();
}

public Car() {
System.out.println("Car's constructor..");
}

public void setBrand(String brand) {
System.out.println("Car's setBrand...");
this.brand = brand;
}

/**
* 初始化方法
*/
public void init() {
System.out.println("init method...");
}

/**
* 销毁方法
*/
public void destroy() {
System.out.println("destroy method...");
}

@Override
public String toString() {
return "Car [brand=" + brand + "]";
}

}

配置bean

<!-- 通过init-method和destroy-method指定bean的初始化和销毁方法 -->
<bean id="car" class="com.tuxianchao.spring.beanCycle.Car"
init-method="init" destroy-method="destroy">
<property name="brand" value="audi"></property>
</bean>

bean 的生命周期



首先通过构造函器创建bean，然后通过setter注入配置文件中的属性值，然后调用bean的初始化方法，再然后使用bean，最后在容器关闭的时候调用bean的销毁方法。

bean的后置处理器

根据spring官方的reference文档的说法：

BeanPostProcessor

定义了回调方法，通过实现这个回调方法，你可以提供你自己的(或者重写容器默认的) 实例化逻辑，依赖分析逻辑等等。如果你想在Spring容器完成实例化配置，实例化一个bean之后，实现一些自定义逻辑 你可以插入一个或多个

BeanPostProcessor

的实现。

你可以配置多个

BeanPostProcessor

实例，同时你也能通过设置 order 属性来控制这些

BeanPostProcessors

的执行顺序。只有

BeanPostProcessor

实现了Ordered 接口，你才可以设置 order 属性。如果，你编写了自己的

BeanPostProcessor

也应当考虑实现 Ordered 接口

也就是说，bean的就后置处理器允许在bean的初始化方法前后对bean做一些外的处理,对于bean的后置处理器需要实现接口

BeanPostProcessor

，在接口中传入bean的实例



tip:bean的后置处理是对IOC容器里所有的bean进行逐一处理，而非单个bean实例

使用bean的后置处理器

首先新建一个类实现

BeanPostProcessor

接口，给出接口中方法的实现

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

/**
* bean的后置处理器（个人感觉这个玩意儿权限异常的大，能做的事情异常的多）
*
* bean的后置处理器允许IOC容器在创建bean实例调用bean的init-method之前和调用对bean进行额外的处理
*
* bean的后置处理器对IOC容器里的所有bean进行逐一检查处理，而不是只检查处理某个单一的bean
*
* 使用bean的后置处理器
*
* 1.实现BeanPostProcessor接口,并且提供两个处理方法的实现
*
* 2.在bean配置文件中配置后置处理器
*
* @author tuxianchao
*
*/
public class MyBeanPostProcessor implements BeanPostProcessor {

/*
* 在bean的init方法被调用之前调用
*
* 参数bean，处理的bean
*
* 参数beanName，处理的bean的id
*
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessBeforeInitialization:" + bean + "," + beanName);
// bean的处理
// ....
// 返回bean
return bean;
}

/*
* 在bean的init方法被调用之后调用
*
* 参数bean，被处理的bean
*
* 参数bean，被处理的bean的id
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessAfterInitialization:" + bean + "," + beanName);
// bean的处理
// ....
// 返回bean
return bean;
}

}

然后在bean的配置文件中配置后置处理器

<!--配置bean的后置处理器 ，无需额外的配置，只需要配置一个实现了后置处理接口的bean即可，会自动识别 -->
<bean class="com.tuxianchao.spring.beanCycle.MyBeanPostProcessor"></bean>

测试：



在bean的初始化方法调用前后，分别调用了postprocessBeforeInitialization和postProcessAfterInitialization方法。