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通知方法

执行完

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

最新文章

  1. hdu 1281 二分图最大匹配
  2. Yahoo!网站性能最佳体验的34条黄金守则
  3. keepalive实现web服务器active/passive
  4. HDU 3416 Marriage Match IV （求最短路的条数，最大流）
  5. Objective-C中的Block
  6. 7 -- Spring的基本用法 -- 8...
  7. 【开源框架】Android之史上最全最简单最有用的第三方开源库收集整理，有助于快速开发，欢迎各位网友补充完善
  8. 【每日一摩斯】-Troubleshooting: High CPU Utilization (164768.1) - 系列5
  9. html表单---学习笔记03
  10. arcgis api 3.x for js入门开发系列九热力图效果（附源码下载）
  11. Django 的路由层 视图层 模板层
  12. ELK架构设计
  13. 图-&gt;连通性-&gt;关节点和重连通分量
  14. 095实战 ETL的数据来源，处理，保存
  15. BFC特性 形成BFC
  16. iOS-AFNetworking参数和多文件同时上传【多文件上传】
  17. python3操作MySQL数据库
  18. xUtils怎么post请求上传字符串
  19. 电脑护眼小软件f.lux
  20. Codeforces Round #361 (Div. 2) E. Mike and Geometry Problem

热门文章

  1. JetBrains新产品Aqua——自动化测试开发工具（抢鲜体验）
  2. 详解Native Memory Tracking之追踪区域分析
  3. 重学c#系列——动态类型[二十二]
  4. 谷歌、微软、Meta？谁才是 Python 最大的金主？
  5. eclipse 无法将节点解析到句柄
  6. 数电第11周周结_by_yc
  7. Java中的反射机制及反射的优缺点
  8. go-carbon 1.5.1 版本发布， 修复已知 bug 和新增土耳其翻译文件
  9. VS2019发布至远程IIS部署流程
  10. go的grpc环境源码编译安装