spring源码-3.beanFactory后处理器

快来打我* 2024-04-17 20:11 73阅读 0赞

上一节我们已经讲完了beanFactory是如何初始化，并且是如何将需要注入到容器中的bean的beanDefinition注册到beanFactory中的。这一节我们再来看一下beanFactory的后处理器是如何运行的。  
这里从初始化完beanFactory到beanFactory的后处理器的执行有三步：

1.  beanFactory的准备工作
2.  自定义方法对beanFactory中的后处理器在执行前进行一些操作
3.  解析beanFactory中的beanDefinition，如果有BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor的实现类，那么`执行其后处理器的方法`

下面我们分别看一下这三步的实现：

### beanFactory的准备工作 ###

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    	// 设置classLoad，这个classLoad就是加载容器的classLoad
    	beanFactory.setBeanClassLoader(getClassLoader());
    	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    
    	//添加一个后处理bean
    	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    	//向ignoredDependencyInterfaces中添加class
    	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    
        //设置类和autowired的名称的映射
    	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    	beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    
    	//添加一个后处理bean
    	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
    
    	if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
    		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
    		//设置一个临时的classLoad，用于类型匹配
    		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    	}
    
    	// 如果容器中不存在environment，那么初始化一个默认的
    	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
    		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    	}
    	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
    		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    	}
    	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
    		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    	}
    }

从上面的代码可以看出，这里就是对beanFactory在标准化初始化完成以后，一些手动的操作，例如设置classLoad,添加后处理bean，设置一些环境相关的beanDefinition等操作。

### 通过自定义的代码对beanFactory中内置的后处理器进行相应的操作 ###

这里需要用户来自定义逻辑，所以源码中是一个空方法：

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {}

### 执行beanFactory的后处理器 ###

这里去解析beanFactory中的beanDefinition，看看其是否实现了BeanDefinitionRegistryPostProcessor或BeanFactoryPostProcessor，如果有实现，那么说明这个beanDefinition是一个beanFactory的后处理器，执行其处理方法。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        //将beanFactory（容器中的beanDefinition都在里面）和applicationCotext中的beanFactoryPostProcessors作为参数，去执行beanFactory的后处理器方法
    	PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
        //这里的这一步在prepareBeanFactory已经做过了，设置一个临时的类加载器，用于类型匹配的类加载
    	if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
    		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
    		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    	}
    }

这里继续计入beanFactory的后处理器的方法：

