Bean 的生命周期

一个受 Spring 管理的 bean，生命周期主要阶段有

1. 创建：根据 bean 的构造方法或者工厂方法来创建 bean 实例对象
2. 依赖注入：根据 @Autowired，@Value 或其它一些手段，为 bean 的成员变量填充值、建立关系
3. 初始化：回调各种 Aware 接口，调用对象的各种初始化方法
4. 销毁：在容器关闭时，会销毁所有单例对象（即调用它们的销毁方法）

• prototype 对象也能够销毁，不过需要容器这边主动调用

package com.mangoubiubiu.show;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.logging.Logger;

@Slf4j
@Component
public class LifeCycleBean {


    public LifeCycleBean(){log.info("构造");}

    @Autowired
    public void autowire(@Value("${JAVA_HOME}") String home){
        log.info("依赖注入：{}",home);
    }



    @PostConstruct
    public void init(){
        log.info("初始化");
    }

    @PostConstruct
    public void destory(){
        log.info("销毁");
    }


}

一些资料会提到，生命周期中还有一类 bean 后处理器：BeanPostProcessor，会在 bean 的初始化的前后，提供一些扩展逻辑。但这种说法是不完整的，见下面的演示1

演示1 - bean 生命周期

创建前后的增强

• postProcessBeforeInstantiation

• 这里返回的对象若不为 null 会替换掉原本的 bean，并且仅会走 postProcessAfterInitialization 流程

• postProcessAfterInstantiation

• 这里如果返回 false 会跳过依赖注入阶段

依赖注入前的增强

• postProcessProperties

• 如 @Autowired、@Value、@Resource

初始化前后的增强

• postProcessBeforeInitialization

• 这里返回的对象会替换掉原本的 bean
• 如 @PostConstruct、@ConfigurationProperties

• postProcessAfterInitialization

• 这里返回的对象会替换掉原本的 bean
• 如代理增强

销毁之前的增强

• postProcessBeforeDestruction

• 如 @PreDestroy 

package com.mangoubiubiu.show;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.stereotype.Component;

import java.beans.PropertyDescriptor;

@Slf4j
@Component
public class MyBeanPostProcessor implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor {
    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
        if(beanName.equals("lifeCycleBean"))
            log.info("<<<<<<<销毁之前执行，如 @PreDestory");
    }


    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if(beanName.equals("lifeCycleBean"))
            log.info("<<<<<<<实例化之前执行，这里返回的对象会替换掉原本的bean");
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if(beanName.equals("lifeCycleBean"))
            log.info("<<<<<<<实例化之后执行，这里返回false会跳过依赖注入阶段");
        return false;
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if(beanName.equals("lifeCycleBean"))
            log.info("<<<<<<<依赖注入阶段执行，如@Autowired 、 @Value、@Resource");
        return pvs;
    }


    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if(beanName.equals("lifeCycleBean"))
            log.info("<<<<<<初始化之前执行，这里返回的对象会替换掉原本的bean , @PostConstruct、@ConfigurationProperties");

        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if(beanName.equals("lifeCycleBean"))
            log.info("<<<<<<初始化之后执行，这里返回的对象会替换掉原本的bean , 如代理增强");
        return null;
    }
}