Spring项目AOP通知获取数据

落日映苍穹つ 2024-04-01 12:09 29阅读 0赞

目前我们写AOP仅仅是在原始方法前后追加一些操作，接下来我们要说说AOP中数据相关的内容，我们将从`获取参数`、`获取返回值`和`获取异常`三个方面来研究切入点的相关信息。

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

我们先来一个个分析下:

*  获取切入点方法的参数，所有的通知类型都可以获取参数
    
     *  JoinPoint：适用于前置、后置、返回后、抛出异常后通知
     *  ProceedingJoinPoint：适用于环绕通知
 *  获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无，所以不做研究
    
     *  返回后通知
     *  环绕通知
 *  获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无，所以不做研究
    
     *  抛出异常后通知
     *  环绕通知

### 1. 环境准备 ###

*  创建一个Maven项目
 *  pom.xml添加Spring依赖
    
        <dependencies>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                    <version>5.2.15.RELEASE</version>
                </dependency>
                <dependency>
                    <groupId>org.aspectj</groupId>
                    <artifactId>aspectjweaver</artifactId>
                    <version>1.9.6</version>
                </dependency>
            </dependencies>
 *  添加UserDao和UserDaoImpl类
    
        public interface UserDao {
              
            public String userInfoById(Integer id);
        }
        
        @Repository
        public class UserDaoImpl implements UserDao {
              
            public String userInfoById(Integer id) {
              
                System.out.println("user id = " + id);
                return "xiaochuang";
            }
        }
 *  创建Spring的配置类
    
        @Configuration
        @ComponentScan("com.dcxuexi")
        @EnableAspectJAutoProxy
        public class SpringConfig {
              
        }
 *  编写通知类
    
        @Component
        @Aspect
        public class UserAdvice {
              
            @Pointcut("execution(* com.dcxuexi.dao.UserDao.userInfoById(..))")
            public void ptUserDaoMethod(){
              }
        
            @Before("ptUserDaoMethod()")
            public void before(){
              
                System.out.println("UserAdvice before ......");
            }
        
            @After("ptUserDaoMethod()")
            public void after(){
              
                System.out.println("UserAdvice after ......");
            }
        
            @Around("ptUserDaoMethod()")
            public Object around(ProceedingJoinPoint point) throws Throwable {
              
                Object proceed = point.proceed();
                return proceed;
            }
        
            @AfterReturning("ptUserDaoMethod()")
            public void afterReturning(){
              
                System.out.println("UserAdvice AfterReturning ......");
            }
        
            @AfterThrowing("ptUserDaoMethod()")
            public void afterThrowing(){
              
                System.out.println("UserAdvice AfterThrowing ......");
            }
        
        
        }
 *  编写SpringAopAdviceData运行类
    
        public class SpringAopAdviceData {
              
            public static void main(String[] args) {
              
                ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
                UserDao userDao = context.getBean(UserDao.class);
                String userInfo = userDao.userInfoById(10);
                System.out.println("用户信息 ：" + userInfo);
        
            }
        }

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

![在这里插入图片描述][7797a64898d9414a8512e3a12822722f.png_pic_center]

### 2. 获取参数 ###

#### 非环绕通知获取方式 ####

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

@Component
    @Aspect
    public class UserAdvice {
        
        @Pointcut("execution(* com.dcxuexi.dao.UserDao.userInfoById(..))")
        public void ptUserDaoMethod(){
        }
    
        @Before("ptUserDaoMethod()")
        public void before(JoinPoint joinPoint){
        
            System.out.println("UserAdvice before , 开始 ......");
            Object[] args = joinPoint.getArgs();
            System.out.println(Arrays.toString(args));
            System.out.println("UserAdvice before  , 结束......");
        }
    
        @After("ptUserDaoMethod()")
        public void after(JoinPoint joinPoint){
        
            System.out.println("UserAdvice after , 开始  ......");
            Object[] args = joinPoint.getArgs();
            System.out.println(Arrays.toString(args));
            System.out.println("UserAdvice after  , 结束......");
        }
    
        @AfterReturning("ptUserDaoMethod()")
        public void afterReturning(JoinPoint joinPoint){
        
            System.out.println("UserAdvice AfterReturning , 开始  ......");
            Object[] args = joinPoint.getArgs();
            System.out.println(Arrays.toString(args));
            System.out.println("UserAdvice AfterReturning  , 结束......");
        }
    
        @AfterThrowing("ptUserDaoMethod()")
        public void afterThrowing(JoinPoint joinPoint){
        
            System.out.println("UserAdvice AfterThrowing , 开始  ......");
            Object[] args = joinPoint.getArgs();
            System.out.println(Arrays.toString(args));
            System.out.println("UserAdvice AfterThrowing  , 结束......");
        }
    }

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