public static void invokeBeanFactoryPostProcessors(
    			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    
    	//初始化一个set，用于记录已经处理的beanFactory的后处理器
    	Set<String> processedBeans = new HashSet<>();
    
        //判断beanFactory是否为BeanDefinitionRegistry，beanFactory是DefaultListableBeanFactory，为BeanDefinitionRegistry的实现
    	if (beanFactory instanceof BeanDefinitionRegistry) {
    		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
    		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
            //遍历beanFactoryPostProcessors，由于之前的代码中没有add过，所以为空
    		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<>();
    
    		/**
    		* 这里的逻辑分为三步
    		* 1. 找出所有的BeanDefinitionRegistryPostProcessor的beanDefinition，并且筛选出PriorityOrdered的实现类，
    		*    进行排序，并执行接口BeanDefinitionRegistryPostProcessor中定义的方法postProcessBeanDefinitionRegistry
    		* 2. 和第一步逻辑是一样的，只不过找出的是Ordered的实现类，因为PriorityOrdered是Ordered的子接口，所以这边需要去除
        	*    在第一步中执行的后处理器
        	* 3. 和前面两步差不多，只不过执行的是前面两步都没有执行过的（没有实现PriorityOrdered是Ordered）
    		*/
    		String[] postProcessorNames =
    				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    		for (String ppName : postProcessorNames) {
    			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    				processedBeans.add(ppName);
    			}
    		}
    		sortPostProcessors(currentRegistryProcessors, beanFactory);
    		registryProcessors.addAll(currentRegistryProcessors);
    		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    		currentRegistryProcessors.clear();
    
    		//对Ordered的实现后处理器进行处理
    		postProcessorNames = 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);
    		currentRegistryProcessors.clear();
    
    		//对剩余的后处理器进行处理
    		boolean 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);
    			currentRegistryProcessors.clear();
    		}
    
    		/**
    		* 由于BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口，所以这边还需要执行
    		* BeanFactoryPostProcessor中定义的方法postProcessBeanFactory
    		*/
    		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
    		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    	}
    
    	else {
    		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    	}
    
    	/**
    	* 这里解释以下为什么还需要下面的步骤，spring中定义一个beanFactory后处理器的方法有两种：
    	* 1. 实现BeanDefinitionRegistryPostProcessor接口
    	* 2. 实现BeanFactoryPostProcessor接口
    	* 其中BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口，上面的逻辑已经处理完了
    	* BeanDefinitionRegistryPostProcessor的实现类的后处理器，下面现在需要处理的是BeanFactoryPostProcessor的实现类
    	*/
    	String[] postProcessorNames =
    			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    
    	//这里的逻辑和上面差不多，找出所有的BeanFactoryPostProcessor的实现，并根据是否实现PriorityOrdered
    	//Ordered进行分类
    	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    	List<String> orderedPostProcessorNames = new ArrayList<>();
    	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    	for (String ppName : postProcessorNames) {
    		if (processedBeans.contains(ppName)) {
    			//如果之前已经执行过了，这边就直接跳过，因为BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口
    		}
    		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);
    		}
    	}
    
    	//首先，执行PriorityOrdered的子类
    	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
    	//截至，执行Ordered的子类
    	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    	for (String postProcessorName : orderedPostProcessorNames) {
    		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    	}
    	sortPostProcessors(orderedPostProcessors, beanFactory);
    	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    
    	//最后，执行没有实现排序接口的子类
    	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    	for (String postProcessorName : nonOrderedPostProcessorNames) {
    		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    	}
    	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
    	//beanFactory清空元数据缓存（allBeanNamesByType和singletonBeanNamesByType），这两个缓存实在上面getBeanNamesForType创建的
    	beanFactory.clearMetadataCache();
    }

这一步的逻辑较为复杂，我们来进行一个简单的梳理：

1.  首先我们需要了解两个定义：  
    1.1 beanFactory的后处理器需要实现BeanDefinitionRegistryPostProcessor或者BeanFactoryPostProcessor，前者是后者的子接口，所以如果后处理器是BeanDefinitionRegistryPostProcessor的实现，则需要执行BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor的实现方法  
    2.2 beanFactory的后处理器的排序可以实现接口PriorityOrdered或者Ordered，前者是后者的子接口
2.  定义一个Set，用来记录已经执行过的beanFactory的后处理器
3.  遍历代码中add的后处理器，如果存在则分为两步：  
    3.1 如果是BeanDefinitionRegistryPostProcessor的实现，则直接执行其实现方法，并记录于registryProcessors中  
    3.2 如果是BeanFactoryPostProcessor，则直接记录于regularPostProcessors
4.  查询出所有的BeanDefinitionRegistryPostProcessor实现类的beanDefinition，这里有四步：  
    4.1 找出PriorityOrdered接口的实现，排序执行，并记录于registryProcessors中  
    4.2 找出Ordered接口的实现，排序执行，并记录于registryProcessors中  
    4.3 找出剩余的，执行，并记录于registryProcessors中  
    4.3 执行registryProcessors中所有的BeanFactoryPostProcessor的接口方法
5.  查询出所有的BeanFactoryPostProcessor实现类且没有执行过的beanDefinition，这里有三步：  
    5.1 找出PriorityOrdered接口的实现，排序执行  
    5.2 找出Ordered接口的实现，排序执行  
    5.3 找出剩余的，执行  
    6.清除查询后处理器的产生的缓存