【Spring源码分析】4、Spring Bean 生命周期扩展点 PostProcessor 和 Aware 分析

超、凢脫俗 2022-11-27 11:29 147阅读 0赞

### 文章目录 ###

*  1、Spring Bean 生命周期扩展点
 *   *   *  （1）BeanFactoryPostProcessor接口类
         *  （2）BeanPostProcessor接口类
         *  （3）Aware接口类
 *  2、扩展点在生命周期中的执行顺序
 *   *   *  （1）BeanFactoryPostProcessor接口类执行顺序
         *  （2）BeanPostProcessor接口类执行顺序
         *  （3）Aware接口类执行顺序
 *  3、BeanFactoryPostProcessor接口分析
 *   *   *  （1）BeanFactoryPostProcessor
         *  （2）BeanDefinitionRegistryPostProcessor
 *  4、BeanPostProcessor接口分析
 *   *   *  （1）BeanPostProcessor
         *  （2）InstantiationAwareBeanPostProcessor
         *  （3）SmartInstantiationAwareBeanPostProcessor
         *  （4）InstantiationAwareBeanPostProcessorAdapter（适配器）
         *  （5）MergedBeanDefinitionPostProcessor
         *  （6）DestructionAwareBeanPostProcessor
 *  5、Aware接口类分析
 *   *   *  （1）Aware
         *  （2）BeanNameAware
         *  （3）BeanFactoryAware
         *  （4）BeanClassLoaderAware
         *  （5）ApplicationContextAware
         *  （6）EmbeddedValueResolverAware
         *  （7）EnvironmentAware
         *  （8）MessageSourceAware
 *  5、更多细节学习
 *  微信公众号

# 1、Spring Bean 生命周期扩展点 #

spring bean的整个生命周期中穿插了各种各样的组件，工具等信息，spring在各个阶段也为我们提供了各式各样的扩展点，其中最核心的分为两大类，PostProcessor类型接口的实现类和Aware接口的实现类

PostProcessor类型接口常用类分为两种，一种是`BeanFactoryPostProcessor`，另一种是`BeanPostProcessor`

BeanFactoryPostProcessor与BeanPostProcessor的使用区别

<table> 
 <thead> 
  <tr> 
   <th align="left">PostProcessor名称</th> 
   <th align="left">作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">BeanFactoryPostProcessor</td> 
   <td align="left">关于对象工厂BeanFactory创建完毕的回调处理</td> 
  </tr> 
  <tr> 
   <td align="left">BeanPostProcessor</td> 
   <td align="left">关于通过对象工厂BeanFactory创建对象前后的回调处理</td> 
  </tr> 
 </tbody> 
</table>

### （1）BeanFactoryPostProcessor接口类 ###

PostProcessor类型接口BeanFactoryPostProcessor

BeanFactoryPostProcessor
    	BeanDefinitionRegistryPostProcessor

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NzYyMjM3_size_16_color_FFFFFF_t_70_pic_center]

### （2）BeanPostProcessor接口类 ###

PostProcessor类型接口BeanPostProcessor

我这里只是举例说明常用的类有哪些，实际上实现类是非常多的，其中相关常用接口的继承关系如下

BeanPostProcessor
    	InstantiationAwareBeanPostProcessor
    		SmartInstantiationAwareBeanPostProcessor
    			InstantiationAwareBeanPostProcessorAdapter（适配器）
    	MergedBeanDefinitionPostProcessor
    	DestructionAwareBeanPostProcessor

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NzYyMjM3_size_16_color_FFFFFF_t_70_pic_center 1]

### （3）Aware接口类 ###

Aware常用类就只有一个根接口Aware，其他接口作为扩展继承Aware，下面是常用接口继承关系图

Aware
    	BeanNameAware
    	BeanFactoryAware
    	BeanClassLoaderAware
    	
    	ApplicationContextAware
    	EmbeddedValueResolverAware
    	EnvironmentAware
    	MessageSourceAware

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NzYyMjM3_size_16_color_FFFFFF_t_70_pic_center 2]

# 2、扩展点在生命周期中的执行顺序 #

