Spring系列第35篇：@Aspect中5中通知详解

star2017 1年前 ⋅ 300 阅读

本文内容：详解@Aspect中5中通知的使用。

Aop相关阅读

阅读本文之前，需要先掌握下面几篇文章内容，不然会比较吃力。

  1. 代理详解（java动态代理&CGLIB代理)
  2. jdk动态代理和cglib代理
  3. Aop概念详解
  4. AOP核心源码、原理详解
  5. ProxyFactoryBean创建AOP代理
  6. @Aspect中@Pointcut 12种用法

@Aspect中有5种通知

  1. @Before：前置通知, 在方法执行之前执行
  2. @Aroud：环绕通知, 围绕着方法执行
  3. @After：后置通知, 在方法执行之后执行
  4. @AfterReturning：返回通知, 在方法返回结果之后执行
  5. @AfterThrowing：异常通知, 在方法抛出异常之后

这几种通知用起来都比较简单，都是通过注解的方式，将这些注解标注在@Aspect类的方法上，这些方法就会对目标方法进行拦截，下面我们一个个来看一下。

@Before：前置通知

介绍

定义一个前置通知

  1. @Aspect
  2. public class BeforeAspect {
  4.     @Before("execution(* com.javacode2018.aop.demo10.test1.Service1.*(..))")
  5.     public void before(JoinPoint joinPoint) {
  6.         System.out.println("我是前置通知!");
  7.     }
  8. }
  1. 类上需要使用@Aspect标注
  2. 任意方法上使用@Before标注，将这个方法作为前置通知，目标方法被调用之前，会自动回调这个方法
  3. 被@Before标注的方法参数可以为空，或者为JoinPoint类型，当为JoinPoint类型时，必须为第一个参数
  4. 被@Before标注的方法名称可以随意命名，符合java规范就可以，其他通知也类似

@Before中value的值为切入点表达式，也可以采用引用的方式指定切入点，如：

  1. package com.javacode2018.aop.demo10.test1;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.annotation.Aspect;
  5. import org.aspectj.lang.annotation.Before;
  6. import org.aspectj.lang.annotation.Pointcut;
  8. @Aspect
  9. public class BeforeAspect {
  11.     @Pointcut("execution(* com.javacode2018.aop.demo10.test1.Service1.*(..))")
  12.     public void pc() {
  13.     }
  15.     @Before("com.javacode2018.aop.demo10.test1.BeforeAspect.pc()")
  16.     public void before(JoinPoint joinPoint) {
  17.         System.out.println("我是前置通知!");
  18.     }
  19. }

此时，before方法上面的切入引用了pc方法上面的@Pointcut的值

案例

来个普通的service

  1. package com.javacode2018.aop.demo10.test1;
  3. public class Service1 {
  4.     public String say(String name) {
  5.         return "你好：" + name;
  6.     }
  8.     public String work(String name) {
  9.         return "开始工作了：" + name;
  10.     }
  11. }

给上面的类定义一个前置通知，Service1中的所有方法执行执行，输出一段文字我是前置通知!

  1. package com.javacode2018.aop.demo10.test1;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.annotation.Aspect;
  5. import org.aspectj.lang.annotation.Before;
  6. import org.aspectj.lang.annotation.Pointcut;
  8. @Aspect
  9. public class BeforeAspect1 {
  11.     @Pointcut("execution(* com.javacode2018.aop.demo10.test1.Service1.*(..))")
  12.     public void pc() {
  13.     }
  15.     @Before("com.javacode2018.aop.demo10.test1.BeforeAspect1.pc()")
  16.     public void before(JoinPoint joinPoint) {
  17.         System.out.println("我是前置通知!");
  18.     }
  19. }

测试代码

  1. package com.javacode2018.aop.demo10;
  3. import com.javacode2018.aop.demo10.test1.BeforeAspect1;
  4. import com.javacode2018.aop.demo10.test1.Service1;
  5. import org.junit.Test;
  6. import org.springframework.aop.aspectj.annotation.AspectJProxyFactory;
  8. public class AopTest10 {
  10.     @Test
  11.     public void test1() {
  12.         Service1 target = new Service1();
  13.         Class<BeforeAspect1> aspectClass = BeforeAspect1.class;
  14.         AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
  15.         proxyFactory.setTarget(target);
  16.         proxyFactory.addAspect(aspectClass);
  17.         Service1 proxy = proxyFactory.getProxy();
  18.         System.out.println(proxy.say("路人"));
  19.         System.out.println(proxy.work("路人"));
  20.     }
  21. }

