- 当前位置：首页 >人工智能 >Spring 冷知识：一个提前 AOP 的机会
Spring 冷知识：一个提前 AOP 的机会
发布时间：2025-11-05 01:24:31 来源：云智核 作者：IT科技类资讯
来源：江南一点雨
今天再来聊一个 Spring 中的冷知冷门知识：Bean 的处理不走正常流程，而是提前提前进行 AOP。
本文算是冷知前面文章（Spring Bean 名称暗藏玄机，这样取名就不会被代理）内容的提前一个补充，如果还没阅读前文，冷知建议先阅读，提前这样有利于更好的冷知理解本文。
1. Bean 创建流程
前面文章中，提前松哥和大家梳理了，冷知在 Bean 创建的提前过程中，会先给 BeanPostProcessor 一个返回代理对象的冷知机会：
@Overrideprotected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException{
//省略。。提前。冷知 try{
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.Object bean = resolveBeforeInstantiation(beanName,提前 mbdToUse);
if (bean != null) {
returnbean;
}
}
catch(Throwable ex) {
throw newBeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try{
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if(logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean " + beanName + "");
}
returnbeanInstance;
}
//省略。。冷知。}
小伙伴们看，这里的 resolveBeforeInstantiation 方法就是给 BeanPostProcessor 一个返回代理对象的机会，在这个方法中，最终就会触发到 InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation 方法，而在 postProcessBeforeInstantiation 方法中，会先判断当前 bean 是否是高防服务器 AOP 相关类等：
@Overridepublic Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName){
Object cacheKey = getCacheKey(beanClass, beanName);
if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
if(isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
if(StringUtils.hasLength(beanName)) {
this.targetSourcedBeans.add(beanName);
}
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
returnproxy;
}
return null;
}
前面 if 分支中的内容，松哥在前面的文章中已经和大家分析过了，这里就不再赘述。
这里主要来说说 getCustomTargetSource 中的逻辑。
先来说什么情况下会走到 getCustomTargetSource 方法：当前 Bean 不是代理对象，也不是 AOP 相关的类，就是一个普普通通的常规类，那么就会走到 getCustomTargetSource 方法这里来，这里失去查找到一个 TargetSource 对象，然后根据该对象创建当前 bean 的代理对象并返回，如果返回了代理对象，那么后续的 bean 创建流程就不执行了。
我们来看下这个方法的源码：
@Nullableprotected TargetSource getCustomTargetSource(Class<?> beanClass, String beanName){
// We cant create fancy target sources for directly registered singletons. if (this.customTargetSourceCreators != null&&
this.beanFactory != null && this.beanFactory.containsBean(beanName)) {
for (TargetSourceCreator tsc : this.customTargetSourceCreators) {
TargetSource ts = tsc.getTargetSource(beanClass, beanName);
if (ts != null) {
returnts;
}
}
}
// No custom TargetSource found. return null;
}
可以看到，这里就是当前类 AbstractAutoProxyCreator 中有一个 customTargetSourceCreators 变量，现在就是遍历该变量，通过这个集合中保存的 TargetSourceCreator 来创建 TargetSource 对象。
TargetSourceCreator 是一个接口，这个接口只有一个抽象类 AbstractBeanFactoryBasedTargetSourceCreator，b2b信息网我们来看下 AbstractBeanFactoryBasedTargetSourceCreator 中的 getTargetSource 方法是怎么执行的：
@Override@Nullablepublic final TargetSource getTargetSource(Class<?> beanClass, String beanName){
AbstractBeanFactoryBasedTargetSource targetSource =
createBeanFactoryBasedTargetSource(beanClass, beanName);
if (targetSource == null) {
return null;
}
DefaultListableBeanFactory internalBeanFactory = getInternalBeanFactoryForBean(beanName);
// We need to override just this bean definition, as it may reference other beans // and were happy to take the parents definition for those. // Always use prototype scope if demanded.BeanDefinition bd = getConfigurableBeanFactory().getMergedBeanDefinition(beanName);
GenericBeanDefinition bdCopy = newGenericBeanDefinition(bd);
if(isPrototypeBased()) {
bdCopy.setScope(BeanDefinition.SCOPE_PROTOTYPE);
}
internalBeanFactory.registerBeanDefinition(beanName, bdCopy);
// Complete configuring the PrototypeTargetSource.targetSource.setTargetBeanName(beanName);
targetSource.setBeanFactory(internalBeanFactory);
returntargetSource;
}
首先，TargetSource 对象是通过 createBeanFactoryBasedTargetSource 方法来创建的，这个方法是一个抽象方法，将来在子类中被实现。
接下来会调用 getInternalBeanFactoryForBean 方法创建一个新的内部容器 internalBeanFactory，本质上这个 internalBeanFactory 其实是一个子容器，现有的容器将作为这个子容器的父容器。
接下来就是获取到当前 beanName 所对应的 BeanDefinition，然后进行属性配置，并注册到内部容器中，最后返回 targetSource 对象。
我们来看下这里的 getInternalBeanFactoryForBean 方法：
protected DefaultListableBeanFactory getInternalBeanFactoryForBean(String beanName){
synchronized (this.internalBeanFactories) {
return this.internalBeanFactories.computeIfAbsent(beanName,
name -> buildInternalBeanFactory(getConfigurableBeanFactory()));
}
}
protected DefaultListableBeanFactory buildInternalBeanFactory(ConfigurableBeanFactory containingFactory){
// Set parent so that references (up container hierarchies) are correctly resolved. DefaultListableBeanFactory internalBeanFactory = newDefaultListableBeanFactory(containingFactory);
// Required so that all BeanPostProcessors, Scopes, etc become available.internalBeanFactory.copyConfigurationFrom(containingFactory);
// Filter out BeanPostProcessors that are part of the AOP infrastructure, // since those are only meant to apply to beans defined in the original factory.internalBeanFactory.getBeanPostProcessors().removeIf(beanPostProcessor ->
beanPostProcessor instanceofAopInfrastructureBean);
returninternalBeanFactory;
}
这个其实就是正常的容器创建，倒也没啥好说的，但是有几个需要注意的点：
在调用 buildInternalBeanFactory 方法构建容器的时候，云服务器会先调用 getConfigurableBeanFactory 方法获取到当前容器作为父容器，如果当前容器不存在，那么就会抛出异常。这就意味着，当我们自己提供 TargetSourceCreator 实例的时候，一定要指定一个容器。在创建了内部容器之后，会从内部容器中移除所有 AopInfrastructureBean 类型的 BeanPostProcessor，也就是内部容器将来创建出来的 bean，不再走 AopInfrastructureBean 类型后置处理器，因为这种类型的后置处理器主要是用来处理 AOP 的，现在，AOP 代理当场就生成了，就不再需要这些后置处理器了。好了，这就是大致的 AOP 提前生成原理，接下来松哥写一个案例我们一起来看下。
2. 实践
首先，我们先来自定义一个 TargetSource：
public class UserServiceTargetSource extends AbstractBeanFactoryBasedTargetSource{
@Override public Object getTarget() throws Exception{
returngetBeanFactory().getBean(getTargetBeanName());
}
@Override public boolean isStatic(){
return true;
}
}
关于 TargetSource 本身，松哥在之前的 Spring 源码视频中已经和大家介绍过很多了，这里我就不再啰嗦了。
接下来自定义 TargetSourceCreator：
public class CustomTargetSourceCreator extends AbstractBeanFactoryBasedTargetSourceCreator{
@Override protected AbstractBeanFactoryBasedTargetSource createBeanFactoryBasedTargetSource(Class<?> beanClass, String beanName){
if (getBeanFactory() instanceofConfigurableListableBeanFactory) {
if (beanClass.isAssignableFrom(UserService.class)){
return newUserServiceTargetSource();
}
}
return null;
}
}
如果要创建的 bean 是 UserService 的话，那么就给返回一个 UserServiceTargetSource 对象。
最后，也是最关键的一步，根据前面的分析，TargetSourceCreator 是存在于 AnnotationAwareAspectJAutoProxyCreator 这样一个 InstantiationAwareBeanPostProcessor 类型的后置处理器中的，因此，我们要想办法把自定义的 TargetSourceCreator 设置给 AnnotationAwareAspectJAutoProxyCreator，如下：
@Componentpublic class SetCustomTargetSourceCreator implements BeanPostProcessor, PriorityOrdered, BeanFactoryAware{
privateBeanFactory beanFactory;
@Override public int getOrder(){
returnInteger.MIN_VALUE;
}
@Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException{
if(bean instanceofAnnotationAwareAspectJAutoProxyCreator) {
AnnotationAwareAspectJAutoProxyCreator annotationAwareAspectJAutoProxyCreator = (AnnotationAwareAspectJAutoProxyCreator)bean;
CustomTargetSourceCreator customTargetSourceCreator = newCustomTargetSourceCreator();
customTargetSourceCreator.setBeanFactory(beanFactory);
annotationAwareAspectJAutoProxyCreator.setCustomTargetSourceCreators(customTargetSourceCreator);
}
returnbean;
}
@Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException{
this.beanFactory = beanFactory;
}
}
AnnotationAwareAspectJAutoProxyCreator 本身就是一个 BeanPostProcessor，我们现在要做的就是修改这个 BeanPostProcessor，BeanPostProcessor 是在 Spring 容器启动时候的 refresh 方法中去初始化的，整个的初始化过程松哥在之前的BeanPostProcessor 是在何时介入 Bean 创建的？一文中已经详细介绍过了。
BeanPostProcessor 初始化的时候，先初始化实现了 PriorityOrdered 接口的，再初始化实现了 Ordered 接口的，最后再去初始化那些没有实现任何排序接口的 BeanPostProcessor。
而我们这里 SetCustomTargetSourceCreator 一定要赶在 AnnotationAwareAspectJAutoProxyCreator 之前进行初始化，这样，当 AnnotationAwareAspectJAutoProxyCreator 进行初始化的时候，就会用到 SetCustomTargetSourceCreator 这样一个后置处理器，进而在该处理器中修改 AnnotationAwareAspectJAutoProxyCreator 的属性。
AnnotationAwareAspectJAutoProxyCreator 类间接实现了 Ordered 接口，默认优先级是最低，但是在 Spring 容器启动时，在处理 BeanFactoryPostProcessor 时（具体是 ConfigurationClassPostProcessor），将其优先级设置为最高。
所以，我们如果想要让自定义的 SetCustomTargetSourceCreator 抢在 AnnotationAwareAspectJAutoProxyCreator 之前执行，那么就只能让 SetCustomTargetSourceCreator 去实现 PriorityOrdered 接口了，实现 PriorityOrdered 接口之后，重写 getOrder 方法，这个方法返回值是什么无所谓，反正都会在实现了 Ordered 接口的 BeanPostProcessor 之前执行。
最后，我们再在启动类上开启自动代理即可：
@Configuration@ComponentScan@EnableAspectJAutoProxypublic class JavaConfig{
}
大功告成。
这样，当 Spring 容器创建一个 Bean 的时候，就会提前被 BeanPostProcessor 拦截，然后给出一个 TargetSource，进而据此创建代理对象，这样就不需要后续常规的 Bean 创建流程了。好啦，感兴趣的小伙伴可以自己去试一试哦～
- 手工卡通电脑折纸教程（通过简单的折纸技巧，制作属于你自己的电脑卡通形象！）
- CVE-2025-9288：流行 JavaScript 库存在严重漏洞，威胁全球 Web 安全
- 设计本地缓存、Redis与数据库的三层架构：一致性协议与过期策略实践
- 分布式锁的使用场景和常见实现
- 电脑循环风扇机箱安装教程（轻松学习如何正确安装电脑循环风扇机箱）
- 我们一起聊聊持续优化运维告警体系
- Sentry日志监控系统基本介绍及部署使用
- F5亚太区首席技术官Mohan Veloo：以ADSP平台重构AI时代的应用交付与安全边界，加速释放AI潜能
- 华硕U盘安装教程（通过华硕U盘安装系统，解决电脑系统问题的利器）
- 管理员修改咖啡价格后，如何保证 Redis 与数据库同步？
随便看看
- Copyright © 2025 Powered by Spring 冷知识：一个提前 AOP 的机会,云智核 滇ICP备2023006006号-28sitemap