乐趣区

关于前端:掌握这些-SpringBoot-启动扩展点已经超过-90-的人了

jiezi

1. 背景

Spring 的核心思想就是容器，当容器 refresh 的时候，内部看上去惊涛骇浪，其实外部则是一片风平浪静，汪洋一片。Springboot 更是封装了 Spring，遵循约定大于配置，加上主动拆卸的机制。很多时候咱们只有援用了一个依赖，简直是零配置就能实现一个性能的拆卸。

我十分喜爱这种主动拆卸的机制，所以在本人开发中间件和公共依赖工具的时候也会用到这个个性。让使用者以最小的代价接入。想要把主动拆卸玩的转，就必须要理解 spring 对于 bean 的结构生命周期以及各个扩大接口。当然理解了 bean 的各个生命周期也能促成咱们加深对 spring 的了解。业务代码也能正当利用这些扩大点写出更加丑陋的代码。

在网上搜寻 spring 扩大点，发现很少有博文说的很全的，只有一些罕用的扩大点的阐明。

所以在这篇文章里，我总结了简直 Spring & Springboot 所有的扩大接口，以及各个扩大点的应用场景。并且整顿出了一个 bean 在 spring 外部从被加载到最初初始化实现所有可扩大点的顺序调用图。从而咱们也能窥探到 bean 是如何一步步加载到 spring 容器中的。

2. 可扩大的接口启动调用程序图

以下是我整顿的 spring 容器中 Bean 的生命周期内所有可扩大的点的调用程序，上面会一个个剖析

3.ApplicationContextInitializer

org.springframework.context.ApplicationContextInitializer

这是整个 spring 容器在刷新之前初始化 ConfigurableApplicationContext 的回调接口，简略来说，就是在容器刷新之前调用此类的 initialize 办法。这个点容许被用户本人扩大。用户能够在整个 spring 容器还没被初始化之前做一些事件。

能够想到的场景可能为，在最开始激活一些配置，或者利用这时候 class 还没被类加载器加载的机会，进行动静字节码注入等操作。

扩大形式为：

public class TestApplicationContextInitializer implements ApplicationContextInitializer {    
    @Override    
    public void initialize(ConfigurableApplicationContext applicationContext) {System.out.println("[ApplicationContextInitializer]");    
    }    
}

因为这时候 spring 容器还没被初始化，所以想要本人的扩大的失效，有以下三种形式：

  • 在启动类中用 springApplication.addInitializers(new TestApplicationContextInitializer()) 语句退出
  • 配置文件配置 context.initializer.classes=com.example.demo.TestApplicationContextInitializer
  • Spring SPI 扩大，在 spring.factories 中退出 org.springframework.context.ApplicationContextInitializer=com.example.demo.TestApplicationContextInitializer

4.BeanDefinitionRegistryPostProcessor

org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor

这个接口在读取我的项目中的 beanDefinition 之后执行，提供一个补充的扩大点

应用场景：你能够在这里动静注册本人的 beanDefinition，能够加载 classpath 之外的 bean

扩大形式为:

public class TestBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {    
    @Override    
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {System.out.println("[BeanDefinitionRegistryPostProcessor] postProcessBeanDefinitionRegistry");    
    }    

    @Override    
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("[BeanDefinitionRegistryPostProcessor] postProcessBeanFactory");    
    }    
}

5.BeanFactoryPostProcessor

org.springframework.beans.factory.config.BeanFactoryPostProcessor

这个接口是 beanFactory 的扩大接口，调用机会在 spring 在读取 beanDefinition 信息之后，实例化 bean 之前。

在这个机会，用户能够通过实现这个扩大接口来自行处理一些货色，比方批改曾经注册的 beanDefinition 的元信息。

扩大形式为：

public class TestBeanFactoryPostProcessor implements BeanFactoryPostProcessor {    
    @Override    
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("[BeanFactoryPostProcessor]");    
    }    
}

6.InstantiationAwareBeanPostProcessor

org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor

该接口继承了 BeanPostProcess 接口，区别如下：

BeanPostProcess 接口只在 bean 的初始化阶段进行扩大（注入 spring 上下文前后），而 InstantiationAwareBeanPostProcessor 接口在此基础上减少了 3 个办法，把可扩大的范畴减少了实例化阶段和属性注入阶段。

