SpringBoot中的扩展点接口

目录

前言

一、SpringBoot的扩展点，以及扩展点的执行时机

二、扩展点的具体说明  

总结

---

---

前言

  SpringBoot在启动以及bean的构造生命周期中会调用一些SpringBoot的的扩展接口类，了解了这些扩展点之后我们可以在SpringBoot启动的时候或者Bean加载的时候进行一些定制化的设置，加载一些资源。

---

一、SpringBoot有哪些展点，以及这些扩展点的执行顺序

 上面是SpringBoot一些扩展点的执行顺序，下面可以通过实现这些接口来看看是否真是如此。

1、MyApplicationContextInitalizer

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

2、MyBeanDefinitionRegistryPostProcessor

@Component
public class MyBeanDefinitionRegistryPostProcessor 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");
    }
}

 3、MyBeanFactoryPostProcessor

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        if ("myTestBean".equals(beanFactory.getBeanNamesForType(MyTestBean.class)[0]))
        System.out.println(">>>>BeanFactoryPostProcessor");
    }
}

4、MyInstantiationAwareBeanPostProcessor

@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("myTestBean".equals(beanName))
        System.out.println("InstantiationAwareBeanPostProcessor--postProcessBeforeInitialization01" + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("myTestBean".equals(beanName))
        System.out.println("InstantiationAwareBeanPostProcessor--postProcessAfterInitialization01" + beanName);
        return bean;
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("myTestBean".equals(beanName))
        System.out.println("InstantiationAwareBeanPostProcessor--postProcessBeforeInstantiation02" + beanName);
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("myTestBean".equals(beanName))
        System.out.println("InstantiationAwareBeanPostProcessor--postProcessAfterInstantiation02" + beanName);
        return true;
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if ("myTestBean".equals(beanName))
        System.out.println("InstantiationAwareBeanPostProcessor--postProcessProperties");
        return pvs;
    }
}

 5、MyBeanFactoryAware

@Component
public class MyBeanFactoryAware implements BeanFactoryAware {
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println(">>>>BeanFactoryAware");
    }
}

6、MyBeanPostProcessor

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("myTestBean".equals(beanName))
        System.out.println(">>>>BeanPostProcessor--postProcessBeforeInitialization");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("myTestBean".equals(beanName))
        System.out.println(">>>>BeanPostProcessor--postProcessAfterInitialization");
        return bean;
    }

}

7、实体类

@Component
public class MyTestBean implements InitializingBean, BeanNameAware, BeanFactoryAware, SmartInitializingSingleton {

    public MyTestBean() {
        System.out.println(">>>>MyTestBean构造方法");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println(">>>>setBeanFactory");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println(">>>>setBeanName");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println(">>>>afterPropertiesSet");
    }

    @Override
    public void afterSingletonsInstantiated() {
        System.out.println(">>>>afterSingletonsInstantiated");
    }

    public void init() {
        System.out.println(">>>>init");
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println(">>>>postConstruct");
    }
}

启动SpringBoot

 

执行顺序一目了然 

二、扩展点的具体说明

  

接下来就针对扩展点具体说明它的作用。

1、ApplicationContextInitializer

  这是整个Spring容器在刷新之前调用此类的initialize方法

使用场景：在最开始激活一些配置，或者利用此时class还没有被类加载器加载的时候，进行动态字节码注入等操作。

2、BeanDefinitionRegistryPostProcessor

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

使用场景：可以在这里注册自己的beanDefinition，可以加载classpath之外的bean

3、BeanFactoryPostProcessor

  这个接口的调用时机为Spring在读取beanDefinition之后，实例化Bean之前

使用场景：可以利用这个扩展点修改beanDefinition的配置信息

4、InstantiationAwareBeanPostProcessor

  该接口继承了BeanPostProcess接口，但是BeanPostProcess接口只在bean初始化的时候起作用，而InstantiationAwareBeanPostProcessor扩展了三个方法，将可扩展的范围增加到了实例化阶段和属性注入阶段。

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

5、BeanFactoryAware

   该扩展点发生在Bean实例化之后，属性注入之前，也就是setter之前。这个类的扩展点方法为setBeanFactory，可以拿到BeanFactory这个属性。

6、InitializingBean、@PostConstruct、init()

  这些都是在Bean实例化之后

使用场景：可以对bean的的变量进行一些初始化设置的工作

---

总结

  本文介绍了SpringBoot的扩展点，以及这些扩展点的执行时机以及执行顺序，还介绍了如何利用这些扩展点。把握这些扩展点之后能够让我们更好的了解Spring的工作机制，同时也给我们工作的时候带来便利。工作中使用的最多的也就是利用InitializingBean、@PostConstruct初始化bean的变量。