了解过IOC容器加载过程的同学都知道，`AbstractApplicationContext.refresh()`中有9个核心方法的调用，其中第二个方法和第三个方法就是PostProcessor类型接口的BeanPostProcessor和BeanFactoryPostProcessor的注册，AbstractApplicationContext.refresh()源码

@Override
    	public void refresh() throws BeansException, IllegalStateException { 
    		synchronized (this.startupShutdownMonitor) { 
    			// 准备此上下文以进行刷新。
    			prepareRefresh();
    
    			// 告诉子类刷新内部bean工厂。
    			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    			// 准备在这种情况下使用的bean工厂。
    			prepareBeanFactory(beanFactory);
    
    			try { 
    				// 1、允许在上下文子类中对bean工厂进行后处理。
    				postProcessBeanFactory(beanFactory);
    
    				// 2、调用在上下文中注册为bean的工厂处理器。
    				invokeBeanFactoryPostProcessors(beanFactory);
    
    				// 3、注册拦截Bean创建的Bean处理器。
    				registerBeanPostProcessors(beanFactory);
    
    				// 4、为此上下文初始化消息源。
    				initMessageSource();
    
    				// 5、为此上下文初始化事件多播器。
    				initApplicationEventMulticaster();
    
    				// 6、在特定上下文子类中初始化其他特殊bean。
    				onRefresh();
    
    				// 7、检查侦听器bean并注册它们。
    				registerListeners();
    
    				// 8、实例化所有剩余的（非延迟初始化）单例。
    				finishBeanFactoryInitialization(beanFactory);
    
    				// 9、最后一步：发布相应的事件。
    				finishRefresh();
    			}
    
    			catch (BeansException ex) { 
    				if (logger.isWarnEnabled()) { 
    					logger.warn("Exception encountered during context initialization - " +
    							"cancelling refresh attempt: " + ex);
    				}
    
    				// 销毁已创建的单例以避免资源悬空。
    				destroyBeans();
    
    				// 重置“活动”标志。
    				cancelRefresh(ex);
    
    				// 将异常传播给呼叫者。
    				throw ex;
    			}
    
    			finally { 
    				//在Spring的核心中重置常见的自省缓存，因为我们
    				//可能不再需要单例bean的元数据...
    				resetCommonCaches();
    			}
    		}
    	}

### （1）BeanFactoryPostProcessor接口类执行顺序 ###

重点分析`AbstractApplicationContext.refresh()`中的第二步

// 2、调用在上下文中注册为bean的工厂处理器。
    	invokeBeanFactoryPostProcessors(beanFactory);

源码中，下一步调用的方法为

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

再下一步`invokeBeanFactoryPostProcessors()`方法即为注册的核心方法

public static void invokeBeanFactoryPostProcessors(
    			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) { 
    
    		// 如果有的话，首先调用BeanDefinitionRegistryPostProcessors。
    		Set<String> processedBeans = new HashSet<>();
    
    		if (beanFactory instanceof BeanDefinitionRegistry) { 
    			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    			// 常规后置处理器
    			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
    			// BeanDefinition注册后置处理器
    			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);
    				}
    			}
    
    			// 不要在这里初始化FactoryBeans：我们需要保留所有常规bean
    			// 未初始化，让Bean工厂后处理器对其应用！
    			// 将实现的BeanDefinitionRegistryPostProcessor分开
    			// PriorityOrdered，Ordered等。
    			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
    
    			// 首先，调用实现PriorityOrdered的BeanDefinitionRegistryPostProcessors。
    			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的BeanDefinitionRegistryPostProcessors。
    			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();
    
    			// 最后，调用所有其他BeanDefinitionRegistryPostProcessor，直到没有其他的出现。
    			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();
    			}
    
    			// 现在，调用到目前为止已处理的所有处理器的postProcessBeanFactory回调。
    			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
    			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    		}
    
    		else { 
    			// 调用在上下文实例中注册的工厂处理器。
    			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    		}
    
    		// 不要在这里初始化FactoryBeans：我们需要保留所有常规bean
    		// 未初始化，让Bean工厂后处理器对其应用！
    		String[] postProcessorNames =
    				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    
    		// 将实现PriorityOrdered的BeanFactoryPostProcessor分开，
    		// 排序，和其他的
    		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    		List<String> orderedPostProcessorNames = new ArrayList<>();
    		List<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);
    			}
    		}
    
    		// 首先，调用实现PriorityOrdered的BeanFactoryPostProcessors。
    		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
    		// 接下来，调用实现Ordered的BeanFactoryPostProcessors。
    		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    		for (String postProcessorName : orderedPostProcessorNames) { 
    			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    		}
    		sortPostProcessors(orderedPostProcessors, beanFactory);
    		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    
    		// 最后，调用所有其他BeanFactoryPostProcessors。
    		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    		for (String postProcessorName : nonOrderedPostProcessorNames) { 
    			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    		}
    		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
    
    		//清除缓存的合并bean定义，因为后处理器可能具有
    		//修改了原始元数据，例如替换值中的占位符...
    		beanFactory.clearMetadataCache();
    	}

