Spirng4-快速入门之Bean的生命周期

BeanFacotry中Bean的生命周期

借用一张图来描述BeanFactory中Bean的生命周期

1.当调用者通过getBean()方法获取某一个bean时，如果容器注册了InstantiationAwareBeanPostProcessor后处理器，则会在bean实例化之前调用该接口的postProcessBeforeInstantiation(Class<?> beanClass, StribeanName)方法
2.实例化bean（一般是根据构造函数实例化，也可以根据工厂方式实例化，可自行选择）
3.如果容器实现了InstantiationAwareBeanPostProcessor接口，则会在bean实例化完成后调用该接口的postProcessAfterINstantiation()方法,然后在设置属性值之前调用该接口的postPorcessPropertyValues()方法
4.为bean实例设置默认的属性值后，如果该bean实现了BeanNameAware接口，则会在设置完属性值后，调用setBeanName()方法，将该bean的名称配置到bean中
5.如果bean实现了BeanFactoryAware接口，则会调用setBeanFacory()方法，将BeanFactory实例设置到bean中
6.如果容器装配了BeanPostProcessor后处理器，会调用该处理器的postProcessBeforeInitialization(Object bean, String beanName)方法
7.如果该bean实现了InitializingBean接口，则会调用该接口的afterPropertiesSet()方法
8.如果在<bean>里使用了init-method属性定义了初始化的方法，则此时会执行这个方法
9.如果容器装配了BeanPostProcessor后处理器，会调用该处理器的postProcessAfterInitialization(Object bean, String beanName)方法
10.如果在<bean>里指定了作用范围为scope=”prototype”，则将bean返回给调用者，由调用者负责bean后续的生命管理，Spring容器不在管理这个bean的生命周期；如果在<bean>里指定了作用范围为scope=”singleton”，则将bean放入到容器的缓存池里，并将bean返回给调用者，Spring容器继续管理这个bean的生命周期
11.对于在<bean>里指定了作用范围为scope=”singleton”的bean，当容器关闭时，会出发Spring容器对bean后续的生命的管理，如果该bean实现了DisposableBean接口，则会调用该接口的destory()方法，如果在<bean>里使用了destory-method属性定义了bean的销毁方法，则会执行这个方法，完成bean的资源释放等操作

简单的例子描述BeanFactory中Bean的生命周期

一个简单的Bean，实现了BeanFactoryAware，BeanNameAware，InitalizingBean，DisposableBean接口

public class NewCar implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {    private String brand;    private String color;    private String maxSpeed;    private BeanFactory beanFactory;    private String beanName;    public NewCar() {        System.out.println("调用NewCar的默认构造函数");    }    public void setBrand(String brand) {        System.out.println("调用setBrand()设置属性");        this.brand = brand;    }    public void setColor(String color) {        this.color = color;    }    public void setMaxSpeed(String maxSpeed) {        this.maxSpeed = maxSpeed;    }    public void introduce() {        System.out.println("brand:" + this.brand + ";color:" + this.color + ";maxSpeed:" + this.maxSpeed);    }    @Override    public void destroy() throws Exception {        System.out.println("调用DisposableBean.destory()方法");    }    @Override    public void afterPropertiesSet() throws Exception {        System.out.println("调用InitialzingBean.afterPropertiesSet()方法");    }    @Override    public void setBeanName(String name) {        System.out.println("调用BeanFactoryAware.setBeanName()方法");        this.beanName = name;    }    @Override    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {        System.out.println("调用BeanFactoryAware.setBeanFactory()方法");        this.beanFactory = beanFactory;    }    public void myInit() {        System.out.println("调用init-method所指定的myInit()，将maxSpeed设置为240");        this.maxSpeed = "240";    }    public void myDestory() {        System.out.println("调用destroy-method所指定的myDestory()");    }}

InstantiationAwareBeanPostProcessor的实现类，Spring提供了一个适配类InstantiationAwareBeanPostProcessorAdapter，可以通过集成这个类来实现InstantiationAwareBeanPostProcessor后处理器

