Spring 中 BeanFactoryPostProcessor 接口的作用

BeanFactoryPostProcessor 作用

BeanFactoryPostProcessor 和该子类 BeanDefinitionRegistryPostProcessor 作用于 BeanDefinition 解析之后，Bean 实例化之前，所以我们可以在 BeanDefinition 定义好了之后做一些修改，从而影响 Bean 的实例化。

源码如下

BeanFactoryPostProcessor 类定义的方法中我们可以获取到 BeanFactory，有了这个工厂自然而然就可以干很多事情啦，比如去修改它的默认配置：

// 对 bean 工厂的进一步后置增强，这个接口会暴露出工厂，有了工厂自然而然就可以干很多事情啦
@FunctionalInterface
public interface BeanFactoryPostProcessor {

	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

比如我们去修改 BeanFactory 中的两个默认属性：是否允许循环依赖，是否允许 BeanDefinition 覆盖（当我们注解和 xml 同时存在并且 beanName 还是相同，是否支持 BeanDefinition 的覆盖）

@Component
public class MyConfigurationPostProcessor implements BeanDefinitionRegistryPostProcessor {
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		if (beanFactory instanceof DefaultListableBeanFactory) {
			DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) beanFactory;
			defaultListableBeanFactory.setAllowCircularReferences(false);
			defaultListableBeanFactory.setAllowBeanDefinitionOverriding(false);
		}
	}
}

BeanDefinitionRegistryPostProcessor 类继承了 BeanFactoryPostProcessor 类，扩展了方法，让我们可以更轻松的获取到 BeanDefinitionRegistry 注册器，这样我们就可以利用这个类去额外注册一些其他的 BeanDefinition，也可以对 BeanDefinition 做一些删除、修改等操作

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}

比如我们现在有一个实体类，但是没有标注 @Component 注解，那么肯定是不能被 @ComponentScan 扫描到的，此时我们可以通过这个方法就可以手动讲该实体交给 Spring 管理。

实体类如下：

public class ProcessorEntity {
	private String name = "ABC";

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

注意实体类没有标注 @Component 注解，并且属性默认值是 ABC，然后通过 BeanDefinitionRegistryPostProcessor 进行注册该实体类，并且还要修改属性的默认值，修改成"小明"，如下：

@Component
public class MyConfigurationPostProcessor1 implements BeanDefinitionRegistryPostProcessor {
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("MyConfigurationPostProcessor1---postProcessBeanFactory");
	}

	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		System.out.println("MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry");
		GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
		genericBeanDefinition.setBeanClass(ProcessorEntity.class);
		MutablePropertyValues propertyValues = genericBeanDefinition.getPropertyValues();
		// 修改 ProcessorEntity 类中 name 属性默认值
		propertyValues.addPropertyValue("name","小明");

		// 然后再将 BeanDefinition 注册到 BeanFactory 容器中
		registry.registerBeanDefinition("processorEntity",genericBeanDefinition);
	}
}

测试类如下：

public class TestBeanScanner {
	public static void main(String[] args) {
		ApplicationContext context = new AnnotationConfigApplicationContext(ScannerConfig.class);

		ProcessorEntity processorEntity = context.getBean("processorEntity", ProcessorEntity.class);
		System.out.println("processorEntity = " + processorEntity+",name="+processorEntity.getName());
	}
}

输出结果如下：

MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry
MyConfigurationPostProcessor1---postProcessBeanFactory
processorEntity = com.gwm.bean221207.processors.ProcessorEntity@346d61be,name=小明

发现也是可以获取到 ProcessorEntity 类的实例。

然后我们继续利用这个方法，来扫描我们自定义注解修饰的类。

自定义注解如下：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyServiceAnno {
	String value() default "";
}

实体类如下：

@MyServiceAnno
public class TestAnnoService {
	private String userName = "张老三";

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}
}

然后借助 Spring 的包扫描器 ClassPathBeanDefinitionScanner 进行扫描，此时我们的 MyConfigurationPostProcessor1 就有点类似于简化版的 ConfigurationClassPostProcessor 后置处理器，都是在 postProcessBeanDefinitionRegistry() 方法中进行操作的，都实现了接口 BeanDefinitionRegistryPostProcessor ，只不过 Spring 提供内置的扫描功能比较全面，我们做的比较简陋而已，就只模拟扫描自定义注解，代码如下：