从源码中可以分析出：首先拿到当前山下文的beanFactory，如果类型是BeanDefinitionRegistry，则进行相关bean的处理（获取所有相关的BeanDefinition进行注册，然后排序），否则直接注册默认的beanFactory。下面我们分析当前beanFactory为BeanDefinitionRegistry类型的时候

> 源码中多次使用sortPostProcessors(currentRegistryProcessors, beanFactory)这个方法，后面我们会详细介绍这个方法的具体使用方法， 因为这个排序方法的逻辑，适用于整个spring源码的环境

首先，准备两个List集合用于存放BeanFactoryPostProcessor类型和BeanDefinitionRegistryPostProcessor类型， 然后将传入的参数BeanFactoryPostProcessor类型的List进行遍历，并分为以上两类

1.  调用实现PriorityOrdered的BeanDefinitionRegistryPostProcessors
2.  调用实现Ordered的BeanDefinitionRegistryPostProcessors
3.  调用所有其他BeanDefinitionRegistryPostProcessor，直到没有其他的出现
4.  调用非BeanDefinitionRegistryPostProcessor类型的bean

调用到目前为止已处理的所有处理器的postProcessBeanFactory回调，源码继续向下分析，将实现PriorityOrdered的BeanFactoryPostProcessor分开，分为三类（priorityOrdered优先选择，ordered第二的，nonOrdered最后的）

1.  调用实现PriorityOrdered的BeanFactoryPostProcessors
2.  调用实现Ordered的BeanFactoryPostProcessors
3.  调用所有其他BeanFactoryPostProcessors

到这里BeanFactoryPostProcessor接口类执行顺序已经分析完成了，细心的同学会发下，调用完所有方法后，观察方法的日志会发现，BeanFactoryPostProcessor的相关方法已经调用了

BeanDefinitionRegistryPostProcessor postProcessBeanDefinitionRegistry() ...
    BeanFactoryPostProcessor postProcessBeanFactory() ...

对应[【Spring Bean 生命周期】][Spring Bean]的初始化过程流程图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NzYyMjM3_size_16_color_FFFFFF_t_70_pic_center 3]

### （2）BeanPostProcessor接口类执行顺序 ###

重点分析`AbstractApplicationContext.refresh()`中的第三步

// 3、注册拦截Bean创建的Bean处理器。
    	registerBeanPostProcessors(beanFactory);

源码中，下一步调用的方法为

