【AOP实战】掌握Spring Boot AOP：重构代码，提升效率

文章目录

Spring Boot AOP - 面向切面编程
- AOP到底有什么不同
- AOP中的编程术语和常用注解
- 定义切面
- 环绕通知
- 通知方法传参
- 总结

Spring Boot AOP - 面向切面编程

AOP，即面向切面编程，其核心思想就是把业务分为核心业务和非核心业务两大部分。例如一个论坛系统，用户登录、发帖等等这是核心功能，而日志统计等等这些就是非核心功能。
在Spring Boot AOP中，非核心业务功能被定义为切面，核心和非核心功能都开发完成之后，再将两者编织在一起，这就是AOP。
AOP的目的就是将那些与业务无关，却需要被业务所用的逻辑单独封装，以减少重复代码，减低模块之间耦合度，利于未来系统拓展和维护。
今天，我将做一个简单的打印用户信息的程序，即后端接受POST请求中的User对象将其打印这样一个逻辑，在这个上面实现AOP。
首先放上用户打印服务逻辑的方法代码：
User类：

public class User implements Serializable {private int id;private String username;private String nickname;
}

Service层：

package com.example.springbootaop.service.impl;import com.example.springbootaop.model.User;
import com.example.springbootaop.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;@Component
public class UserServiceImpl implements UserService {/*** 使用Logger*/private Logger logger = LoggerFactory.getLogger(this.getClass());@Overridepublic void printUserInfo(User user) {logger.info("用户id：" + user.getId());logger.info("用户名：" + user.getUsername());logger.info("用户昵称：" + user.getNickname());}}

Controller层：

package com.example.springbootaop.api;import com.example.springbootaop.model.User;
import com.example.springbootaop.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;@RestController
public class UserAPI {@Autowiredprivate UserService userService;@PostMapping("/user")public String printUser(@RequestBody User user) {userService.printUserInfo(user);return "已完成打印！";}}

AOP到底有什么不同

这里只是实现一个简单的逻辑，打印用户信息，这就是我们今天的核心功能。

如果这个时候我们要给它加上非核心功能：在打印之前和打印之后分别执行一个方法，如果你不知道AOP，你可能会把Controller层的方法改成如下形式：

@PostMapping("/user")
public String printUser(@RequestBody User user) {// 执行核心业务之前doBefore();// 执行核心业务userService.printUserInfo(user);// 执行核心业务之后doAfter();...return "已完成打印！";
}

如果说方法多了，业务多了，非核心业务的逻辑一变，所有Controller的全部方法都要改动，非常麻烦，且代码冗余，耦合度高。
这时，就需要AOP来解决这个问题。
AOP只需要我们单独定义一个切面，在里面写好非核心业务的逻辑，即可将其织入核心功能中去，无需我们再改动Service层或者Controller层。

AOP中的编程术语和常用注解

在学习AOP之前，我们还是需要了解一下常用术语：

切面：非核心业务功能就被定义为切面。比如一个系统的日志功能，它贯穿整个核心业务的逻辑，因此叫做切面
切入点：在哪些类的哪些方法上面切入
通知：在方法执行前/后或者执行前后做什么
- 前置通知：在被代理方法之前执行
- 后置通知：在被代理方法之后执行
- 返回通知：被代理方法正常返回之后执行
- 异常通知：被代理方法抛出异常时执行
- 环绕通知：是AOP中强大、灵活的通知，集成前置和后置通知
切面：在什么时机、什么地方做什么（切入点+通知）
织入：把切面加入对象，是生成代理对象并将切面放入到流程中的过程（简而言之，就是把切面逻辑加入到核心业务逻辑的过程）

在Spring Boot中，我们使用@AspectJ注解开发AOP，首先需要在pom.xml中引入如下依赖：

<!-- Spring Boot AOP -->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId>
</dependency>

然后就可以进行AOP开发了！
这里先给出常用注解，大家联系着下面的例子看就可以了：

@Pointcut 定义切点
@Before 前置通知
@After 后置通知
@AfterReturning 返回通知
@AfterThrowing 异常通知
@Around 环绕通知

定义切面

新建aop包，在里面新建类作为我们的切面类，先放出切面类代码：