@Component
public class MyConfigurationPostProcessor1 implements BeanDefinitionRegistryPostProcessor {
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("MyConfigurationPostProcessor1---postProcessBeanFactory");
	}

	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		System.out.println("MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry");
		GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
		genericBeanDefinition.setBeanClass(ProcessorEntity.class);
		MutablePropertyValues propertyValues = genericBeanDefinition.getPropertyValues();
		// 修改 ProcessorEntity 类中 name 属性默认值
		propertyValues.addPropertyValue("name","小明");

		// 然后再将 BeanDefinition 注册到 BeanFactory 容器中
		registry.registerBeanDefinition("processorEntity",genericBeanDefinition);

		// 直接把 Spring 的类路径扫描器拿过来用用
		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry);
		// 添加过滤条件：自定义的注解修饰的类
		scanner.addIncludeFilter(new AnnotationTypeFilter(MyServiceAnno.class));
		// 开始自动扫描然后封装 ScannedBeanDefinition，然后注册到容器
		scanner.scan("com.gwm.anno");
	}
}

输出结果如下：

MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry
MyConfigurationPostProcessor1---postProcessBeanFactory
testAnnoService = com.gwm.anno.TestAnnoService@747edf66,userName=张老三
processorEntity = com.gwm.bean221207.processors.ProcessorEntity@346d61be,name=小明

那么以上两个接口中的方法在哪里被调用呢，这里举例说明其中的一处调用。为了更好地展示效果，这里直接我们直接输出日志。

定义两个 Processor 都实现 BeanDefinitionRegistryPostProcessor 接口，代码如下：

@Component
public class MyConfigurationPostProcessor1 implements BeanDefinitionRegistryPostProcessor {
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("MyConfigurationPostProcessor1---postProcessBeanFactory");
	}

	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		System.out.println("MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry");
	}
}

@Component
public class MyConfigurationPostProcessor2 implements BeanDefinitionRegistryPostProcessor {

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("MyConfigurationPostProcessor2---postProcessBeanFactory");
	}

	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		System.out.println("MyConfigurationPostProcessor2---postProcessBeanDefinitionRegistry");
	}
}

输出结果：

MyConfigurationPostProcessor2---postProcessBeanDefinitionRegistry
MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry
MyConfigurationPostProcessor2---postProcessBeanFactory
MyConfigurationPostProcessor1---postProcessBeanFactory

