【Spring源码分析】4、Spring Bean 生命周期扩展点 PostProcessor 和 Aware 分析
文章目录
- 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的使用区别
| PostProcessor名称 | 作用 |
|---|---|
| BeanFactoryPostProcessor | 关于对象工厂BeanFactory创建完毕的回调处理 |
| BeanPostProcessor | 关于通过对象工厂BeanFactory创建对象前后的回调处理 |
（1）BeanFactoryPostProcessor接口类
PostProcessor类型接口BeanFactoryPostProcessor
BeanFactoryPostProcessor
BeanDefinitionRegistryPostProcessor
（2）BeanPostProcessor接口类
PostProcessor类型接口BeanPostProcessor
我这里只是举例说明常用的类有哪些，实际上实现类是非常多的，其中相关常用接口的继承关系如下
BeanPostProcessor
InstantiationAwareBeanPostProcessor
SmartInstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessorAdapter（适配器）
MergedBeanDefinitionPostProcessor
DestructionAwareBeanPostProcessor
（3）Aware接口类
Aware常用类就只有一个根接口Aware，其他接口作为扩展继承Aware，下面是常用接口继承关系图
Aware
BeanNameAware
BeanFactoryAware
BeanClassLoaderAware
ApplicationContextAware
EmbeddedValueResolverAware
EnvironmentAware
MessageSourceAware
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进行遍历，并分为以上两类
- 调用实现PriorityOrdered的BeanDefinitionRegistryPostProcessors
- 调用实现Ordered的BeanDefinitionRegistryPostProcessors
- 调用所有其他BeanDefinitionRegistryPostProcessor，直到没有其他的出现
- 调用非BeanDefinitionRegistryPostProcessor类型的bean
调用到目前为止已处理的所有处理器的postProcessBeanFactory回调，源码继续向下分析，将实现PriorityOrdered的BeanFactoryPostProcessor分开，分为三类（priorityOrdered优先选择，ordered第二的，nonOrdered最后的）
- 调用实现PriorityOrdered的BeanFactoryPostProcessors
- 调用实现Ordered的BeanFactoryPostProcessors
- 调用所有其他BeanFactoryPostProcessors
到这里BeanFactoryPostProcessor接口类执行顺序已经分析完成了，细心的同学会发下，调用完所有方法后，观察方法的日志会发现，BeanFactoryPostProcessor的相关方法已经调用了
BeanDefinitionRegistryPostProcessor postProcessBeanDefinitionRegistry() ...
BeanFactoryPostProcessor postProcessBeanFactory() ...
对应【Spring Bean 生命周期】的初始化过程流程图
（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未排序的）
- 注册实现PriorityOrdered的BeanPostProcessor
- 注册实现Ordered的BeanPostProcessor
- 注册所有常规BeanPostProcessor
- 重新注册所有内部BeanPostProcessor（用于将内部bean检测为ApplicationListener的后处理器）
- 最后将其移动到处理器链的末尾（用于拾取代理等）
到这里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 出书画的第三个大阶段，初始化阶段调用的方法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的生命周期】的流程图中，我们分析了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的适配器，相关继承关系如下
测试类中分别实现了以上几个类的方法
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.
*
* 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全系列文章目录