认识Spring中的BeanFactoryPostProcessor

2024-06-11 00:28
文章标签 java 认识 spring beanfactorypostprocessor

本文主要是介绍认识Spring中的BeanFactoryPostProcessor，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

先看下AI的介绍

在Spring 5.3.x中，BeanFactoryPostProcessor是一个重要的接口，用于在Spring IoC容器实例化任何bean之前，读取bean的定义（配置元数据），并可能对其进行修改。以下是关于BeanFactoryPostProcessor的详细介绍：1. 接口定义与功能
接口定义：BeanFactoryPostProcessor是Spring提供的一个接口，它允许用户自定义逻辑以修改或扩展容器内部的功能。
功能：在BeanFactory实例化之后、其他Bean被创建之前，执行一些自定义的修改或增强操作。这包括修改BeanDefinition（bean的定义信息），如修改属性、添加或删除bean等。
2. 使用方法
实现接口：要使用BeanFactoryPostProcessor，你需要创建一个类来实现这个接口，并重写其中的postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)方法。
注册：将你的BeanFactoryPostProcessor实现注册为Spring容器中的一个bean。这通常可以通过XML配置文件、Java配置类或注解（如@Bean）来完成。
3. 子接口BeanDefinitionRegistryPostProcessor
定义：BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的一个子接口，它添加了一个额外的方法postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)。
功能：除了可以修改BeanDefinition之外，它还可以注册新的bean定义到容器中。
4. 执行顺序
如果有多个BeanFactoryPostProcessor或BeanDefinitionRegistryPostProcessor，可以通过设置order属性或实现Ordered接口来定义它们的执行顺序。
5. 示例
示例代码可能包括一个实现BeanFactoryPostProcessor接口的类，以及一个将其注册为Spring bean的配置类或注解。这个类中的postProcessBeanFactory方法会包含自定义的修改或增强逻辑。
6. 与其他接口的区别
BeanFactoryPostProcessor和BeanPostProcessor都是Spring初始化bean时对外暴露的扩展点，但它们的作用和使用场景不同。BeanFactoryPostProcessor主要关注于修改或增强BeanFactory和BeanDefinition，而BeanPostProcessor则关注于Bean实例化前后的操作。
7. 总结
BeanFactoryPostProcessor是Spring框架中一个非常有用的接口，它允许你在Spring IoC容器实例化bean之前，对bean的定义进行自定义的修改或增强。通过实现这个接口并注册你的实现类，你可以扩展Spring容器的功能，满足更复杂的应用需求。

根据BeanFactoryPostProcessor的介绍，创建几个测试类：
A类
通过扫描增加，BeanFactoryPostProcessor 实现类

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;/**
* 简单实现
*/
@Component
public class A implements BeanFactoryPostProcessor {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("A scan");}
}

B类
通过扫描增加，实现BeanFactoryPostProcessor, PriorityOrdered类

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.PriorityOrdered;
import org.springframework.stereotype.Component;@Component
public class B implements BeanFactoryPostProcessor, PriorityOrdered {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("B scan, priorityOrdered 0");}@Overridepublic int getOrder() {return 0;}
}

B1类
通过扫描增加，实现BeanFactoryPostProcessor, PriorityOrdered类，排序靠后

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.PriorityOrdered;
import org.springframework.stereotype.Component;@Component
public class B1 implements BeanFactoryPostProcessor, PriorityOrdered {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("B1 scan, priorityOrdered 1");}@Overridepublic int getOrder() {return 1;}
}

C类
通过扫描增加，实现BeanFactoryPostProcessor, Ordered 类

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.Ordered;
import org.springframework.core.PriorityOrdered;
import org.springframework.stereotype.Component;@Component
public class C implements BeanFactoryPostProcessor, Ordered {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("C scan, Ordered 0");}@Overridepublic int getOrder() {return 0;}
}

C1类
通过扫描增加，实现BeanFactoryPostProcessor, Ordered 类，排序靠后

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;@Component
public class C1 implements BeanFactoryPostProcessor, Ordered {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("C1 scan, Ordered 1");}@Overridepublic int getOrder() {return 1;}
}

D类
通过扫描增加，实现BeanFactoryPostProcessor的类，注解@Order

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;@Component
@Order(1)
public class D implements BeanFactoryPostProcessor {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("D scan, @Ordered 1");}}

E类
在测试类中，通过api增加

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;public class E implements BeanFactoryPostProcessor {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("E parent api add");}}

F类
普通Bean


