SpringBoot AOP使用

AOP即面向切面编程，其存在的目的就是为了解耦，通过AOP的实现，可以让业务逻辑只关心业务本身，而不用在意其他的事情，无需改动原有代码，实现无侵入增加部分能力。在系统日志处理、系统事务处理、系统安全验证、系统数据验证等多个场景中都有可能使用到。
在关于AOP的描述中，有如下几个比较重要的概念：
通知：Advice，给目标方法添加额外操作步骤，即拦截到连接点之后要执行的方法
连接点：JoinPoint，可以添加额外步骤的地方，基本上每个方法前后都可以是连接点
切面：Aspect，横切面对象，即通知和切点的结合，是封装了通知和切入点用来横向插入的类，也可理解为要植入的新的功能的类
切点：PointCut，筛选部分连接点作为切点，程序执行过程中某个特点的点，也就是实际需要添加额外步骤的地方
目标对象：Target，需要额外添加操作步骤的对象（业务逻辑）
代理对象：Proxy，负责调用切面中的方法为目标对象植入新的功能
织入：Weaving，把切面加入程序代码的过程，切面在指定的连接点被织入到目标对象中

举一个简单的栗子来说

public class TestService {

    void funcA() {};

    void funcB() {}
}

TestService中的所有方法都是连接点(JoinPoint)，其中某个方法亦可称之为切点，如funcA方法就可以成为一个切点(PointCut)。需要在funcA方法前后执行方法就是通知(Advice)。funcA方法就是目标对象(Target)，把切面中想要增加的代码加入到funcA方法的前后就是织入(Weaving)。

AOP常用通知注解

@PointCut：定义切入点
@Before：在目标方法开始执行前执行
@After：在目标方法执行后执行，无论目标方法成功与否，但是不能访问目标方法的返回结果
@AfterReturning：在目标方法有返回值正常返回后执行
@AfterThrowing：在目标方法抛出异常时执行
@Around：环绕通知，可以获取到目标方法到入参和返回值，在方法执行前和执行后都会执行

使用方法

引入依赖

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

定义切面

@Aspect
@Component
public class MyLogAspect { }

使用@Aspect和@Component便可简单的定义一个切面

定义切入点

切入点定义有如下三种方式

beanId方式

@Pointcut("bean(appController)")
public void pointCut() {}

execution方式

@Pointcut("execution(public * com.example.demo.Service..*.*(..))")
public void pointCut() {}

execution中是AspectJ表达式，其大概的含义为
• 第一个* 代表任意的返回值
• com.example.demo.Service表示横切的包名
• 包后面… 表示当前包及其子包
• 第二个* 表示类名，代表所有类
• .*(…) 表示任何方法,括号代表参数 … 表示任意参数

注解annonation方式

@Pointcut("@annotation(com.example.demo.meta.myAnnotation)")
public void pointCut() {}

使用注解的形式时，可自定义注解来实现切入点的定义，个人还是比较喜欢用注解的方式来实现的。

注解使用

注解在使用切入点时，可直接传入定义该切入点的方法名即可

@Before、@After

@Before定义在具体的业务逻辑执行前执行的通知，@After定义在具体的业务逻辑执行后执行的通知，看到网上有文章指出可以通过@Before来实现业务逻辑执行方法输入参数的修改，但我试了下并不可行，不知道是哪里写的不对，还是咋的。
需要特别指出的是@After无法获取到业务逻辑处理的返回值。
同时，@Before和@After注解的方法都需要携带一个JoinPoint类型的参数。

// 目标方法执行前前的方法
@Before("myPointCut()")
public void before(JoinPoint point) {
    System.out.println("目标方法执行之前...");
}

// 目标方法执行后的方法
@After("myPointCut()")
public void after(JoinPoint point) {
    System.out.println("目标方法执行之后...");
}

@AfterReturning

根据名字就可以很清楚的知道，该注解可以获取到业务逻辑处理后的返回值，因此可以根据需要，对返回值进行修改。
此外，@AfterReturning注解在使用时，需严格根据要求传入value和returning两个变量，其中value为定义的切入点，returning 标识目标业务逻辑的返回值自定义变量名必须和通知方法的形参一样。

@AfterReturning(value = "myPointCut()",returning = "result")
public void afterReturn(JoinPoint point, Object result) {
    System.out.println("实际方法返回后执行...");
    processOutPutObj(result);
}

@AfterThrowing

其主要能力和@AfterReturning差不多，区别在于该注解是在目标业务逻辑抛出异常时执行的通知，并且可以获得目标业务逻辑所抛出的具体的异常信息，其在使用时也需要在注解中传入value和throwing的值。

@AfterThrowing(value = "myPointCut()", throwing = "ex")
public void afterThrowing(JoinPoint point, Exception ex) {
    System.out.println("实际方法抛出异常...");
    System.out.println("异常信息:" + ex.getMessage());
}

@Around

由于@Around贯穿于业务方法执行之前和之后，因此在实际使用中，仅使用@Around便可实现我们大多数想要附加的内容，比如，根据用户输入的参数是否含有敏感词来过滤，或者根据返回结果是否加密来决定是否返回等。通过@Around可同时对输入参数和返回值进行修改。
需要注意的是@Around注解下的方法需要带有ProceedingJoinPoint类型的参数，通过该参数来决定是否可以执行目标业务逻辑，并且其必须要有返回值，返回值即为具体目标业务逻辑的返回值。

