美文网首页IT@程序员猿媛Java服务端面试
【Spring 笔记】BeanPostProcessor 相关整

【Spring 笔记】BeanPostProcessor 相关整

作者: 58bc06151329 | 来源:发表于2019-09-30 14:32 被阅读0次

文前说明

作为码农中的一员，需要不断的学习，我工作之余将一些分析总结和学习笔记写成博客与大家一起交流，也希望采用这种方式记录自己的学习之旅。

本文仅供学习交流使用，侵权必删。
不用于商业目的，转载请注明出处。

1. 概述

  • 初始化 bean 的方法的调用流程（主要还是根据 用户设定 的来进行初始化）的一个很重要的步骤就是后置处理器（BeanPostProcessor）。

BeanPostProcessor 接口

  • BeanPostProcessor 的作用是在 Bean 完成实例化后，如果需要对其进行一些配置、增加一些自己的处理逻辑，可以使用 BeanPostProcessor。

  • 用例。

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test implements BeanPostProcessor {


    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Bean [" + beanName + "] 开始初始化");
        // 这里一定要返回 bean，不能返回 null
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Bean [" + beanName + "] 完成初始化");
        return bean;
    }

    public void display() {
        System.out.println("hello BeanPostProcessor!!!");
    }

    public static void main(String[] args) {
        ClassPathResource resource = new ClassPathResource("spring.xml");
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
        reader.loadBeanDefinitions(resource);
        Test testObj = new Test();
        factory.addBeanPostProcessor(testObj);
        Test test = (Test) factory.getBean("test");
        test.display();
    }
}
  • 配置文件。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="test" class="Test"></bean>
</beans>
  • 后置处理器是通过 getBeanPostProcessors() 方法，获取定义的 BeanPostProcessor，然后分别调用其 postProcessBeforeInitialization()、postProcessAfterInitialization() 方法，进行自定义的业务处理。
// AbstractAutowireCapableBeanFactory.java
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
        throws BeansException {
    Object result = existingBean;
    // 遍历 BeanPostProcessor 数组
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        // 处理
        Object current = processor.postProcessBeforeInitialization(result, beanName);
        // 返回空，则返回 result
        if (current == null) {
            return result;
        }
        // 修改 result
        result = current;
    }
    return result;
}

// AbstractAutowireCapableBeanFactory.java
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {
    Object result = existingBean;
    // 遍历 BeanPostProcessor
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        // 处理
        Object current = processor.postProcessAfterInitialization(result, beanName);
        // 返回空，则返回 result
        if (current == null) {
            return result;
        }
        // 修改 result
        result = current;
    }
    return result;
}
  • org.springframework.beans.factory.config.ConfigurableBeanFactory 接口定义 addBeanPostProcessor() 方法，将指定 BeanPostProcessor 注册到由 BeanFactory 创建的 bean 中，同时是按照插入的顺序进行注册，完全忽略 Ordered 接口所表达任何排序语义（在 BeanPostProcessor 中提供一个 Ordered 顺序）。
// AbstractBeanFactory.java
@Override
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
    Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
    // Remove from old position, if any
    this.beanPostProcessors.remove(beanPostProcessor);
    // Track whether it is instantiation/destruction aware
    if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
        this.hasInstantiationAwareBeanPostProcessors = true;
    }
    if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
        this.hasDestructionAwareBeanPostProcessors = true;
    }
    // Add to end of list
    this.beanPostProcessors.add(beanPostProcessor);
}
  • 运行结果。
Bean [test] 开始初始化
Bean [test] 完成初始化
hello BeanPostProcessor!!!

2. 原理

  • org.springframework.beans.factory.config.BeanPostProcessor 接口。
public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}
  • BeanPostProcessor 可以理解为是 Spring 的一个工厂钩子（其实 Spring 提供一系列的钩子，如 Aware、InitializingBean、DisposableBean），它是 Spring 提供的对象实例化阶段强有力的扩展点，允许 Spring 在实例化 bean 阶段对其进行定制化修改，比较常见的使用场景是处理标记接口实现类或者为当前对象提供代理实现（例如 AOP）。
  • 一般普通的 BeanFactory 是不支持自动注册 BeanPostProcessor 的，需要手动调用 addBeanPostProcessor() 方法进行注册。注册后的 BeanPostProcessor 适用于所有该 BeanFactory 创建的 bean，但是 ApplicationContext 可以在其 bean 定义中自动检测所有的 BeanPostProcessor 并自动完成注册，同时将他们应用到随后创建的任何 Bean 中。
  • postProcessBeforeInitialization() 和 postProcessAfterInitialization() 两个方法，都接收一个 Object 类型的 bean ，一个 String 类型的 beanName ，其中 bean 是已经实例化了的 instanceBean。
    • 他们应用在 invokeInitMethods() 方法的前后。
