Spring04-AOP(Debug查看执行流程)

1 AOP的几个核心技术

　　AOP-面向切面编程的实现的核心技术：jvm运行期间对字节码进行修改或者动态生成新的字节码文件(asm技术)。

2 AOP的几个核心概念

　　AOP在运行期间我们要对class文件做修改或者生成新的。AOP就定义了一套规范，包括了切面、切点、连接点、通知、织入等等这些内容。

（1）连接点（Join point）：指程序运行过程中所执行的方法。在Spring AOP中，一个连接点总代表一个方法的执行。

（2）切面（Aspect）：被抽取出来的公共模块，可以用来横切多个对象。Aspect切面可以看成 Pointcut切点 和 Advice通知 的结合，一个切面可以由多个切点和通知组成。在Spring AOP中，切面可以在类上使用 @AspectJ 注解来实现。

（3）切点（Pointcut）：切点用于定义 要对哪些Join point进行拦截。切点分为execution方式和annotation方式。execution方式可以用路径表达式指定对哪些方法拦截，比如指定拦截add*、search*。annotation方式可以指定被哪些注解修饰的代码进行拦截。

（4）通知（Advice）：指要在连接点（Join Point）上执行的动作，即增强的逻辑，比如权限校验和、日志记录等。通知有各种类型，包括Around、Before、After、After returning、After throwing。

（5）目标对象（Target）：包含连接点的对象，也称作被通知（Advice）的对象。 由于Spring AOP是通过动态代理实现的，所以这个对象永远是一个代理对象。

（6）织入（Weaving）：通过动态代理，在目标对象（Target）的方法（即连接点Join point）中执行增强逻辑（Advice）的过程。

（7）引入（Introduction）：添加额外的方法或者字段到被通知的类。Spring允许引入新的接口（以及对应的实现）到任何被代理的对象。例如，你可以使用一个引入来使bean实现 IsModified 接口，以便简化缓存机制。

3 通知

3.1 前置通知

　　前置通知:在方法执行之前执行的通知。前置通知使用 @Before 注解, 并将切入点表达式的值作为注解值.

@Before("declareJoinPointExpression()")
public void beforMethod(JoinPoint joinPoint){
    /*获取方法名*/
    String methodName = joinPoint.getSignature().getName();
    /*获取方法的参数*/
    List<Object> args = Arrays.asList(joinPoint.getArgs());

    System.out.println("The method "+methodName+" begins with"+args);
}

　　外部类切入点表达式方法引用如下：
　　使用类全路径+方法名

@Before("com.web.aop.LogAspects.pointCut()")
public void logEnd(JoinPoint joinPoint){
    System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");
}

3.2 后置通知

　　后置通知：在目标方法执行后执行，无论是否抛出异常。后置通知中不能访问目标方法执行后返回的结果。

@After("execution(* com.web.aop.impl.*.*(int , int ))")
/*表示该包下所有返回类型的所有类的所有方法*/
public void afterMethod(JoinPoint joinPoint){
    /*获取方法名*/
    String methodName = joinPoint.getSignature().getName();
    /*获取方法的参数*/
    List<Object> args = Arrays.asList(joinPoint.getArgs());

    System.out.println("The method "+methodName+" ends with"+args);

}

3.3 返回通知

　　返回通知 :在方法正常执行返回结果后执行，返回通知可以获取目标方法的返回值。
　　在返回通知中, 只要将 returning 属性添加到 @AfterReturning 注解中, 就可以访问连接点的返回值。 该属性的值即为用来传入返回值的参数名称。
　　必须在通知方法的签名中添加一个同名参数，在运行时Spring AOP 会通过这个参数传递返回值。
　　原始的切点表达式需要出现在 pointcut 属性中。

@AfterReturning(pointcut="execution(* com.web.aop.impl.*.*(int , int ))",returning="result")
/*表示该包下所有返回类型的所有类的所有方法*/
public void afterReturning(JoinPoint joinPoint ,Object result){
    /*获取方法名*/
    String methodName = joinPoint.getSignature().getName();
    /*获取方法的参数*/
    List<Object> args = Arrays.asList(joinPoint.getArgs());

    System.out.println("The method "+methodName+" ends with "+result);

}

3.4 异常通知