运行输出

  1. 我是前置通知!
  2. 你好：路人
  3. 我是前置通知!
  4. 开始工作了：路人

对应的通知类

@Before通知最后会被解析为下面这个通知类

  1. org.springframework.aop.aspectj.AspectJMethodBeforeAdvice

通知中获取被调方法信息

通知中如果想获取被调用方法的信息，分2种情况

  1. 非环绕通知，可以将org.aspectj.lang.JoinPoint作为通知方法的第1个参数，通过这个参数获取被调用方法的信息
  2. 如果是环绕通知，可以将org.aspectj.lang.ProceedingJoinPoint作为方法的第1个参数，通过这个参数获取被调用方法的信息

JoinPoint：连接点信息

  1. org.aspectj.lang.JoinPoint

提供访问当前被通知方法的目标对象、代理对象、方法参数等数据：

  1. package org.aspectj.lang;  
  2. import org.aspectj.lang.reflect.SourceLocation;
  4. public interface JoinPoint {  
  5.     String toString();         //连接点所在位置的相关信息  
  6.     String toShortString();     //连接点所在位置的简短相关信息  
  7.     String toLongString();     //连接点所在位置的全部相关信息  
  8.     Object getThis();         //返回AOP代理对象
  9.     Object getTarget();       //返回目标对象  
  10.     Object[] getArgs();       //返回被通知方法参数列表，也就是目前调用目标方法传入的参数  
  11.     Signature getSignature();  //返回当前连接点签名，这个可以用来获取目标方法的详细信息，如方法Method对象等
  12.     SourceLocation getSourceLocation();//返回连接点方法所在类文件中的位置  
  13.     String getKind();        //连接点类型  
  14.     StaticPart getStaticPart(); //返回连接点静态部分  
  15. }

ProceedingJoinPoint：环绕通知连接点信息

用于环绕通知，内部主要关注2个方法，一个有参的，一个无参的，用来继续执行拦截器链上的下一个通知。

  1. package org.aspectj.lang;
  2. import org.aspectj.runtime.internal.AroundClosure;
  4. public interface ProceedingJoinPoint extends JoinPoint {
  6.     /**
  7.      * 继续执行下一个通知或者目标方法的调用
  8.      */
  9.     public Object proceed() throws Throwable;
  11.     /**
  12.      * 继续执行下一个通知或者目标方法的调用
  13.      */
  14.     public Object proceed(Object[] args) throws Throwable;
  16. }

Signature：连接点签名信息

注意JoinPoint#getSignature()这个方法，用来获取连接点的签名信息，这个比较重要

  1. Signature getSignature();

通常情况，spring中的aop都是用来对方法进行拦截，所以通常情况下连接点都是一个具体的方法，Signature有个子接口

  1. org.aspectj.lang.reflect.MethodSignature

JoinPoint#getSignature()都可以转换转换为MethodSignature类型，然后可以通过这个接口提供的一些方法来获取被调用的方法的详细信息。

下面对上面的前置通知的案例改造一下，获取被调用方法的详细信息，新建一个Aspect类：BeforeAspect2

  1. package com.javacode2018.aop.demo10.test2;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.Signature;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.aspectj.lang.annotation.Before;
  7. import org.aspectj.lang.annotation.Pointcut;
  8. import org.aspectj.lang.reflect.MethodSignature;
  10. import java.lang.reflect.Method;
  12. @Aspect
  13. public class BeforeAspect2 {
  15.     @Pointcut("execution(* com.javacode2018.aop.demo10.test1.Service1.*(..))")
  16.     public void pc() {
  17.     }
  19.     @Before("com.javacode2018.aop.demo10.test2.BeforeAspect2.pc()")
  20.     public void before(JoinPoint joinPoint) {
  21.         //获取连接点签名
  22.         Signature signature = joinPoint.getSignature();
  23.         //将其转换为方法签名
  24.         MethodSignature methodSignature = (MethodSignature) signature;
  25.         //通过方法签名获取被调用的目标方法
  26.         Method method = methodSignature.getMethod();
  27.         //输出方法信息
  28.         System.out.println(method);
  29.     }
  30. }

