spring底层自用学习笔记（三） bean的生命周期与模板设计模式

1.spring bean生命周期各个阶段

@SpringBootApplication
public class A03Application {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(A03Application.class, args);
        //展示销毁阶段
        context.close();
    }
}

新建一个bean打印日志方便看生命周期

@Component
@Slf4j
public class LifeCycleBean {

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

    @Autowired
    //方法上加了@Autowired注解，会根据入参类型查找注入对应类
    //入参是String类型，默认是不会当成特殊的bean做依赖注入的，除非加了@Value注解
    public void autowire(@Value("${JAVA_HOME}") String home){
        log.debug("依赖注入:{}", home);
    }

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

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

这时启动发现日志如下

之前我们提到过后处理器，
bean工厂后处理器主要补充beanDefination定义的，
bean后处理器是提供bean各个生命周期阶段的扩展。

我们这里创建一个MybeanPostProcessor，实现了InstantiationAwareBeanPostProcessor与DestructionAwareBeanPostProcessor接口，重写其中比较重要的6个方法

@Slf4j
@Component
public class MybeanPostProcessor implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor {

    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
        //这里加了if,只在lifeCycleBean的销毁方法时做打印
        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;
    }
}

【实例化】与【初始化】的区别：

「实例化」：实例化是创建类的实例的过程。在Spring中，当一个Bean被定义在配置文件中（或者通过其他方式如注解或Java配置），Spring
IoC容器就会实例化这个Bean。实例化通常通过调用类的无参数构造函数来完成。这个步骤产生了一个Bean的实例，但是这个实例的属性尚未被设置。

「初始化」：初始化是在Bean实例化后、使用前的一个阶段，主要是对Bean进行一些定制化的设置，比如设置属性的值、执行某些方法等。在Spring中，你可以通过实现InitializingBean接口，或者使用@PostConstruct注解，或者在XML配置中定义，来定义Bean的初始化逻辑。

实例化和初始化的关键代码在方法AbstractAutowireCapableBeanFactory#doCreateBean。

然后我们看一下输出日志

结合LifeCycleBean的日志，可以看到几个方法（实际也就是一些注解）的执行时机

2.模板方法设计模式

public class TestMethodTemplate {

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

    //模板方法 Template Method Pattern
    static class MyBeanFactory{
        public Object getBean(){
            Object bean = new Object();
            //仅作为参考
            System.out.println("构造 " + bean);
            System.out.println("依赖注入 " + bean);
            System.out.println("初始化 " + bean);
            return bean;
        }
    }
}

这样的代码扩展性较弱，每次做修改都得改这个getBean方法，那怎样能让代码扩展性好起来呢？

新增一个抽象接口BeanPostProcessor，在getBean中遍历调用实现了BeanPostProcessor接口的后处理器

public class TestMethodTemplate {

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

    //模板方法 Template Method Pattern
    static class MyBeanFactory{
        private List<BeanPostProcessor> processorList = new ArrayList<>();

        public void addBeanPostProcessor(BeanPostProcessor processor){
            processorList.add(processor);
        }

        public Object getBean(){
            Object bean = new Object();
            //仅作为参考，固定不变的逻辑
            System.out.println("构造 " + bean);
            System.out.println("依赖注入 " + bean);

            for (BeanPostProcessor processor : processorList) {
                processor.inject(bean);
            }

            System.out.println("初始化 " + bean);
            return bean;
        }
    }


    //可能有些不确定的逻辑，可以把它做成抽象接口
    static interface BeanPostProcessor{
        public void inject(Object bean); //对依赖注入阶段的扩展
    }
}

输出如图

此时，如果再需要进行其他的扩展，getBean方法都不需要再改动了