Spring源码 - 核心接口BeanPostProcessor[通俗易懂]

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元售后保障童叟无欺

`Spring`源码 – 核心接口`BeanPostProcessor`

Spring版本：Spring 5.3.13-release

# 1、核心接口`BeanPostProcessor`

BeanPostProcessor接口我们一般称为后置处理器或者增强器。

BeanPostProcessor接口是Spring本着开闭原则(面对修改关闭面对扩展开放)设计的一个接口。

BeanPostProcessor接口允许开发者在Bean实例化前后对Bean做一些定制化处理，如修改BeanDefinition等。

BeanPostProcessor接口代码：

public interface BeanPostProcessor { 
   

	/** * Apply this {@code BeanPostProcessor} to the given new bean instance <i>before</i> any bean * initialization callbacks (like InitializingBean's {@code afterPropertiesSet} * or a custom init-method). The bean will already be populated with property values. * The returned bean instance may be a wrapper around the original. * <p>The default implementation returns the given {@code bean} as-is. * @param bean the new bean instance * @param beanName the name of the bean * @return the bean instance to use, either the original or a wrapped one; * if {@code null}, no subsequent BeanPostProcessors will be invoked * @throws org.springframework.beans.BeansException in case of errors * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet */
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
   
		return bean;
	}

	/** * Apply this {@code BeanPostProcessor} to the given new bean instance <i>after</i> any bean * initialization callbacks (like InitializingBean's {@code afterPropertiesSet} * or a custom init-method). The bean will already be populated with property values. * The returned bean instance may be a wrapper around the original. * <p>In case of a FactoryBean, this callback will be invoked for both the FactoryBean * instance and the objects created by the FactoryBean (as of Spring 2.0). The * post-processor can decide whether to apply to either the FactoryBean or created * objects or both through corresponding {@code bean instanceof FactoryBean} checks. * <p>This callback will also be invoked after a short-circuiting triggered by a * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method, * in contrast to all other {@code BeanPostProcessor} callbacks. * <p>The default implementation returns the given {@code bean} as-is. * @param bean the new bean instance * @param beanName the name of the bean * @return the bean instance to use, either the original or a wrapped one; * if {@code null}, no subsequent BeanPostProcessors will be invoked * @throws org.springframework.beans.BeansException in case of errors * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet * @see org.springframework.beans.factory.FactoryBean */
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
   
		return bean;
	}

}

BeanPostProcessor接口中定义了两个方法：

1、postProcessBeforeInitialization(Object bean, String beanName)：在Bean实例化、依赖注入完毕，在调用显示的初始化之前完成一些定制的初始化操作。
2、postProcessAfterInitialization(Object bean, String beanName)：在Bean实例化、依赖注入、初始化完毕时执行。

可以看出postProcessBeforeInitialization()方法是Spring在Bean进行初始化之前的回调，postProcessAfterInitialization()方法是Spring在Bean初始化完成之后的回调。

# 2、`BeanPostProcessor`的注册