debug 跟踪源码，发现调用的地方在下面这段代码中，源码如下：

	public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		// 因为第一过来的时候 TODO beanFactoryPostProcessors 这个变量不知道什么时候才会传入值，目前看是空集合，有待调试
		Set<String> processedBeans = new HashSet<>();

		// beanFactory 实现了 BeanDefinitionRegistry 注册接口，所以这里条件成立
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;

					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}


			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			/**
			 * 获取所有实现了 BeanDefinitionRegistryPostProcessor 接口的子类
			 * 并且判断是否还实现了 PriorityOrdered 权重接口，如果实现了则优先回调该类的 postProcessBeanDefinitionRegistry() 方法
			 * 目前看如果是以注解方式启动，Spring 其中有一个内置类实现了该接口，就是 ConfigurationClassPostProcessor 该配置类是在
			 * 外面的 this() 构造函数中直接把 BeanDefinition 注册到了 BeanDefinitionMap 容器中,其中还有 @AutowiredPostProcessor
			 * 所以这里优先调用的是这个扫描后置处理类的方法，然后去调用 doScan() 扫描其他组件
			 * 所以下面如果在重新调用这个 getBeanNamesForType() 方法，可能就会多出很多的子类了
			 * 因为 ConfigurationClassPostProcessor 后之类已经把所有的类扫描进来了
			 */
			String[] postProcessorNames =
 					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				// 是否实现了 PriorityOrdered 排序接口
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					// 调用 getBean() 直接实例化这个子类
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					// 记录一下当前已经执行过的 Processor，避免重复调用
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			/**
			 * 循环回调 BeanDefinitionRegistryPostProcessor 所有实现子类的方法
			 * 目前这里看只会回调到 ConfigurationClassPostProcessor 子类中的方法
			 * 这个类回调到 doScan() 扫描其他组件，然后注册到 BeanDefinitionMap 容器中，所以下面在执行 getBeanNamesForType()
			 * 方法时肯定会多出很多 BeanDefinitionRegistryPostProcessor 的子类实现
			 */
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			currentRegistryProcessors.clear();


			/**
			 * 再次去检索一下 BeanDefinitionRegistryPostProcessor 接口的实现子类，此时应该是会更多或者是一样
			 * 此时如果我们扩展了这个接口，比较交给了 Spring 管理，那么这里肯定是能够扫描出来的
			 * 如果还实现了 Ordered 接口的话，那么下面这段代码就会会调用方法 postProcessBeanDefinitionRegistry()
			 */
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				 // 是否实现了 Ordered 排序接口
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					// 调用 getBean() 直接实例化这个子类
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					// 记录一下当前已经执行过的 Processor，避免重复调用
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			/**
			 * 执行过的就不会再回调了，因为 processedBeans 标记好了哪些执行过的，这里会回调我们自己扩展的 Processor 子类
			 */
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			currentRegistryProcessors.clear();



			/**
			 * 最后，再次检索 BeanDefinitionRegistryPostProcessor，然后处理没有实现 PriorityOrdered、Ordered 接口的子类实现
			 */
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						/**
						 * 此处会通过 getBean() 去创建好这个后置处理器 Bean
						 */
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				/** 调用 postProcessBeanDefinitionRegistry() 方法 */
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
				currentRegistryProcessors.clear();
			}

			/**
			 * 上面一大段逻辑都是去调用 BeanDefinitionRegistryPostProcessor 类子类的 postProcessBeanDefinitionRegistry()
			 * 的注册方法。
			 * 最后在调用 BeanDefinitionRegistryPostProcessor 从父类继承过来的 postProcessBeanFactory() 方法
			 */
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			/**
			 * 一般这里是没有值的，无需注重
			 * 调用从入参中传入过来的 BeanDefinitionRegistryPostProcessor 对象的方法
			 */
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

		}

		else {
			// TODO 这个应该是测试代码，只有一个地方调用了，就是 Test
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}


		//=========================================================================================
		// 这下面的逻辑全部都是调用 BeanFactoryPostProcessor 的 postProcessBeanFactory() 方法
		//=========================================================================================


		/** 获取到所有的  BeanFactoryPostProcessor beaFactory后置处理器*/
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);


		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			/**
			 * processedBeans 如果是执行过的 bean 后置处理器，就直接跳过 skip 不再处理
			 * 注意虽然代码会走到这些面，但是因为这里的 processedBeans 会拦截处理过的 BeanFactoryPostProcessor
			 * 这个细节注意哟
			 **/
			if (processedBeans.contains(ppName)) {
				// ...do nothing...
			}
			// 判断你是否实现了 PriorityOrdered 接口，实现这个接口可以将后置处理进行排序执行
			// 其中 Ordered 数值越小优先级越高
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			// 判断你是否实现了注解方式的优先级，和 PriorityOrdered 接口功能是一样的
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				// 就上述两种处理器，其他的都是普通的 bean 工厂后置处理器
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// gwm_tag: 最先调用实现了 PriorityOrdered 接口的 beanFactoryPostProcessor 处理器
		// 处理器进行排序
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		// 开始调用实现了 PriorityOrdered 接口的 bean 工厂处理器的 postProcessBeanFactory() 方法
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		// 处理器进行排序
		sortPostProcessors(orderedPostProcessors, beanFactory);
		// gwm_tag: 第二调用实现了 Ordered 注解的 bean 工厂后置处理器的 postProcessBeanFactory() 方法
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		// gwm_tag: 最后才是调用普通的 bean 工厂后置处理器的 postProcessBeanFactory() 方法
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// 最后清空缓存就是这个 Map 而已： Map<String, BeanDefinitionHolder> mergedBeanDefinitionHolders = new ConcurrentHashMap<>(256)
		beanFactory.clearMetadataCache();
	}

这里特别注意一点，优先级问题，因为我们平时可能扩展的 BeanFactoryPostProcessor 不止一个，所以这里就需要分优先级执行，优先级可以通过 PriorityOrdered 和 Ordered 方法定义优先级。