【㊫SpringBoot】SpringBoot的扩展实现方式

Spring Boot 是 Java 领域最优秀的微服务架构落地技术：

• Spring Boot 使编码更简单：提供了丰富的解决方案，快速集成各种解决方案提升开发效率。
• Spring Boot 配置变简单：提供了丰富的 Starters，集成主流开源产品往往只需要简单的配置即可。
• Spring Boot 使部署变简单：本身内嵌启动容器，仅仅需要一个命令即可启动项目，结合 Jenkins 、Docker 自动化运维非常容易实现。
• Spring Boot 使监控变简单：自带监控组件，使用 Actuator 轻松监控服务各项状态。

Springboot封装了Spring，遵循约定大于配置原则，支持自动装配，很方便的集成各种自定义的功能。因此SpringBoot扩展实现的方式大部分是Spring提供的扩展接口（Spring bean生命周期），也有SpringBoot封装时自己提供的扩展支持。下面我们根据Spring启动过程来盘点有哪些扩展方式。

SpringBoot启动核心：可扩展的接口启动调用顺序图

我们要根据实际业务场景，来选择扩展的入口：

org.springframework.context.ApplicationContextInitializer

应用场景

在最开始激活一些配置，或者利用这时候class还没被类加载器加载的时机，进行动态字节码注入等操作。这是整个spring容器在刷新之前初始化ConfigurableApplicationContext的回调接口，简单来说，就是在容器刷新之前调用此类的initialize方法。这个点允许被用户自己扩展。用户可以在整个spring容器还没被初始化之前做一些事情。

实现方式

因为这时候spring容器还没被初始化，所以想要自己的扩展的生效，有以下三种方式：

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

代码示例

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

org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor

使用场景

可以在这里动态注册自己的beanDefinition，可以加载classpath之外的bean，这个接口在读取项目中的beanDefinition之后执行，提供一个补充的扩展点。

代码示例

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");      
    }      
}

org.springframework.beans.factory.config.BeanFactoryPostProcessor

使用场景

修改已经注册的beanDefinition的元信息，这个接口是beanFactory的扩展接口，调用时机在spring在读取beanDefinition信息之后，实例化bean之前。

代码示例

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

org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor

使用场景

比如对实现了某一类接口的bean在各个生命期间进行收集，或者对某个类型的bean进行统一的设值等等。这个扩展点非常有用 ，无论是写中间件和业务中，都能利用这个特性。

BeanPostProcessor只在bean的初始化阶段进行扩展（注入spring上下文前后），而该接口把可扩展的范围增加了实例化阶段和属性注入阶段

代码示例

public class TestInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {      
    // 实例化bean之前，相当于new这个bean之前
    @Override      
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {      
        System.out.println("[TestInstantiationAwareBeanPostProcessor] before initialization " + beanName);      
        return bean;      
    }      
    // 实例化bean之后，相当于new这个bean之后
    @Override      
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {      
        System.out.println("[TestInstantiationAwareBeanPostProcessor] after initialization " + beanName);      
        return bean;      
    }      
    // 初始化bean之前，相当于把bean注入spring上下文之前
    @Override      
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {      
        System.out.println("[TestInstantiationAwareBeanPostProcessor] before instantiation " + beanName);      
        return null;      
    }      
    // 初始化bean之后，相当于把bean注入spring上下文之后
    @Override      
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {      
        System.out.println("[TestInstantiationAwareBeanPostProcessor] after instantiation " + beanName);      
        return true;      
    }      
    // bean已经实例化完成，在属性注入时阶段触发，`@Autowired`,`@Resource`等注解原理基于此方法实现
    @Override      
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {      
        System.out.println("[TestInstantiationAwareBeanPostProcessor] postProcessPropertyValues " + beanName);      
        return pvs;      
    }
}

org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor

使用场景

• 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;      
    }      
}

org.springframework.beans.factory.BeanFactoryAware

使用场景

可以对每个bean作特殊化的定制，也可以把BeanFactory拿到进行缓存，日后使用 。这个类只有一个触发点，发生在bean的实例化之后，但还未初始化之前，注入属性之前，也就是Setter之前。

代码示例

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

org.springframework.context.support.ApplicationContextAwareProcessor（6个扩展点）

该类本身并没有扩展点，但是该类内部却有6个扩展点可供实现 ，这些类触发的时机在bean实例化之后，初始化之前。可以看到，该类用于执行各种驱动接口，在bean实例化之后，属性填充之后，通过执行以上红框标出的扩展接口，来获取对应容器的变量。

使用场景

• 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等接口，也可以用来做相关接口的事情。

invokeAwareInterfaces代码：

private void invokeAwareInterfaces(Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof EnvironmentAware) {
            ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
        }
        if (bean instanceof EmbeddedValueResolverAware) {
            ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
        }
        if (bean instanceof ResourceLoaderAware) {
            ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
        }
        if (bean instanceof ApplicationEventPublisherAware) {
            ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
        }
        if (bean instanceof MessageSourceAware) {
            ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
        }
        if (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
        }
    }
}

org.springframework.beans.factory.BeanNameAware

使用场景

用户可以扩展这个点，在初始化bean之前拿到spring容器中注册的的beanName，来自行修改这个beanName的值。可以看到，这个类也是Aware扩展的一种，触发点在bean的初始化之前，也就是postProcessBeforeInitialization之前，这个类的触发点方法只有一个：setBeanName。

代码示例

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

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

javax.annotation.PostConstruct

使用场景

bean执行初始化逻辑。其作用是在bean的初始化阶段，如果对一个方法标注了@PostConstruct，会先调用这个方法。这里重点是要关注下这个标准的触发点，这个触发点是在postProcessBeforeInitialization之后，InitializingBean.afterPropertiesSet之前。

代码示例

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

org.springframework.beans.factory.InitializingBean

使用场景

用户实现此接口，来进行系统启动的时候一些业务指标的初始化工作。顾名思义，也是用来初始化bean的。InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。这个扩展点的触发时机在postProcessAfterInitialization之前。

代码示例

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

org.springframework.beans.factory.FactoryBean

使用场景

为要实例化的bean作一个代理，比如为该对象的所有的方法作一个拦截，在调用前后输出一行log，模仿ProxyFactoryBean的功能。

FactoryBean接口对于Spring框架来说占用重要的地位，隐藏了实例化一些复杂bean的细节，给上层应用带来了便利，用户可以通过实现该接口定制实例化Bean的逻辑。

代码示例

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{
    }      
}

org.springframework.beans.factory.SmartInitializingSingleton

使用场景

用户可以扩展此接口在对所有单例对象初始化完毕后，做一些后置的业务处理。这个接口中只有一个方法afterSingletonsInstantiated，其作用是是 在spring容器管理的所有单例对象（非懒加载对象）初始化完成之后调用的回调接口。其触发时机为postProcessAfterInitialization之后。

代码示例

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

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]");      
    }      
}

org.springframework.beans.factory.DisposableBean

使用场景

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

代码示例

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

org.springframework.context.ApplicationListener

ApplicationListener可以监听某个事件的event，穿插在启动调用中，我们可以自定义某个业务事件，来自己做一些内置事件的监听器来达到和前面一些触发点大致相同的事情。

Spring主要的内置事件包括ContextRefreshedEvent、ContextStartedEvent、ContextStoppedEvent、ContextClosedEvent、RequestHandledEvent等。