　　在方法抛出异常后执行，可以访问到异常对象。且可以指定在出现特定异常对象时，再执行。
　　只在连接点抛出异常时才执行异常通知
 　　将 throwing 属性添加到 @AfterThrowing 注解中, 也可以访问连接点抛出的异常.
　　Throwable 是所有错误和异常类的超类. 所以在异常通知方法可以捕获到任何错误和异常.
　　如果只对某种特殊的异常类型感兴趣, 可以将参数声明为其他异常的参数类型. 然后通知就只在抛出这个类型及其子类的异常时才被执行。

@AfterThrowing(value="execution(* com.web.aop.impl.*.*(int , int ))",throwing="exception")
/*表示该包下所有返回类型的所有类的所有方法*/
public void afterThrowing(JoinPoint joinPoint ,Exception exception){
    /*获取方法名*/
    String methodName = joinPoint.getSignature().getName();
    /*获取方法的参数*/
    List<Object> args = Arrays.asList(joinPoint.getArgs());

    System.out.println("The method "+methodName+" throws exception :"+exception);

}

3.5 环绕通知

　　环绕通知是所有通知类型中功能最为强大的, 能够全面地控制连接点. 甚至可以控制是否执行连接点.动态代理，手动推进目标方法运行（joinPoint.procced()）
　　环绕通知需要携带ProceedingJoinPoint类型的参数；
　　环绕通知类似于动态代理的全过程：ProceedingJoinPoint类型的参数可以决定是否执行目标方法；
　　环绕通知必须有返回值，返回值即为目标方法的返回值 ！
　　对于环绕通知来说, 连接点的参数类型必须是 ProceedingJoinPoint 。它是 JoinPoint 的子接口, 允许控制何时执行, 是否执行连接点。
　　在环绕通知中需要明确调用 ProceedingJoinPoint 的 proceed() 方法来执行被代理的方法。 如果忘记这样做就会导致通知被执行了, 但目标方法没有被执行。
　　注意: 环绕通知的方法需要返回目标方法执行之后的结果, 即调用 joinPoint.proceed() 的返回值, 否则会出现空指针异常。

@Around("execution(* com.web.aop.impl.*.*(int , int ))")
/*表示该包下所有返回类型的所有类的所有方法*/
public Object aroundMethod(ProceedingJoinPoint joinPoint){

    System.out.println("This is aroundMethod....");

    /*获取方法名*/
    String methodName = joinPoint.getSignature().getName();
    /*获取方法的参数*/
    List<Object> args = Arrays.asList(joinPoint.getArgs());

    Object result = null;
    try {
        //前置通知
        System.out.println("The method "+methodName+" begins with  :"+args);

        result = joinPoint.proceed();

        //返回通知
        System.out.println();
        System.out.println("The method "+methodName+" ends with  :"+result);
    } catch (Throwable e) {
        // 异常通知
        System.out.println("The method "+methodName+" throws exception :"+e);
        throw new RuntimeException(e);
    }

    //后置通知
    System.out.println("The method "+methodName+" ends ");

    return result;
}

3.6 切点的表达式

4 AOP的执行过程

具体顺序

　　1）从chain取出around通知对象，执行自定义的aorund通知方法前置通知内容(Object proceed = joinPoint.proceed()之前的内容)

　　2）从chain取出before通知对象，执行自定义的before通知方法

　　3）从chain取出after通知对象

　　4）从chain取出afterreturning通知对象

　　5）从chain取出atferthrowing通知对象

　　6）执行连接点的逻辑方法

　　7）执行自定义的afterthrowing的通知方法(没有异常不会执行)

　　8）执行自定义的afterreturning的通知方法

　　9）执行自定义的afterre的通知方法

　　10）继续执行自定义的around通知方法，执行后置通知内容(Object proceed = joinPoint.proceed()之后的内容)

5 测试代码(配合上图看)

5.1 切面

@Component
@Aspect
public class AopLogUtils {

    @Pointcut("execution(public * com.ruoyi.weixin.user.AopTest.AopTestServiceImpl.test(..)))")
    public void myPointCut(){};

    @Around(value = "myPointCut()")
    public Object doAround(ProceedingJoinPoint joinPoint)
    {
        int result = 0;
        try {
            System.out.println("doAround 前面执行");
            Object proceed = joinPoint.proceed();
            System.out.println("doAround 后面执行");
        }catch (Throwable t){
            System.out.println("doAround 出错");
        }finally {
            System.out.println("doAround finally执行");
        }
        return result;

    }