![在这里插入图片描述][165e58a2b68b479abdf8d3f666ac3312.png_pic_center]

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

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

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

(1)修改UserDao接口和UserDaoImpl实现类

public interface UserDao {
        
        public String userInfoById(Integer id, String name);
    }
    
    @Repository
    public class UserDaoImpl implements UserDao {
        
        public String userInfoById(Integer id,String name) {
        
            System.out.println("user id = " + id + " , name = "+ name);
            return "id = " + id + " , name = "+ name;
        }
    }

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

public class SpringAopAdviceData {
        
        public static void main(String[] args) {
        
            ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
            UserDao userDao = context.getBean(UserDao.class);
            String userInfo = userDao.userInfoById(10,"zhangsan");
            System.out.println("用户信息 ：" + userInfo);
    
        }
    }

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

![在这里插入图片描述][feb9e496d9da469e878864e00cb8d515.png_pic_center]

**说明:**

使用JoinPoint的方式获取参数适用于`前置`、`后置`、`返回后`、`抛出异常后`通知。剩下的大家自行去验证。

#### 环绕通知获取方式 ####

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

@Component
    @Aspect
    public class UserAdvice {
        
        @Pointcut("execution(* com.dcxuexi.dao.UserDao.userInfoById(..))")
        public void ptUserDaoMethod(){
        }
    
        @Around("ptUserDaoMethod()")
        public Object around(ProceedingJoinPoint point) throws Throwable {
        
            System.out.println("UserAdvice around , 开始 ......");
            Object[] args = point.getArgs();
            System.out.println(Arrays.toString(args));
            Object proceed = point.proceed();
            System.out.println("UserAdvice around  , 结束......");
            return proceed;
        }
    }

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

![在这里插入图片描述][1b1344ab442849ddad3130b14ff79afb.png_pic_center]

**注意:**

*  pjp.proceed()方法是有两个构造方法，分别是:
    
    ![在这里插入图片描述][5be1f00bced44c14a9c727351d17d4b4.png_pic_center]
    
     *  调用无参数的proceed，当原始方法有参数，会在调用的过程中自动传入参数
     *  所以调用这两个方法的任意一个都可以完成功能
     *  但是当需要修改原始方法的参数时，就只能采用带有参数的方法,如下:
        
            @Component
            @Aspect
            public class UserAdvice {
                    
                @Pointcut("execution(* com.dcxuexi.dao.UserDao.userInfoById(..))")
                public void ptUserDaoMethod(){
                    }
            
                @Around("ptUserDaoMethod()")
                public Object around(ProceedingJoinPoint point) throws Throwable {
                    
                    System.out.println("UserAdvice around , 开始 ......");
                    Object[] args = point.getArgs();
                    System.out.println(Arrays.toString(args));
                    args[1] = "lisi";
                    Object proceed = point.proceed(args);
                    System.out.println("UserAdvice around  , 结束......");
                    return proceed;
                }
            }
        
        ![在这里插入图片描述][585e25b0bcdc4d749978a8aef2efad25.png_pic_center]
        
        有了这个特性后，我们就可以在环绕通知中对原始方法的参数进行拦截过滤，避免由于参数的问题导致程序无法正确运行，保证代码的健壮性。

### 3. 获取返回值 ###

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

#### 环绕通知获取返回值 ####

@Component
    @Aspect
    public class UserAdvice {
        
        @Pointcut("execution(* com.dcxuexi.dao.UserDao.userInfoById(..))")
        public void ptUserDaoMethod(){
        }
    
        @Around("ptUserDaoMethod()")
        public Object around(ProceedingJoinPoint point) throws Throwable {
        
            System.out.println("UserAdvice around , 开始 ......");
            Object[] args = point.getArgs();
            System.out.println(Arrays.toString(args));
            args[1] = "lisi";
            Object proceed = point.proceed(args);
            System.out.println("UserAdvice around  , 结束......");
            return proceed;
        }
    }

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

#### 返回后通知获取返回值 ####

