spring的bean的生命周期

Spring的bean生命周期分为11步

1、初始化bean，调用构造函数，创建bean实例
2、对其bean的属性进行注入赋值
3、如果bean实现BeanNameAware接口，执行setBeanName方法
4、如果bean实现BeanFactoryAware或ApplicationContextAware接口，将会执行setBeanFactory方法，可以获取到上下文对象BeanFactory
5、如果有其他类实现了BeanPostProcessor接口，将会执行postProcessBeforeInitialization方法
6、如果bean实现InitializingBean接口，将执行afterPropertiesSet方法
7、我们可以自定义一个bean类的初始化方法，例如：initBean方法,这个需要在配置文件中设置，才能执行
8、这一步跟第五步是同一个类，也就是其他类实现了BeanPostProcessor接口，但它将会执行postProcessAfterInitialization方法
9、这是执行的我们自己将要执行的业务方法，这里举例使用show方法
10、如果bean实现DisposableBean接口，将会执行destroy方法
11、可以自定义一个bean类的销毁方法，例如：destroyBean方法,这个需要在配置文件中设置，才能执行

第五步和第八步可以对bean进行功能增强，一般会使用动态代理技术，也是spring的AOP（面向切面）编程的方式

上面列举了具体的11步，下面使用一个例子列举

这是bean类
LifeCycleBean.java

package cn.ioc.lifecycle;

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 LifeCycleBean implements BeanNameAware,BeanFactoryAware,InitializingBean,DisposableBean{
    private String info;

    public LifeCycleBean() {
        super();
        System.out.println("第一步：使用无参构造实例化对象");
    }

    public void setInfo(String info) {
        System.out.println("第二步：info属性封装");
        this.info = info;
    }

    public void show(){
        System.out.println("第九步：这是我自己定义的一个方法，执行我的业务"+info);
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("第三步：获取BeanName的名字--"+name);

    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("第四步：获取到BeanFactory对象"+beanFactory);

    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("第六步：Spring自带的Bean初始化");
    }

    public void initBean(){
        System.out.println("第七步：这是我自己定义的一个Bean初始化");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("第十步：这是Spring自带的Bean清除");
    }

    public void destroyBean(){
        System.out.println("第十一步：这是我自己定义的一个Bean清除");
    }
}

这个一个实现了BeanPostProcessor接口的类
ProxyBean.java

package cn.ioc.lifecycle;

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

public class ProxyBean implements BeanPostProcessor{

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第五步：代理类的初始化Bean"+"  "+bean+"   执行的类名："+beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第八步：代理类的后处理Bean"+"  "+bean+"   执行的类名："+beanName);
        return bean;
    }

}

配置文件：
applicationContext.xml

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

    <!-- 指定实现了BeanPostProcessor接口的类 -->
    <bean class="cn.ioc.lifecycle.ProxyBean"></bean>

    <!-- init-method:指定自定义初始化方法名称
         destroy-method:指定自定义销毁方法名称
     -->
    <bean name="LifeCycleBeanTest" class="cn.ioc.lifecycle.LifeCycleBean" init-method="initBean" destroy-method="destroyBean">
        <!-- 为bean类的属性赋值 -->
        <property name="info" value="spring生命周期展示"></property>
    </bean>
</beans>

测试类
LifeCycleTest.java

package cn.ioc.test;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.ioc.lifecycle.LifeCycleBean;

public class LifeCycleTest {
    @Test
    public void test1(){
        //读取配置文件
        ClassPathXmlApplicationContext  applicationContex = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        //获取bean对象
        LifeCycleBean bean = (LifeCycleBean) applicationContex.getBean("LifeCycleBeanTest");
        //自定义方法执行
        bean.show();
        //关闭时，bean对象销毁
        applicationContex.close();
    }
}

测试结果：

第一步：使用无参构造实例化对象
第二步：info属性封装
第三步：获取BeanName的名字--LifeCycleBeanTest
第四步：获取到BeanFactory对象org.springframework.beans.factory.support.DefaultListableBeanFactory@544fe44c: defining beans [cn.ioc.lifecycle.ProxyBean#0,LifeCycleBeanTest]; root of factory hierarchy
第五步：代理类的初始化Bean  cn.ioc.lifecycle.LifeCycleBean@4eb7f003   执行的类名：LifeCycleBeanTest
第六步：Spring自带的Bean初始化
第七步：这是我自己定义的一个Bean初始化
第八步：代理类的后处理Bean  cn.ioc.lifecycle.LifeCycleBean@4eb7f003   执行的类名：LifeCycleBeanTest
第九步：这是我自己定义的一个方法，执行我的业务spring生命周期展示
第十步：这是Spring自带的Bean清除
第十一步：这是我自己定义的一个Bean清除