• Java开发学习----AOP通知获取数据（参数、返回值、异常）

    通知类型的时候总共讲了五种，那么对于这五种类型都会有参数，返回值和异常吗?

    我们先来一个个分析下:

    • 获取切入点方法的参数，所有的通知类型都可以获取参数

      • JoinPoint：适用于前置、后置、返回后、抛出异常后通知

      • ProceedingJoinPoint：适用于环绕通知

    • 获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无，所以不做研究

      • 返回后通知

      • 环绕通知

    • 获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无，所以不做研究

      • 抛出异常后通知

      • 环绕通知

    一、环境准备

    • 创建一个Maven项目

    • pom.xml添加Spring依赖

      1. <dependencies>
      2.     <dependency>
      3.       <groupId>org.springframeworkgroupId>
      4.       <artifactId>spring-contextartifactId>
      5.       <version>5.2.10.RELEASEversion>
      6.     dependency>
      7.     <dependency>
      8.       <groupId>org.aspectjgroupId>
      9.       <artifactId>aspectjweaverartifactId>
      10.       <version>1.9.4version>
      11.     dependency>
      12.   dependencies>

    • 添加BookDao和BookDaoImpl类

      1. public interface BookDao {
      2.     public String findName(int id);
      3. }
      4. @Repository
      5. public class BookDaoImpl implements BookDao {
      6. ​
      7.     public String findName(int id) {
      8.         System.out.println("id:"+id);
      9.         return "itcast";
      10.     }
      11. }

    • 创建Spring的配置类

      1. @Configuration
      2. @ComponentScan("com.itheima")
      3. @EnableAspectJAutoProxy
      4. public class SpringConfig {
      5. }

    • 编写通知类

      1. @Component
      2. @Aspect
      3. public class MyAdvice {
      4.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
      5.     private void pt(){}
      6. ​
      7.     @Before("pt()")
      8.     public void before() {
      9.         System.out.println("before advice ..." );
      10.     }
      11. ​
      12.     @After("pt()")
      13.     public void after() {
      14.         System.out.println("after advice ...");
      15.     }
      16. ​
      17.     @Around("pt()")
      18.     public Object around() throws Throwable{
      19.         Object ret = pjp.proceed();
      20.         return ret;
      21.     }
      22.     @AfterReturning("pt()")
      23.     public void afterReturning() {
      24.         System.out.println("afterReturning advice ...");
      25.     }
      26. ​
      27. ​
      28.     @AfterThrowing("pt()")
      29.     public void afterThrowing() {
      30.         System.out.println("afterThrowing advice ...");
      31.     }
      32. }

    • 编写App运行类

      1. public class App {
      2.     public static void main(String[] args) {
      3.         ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
      4.         BookDao bookDao = ctx.getBean(BookDao.class);
      5.         String name = bookDao.findName(100);
      6.         System.out.println(name);
      7.     }
      8. }

    最终创建好的项目结构如下:

    二、获取参数

    非环绕通知获取方式

    在方法上添加JoinPoint,通过JoinPoint来获取参数

    1. @Component
    2. @Aspect
    3. public class MyAdvice {
    4.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    5.     private void pt(){}
    6. ​
    7.     @Before("pt()")
    8.     public void before(JoinPoint jp) 
    9.         Object[] args = jp.getArgs();
    10.         System.out.println(Arrays.toString(args));
    11.         System.out.println("before advice ..." );
    12.     }
    13.     //...其他的略
    14. }

    运行App类，可以获取如下内容，说明参数100已经被获取

    思考:方法的参数只有一个，为什么获取的是一个数组?

    因为参数的个数是不固定的，所以使用数组更通配些。

    如果将参数改成两个会是什么效果呢?

    (1)修改BookDao接口和BookDaoImpl实现类

    1. public interface BookDao {
    2.     public String findName(int id,String password);
    3. }
    4. @Repository
    5. public class BookDaoImpl implements BookDao {
    6. ​
    7.     public String findName(int id,String password) {
    8.         System.out.println("id:"+id);
    9.         return "itcast";
    10.     }
    11. }

    (2)修改App类，调用方法传入多个参数

    1. public class App {
    2.     public static void main(String[] args) {
    3.         ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
    4.         BookDao bookDao = ctx.getBean(BookDao.class);
    5.         String name = bookDao.findName(100,"itheima");
    6.         System.out.println(name);
    7.     }
    8. }

    (3)运行App，查看结果,说明两个参数都已经被获取到

    说明:

    使用JoinPoint的方式获取参数适用于 前置 、 后置 、 返回后 、 抛出异常后 通知。

    环绕通知获取方式

    环绕通知使用的是ProceedingJoinPoint，因为ProceedingJoinPoint是JoinPoint类的子类，所以对于ProceedingJoinPoint类中应该也会有对应的 getArgs() 方法，我们去验证下:

    1. @Component
    2. @Aspect
    3. public class MyAdvice {
    4.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    5.     private void pt(){}
    6. ​
    7.     @Around("pt()")
    8.     public Object around(ProceedingJoinPoint pjp)throws Throwable {
    9.         Object[] args = pjp.getArgs();
    10.         System.out.println(Arrays.toString(args));
    11.         Object ret = pjp.proceed();
    12.         return ret;
    13.     }
    14.     //其他的略
    15. }

    运行App后查看运行结果，说明ProceedingJoinPoint也是可以通过getArgs()获取参数

    注意:

    • pjp.proceed()方法是有两个构造方法，分别是:

      • 调用无参数的proceed，当原始方法有参数，会在调用的过程中自动传入参数

      • 所以调用这两个方法的任意一个都可以完成功能

      • 但是当需要修改原始方法的参数时，就只能采用带有参数的方法,如下:

        1. @Component
        2. @Aspect
        3. public class MyAdvice {
        4.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
        5.     private void pt(){}
        6. ​
        7.     @Around("pt()")
        8.     public Object around(ProceedingJoinPoint pjp) throws Throwable{
        9.         Object[] args = pjp.getArgs();
        10.         System.out.println(Arrays.toString(args));
        11.         args[0] = 666;
        12.         Object ret = pjp.proceed(args);
        13.         return ret;
        14.     }
        15.     //其他的略
        16. }

        有了这个特性后，我们就可以在环绕通知中对原始方法的参数进行拦截过滤，避免由于参数的问题导致程序无法正确运行，保证代码的健壮性。

    三、获取返回值

    对于返回值，只有返回后 AfterReturing 和环绕 Around 这两个通知类型可以获取，具体如何获取?

    环绕通知获取返回值

    1. @Component
    2. @Aspect
    3. public class MyAdvice {
    4.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    5.     private void pt(){}
    6. ​
    7.     @Around("pt()")
    8.     public Object around(ProceedingJoinPoint pjp) throws Throwable{
    9.         Object[] args = pjp.getArgs();
    10.         System.out.println(Arrays.toString(args));
    11.         args[0] = 666;
    12.         Object ret = pjp.proceed(args);
    13.         return ret;
    14.     }
    15.     //其他的略
    16. }

    上述代码中， ret 就是方法的返回值，我们是可以直接获取，不但可以获取，如果需要还可以进行修改。

    返回后通知获取返回值

    1. @Component
    2. @Aspect
    3. public class MyAdvice {
    4.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    5.     private void pt(){}
    6. ​
    7.     @AfterReturning(value = "pt()",returning = "ret")
    8.     public void afterReturning(Object ret) {
    9.         System.out.println("afterReturning advice ..."+ret);
    10.     }
    11.     //其他的略
    12. }

    注意:

    (1)参数名的问题

    (2)afterReturning方法参数类型的问题

    参数类型可以写成String，但是为了能匹配更多的参数类型，建议写成Object类型

    (3)afterReturning方法参数的顺序问题

    运行App后查看运行结果，说明返回值已经被获取到

    四、获取异常

    对于获取抛出的异常，只有抛出异常后 AfterThrowing 和环绕 Around 这两个通知类型可以获取，具体如何获取?

    环绕通知获取异常

    这块比较简单，以前我们是抛出异常，现在只需要将异常捕获，就可以获取到原始方法的异常信息了

    1. @Component
    2. @Aspect
    3. public class MyAdvice {
    4.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    5.     private void pt(){}
    6. ​
    7.     @Around("pt()")
    8.     public Object around(ProceedingJoinPoint pjp){
    9.         Object[] args = pjp.getArgs();
    10.         System.out.println(Arrays.toString(args));
    11.         args[0] = 666;
    12.         Object ret = null;
    13.         try{
    14.             ret = pjp.proceed(args);
    15.         }catch(Throwable throwable){
    16.             t.printStackTrace();
    17.         }
    18.         return ret;
    19.     }
    20.     //其他的略
    21. }

    在catch方法中就可以获取到异常，至于获取到异常以后该如何处理，这个就和你的业务需求有关了。

    抛出异常后通知获取异常

    1. @Component
    2. @Aspect
    3. public class MyAdvice {
    4.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    5.     private void pt(){}
    6. ​
    7.     @AfterThrowing(value = "pt()",throwing = "t")
    8.     public void afterThrowing(Throwable t) {
    9.         System.out.println("afterThrowing advice ..."+t);
    10.     }
    11.     //其他的略
    12. }

    如何让原始方法抛出异常，方式有很多，

    1. @Repository
    2. public class BookDaoImpl implements BookDao {
    3. ​
    4.     public String findName(int id,String password) {
    5.         System.out.println("id:"+id);
    6.         if(true){
    7.             throw new NullPointerException();
    8.         }
    9.         return "itcast";
    10.     }
    11. }

    注意:

    运行App后，查看控制台，就能看的异常信息被打印到控制台

  • 相关阅读:
    Python也可以实现Excel中的“Vlookup”函数
    【附源码】计算机毕业设计SSM软考刷题系统
    HTTP——HTTP特性,缓存技术以及HTTP版本的演变
    Docker的交互式模式，你知道了吗？
    基于springboot的房屋租赁系统论文
    vue中使用base64编码上传文件或者图片,以及base64编码的图片在img标签中使用
    【前端】【探究】HTML - input类型为file时如何实现自定义文本以更好的美化
    react Hooks怎么用
    MQTT 协议概要
    Java复习最后一弹~~~
  • 原文地址：https://blog.csdn.net/Park33/article/details/126028462