前置文章：
Spring原理分析-容器&Bean（一）
前置文章主要讲了：BeanFactory原生功能，ApplicationContext拓展功能，Bean&BeanFactory后置处理器添加及调用，ApplicationContext常见实现类 等。

零、本文纲要

• 一、Bean生命周期
  1、Bean生命周期测试
  2、生命周期顺序
• 二、自定义BeanPostProcessor实现增强
• 三、模板方法-设计模式

一、Bean生命周期

1、Bean生命周期测试

• ① 编写LifeCycleBean类

@Component
public class LifeCycleBean {
    private static final Logger log = LoggerFactory.getLogger(LifeCycleBean.class);

    public LifeCycleBean() {
        log.debug("构造方法()");
    }

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

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

    @PreDestroy
    public void destroy() {
        log.debug("销毁方法()");
    }
}

• ② 编写启动类

@SpringBootApplication
public class Demo03 {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Demo03.class, args);
        context.close();
    }
}

• ③ 测试

Bean生命周期.png

2、生命周期顺序

执行顺序：构造方法 → @Autowired → @PostConstruct → @PreDestroy

二、自定义BeanPostProcessor实现增强

• ① 实现InstantiationAwareBeanPostProcessor与DestructionAwareBeanPostProcessor接口

Ⅰ postProcessBeforeDestruction：销毁前执行，如@PreDestroy；
Ⅱ postProcessBeforeInstantiation：实例化前执行，返回的对象会替换原本的bean；
Ⅲ postProcessAfterInstantiation：实例化后执行，返回的对象会替换原本的bean；
Ⅳ postProcessProperties：依赖注入阶段执行，如@Autowired、@Value、@Resource；
Ⅴ postProcessBeforeInitialization：初始化前执行，返回的对象会替换原本的bean，如@PostConstruct、@ConfigurationProperties；
Ⅵ postProcessAfterInitialization：初始化后执行，，返回的对象会替换原本的bean，如代理增强。

@Component
public class OwnBeanPostProcessor implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor {

    private static final Logger log = LoggerFactory.getLogger(OwnBeanPostProcessor.class);

    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean"))
            log.debug("━━|━━|━━|━━ 销毁之前执行, 如 @PreDestroy");
    }

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

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

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

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

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

• ② 测试

image.png

三、模板方法-设计模式

• ① 编写测试类

public class TestTemplatePattern {
    public static void main(String[] args) {
        MyBeanFactory beanFactory = new MyBeanFactory();
        beanFactory.getBean();
    }

    static class MyBeanFactory{
        public Object getBean(){
            Object bean = new Object();
            System.out.println("CONSTRUCTOR ====>" + bean);
            System.out.println("DEPENDENCE INJECT ====>" + bean);
            System.out.println("INITIALIZATION ====>" + bean);
            return bean;
        }
    }
}

模板方法模式使用前.png

• ② 编写后置处理器接口

static interface MyBeanPostProcessor{
    public void postProcessMethod(Object bean);
}

• ③ 修改MyBeanFactory类

添加如下属性，及方法：

private List<MyBeanPostProcessor> processors = new ArrayList<>();

public void addBeanPostProcessor(MyBeanPostProcessor beanPostProcessor){
    processors.add(beanPostProcessor);
}

public Object getBean(){
    Object bean = new Object();
    System.out.println("CONSTRUCTOR ====>" + bean);
    System.out.println("POST PROCESS PROPERTIES ====>" + bean);
    for (MyBeanPostProcessor processor : processors) {
        processor.postProcessMethod();
    }
    System.out.println("INITIALIZATION ====>" + bean);
    return bean;
}

此时，由于模板方法还没有实现，所以直接测试并没有变化。

• ④ 修改测试类main方法

通过匿名内部类形式实现接口中的方法，如下：

public static void main(String[] args) {
    MyBeanFactory beanFactory = new MyBeanFactory();
    beanFactory.addBeanPostProcessor(() -> System.out.println("PARSING @Autowired"));
    beanFactory.addBeanPostProcessor(() -> System.out.println("PARSING @Resource"));
    beanFactory.getBean();
}

模板方法模式使用后.png

四、结尾

以上即为Spring原理分析-容器&Bean（二）的全部内容，感谢阅读。