@Component
    @Aspect
    public class UserAdvice {
        
        @Pointcut("execution(* com.dcxuexi.dao.UserDao.userInfoById(..))")
        public void ptUserDaoMethod(){
        }
    
        @AfterReturning(value = "ptUserDaoMethod()" ,returning = "ret")
        public void afterReturning(Object ret){
        
            System.out.println("UserAdvice AfterReturning , 开始  ......");
            System.out.println(ret);
            System.out.println("UserAdvice AfterReturning  , 结束......");
        }
    }

注意:

(1)参数名的问题

![在这里插入图片描述][dab317a3c69b4200901489cde3debe13.png_pic_center]

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

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

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

![在这里插入图片描述][1d0e8b0c2aca481480123fef51a61d1c.png_pic_center]

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

![在这里插入图片描述][8e36915d3b01436a9d1e15ba9304cefc.png_pic_center]

### 4. 获取异常 ###

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

#### 环绕通知获取异常 ####

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

@Component
    @Aspect
    public class UserAdvice {
        
        @Pointcut("execution(* com.dcxuexi.dao.UserDao.userInfoById(..))")
        public void ptUserDaoMethod(){
        }
    
        @Around("ptUserDaoMethod()")
        public Object around(ProceedingJoinPoint point){
        
            Object[] args = point.getArgs();
            System.out.println(Arrays.toString(args));
            args[1] = "lisi";
            Object ret = null;
            try{
        
                ret = point.proceed(args);
            }catch(Throwable t){
        
                t.printStackTrace();
            }
            return ret;
        }
    }

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

#### 抛出异常后通知获取异常 ####

@Component
    @Aspect
    public class UserAdvice {
        
        @Pointcut("execution(* com.dcxuexi.dao.UserDao.userInfoById(..))")
        public void ptUserDaoMethod(){
        }
    
        @AfterThrowing(value = "ptUserDaoMethod()",throwing = "t")
        public void afterThrowing(JoinPoint joinPoint,Throwable t){
        
            System.out.println("UserAdvice AfterThrowing , 开始  ......");
            Object[] args = joinPoint.getArgs();
            System.out.println(Arrays.toString(args));
            System.out.println("-----");
            System.out.println(t);
            System.out.println("UserAdvice AfterThrowing  , 结束......");
        }
    }

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

@Repository
    public class UserDaoImpl implements UserDao {
        
        public String userInfoById(Integer id,String name) {
        
            System.out.println("user id = " + id + " , name = "+ name);
    
            throw  new NullPointerException(); // 抛出异常
            
            //return "id = " + id + " , name = "+ name;
        }
    }

注意:

![在这里插入图片描述][e1c1b3ad10cc49afbcdd21f07d1c4d97.png_pic_center]

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

![在这里插入图片描述][502218831ec64e5c91083e5e7adce3fc.png_pic_center]  
至此，AOP通知如何获取数据就已经介绍完了，数据中包含`参数`、`返回值`、`异常(了解)`。

### 项目代码 ###

*  [gitee 代码下载][gitee]
 *  [github 代码下载][github]

[7797a64898d9414a8512e3a12822722f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/9220f6c64ec344dd8390dd44642e9be9.png
[165e58a2b68b479abdf8d3f666ac3312.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/6c7b40cf38d14fad900cedb5fde73b29.png
[feb9e496d9da469e878864e00cb8d515.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f160a3930a1b4bcfa2848b51b18b26ee.png
[1b1344ab442849ddad3130b14ff79afb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/7ecf99dd7d51492a81353cb394030764.png
[5be1f00bced44c14a9c727351d17d4b4.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/00cbd57c293f4831a1200b66ac28db96.png
[585e25b0bcdc4d749978a8aef2efad25.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/453cd6ca3ce2495d981d79d1300dfdfe.png
[dab317a3c69b4200901489cde3debe13.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/b4a362801b8644b9a5a5440a26543c4c.png
[1d0e8b0c2aca481480123fef51a61d1c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/066966e85f3a40f3a15a37303404f4f5.png
[8e36915d3b01436a9d1e15ba9304cefc.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f767f7d80e0b4e929dd2fd286099df77.png
[e1c1b3ad10cc49afbcdd21f07d1c4d97.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/a07ba0fbcf874cd48eba21d71fbe923e.png
[502218831ec64e5c91083e5e7adce3fc.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/735f147c78684eeaa174fc13a13019a8.png
[gitee]: https://gitee.com/DchuangDB/sping-projeck
[github]: https://github.com/dcbut/spring