关于java:AOP切面运行原理解析

日志、事务、限流、统计、上下文切换、异步等非业务性能的逻辑解决都能够用

网上随处可见，这里只是简略举个例子

@Aspect
@Component
public class DemoAspect {@Pointcut("execution(* com.example.demo2.controller.DemoController.sayDemo())")
    public void aa(){System.out.println("pointcut");
    }

    @Before("aa()")
    public void beforeDemo(JoinPoint joinPoint){System.out.println(joinPoint);
        System.out.println("before demo");
    }

    @After("aa()")
    public void afterDemo(){System.out.println("after demo");
    }

    @Around("aa()")
    public void zaroundDemo(ProceedingJoinPoint joinPoint){System.out.println("demo around1");
        try {joinPoint.proceed();
        } catch (Throwable throwable) {throwable.printStackTrace();
        }
        System.out.println("demo around2");
    }

}

AbstractAspectJAdvise
AspectJAroundAdvice
AspectJMethodBeforeAdvice
AspectJAfterThrowingAdvice
AspectJAfterAdvice

AspectjAroundAdvice — 继承自 methodInterceptor

AspectjMethodBeforeAdvice — 这还有一个 MethodBeforeInterceptor 用来实现动静代理

通过 cglib 代理生成代理类，外面重写父类的办法，退出拦截器 DynamicCglibMethodInterceptor，这外面退出了对于这个类的所有织入告诉（advice）对应的拦截器，比方：AspectJMethodBeforeAdvice—MethodBeforeAdviceInterceptor;AspectJAroundAdvice 的拦截器就是自身；
在进行调用的时候，会先遍历所有的 Advice 对应的拦截器，调用外面的 invoke 办法；把以后的 CglibMethodInvocation 对象传下去；（典型责任链模式）
3. 重点：AspectJAroundAdvise 外面有一个 ProceedingJoinPoint 参数，这个是如何调用的呢？实际上外面在 Advice 外面都是通过返回调用了切面类中的告诉办法，method.invoke(obj,args)；为了实现盘绕告诉呢？在初始化 MethodInvokcationProceedingJoinPoint 的时候，就把 CglibMethodInvocation 也传入进去了，不便调用链的持续运行；如果是调用链最初一个，那么 methodInvocationProceedingJoinPoint 调用实现后，间接返回到盘绕告诉办法外面，而后持续向下执行，直至完结即可。

依据

System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,fileName);

生成的动静代理对象，能够看出，外面会有一个 DemoController$$EnhanceByCglib 这个对象，外面有一个 callback[] 数组，这个就是记录的所有拦截器；
通过动静生成的代理类调用 demo 办法的时候，实际上走的流程是：

public final void sayDemo() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
# 如果有拦截器，则调用拦截器办法，if (var10000 != null) {var10000.intercept(this, CGLIB$sayDemo$0$Method, CGLIB$emptyArgs, CGLIB$sayDemo$0$Proxy);
        } else {super.sayDemo();
        }
    }

能够看到动静代理产生的类重写了父类的 DemoController 中的 sayDemo 办法，而后有写了一个办法叫

final void CGLIB$sayDemo$0() {super.sayDemo();
    }

来调用父类的办法；
重点看下拦截器是什么？怎么调用的？

注入的拦截器，
在 intercept 办法中，会判断 advice 是否为空，如果不为空，则会调用

retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();

调用父类 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();
        }
// 依据 index 找下一个 advice 是什么？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)) {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.
// 走到这里，调用 advice 对应的 MethodInterceptor
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }

假如：第一个是盘绕告诉对应的拦截器

public Object invoke(MethodInvocation mi) throws Throwable {if (!(mi instanceof ProxyMethodInvocation)) {throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation:" + mi);
        }
// 把以后的 CglibMethodInvocation 实例对象传到 ProceedingJoinPoint 中，不便前面来用；ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
        ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi);
        JoinPointMatch jpm = getJoinPointMatch(pmi);
// 利用反射调用切面中的盘绕告诉办法，（即上文的 zaroundDemo 办法）return invokeAdviceMethod(pjp, jpm, null, null);
    }

代码如下

 @Around("aa()")
    public void zaroundDemo(ProceedingJoinPoint joinPoint){System.out.println("demo around1");
        try {
// 这里就是调用 MethodInvocationProceedingJoinPoint;
            joinPoint.proceed();} catch (Throwable throwable) {throwable.printStackTrace();
        }
        System.out.println("demo around2");
    }

MethodInvocationProceedingJoinPoint.proceed 办法，能够发现，实际上它调用的是下面作为成员变量传进来的 CglibMethodInvocation 对象；造成一个调用链；

public Object proceed() throws Throwable {return this.methodInvocation.invocableClone().proceed();}

拦截器外面的逻辑：

先调用前置告诉的 before 办法，
再返回调用链的 CglibMethodInvocation– 持续责任链的调用；

public Object invoke(MethodInvocation mi) throws Throwable {this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
        return mi.proceed();}

AspectJMethodBeforeAdvice.proceed
也是利用反射进行调用切面中的前置告诉；

    @Override
    public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {invokeAdviceMethod(getJoinPointMatch(), null, null);
    }

在 finally 外面在反射调用织入的后置告诉；

    public Object invoke(MethodInvocation mi) throws Throwable {
        try {return mi.proceed();
        }
        finally {invokeAdviceMethod(getJoinPointMatch(), null, null);
        }
    }

if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {return invokeJoinpoint();
        }

invokeJoinPoint

protected Object invokeJoinpoint() throws Throwable {
 // 如果通过 cglib 代理，则调用动静代理办法
            if (this.methodProxy != null) {
                try {return this.methodProxy.invoke(this.target, this.arguments);
                }
                catch (CodeGenerationException ex) {logFastClassGenerationFailure(this.method);
                }
            }
// 否则就通过反射调用
            return super.invokeJoinpoint();}

AOP 大量应用反射，诸如：调用织入告诉
spring 将所有的告诉放到一个 list 中，利用责任链模式进行逐个调用；
最初在触发 cglib 的动静代理，调用 MethodProxy.invoke 办法

关于java:AOP切面运行原理解析

1 利用

2 例子

3 相干重要类

4 调用过程

5 源码解析

5.1 动静代理类

5.2 DynamicAdvisedInterceptor

5.3 CglibMethodInvocation

5.4 AspectJAroundAdvice

5.5 AspectJMethodBeforeAdvice–MethodBeforeAdviceInterceptor

5.6 AspectJAfterAdvice

5.7 责任链的最初一步：–invokeJoinpoint

6 总结