切面编程#

浅聊AOP#

当我第一次接触Spring框架的时候，就告诉我们 IOC（控制反转）和 AOP（面向切面编程）这两个最核心的知识点，IOC 作为我们工作中最经常使用的知识点大家肯定是烂熟于心，而一聊到 AOP ，脑海中想到的只有零零散散的面试题，和一些日志、缓存、事务、安全、权限等功能场景，这些场景确实主要在项目搭建阶段就已经搭建完毕了，这也导致我们很少在工作中接触到它。其实学习使用 AOP 是相对简单的，我们需要先知道以下几个核心概念：

切面：一个关注点的模块化，这个关注点可能会横切多个对象。
连接点：程序执行过程中明确的点，如方法调用或异常处理器。
切点：指定一个或多个连接点，切面在这些点上执行它的操作。
通知：切面在特定连接点上执行的操作，有 before、after、around、afterThrowing 和 afterReturning 等类型。
织入：将切面应用到目标对象来创建新的代理对象的过程。

通过这些概念我们也可以看出来，AOP 的基本思想是将这些横切关注点与系统的核心业务逻辑分离开来，通过定义一个切面（Aspect）来包含这些关注点，然后在系统运行时，动态地将切面织入到核心业务逻辑中。

AOP 是一种编程范式，是一种思想，用于解决横切关注点的模块化问题。我们常用的 AspectJ 则是基于 Java 的 AOP 框架，提供了实现 AOP 概念的语法和工具。

工作中使用到 AOP 的例子#

自定义日志注解#

最经典的切面应用场景，为了更加灵活和方便的查看每个方法和请求的出参入参，我们可以使用自定义注解的方式指定需要打印的方法或者类。

首先定义打印信息。

1
@Data
2
public class ILogPrintDTO {
3

4
    /**
5
     * 开始时间
6
     */
7
    private String beginTime;
8

9
    /**
10
     * 请求入参
11
     */
12
    private Object[] inputParams;
13

14
    /**
15
     * 返回参数
16
     */
17
    private Object outputParams;
18
}

定义日志注解，作用域为方法或类，并在运行时生效。

1
@Target({ElementType.TYPE, ElementType.METHOD})
2
@Retention(RetentionPolicy.RUNTIME)
3
public @interface ILog {
4

5
    /**
6
     * 是否需要打印入参
7
     *
8
     * @return 入参打印是否打印
9
     */
10
    boolean input() default true;
11

12
    /**
13
     * 是否需要打印出参
14
     *
15
     * @return 出参打印是否打印
16
     */
17
    boolean output() default true;
18
}

定义切面

1
@Aspect
2
public class ILogPrintAspect {
3

4
    @Pointcut("@within(com.sbc.log.annotation.ILog) || @annotation(com.sbc.log.annotation.ILog)")
5
    public void pointcut() {
6
    }
7

8
    @Around("pointcut()")
9
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
10
        long startTime = SystemClock.now();
11
        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
12
        Logger log = LoggerFactory.getLogger(methodSignature.getDeclaringType());
13
        String beginTime = DateUtil.now();
14
        Object result = null;
15
        try {
16
            result = pjp.proceed();
17
        } finally {
18
            Method targetMethod = pjp.getTarget().getClass().getDeclaredMethod(methodSignature.getName(), methodSignature.getMethod().getParameterTypes());
19
            ILog logAnnotation = Optional.ofNullable(targetMethod.getAnnotation(ILog.class)).orElse(pjp.getTarget().getClass().getAnnotation(ILog.class));
20
            if (logAnnotation != null) {
21
                ILogPrintDTO logPrint = new ILogPrintDTO();
22
                logPrint.setBeginTime(beginTime);
23
                if (logAnnotation.input()) {
24
                    logPrint.setInputParams(buildInput(pjp));
25
                }
26
                if (logAnnotation.output()) {
27
                    logPrint.setOutputParams(result);
28
                }
29
                String methodType = "", requestURI = "";
30
                try {
31
                    ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
32
                    assert servletRequestAttributes != null;
33
                    methodType = servletRequestAttributes.getRequest().getMethod();
34
                    requestURI = servletRequestAttributes.getRequest().getRequestURI();
35
                } catch (Exception ignored) {
36
                }
37
                log.info("[{}] {}, executeTime: {}ms, info: {}", methodType, requestURI, SystemClock.now() - startTime, JSON.toJSONString(logPrint));
38
            }
39
        }
40
        return result;
41
    }
42