    @Before(value = "myPointCut()")
    public void doBefore(JoinPoint joinPoint)
    {
        System.out.println("doBefore 执行");
    }

    @After(value = "myPointCut()")
    public void doAfter(JoinPoint joinPoint)
    {
        System.out.println("doAfter 执行");
    }

    @AfterReturning(value = "myPointCut()",returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, Object jsonResult)
    {
        System.out.println("doAfterReturning 执行");
    }

    @AfterThrowing(value = "myPointCut()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e)
    {
        System.out.println("AfterThrowing 执行");
    }
}

5.2 业务代码

public interface AopTestService {
    void test();
}

@Service("aoptestservice")
public class AopTestServiceImpl implements AopTestService{

    @Override
    public void test(){
        System.out.println("asdf");
    }

}

@RestController
public class MyAopTest {

    @Autowired
    @Qualifier("aoptestservice")
    private AopTestService aoptestservice;

    @GetMapping("/lj_weixin/aoptest")
    public void test(){

        aoptestservice.test();
    }

5.3 执行调用debug

　　进入controller，我们看一下aoptestservice，发现它是一个代理对象

看它的属性，里面有一个CALLBACK数组

class CglibAopProxy implements AopProxy, Serializable {
    2 public static class SerializableNoOp implements NoOp, Serializable {}
    private static class StaticUnadvisedInterceptor implements MethodInterceptor, Serializable {}
    1 private static class StaticUnadvisedExposedInterceptor implements MethodInterceptor, Serializable {}
    private static class DynamicUnadvisedInterceptor implements MethodInterceptor, Serializable {}
    private static class DynamicUnadvisedExposedInterceptor implements MethodInterceptor, Serializable {}
    3 private static class StaticDispatcher implements Dispatcher, Serializable {}
    4 private static class AdvisedDispatcher implements Dispatcher, Serializable {}
    5 private static class EqualsInterceptor implements MethodInterceptor, Serializable {}
    6 private static class HashCodeInterceptor implements MethodInterceptor, Serializable {}
    private static class FixedChainStaticTargetInterceptor implements MethodInterceptor, Serializable {}
    0 private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {}
    private static class CglibMethodInvocation extends ReflectiveMethodInvocation {}
    private static class ProxyCallbackFilter implements CallbackFilter {}
}

6 f7进入方法来到CglibAopProxy.java里面的内部类DynamicAdvisedInterceptor的intercept方法

　　和上面的CALLBACK数组的元素比对，发现它的0号元素就是DynamicAdvisedInterceptor

往下执行，一直到下面代码执行完

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);          

chain是一个集合，里面存储了通知对象，我们可以看到，一共有6个元素。

但是我们实际上只定义了5个通知，多了一个元素0号元素：ExposeInvocationInterceptor

1-5号元素就是我们定义的通知：它们的顺序是around-before-after-afterreturn-afterthrowing

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

　chain放入CglibMethodInvocation对象中，调用proceed()方法

7 进入CglibAopProxy.java.CglibMethodInvocation.java的proceed方法

private static class CglibMethodInvocation extends ReflectiveMethodInvocation {

public Object proceed() throws Throwable {
            try {
                return super.proceed();
            }

8 进入super.proceed，也就是ReflectiveMethodInvocation.java的proceed方法

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

currentInterceptorIndex = -1 ，this.interceptorsAndDynamicMethodMatchers.size() = 6

Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);

获取到的interceptorOrInterceptionAdvice是ExposeInvocationInterceptor对象，也就是chain里面的0好元素

return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);

里面传入的this是上面创建的CglibMethodInvocation对象(它里面有chain对象)

9 进入ExposeInvocationInterceptor的invoke方法

@Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        MethodInvocation oldInvocation = invocation.get();
        invocation.set(mi);
        try {
            return mi.proceed();
        }
        finally {
            invocation.set(oldInvocation);
        }
    }

把mi对象(也就是上面传入的this对象-CglibAopProxy.java.CglibMethodInvocation对象)赋值给invocation

invocation是当前类ExposeInvocationInterceptor的一个static final静态变量

private static final ThreadLocal<MethodInvocation> invocation =
            new NamedThreadLocal<>("Current AOP method invocation");

