spring aop 获取方法参数 spring aop获取返回值

目前我们写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);

    }
}

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

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已经被获取

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

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

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

(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，查看结果,说明两个参数都已经被获取到

说明:

使用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()获取参数

注意:

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

• 调用无参数的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;
    }
}

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

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)参数名的问题

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

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

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

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

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;
    }
}

注意:

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

至此，AOP通知如何获取数据就已经介绍完了，数据中包含参数、返回值、异常(了解)。