package org.springframework.example.BFPP;import org.springframework.stereotype.Component;@Component
public class F {private String name;@Overridepublic String toString() {return "F{" +"name='" + name + '\'' +'}';}
}

F1类
修改的Bean

package org.springframework.example.BFPP;import org.springframework.stereotype.Component;@Component
public class F1 {private String name;@Overridepublic String toString() {return "F1{" +"name='" + name + '\'' +'}';}
}

G类
其中修改了F的BeanDefinition

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.stereotype.Component;@Component
public class G implements BeanFactoryPostProcessor {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) beanFactory.getBeanDefinition("f");beanDefinition.setBeanClass (F1.class);}
}

H类
扫描增加，实现了BeanDefinitionRegistryPostProcessor 的类

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;@Component
public class H implements BeanDefinitionRegistryPostProcessor  {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("H sub-parent");}@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {System.out.println("H sub");}
}

I类
在J类中增加，实现了BeanDefinitionRegistryPostProcessor 的类

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;public class I implements BeanDefinitionRegistryPostProcessor  {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("I sub-parent");}@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {System.out.println("I sub");}
}

J类
通过扫描增加，实现了BeanDefinitionRegistryPostProcessor 的类

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;@Component
public class J implements BeanDefinitionRegistryPostProcessor  {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("J sub-parent");}@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {System.out.println("J sub add BFPP I");BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(I.class);registry.registerBeanDefinition("i", builder.getBeanDefinition());}
}

K类
通过扫描增加，实现了BeanDefinitionRegistryPostProcessor 、PriorityOrdered 的类

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.core.PriorityOrdered;
import org.springframework.stereotype.Component;@Component
public class K implements BeanDefinitionRegistryPostProcessor, PriorityOrdered {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("k sub-parent priorityOrdered 0");}@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {System.out.println("K sub priorityOrdered 0");}@Overridepublic int getOrder() {return 0;}
}

K1类
通过扫描增加，实现了BeanDefinitionRegistryPostProcessor 、PriorityOrdered 的类，排序靠后

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.core.PriorityOrdered;
import org.springframework.stereotype.Component;@Component
public class K1 implements BeanDefinitionRegistryPostProcessor, PriorityOrdered {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("k1 sub-parent priorityOrdered 1");}@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {System.out.println("K1 sub priorityOrdered 1");}@Overridepublic int getOrder() {return 1;}
}

L类
通过扫描增加，实现了BeanDefinitionRegistryPostProcessor 、Ordered 的类

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.core.Ordered;
import org.springframework.core.PriorityOrdered;
import org.springframework.stereotype.Component;@Component
public class L implements BeanDefinitionRegistryPostProcessor, Ordered {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("L sub-parent Ordered 0");}@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {System.out.println("L sub Ordered 0");}@Overridepublic int getOrder() {return 0;}
}

L1类
通过扫描增加，实现了BeanDefinitionRegistryPostProcessor 、Ordered 的类，排序靠后

package org.springframework.example.BFPP;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;@Component
public class L1 implements BeanDefinitionRegistryPostProcessor, Ordered {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("L1 sub-parent Ordered 1");}@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {System.out.println("L1 sub Ordered 1");}@Overridepublic int getOrder() {return 1;}
}

BFPPTest测试类

package org.springframework.example.BFPP;import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class BFPPTest {public static void main(String[] args) {AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();annotationConfigApplicationContext.scan("org.springframework.example.BFPP");annotationConfigApplicationContext.addBeanFactoryPostProcessor(new E());annotationConfigApplicationContext.addBeanFactoryPostProcessor(new E1());annotationConfigApplicationContext.refresh();System.out.println(annotationConfigApplicationContext.getBean("f"));}
}

运行结果

E1 sub api add
K sub priorityOrdered 0
K1 sub priorityOrdered 1
L sub Ordered 0
L1 sub Ordered 1
H sub
J sub add BFPP I
I sub
E1 sub parent api add
k sub-parent priorityOrdered 0
k1 sub-parent priorityOrdered 1
L sub-parent Ordered 0
L1 sub-parent Ordered 1
H sub-parent
J sub-parent
I sub-parent
E parent api add
B scan, priorityOrdered 0
B1 scan, priorityOrdered 1
C scan, Ordered 0
C1 scan, Ordered 1
A scan
D scan, @Ordered 1
F1{name='null'}