public static void registerBeanPostProcessors(
    			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { 
    
    		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    
    		// 注册BeanPostProcessorChecker，该日志将在以下情况下记录信息消息
    		// 在BeanPostProcessor实例化期间，即当
    		// 一个bean不适合所有BeanPostProcessor处理。
    		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    
    		// 将实现PriorityOrdered的BeanPostProcessor之间分开，
    		// 排序和其他的
    		// 优先选择的后置处理器
    		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    		// 内部的后置处理器
    		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    		// 排序名称
    		List<String> orderedPostProcessorNames = new ArrayList<>();
    		// 没有排序名称
    		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    		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);
    			}
    		}
    
    		// 首先，注册实现PriorityOrdered的BeanPostProcessor。
    		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    
    		// 接下来，注册实现Ordered的BeanPostProcessor。
    		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    		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);
    
    		// 现在，注册所有常规BeanPostProcessor。
    		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    		for (String ppName : nonOrderedPostProcessorNames) { 
    			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
    			nonOrderedPostProcessors.add(pp);
    			if (pp instanceof MergedBeanDefinitionPostProcessor) { 
    				internalPostProcessors.add(pp);
    			}
    		}
    		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
    
    		// 最后，重新注册所有内部BeanPostProcessor。
    		sortPostProcessors(internalPostProcessors, beanFactory);
    		registerBeanPostProcessors(beanFactory, internalPostProcessors);
    
    		// 重新注册用于将内部bean检测为ApplicationListener的后处理器，
    		// 将其移动到处理器链的末尾（用于拾取代理等）。
    		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
    	}

从源码中可以分析出：首先拿到BeanPostProcessor的所有beanName，然后将BeanPostProcessor分为两类（priorityOrdered优先选择，internal内部的），然后将beanName分为两类（ordered已排序的，nonOrdered未排序的）

1.  注册实现PriorityOrdered的BeanPostProcessor
2.  注册实现Ordered的BeanPostProcessor
3.  注册所有常规BeanPostProcessor
4.  重新注册所有内部BeanPostProcessor（用于将内部bean检测为ApplicationListener的后处理器）
5.  最后将其移动到处理器链的末尾（用于拾取代理等）

到这里BeanPostProcessor接口类执行顺序已经分析完成了

### （3）Aware接口类执行顺序 ###

所有Aware方法为以下几种，通过测试之后，执行顺序如下

1. BeanNameAware.setBeanName()
    2. BeanClassLoaderAware.setBeanClassLoader()
    3. BeanFactoryAware.setBeanFactory() 
    4. EnvironmentAware.setEnvironment()
    5. EmbeddedValueResolverAware.setEmbeddedValueResolver()
    6. ResourceLoaderAware.setResourceLoader()
    7. ApplicationEventPublisherAware.setApplicationEventPublisher()
    8. MessageSourceAware.setMessageSource()
    9. ApplicationContextAware.setApplicationContext()
    10. ServletContextAware.setServletContext()

*  1 ~ 3：AbstractAutowireCapableBeanFactory中处理  
    的执行顺序在`AbstractAutowireCapableBeanFactory.doCreateBean()`方法中，这个类很眼熟，就是spring bean 加载的核心类，不熟悉的看[【spring bean的生命周期】][Spring Bean]学习一下，其中spring bean 出书画的第三个大阶段，初始化阶段调用的方法`initializeBean()`，该方法调用`invokeAwareMethods()`方法，源码为

private void invokeAwareMethods(String beanName, Object bean) { 
    		if (bean instanceof Aware) { 
    			if (bean instanceof BeanNameAware) { 
    				((BeanNameAware) bean).setBeanName(beanName);
    			}
    			if (bean instanceof BeanClassLoaderAware) { 
    				ClassLoader bcl = getBeanClassLoader();
    				if (bcl != null) { 
    					((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
    				}
    			}
    			if (bean instanceof BeanFactoryAware) { 
    				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
    			}
    		}
    	}

*  4 ~ 9：ApplicationContextAwareProcessor中处理  
    `在ApplicationContextAwareProcessor.postProcessBeforeInitialization()`的源码方法中，判断了相应的类型,，

@Override
    	@Nullable
    	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
    		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
    				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
    				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){ 
    			return bean;
    		}
    
    		AccessControlContext acc = null;
    
    		if (System.getSecurityManager() != null) { 
    			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
    		}
    
    		if (acc != null) { 
    			AccessController.doPrivileged((PrivilegedAction<Object>) () -> { 
    				invokeAwareInterfaces(bean);
    				return null;
    			}, acc);
    		}
    		else { 
    			invokeAwareInterfaces(bean);
    		}
    
    		return bean;
    	}
    
    	private void invokeAwareInterfaces(Object bean) { 
    		if (bean instanceof EnvironmentAware) { 
    			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
    		}
    		if (bean instanceof EmbeddedValueResolverAware) { 
    			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
    		}
    		if (bean instanceof ResourceLoaderAware) { 
    			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
    		}
    		if (bean instanceof ApplicationEventPublisherAware) { 
    			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
    		}
    		if (bean instanceof MessageSourceAware) { 
    			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
    		}
    		if (bean instanceof ApplicationContextAware) { 
    			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
    		}
    	}