10  然后调用mi的proceed方法

　　就是CglibAopProxy.java.CglibMethodInvocation.java的proceed方法

　　进入proceed方法

public Object proceed() throws Throwable {
            try {
                return super.proceed();
            }

11 调用super.proceed方法，又回到了ReflectiveMethodInvocation的proceed方法

　　此时currentInterceptorIndex值为0

get(++this.currentInterceptorIndex)取出来的是AspectAroundAdvice 环绕通知

Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);

12 执行((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);进入AspectJAroundAdvice.java的invoke方法

进入invokeAdviceMethod方法

进入invokeAdviceMethodWithGivenArgs方法

进入this.aspectJAdviceMethod.invoke方法，也就是Method.java的invoke方法

执行ma.invoke(obj, args);

执行，来到环绕通知方法

执行完System.out.println("doAround 前面执行");这个就是around的第一次执行

13 接着执行我们定义的环绕通知方法里面的代码Object proceed = joinPoint.proceed();进入MethodInvocationProceedingJoinPoint.java的proceed方法

14 进入this.methodInvocation.invocableClone().proceed()也就是CglibAopProcy.java.CglibMethodInvocation.java.proceed方法(又回到这个方法)

15 (同11步)进入super.proceed，就是ReflectiveMethodInvocation.java的proceed方法

　　此时currentInterceptorIndex为1

　　取出++this.currentInterceptorIndex号元素，为MethodBeforeAdviceInterceptor，也就是before通知

Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);

16 执行((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);进入MethodBeforeAdviceInterceptor.java的invoke方法

执行完this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());

before通知方法已执行

17 (同11步)调用super.proceed方法，又回到了ReflectiveMethodInvocation的proceed方法

　　此时currentInterceptorIndex为2

　　取出++this.currentInterceptorIndex号元素，为AspectJAfterAdvice，也就是after通知

18 执行((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);进入AspectJAfterAdvice.java的invoke方法

直接执行return mi.proceed();并没有去调用我们定义的after通知的方法

19 (同11步)调用super.proceed方法，又回到了ReflectiveMethodInvocation的proceed方法

　　此时currentInterceptorIndex为2

取出++this.currentInterceptorIndex号元素，为AfterReturningAdviceInterceptor，也就是afterReturning通知

20 执行((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);进入AfterReturningAdviceInterceptor.java的invoke方法

　　先直接执行Object retVal = mi.proceed();等它执行完成，才去执行this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());

　　也就是我们自定义的通知方法

21 (同11步)调用super.proceed方法，又回到了ReflectiveMethodInvocation的proceed方法

　　此时currentInterceptorIndex为4

取出++this.currentInterceptorIndex号元素，为AspectAfterThrowingAdvice，也就是afterrThrowing通知

22 执行((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);进入AspectJAfterThrowingAdvice.java的invoke方法

　　直接执行mi.proceed();执行完成后，采取执行invokeAdviceMethod(getJoinPointMatch(), null, ex);也就是我们自定义的通知方法

23 进入super.proceed，也就是ReflectiveMethodInvocation.java的proceed方法

　　此时currentInterceptorIndex为5，判断为true，执行return invokeJoinpoint();

24 执行return invokeJoinpoint();

　　进入CglibAopProxy.java.CglibMethodInvocation.java的invokeJoinpoint方法

执行this.methodProxy.invoke(this.target, this.arguments);来到MethodProxy的invoke方法

25 执行 fci.f1.invoke(fci.i1, obj, args);来到我们的连接点方法

26 一步步执行，回到AspectJAfterThrowingAdvice.invoke方法

　　回到ThrowingAdvice通知的invoke方法，继续执行，由于没有异常，不会执行catch里面的invokeAdviceMethod(getJoinPointMatch(), null, ex);，所以自定义的通知方法不会执行

27 继续执行，回到AfterReturningAdviceInterceptor的invoke方法

　　回到了AfterReturning通知的invoke方法

执行this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());

一步步往里面走，直到执行我们自定义的通知方法

28 继续执行，回到AspectJAfterAdvice的invoke方法

　　执行invokeAdviceMethod(getJoinPointMatch(), null, null);

　　一步步往里面走，直到执行我们自定义的通知方法

29 继续走，回到自定义的around通知方法

执行完

到此，五个通知全部执行完成