可以看到执行顺序是：
1、执行实现了BeanDefinitionRegistryPostProcessor接口，通过addBeanFactoryPostProcessor 添加的类
2、执行实现了BeanDefinitionRegistryPostProcessor接口、PriorityOrdered接口的类
3、执行实现了BeanDefinitionRegistryPostProcessor接口、Ordered 接口的类
4、执行剩余实现了BeanDefinitionRegistryPostProcessor接口的类，以及后置处理中新增的BeanDefinitionRegistryPostProcessor类
5、执行实现了BeanDefinitionRegistryPostProcessor接口类的父类BeanFactoryPostProcessor的postProcessBeanFactory方法
6、执行实现了父类BeanFactoryPostProcessor接口，通过addBeanFactoryPostProcessor 添加的类
7、执行实现了父类BeanFactoryPostProcessor接口、PriorityOrdered接口的类
8、执行实现了父类BeanFactoryPostProcessor接口、Ordered 接口的类
9、其他剩余实现了BeanFactoryPostProcessor接口的类

接着来分析一下源码：
BeanFactoryPostProcessor的处理也是在AbstractApplicationContext的refresh内invokeBeanFactoryPostProcessors中，继续跟踪直到PostProcessorRegistrationDelegate–>invokeBeanFactoryPostProcessors。