测试用例

  1. @Test
  2. public void test2() {
  3.     Service1 target = new Service1();
  4.     Class<BeforeAspect2> aspectClass = BeforeAspect2.class;
  5.     AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
  6.     proxyFactory.setTarget(target);
  7.     proxyFactory.addAspect(aspectClass);
  8.     Service1 proxy = proxyFactory.getProxy();
  9.     System.out.println(proxy.say("路人"));
  10.     System.out.println(proxy.work("路人"));
  11. }

运行输出

  1. public java.lang.String com.javacode2018.aop.demo10.test1.Service1.say(java.lang.String)
  2. 你好：路人
  3. public java.lang.String com.javacode2018.aop.demo10.test1.Service1.work(java.lang.String)
  4. 开始工作了：路人

@Around：环绕通知

介绍

环绕通知会包裹目标目标方法的执行，可以在通知内部调用ProceedingJoinPoint.process方法继续执行下一个拦截器。

用起来和@Before类似，但是有2点不一样

  1. 若需要获取目标方法的信息，需要将ProceedingJoinPoint作为第一个参数
  2. 通常使用Object类型作为方法的返回值，返回值也可以为void

特点

环绕通知比较特殊，其他4种类型的通知都可以用环绕通知来实现。

案例

通过环绕通知来统计方法的耗时。

  1. package com.javacode2018.aop.demo10.test3;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.Signature;
  5. import org.aspectj.lang.annotation.Around;
  6. import org.aspectj.lang.annotation.Aspect;
  7. import org.aspectj.lang.annotation.Pointcut;
  8. import org.aspectj.lang.reflect.MethodSignature;
  10. import java.lang.reflect.Method;
  12. @Aspect
  13. public class AroundAspect3 {
  15.     @Pointcut("execution(* com.javacode2018.aop.demo10.test1.Service1.*(..))")
  16.     public void pc() {
  17.     }
  19.     @Around("com.javacode2018.aop.demo10.test3.AroundAspect3.pc()")
  20.     public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
  21.         //获取连接点签名
  22.         Signature signature = joinPoint.getSignature();
  23.         //将其转换为方法签名
  24.         MethodSignature methodSignature = (MethodSignature) signature;
  25.         //通过方法签名获取被调用的目标方法
  26.         Method method = methodSignature.getMethod();
  28.         long startTime = System.nanoTime();
  29.         //调用proceed方法，继续调用下一个通知
  30.         Object returnVal = joinPoint.proceed();
  31.         long endTime = System.nanoTime();
  32.         long costTime = endTime - startTime;
  33.         //输出方法信息
  34.         System.out.println(String.format("%s，耗时(纳秒)：%s", method.toString(), costTime));
  35.         //返回方法的返回值
  36.         return returnVal;
  37.     }
  38. }

测试用例

  1. @Test
  2. public void test3() {
  3.     Service1 target = new Service1();
  4.     Class<AroundAspect3> aspectClass = AroundAspect3.class;
  5.     AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
  6.     proxyFactory.setTarget(target);
  7.     proxyFactory.addAspect(aspectClass);
  8.     Service1 proxy = proxyFactory.getProxy();
  9.     System.out.println(proxy.say("路人"));
  10.     System.out.println(proxy.work("路人"));
  11. }

运行输出

  1. public java.lang.String com.javacode2018.aop.demo10.test1.Service1.say(java.lang.String)，耗时(纳秒)：19000500
  2. 你好：路人
  3. public java.lang.String com.javacode2018.aop.demo10.test1.Service1.work(java.lang.String)，耗时(纳秒)：59600
  4. 开始工作了：路人

对应的通知类

@Around通知最后会被解析为下面这个通知类

  1. org.springframework.aop.aspectj.AspectJAroundAdvice

@After：后置通知

介绍

后置通知，在方法执行之后执行，用法和前置通知类似。

特点

  • 不管目标方法是否有异常，后置通知都会执行
  • 这种通知无法获取方法返回值
  • 可以使用JoinPoint作为方法的第一个参数，用来获取连接点的信息

案例