public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter{    //在实例化bean之前调用    @Override    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {        if("newCar".equals(beanName)) {            System.out.println("InstantiationAware BeanPostProcessor.postProcessBeforeInitialization()");        }        return null;    }    @Override    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {        if("newCar".equals(beanName)) {            System.out.println("222InstantiationAware BeanPostProcessor.postProcessBeforeInitialization()");        }        return bean;    }    //在实例化bean后调用    @Override    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {        if("newCar".equals(beanName)) {            System.out.println("InstantiationAware BeanPostProcessor.postProcessAfterInitialization()");        }        return true;    }    @Override    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {        if("newCar".equals(beanName)) {            System.out.println("222InstantiationAware BeanPostProcessor.postProcessAfterInitialization()");        }        return bean;    }    //在设置某个属性时调用    @Override    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean,            String beanName) throws BeansException {        if("newCar".equals(beanName)) {            System.out.println("InstantiationAware BeanPostProcessor.postProcessPropertyValues()");        }        return pvs;    }}这里需要注意的是，InstantiationAwareBeanPostProcessor是BeanPostProcessor的子接口，所以上面的实现类中会有两个postProcessBeforeInstantiation和postProcessAfterInstantiation方法//在实例化bean之前调用    @Override    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {        if("newCar".equals(beanName)) {            System.out.println("InstantiationAware BeanPostProcessor.postProcessBeforeInitialization()");        }        return null;    }    @Override    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {        if("newCar".equals(beanName)) {            System.out.println("222InstantiationAware BeanPostProcessor.postProcessBeforeInitialization()");        }        return bean;    }    //在实例化bean后调用    @Override    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {        if("newCar".equals(beanName)) {            System.out.println("InstantiationAware BeanPostProcessor.postProcessAfterInitialization()");        }        return true;    }    @Override    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {        if("newCar".equals(beanName)) {            System.out.println("222InstantiationAware BeanPostProcessor.postProcessAfterInitialization()");        }        return bean;    }可以根据参数的不同区分，前者会在bean实例化之前和之后执行，后者会在上面描述的第6步和第9步执行

BeanPostProcessor的实现类

public class MyBeanPostPorcessor implements BeanPostProcessor{    @Override    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {        if("newCar".equals(beanName)) {            NewCar newCar = (NewCar) bean;            System.out.println("调用BeanPostProcessor.postProcessBeforeInitialization，把newCar的颜色改为绿色");            newCar.setColor("绿色");        }        return bean;    }    @Override    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {        if("newCar".equals(beanName)) {            NewCar newCar = (NewCar) bean;            System.out.println("调用BeanPostProcessor.postProcessAfterInitialization，把newCar的速度改为300");            newCar.setMaxSpeed("300");        }        return bean;    }}

配置文件bean.xml

  <!-- init-method指定初始化时调用的方法，destory-method指定销毁时调用的方法 -->  <bean id="newCar" class="com.spring4.chpter4.NewCar" init-method="myInit" destroy-method="myDestory" scope="singleton">    <property name="brand" value="NEW棉花糖黄金版"></property>    <property name="color" value="黄色"></property>    <property name="maxSpeed" value="150"></property>  </bean>

Bean生命周期的测试类

public class BeanLifeCycle {    private static void LifeCycleInBeanFactory() {        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();        Resource resource = resolver.getResource("classpath:com/spring4/chpter4/bean.xml");        BeanFactory factory = new DefaultListableBeanFactory();        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((BeanDefinitionRegistry) factory);        reader.loadBeanDefinitions(resource);        //向容器中注入MyInstantiationAwareBeanPostProcessor后处理器        ((ConfigurableBeanFactory)factory).addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());        //向容器中注入MyBeanPostProcessor后处理器        ((ConfigurableBeanFactory)factory).addBeanPostProcessor(new MyBeanPostPorcessor());        //第一次从容器中获取bean，容器会实例化该bean，引发bean级的生命周期方法的调用        NewCar newCar = factory.getBean("newCar",NewCar.class);        newCar.introduce();        newCar.setColor("红色");        //第二次获取bean，直接从缓存池中获取        NewCar newCar2 = factory.getBean("newCar",NewCar.class);        //查看newCar和newCar2是否指向同一引用        System.out.println(newCar == newCar2);        //关闭容器        ((DefaultListableBeanFactory)factory).destroySingletons();    }    public static void main(String[] args) {        LifeCycleInBeanFactory();    }}

执行结果如下：

ApplicationContext中Bean的生命周期

Bean在AppliationContext中的生命周期和在BeanFactory中类似，不同的是如果该Bean实现了ApplicationContextAware接口，则会增加一个调用该接口setApplicationContext()方法的步骤，具体流程如下图

可参考上面BeanFactory中Bean的生命周期
描述ApplicationContext中Bean的生命周期的实例
BeanFactoryPostProcessor实现类

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor{    @Override    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {        System.out.println("调用BeanFactoryPostProcessor.postProcessBeanFactory方法");    }}

bean.xml配置文件

<!-- init-method指定初始化时调用的方法，destory-method指定销毁时调用的方法 -->  <bean id="newCar" class="com.spring4.chpter4.NewCar" init-method="myInit" destroy-method="myDestory" scope="singleton">    <property name="brand" value="NEW棉花糖黄金版"></property>    <property name="color" value="黄色"></property>    <property name="maxSpeed" value="150"></property>  </bean>  <!-- 下面3个Bean会在ApplicationContext启动时自动被识别，并注册到容器中 -->  <bean id="myBeanFactoryPostProcessor" class="com.spring4.chpter4.MyBeanFactoryPostProcessor"></bean>  <bean id="myBeanPostPorcessor" class="com.spring4.chpter4.MyBeanPostPorcessor"></bean>  <bean id="myInstantiationAwareBeanPostProcessor" class="com.spring4.chpter4.MyInstantiationAwareBeanPostProcessor"></bean>

Bean生命周期的测试类

public class ApplicationLifeCycle {    private static void LifeCycleInApplicationContext() {        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*:com/spring4/chpter4/bean.xml");        //实例化bean        NewCar newCar = context.getBean("newCar",NewCar.class);        newCar.introduce();        //关闭容器        context.close();    }    public static void main(String[] args) {        LifeCycleInApplicationContext();    }}

执行结果如下：

最后有个问题

使用下面这种方式无法为ApplicationContext容器注册后处理器，求知道的大神指导

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*:com/spring4/chpter4/bean.xml");        //向容器中注入MyBeanFactoryPostProcessor后处理器        context.addBeanFactoryPostProcessor(new MyBeanFactoryPostProcessor());        //向容器中注入MyInstantiationAwareBeanPostProcessor后处理器        context.getBeanFactory().addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());        //向容器中注入MyBeanPostProcessor后处理器        context.getBeanFactory().addBeanPostProcessor(new MyBeanPostPorcessor());