@Around("myPointCut()") // 环绕通知，在方法执行前和执行后都会执行
public Object around(ProceedingJoinPoint point) {
    System.out.println("切点【环绕通知】开始执行...");
    Object result = null;
    long beginTime = System.currentTimeMillis();
    try {
        // 处理输入参数
        Object[] args = point.getArgs();
        processInputObj(args);
        // 执行方法
        // 可以决定是否执行目标方法
        result = point.proceed(args);
        // 处理返回值
        processOutPutObj(result);
    } catch (Throwable e) {
        e.printStackTrace();
    }
    long time = System.currentTimeMillis() - beginTime;
    // 具体的额外操作方法
    processing(point, time);
    System.out.println("切点【环绕通知】执行结束...");
    return result;
}

切面的全部代码：

package com.example.demo.aop;

import com.alibaba.fastjson.JSONObject;
import com.example.demo.entity.SysLog;
import com.example.demo.entity.User;
import com.example.demo.meta.MyLog;
import com.example.demo.util.HttpContextUtils;
import com.example.demo.util.IPUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Date;

/**
 * Description:
 *
 * @date:2021/11/14 12:54
 * @author: lyf
 */
// 定义切面
@Aspect
@Component
public class MyLogAspect {

//    @Pointcut("bean(appController)")
//    public void pointCut() {}
//
//    @Pointcut("execution(public * com.example.demo.Service..*.*(..))")
//    public void pointCut() {}
//
//    @Pointcut("@annotation(com.example.demo.meta.myAnnotation)")
//    public void pointCut() {}

    // 定义切点  切点的定义有多种方式
    // 这边使用的是注解的方式
    @Pointcut("@annotation(com.example.demo.meta.MyLog)")
    public void myPointCut() {}

    // 目标方法执行前前的方法
//    @Before("myPointCut()")
    public void before(JoinPoint point) {
        System.out.println("目标方法执行之前...");
    }

    // 目标方法执行后的方法
//    @After("myPointCut()")
    public void after(JoinPoint point) {
        System.out.println("目标方法执行之后...");
    }

//    @AfterReturning(value = "myPointCut()",returning = "result")
    public void afterReturn(JoinPoint point, Object result) {
        System.out.println("实际方法返回后执行...");
        processOutPutObj(result);
    }

//    @AfterThrowing(value = "myPointCut()", throwing = "ex")
    public void afterThrowing(JoinPoint point, Exception ex) {
        System.out.println("实际方法抛出异常...");
        System.out.println("异常信息:" + ex.getMessage());
    }

    @Around("myPointCut()") // 环绕通知，在方法执行前和执行后都会执行
    public Object around(ProceedingJoinPoint point) {
        System.out.println("切点【环绕通知】开始执行...");
        Object result = null;
        long beginTime = System.currentTimeMillis();
        try {
            // 处理输入参数
            Object[] args = point.getArgs();
            processInputObj(args);
            // 执行方法
            // 可以决定是否执行目标方法
            result = point.proceed(args);
            long time = System.currentTimeMillis() - beginTime;
            // 具体的额外操作方法
            processing(point, time);
            // 处理返回值
            processOutPutObj(result);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("切点【环绕通知】执行结束...");
        return result;
    }


    /**
     * 处理输入参数
     * @param args
     */
    private Object[] processInputObj(Object[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("arg原来的值为：" + args[i]);
            args[i] = "被aop修改的name";
        }
        return args;
    }

    /**
     * 处理返回对象
     * @param obj
     */
    private void processOutPutObj(Object obj) {
        System.out.println("OBJ 原本为：" + obj.toString());
        if (obj instanceof User) {
            User user = (User) obj;
            user.setDesc("哈哈，我被aop改了");
        }
    }


    private SysLog processing(ProceedingJoinPoint joinPoint, long time) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        SysLog sysLog = new SysLog();
        MyLog logAnnotation = method.getAnnotation(MyLog.class); // 获取方法上的注解
        if (logAnnotation != null) {
            // 注解上的描述
            sysLog.setOperation(logAnnotation.value());
        }
        // 请求的方法名
        String className = joinPoint.getTarget().getClass().getName(); // target
        String methodName = signature.getName();
        sysLog.setMethod(className + "." + methodName + "()");
        // 请求的方法参数
        Object[] args = joinPoint.getArgs();
        // 请求的方法参数名称
        LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
        String[] paramNames = u.getParameterNames(method);
        if (args != null && paramNames != null) {
            String params = "";
            for (int i = 0; i < args.length; i++) {
                params += "  " + paramNames[i] + ": " + args[i];
            }
            sysLog.setParams(params);
        }
        // 获取request
        HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
        // 设置ip地址
        sysLog.setIp(IPUtils.getIpAddr(request));
        // 模拟一个用户
        sysLog.setUserName("test");
        sysLog.setTime((int) time);
        sysLog.setCreatTime(new Date());
        System.out.println(JSONObject.toJSONString(sysLog));
        return sysLog;
        // 这边可以实现存入数据库的操作
    }
}

参考文章：
[1] https://www.jianshu.com/p/4d22ea402d14
[2] https://www.jianshu.com/p/a7c150458e2c
[3] https://blog.csdn.net/puhaiyang/article/details/78146620