Spring Bean 生命周期

说到Spring Bean的生命周期，有好多内容，大部分都用不到，除了几个关键点可以用到。以下图就描述了

 

 

 

 

上面的图就看看吧，我也不讲诉太多，就列举几个常见的，普通的流程吧。

在大部分情况下我们基本用的是适配器设计模式，就是一个class里面 调用其他其他class，并以属性形式注入存在。主要关注下初始化和销毁阶段的内容，

然后实现InitializingBean, DisposableBean，再然后写Bean 中的init-method和destroy-method，了解下其流程

我列举了一个Car，里面有个RedCar属性，来获取其名称。都是注解版

public class Car implements InitializingBean, DisposableBean
{
    private String name;
    private RedCar redCar;

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

    public String getName()
    {
        return name;
    }

    @Value("China Car")
    public void setName(String name)
    {
        System.out.println("Car设置属性");
        this.name = name;
    }

    public RedCar getRedCar()
    {
        return redCar;
    }
    
    @Autowired
    public void setRedCar(RedCar redCar)
    {
        System.out.println("Car内的RedCar设置属性");
        this.redCar = redCar;
    }

    public void myInit()
    {
        System.out.println("Car调用<bean>的init-method属性指定的初始化方法");
    }

    @Override
    public void afterPropertiesSet() throws Exception
    {
        System.out.println("Car调用InitializingBean的afterPropertiesSet");
    }

    @Override
    public void destroy() throws Exception
    {
        System.out.println("Car调用DisposableBean的destroy");
    }

    public void myDestroy()
    {
        System.out.println("Car调用<bean>的destroy-method属性指定的初始化方法");
    }
}

RedCar:

public class RedCar implements InitializingBean, DisposableBean
{
    private String name;

    public RedCar()
    {
        System.out.println("RedCar构造函数");
    }

    public String getName()
    {
        return name;
    }

    @Value("China RedCar")
    public void setName(String name)
    {
        System.out.println("RedCar设置属性");
        this.name = name;
    }

    @Override
    public void afterPropertiesSet() throws Exception
    {
        System.out.println("RedCar调用InitializingBean的afterPropertiesSet");
    }

    @Override
    public void destroy() throws Exception
    {
        System.out.println("RedCar调用DisposableBean的destroy");
    }

    public void myInit()
    {
        System.out.println("RedCar调用<bean>的init-method属性指定的初始化方法");
    }

    public void myDestroy()
    {
        System.out.println("RedCar调用<bean>的destroy-method属性指定的初始化方法");
    }
}

其中@Autowired注解放在setxxx方法上，不要放在成员变量上，不然是不会执行setxxx的内容

然后写个Configuration注解注入Bean，并写上initMethod和destroyMethod方法

@Configuration
public class MyConfig
{
    @Bean(initMethod = "myInit", destroyMethod = "myDestroy")
    public Car getCar()
    {
        return new Car();
    }

    @Bean(initMethod = "myInit", destroyMethod = "myDestroy")
    public RedCar getRedCar()
    {
        return new RedCar();
    }
}

Main函数执行

public class Application
{
    public static void main(String[] args)
    {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
        String[] beanDefinitionNames = annotationConfigApplicationContext.getBeanDefinitionNames();
        
        Car car = annotationConfigApplicationContext.getBean(Car.class);
        annotationConfigApplicationContext.close();
    }
}

其中annotationConfigApplicationContext.close()是用来销毁Bean

运行结果如下

Car构造函数
Car设置属性
RedCar构造函数
RedCar设置属性
RedCar调用InitializingBean的afterPropertiesSet
RedCar调用<bean>的init-method属性指定的初始化方法
Car内的RedCar设置属性
Car调用InitializingBean的afterPropertiesSet
Car调用<bean>的init-method属性指定的初始化方法
Car调用DisposableBean的destroy
Car调用<bean>的destroy-method属性指定的初始化方法
RedCar调用DisposableBean的destroy
RedCar调用<bean>的destroy-method属性指定的初始化方法

总结：

1、先调用自己的无参数构造函数(你写个有参构造是没啥作用的)

2、再执行属性注入，就先调用属性类的构造函数

3、再注入属性类的属性

4、调用属性类的InitializingBean的afterPropertiesSet

5、调用属性类的init-method

6、再返回该类的属性setxxx

7、.....重复步骤

8、销毁的顺序要注意下，最后执行的属性类的销毁

 

然后Spring 又出现了一个后期处理加强的Bean处理 BeanPostProcessor 接口

这个BeanPostProcessor是针对所有的bean

代码如下：

@Component
public class MyPostProcessor implements BeanPostProcessor
{
    @Override
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException
    {
        System.out.println(String.format("BeanPostProcessor-postProcessBeforeInitialization:%s,%s", o, s));
        return o;
    }

    @Override
    public Object postProcessAfterInitialization(Object o, String s) throws BeansException
    {
        System.out.println(String.format("BeanPostProcessor-postProcessAfterInitialization:%s,%s", o, s));
        return o;
    }
}

运行如下：

Car构造函数
Car设置属性
RedCar构造函数
RedCar设置属性
BeanPostProcessor-postProcessBeforeInitialization:dto.RedCar@70b0b186,getRedCar
RedCar调用InitializingBean的afterPropertiesSet
RedCar调用<bean>的init-method属性指定的初始化方法
BeanPostProcessor-postProcessAfterInitialization:dto.RedCar@70b0b186,getRedCar
Car内的RedCar设置属性
BeanPostProcessor-postProcessBeforeInitialization:dto.Car@ba8d91c,getCar
Car调用InitializingBean的afterPropertiesSet
Car调用<bean>的init-method属性指定的初始化方法
BeanPostProcessor-postProcessAfterInitialization:dto.Car@ba8d91c,getCar
Car调用DisposableBean的destroy
Car调用<bean>的destroy-method属性指定的初始化方法
RedCar调用DisposableBean的destroy
RedCar调用<bean>的destroy-method属性指定的初始化方法

总结：

postProcessBeforeInitialization和postProcessAfterInitialization是在InitializingBean和init-method之前后执行的。

postProcessBeforeInitialization是前

postProcessAfterInitialization是后

 

其他的不说了，说多了记不住，最后一句话概括，bean的生命周期先自身构造再调用依赖后再回来执行自己，销毁顺序反向，先自己销毁再销毁依赖的，BeanPostProcessor就是在初始化中前后执行。