前言

本篇主要以下五点，带大家学习下 Spring AOP。

• 什么是 AOP
• AOP 的作用
• AOP 术语
• AOP 底层实现原理
• AOP 实战

什么是 AOP？

AOP（Aspect Oriented Programming）意为：面向切面编程，通过「预编译方式」和「运行期动态代理」实现程序功能的统一维护的一种技术。

面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术，如下图所示：

AOP 可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离。比如 Spring 的事务，通过事务的注解配置，Spring 会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。

AOP 的作用

AOP 可以说是 OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP 引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP 则显得无能为力。

也就是说，OOP 允许你定义从上到下的关系，但并不适合定义从左到右的关系，例如「日志功能」。

日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。这种散布在各处的无关的代码被称为「横切」（cross-cutting）代码，在 OOP 设计中，它导致了大量代码的重复，而不利于各个模块的重用。

而 AOP 技术则恰恰相反，它利用一种称为「横切」的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为 Aspect，即切面。

如何理解「切面」二字呢？

所谓「切面」，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。

AOP 代表的是一个横向的关系，如果说「对象」是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向切面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

使用「横切」技术，AOP 把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。

横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志处理、事务控制。

AOP 旨在将横切关注点从业务主体逻辑中进行剥离，实现关注点分离，以提高程序的模块化程度。即业务模块只需关注业务逻辑，无需关注日志、安全、事务等通用逻辑。

AOP 小结

AOP 采取横向抽取机制（动态代理），取代了传统纵向继承机制的重复性代码，其应用主要体现在事务处理、日志管理、权限控制、异常处理等方面。

主要作用是分离功能性需求和非功能性需求，使开发人员可以集中处理某一个关注点或者横切逻辑，减少对业务代码的侵入，增强代码的可读性和可维护性。

简单的说，AOP 的作用就是保证开发者在不修改源代码的前提下，为系统中的业务组件添加某种通用功能。

通俗理解 AOP

来看下面这段伪代码 :