BeanPostProcessor 处理流程 
// AbstractAutowireCapableBeanFactory.java
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
        throws BeansException {
    Object result = existingBean;
    // 遍历 BeanPostProcessor 数组
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        // 处理
        Object current = processor.postProcessBeforeInitialization(result, beanName);
        // 返回空，则返回 result
        if (current == null) {
            return result;
        }
        // 修改 result
        result = current;
    }
    return result;
}

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {
    Object result = existingBean;
    // 遍历 BeanPostProcessor
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        // 处理
        Object current = processor.postProcessAfterInitialization(result, beanName);
        // 返回空，则返回 result
        if (current == null) {
            return result;
        }
        // 修改 result
        result = current;
    }
    return result;
}

2.1 自动检测并注册

  • getBeanPostProcessors() 方法，返回的是 beanPostProcessors 集合，该集合里面存放就是自定义的 BeanPostProcessor，如果该集合中存在元素则调用相应的方法，否则就直接返回 bean。
  • BeanFactory 容器无法输出自定义 BeanPostProcessor 里面的内容，是因为在 BeanFactory#getBean() 方法的过程没有将自定义的 BeanPostProcessor 注入，要想 BeanFactory 容器 的 BeanPostProcessor 生效，必须手动调用 addBeanPostProcessor() 方法，将定义的 BeanPostProcessor 注册到相应的 BeanFactory 中。
    • ApplicationContext 不需要手动，ApplicationContext 可以自动检测并完成注册。
    • ApplicationContext 实现自动注册的原因，在于构造一个 ApplicationContext 实例对象的同时会调用 registerBeanPostProcessors() 方法，将检测到的 BeanPostProcessor 注入到 ApplicationContext 容器中，同时应用到该容器创建的 bean 中。
// AbstractApplicationContext.java
/**
 * 实例化并调用已经注入的 BeanPostProcessor
 * 必须在应用中 bean 实例化之前调用
 */
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

// PostProcessorRegistrationDelegate.java

public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

    // 获取所有的 BeanPostProcessor 的 beanName
    // 这些 beanName 都已经全部加载到容器中去，但是没有实例化
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    // Register BeanPostProcessorChecker that logs an info message when
    // a bean is created during BeanPostProcessor instantiation, i.e. when
    // a bean is not eligible for getting processed by all BeanPostProcessors.
    // 记录所有的beanProcessor数量
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    // 注册 BeanPostProcessorChecker，它主要是用于在 BeanPostProcessor 实例化期间记录日志
    // 当 Spring 中高配置的后置处理器还没有注册就已经开始了 bean 的实例化过程，这个时候便会打印 BeanPostProcessorChecker 中的内容
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    // Separate between BeanPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    // PriorityOrdered 保证顺序
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    // MergedBeanDefinitionPostProcessor
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    // 使用 Ordered 保证顺序
    List<String> orderedPostProcessorNames = new ArrayList<>();
    // 没有顺序
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        // PriorityOrdered
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            // 调用 getBean 获取 bean 实例对象
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            // 有序 Ordered
            orderedPostProcessorNames.add(ppName);
        } else {
            // 无序
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, register the BeanPostProcessors that implement PriorityOrdered.
    // 第一步，注册所有实现了 PriorityOrdered 的 BeanPostProcessor
    // 先排序
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    // 后注册
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // Next, register the BeanPostProcessors that implement Ordered.
    // 第二步，注册所有实现了 Ordered 的 BeanPostProcessor
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    // 先排序
    sortPostProcessors(orderedPostProcessors, beanFactory);
    // 后注册
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    // Now, register all regular BeanPostProcessors.
    // 第三步注册所有无序的 BeanPostProcessor
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    // 注册，无需排序
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    // Finally, re-register all internal BeanPostProcessors.
    // 最后，注册所有的 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    // Re-register post-processor for detecting inner beans as ApplicationListeners,
    // moving it to the end of the processor chain (for picking up proxies etc).
    // 加入ApplicationListenerDetector（探测器）
    // 重新注册 BeanPostProcessor 以检测内部 bean，因为 ApplicationListeners 将其移动到处理器链的末尾
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
  • 首先，获取注册到该 BeanFactory 中所有 BeanPostProcessor 类型的 beanName 数组（找到所有实现了 BeanPostProcessor 接口的 bean）。
  • 然后，迭代这些 bean ，将其按照 PriorityOrdered、Ordered、无序的顺序，添加至相应的 List 集合中。
  • 最后，依次调用 sortPostProcessors() 方法进行排序处理、registerBeanPostProcessors() 方法完成注册。

sortPostProcessors

  • 如果 beanFactory 为 DefaultListableBeanFactory，则返回 BeanFactory 所依赖的比较器，否则反正默认的比较器（OrderComparator），然后调用 List#sort() 方法。
// PostProcessorRegistrationDelegate.java
private static void sortPostProcessors(List<?> postProcessors, ConfigurableListableBeanFactory beanFactory) {
    // 获得 Comparator 对象
    Comparator<Object> comparatorToUse = null;
    if (beanFactory instanceof DefaultListableBeanFactory) { // 依赖的 Comparator 对象
        comparatorToUse = ((DefaultListableBeanFactory) beanFactory).getDependencyComparator();
    }
    if (comparatorToUse == null) { // 默认 Comparator 对象
        comparatorToUse = OrderComparator.INSTANCE;
    }
    // 排序
    postProcessors.sort(comparatorToUse);
}

registerBeanPostProcessors

  • 调用 AbstractBeanFactory#addBeanPostProcessor() 方法完成注册。
// PostProcessorRegistrationDelegate.java
private static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
    // 遍历 BeanPostProcessor 数组，注册
    for (BeanPostProcessor postProcessor : postProcessors) {
        beanFactory.addBeanPostProcessor(postProcessor);
    }
}