*  10：ServletContextAwareProcessor中处理  
    `ServletContextAwareProcessor.postProcessBeforeInitialization()`中处理Aware相关接口，相关源码为

@Override
    	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
    		if (getServletContext() != null && bean instanceof ServletContextAware) { 
    			((ServletContextAware) bean).setServletContext(getServletContext());
    		}
    		if (getServletConfig() != null && bean instanceof ServletConfigAware) { 
    			((ServletConfigAware) bean).setServletConfig(getServletConfig());
    		}
    		return bean;
    	}

# 3、BeanFactoryPostProcessor接口分析 #

### （1）BeanFactoryPostProcessor ###

spring的bean创建之前，修改bean的定义属性

也就是说，Spring允许BeanFactoryPostProcessor在容器实例化任何其它bean之前读取配置元数据，并可以根据需要进行修改，例如可以把bean的scope从singleton改为prototype，也可以把property的值给修改掉。可以同时配置多个BeanFactoryPostProcessor，并通过设置’order’属性来控制各个BeanFactoryPostProcessor的执行次序

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.context.annotation.Configuration;
    
    /** * @author Tellsea * @date 2020-8-14 */
    @Configuration
    public class ExtBeanFactoryPostProcessor implements BeanFactoryPostProcessor { 
    
    	@Override
    	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { 
    		//spring的bean创建之前，修改bean的定义属性
    		System.out.println("【BeanFactoryPostProcessor接口】调用BeanFactoryPostProcessor接口的postProcessBeanFactory方法");
    		BeanDefinition beanDefinition = beanFactory.getBeanDefinition("personBean");
    		beanDefinition.getPropertyValues().addPropertyValue("age", "22");
    	}
    }

### （2）BeanDefinitionRegistryPostProcessor ###

BeanDefinition注册的后置处理器，可以实现自定义bean的注入

在对象工厂BeanFactory创建完毕，正常的BeanDefinition都已经加载完毕，而且尚未初始化时调用，用来修改BeanDefinitionRegistry

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.context.annotation.Configuration;
    
    /** * @author Tellsea * @date 2020-8-16 */
    @Configuration
    public class ExtBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor { 
    
    	@Override
    	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { 
    		//拿到BeanDefinitionRegistry对象，可以实现自定义bean注入的相关操作
    	}
    
    	@Override
    	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { 
    		//spring的bean创建之前，修改bean的定义属性
    	}
    }

# 4、BeanPostProcessor接口分析 #

### （1）BeanPostProcessor ###

BeanPostProcessor是对象初始化前后的回调

在[【spring bean的生命周期】][Spring Bean]的流程图中，我们分析了BeanPostProcessor的执行时间和所在位置，相关的执行流程不清楚的可以先去学完初级生命周期分析再继续学习

import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    import org.springframework.context.annotation.Configuration;
    
    /** * @author Tellsea * @date 2020-8-15 */
    @Configuration
    public class ExtBeanPostProcessor implements BeanPostProcessor { 
    
    	@Override
    	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
    		//该方法在bean实例化完毕（且已经注入完毕），在afterPropertiesSet或自定义init方法执行之前
    		System.out.println("BeanPostProcessor postProcessBeforeInitialization ...");
    		return null;
    	}
    
    	@Override
    	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
    		//在afterPropertiesSet或自定义init方法执行之后
    		System.out.println("BeanPostProcessor postProcessAfterInitialization ...");
    		return null;
    	}
    }