public Student queryStudent(int studentId){
​
    // 记录方法开始时间
    long startTime = System.currentTimeMillis();
​
    // 查询学生信息
    Student student = studentDao.selectStudentInfo(studentId);
​
    // 记录操作日志
    operationLog.add();
        
    // 记录方法结束时间
    long endTime = System.currentTimeMillis();
    // 计算方法执行时间
    log.info("执行时间: " + (endTime - startTime));
​
    return student;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

可以看到，上面的案例，除了查询学生信息是业务代码以外, 其它的所有步骤都不属于业务代码。

在平时工作中如果遇到这种代码的解决方案无非两种 :

• 抽取方法
• 抽取类

这两种方法我们称为 : 纵向抽取。

回顾我们平时开发的固定模式： Controller → Service → Dao。在这种顺序执行，纵向延伸的执行逻辑里面不管怎么进行上面的两种封装，依旧还是会出现重复的代码。

以上面为例 : 即便将记录方法时间与记录用户操作记录封装为一个方法, 那么这个方法依旧要依附与我们主体业务类的方法逻辑中。

结论就是 : 纵向并不能解决此类问题。

此时就要引出 AOP 理念 : 将分散在各个业务逻辑代码中的相同代码通过横向切割的方式抽取到独立模块中。

于是就有了切面的概念，通过将方法注入到接口调用的某个地方（切点）。

这样接口只需要关心具体的业务，而不需要关注其他非该接口关注的逻辑或处理。红框处，就是面向切面编程。

了解了这些，我们再来看下面的相关术语。

AOP 中的相关术语

这里将术语分为两类，一类是对象术语，另一类是行为术语。

• 对象术语指的是用于描述 AOP 中的各个对象部分；
• 行为术语指的是在 AOP 实现过程中涉及到的具体行为。

对象术语

连接点（Join Point）

连接点描述的是程序执行的某个特定位置。如一个类的初始化前、初始化后，或者类的某个方法调用前、调用后、方法抛出异常后等等。一个类或一段程序代码拥有一些具有边界性质的特定点，这些特定点就称为连接点。

连接点用来定义在目标程序的哪里通过 AOP 加入新的逻辑——即能够被拦截的地方。

Spring 仅支持方法的连接点，即仅能在方法调用前、方法调用后、方法抛出异常时以及方法调用前后这些程序执行点织入增强。

切点（Pointcut）

具体定位的连接点，AOP 通过切点定位到特定的连接点。

每个类都拥有多个连接点：例如一个拥有两个方法的类，这两个方法都是连接点，即连接点是程序类中客观存在的事物。我们具体定位到某一个方法就成为切点。

类比：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系，一个切点匹配多个连接点，它使用类和方法作为连接点的查询条件。

Spring AOP 会根据切点的定义，来匹配一个或多个连接点，然后应用我们的通知。我们通常会使用明确的类/方法名，或是正则表达式来指定切点。

@Pointcut("execution(* com.atu.web.LogController..*(..))")
public void requestServer() {
}
1
2
3

通知/增强（Advice）

通知是指切面在某个具体的连接点采取的行为或行动。切面的核心逻辑代码都写在通知中，有人也称之为增强或者横切关注点。

通知是切面功能的具体实现，通常是业务代码以外的需求，如日志、验证等，这些被模块化的特殊对象。

Spring AOP 提供了 5 种类型的通知：

• 前置通知（Before）：在目标方法被调用前执行的行为。
• 后置通知（After）：在目标方法执行完成后执行的行为，不能获取到方法的输出。
• 后置返回通知（After-returning）：在目标方法成功执行后执行的行为，可以获取到方法的输出。
• 后置异常通知（After-throwing）：在目标方法抛出异常后执行的行为。
• 环绕通知（Around）：包裹了目标方法，可以在其执行前后执行自定义的行为。

切面（Aspect）

切面是一个类，这个类实现上述横切关注点的功能，例如日志记录，事务处理等。

切面是切点和通知的聚合，它既包括了横切逻辑的定义、也包括了连接点的定义。定义了在哪一个切点做什么通知。

• 通知说明了干什么和什么时候干（什么时候通过方法名中的 before，after，around 等就能知道），
• 切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。

行为术语

引入（Introduction）

引入指的向现有的类中添加新的方法或属性。我们可以把切面（也就是新方法属性：通知定义的）引入到目标类中，这样目标类就具有了新的方法，同时还不用修改现有具体类的定义。

目标类，也就是要被通知的对象。

织入（Weaving）

织入指的是将切面应用到目标对象，在这个过程中会生成新的代理对象。

织入的执行的时机有以下几个：

• 编译期：在目标类被编译时进行织入，需要依赖于特殊的编译器。AspectJ 的织入编译器就采用的这种方式。
• 类加载期：在目标类被加载到 JVM 时进行织入，需要依赖于特殊的类加载器。这种方式会在目标类被引入应用前增强目标类的字节码。
• 运行期：在应用运行的某一具体时刻进行织入。在这种情况下，AOP 容器会为目标对象动态地创建一个代理对象，Spring AOP 就采用的这种方式。

总结

我们简单总结一下对象术语，完整的场景如下：

王老师在上语文课前，需要有人来擦黑板。

在这个场景中，各自对象代表的内容如下：

• 被增强的方法：王老师的语文课
• 目标方法所在类：王老师
• 通知（前置通知）：做某事前擦黑板，重点是擦黑板这一行为
• 连接点：老师上课前的时间，并不确定是哪些老师上哪门课前
• 切点：王老师上语文课前这一时间点
• 切面：在王老师上语文课前擦黑板

Spring AOP 的实现机制

Spring 通过动态代理和动态字节码技术实现了 AOP。

Spring AOP 采用了两种混合的实现方式：JDK 动态代理和 CGLIB 动态代理。

• JDK 动态代理：Spring AOP 的首选方法。每当目标对象实现一个接口时，就会使用 JDK 动态代理。目标对象必须实现接口
• CGLIB 代理：如果目标对象没有实现接口，则可以使用 CGLIB 代理。

如果没有代理模式基础，建议先看看：设计模式之代理模式这篇文章。

实战：自定义注解记录项目日志

注解的定义

@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {
    /**
     * 模块
     */
    public String title() default "";

    /**
     * 业务类型
     */
    public BusinessType businessType() default BusinessType.OTHER;

    /**
     * 操作人类别
     */
    public OperatorType operatorType() default OperatorType.MANAGE;

    /**
     * 是否保存请求的参数
     */
    public boolean isSaveRequestData() default true;

    /**
     * 是否保存响应的参数
     */
    public boolean isSaveResponseData() default true;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

切面的定义

定义 LogAspect 切面解析 @Log 注解。

@Slf4j
@Aspect
@Component
public class LogAspect {
    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "@annotation(controllerLog)", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, Log controllerLog, Object jsonResult) {
        handleLog(joinPoint, controllerLog, null, jsonResult);
    }

    /**
     * 拦截异常操作
     *
     * @param joinPoint 切点
     * @param e         异常
     */
    @AfterThrowing(value = "@annotation(controllerLog)", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Log controllerLog, Exception e) {
        handleLog(joinPoint, controllerLog, e, null);
    }

    protected void handleLog(final JoinPoint joinPoint, Log controllerLog, final Exception e, Object jsonResult) {
        try {
            // *========数据库日志=========*//
            SysOperLog operLog = new SysOperLog();
            operLog.setStatus(BusinessStatus.SUCCESS.ordinal());
            // 请求的地址
            String ip = IPUtils.getIpAddr(ServletUtils.getRequest());
            operLog.setOperIp(ip);
            operLog.setOperUrl(ServletUtils.getRequest().getRequestURI());
            operLog.setOperName("system");

            if (e != null) {
                operLog.setStatus(BusinessStatus.FAIL.ordinal());
                operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));
            }
            // 设置方法名称
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = joinPoint.getSignature().getName();
            operLog.setMethod(className + "." + methodName + "()");
            // 设置请求方式
            operLog.setRequestMethod(ServletUtils.getRequest().getMethod());
            // 处理设置注解上的参数
            getControllerMethodDescription(joinPoint, controllerLog, operLog, jsonResult);
            // 保存数据库
            AsyncService.me().execute(AsyncFactory.recordOper(operLog));
        } catch (Exception exp) {
            // 记录本地异常日志
            log.error("==处理完请求后执行异常==");
            log.error("异常信息:{}", exp.getMessage());
            exp.printStackTrace();
        }
    }

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     *
     * @param log     日志
     * @param operLog 操作日志
     * @throws Exception
     */
    public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog, Object jsonResult) throws Exception {
        // 设置action动作
        operLog.setBusinessType(log.businessType().ordinal());
        // 设置标题
        operLog.setTitle(log.title());
        // 设置操作人类别
        operLog.setOperatorType(log.operatorType().ordinal());
        // 是否需要保存request，参数和值
        if (log.isSaveRequestData()) {
            // 获取参数的信息，传入到数据库中。
            setRequestValue(joinPoint, operLog);
        }
        // 是否需要保存response，参数和值
        if (log.isSaveResponseData() && ObjectUtils.isNotEmpty(jsonResult)) {
            operLog.setJsonResult(StringUtils.substring(JSON.toJSONString(jsonResult), 0, 2000));
        }
    }

    /**
     * 获取请求的参数，放到log中
     *
     * @param operLog 操作日志
     * @throws Exception 异常
     */
    private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog) throws Exception {
        String requestMethod = operLog.getRequestMethod();
        if (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod)) {
            String params = argsArrayToString(joinPoint.getArgs());
            operLog.setOperParam(StringUtils.substring(params, 0, 2000));
        } else {
            Map<?, ?> paramsMap = (Map<?, ?>) ServletUtils.getRequest().getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
            operLog.setOperParam(StringUtils.substring(paramsMap.toString(), 0, 2000));
        }
    }

    /**
     * 参数拼装
     */
    private String argsArrayToString(Object[] paramsArray) {
        String params = "";
        if (paramsArray != null && paramsArray.length > 0) {
            for (Object o : paramsArray) {
                if (ObjectUtils.isNotEmpty(o) && !isFilterObject(o)) {
                    try {
                        Object jsonObj = JSON.toJSON(o);
                        params += jsonObj.toString() + " ";
                    } catch (Exception e) {
                    }
                }
            }
        }
        return params.trim();
    }

    /**
     * 判断是否需要过滤的对象。
     *
     * @param o 对象信息。
     * @return 如果是需要过滤的对象，则返回true；否则返回false。
     */
    public boolean isFilterObject(final Object o) {
        Class<?> clazz = o.getClass();
        if (clazz.isArray()) {
            return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
        } else if (Collection.class.isAssignableFrom(clazz)) {
            Collection collection = (Collection) o;
            for (Object value : collection) {
                return value instanceof MultipartFile;
            }
        } else if (Map.class.isAssignableFrom(clazz)) {
            Map map = (Map) o;
            for (Object value : map.entrySet()) {
                Map.Entry entry = (Map.Entry) value;
                return entry.getValue() instanceof MultipartFile;
            }
        }
        return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse
                || o instanceof BindingResult;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

我们大概捋一下这个切面的逻辑：

1. 首先定义了两种不同类型的通知：返回通知和异常通知。正常流程就是在返回通知中处理日志写入操作，但是如果系统不幸抛出异常，就在异常通知中处理日志写入操作（此时就多了一个异常对象）。
2. 日志数据保存在 SysOperLog 对象中，采集各种日志数据都是常规操作，不多说。
3. 当收集接口参数的时候，有两个需要注意的地方：
   1. 如果请求类型是 PUT 或者 POST，就直接从接口的参数中获取想要的数据，但是接口的参数中可能会存在一些并不需要记录的内容，例如 HttpServletRequest、HttpServletResponse 或者文件上传对象 MultipartFile 等，这些类型的内容是不需要记录到日志中的，这里通过一个 isFilterObject 方法完成了数据过滤操作；
   2. 如果请求类型是 GET 或者 DELETE，则请求参数就直接从请求对象提取了。为什么设计成这样呢？很明显，直接从请求对象中提取参数是最为方便的，一行代码就搞定，但是如果请求类型是 PUT 或者 POST，就意味着请求参数是在请求体中，请求参数有可能是二进制数据（例如上传的文件），二进制数据就不好保存了，所以对于 POST 和 PUT 还是从接口参数中提取，然后过滤掉二进制数据即可。
4. 数据收集齐了，接下来就是往数据库中写入了。因为我们现在用的 SpringMVC 这一套是线程阻塞的，也就是得等到服务端都处理完毕之后，接口才会给客户端响应，而写日志是一个业务无关的操作，所以可以直接放在一个子线程中去完成。我们使用了 Java JUC 中的 ScheduledExecutorService 去完成这个延时任务，AsyncManager.me().execute 方法实际上就是去执行一个延时任务，这个延时任务就是一个往数据库中写入一条记录。

注解使用

@Log(title = "add")
@RequestMapping(value = "/add", method = RequestMethod.POST)
public int add(@RequestParam(value= "i") int i, @RequestParam(value= "j") int j) {
    return i+j;
}
1
2
3
4
5

如需本文源码，可以留言私信我！

参考资料

江南一点雨：记录项目日志，一个注解搞定