在Service1中任意方法执行完毕之后，输出一行日志。

  1. package com.javacode2018.aop.demo10.test4;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.annotation.After;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.aspectj.lang.annotation.Pointcut;
  7. import org.aspectj.lang.reflect.MethodSignature;
  9. @Aspect
  10. public class AfterAspect4 {
  12.     @Pointcut("execution(* com.javacode2018.aop.demo10.test1.Service1.*(..))")
  13.     public void pc() {
  14.     }
  16.     @After("com.javacode2018.aop.demo10.test4.AfterAspect4.pc()")
  17.     public void after(JoinPoint joinPoint) throws Throwable {
  18.         MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
  19.         System.out.println(String.format("%s,执行完毕!", methodSignature.getMethod()));
  20.     }
  21. }

测试案例

  1. @Test
  2. public void test4() {
  3.     Service1 target = new Service1();
  4.     Class<AfterAspect4> aspectClass = AfterAspect4.class;
  5.     AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
  6.     proxyFactory.setTarget(target);
  7.     proxyFactory.addAspect(aspectClass);
  8.     Service1 proxy = proxyFactory.getProxy();
  9.     System.out.println(proxy.say("路人"));
  10.     System.out.println(proxy.work("路人"));
  11. }

运行输出

  1. public java.lang.String com.javacode2018.aop.demo10.test1.Service1.say(java.lang.String),执行完毕!
  2. 你好：路人
  3. public java.lang.String com.javacode2018.aop.demo10.test1.Service1.work(java.lang.String),执行完毕!
  4. 开始工作了：路人

对应的通知类

@After通知最后会被解析为下面这个通知类

  1. org.springframework.aop.aspectj.AspectJAfterAdvice

这个类中有invoke方法，这个方法内部会调用被通知的方法，其内部采用try..finally的方式实现的，所以不管目标方法是否有异常，通知一定会被执行。

  1. @Override
  2. public Object invoke(MethodInvocation mi) throws Throwable {
  3.     try {
  4.         //继续执行下一个拦截器
  5.         return mi.proceed();
  6.     }
  7.     finally {
  8.         //内部通过反射调用被@After标注的方法
  9.         invokeAdviceMethod(getJoinPointMatch(), null, null);
  10.     }
  11. }

@AfterReturning：返回通知

用法

返回通知，在方法返回结果之后执行。

特点

  • 可以获取到方法的返回值
  • 当目标方法返回异常的时候，这个通知不会被调用，这点和@After通知是有区别的

案例

后置通知中打印出方法及返回值信息。

  1. package com.javacode2018.aop.demo10.test5;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.annotation.AfterReturning;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.aspectj.lang.annotation.Pointcut;
  7. import org.aspectj.lang.reflect.MethodSignature;
  9. @Aspect
  10. public class AfterReturningAspect5 {
  11.     @Pointcut("execution(* com.javacode2018.aop.demo10.test1.Service1.*(..))")
  12.     public void pc() {
  13.     }
  15.     @AfterReturning(value = "com.javacode2018.aop.demo10.test5.AfterReturningAspect5.pc()", returning = "retVal")
  16.     public void afterReturning(JoinPoint joinPoint, Object retVal) throws Throwable {
  17.         MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
  18.         System.out.println(String.format("%s返回值：%s", methodSignature.getMethod(), retVal));
  19.     }
  21. }

注意@AfterReturning注解，用到了2个参数

  • value：用来指定切入点
  • returning：用来指定返回值对应方法的参数名称，返回值对应方法的第二个参数，名称为retVal

对应的通知类

@AfterReturning通知最后会被解析为下面这个通知类

  1. org.springframework.aop.aspectj.AspectJAfterReturningAdvice

@AfterThrowing：异常通知

用法

在方法抛出异常之后会回调@AfterThrowing标注的方法。

@AfterThrowing标注的方法可以指定异常的类型，当被调用的方法触发该异常及其子类型的异常之后，会触发异常方法的回调。也可以不指定异常类型，此时会匹配所有异常。

未指定异常类型

未指定异常类型，可以匹配所有异常类型，如下

  1. @AfterThrowing(value = "切入点")
  2. public void afterThrowing()

指定异常类型

通过@AfterThrowing的throwing指定参数异常参数名称，我们用方法的第二个参数用来接收异常，第二个参数名称为e，下面的代码，当目标方法发生IllegalArgumentException异常及其子类型异常时，下面的方法会被回调。

  1. @AfterThrowing(value = "com.javacode2018.aop.demo10.test6.AfterThrowingAspect6.pc()", throwing = "e")
  2. public void afterThrowing(JoinPoint joinPoint, IllegalArgumentException e)

