Spring Bean生命周期

定义类与

public class Result implements Serializable , BeanNameAware, BeanFactoryAware , ApplicationContextAware,
        InitializingBean, DisposableBean {

    private static final long serialVersionUID = -645547982453859521L;
    private Integer status;


    public Result() {
        System.out.println("构造方法...1");
    }



    @PostConstruct
    public void postConstruct(){
        System.out.println("postConstruct...7");
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        System.out.println("setStatus...2");
        this.status = status;
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("BeanNameAware...3");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryAware...4");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("ApplicationContextAware....5");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean afterPropertiesSet ...8");
    }



    public void initBean(){
        System.out.println("init-method...9");
    }

    @PreDestroy
    public void preDestroy(){
        System.out.println("preDestroy....11");
    }

    @Override
    public void destroy(){
        System.out.println("destroy....12");
    }


}

外部类BeanPostProcessor

public class ResultBeanPostPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if(beanName.equalsIgnoreCase("result")) {
            System.out.println("BeanPostProcessor postProcessBeforeInitialization.... 6 ");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if(beanName.equalsIgnoreCase("result")) {
            System.out.println("BeanPostProcessor postProcessAfterInitialization....10  ");
        }
        return bean;
    }
}

BeanFactoryPostProcessor

public class ResultBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    /**
     * org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization(org.springframework.beans.factory.config.ConfigurableListableBeanFactory)
     * @param beanFactory
     * @throws BeansException
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryPostProcessor....0");
    }
}

一个工厂类

public class ResultFactoryBean {

    public static Result getResultStatic(){
        System.out.println("ResultFactoryBean...");
        return new Result();
    }
}

xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">

    <context:annotation-config/>

    <bean id="result" class="com.liu.me.entity.ResultFactoryBean" factory-method="getResultStatic">


    </bean>

  <!--  <bean id="result" class="com.liu.me.entity.Result"

          init-method="initBean" destroy-method="destroy">
        <property name="status" value="200"/>

    </bean>-->

    <bean class="com.liu.me.entity.ResultBeanPostPostProcessor"/>
    <bean class="com.liu.me.entity.ResultBeanFactoryPostProcessor"/>

</beans>

测试类

public class IOCTest {


    @Test
    public void  beanTest(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        Result bean = context.getBean(Result.class);

        context.close();
    }
}

结果
BeanFactoryPostProcessor…0 (这步是BeanFactory初化后增强)
ResultFactoryBean…
构造方法…1
BeanNameAware…3
BeanFactoryAware…4
ApplicationContextAware…5
BeanPostProcessor postProcessBeforeInitialization… 6
postConstruct…7
InitializingBean afterPropertiesSet …8
BeanPostProcessor postProcessAfterInitialization…10
preDestroy…11
destroy…12

不使用工厂

结果
BeanFactoryPostProcessor…0
构造方法…1
setStatus…2
BeanNameAware…3
BeanFactoryAware…4
ApplicationContextAware…5
BeanPostProcessor postProcessBeforeInitialization… 6
postConstruct…7
InitializingBean afterPropertiesSet …8
init-method…9
BeanPostProcessor postProcessAfterInitialization…10
preDestroy…11
destroy…12

总结Spring生命周期

调用BeanFactoryPostProcessor的实现接口增强BeanFactory(工厂增强)

1. 根据配置情况调用Bean的构造方法或者工厂方法初如化实例化Bean
2. 利用依赖注入完成Bean的属性注入
3. 如果Bean实现BeanNameAware接口,Spring会调用Bean的setName方法传入当前Bean的id
4. 如果Bean实现BeanFactoryAware接口,Spring会调用Bean的setBeanFactory方法传入当前 工厂的实例
5. 如果Bean实现了ApplicationContextAware接口,Spring会调用Bean的setApplicationContext方法传入当前的ApplicationContext实例
6. 如果Bean和有实现的BeanPostProcessor 接口的类关联,Spring会调BeanPostProcessor实现类 的postProcessBeforeInitialization方法可以对Bean进行加工,增强,SpringAOP就是利用它实现的
7. 如果开启注解Bean中有@postConstruct注解的方法,则执行
8. 如果Bean和有实现InitializingBean接口,Spring会调用Bean中的afterPropertiesSet方法
9. 如果Bean和有配置init-method方法,Spring会调用配置的init-method方法
10. 如果Bean和有实现的BeanPostProcessor 接口的类关联,Spring会调BeanPostProcessor实现类 的postProcessAfterInitialization方法,这时Bean已经初始化
11. 如果 scope=“prototype” ，Spring会直接将初始化就绪的Bean交给调用者，不在管理这个Bean的生命周期
12. scope=“singleton” Spring会将这个Bean放入IOC容器的缓冲池中，进行生命周期管理
13. 被Spring管理的Bean在窗口关闭时先执行preDestroy方法
14. 如果有实现DisposableBean或者配置destroy-method方法，最后执行这个方法，进行Bean的销毁