BeanFactory中bean的生命周期

• BeanFactory在初始化容器，并未实例化Bean，直到第一次访问某个Bean时才实例化目标Bean。
  

  1. 当调用者通过getBean()向容器请求某一个Bean时，如果容器注册了org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor接口，则在实例化Bean之前调用postProcessBeforeInstantiation()方法。

  2. 根据配置情况调用Bean构造函数或者工厂方法实例化Bean。

  3. 如果容器注册了 org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor接口，则在实例化Bean之后，调用该接口的postProcessAfterInstantiation()方法。

  4. 如果Bean配置了属性信息，则在设置属性之前将调用 org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor接口的postProcessPropertyValues()方法。

  5. 调用Bean的属性设置方法设置属性值。

  6. 如果Bean实现了org.springframework.beans.factory.BeanNameAware接口，则将调用setBeanName()方法，将配置文件的Bean名称设置到Bean中。

  7. 如果Bean实现了org.springframework.beans.factory.BeanFactoryAware接口，则将调用setBeanFactory()方法，将BeanFactory容器实例设置到Bean中。

  8. 如果BeanFactory装配了org.springframework.beans.factory.config.BeanPostProcessor后处理器，则将调用接口的postProcessBeforeInitialization()方法对Bean进行加工操作。

  9. 如果Bean实现了org.springframework.beans.factory.InitializingBean接口，则将调用接口的afterPropertiesSet()方法。

  10. 如果在《bean》《/bean》标签中init-method属性定义了初始化方法，则将执行这个方法。

  11. 如果BeanFactory装配了org.springframework.beans.factory.config.BeanPostProcessor后处理器，则将调用接口的postProcessAfterInitialization()方法对Bean再次进行加工操作。

  12. 对于scope=”singleton”(默认),则将Bean放入springIOC容器的缓存池中，并将引用返回给调用者，spring继续对这些Bean进行后续的生命管理。对于scope=”prototype”,则将Bean返回给调用者，调用者负责Bean的后续生命的管理，spring不再管理这个Bean的生命周期。

  13. 对于scope=”singleton”(默认),容器关闭时，将触发spring对Bean的后续生命周期的管理。如果Bean实现了org.springframework.beans.factory.DisposableBean接口，则将调用接口的destroy()方法，可以编写释放日志，记录日志等。

  14. 对于scope=”singleton”(默认)的Bean，如果在《bean》《/bean》标签中destory-method属性定义了Bean的销毁方法，则spring将执行这个方法。

package com.test.pojo;

import java.beans.PropertyDescriptor;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;

public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {

    //在实例化bean之前执行
    public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        if("car".equals(beanName)){
            System.out.println("这是postProcessBeforeInstantiation方法===");
        }
        return null;
    }
    //在实例化bean之后执行
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        if("car".equals(beanName)){
            System.out.println("这是postProcessAfterInstantiation方法===");
        }
        return true;
    }
    //在设置那个属性的值的时候执行
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean,
            String beanName) throws BeansException {
        // TODO Auto-generated method stub
        if("car".equals(beanName)){
            System.out.println("这是postProcessPropertyValues方法===");
        }
        return pvs;
    }

}

package com.test.pojo;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class Car implements BeanFactoryAware,BeanNameAware,InitializingBean,DisposableBean{

    private String brand;
    private String color;
    private int maxSpeed;

    private String beanName;
    private BeanFactory beanFactory;

    public Car() {
        System.out.println("====调用构造函数====");
    }

    public void afterPropertiesSet() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("调用InitializingBean.afterPropertiesSet()。");
    }


    public void setBeanName(String name) {
        // TODO Auto-generated method stub
        System.out.println("调用了BeanNameAware.setBeanName()。");
        this.beanName=name;
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("调用了BeanFactoryAware.setBeanFactory()。");
        this.beanFactory=beanFactory;
    }


    public void destroy() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("这是DisposableBean.destory()的方法");
    }
    public void myInit(){
        System.out.println("这是我指定的初始化方法,默认将maxSpeed设为240。");
        this.maxSpeed=240;
    }
    public void myDestory(){
        System.out.println("这是我的销毁方法");
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        System.out.println("这是setBrand方法");
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        System.out.println("这是setColor方法");
        this.color = color;
    }

    public int getMaxSpeed() {
        return maxSpeed;
    }

    public void setMaxSpeed(int maxSpeed) {
        System.out.println("这是setMaxSpeed方法");
        this.maxSpeed = maxSpeed;
    }

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

}

package com.test.pojo;

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

public class MyBeanPostProcessor implements BeanPostProcessor {


    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        if("car".equals(beanName)){
            Car car=(Car)bean;
            if(car.getColor()==null){
                System.out.println("这是postProcessBeforeInitialization方法===");
                car.setColor("黑色");;
            }

        }
        return bean;
    }


    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        if("car".equals(beanName)){
            Car car=(Car)bean;
            if(car.getMaxSpeed()>=200){
                System.out.println("postProcessAfterInitialization方法===");
                car.setMaxSpeed(200);
            }
        }
        return bean;
    }

}

package com.test.spring;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import com.test.pojo.Car;
import com.test.pojo.MyBeanPostProcessor;
import com.test.pojo.MyInstantiationAwareBeanPostProcessor;
public class StudentSpring {
    protected Logger logger = Logger.getLogger(this.getClass());


    public static void main(String[] args) {
        Resource resource = new ClassPathResource("spring/applicationContext-dao.xml");
        BeanFactory bf=new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((DefaultListableBeanFactory)bf);
        reader.loadBeanDefinitions(resource);
        ((DefaultListableBeanFactory)bf).addBeanPostProcessor(new MyBeanPostProcessor());
        ((DefaultListableBeanFactory)bf).addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());
        Car car1 = (Car)bf.getBean("car");
        Car car2 = (Car)bf.getBean(Car.class);
        System.out.println(car1.toString()+"::"+car2.toString());
        System.out.println(car1==car2);
        ((DefaultListableBeanFactory)bf).destroySingletons();
    }
}