特点

  • 不论异常是否被异常通知捕获，异常还会继续向外抛出。

案例

Service1中加了login方法，用户名不是路人甲java时抛出异常。

  1. package com.javacode2018.aop.demo10.test1;
  3. public class Service1 {
  4.     public String say(String name) {
  5.         return "你好：" + name;
  6.     }
  8.     public String work(String name) {
  9.         return "开始工作了：" + name;
  10.     }
  12.     public boolean login(String name) {
  13.         if (!"路人甲java".equals(name)) {
  14.             throw new IllegalArgumentException("非法访问!");
  15.         }
  16.         return true;
  17.     }
  18. }

来个异常通知

  1. package com.javacode2018.aop.demo10.test6;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.annotation.AfterReturning;
  5. import org.aspectj.lang.annotation.AfterThrowing;
  6. import org.aspectj.lang.annotation.Aspect;
  7. import org.aspectj.lang.annotation.Pointcut;
  8. import org.aspectj.lang.reflect.MethodSignature;
  10. @Aspect
  11. public class AfterThrowingAspect6 {
  12.     @Pointcut("execution(* com.javacode2018.aop.demo10.test1.Service1.*(..))")
  13.     public void pc() {
  14.     }
  16.     @AfterThrowing(value = "com.javacode2018.aop.demo10.test6.AfterThrowingAspect6.pc()", throwing = "e")
  17.     public void afterThrowing(JoinPoint joinPoint, IllegalArgumentException e) {
  18.         MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
  19.         System.out.println(String.format("%s发生异常,异常信息：%s", methodSignature.getMethod(), e.getMessage()));
  20.     }
  22. }

测试用例

  1. @Test
  2. public void test6() {
  3.     Service1 target = new Service1();
  4.     Class<AfterThrowingAspect6> aspectClass = AfterThrowingAspect6.class;
  5.     AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
  6.     proxyFactory.setTarget(target);
  7.     proxyFactory.addAspect(aspectClass);
  8.     Service1 proxy = proxyFactory.getProxy();
  9.     proxy.login("路人");
  10. }

运行输出

  1. public boolean com.javacode2018.aop.demo10.test1.Service1.login(java.lang.String)发生异常,异常信息：非法访问!
  3. java.lang.IllegalArgumentException: 非法访问!
  5.     at com.javacode2018.aop.demo10.test1.Service1.login(Service1.java:14)
  6.     at com.javacode2018.aop.demo10.test1.Service1$$FastClassBySpringCGLIB$$ea03ccbe.invoke(<generated>)
  7.     at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)
  8.     at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:769)

对应的通知类

@AfterThrowing通知最后会被解析为下面这个通知类

  1. org.springframework.aop.aspectj.AspectJAfterThrowingAdvice

来看一下这个类的invoke方法，这个方法是关键

  1. @Override
  2. public Object invoke(MethodInvocation mi) throws Throwable {
  3.     try {
  4.         //继续调用下一个拦截器链
  5.         return mi.proceed();
  6.     }
  7.     catch (Throwable ex) {
  8.         //判断ex和需要不糊的异常是否匹配
  9.         if (shouldInvokeOnThrowing(ex)) {
  10.             //通过反射调用@AfterThrowing标注的方法
  11.             invokeAdviceMethod(getJoinPointMatch(), null, ex);
  12.         }
  13.         //继续向外抛出异常
  14.         throw ex;
  15.     }
  16. }

几种通知对比

通知类型 执行时间点 可获取返回值 目标方法异常时是否会执行
@Before 方法执行之前 否 是
@Around 环绕方法执行 是 自己控制
@After 方法执行后 否 是
@AfterReturning 方法执行后 是 否
@AfterThrowing 方法发生异常后 否 是

案例源码

  1. https://gitee.com/javacode2018/spring-series

本博客所有系列案例代码以后都会放到这个上面，大家watch一下，可以持续关注动态。

最新资料

更多内容请访问：IT源点

注意：本文归作者所有，未经作者允许，不得转载

#Spring教程  |  SpringAOP专题
阅读全部
相关文章推荐
  • 1

全部评论: 0 条

    我有话说: