深入理解 Spring BeanPostProcessor

回顧上一篇博客中,在AbstractApplicationContext這個抽象類中,Spring使用invokeBeanFactoryPostProcessors(beanFactory);執行BeanFactoryPostProcessor,通過回調Spring自己添加的ConfigurationClassPostProcessor以及用戶添加的bean工廠的后置處理器,完成了包掃描以及對主配置類代理的工作

本篇博文將繼續往下跟進

程序入口:注冊bean的后置處理器

AbstractApplicationContext的registerBeanPostProcessors(beanFactory);方法

通過方法名字,見名知意, 注冊bean的后置處理器, 說白了就是將系統中所有的bean的后置處理器統一交給Spring的beanFactory管理

那么問題來了

什么是BeanPostProcessor? 有什么作用?

Bean的后置處理器,首先來說,他是Spring中抽象出來的一個頂級的接口, 他里面有如下有如下兩個方法, 這兩個方法的執行時機通過方法的名字也能猜的出, 一個是在構造方法之后,init()方法之前,第二個是在init()方法之后執行

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

大家說它是Spring對外提供的拓展點,也許是因為,通過實現這個接口,程序員可以被Spring管理的bean的生命周期進行插手

這也體現了AOP的設計思想,就比如在init()方法執行前后做出不同的動作,其實就是對bean的一種增強

此外BeanPostProcessor可以存在多個,他們會被存儲在一個列表中,然后依次被執行

為什么要注冊BeanPostProcessor?

所謂的注冊,只不過是對當前上下文中所有的BeanPostProcessor進行一種集中式管理罷了, 為什么非得這么做呢? 因為上下文中BeanPostProcessor的數量不是一成不變的,Spring為了啟動的正常,需要添加原生的BeanPostProcessor,程序員因為自己的需求也會添加不同數量的bean的后置處理器,因此需要這種策略,將上下文中所有的后置處理器進行統一的管理,方便回調

源碼閱讀:

這段代碼的邏輯很清楚簡明: 首先,根據類型從當前的上面中取出所有的BeanPostProcessor的實現類,那么問題來了,當前上下文中有幾個呢?如下圖:

這三個中的前兩個后置還處理器是在prepareBeanFactory()時添加進去的,第三個是在為主配置類生成代理時傳遞進去的

緊接着調用beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false),結果如下圖

前三個處理器是不是很熟悉? 沒錯,他們是創建AnnotationedBeanDefinitionReader時創建的6個RootBeanDefinition中 的第4-5-6個, 其中的AutowiredAnnotationBeanPostProcessor的主要功能是處理@Autowired注解,並且解決了setter方式的循環依賴問題, CommonAnnotationBeanPostProcessor 主要處理@Resource @PostConstructor @PreDestory注解
RequiredAnnotationBeanPostProcessor處理@Required注解, 上圖中的最后一個注解是``

在下面的代碼中,Spring開始根據不同的處理器的注解標注情況,接口的實現情況進行排序處理, 並且又添加了兩個后置處理器

public static void registerBeanPostProcessors(
		ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    // 根據類型從beanFactory中取出所有實現BeanPostProcessor接口的實現類的名字
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

	int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    // 這是個內部類,用來檢查是否在bean的創建過程中,經過了所有本來應經過的后置處理器
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

	List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
	List<String> orderedPostProcessorNames = new ArrayList<>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    
    // 將添加執行注解,實現排序接口的beanPostProcessor添加到相應的集合中
	for (String ppName : postProcessorNames) {
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			priorityOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}
    // 按照優先順序排序
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    // 批量注冊priorityOrderedPostProcessors中的bean的后置處理器
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

	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.
	// todo 現在注冊 全部 正常的沒有排序的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);
	sortPostProcessors(internalPostProcessors, beanFactory);

	// Finally, re-register all internal BeanPostProcessors.
	// 最后注冊所有內置的BeanPostProcessor
	registerBeanPostProcessors(beanFactory, internalPostProcessors);

	//這里又添加了一個處理器
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

beanPostProcessor全部注冊到了AbstractBeanFactory中的下面這個字段中

private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();