一、前言
本文是笔者阅读Spring源码的记录文章，由于本人技术水平有限，在文章中难免出现错误，如有发现，感谢各位指正。在阅读过程中也创建了一些衍生文章，衍生文章的意义是因为自己在看源码的过程中，部分知识点并不了解或者对某些知识点产生了兴趣，所以为了更好的阅读源码，所以开设了衍生篇的文章来更好的对这些知识点进行进一步的学习。
全集目录：Spring源码分析：全集整理
本文系列：
Spring源码分析十一：@Aspect方式的AOP上篇 - @EnableAspectJAutoProxy
Spring源码分析十二：@Aspect方式的AOP中篇 - getAdvicesAndAdvisorsForBean
Spring源码分析十三：@Aspect方式的AOP下篇 - createProxy
本文衍生篇：
Spring 源码分析衍生篇九 ： AOP源码分析 - 基础篇
我们上篇已经分析到了 Spring将已经找到所有适用于当前bean 的Advisor 集合。下面就要创建代理对象了，而代理对象的创建是从 AbstractAutoProxyCreator#createProxy 开始。下面我们就来看看代理对象的创建过程。
1. ProxyFactory
ProxyFactory 的结构图如下：
在代理对象的创建过程中，实际上是委托给 ProxyFactory 来完成的。ProxyFactory 在创建过程中保存了筛选后的 Advisor 集合以及其他的一些属性。而在后面创建代理类的时候，将 ProxyFactory 作为参数传递给了 JdkDynamicAopProxy 和 ObjenesisCglibAopProxy。这个在后面的代码分析中会有详细说明。
二、创建代理类 - AbstractAutoProxyCreator#createProxy
AbstractAutoProxyCreator#createProxy 的代码如下：
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource) {
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
ProxyFactory proxyFactory = new ProxyFactory();
// 获取当前类的相关属性
proxyFactory.copyFrom(this);
// 判断当前bean 是使用 TargetClass 代理还是接口代理
if (!proxyFactory.isProxyTargetClass()) {
// 检查 proxyTargeClass设置以及preservetargetClass 属性
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
// 将拦截器 Interceptors 封装成增强器 Advisor
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
// 加入增强器
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
// 定制代理
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
// 在这里面就封装出了ProxyFactory，并交由其来完成剩下的代理工作。
return proxyFactory.getProxy(getProxyClassLoader());
}
代码中已经有详细的注释了，可以看到代理类的创建Spring委托给 ProxyFactory 去处理，而在此函数中主要是对 ProxyFactory 的初始化操作：
- 获取当前类的属性
- 添加代理接口
- 封装Advisor 并加入到ProxyFactory 中
- 设置要代理的类
- 通过customizeProxyFactory定制代理类 ，对ProxyFactory 进一步封装
- 进行获取代理操作
下面我们主要下面两个方法：
1. buildAdvisors(beanName, specificInterceptors);
需要注意的是：这里的参数 就是 Object[] specificInterceptors 就是 getAdvicesAndAdvisorsForBean 方法返回的 Advisor，通过对 getAdvicesAndAdvisorsForBean 方法的分析我们可以得知， specificInterceptors 应该全是 InstantiationModelAwarePointcutAdvisorImpl 类型。
protected Advisor[] buildAdvisors(@Nullable String beanName, @Nullable Object[] specificInterceptors) {
// Handle prototypes correctly...
// 解析注册的所有 Interceptor Name。即我们可以手动添加一些 拦截器，这里将手动添加的拦截器保存到commonInterceptors 中
Advisor[] commonInterceptors = resolveInterceptorNames();
List<Object> allInterceptors = new ArrayList<>();
if (specificInterceptors != null) {
// 加入拦截器
allInterceptors.addAll(Arrays.asList(specificInterceptors));
if (commonInterceptors.length > 0) {
if (this.applyCommonInterceptorsFirst) {
allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
}
else {
allInterceptors.addAll(Arrays.asList(commonInterceptors));
}
}
}
if (logger.isTraceEnabled()) {
int nrOfCommonInterceptors = commonInterceptors.length;
int nrOfSpecificInterceptors = (specificInterceptors != null ? specificInterceptors.length : 0);
logger.trace("Creating implicit proxy for bean '" + beanName + "' with " + nrOfCommonInterceptors +
" common interceptors and " + nrOfSpecificInterceptors + " specific interceptors");
}
Advisor[] advisors = new Advisor[allInterceptors.size()];
for (int i = 0; i < allInterceptors.size(); i++) {
// 拦截器进行转化为 Advisor
advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
}
return advisors;
}
...
// this.interceptorNames 是自己通过set设置的属性。在基础篇中Advice 有过类似的设置。我们这里是没有的
private Advisor[] resolveInterceptorNames() {
BeanFactory bf = this.beanFactory;
ConfigurableBeanFactory cbf = (bf instanceof ConfigurableBeanFactory ? (ConfigurableBeanFactory) bf : null);
List<Advisor> advisors = new ArrayList<>();
// 将 interceptorNames 获取到的拦截器保存起来，并返回。
for (String beanName : this.interceptorNames) {
if (cbf == null || !cbf.isCurrentlyInCreation(beanName)) {
Assert.state(bf != null, "BeanFactory required for resolving interceptor names");
Object next = bf.getBean(beanName);
advisors.add(this.advisorAdapterRegistry.wrap(next));
}
}
return advisors.toArray(new Advisor[0]);
}
我们下面来看一下 this.advisorAdapterRegistry.wrap(allInterceptors.get(i)); 的实现。
public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
// 如果 adviceObject 本身就是 Advisor则不需进一步操作
if (adviceObject instanceof Advisor) {
return (Advisor) adviceObject;
}
// 此封装方法只能处理Advisor 和 Advice两种类型，如果不是将不能封装
if (!(adviceObject instanceof Advice)) {
throw new UnknownAdviceTypeException(adviceObject);
}
Advice advice = (Advice) adviceObject;
if (advice instanceof MethodInterceptor) {
// So well-known it doesn't even need an adapter.
// 如果是MethodInterceptor 类型则使用 DefaultPointcutAdvisor 封装
return new DefaultPointcutAdvisor(advice);
}
// 如果存在 Advisor 的适配器则同样需要进行封装。
for (AdvisorAdapter adapter : this.adapters) {
// Check that it is supported.
if (adapter.supportsAdvice(advice)) {
return new DefaultPointcutAdvisor(advice);
}
}
throw new UnknownAdviceTypeException(advice);
}
DefaultAdvisorAdapterRegistry#wrap 方法也很简单，就是将 adviceObject 包装成 Advisor 。
2. proxyFactory.getProxy(getProxyClassLoader());
上述代码中 proxyFactory.getProxy(getProxyClassLoader()); 会继续调用到 DefaultAopProxyFactory#createAopProxy
因此我们来看 DefaultAopProxyFactory#createAopProxy
首先我们来看一下 proxyFactory.getProxy 方法。
public Object getProxy(@Nullable ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
显然意见我们需要将这个内容分为两步： createAopProxy() 和 getProxy(classLoader)
2.1 ProxyCreatorSupport#createAopProxy
ProxyCreatorSupport#createAopProxy 代码如下，这里我们可以看到，ProxyCreatorSupport#createAopProxy 会调用 DefaultAopProxyFactory#createAopProxy，并且将this作为参数传递了过去。而此时的 this，正是上面提到的创建的 ProxyFactory。
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
// 这里我们需要注意的是 ，这里 createAopProxy 传入的是 this。也就是说这里参数传递实际上是ProxyFactroy
return getAopProxyFactory().createAopProxy(this);
}
这里我们再来看 DefaultAopProxyFactory#createAopProxy 的实现
@Override
// 这里的参数 AdvisedSupport config 即是之前创建的ProxyFactory。这里又将其传递给了AopProxy
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
在这个方法中我们可以看到 Aop代理使用了 JDK动态代理和 Cglib动态代理两种动态代理模式，并根据某些参数来进行选择代理方式
从 createAopProxy 代码中我们可以看到几个参数：
optimize： 用来控制通过CGlib 创建的代理是否使用激进的优化策略，一般默认false，对JDK动态代理无效。proxyTargetClass：若为true，则目标类本身被代理，而不是代理目标类的接口，创建 cglib代理。hasNoUserSuppliedProxyInterfaces：是否存在代理接口
即：
- 如果目标对象实现了接口，默认会采用JDK动态代理实现AOP
- 如果目标对象实现了接口，可以强制使用CGLIB动态代理实现AOP
- 如果目标对象没有实现接口，必须采用CGLIB代理，Spring会自动在JDK动态代理和CGLIB代理之前切换。
2.2 getProxy(classLoader)
首先我们需要知道的是，调用这个方法的是 createAopProxy() 方法的返回值，那么就可能是JdkDynamicAopProxy.getProxy 或者 ObjenesisCglibAopProxy.getProxy。
我们这里以 JdkDynamicAopProxy 为例，ObjenesisCglibAopProxy 的实现逻辑出了一些标准的cglib代理实现之外，关键逻辑与之基本相同，就不再单独解析。
下面代码省略了JdkDynamicAopProxy 部分无关代码。
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
private boolean equalsDefined;
private boolean hashCodeDefined;
private final AdvisedSupport advised;
// 保存到advised中
public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
Assert.notNull(config, "AdvisedSupport must not be null");
if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
throw new AopConfigException("No advisors and no TargetSource specified");
}
this.advised = config;
}
@Override
public Object getProxy() {
return getProxy(ClassUtils.getDefaultClassLoader());
}
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
if (logger.isTraceEnabled()) {
logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
}
// 获取代理接口，因为是jdk代理，所以需要获取代理接口
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
// 发现 equals 和 hashCode 方法，如果发现，则改变 equalsDefined = true; 和 hashCodeDefined = true;
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
...
// 既然是代理，必然要看一看 invoke 方法了。
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
// 获取目标源
TargetSource targetSource = this.advised.targetSource;
Object target = null;
try {
// 处理 equals 方法
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
return equals(args[0]);
}
// 处理 hashCode 方法
else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// The target does not implement the hashCode() method itself.
return hashCode();
}
// 处理 DecoratingProxy 类
else if (method.getDeclaringClass() == DecoratingProxy.class) {
// There is only getDecoratedClass() declared -> dispatch to proxy config.
return AopProxyUtils.ultimateTargetClass(this.advised);
}
// 处理 Class类的isAssignableFrom(Class cls) 方法
else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
Object retVal;
// 是否暴露代理对象。有时候目标对象内部的自我调用将无法实施切面中的增强，则需要通过此属性暴露
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// Get as late as possible to minimize the time we "own" the target,
// in case it comes from a pool.
target = targetSource.getTarget();
Class<?> targetClass = (target != null ? target.getClass() : null);
// Get the interception chain for this method.
// 获取当前方法的拦截链路，其中包括将AspectJMethodBeforeAdvice、AspectJAfterAdvice、AspectJAfterReturningAdvice 转换成 MethodInterceptor
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
if (chain.isEmpty()) {
// 拦截链路为空则直接调用切点方法
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
else {
// We need to create a method invocation...
// 否则构建一个新的 方法调用对象 ReflectiveMethodInvocation
// 以便于使用proceed 方法进行链接表用拦截器
MethodInvocation invocation =
new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
// 调用方法，执行拦截器链路
retVal = invocation.proceed();
}
// Massage return value if necessary.
// 返回结果
Class<?> returnType = method.getReturnType();
if (retVal != null && retVal == target &&
returnType != Object.class && returnType.isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
// Special case: it returned "this" and the return type of the method
// is type-compatible. Note that we can't help if the target sets
// a reference to itself in another returned object.
retVal = proxy;
}
else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
throw new AopInvocationException(
"Null return value from advice does not match primitive return type for: " + method);
}
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
// Must have come from TargetSource.
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
}
上面我们有两个方法需要注意：
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);。这一句将 获取当前方法的拦截链路，其中包括将AspectJMethodBeforeAdvice、AspectJAfterAdvice、AspectJAfterReturningAdvice 转换成 MethodInterceptor，用于后面的掉啊用retVal = invocation.proceed();，不用讲，实现增强方法的调用
下面我们逐个来看
2.2.1. this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
在中篇中我们讲了在 InstantiationModelAwarePointcutAdvisorImpl 中，Spring根据注解的不同将方法封装成了不同的Advice ：AspectJAroundAdvice、AspectJMethodBeforeAdvice、AspectJAfterAdvice、AspectJAfterReturningAdvice、AspectJAfterThrowingAdvice。
在 invocation.proceed() 的分析中我们会发现最终调用的增强方法为 MethodInterceptor#invoke方法(这个就是2.2.2 的部分)。但是在上述五个Advice 中，只有AspectJAroundAdvice 和 AspectJAfterAdvice 实现了MethodInterceptor 接口，其余的并没有实现 MethodInterceptor 接口，那么这时候就需要进行一个转换，将 Advice 转换成 MethodInterceptor 类型，该转换就是在此方法中完成。
由于 this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); 方法最终会调用DefaultAdvisorChainFactory#getInterceptorsAndDynamicInterceptionAdvice，所以我们这里直接看该方法
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
Advised config, Method method, @Nullable Class<?> targetClass) {
// This is somewhat tricky... We have to process introductions first,
// but we need to preserve order in the ultimate list.
AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
Advisor[] advisors = config.getAdvisors();
List<Object> interceptorList = new ArrayList<>(advisors.length);
Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
Boolean hasIntroductions = null;
for (Advisor advisor : advisors) {
// 我们这里的Advisor 都是 PointcutAdvisor 所以这里只分析该内容
if (advisor instanceof PointcutAdvisor) {
// Add it conditionally.
PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
boolean match;
if (mm instanceof IntroductionAwareMethodMatcher) {
if (hasIntroductions == null) {
hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
}
match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
}
else {
match = mm.matches(method, actualClass);
}
//如果代理规则与当前类匹配
if (match) {
// 进行转化注册
MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
if (mm.isRuntime()) {
// Creating a new object instance in the getInterceptors() method
// isn't a problem as we normally cache created chains.
for (MethodInterceptor interceptor : interceptors) {
interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
}
}
else {
interceptorList.addAll(Arrays.asList(interceptors));
}
}
}
}
else if (advisor instanceof IntroductionAdvisor) {
IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
else {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
// 返回最终的拦截器集合
return interceptorList;
}
我们可以看到关键的代码就是 registry.getInterceptors(advisor);，所以我们这里来看 DefaultAdvisorAdapterRegistry#getInterceptors 的 实现
@Override
public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
List<MethodInterceptor> interceptors = new ArrayList<>(3);
Advice advice = advisor.getAdvice();
// 如果 Advice 就是MethodInterceptor 类型，则直接保存
if (advice instanceof MethodInterceptor) {
interceptors.add((MethodInterceptor) advice);
}
// 否则寻找合适的适配器进行转换
for (AdvisorAdapter adapter : this.adapters) {
if (adapter.supportsAdvice(advice)) {
interceptors.add(adapter.getInterceptor(advisor));
}
}
if (interceptors.isEmpty()) {
throw new UnknownAdviceTypeException(advisor.getAdvice());
}
return interceptors.toArray(new MethodInterceptor[0]);
}
这里的适配器有三个，分别是AfterReturningAdviceAdapter、MethodBeforeAdviceAdapter、ThrowsAdviceAdapter。很明显就是为了上面的三个Advice类型准备的，我们这里调其中一个ThrowsAdviceAdapter 看：
class ThrowsAdviceAdapter implements AdvisorAdapter, Serializable {
@Override
public boolean supportsAdvice(Advice advice) {
return (advice instanceof ThrowsAdvice);
}
@Override
public MethodInterceptor getInterceptor(Advisor advisor) {
return new ThrowsAdviceInterceptor(advisor.getAdvice());
}
}
逻辑很简答，就是将 ThrowsAdvice 封装成了ThrowsAdviceInterceptor。
经历过此步骤，所有的Advice 都转换为了 MethodInterceptor
2.2.2. retVal = invocation.proceed();
我们再来看看 ReflectiveMethodInvocation#proceed 的实现
public Object proceed() throws Throwable {
// We start with an index of -1 and increment early.
// 如果所有的增强器已经执行完了，则调用实际方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
// 获取下一个要调用的增强拦截器
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
// been evaluated and found to match.
// 动态匹配
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
// 如果匹配则调用
if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
// 调用invoke 方法
return dm.interceptor.invoke(this);
}
else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
// 不匹配则不执行拦截器，递归调用，遍历下一个拦截器
return proceed();
}
}
else {
// It's an interceptor, so we just invoke it: The pointcut will have
// been evaluated statically before this object was constructed.
// 普通的拦截器，直接调用拦截器。我们一般都走这里
// 将this 作为参数传递以保证当前实力中的调用链路的执行
// 直接调用 Advice 的 invoke 方法
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
在 ReflectiveMethodInvocation#process 方法中的逻辑并不复杂。ReflectiveMethodInvocation 中的主要职责是维护了链接调用的计数器，记录着当前调用链接的位置，以便链可以有序的进行下去，在这个方法中并没有维护各种增强的顺序，而是将此工作委托给了各个增强器，使各个增强器在内部进行逻辑实现。
以上：内容部分参考
《Spring实战》
《Spring源码深度解析》
https://www.cnblogs.com/cheng21553516/p/12190008.html
https://blog.csdn.net/wyl6019/article/details/80136000
如有侵扰，联系删除。 内容仅用于自我记录学习使用。如有错误，欢迎指正