### （2）InstantiationAwareBeanPostProcessor ###

对象实例化前后以及实例化后设置propertyValues的回调

import org.springframework.beans.BeansException;
    import org.springframework.beans.PropertyValues;
    import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
    import org.springframework.context.annotation.Configuration;
    
    /** * @author Tellsea * @date 2020-8-16 */
    @Configuration
    public class ExtInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor { 
    
    	@Override
    	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException { 
    		//这个方法用来在对象实例化前直接返回一个对象（如代理对象）来代替通过内置的实例化流程创建对象
    		System.out.println("InstantiationAwareBeanPostProcessor postProcessBeforeInstantiation ...");
    		return null;
    	}
    
    	@Override
    	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException { 
    		//在对象实例化完毕执行populateBean之前 如果返回false则spring不再对对应的bean实例进行自动依赖注入
    		System.out.println("InstantiationAwareBeanPostProcessor postProcessAfterInstantiation ...");
    		return false;
    	}
    
    	@Override
    	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException { 
    		//这里是在spring处理完默认的成员属性，应用到指定的bean之前进行回调，可以用来检查和修改属性，最终返回的PropertyValues会应用到bean中
    		//@Autowired、@Resource等就是根据这个回调来实现最终注入依赖的属性的
    		System.out.println("InstantiationAwareBeanPostProcessor postProcessProperties ...");
    		return null;
    	}
    }

### （3）SmartInstantiationAwareBeanPostProcessor ###

主要是spring框架内部来使用

import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor;
    import org.springframework.context.annotation.Configuration;
    
    import java.lang.reflect.Constructor;
    
    /** * @author Tellsea * @date 2020-8-16 */
    @Configuration
    public class ExtSmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor { 
    
    	@Override
    	public Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException { 
    		//用来返回目标对象的类型（比如代理对象通过raw class获取proxy type 用于类型匹配）
    		System.out.println("SmartInstantiationAwareBeanPostProcessor predictBeanType ...");
    		return null;
    	}
    
    	@Override
    	public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException { 
    		//这里提供一个拓展点用来解析获取用来实例化的构造器（比如未通过bean定义构造器以及参数的情况下，会根据这个回调来确定构造器）
    		System.out.println("SmartInstantiationAwareBeanPostProcessor determineCandidateConstructors ...");
    		// return new Constructor[0];
    		return null;
    	}
    
    	@Override
    	public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException { 
    		//获取要提前暴露的bean的引用，用来支持单例对象的循环引用（一般是bean自身，如果是代理对象则需要取用代理引用）
    		System.out.println("SmartInstantiationAwareBeanPostProcessor getEarlyBeanReference ...");
    		return null;
    	}
    }

### （4）InstantiationAwareBeanPostProcessorAdapter（适配器） ###

spring源码中提供的InstantiationAwareBeanPostProcessor的适配器，相关继承关系如下

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NzYyMjM3_size_16_color_FFFFFF_t_70_pic_center 4]  
测试类中分别实现了以上几个类的方法

BeanPostProcessor
    	postProcessBeforeInstantiation()
    	postProcessAfterInstantiation()
    InstantiationAwareBeanPostProcessor
    	postProcessBeforeInstantiation()
    	postProcessAfterInstantiation()
    	postProcessProperties()
    SmartInstantiationAwareBeanPostProcessor
    	predictBeanType()
    	determineCandidateConstructors()
    	getEarlyBeanReference()
    InstantiationAwareBeanPostProcessorAdapter（适配器）