package com.example.springbootaop.aop;import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;@Aspect
@Component
public class LogAspect {/*** 日志打印*/private Logger logger = LoggerFactory.getLogger(this.getClass());/*** 使用Pointcut给这个方法定义切点，即UserService中全部方法均为切点。<br>* 这里在这个log方法上面定义切点，然后就只需在下面的Before、After等等注解中填写这个切点方法"log()"即可设置好各个通知的切入位置。* 其中：* <ul>*     <li>execution：代表方法被执行时触发</li>*     <li>*：代表任意返回值的方法</li>*     <li>com.example.springbootaop.service.impl.UserServiceImpl：这个类的全限定名</li>*     <li>(..)：表示任意的参数</li>* </ul>*/@Pointcut("execution(* com.example.springbootaop.service.impl.UserServiceImpl.*(..))")public void log() {}/*** 前置通知：在被代理方法之前调用*/@Before("log()")public void doBefore() {logger.warn("调用方法之前：");logger.warn("接收到请求！");}/*** 后置通知：在被代理方法之后调用*/@After("log()")public void doAfter() {logger.warn("调用方法之后：");logger.warn("打印请求内容完成！");}/*** 返回通知：被代理方法正常返回之后调用*/@AfterReturning("log()")public void doReturning() {logger.warn("方法正常返回之后：");logger.warn("完成返回内容！");}/*** 异常通知：被代理方法抛出异常时调用*/@AfterThrowing("log()")public void doThrowing() {logger.error("方法抛出异常！");}}

切面类需要打上@Aspect注解表示这是一个切面类，然后不要忘了打上@Component注解。
我们逐步来看。
首先是定义切点，只需定义一个空方法，在上面使用@Pointcut注解即可，注解里面内容含义如下：

execution 代表方法被执行时触发
* 代表任意返回值的方法
com.example.springbootaop.service.impl.UserServiceImpl 被织入类的全限定名
(..) 表示任意的参数

定义完切点之后，就可以定义各个通知的方法逻辑了，这些就是我们的切面逻辑，也就是非核心业务的逻辑。
上面在doBefore方法上面，我们使用了@Before注解，这样就标明了doBefore方法是前置通知逻辑，会在被织入方法之前执行。我们把log方法定义为切入点，然后下面各个通知注解中，填写这个切入点方法名称即可。
我们也并不需要定义所有的通知，只需定义需要的即可。
其实，如果不定义上面的切入点方法log和@Pointcut，你仍然可以把execution表达式直接写在各个通知的注解里面，例如：

/*** 前置通知：在被代理方法之前调用*/
@Before("execution(* com.example.springbootaop.service.impl.UserServiceImpl.*(..))")
public void doBefore(JoinPoint joinPoint) {logger.warn("调用方法之前："); logger.warn("接收到请求！");
}

但是大多数情况并不推荐这样，这种写法较为复杂。

我们发送一个请求测试一下：
在这里插入图片描述
通过这个，我们也可以发现各个通知的执行顺序：

Before -> AfterReturning -> After

环绕通知

环绕通知是AOP中最强大的通知，可以同时实现前置和后置通知，不过它的可控性没那么强，如果不用大量改变业务逻辑，一般不需要用到它。我们在上述切面加入下列环绕通知方法：

/*** 环绕通知*/
@Around("log()")
public void around(ProceedingJoinPoint joinPoint) {logger.warn("执行环绕通知之前：");try {joinPoint.proceed();} catch (Throwable e) {e.printStackTrace();}logger.warn("执行环绕通知之后");
}

通知方法中有一个ProceedingJoinPoint类型参数，通过其proceed方法来调用原方法。需要注意的是环绕通知是会覆盖原方法逻辑的，如果上面代码不执行joinPoint.proceed();这一句，就不会执行原被织入方法。因此环绕通知一定要调用参数的proceed方法，这是通过反射实现对被织入方法调用。
再次测试如下：
在这里插入图片描述

通知方法传参

上面每个通知方法是没有参数的。其实，通知方法是可以接受被织入方法的参数的。我们上述被织入方法参数就是一个User对象，因此通知方法也可以加上这个参数接受。我们改变前置通知方法如下：

/*** 前置通知：在被代理方法之前调用*/
@Before("log() && args(user)")
public void doBefore(User user) {logger.warn("调用方法之前：");logger.warn("接收到请求！");logger.warn("得到用户id：" + user.getId());
}

在这里插入图片描述
可见在注解后面加一个args选项，里面写参数名即可。

需要注意的是，通知方法的参数必须和被织入方法参数一一对应例如：

/*** 被织入方法* /
public void print(User user, int num) {...
}/*** 通知* /
@Before("log() && args(user, num)")
public void doBefore(User user, int num) {...
}