BeanPostProcessor的注册是在Spring进行容器刷新中的AbstractApplicationContext#registerBeanPostProcessors()方法中完成的。而具体的逻辑实现Spring则是委派给PostProcessorRegistrationDelegate#registerBeanPostProcessors()方法进行具体的注册实现。

	public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { 

// WARNING: Although it may appear that the body of this method can be easily
// refactored to avoid the use of multiple loops and multiple lists, the use
// of multiple lists and multiple passes over the names of processors is
// intentional. We must ensure that we honor the contracts for PriorityOrdered
// and Ordered processors. Specifically, we must NOT cause processors to be
// instantiated (via getBean() invocations) or registered in the ApplicationContext
// in the wrong order.
//
// Before submitting a pull request (PR) to change this method, please review the
// list of all declined PRs involving changes to PostProcessorRegistrationDelegate
// to ensure that your proposal does not result in a breaking change:
// https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22
// 获取所有的 BeanPostProcessor 的 BeanName
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
// BeanPostProcessorChecker 是一个普通的信息打印
// 可能存在有些情况当 Spring 配置中的后置处理器还没有被注册就已经开始 Bean 的实例化了, 这个时候就会打印出 BeanPostProcessorChecker 中设定的信息
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 用于保存实现了 PriorityOrdered 排序接口的 BeanPostProcessor
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 用于保存 MergedBeanDefinitionPostProcessor 类型 BeanPostProcessor
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 用于保存实现了 Ordered 排序接口的 BeanPostProcessor 的 BeanName
List<String> orderedPostProcessorNames = new ArrayList<>();
// 用于保存没有实现任何排序接口的 BeanPostProcessor 的 BeanName
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 遍历所有的 BeanPostProcessor 的 BeanName, 按照不同筛选条件放入相应的容器中
for (String ppName : postProcessorNames) { 

// 如果实现了 PriorityOrdered 排序接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { 

// 根据 BeanName 获取 Bean 实例并放入 priorityOrderedPostProcessors 中
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
// 如果是 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor 继续放入 internalPostProcessors 中
if (pp instanceof MergedBeanDefinitionPostProcessor) { 

internalPostProcessors.add(pp);
}
}
// 如果实现了 Ordered 排序接口
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { 

// 将 BeanName 放入 orderedPostProcessorNames 中
orderedPostProcessorNames.add(ppName);
}
// 没有实现任何排序接口
else { 

// 将 BeanName 放入 nonOrderedPostProcessorNames 中
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 对实现了 PriorityOrdered 排序接口的 BeanPostProcessor 进行排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 根据排序结果依次注册 BeanPostProcessor 到 BeanFactory 中,
// 实际就是将排序后的 BeanPostProcessor 保存到 AbstractBeanFactory#beanPostProcessors 容器中
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 创建一个容器用于存放实现了 Ordered 排序接口的 BeanPostProcessor
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
// 遍历实现了 Ordered 排序接口的 BeanPostProcessor 的 BeanName
for (String ppName : orderedPostProcessorNames) { 

// 根据 BeanName 获取 Bean 实例并放入 orderedPostProcessors 中
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
// 如果是 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor 继续放入 internalPostProcessors 中
if (pp instanceof MergedBeanDefinitionPostProcessor) { 

internalPostProcessors.add(pp);
}
}
// 对实现了 Ordered 排序接口的 BeanPostProcessor 的 Bean 实例进行排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 根据排序结果依次注册 BeanPostProcessor 到 BeanFactory 中,
// 实际就是将排序后的 BeanPostProcessor 保存到 AbstractBeanFactory#beanPostProcessors 容器中
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
// 创建一个容器用于存放没有实现任何排序接口的 BeanPostProcessor
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
// 遍历没有实现任何排序接口的 BeanPostProcessor 的 BeanName
for (String ppName : nonOrderedPostProcessorNames) { 

// 根据 BeanName 获取 Bean 实例并放入 nonOrderedPostProcessors 中
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
// 如果是 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor 继续放入 internalPostProcessors 中
if (pp instanceof MergedBeanDefinitionPostProcessor) { 

internalPostProcessors.add(pp);
}
}
// 注册 BeanPostProcessor 到 BeanFactory 中
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
// 对 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor 进行排序
sortPostProcessors(internalPostProcessors, beanFactory);
// 注册 BeanPostProcessor 到 BeanFactory 中, 注册时会先执行移除已存在的 BeanPostProcessor 然后在进行添加
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
// 添加处理用户自定义 ApplicationListener 注册和销毁的 BeanPostProcessor
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

BeanPostProcessor的注册逻辑也是非常清晰：按照BeanPostProcessor实现的排序接口依次进行注册。

需要注意的是，这里仅仅是完成BeanPostProcessor的注册工作，此时BeanPostProcessor类型的Bean已经注册到Spring的IOC容器中，并且由AbstractBeanFactory中的beanPostProcessors持有一份已注册的缓存副本。

# 3、`BeanPostProcessor`的激活

BeanPostProcessor的激活是在Spring初始化Bean时完成。

AbstractAutowireCapableBeanFactory#initializeBean()代码：

	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { 

// 如果安全管理器不为空
if (System.getSecurityManager() != null) { 

// 以特权的方式执行回调 Bean 中的 Aware 接口方法
AccessController.doPrivileged((PrivilegedAction<Object>) () -> { 

invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else { 

// Aware 接口处理器, 调用 BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
// 如果 RootBeanDefinition 不为空 || RootBeanDefinition 不是 synthetic。一般指只有 AOP 相关的 PointCut 配置或者 Advice 配置才会将 synthetic 设置为 true
if (mbd == null || !mbd.isSynthetic()) { 

// 将 BeanPostProcessor 应用到给定的现有 Bean 实例, 调用它们的 PostProcessorsBeforeInitialization 初始化方法
// 返回的 Bean 实例可能是原始 Bean 包装器
// 执行 applyBeanPostProcessorsBeforeInitialization 方法后会将 ApplicationContext 注入进来
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try { 

// 调用初始化方法, 先调用 Bean 的 InitializeBean 接口方法, 后调用 Bean 的自定义初始化方法
// invokeInitMethods() 方法的作用是执行初始化方法, 这些初始化方法包括 :
// 1.在 XML 文件中的 <bean></bean> 标签中使用的 init-method 属性的 Bean 初始化方法;
// 2.在 @Bean 注解中使用 initMethod 属性指定的 Bean 初始化方法;
// 3.使用 @PostConstruct 注解标注的方法;
// 4.实现 InitializingBean 接口的方法等;
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) { 

// 捕捉调用初始化方法时抛出的异常, 重新抛出 Bean 创建异常 : 调用初始化方法失败
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
// 如果 RootBeanDefinition 不为空 || RootBeanDefinition 不是 synthetic
if (mbd == null || !mbd.isSynthetic()) { 

// 将 BeanPostProcessor 应用到给定的现有 Bean 实例, 调用它们的 postProcessAfterInitialization 方法
// 返回的 Bean 实例可能是原始 Bean 包装器
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
// 返回包装后的 Bean
return wrappedBean;
}

可以看到在Spring在Bean完全实例化之前调用了applyBeanPostProcessorsBeforeInitialization()方法，在Bean完全实例化之后调用了applyBeanPostProcessorsAfterInitialization()方法。

AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization()代码：

	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException { 

// 初始化返回结果为 existingBean
Object result = existingBean;
// 遍历, 该工厂创建的 Bean 的 BeanPostProcessors 列表
for (BeanPostProcessor processor : getBeanPostProcessors()) { 

// postProcessBeforeInitialization : 在任何 Bean 初始化回调之前(如初始化 Bean 的 afterPropertiesSet 或自定义的 init 方法)
// 将此 BeanPostProcessor 应用到给定的新 Bean 实例。Bean 已经填充了属性值。返回的 Bean 实例可能是原始 Bean 的包装器
// 默认实现按原样返回给定的 Bean
Object current = processor.postProcessBeforeInitialization(result, beanName);
// 如果 current 为空。即一旦 Bean 的 BeanPostProcessors 中的某一个增强处理器返回 null, 后续 BeanPostProcessor 对象的 postProcessBeforeInitialization 方法不在执行, 直接退出后续循环
if (current == null) { 

// 直接返回 result, 中断其后续的 BeanPostProcessor 处理器
return result;
}
// 让 result 引用 processor 返回的结果, 使其经过所有 BeanPostProcessor 对象的后置处理器的层层包装
result = current;
}
// 返回经过所有 BeanPostProcessor 对象的后置处理器的层层包装后的 result
return result;
}

Spring会获取在AbstractBeanFactory中持有的已经注册完成的BeanPostProcessor实例。获取到之后根据顺序依次激活。调用postProcessBeforeInitialization()对Bean进行包装并返回。如果其中某一个BeanPostProcessor返回的结果为null，则中断执行后续的BeanPostProcessor，直接返回当前结果。

AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization()代码：

	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException { 

Object result = existingBean;
// 获取创建 Bean 实例对象过程中所有的 BeanPostProcessors(Bean后置处理器)
for (BeanPostProcessor processor : getBeanPostProcessors()) { 

// 如果 Bean 被子类标记为代理, 则使用配置的拦截器创建一个代理
Object current = processor.postProcessAfterInitialization(result, beanName);
// 如果某一个 BeanPostProcessor 返回 null, 则中断后续所有 BeanPostProcessor 的激活, 直接放回当前结果
if (current == null) { 

return result;
}
// 让 result 引用 processor 返回的结果, 使其经过所有 BeanPostProcessor 对象的后置处理器的层层包装
result = current;
}
// 返回经过所有 BeanPostProcessor 对象的后置处理器的层层包装后的 result
return result;
}

逻辑与applyBeanPostProcessorsBeforeInitialization()方法类型。也是先获取所有的BeanPsotProcessor实例副本，然后依次执行激活。

GitHub源码地址：https://github.com/kapbc/kapcb-spring-source/tree/master/Spring-Framework-v5.3.13

备注：此文为笔者学习Spring源码的笔记，鉴于本人技术有限，文中难免出现一些错误，感谢大家批评指正。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/170022.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权正版激活】： 官方授权正版激活支持Jetbrains家族下所有IDE 使用个人JB账号...

Spring源码 – 核心接口BeanPostProcessor[通俗易懂]