SpringAOP的实现有 jdk 动态代理和 cglib 代理，对应的核心类是 JdkDynamicAopProxy 和CglibAopProxy。
先来看 JdkDynamicAopProxy，找到它的 invoke方法,上码：
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
// 最终操作的是 TargetSource对象
TargetSource targetSource = this.advised.targetSource;
Object target = null;
try {
// 不代理 equals 和 hashCode 方法，调用 JdkDynamicAopProxy中的equal比较和hashCode方法
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
return equals(args[0]);
}
else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
return hashCode();
}
else if (method.getDeclaringClass() == DecoratingProxy.class) {
return AopProxyUtils.ultimateTargetClass(this.advised);
}
else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// 如果 method是在 advised中声明的，则把 method转到 advised对象中使用
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
Object retVal;
if (this.advised.exposeProxy) {
// 如果暴露代理对象，则把proxy设置到 ThreadLocal 中，线程内可共享该对象
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
target = targetSource.getTarget();
Class targetClass = (target != null ? target.getClass() : null);
// 获取方法的拦截器链
List我们来重点分析 ReflectiveMethodInvocation#proceed() 方法：
public Object proceed() throws Throwable {
// 拦截器执行完了，就执行目标对象的目标方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
// 获取责任链下一个 MethodInterceptor, 对目标方法进行增强处理
Object interceptorOrInterceptionAdvice =this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
InterceptorAndDynamicMethodMatcher dm =(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
Class targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
// 方法动态匹配成功，才进行增强处理
if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
// 动态匹配失败，跳过当前拦截器，跳到下一个
return proceed();
}
}
else {
// 不需要动态匹配，则直接调用 MethodInterceptor 的invoke方法
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}我们来看 ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this) ，这里是每个interceptor都去invoke一遍，我们先看 MethodBeforeAdviceInterceptor#invoke()
public class MethodBeforeAdviceInterceptor implements MethodInterceptor, BeforeAdvice, Serializable {
private final MethodBeforeAdvice advice;
public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
Assert.notNull(advice, "Advice must not be null");
this.advice = advice;
}
@Override
@Nullable
public Object invoke(MethodInvocation mi) throws Throwable {
// 先执行 MethodBeforeAdvice 这个 advice，而advice.before 的这个before,
//正是我们定义的前置通知的方法体
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
// 再递归执行 MethodInvocation
return mi.proceed();
}
}接着再来看 AfterReturningAdviceInterceptor#invoke()
public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {
private final AfterReturningAdvice advice;
public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {
Assert.notNull(advice, "Advice must not be null");
this.advice = advice;
}
@Override
@Nullable
public Object invoke(MethodInvocation mi) throws Throwable {
//先执行中间的 MethodInvocation，比如 目标方法
Object retVal = mi.proceed();
// 再执行 AfterReturningAdvice advice的 afterReturning(),这个
// afterReturning() 就是我们定义的后置处理的方法体
this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
return retVal;
}
}各位看官，到这里是不是很明了了。简而言之，就是遍历所有的增强器（拦截器），有前置增强器就先执行它，接着执行目标方法，再执行后置增强器。就是辣么竿丹~~
CglibAopProxy 也类似，最终也是调用 ReflectiveMethodInvocation#proceed()~~
各位看官，下节更精彩，点个赞，年薪百万不是梦~