Spring AOP源码篇二之代理工厂ProxyFactory学习

了解AspectJ表达式以及PointCut、Advice、Advisor后，继续学习Spring AOP代理工厂

AspectJ表达式参考：Spring AOP之AspectJ表达式-CSDN博客

PointCut、Advice、Advisor参考：Spring AOP源码篇一之 PointCut、Advice、Advisor学习-CSDN博客

简单代码示例：

package org.spring.aop.proxy.service;public interface IUserService {void say();
}

package org.spring.aop.proxy.service;public class UserService implements IUserService {public void say() {System.out.println("Hello world!!");}
}

package org.spring.aop.proxy.advice;import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;public class LogAdvice implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation methodInvocation) throws Throwable {System.out.println("===============log record start==============");Object object = methodInvocation.proceed();System.out.println("===============log record end================");return object;}
}

测试代码：

package org.spring.aop.proxy;import org.spring.aop.proxy.advice.LogAdvice;
import org.spring.aop.proxy.service.IUserService;
import org.spring.aop.proxy.service.UserService;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;public class ProxyFactoryTest {public static void main(String[] args) {System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");IUserService service = new UserService();ProxyFactory proxyFactory = new ProxyFactory(service);IUserService serviceProxy = (IUserService) proxyFactory.getProxy();//不打印toString是因为代理对象底层toString调的是目标对象的toString,二者toString内容一样。System.out.printf("原始对象[%s]====代理对象[%s]====[比较二者：%s]\n", service.hashCode(), serviceProxy.hashCode(), (service == serviceProxy));serviceProxy.say();System.out.println("\n-------------对目标对象增强功能-----------------\n");String expression = "execution(* org.spring.aop.proxy.service.UserService.*(..))";Advisor advisor = buildAdvisor(expression);proxyFactory.addAdvisor(advisor);serviceProxy = (IUserService) proxyFactory.getProxy();serviceProxy.say();}public static Advisor buildAdvisor(String expression) {//创建pointcutAspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();pointcut.setExpression(expression);//创建adviceLogAdvice advice = new LogAdvice();//创建advisorAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);return advisor;}
}

执行结果：

代理工厂ProxyFactory继承体系

Advised是个配置管理类，对Advisor、Advice进行配置管理

package org.springframework.aop.framework;import org.aopalliance.aop.Advice;import org.springframework.aop.Advisor;
import org.springframework.aop.TargetClassAware;
import org.springframework.aop.TargetSource;
import org.springframework.aop.framework.AopConfigException;public interface Advised extends TargetClassAware {/*** 判断advised配置是否冻结* 一旦冻结，不允许删除或增加Advisor和Adivce*/boolean isFrozen();/*** 判断是否直接代理目标类，而不是目标类的父接口* Spring中代理分为JDK动态代理、CGLIB代理；JDK动态代理的是父接口，CGLIB代理的是目标类（具体类）*/boolean isProxyTargetClass();/*** 返回目标对象的父接口，如果目标对象类型是接口则包含其中，如果不是接口则不包含其中。* 如果advice是引介增强的话，advice的接口也会放入其中。*/Class<?>[] getProxiedInterfaces();/*** 判断指定的接口是否已被代理（被代理的接口一般是目标类的父接口，* 默认Spring Aop会为目标对象的代理对象额外添加两个父接口SpringProxy、Advised）*/boolean isInterfaceProxied(Class<?> intf);/*/*public interface TargetSource extends TargetClassAware {/*** 返回目标对象类型*//*Class<?> getTargetClass();*//*** 判断目标对象是否为静态*//*boolean isStatic();*//*** 返回目标对象*//*Object getTarget() throws Exception;*//*** 释放销毁目标对象(spring中该方法基本都是空实现)，getTarget()时重新创建*//*void releaseTarget(Object target) throws Exception;}*//*** 设置被代理的目标对象TargetSource（目标对象被封装在TargetSource）*/void setTargetSource(TargetSource targetSource);/*** 返回被代理目标对象的TargetSource（目标对象被封装在TargetSource中）*/TargetSource getTargetSource();/*** 代理对象是否设置到AOP框架中的ThreadLocal中*/void setExposeProxy(boolean exposeProxy);/*** 判断代理对象是否被设置到了AOP框架中的ThreadLocal中*/boolean isExposeProxy();/*** 设置所有添加的advisor是否已经提前过滤过了（advisor和目标对象已经提前匹配过了）* 也就是所添加advisor的Advice已经是完全可以应用到目标对象上的*/void setPreFiltered(boolean preFiltered);/*** 判断所有添加的advisor是否已经提前过滤过了*/boolean isPreFiltered();/*** 返回Advisor列表*/Advisor[] getAdvisors();/*** 添加Advisor*/void addAdvisor(Advisor advisor) throws AopConfigException;/*** 在指定位置添加Advisor*/void addAdvisor(int pos, Advisor advisor) throws AopConfigException;/*** 删除Advisor，不存在的话不做删除*/boolean removeAdvisor(Advisor advisor);/*** 删除指定位置Advisor，index无效的话会报异常*/void removeAdvisor(int index) throws AopConfigException;/*** 返回advisor位置，不存在返回-1*/int indexOf(Advisor advisor);/*** 用新的advisor替换旧的advisor(b替换a)* <p><b>Note:</b>如果旧advisor实现了接口{@link org.springframework.aop.IntroductionAdvisor}* 会将旧advisor的父类接口从配置interfaces中删除，List<Class> interfaces是Advised的属性(在子类：AdvisedSupport)*/boolean replaceAdvisor(Advisor a, Advisor b) throws AopConfigException;/*** 添加Advice*/void addAdvice(Advice advice) throws AopConfigException;/*** 在指定位置添加advice，对应创建Advisor（类型为：DefaultPointcutAdvisor）* DefaultPointcutAdvisor里面的pointcut为Pointcut.TRUE，和目标对象总是匹配的*/void addAdvice(int pos, Advice advice) throws AopConfigException;/*** 删除advice，成功返回true，失败返回false（对应的Advisor也被删除）*/boolean removeAdvice(Advice advice);/*** 返回advice位置，不存在返回-1*/int indexOf(Advice advice);/*** 返回Advised的配置信息，等效toString()，内部一般是调用toString方法*/String toProxyConfigString();}

ProxyConfig是个代理配置管理类，对代理配置进行设置

package org.springframework.aop.framework;import java.io.Serializable;import org.springframework.util.Assert;public class ProxyConfig implements Serializable {/** use serialVersionUID from Spring 1.2 for interoperability */private static final long serialVersionUID = -8409359707199703185L;private boolean proxyTargetClass = false;private boolean optimize = false;boolean opaque = false;boolean exposeProxy = false;private boolean frozen = false;/*** 设置是否直接代理目标类，而不是目标类的父接口* Spring中代理分为JDK动态代理、CGLIB代理；JDK动态代理是接口，CGLIB代理是目标类（具体类）*/public void setProxyTargetClass(boolean proxyTargetClass) {this.proxyTargetClass = proxyTargetClass;}/*** 判断是否直接代理的目标类，而不是目标类的父接口* Spring中代理分为JDK动态代理、CGLIB代理；JDK动态代理是接口，CGLIB代理是目标类（具体类）*/public boolean isProxyTargetClass() {return this.proxyTargetClass;}/*** 设置是否进行优化*/public void setOptimize(boolean optimize) {this.optimize = optimize;}/*** 判断是否进行优化*/public boolean isOptimize() {return this.optimize;}/*** Spring AOP在生成代理对象时，默认为代理对象添加接口Advised。* opaque如果为true，则不会添加，举例：* interface IService{}* class A implements IService{}，** 如果opaque为false：*  A生成的代理对象为：Proxy.newProxyInstance(ClassLoader, new Class[]{Advised.class, IService.class}, InvocationHandler);*  如果opaque为true：*  A生成的代理对象为：Proxy.newProxyInstance(ClassLoader, new Class[]{IService.class}, InvocationHandler);*/public void setOpaque(boolean opaque) {this.opaque = opaque;}/*** 判断是否阻止为创建的代理对象添加接口Advised*/public boolean isOpaque() {return this.opaque;}/*** 将代理对象是否设置到AOP框架中的ThreadLocal中*/public void setExposeProxy(boolean exposeProxy) {this.exposeProxy = exposeProxy;}/*** 判断代理对象是否被设置到了AOP框架中的ThreadLocal中*/public boolean isExposeProxy() {return this.exposeProxy;}/*** 设置advised配置是否冻结*  一旦冻结，不允许删除或增加Advisor和Adivce*/public void setFrozen(boolean frozen) {this.frozen = frozen;}/*** 判断advised配置是否冻结* 一旦冻结，不允许删除或增加Advisor和Adivce*/public boolean isFrozen() {return this.frozen;}/*** 复制代理配置内容*/public void copyFrom(ProxyConfig other) {Assert.notNull(other, "Other ProxyConfig object must not be null");this.proxyTargetClass = other.proxyTargetClass;this.optimize = other.optimize;this.exposeProxy = other.exposeProxy;this.frozen = other.frozen;this.opaque = other.opaque;}@Overridepublic String toString() {StringBuilder sb = new StringBuilder();sb.append("proxyTargetClass=").append(this.proxyTargetClass).append("; ");sb.append("optimize=").append(this.optimize).append("; ");sb.append("opaque=").append(this.opaque).append("; ");sb.append("exposeProxy=").append(this.exposeProxy).append("; ");sb.append("frozen=").append(this.frozen);return sb.toString();}}

类AdvisedSupport对接口Advised中的方法做了具体实现

类ProxyCreatorSupport对接口ProxyConfig中的方法做了具体实现

ProxyFactory: 根据上面的配置，创建代理对象

package org.springframework.aop.framework;import org.aopalliance.intercept.Interceptor;import org.springframework.aop.TargetSource;
import org.springframework.util.ClassUtils;public class ProxyFactory extends ProxyCreatorSupport {/*** 无参构造函数*/public ProxyFactory() {}/*** 根据被代理目标类对象创建ProxyFactory* @param target*/public ProxyFactory(Object target) {setTarget(target);//获取被代理目标类对象上的接口，设置为被代理接口setInterfaces(ClassUtils.getAllInterfaces(target));}/*** 根据被代理接口Class创建ProxyFactory* @param proxyInterfaces*/public ProxyFactory(Class<?>... proxyInterfaces) {setInterfaces(proxyInterfaces);}/*** 根据被代理接口Class、Advice创建ProxyFactory* @param proxyInterface* @param interceptor*/public ProxyFactory(Class<?> proxyInterface, Interceptor interceptor) {addInterface(proxyInterface);addAdvice(interceptor);}/*** 根据被代理接口Class、被代理目标类对象(被封装在TargetSource中)创建ProxyFactory* @param proxyInterface* @param targetSource*/public ProxyFactory(Class<?> proxyInterface, TargetSource targetSource) {addInterface(proxyInterface);setTargetSource(targetSource);}/*** 创建代理对象，关键入口* 源码分析：节点1* @return*/public Object getProxy() {//createAopProxy()，源码分析：节点2，具体实现位于父类ProxyCreatorSupport.createAopProxy()return createAopProxy().getProxy();}/*** 创建代理对象* @param classLoader* 		类加载器* @return*/public Object getProxy(ClassLoader classLoader) {return createAopProxy().getProxy(classLoader);}/*** 创建代理对象* @param proxyInterface* 		被代理的接口* @param interceptor* 		Advice对象* @return*/public static <T> T getProxy(Class<T> proxyInterface, Interceptor interceptor) {return (T) new ProxyFactory(proxyInterface, interceptor).getProxy();}/*** 创建代理对象* @param proxyInterface* 		被代理的接口* @param targetSource* 		被代理的目标类对象(被封装在TargetSource中)* @return*/public static <T> T getProxy(Class<T> proxyInterface, TargetSource targetSource) {return (T) new ProxyFactory(proxyInterface, targetSource).getProxy();}/*** 创建代理对象* @param targetSource* 		被代理的目标类对象(被封装在TargetSource中)* @return*/public static Object getProxy(TargetSource targetSource) {if (targetSource.getTargetClass() == null) {throw new IllegalArgumentException("Cannot create class proxy for TargetSource with null target class");}ProxyFactory proxyFactory = new ProxyFactory();proxyFactory.setTargetSource(targetSource);//采用直接代理目标类（cglib）方式proxyFactory.setProxyTargetClass(true);return proxyFactory.getProxy();}}

package org.springframework.aop.framework;import java.util.LinkedList;
import java.util.List;import org.springframework.util.Assert;public class ProxyCreatorSupport extends AdvisedSupport {//Aop代理工厂，从继承关系上看和ProxyFactory没有关系private AopProxyFactory aopProxyFactory;private List<AdvisedSupportListener> listeners = new LinkedList<AdvisedSupportListener>();//标记AopProxy对象是否已经创建，AopProxy是真正创建代理的类。private boolean active = false;/*** 无参构造函数* 	核心代码，里面创建this.aopProxyFactory = new DefaultAopProxyFactory();*/public ProxyCreatorSupport() {this.aopProxyFactory = new DefaultAopProxyFactory();}public ProxyCreatorSupport(AopProxyFactory aopProxyFactory) {this.aopProxyFactory = aopProxyFactory;}public void setAopProxyFactory(AopProxyFactory aopProxyFactory) {this.aopProxyFactory = aopProxyFactory;}public AopProxyFactory getAopProxyFactory() {return this.aopProxyFactory;}public void addListener(AdvisedSupportListener listener) {this.listeners.add(listener);}public void removeListener(AdvisedSupportListener listener) {this.listeners.remove(listener);}/*** 源码分析：节点2* @return*/protected final synchronized AopProxy createAopProxy() {if (!this.active) {activate();}//源码分析：节点3//getAopProxyFactory()默认构造函数创建的aopProxyFactory= new DefaultAopProxyFactory()//aopProxyFactory.createAopProxy()创建AopProxyreturn getAopProxyFactory().createAopProxy(this);}private void activate() {this.active = true;for (AdvisedSupportListener listener : this.listeners) {listener.activated(this);}}@Overrideprotected void adviceChanged() {super.adviceChanged();synchronized (this) {if (this.active) {for (AdvisedSupportListener listener : this.listeners) {listener.adviceChanged(this);}}}}protected final synchronized boolean isActive() {return this.active;}}

package org.springframework.aop.framework;import java.io.Serializable;import org.springframework.aop.SpringProxy;public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {//源码分析：节点3//创建AopProxy对象，分为：JdkDynamicAopProxy和CglibAopProxypublic 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()) {//源码分析：节点4//创建JDK动态代理return new JdkDynamicAopProxy(config);}return CglibProxyFactory.createCglibProxy(config);}else {return new JdkDynamicAopProxy(config);}}private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {Class[] interfaces = config.getProxiedInterfaces();return (interfaces.length == 0 || (interfaces.length == 1 && SpringProxy.class.equals(interfaces[0])));}private static class CglibProxyFactory {public static AopProxy createCglibProxy(AdvisedSupport advisedSupport) {return new CglibAopProxy(advisedSupport);}}}

以JDK动态代理为例：

package org.springframework.aop.framework;import java.io.Serializable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.List;import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;import org.springframework.aop.AopInvocationException;
import org.springframework.aop.RawTargetAccess;
import org.springframework.aop.TargetSource;
import org.springframework.aop.support.AopUtils;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {/** use serialVersionUID from Spring 1.2 for interoperability */private static final long serialVersionUID = 5531744639992436476L;private static final Log logger = LogFactory.getLog(JdkDynamicAopProxy.class);//advised配置对象private final AdvisedSupport advised;//是否有equals方法private boolean equalsDefined;//是否有hashCode方法private boolean hashCodeDefined;/*** 构造函数** @param config* 		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;}//获取代理对象，核心代码public Object getProxy() {return getProxy(ClassUtils.getDefaultClassLoader());}//源码分析：节点4//获取代理对象，核心代码public Object getProxy(ClassLoader classLoader) {if (logger.isDebugEnabled()) {logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());}//从配置advised中获取被代理的接口Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);//创建代理对象return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);}//为equalsDefined和hashCodeDefined赋值private void findDefinedEqualsAndHashCodeMethods(Class<?>[] proxiedInterfaces) {for (Class<?> proxiedInterface : proxiedInterfaces) {Method[] methods = proxiedInterface.getDeclaredMethods();for (Method method : methods) {if (AopUtils.isEqualsMethod(method)) {this.equalsDefined = true;}if (AopUtils.isHashCodeMethod(method)) {this.hashCodeDefined = true;}if (this.equalsDefined && this.hashCodeDefined) {return;}}}}//源码分析：节点5//JDK动态代理接口InvocationHandler固定方法，每次调用目标类方法时，先执行该方法。public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {MethodInvocation invocation;Object oldProxy = null;boolean setProxyContext = false;TargetSource targetSource = this.advised.targetSource;Class<?> targetClass = null;Object target = null;try {if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {return equals(args[0]);}if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {return hashCode();}if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&method.getDeclaringClass().isAssignableFrom(Advised.class)) {return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);}Object retVal;if (this.advised.exposeProxy) {//将代理对象proxy放入TreadLocal中oldProxy = AopContext.setCurrentProxy(proxy);setProxyContext = true;}//获取目标对象target = targetSource.getTarget();if (target != null) {targetClass = target.getClass();}//源码分析：节点6// 从配置advised中获取所有的AdviceList<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);if (chain.isEmpty()) { //advice列表为空，直接执行目标类的目标方法retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);}else {//源码分析：节点7//匹配且挨个执行Adviceinvocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);retVal = invocation.proceed();}Class<?> returnType = method.getReturnType();if (retVal != null && retVal == target && returnType.isInstance(proxy) &&!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {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);}}}@Overridepublic boolean equals(Object other) {if (other == this) {return true;}if (other == null) {return false;}JdkDynamicAopProxy otherProxy;if (other instanceof JdkDynamicAopProxy) {otherProxy = (JdkDynamicAopProxy) other;}else if (Proxy.isProxyClass(other.getClass())) {InvocationHandler ih = Proxy.getInvocationHandler(other);if (!(ih instanceof JdkDynamicAopProxy)) {return false;}otherProxy = (JdkDynamicAopProxy) ih;}else {// Not a valid comparison...return false;}// If we get here, otherProxy is the other AopProxy.return AopProxyUtils.equalsInProxy(this.advised, otherProxy.advised);}/*** Proxy uses the hash code of the TargetSource.*/@Overridepublic int hashCode() {return JdkDynamicAopProxy.class.hashCode() * 13 + this.advised.getTargetSource().hashCode();}}

总结一下调用链路：

ProxyFactory===创建===》AopProxyFactory(默认实现：DefaultAopProxyFactory)===创建===》AopProxy（JdkDynamicAopProxy||CglibAopProxy）

AopProxy完成代理对象创建和调用。

============================================================

源码分析：节点6，AdvisedSupport#getInterceptorsAndDynamicInterceptionAdvice==》

AdvisorChainFactory#getInterceptorsAndDynamicInterceptionAdvice，进入到DefaultAdvisorChainFactory

package org.springframework.aop.framework;import java.io.Serializable;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;import org.aopalliance.intercept.Interceptor;
import org.aopalliance.intercept.MethodInterceptor;import org.springframework.aop.Advisor;
import org.springframework.aop.IntroductionAdvisor;
import org.springframework.aop.MethodMatcher;
import org.springframework.aop.PointcutAdvisor;
import org.springframework.aop.framework.AdvisorChainFactory;
import org.springframework.aop.framework.adapter.AdvisorAdapterRegistry;
import org.springframework.aop.framework.adapter.GlobalAdvisorAdapterRegistry;
import org.springframework.aop.support.MethodMatchers;public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {//获取匹配的Advice列表public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, Class targetClass) {List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);boolean hasIntroductions = hasMatchingIntroductions(config, targetClass);//里面注册着Advisor适配器，例如：ThrowsAdvice类型的会被转为ThrowsAdviceInterceptorAdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();for (Advisor advisor : config.getAdvisors()) {if (advisor instanceof PointcutAdvisor) {// 从Advised配置中获取AdvisorPointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;// 获取ClassFilter过滤类if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) {MethodInterceptor[] interceptors = registry.getInterceptors(advisor);MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();// 获取MethodMatcher过滤方法if (MethodMatchers.matches(mm, method, targetClass, hasIntroductions)) {if (mm.isRuntime()) {for (MethodInterceptor interceptor : interceptors) { //如果是动态匹配，包装一层InterceptorAndDynamicMethodMatcherinterceptorList.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(targetClass)) {Interceptor[] interceptors = registry.getInterceptors(advisor);interceptorList.addAll(Arrays.asList(interceptors));}}else {Interceptor[] interceptors = registry.getInterceptors(advisor);interceptorList.addAll(Arrays.asList(interceptors));}}return interceptorList;}/*** Determine whether the Advisors contain matching introductions.*/private static boolean hasMatchingIntroductions(Advised config, Class targetClass) {for (int i = 0; i < config.getAdvisors().length; i++) {Advisor advisor = config.getAdvisors()[i];if (advisor instanceof IntroductionAdvisor) {IntroductionAdvisor ia = (IntroductionAdvisor) advisor;if (ia.getClassFilter().matches(targetClass)) {return true;}}}return false;}}

源码分析：节点7，ReflectiveMethodInvocation#proceed

package org.springframework.aop.framework;package org.spring.aop.proxyfactory;import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;import org.springframework.aop.ProxyMethodInvocation;
import org.springframework.aop.support.AopUtils;
import org.springframework.core.BridgeMethodResolver;public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {//代理对象protected final Object proxy;//目标对象protected final Object target;//被调方法protected final Method method;//被掉方法参数protected Object[] arguments;//目标对象的Classprivate final Class targetClass;private Map<String, Object> userAttributes;//Advice列表protected final List interceptorsAndDynamicMethodMatchers;//Advice是个list链，用于记录执行到第几个Advice的下标private int currentInterceptorIndex = -1;/*** 构造函数** @param proxy* 		代理对象* @param target* 		目标对象* @param method* 		被调方法* @param arguments* 		被掉方法参数* @param targetClass* 		目标对象的Class* @param interceptorsAndDynamicMethodMatchers* 		Advice列表*/protected ReflectiveMethodInvocation(Object proxy, Object target, Method method, Object[] arguments,Class targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {this.proxy = proxy;this.target = target;this.targetClass = targetClass;this.method = BridgeMethodResolver.findBridgedMethod(method);this.arguments = arguments;this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;}public final Object getProxy() {return this.proxy;}public final Object getThis() {return this.target;}public final AccessibleObject getStaticPart() {return this.method;}public final Method getMethod() {return this.method;}public final Object[] getArguments() {return (this.arguments != null ? this.arguments : new Object[0]);}public void setArguments(Object[] arguments) {this.arguments = arguments;}//核心代码//执行Advice//递归调用Advicepublic Object proceed() throws Throwable {if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {return invokeJoinpoint();}Object interceptorOrInterceptionAdvice =this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) { //动态匹配InterceptorAndDynamicMethodMatcher dm =(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {return dm.interceptor.invoke(this);}else { //动态匹配失败return proceed();}}else {//不是动态匹配return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);}}protected Object invokeJoinpoint() throws Throwable {return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);}public MethodInvocation invocableClone() {Object[] cloneArguments = null;if (this.arguments != null) {// Build an independent copy of the arguments array.cloneArguments = new Object[this.arguments.length];System.arraycopy(this.arguments, 0, cloneArguments, 0, this.arguments.length);}return invocableClone(cloneArguments);}public MethodInvocation invocableClone(Object[] arguments) {// Force initialization of the user attributes Map,// for having a shared Map reference in the clone.if (this.userAttributes == null) {this.userAttributes = new HashMap<String, Object>();}// Create the MethodInvocation clone.try {ReflectiveMethodInvocation clone = (ReflectiveMethodInvocation) clone();clone.arguments = arguments;return clone;}catch (CloneNotSupportedException ex) {throw new IllegalStateException("Should be able to clone object of type [" + getClass() + "]: " + ex);}}public void setUserAttribute(String key, Object value) {if (value != null) {if (this.userAttributes == null) {this.userAttributes = new HashMap<String, Object>();}this.userAttributes.put(key, value);}else {if (this.userAttributes != null) {this.userAttributes.remove(key);}}}public Object getUserAttribute(String key) {return (this.userAttributes != null ? this.userAttributes.get(key) : null);}public Map<String, Object> getUserAttributes() {if (this.userAttributes == null) {this.userAttributes = new HashMap<String, Object>();}return this.userAttributes;}@Overridepublic String toString() {// Don't do toString on target, it may be proxied.StringBuilder sb = new StringBuilder("ReflectiveMethodInvocation: ");sb.append(this.method).append("; ");if (this.target == null) {sb.append("target is null");}else {sb.append("target is of class [").append(this.target.getClass().getName()).append(']');}return sb.toString();}}