本文将详细介绍创建代理对象的三个核心步骤。关于
AOP
的基本调试,可以参考前文介绍的调试代码(任何涉及AOP
的代码均可,如前置通知),这里不再详细说明。
本节源码基于 spring-aop-5.3.16
。
在Spring AOP
中,这一步骤主要通过检查目标bean
是否实现了特定接口或已是代理对象来完成。关键的方法是在AbstractAutoProxyCreator
类的postProcessBeforeInstantiation
中实现,该方法是 Spring AOP
的核心,属于 Spring Bean
生命周期的一部分,特别是在后置处理器(BeanPostProcessor
)机制中起重要作用。
主要功能:
Bean
的创建:在实际的 Bean
实例化之前拦截创建过程,这使得开发者可以在对象实际创建之前注入特定的行为或逻辑。Bean
的类型或注解)来确定是否需要对该 Bean
应用代理或其他增强,特定条件比如(切点表达式)Bean
,以便在运行时应用如安全、事务、日志等横切关注点。作用流程:
1. 获取缓存键:首先通过 Bean
的类和名称构造一个缓存键,用于后续的快速查找和决策。2. 初步检查:检查缓存是否已经有该 Bean
的信息,检查Bean
是否为基础设施类或是否标记为不应代理。如果缓存中未找到对应键且Bean
需要代理,将进入代理创建步骤。3. 决定是否创建代理:如果 Bean
不在上述类别中,进一步检查是否存在自定义的 TargetSource
(一个控制如何获取或创建被代理对象的组件)。如果存在,表示这个 Bean
需要被增强或代理。4. 代理创建:如果需要,创建一个代理实例,这个代理会封装原始 Bean
,加入额外的行为如拦截方法调用。5. 结果返回:返回创建的代理实例或者在不需要代理的情况下返回 null
。
来看看对应的源码:
源码提出来分析:
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
// 获取beanClass和beanName组合的缓存键
Object cacheKey = getCacheKey(beanClass, beanName);
// 检查beanName是否有效,并且当前bean是否已经有一个自定义的TargetSource
if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
// 如果当前bean已经被处理过,直接返回null,不再处理
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
// 判断当前类是否是基础设施类或者是否应该跳过代理
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
// 标记为不需要代理,并返回null
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
// 获取自定义的TargetSource,如果存在,则创建代理
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
// 如果beanName有效,将其加入到管理自定义TargetSource的集合中
if (StringUtils.hasLength(beanName)) {
this.targetSourcedBeans.add(beanName);
}
// 获取适用于当前bean的advice和advisor
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
// 创建代理对象
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
// 缓存代理对象的类型
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
return null;
}
源码分析说明:
beanClass
和 beanName
组合生成缓存键。beanName
有效且 bean
未被处理过,若已处理则返回 null
。bean
是否为基础设施类或应跳过代理,若是则返回 null
。TargetSource
,则创建代理对象并缓存其类型。这里为什么要获取自定义的 TargetSource?
在Spring AOP
中,创建代理对象时,TargetSource
起着关键作用。它主要决定了如何获取或创建将被代理的目标对象。默认情况下,Spring
使用简单的目标源,即直接引用具体的 Bean
实例。但在某些情况下,开发者可能需要通过自定义TargetSource
来改变目标对象的获取逻辑,以适应特定的增强需求。
在AbstractAutoProxyCreator
类的postProcessBeforeInstantiation
方法中,我们可以决定是否使用自定义的TargetSource
。如果存在,这意味着Bean
需要特殊的处理或增强。自定义的TargetSource
还可以实现很多复杂的逻辑,比如:
池化目标对象
:为了提高性能,可以使用对象池来管理目标对象的实例。延迟初始化
:只有在真正需要时才创建目标对象,可以减少资源使用和启动时间。远程对象访问
:目标对象可能在远程服务器上,需要通过网络调用。多租户支持
:基于当前用户或会话信息返回不同的目标对象实例。用时序图表示如下:
总体流程 这个时序图描述了Spring AOP
在创建代理对象时的核心过程。主要涉及的组件包括:调用者、postProcessBeforeInstantiation
方法、缓存与条件检查、自定义TargetSource
管理以及代理创建与返回。
步骤解析1. 调用开始:
postProcessBeforeInstantiation
方法,开始代理对象的创建过程。bean
实例化之前判断并创建其代理。2. 获取缓存键和初步条件检查:
beanClass
和beanName
获取一个cacheKey
。beanName
是否有效(非空且长度大于0
)和当前bean
是否已经有自定义的TargetSource
。bean
已经存在于advisedBeans
缓存中,或者属于基础设施类(如配置类等),或已指定为跳过代理,则不会进行进一步处理。3. 尝试获取自定义TargetSource
:
bean
的自定义TargetSource
。bean
的增强配置,如果有,则可以继续创建代理。4. 代理对象的创建:
TargetSource
,则使用相关的advisors
(增强器)和这个TargetSource
来创建一个代理对象。bean
的调用,并应用定义的增强逻辑(如安全检查、事务管理等)。5. 返回结果:
TargetSource
或者不需要创建代理,方法将返回null
。条件判断
bean
需要代理:这个分支处理创建代理所需的条件检查和配置获取。TargetSource
存在:只有当自定义的TargetSource
存在时,才会尝试创建代理对象。TargetSource
不存在或缓存键存在且bean
不需要代理:这些情况将导致方法返回null
,不进行代理的创建。 增强器(或称为 "advisors
")定义何时以及如何增强目标对象。 源码中的AbstractAdvisorAutoProxyCreator
类继承自AbstractAutoProxyCreator
,添加处理Advisor的功能。特别是findEligibleAdvisors
方法,它用于找出适用于特定bean
的所有advisors
。
来看看源码
提取关键代码分析
// 重写getAdvicesAndAdvisorsForBean方法,用于获取适用于特定bean的advisors和advices
@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
// 调用findEligibleAdvisors方法获取所有适用的advisors
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
// 如果没有找到任何适用的advisor,则返回DO_NOT_PROXY(不进行代理)
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
// 将找到的advisors转换为数组并返回
return advisors.toArray();
}
/**
* 查找所有适合自动代理的advisors。
* @param beanClass 需要查找advisors的bean的类
* @param beanName 当前被代理的bean的名称
* @return 如果没有找到适用的pointcuts或interceptors,返回空列表,而不是null
* @see #findCandidateAdvisors 查找候选的advisors
* @see #sortAdvisors 对advisors进行排序
* @see #extendAdvisors 扩展advisors
*/
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
// 查找所有候选的advisors
List<Advisor> candidateAdvisors = findCandidateAdvisors();
// 从候选advisors中找出可以应用于当前bean的advisors
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
// 可选操作:扩展advisors列表
extendAdvisors(eligibleAdvisors);
// 如果找到了适用的advisors,则对它们进行排序
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
// 返回最终确定的适用于当前bean的advisors列表
return eligibleAdvisors;
}
用时序图表示如下:
时序图详解
1. 客户端请求Bean实例:
AbstractAutoProxyCreator
发出请求以获取Bean
实例。这通常发生在Spring
的应用上下文中,当一个Bean
被请求时,Spring
会检查这个Bean
是否需要代理。2. 调用findEligibleAdvisors方法:
AbstractAutoProxyCreator
调用findEligibleAdvisors
方法,传入beanClass
和beanName
。这个方法负责找出所有可能适用于这个特定Bean
的Advisors
。3. 查找所有候选Advisors:
findEligibleAdvisors
进一步调用findCandidateAdvisors
,这个方法从Spring
的应用上下文中检索所有配置的Advisors
。4. 筛选适用于Bean的Advisors:
Advisors
列表会传给findAdvisorsThatCanApply
,这个方法根据当前Bean
的类型和名称筛选出适用的Advisors
。5. 对Advisors进行排序:
Advisors
会传给sortAdvisors
,以确保在代理中按正确的顺序应用它们。6. 返回适用的Advisors列表:
findEligibleAdvisors
将排序后的Advisors
列表返回给AbstractAutoProxyCreator
。7. 决策点 - 是否存在适用的Advisors:
Advisors
,将继续创建Bean
的代理;如果没有找到,直接返回原始的Bean
实例。8. 创建Bean的代理:
Advisors
创建Bean
的代理实例,并将Advisors
注入到代理中。9. 客户端调用Bean的方法:
Bean
的方法。如果Bean
被代理,Advisors
中定义的额外逻辑(例如,拦截、事务管理)会在调用实际Bean
方法之前或之后执行。10. 返回方法执行结果:
如果发现有合适的advisors
,Spring
将使用AOP
代理工厂来创建代理对象。这部分的处理通常涉及到多种代理的创建策略,如JDK
动态代理或CGLIB
代理。
查看AbstractAutoProxyCreator
中的createProxy
方法。这个方法负责根据给定的bean
、其对应的bean
名称、匹配到的advisors
等信息来创建代理对象。
源代码如下:
提出代码分析:
/**
* 创建给定bean的AOP代理。
* @param beanClass bean的类
* @param beanName bean的名称
* @param specificInterceptors 针对这个bean的一组拦截器(可能为空,但不为null)
* @param targetSource 为代理配置的目标源
* @return bean的AOP代理
* @see #buildAdvisors 构建advisor的方法
*/
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource) {
// 检查bean工厂是否为ConfigurableListableBeanFactory类型,如果是,则暴露bean的目标类
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
// 创建ProxyFactory对象,并从当前实例复制配置
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
// 判断是否应该使用代理目标类,而不是只使用接口代理
if (proxyFactory.isProxyTargetClass()) {
// 如果beanClass是一个JDK代理类,处理引入通知场景
if (Proxy.isProxyClass(beanClass)) {
// 允许引入,不能仅设置接口为代理的接口
for (Class<?> ifc : beanClass.getInterfaces()) {
proxyFactory.addInterface(ifc);
}
}
} else {
// 如果没有强制代理目标类标志,则进行默认检查
if (shouldProxyTargetClass(beanClass, beanName)) {
// 如果决定代理目标类,则设置相应标志
proxyFactory.setProxyTargetClass(true);
} else {
// 否则,评估并设置需要代理的接口
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
// 构建适用于此bean的advisors数组
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
// 将advisors添加到代理工厂
proxyFactory.addAdvisors(advisors);
// 设置代理的目标源
proxyFactory.setTargetSource(targetSource);
// 根据需要自定义代理工厂
customizeProxyFactory(proxyFactory);
// 设置代理是否冻结,即之后是否允许更改代理的配置
proxyFactory.setFrozen(this.freezeProxy);
// 如果advisors已经预过滤,设置代理为预过滤状态
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
// 获取代理的类加载器
ClassLoader classLoader = getProxyClassLoader();
if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
// 如果类加载器为SmartClassLoader且与bean的类加载器不同,使用原始类加载器
classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
}
// 获取并返回代理对象
return proxyFactory.getProxy(classLoader);
}
时序图如下:
时序图详解:
1. 客户端请求创建代理
Spring
容器请求创建一个代理对象。这通常是因为客户端需要一个被AOP
增强的Bean
,比如添加了事务管理、性能监控或安全控制等。Spring
应用启动时或者第一次请求Bean
时,Spring
容器会根据Bean
的定义和AOP
配置决定是否需要创建代理。2. Spring容器调用createProxy方法
Spring
容器调用createProxy
方法开始代理创建过程。createProxy
是实现代理逻辑的核心方法,它负责集成所有相关配置并生成代理对象。3. 检查BeanFactory类型并暴露目标类
createProxy
方法首先检查Bean
工厂的类型,如果是ConfigurableListableBeanFactory
,则调用AutoProxyUtils.exposeTargetClass
来暴露Bean
的目标类。Bean
的实际类信息,尤其是当代理需要基于类而非接口创建时。4. 创建ProxyFactory实例
createProxy
方法创建一个ProxyFactory
实例。ProxyFactory
是用于创建实际代理对象的工具,它支持对代理的各种配置,如代理的类型、拦截器链等。5. 判断并处理代理策略
JDK
动态代理或CGLIB
代理。JDK
代理类,将添加所有实现的接口到代理。JDK
代理类,将根据shouldProxyTargetClass
的结果决定是否代理目标类或仅代理特定接口。6. 构建Advisors并配置ProxyFactory
buildAdvisors
方法构建适用于此Bean
的advisors
数组,然后将这些advisors
添加到ProxyFactory
。Advisors
包含了增强的定义,这些增强定义了如何拦截方法调用及在调用前后执行特定的操作。7. 自定义ProxyFactory并创建代理对象
ProxyFactory
获取代理对象。Bean
,增加了指定的AOP
功能。8. 返回代理对象
createProxy
方法将代理对象返回给Spring
容器,容器再返回给客户端。Bean
是一个被代理增强过的对象,具备了额外的AOP
功能,如事务控制、安全检查等。欢迎一键三连~
有问题请留言,大家一起探讨学习
----------------------Talk is cheap, show me the code-----------------------
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。