3. BeanPostProcessor 体系

BeanPostProcessor 体系

BeanPostProcessor

public interface BeanPostProcessor {
    //该方法在bean实例化完毕（且已经注入完毕），在afterPropertiesSet或自定义init方法执行之前
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    //在afterPropertiesSet或自定义init方法执行之后
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

InstantiationAwareBeanPostProcessor

  • 关于对象实例化前后以及实例化后设置 propertyValues 的回调。
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    //这个方法用来在对象实例化前直接返回一个对象（如代理对象）来代替通过内置的实例化流程创建对象；
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }
    //在对象实例化完毕执行populateBean之前 如果返回false则spring不再对对应的bean实例进行自动依赖注入。
    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }
    //这里是在spring处理完默认的成员属性，应用到指定的bean之前进行回调，可以用来检查和修改属性，最终返回的PropertyValues会应用到bean中
    //@Autowired、@Resource等就是根据这个回调来实现最终注入依赖的属性的。
    @Nullable
    default PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        return pvs;
    }
}

SmartInstantiationAwareBeanPostProcessor

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {
    //用来返回目标对象的类型（比如代理对象通过raw class获取proxy type 用于类型匹配）
    @Nullable
    default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }
    //这里提供一个拓展点用来解析获取用来实例化的构造器（比如未通过bean定义构造器以及参数的情况下，会根据这个回调来确定构造器）
    @Nullable
    default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
            throws BeansException {
        return null;
    }
    //获取要提前暴露的bean的引用，用来支持单例对象的循环引用（一般是bean自身，如果是代理对象则需要取用代理引用）
    default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

MergedBeanDefinitionPostProcessor

  • 将 merged BeanDefinition 暴露出来的回调。
public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {
    //在bean实例化完毕后调用 可以用来修改merged BeanDefinition的一些properties 或者用来给后续回调中缓存一些meta信息使用
    //这个算是将merged BeanDefinition暴露出来的一个回调
    void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);
}

DestructionAwareBeanPostProcessor

  • 处理对象销毁的前置回调。
public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {
    //这里实现销毁对象的逻辑
    void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;
    //判断是否需要处理这个对象的销毁
    default boolean requiresDestruction(Object bean) {
        return true;
    }
}