import org.springframework.beans.BeansException;
    import org.springframework.beans.PropertyValues;
    import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
    import org.springframework.context.annotation.Configuration;
    
    import java.lang.reflect.Constructor;
    
    /** * @author Tellsea * @date 2020-8-16 */
    @Configuration
    public class ExtInstantiationAwareBeanPostProcessorAdapter extends InstantiationAwareBeanPostProcessorAdapter { 
    
    	/* BeanPostProcessor接口方法 */
    	@Override
    	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
    		return super.postProcessBeforeInitialization(bean, beanName);
    	}
    
    	@Override
    	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
    		return super.postProcessAfterInitialization(bean, beanName);
    	}
    
    
    	/* InstantiationAwareBeanPostProcessor接口方法 */
    	@Override
    	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException { 
    		return super.postProcessBeforeInstantiation(beanClass, beanName);
    	}
    
    	@Override
    	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException { 
    		return super.postProcessAfterInstantiation(bean, beanName);
    	}
    
    	@Override
    	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException { 
    		return super.postProcessProperties(pvs, bean, beanName);
    	}
    
    
    	/* SmartInstantiationAwareBeanPostProcessor接口方法 */
    	@Override
    	public Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException { 
    		return super.predictBeanType(beanClass, beanName);
    	}
    
    	@Override
    	public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException { 
    		return super.determineCandidateConstructors(beanClass, beanName);
    	}
    
    	@Override
    	public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException { 
    		return super.getEarlyBeanReference(bean, beanName);
    	}
    }

### （5）MergedBeanDefinitionPostProcessor ###

用来将merged BeanDefinition暴露出来的回调

import org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor;
    import org.springframework.beans.factory.support.RootBeanDefinition;
    import org.springframework.context.annotation.Configuration;
    
    /** * @author Tellsea * @date 2020-8-16 */
    @Configuration
    public class ExtMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor { 
    
    	@Override
    	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) { 
    		//在bean实例化完毕后调用 可以用来修改merged BeanDefinition的一些properties 或者用来给后续回调中缓存一些meta信息使用
    		//这个算是将merged BeanDefinition暴露出来的一个回调
    	}
    
    	@Override
    	public void resetBeanDefinition(String beanName) { 
    		//通知已重新设置指定名称的Bean定义，这个是一个回调接口
    	}
    }

### （6）DestructionAwareBeanPostProcessor ###

处理对象销毁的前置回调

import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor;
    import org.springframework.context.annotation.Configuration;
    
    /** * @author Tellsea * @date 2020-8-16 */
    @Configuration
    public class ExtDestructionAwareBeanPostProcessor implements DestructionAwareBeanPostProcessor { 
    
    	@Override
    	public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException { 
    		//这里实现销毁对象的逻辑
    	}
    
    	@Override
    	public boolean requiresDestruction(Object bean) { 
    		//判断是否需要处理这个对象的销毁
    		return false;
    	}
    }

# 5、Aware接口类分析 #

### （1）Aware ###

Aware接口是一个超级接口，也就是顶级父类接口，相关源码就一行，定义了一个Aware接口，Aware接口的功能是通过它的实现类来进行操作的

package org.springframework.beans.factory;
    
    /** * A marker superinterface indicating that a bean is eligible to be notified by the * Spring container of a particular framework object through a callback-style method. * The actual method signature is determined by individual subinterfaces but should * typically consist of just one void-returning method that accepts a single argument. * * <p>Note that merely implementing {@link Aware} provides no default functionality. * Rather, processing must be done explicitly, for example in a * {@link org.springframework.beans.factory.config.BeanPostProcessor}. * Refer to {@link org.springframework.context.support.ApplicationContextAwareProcessor} * for an example of processing specific {@code *Aware} interface callbacks. * * @author Chris Beams * @author Juergen Hoeller * @since 3.1 */
    public interface Aware { 
    
    }

### （2）BeanNameAware ###

让 Bean 获取自己在 BeanFactory 配置中的 Name

import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.stereotype.Component;
    
    /** * @author Tellsea * @date 2020-8-16 */
    @Component
    public class ExtBeanNameAware implements BeanNameAware { 
    
    	@Override
    	public void setBeanName(String name) { 
    		System.out.println("BeanNameAware setBeanName：" + name);
    	}
    }

### （3）BeanFactoryAware ###

让 Bean 获取配置它们的 BeanFactory 的引用