43
    private Object[] buildInput(ProceedingJoinPoint pjp) {
44
        Object[] args = pjp.getArgs();
45
        Object[] printArgs = new Object[args.length];
46
        for (int i = 0; i < args.length; i++) {
47
            if ((args[i] instanceof HttpServletRequest) || args[i] instanceof HttpServletResponse) {
48
                continue;
49
            }
50
            if (args[i] instanceof byte[]) {
51
                printArgs[i] = "byte array";
52
            } else if (args[i] instanceof MultipartFile) {
53
                printArgs[i] = "file";
54
            } else {
55
                printArgs[i] = args[i];
56
            }
57
        }
58
        return printArgs;
59
    }
60
}

创建配置类

1
@Configuration
2
public class LogAutoConfiguration {
3

4
    /**
5
     * 日志打印 AOP 切面
6
     */
7
    @Bean
8
    public ILogPrintAspect iLogPrintAspect() {
9
        return new ILogPrintAspect();
10
    }
11
}

返回对象脱敏#

最近公司开始要求对客户信息的保密性进行加强，需要我们将日志和前台界面的客户信息进行加密处理，由于我们项目的日志五花八门，而且使用的架构也不尽相同，所以日志脱敏的解决办法就是开发一个脱敏工具类，同时将脱敏需要的依赖打包成 jar 添加到每个项目中去，检索项目中所有打印日志的语句，统一加上工具类中的脱敏方法，听起来这就是个感人的工作。其次是前台界面客户信息脱敏，因为我们大部分项目都是纯后台，所以负责这个任务的工作就落到了我另一个同事头上，当他在和我讨论这个实现的时候和我说了一下他的思路：我们后台需要做的就是把传递给前台的 vo 中的敏感信息过滤，如果每个 vo 对象都要过滤那简直是天方夜谭，于是他想将所有 controller 中的方法作为切点增加个切面，拿到每个方法返回值判断 vo 并进行过滤。下面我拿 demo 来演示一下：

首先我们先模拟一个 controller 返回前台一个 vo：

1
@GetMapping("/test/vo")
2
public UserVo testReturnVo() {
3
    return UserVo.builder()
4
            .id(IdUtil.getSnowflakeNextId())
5
            .email("recipient@example.com")
6
            .firstName("baicheng")
7
            .lastName("song")
8
            .phoneNumber("12345678912")
9
            .username("songbaicheng")
10
            .build();
11
}
12

13
@Data
14
@Builder
15
public class UserVo {
16
    private Long id;
17
    private String username;
18
    private String email;
19
    private String firstName;
20
    private String lastName;
21
    private String phoneNumber;
22
}

接下来新增切面，把要处理返回值的方法作为切点托管。这里有两种方式，分别是在 @Around 和 @AfterReturning 中进行操作，如果我们只是操作返回值，则推荐使用 @AfterReturning 中获取入参中的返回值项进行修改，如果有其他更复杂的操作，则可以在 @Around 的 ProceedingJoinPoint 获取更多的钩子进行操作。而且值得注意的是如果这里同时使用两个方法的话，是先执行 @AfterReturning 再执行 @Around。

1
@Slf4j
2
@Aspect
3
@Component
4
public class TestReturnVoAspect {
5

6
    // 如果用切点表达式力度太大或者不够灵活的时候，可以使用自定义注解的方式代替切点表达：
7
    // @Pointcut("@annotation(com.example.CustomAnnotation)")
8
    @Pointcut("execution(* com.sbc.springbootmoudle.controller.HelloController.testReturnVo(..))")
9
    public void servicePointcut() {
10
    }
11

12
    /**
13
        方法一
14
     */
15
    @Around("servicePointcut()")
16
    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
17

18
        // 获取方法返回值
19
        Object result = pjp.proceed();
20

21
        if (result instanceof UserVo) {
22

23
            // 模拟脱敏操作
24
            return  UserVo.builder()
25
                    .id(IdUtil.getSnowflakeNextId())
26
                    .email("**********@example.com")
27
                    .firstName("ba****ng")
28
                    .lastName("s**g")
29
                    .phoneNumber("123****912")
30
                    .username("son*****heng")
31
                    .build();
32
        }
33

34
        return result;
35
    }
36

37
    /**
38
        方法二（推荐）
39
     */
40
    @AfterReturning(value = "servicePointcut()", returning = "result")
41
    public void doAfterReturning(JoinPoint joinPoint, UserVo result) {
42

43
        if (result instanceof UserVo) {
44
            // 模拟脱敏过程
45
            result.setUsername("so****ng");
46
            result.setEmail("**********@example.com");
47
            result.setFirstName("ba****ng");
48
            result.setLastName("s**g");
49
            result.setPhoneNumber("123****912");
50
        }
51
    }
52
}

请求方法就可以看到返回的 Vo 已经脱敏：

脱敏后的 Vo