发现没有，跟前面的BeanPostProcessor的处理在同一个类中

	/*** 调用BeanFactory 后置处理器* @param beanFactory* @param beanFactoryPostProcessors*/public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {// WARNING: Although it may appear that the body of this method can be easily// refactored to avoid the use of multiple loops and multiple lists, the use// of multiple lists and multiple passes over the names of processors is// intentional. We must ensure that we honor the contracts for PriorityOrdered// and Ordered processors. Specifically, we must NOT cause processors to be// instantiated (via getBean() invocations) or registered in the ApplicationContext// in the wrong order.//// Before submitting a pull request (PR) to change this method, please review the// list of all declined PRs involving changes to PostProcessorRegistrationDelegate// to ensure that your proposal does not result in a breaking change:// https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22// Invoke BeanDefinitionRegistryPostProcessors first, if any.//存放所有已经处理的Bean名称，避免重复处理Set<String> processedBeans = new HashSet<>();//先处理beanFactory是BeanDefinitionRegistry类型的，BeanDefinitionRegistry 用来注册和管理BeanDefinition//在spring中一般都是DefaultListableBeanFactoryif (beanFactory instanceof BeanDefinitionRegistry) {BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;//存放常规的BeanFactoryPostProcessorList<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();//存放BeanDefinitionRegistryPostProcessor类型的BeanFactoryPostProcessor//其是BeanFactoryPostProcessor的子类List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {//先处理BeanDefinitionRegistryPostProcessor类型的BeanFactoryPostProcessorif (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {BeanDefinitionRegistryPostProcessor registryProcessor =(BeanDefinitionRegistryPostProcessor) postProcessor;registryProcessor.postProcessBeanDefinitionRegistry(registry);registryProcessors.add(registryProcessor);}else {//处理常规的BeanFactoryPostProcessorregularPostProcessors.add(postProcessor);}}// Do not initialize FactoryBeans here: We need to leave all regular beans// uninitialized to let the bean factory post-processors apply to them!// Separate between BeanDefinitionRegistryPostProcessors that implement// PriorityOrdered, Ordered, and the rest.//存放当前执行的BeanDefinitionRegistryPostProcessorList<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.//获取BeanDefinitionRegistryPostProcessor类型的BeanFactoryPostProcessor 名称String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {//处理实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessorif (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);}}//排序sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);//里面循环调用BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());//清空当前执行的BeanDefinitionRegistryPostProcessor列表，因为后面还要用currentRegistryProcessors.clear();// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.//处理实现了Ordered接口的BeanDefinitionRegistryPostProcessorpostProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);}}sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());currentRegistryProcessors.clear();// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.//最后处理其他的BeanDefinitionRegistryPostProcessor，直到没有新的BeanDefinitionRegistryPostProcessor//循环处理，因为在BeanDefinitionRegistryPostProcessor中可能会注册新的BeanDefinitionRegistryPostProcessorboolean reiterate = true;while (reiterate) {reiterate = false;postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {if (!processedBeans.contains(ppName)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);reiterate = true;}}sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());currentRegistryProcessors.clear();}// Now, invoke the postProcessBeanFactory callback of all processors handled so far.//调用所有已处理的BeanDefinitionRegistryPostProcessors和BeanFactoryPostProcessors的postProcessBeanFactory方法//这段内部调用的是BeanDefinitionRegistryPostProcessor父类的postProcessBeanFactory方法invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);}else {// Invoke factory processors registered with the context instance.//如果beanFactory不是一个BeanDefinitionRegistry，直接调用所有的bean工厂后处理器invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);}// Do not initialize FactoryBeans here: We need to leave all regular beans// uninitialized to let the bean factory post-processors apply to them!//查找所有实现了父类BeanFactoryPostProcessor接口的beanString[] postProcessorNames =beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,// Ordered, and the rest.//存放priorityOrdered的BeanFactoryPostProcessorList<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();//存放ordered的BeanFactoryPostProcessorList<String> orderedPostProcessorNames = new ArrayList<>();//存放没有实现priorityOrdered和ordered的BeanFactoryPostProcessorList<String> nonOrderedPostProcessorNames = new ArrayList<>();for (String ppName : postProcessorNames) {//前面已经处理过了，就跳过if (processedBeans.contains(ppName)) {// skip - already processed in first phase above}else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {orderedPostProcessorNames.add(ppName);}else {nonOrderedPostProcessorNames.add(ppName);}}// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.//处理实现priorityOrdered的BeanFactoryPostProcessorsortPostProcessors(priorityOrderedPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);// Next, invoke the BeanFactoryPostProcessors that implement Ordered.//处理实现ordered的BeanFactoryPostProcessorList<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());for (String postProcessorName : orderedPostProcessorNames) {orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}sortPostProcessors(orderedPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);// Finally, invoke all other BeanFactoryPostProcessors.//处理没有实现priorityOrdered和ordered的BeanFactoryPostProcessorList<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());for (String postProcessorName : nonOrderedPostProcessorNames) {nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);// Clear cached merged bean definitions since the post-processors might have// modified the original metadata, e.g. replacing placeholders in values...//清空缓存的合并bean定义，因为后处理器可能修改了原始的元数据，例如替换值中的占位符beanFactory.clearMetadataCache();}

Debug 启动，能够看到beanFactory 是 DefaultListableBeanFactory，所以进入BeanDefinitionRegistry部分，此时的beanFactoryPostProcessors 只有E、E1，这两个是通过BFPPTest类中的addBeanFactoryPostProcessor增加，会在invokeBeanFactoryPostProcessors中最先获取。
在这里插入图片描述

在这里插入图片描述

继续往下执行，随后会判断postProcessor类型是否是BeanDefinitionRegistryPostProcessor类型，如果是会最先得到处理，调用其postProcessBeanDefinitionRegistry方法。

所以E1类是实现了BeanDefinitionRegistryPostProcessor接口，并且通过api增加，就在这里最先打印日志。

继续执行，来到了处理实现了PriorityOrdered接口的类。
在这里插入图片描述

继续执行，下面来处理实现了Ordered接口的类
在这里插入图片描述

继续执行到了，循环处理部分，此处会处理在J类中增加的I类。
在这里插入图片描述

继续执行，开始处理实现了BeanDefinitionRegistryPostProcessor接口父类的postProcessBeanFactory方法
在这里插入图片描述

在这里插入图片描述
下一步接口处理通过最开始采集到的regularPostProcessors中的BeanFactoryPostProcessor，此时这个里面只有一个E类，我们通过api接口添加
在这里插入图片描述

到这里为止，BeanDefinitionRegistryPostProcessor接口的类已经处理完毕。

接口处理BeanFactoryPostProcessor接口的类，会把实现了BeanDefinitionRegistryPostProcessor接口的类也找出来，因为BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子类
在这里插入图片描述

后面是同样的操作，先处理实现了PriorityOrdered接口的类，再处理Ordered的类，最后出来其他类。加了@Order注解的类，是当做没有实现排序类处理，所以加@Order注解对于排序在这里同样是没用的，跟BeanPostProcessor一样。
在这里插入图片描述

最后，清除缓存的合并Bean definitions，为什么要清除？好像是在并发环境下会获取到老的Bean。见：https://github.com/spring-projects/spring-framework/issues/18841

至于对BeanDefinition的修改，在G类里面将F对应的Bean类修改为F1，最后从容器中获取的Bean也是确实变成了F1。
在这里插入图片描述

作者其他文章推荐：
基于Spring Boot 3.1.0 系列文章

  1. Spring Boot 源码阅读初始化环境搭建
  2. Spring Boot 框架整体启动流程详解
  3. Spring Boot 系统初始化器详解
  4. Spring Boot 监听器详解
  5. Spring Boot banner详解
  6. Spring Boot 属性配置解析
  7. Spring Boot 属性加载原理解析
  8. Spring Boot 异常报告器解析
  9. Spring Boot 3.x 自动配置详解

这篇关于认识Spring中的BeanFactoryPostProcessor的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1049695。

相关文章

springboot集成easypoi导出word换行处理过程

springboot集成easypoi导出word换行处理过程

《springboot集成easypoi导出word换行处理过程》SpringBoot集成Easypoi导出Word时,换行符n失效显示为空格,解决方法包括生成段落或替换模板中n为回车,同时需确... 目录项目场景问题描述解决方案第一种：生成段落的方式第二种：替换模板的情况，换行符替换成回车总结项目场景s
阅读更多...
SpringBoot集成redisson实现延时队列教程

SpringBoot集成redisson实现延时队列教程

《SpringBoot集成redisson实现延时队列教程》文章介绍了使用Redisson实现延迟队列的完整步骤,包括依赖导入、Redis配置、工具类封装、业务枚举定义、执行器实现、Bean创建、消费... 目录1、先给项目导入Redisson依赖2、配置redis3、创建 RedissonConfig 配
阅读更多...
SpringBoot中@Value注入静态变量方式

SpringBoot中@Value注入静态变量方式

《SpringBoot中@Value注入静态变量方式》SpringBoot中静态变量无法直接用@Value注入,需通过setter方法,@Value(${})从属性文件获取值,@Value(#{})用... 目录项目场景解决方案注解说明1、@Value("${}")使用示例2、@Value("#{}"php
阅读更多...
SpringBoot分段处理List集合多线程批量插入数据方式

SpringBoot分段处理List集合多线程批量插入数据方式

《SpringBoot分段处理List集合多线程批量插入数据方式》文章介绍如何处理大数据量List批量插入数据库的优化方案：通过拆分List并分配独立线程处理,结合Spring线程池与异步方法提升效率... 目录项目场景解决方案1.实体类2.Mapper3.spring容器注入线程池bejsan对象4.创建
阅读更多...
线上Java OOM问题定位与解决方案超详细解析

线上Java OOM问题定位与解决方案超详细解析

《线上JavaOOM问题定位与解决方案超详细解析》OOM是JVM抛出的错误,表示内存分配失败,：本文主要介绍线上JavaOOM问题定位与解决方案的相关资料,文中通过代码介绍的非常详细,需要的朋... 目录一、OOM问题核心认知1.1 OOM定义与技术定位1.2 OOM常见类型及技术特征二、OOM问题定位工具
阅读更多...
基于 Cursor 开发 Spring Boot 项目详细攻略

基于 Cursor 开发 Spring Boot 项目详细攻略

《基于Cursor开发SpringBoot项目详细攻略》Cursor是集成GPT4、Claude3.5等LLM的VSCode类AI编程工具,支持SpringBoot项目开发全流程,涵盖环境配... 目录cursor是什么？基于 Cursor 开发 Spring Boot 项目完整指南1. 环境准备2. 创建
阅读更多...
Spring Security简介、使用与最佳实践

Spring Security简介、使用与最佳实践

《SpringSecurity简介、使用与最佳实践》SpringSecurity是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架,本文给大家介绍SpringSec... 目录一、如何理解 Spring Security？—— 核心思想二、如何在 Java 项目中使用？——
阅读更多...
SpringBoot+RustFS 实现文件切片极速上传的实例代码

SpringBoot+RustFS 实现文件切片极速上传的实例代码

《SpringBoot+RustFS实现文件切片极速上传的实例代码》本文介绍利用SpringBoot和RustFS构建高性能文件切片上传系统,实现大文件秒传、断点续传和分片上传等功能,具有一定的参考... 目录一、为什么选择 RustFS + SpringBoot？二、环境准备与部署2.1 安装 RustF
阅读更多...
springboot中使用okhttp3的小结

springboot中使用okhttp3的小结

《springboot中使用okhttp3的小结》OkHttp3是一个JavaHTTP客户端,可以处理各种请求类型,比如GET、POST、PUT等,并且支持高效的HTTP连接池、请求和响应缓存、以及异... 在 Spring Boot 项目中使用 OkHttp3 进行 HTTP 请求是一个高效且流行的方式。
阅读更多...
java.sql.SQLTransientConnectionException连接超时异常原因及解决方案

java.sql.SQLTransientConnectionException连接超时异常原因及解决方案

《java.sql.SQLTransientConnectionException连接超时异常原因及解决方案》：本文主要介绍java.sql.SQLTransientConnectionExcep... 目录一、引言二、异常信息分析三、可能的原因3.1 连接池配置不合理3.2 数据库负载过高3.3 连接泄漏
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2