import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.beans.factory.BeanFactoryAware;
    import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.stereotype.Component;
    
    /** * @author Tellsea * @date 2020-8-16 */
    @Component
    public class ExtBeanFactoryAware implements BeanFactoryAware { 
    
    	@Override
    	public void setBeanFactory(BeanFactory beanFactory) throws BeansException { 
    		System.out.println("BeanFactoryAware setBeanFactory：" + beanFactory);
    	}
    }

### （4）BeanClassLoaderAware ###

让 bean 知道 BeanClassLoader 的回调，即当前 beanFactory 加载 bean类使用的类加载器

import org.springframework.beans.factory.BeanClassLoaderAware;
    import org.springframework.stereotype.Component;
    
    /** * @author Tellsea * @date 2020-8-17 */
    @Component
    public class ExtBeanClassLoaderAware implements BeanClassLoaderAware { 
    	
    	@Override
    	public void setBeanClassLoader(ClassLoader classLoader) { 
    		System.out.println("BeanClassLoaderAware setBeanClassLoader：" + classLoader);
    	}
    }

### （5）ApplicationContextAware ###

让 Bean 获取 ApplicationContext 上下文对象

import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    /** * @author Tellsea * @date 2020-8-17 */
    @Component
    public class ExtApplicationContextAware implements ApplicationContextAware { 
    
    	// 当前上下文
    	private ApplicationContext applicationContext;
    
    	@Override
    	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { 
    		this.applicationContext = applicationContext;
    	}
    }

### （6）EmbeddedValueResolverAware ###

让 Bean 获取配置文件内容（解析配置文件，@Value 功能类似）

import org.springframework.context.EmbeddedValueResolverAware;
    import org.springframework.stereotype.Component;
    import org.springframework.util.StringValueResolver;
    
    /** * @author Tellsea * @date 2020-8-17 */
    @Component
    public class ExtEmbeddedValueResolverAware implements EmbeddedValueResolverAware { 
    	
    	@Override
    	public void setEmbeddedValueResolver(StringValueResolver resolver) { 
    		System.out.println("ExtEmbeddedValueResolverAware setEmbeddedValueResolver：" + resolver);	
    	}
    }

### （7）EnvironmentAware ###

让 Bean 获得系统环境相关信息，配制文件信息

import org.springframework.context.EnvironmentAware;
    import org.springframework.core.env.Environment;
    import org.springframework.stereotype.Component;
    
    /** * @author Tellsea * @date 2020-8-17 */
    @Component
    public class ExtEnvironmentAware implements EnvironmentAware { 
    
    	@Override
    	public void setEnvironment(Environment environment) { 
    		System.out.println("EnvironmentAware setEnvironment：" + environment);
    	}
    }

### （8）MessageSourceAware ###

对 MessageSource 的一个包装，处理国际化

import org.springframework.context.MessageSource;
    import org.springframework.context.MessageSourceAware;
    import org.springframework.context.support.MessageSourceAccessor;
    import org.springframework.stereotype.Component;
    
    /** * @author Tellsea * @date 2020-8-17 */
    @Component
    public class ExtMessageSourceAware implements MessageSourceAware { 
    
    	protected MessageSourceAccessor messageSourceAccessor;
    
    	@Override
    	public void setMessageSource(MessageSource messageSource) { 
    		this.messageSourceAccessor = new MessageSourceAccessor(messageSource);
    	}
    }

# 5、更多细节学习 #

*  [Tellsea全系列文章目录][Tellsea]

# 微信公众号 #

![每天Get一个小技巧][Get]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NzYyMjM3_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/a4259a07bd614d6887ffff2a3c0f7ce6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NzYyMjM3_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221124/c55192b0dfa84ba6a48d8b3fc9974753.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NzYyMjM3_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221124/c7f0f156004643258af1f3bfd09573c3.png
[Spring Bean]: https://blog.csdn.net/qq_38762237/article/details/107983186
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NzYyMjM3_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221124/30db74df77eb4fb9b9447e83fa9de1c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NzYyMjM3_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221124/105f2f0386cc418e9e2d4aca064475a7.png
[Tellsea]: https://blog.csdn.net/qq_38762237/article/details/107228946
[Get]: /images/20221124/6119b773b0644114bcab4acc81f64cc5.png