3.1 BeanPostProcessor 中各个回调的调用顺序

  1. InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation() 该方法在 创建对象之前 调用，如果返回实例则直接使用，不再执行创建对象的逻辑，并在之后执行 BeanPostProcessor#postProcessAfterInitialization()。
  2. SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors() 如果需要，在 实例化对象之前 执行。
  3. MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition() 在 对象实例化完毕 或 实例化之前 执行。
  4. InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation() 在 bean创建完毕实例化之前 执行。
  5. InstantiationAwareBeanPostProcessor#postProcessPropertyValues() 在 bean 的 property 属性注入完毕 或者 向 bean 中设置属性之前 执行。
  6. BeanPostProcessor#postProcessBeforeInitialization() 在 bean 初始化（自定义 init 或者是实现了 InitializingBean#afterPropertiesSet()）之前 执行。
  7. BeanPostProcessor#postProcessAfterInitialization() 在 bean 初始化（自定义 init 或者是实现了 InitializingBean#afterPropertiesSet()）之后 执行。
  8. 其中 DestructionAwareBeanPostProcessor#postProcessBeforeDestruction() 方法 在销毁对象前 执行。
  9. DestructionAwareBeanPostProcessor#requiresDestruction() 用于判断是否属于当前 processor 处理的 bean。
  10. SmartInstantiationAwareBeanPostProcessor#predictBeanType() 用于预判类型。
  • 用例。
@Configuration
public class Application {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Application.class);
        applicationContext.registerBeanDefinition("demoBean", new RootBeanDefinition(DemoBean.class));
        applicationContext.getBean("demoBean");
        applicationContext.start();
        applicationContext.destroy();
    }

    @Bean
    public BeanPostProcessor fullyPostProcessor() {
        return new FullyBeanPostProcessor();
    }

    public static class DemoBean {

    }

    @Order
    public class FullyBeanPostProcessor implements BeanPostProcessor,
            InstantiationAwareBeanPostProcessor,
            SmartInstantiationAwareBeanPostProcessor,
            MergedBeanDefinitionPostProcessor,
            DestructionAwareBeanPostProcessor {
        @Override
        public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
            if (beanClass == DemoBean.class) {
                System.out.println("1 --> InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(beanClass, beanName)");
            }
            return null;
        }

        @Override
        public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
            if (beanClass == DemoBean.class) {
                System.out.println("2 --> SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors(beanClass, beanName)");
            }
            return null;
        }

        @Override
        public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
            if (beanType == DemoBean.class) {
                System.out.println("3 --> MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(mbd, beanType, beanName)");
            }

        }

        @Override
        public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
            if (bean instanceof DemoBean) {
                System.out.println("4 --> InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)");
            }
            return true;
        }

        @Override
        public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
            if (bean instanceof DemoBean) {
                System.out.println("5 --> InstantiationAwareBeanPostProcessor.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName)");
            }
            return pvs;
        }

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

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

        @Override
        public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
            if (bean instanceof DemoBean) {
                System.out.println("8 --> DestructionAwareBeanPostProcessor.postProcessBeforeDestruction(Object bean, String beanName)");
            }
        }

        @Override
        public Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
            return null;
        }


        @Override
        public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
            return bean;
        }
    }
}

/**
print
1 --> InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(beanClass, beanName)
2 --> SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors(beanClass, beanName)
3 --> MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(mbd, beanType, beanName)
4 --> InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)
5 --> InstantiationAwareBeanPostProcessor.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName)
6 --> BeanPostProcessor.postProcessBeforeInitialization(result, beanName)
7 --> BeanPostProcessor.postProcessAfterInitialization(result, beanName)
8 --> DestructionAwareBeanPostProcessor.postProcessBeforeDestruction(Object bean, String beanName)
**/

4. 总结

  • BeanPostProcessor 的作用域是容器级别的，只和所在的容器相关 ，当 BeanPostProcessor 完成注册后，会应用于所有跟它在同一个容器内的 bean。
  • BeanFactory 和 ApplicationContext 对 BeanPostProcessor 的处理不同，ApplicationContext 会自动检测所有实现 BeanPostProcessor 接口的 bean，并完成注册，使用 BeanFactory 容器则需要手动调用 AbstractBeanFactory#addBeanPostProcessor() 方法来完成注册。
  • ApplicationContext 的 BeanPostProcessor 支持 Ordered，而 BeanFactory 的 BeanPostProcessor 不支持，原因在于 ApplicationContext 会对 BeanPostProcessor 进行 Ordered 检测并完成排序，而 BeanFactory 中的 BeanPostProcessor 只跟 注册的顺序 有关。

相关文章

网友评论

    本文标题：【Spring 笔记】BeanPostProcessor 相关整

    本文链接：https://www.haomeiwen.com/subject/tlifpctx.html

    延伸阅读

    深度阅读

    • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

    栏目导航

    热点阅读

    IT@程序员猿媛

    Java服务端面试

    关于我们|服务条款|联系我们|【Spring 笔记】BeanPostProcessor 相关整|投稿指南|网站地图|RSS订阅|排版工具|手机版

    提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

    Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

    备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

    本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

    所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！