该类次要的扩大点有以下 5 个办法，次要在 bean 生命周期的两大阶段：实例化阶段 和 初始化阶段，上面一起进行阐明，按调用程序为：

  • postProcessBeforeInstantiation：实例化 bean 之前，相当于 new 这个 bean 之前
  • postProcessAfterInstantiation：实例化 bean 之后，相当于 new 这个 bean 之后
  • postProcessPropertyValues：bean 曾经实例化实现，在属性注入时阶段触发，@Autowired , @Resource 等注解原理基于此办法实现
  • postProcessBeforeInitialization：初始化 bean 之前，相当于把 bean 注入 spring 上下文之前
  • postProcessAfterInitialization：初始化 bean 之后，相当于把 bean 注入 spring 上下文之后

应用场景：这个扩大点十分有用，无论是写中间件和业务中，都能利用这个个性。比方对实现了某一类接口的 bean 在各个生命期间进行收集，或者对某个类型的 bean 进行对立的设值等等。

扩大形式为：

public class TestInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {    

    @Override    
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println("[TestInstantiationAwareBeanPostProcessor] before initialization" + beanName);    
        return bean;    
    }    

    @Override    
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println("[TestInstantiationAwareBeanPostProcessor] after initialization" + beanName);    
        return bean;    
    }    

    @Override    
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {System.out.println("[TestInstantiationAwareBeanPostProcessor] before instantiation" + beanName);    
        return null;    
    }    

    @Override    
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {System.out.println("[TestInstantiationAwareBeanPostProcessor] after instantiation" + beanName);    
        return true;    
    }    

    @Override    
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {System.out.println("[TestInstantiationAwareBeanPostProcessor] postProcessPropertyValues" + beanName);    
        return pvs;    
    }

7.SmartInstantiationAwareBeanPostProcessor

org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor

该扩大接口有 3 个触发点办法：

  • predictBeanType：该触发点产生在 postProcessBeforeInstantiation 之前(在图上并没有表明，因为个别不太须要扩大这个点)，这个办法用于预测 Bean 的类型，返回第一个预测胜利的 Class 类型，如果不能预测返回 null；当你调用 BeanFactory.getType(name) 时当通过 bean 的名字无奈失去 bean 类型信息时就调用该回调办法来决定类型信息。
  • determineCandidateConstructors：该触发点产生在 postProcessBeforeInstantiation 之后，用于确定该 bean 的构造函数之用，返回的是该 bean 的所有构造函数列表。用户能够扩大这个点，来自定义抉择相应的结构器来实例化这个 bean。
  • getEarlyBeanReference：该触发点产生在 postProcessAfterInstantiation 之后，当有循环依赖的场景，当 bean 实例化好之后，为了避免有循环依赖，会提前裸露回调办法，用于 bean 实例化的后置解决。这个办法就是在提前裸露的回调办法中触发。

扩大形式为：

public class TestSmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {    

    @Override    
    public Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] predictBeanType" + beanName);    
        return beanClass;    
    }    

    @Override    
    public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] determineCandidateConstructors" + beanName);    
        return null;    
    }    

    @Override    
    public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] getEarlyBeanReference" + beanName);    
        return bean;    
    }    
}

8.BeanFactoryAware

org.springframework.beans.factory.BeanFactoryAware

这个类只有一个触发点，产生在 bean 的实例化之后，注入属性之前，也就是 Setter 之前。这个类的扩大点办法为 setBeanFactory，能够拿到 BeanFactory 这个属性。

应用场景为，你能够在 bean 实例化之后，但还未初始化之前，拿到 BeanFactory，在这个时候，能够对每个 bean 作特殊化的定制。也或者能够把 BeanFactory 拿到进行缓存，日后应用。

扩大形式为：

public class TestBeanFactoryAware implements BeanFactoryAware {    
    @Override    
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {System.out.println("[TestBeanFactoryAware]" + beanFactory.getBean(TestBeanFactoryAware.class).getClass().getSimpleName());    
    }    
}

9.ApplicationContextAwareProcessor

org.springframework.context.support.ApplicationContextAwareProcessor

该类自身并没有扩大点，然而该类外部却有 6 个扩大点可供实现，这些类触发的机会在 bean 实例化之后，初始化之前

