前言

很多时候，我们会需要对方法的入参或者出参进行一些额外的处理，这时候使用AOP可以很好的满足我们的需求。因为AOP的侵入性较低，与业务逻辑的代码耦合度低，并且有较好的可重用性，开发效率较高。

下面摘抄一些关于AOP的介绍

AOP意为面向切面编程，AOP是通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

前提

在Spring Boot项目中使用aop，需要添加以下依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
 </dependency>

AOP增强入参和出参

如果我们要对入参和出参进行增强处理，那么需要使用的是Around环绕增强。

下面简单介绍下Around环绕的作用

Around环绕增强作用：可以在目标方法执行前织入增强动作，也可以在方法执行后织入增强动作，可以决定目标方法在什么时候执行，如何执行。可以改变目标的入参和返回值。

看了Around环绕增强的作用，我们可以看到Around环绕增强很适合我们处理目标方法的入参和出参

下面我就演示下Around环绕增强入参和出参的基本用法，大家可以参考进行自己的处理

@Aspect //定义切面类
@Component
public class ControllerAspect {
    
    

    /**
     * 定义切点
     */
    @Pointcut("execution(* com.example.demo2.controller.*.*(..))")
    public void point(){
    
    
    }

    /**
     * 定义环绕增强
     */
    @Around("point()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    
    
        //获取入参
        Object[] args = joinPoint.getArgs();
        //获取方法名
        System.out.println(joinPoint.getSignature().getName());
        //获取方法所在类的类名
        System.out.println(joinPoint.getSignature().getDeclaringType().getSimpleName());
        //对入参进行处理
        int i=0;
        if (ArrayUtils.isNotEmpty(args)){
    
    
            //入参为对象
            Params params=null;
            for (Object arg : args) {
    
    
                //String类型或者Integer等包装类，需要对入参数组进行重新赋值
                if (arg instanceof String){
    
    
                    args[i]="aop处理后的入参";
                }
                //对象类型的入参直接修改属性即可
                if (arg instanceof Params){
    
    
                    params= (Params) arg;
                    params.setName("aop处理后的入参对象");
                }
                i++;
            }
        }
        //传入入参执行方法
        Object response = joinPoint.proceed(args);
        //修改返回值
        if (response instanceof String){
    
    
            response="修改后的返回值";
        }
        //将返回值返回，方法的返回值是around的返回值，而不是原来的返回值
        return response;
    }
}

下面概括下AOP修改方法入参和出参的大体过程

修改入参
1、通过ProceedingJoinPoint获取原来的入参

2、对原入参进行增强处理

3、将入参传入ProceedingJoinPoint的proceed，执行方法，这时候方法就相当于是用增强后的入参执行方法

修改出参
1、接收proceed方法的返回值，这就是方法初始的返回值

2、对初始返回值进行增强处理

3、返回增强后的返回值，被around环绕的方法，它的出参是around方法的返回值，而不一定是方法的原返回值，这就是我们能对返回值进行增强处理的本质

测试类：

@Controller
@RestController
public class TestController {
    
    


    @PostMapping(value = "testAop")
    public String testAop(String userName, Params params)throws Exception{
    
    
        System.out.println("入参为:  "+userName);
        System.out.println("入参对象为： "+params);
        return "正常返回值";
    }
}

调用后输出：

testAop
TestController
入参为:  aop处理后的入参
入参对象为： Params(name=aop处理后的入参对象)
修改后的返回值

通过结果，我们可以看到AOP已经对方法的入参和出参进行了处理