能够看到，该类用于执行各种驱动接口，在 bean 实例化之后，属性填充之后，通过执行以上红框标出的扩大接口，来获取对应容器的变量。所以这里应该来说是有 6 个扩大点，这里就放一起来说了

  • EnvironmentAware：用于获取 EnviromentAware 的一个扩大类，这个变量十分有用，能够取得零碎内的所有参数。当然集体认为这个 Aware 没必要去扩大，因为 spring 外部都能够通过注入的形式来间接取得。
  • EmbeddedValueResolverAware：用于获取 StringValueResolver 的一个扩大类，StringValueResolver 用于获取基于 String 类型的 properties 的变量，个别咱们都用 @Value 的形式去获取，如果实现了这个 Aware 接口，把 StringValueResolver 缓存起来，通过这个类去获取 String 类型的变量，成果是一样的。
  • ResourceLoaderAware：用于获取 ResourceLoader 的一个扩大类，ResourceLoader 能够用于获取 classpath 内所有的资源对象，能够扩大此类来拿到 ResourceLoader 对象。
  • ApplicationEventPublisherAware：用于获取 ApplicationEventPublisher 的一个扩大类，ApplicationEventPublisher 能够用来公布事件，联合 ApplicationListener 来独特应用，下文在介绍 ApplicationListener 时会具体提到。这个对象也能够通过 spring 注入的形式来取得。
  • MessageSourceAware：用于获取 MessageSource 的一个扩大类，MessageSource 次要用来做国际化。
  • ApplicationContextAware：用来获取 ApplicationContext 的一个扩大类，ApplicationContext 应该是很多人十分相熟的一个类了，就是 spring 上下文管理器，能够手动的获取任何在 spring 上下文注册的 bean，咱们常常扩大这个接口来缓存 spring 上下文，包装成静态方法。同时 ApplicationContext 也实现了 BeanFactory，MessageSource，ApplicationEventPublisher 等接口，也能够用来做相干接口的事件。

10.BeanNameAware

org.springframework.beans.factory.BeanNameAware

能够看到，这个类也是 Aware 扩大的一种，触发点在 bean 的初始化之前，也就是 postProcessBeforeInitialization 之前，这个类的触发点办法只有一个：setBeanName

应用场景为：用户能够扩大这个点，在初始化 bean 之前拿到 spring 容器中注册的的 beanName，来自行批改这个 beanName 的值。

扩大形式为：

public class NormalBeanA implements BeanNameAware{public NormalBeanA() {System.out.println("NormalBean constructor");    
    }    

    @Override    
    public void setBeanName(String name) {System.out.println("[BeanNameAware]" + name);    
    }    
}

11.@PostConstruct

javax.annotation.PostConstruct

这个并不算一个扩大点，其实就是一个标注。其作用是在 bean 的初始化阶段，如果对一个办法标注了 @PostConstruct，会先调用这个办法。这里重点是要关注下这个规范的触发点，这个触发点是在 postProcessBeforeInitialization 之后，InitializingBean.afterPropertiesSet 之前。

应用场景：用户能够对某一办法进行标注，来进行初始化某一个属性

扩大形式为：

public class NormalBeanA {public NormalBeanA() {System.out.println("NormalBean constructor");    
    }    

    @PostConstruct    
    public void init(){System.out.println("[PostConstruct] NormalBeanA");    
    }    
}

12.InitializingBean

org.springframework.beans.factory.InitializingBean

这个类，顾名思义，也是用来初始化 bean 的。InitializingBean 接口为 bean 提供了初始化办法的形式，它只包含 afterPropertiesSet 办法，但凡继承该接口的类，在初始化 bean 的时候都会执行该办法。这个扩大点的触发机会在 postProcessAfterInitialization 之前。

应用场景：用户实现此接口，来进行系统启动的时候一些业务指标的初始化工作。

扩大形式为：

public class NormalBeanA implements InitializingBean{    
    @Override    
    public void afterPropertiesSet() throws Exception {System.out.println("[InitializingBean] NormalBeanA");    
    }    
}

13.FactoryBean

org.springframework.beans.factory.FactoryBean

个别状况下，Spring 通过反射机制利用 bean 的 class 属性指定干线类去实例化 bean，在某些状况下，实例化 Bean 过程比较复杂，如果依照传统的形式，则须要在 bean 中提供大量的配置信息。配置形式的灵活性是受限的，这时采纳编码的形式可能会失去一个简略的计划。Spring 为此提供了一个 org.springframework.bean.factory.FactoryBean 的工厂类接口，用户能够通过实现该接口定制实例化 Bean 的逻辑。

FactoryBean 接口对于 Spring 框架来说占用重要的位置，Spring 本身就提供了 70 多个 FactoryBean 的实现。它们暗藏了实例化一些简单 bean 的细节，给下层利用带来了便当。从 Spring3.0 开始，FactoryBean 开始反对泛型，即接口申明改为 FactoryBean<T> 的模式

应用场景：用户能够扩大这个类，来为要实例化的 bean 作一个代理，比方为该对象的所有的办法作一个拦挡，在调用前后输入一行 log，模拟 ProxyFactoryBean 的性能。扩大：SpringBoot 内容聚合

扩大形式为：

public class TestFactoryBean implements FactoryBean<TestFactoryBean.TestFactoryInnerBean> {    

    @Override    
    public TestFactoryBean.TestFactoryInnerBean getObject() throws Exception {System.out.println("[FactoryBean] getObject");    
        return new TestFactoryBean.TestFactoryInnerBean();}    

    @Override    
    public Class<?> getObjectType() {return TestFactoryBean.TestFactoryInnerBean.class;}    

    @Override    
    public boolean isSingleton() {return true;}    

    public static class TestFactoryInnerBean{}}

14.SmartInitializingSingleton

org.springframework.beans.factory.SmartInitializingSingleton

这个接口中只有一个办法 afterSingletonsInstantiated，其作用是是 在 spring 容器治理的所有单例对象（非懒加载对象）初始化实现之后调用的回调接口。其触发机会为 postProcessAfterInitialization 之后。

应用场景：用户能够扩大此接口在对所有单例对象初始化结束后，做一些后置的业务解决。

扩大形式为：

public class TestSmartInitializingSingleton implements SmartInitializingSingleton {    
    @Override    
    public void afterSingletonsInstantiated() {System.out.println("[TestSmartInitializingSingleton]");    
    }    
}

15.CommandLineRunner

org.springframework.boot.CommandLineRunner

这个接口也只有一个办法：run(String... args)，触发机会为整个我的项目启动结束后，主动执行。如果有多个 CommandLineRunner，能够利用 @Order 来进行排序。

应用场景：用户扩大此接口，进行启动我的项目之后一些业务的预处理。

扩大形式为：

public class TestCommandLineRunner implements CommandLineRunner {    

    @Override    
    public void run(String... args) throws Exception {System.out.println("[TestCommandLineRunner]");    
    }    
}

16.DisposableBean

org.springframework.beans.factory.DisposableBean

这个扩大点也只有一个办法：destroy()，其触发机会为当此对象销毁时，会主动执行这个办法。比如说运行 applicationContext.registerShutdownHook 时，就会触发这个办法。

扩大形式为：

public class NormalBeanA implements DisposableBean {    
    @Override    
    public void destroy() throws Exception {System.out.println("[DisposableBean] NormalBeanA");    
    }    
}

17.ApplicationListener

org.springframework.context.ApplicationListener

精确的说，这个应该不算 spring&springboot 当中的一个扩大点，ApplicationListener 能够监听某个事件的 event，触发机会能够穿插在业务办法执行过程中，用户能够自定义某个业务事件。

然而 spring 外部也有一些内置事件，这种事件，能够穿插在启动调用中。咱们也能够利用这个个性，来本人做一些内置事件的监听器来达到和后面一些触发点大致相同的事件。

接下来列举下 spring 次要的内置事件：

  • ContextRefreshedEvent

    ApplicationContext 被初始化或刷新时，该事件被公布。这也能够在 ConfigurableApplicationContext 接口中应用  refresh() 办法来产生。此处的初始化是指：所有的 Bean 被胜利装载，后处理 Bean 被检测并激活，所有 Singleton Bean 被预实例化，ApplicationContext 容器已就绪可用。

  • ContextStartedEvent

    当应用 ConfigurableApplicationContext（ApplicationContext 子接口）接口中的 start() 办法启动  ApplicationContext 时，该事件被公布。你能够考察你的数据库，或者你能够在承受到这个事件后重启任何进行的应用程序。

  • ContextStoppedEvent

    当应用 ConfigurableApplicationContext 接口中的  stop() 进行 ApplicationContext 时，公布这个事件。你能够在承受到这个事件后做必要的清理的工作

  • ContextClosedEvent

    当应用 ConfigurableApplicationContext 接口中的  close() 办法敞开  ApplicationContext 时，该事件被公布。一个已敞开的上下文达到生命周期末端；它不能被刷新或重启

  • RequestHandledEvent

    这是一个 web-specific 事件，通知所有 bean HTTP 申请曾经被服务。只能利用于应用 DispatcherServlet 的 Web 利用。在应用 Spring 作为前端的 MVC 控制器时，当 Spring 解决用户申请完结后，零碎会主动触发该事件

18. 最初

咱们从这些 spring&springboot 的扩大点当中，大抵能够窥视到整个 bean 的生命周期。在业务开发或者写中间件业务的时候，能够正当利用 spring 提供给咱们的扩大点，在 spring 启动的各个阶段内做一些事件。以达到自定义初始化的目标。此篇总结，如果有谬误或者疏漏的中央，恳请斧正。

退出移动版