Spring Boot 2.x 教程系列 | AOP 切面统一打印请求日志

欢迎关注微信公众号: 小哈学Java

文章首发于个人网站 https://www.exception.site/springboot/spring-boot-aop-web-request

本节中，您将学习如何在 Spring Boot 中使用 AOP 切面统一处理请求日志，打印进出参相关参数。

一、先看看日志输出效果

可以看到，每个对于每个请求，开始与结束一目了然，并且打印了以下参数：

• URL: 请求接口地址；

• HTTP Method: 请求的方法，是 POST, GET, 还是 DELETE 等；

• Class Method: 对应 Controller 的全路径以及调用的哪个方法;

• IP: 请求 IP 地址；

• Request Args: 请求入参，以 JSON 格式输出；

• Response Args: 响应出参，以 JSON 格式输出；

• Time-Consuming: 请求耗时；

效果应该还不错吧！接下来就让我们一步一步去实现该功能, 首先，新建一个 Spring Boot Web 项目。

二、添加 Maven 依赖

在项目 pom.xml 文件中添加依赖：

<!-- aop 依赖 -->	
<dependency>	
    <groupId>org.springframework.boot</groupId>	
    <artifactId>spring-boot-starter-aop</artifactId>	
</dependency>	
<!-- 用于日志切面中，以 json 格式打印出入参（本来使用阿里的 FASTJSON, 但是对于文件上传的接口，打印参数会报错，换为 Gson） -->	
<dependency>	
    <groupId>com.google.code.gson</groupId>	
    <artifactId>gson</artifactId>	
    <version>2.8.5</version>	
</dependency>

三、配置 AOP 切面

在配置 AOP 切面之前，我们需要了解下 aspectj 相关注解的作用：

• @Aspect：声明该类为一个注解类；

• @Pointcut：定义一个切点，后面跟随一个表达式，表达式可以定义为某个 package 下的方法，也可以是自定义注解等；

• 切点定义好后，就是围绕这个切点做文章了：

• @Before: 在切点之前，织入相关代码；

• @After: 在切点之后，织入相关代码;

• @AfterReturning: 在切点返回内容后，织入相关代码，一般用于对返回值做些加工处理的场景；

• @AfterThrowing: 用来处理当织入的代码抛出异常后的逻辑处理;

• @Around: 在切入点前后织入代码，并且可以自由的控制何时执行切点；

接下来，定义一个 WebLogAspect.java 切面类，代码如下：

package site.exception.springbootaopwebrequest.aspect;	
import com.google.gson.Gson;	
import org.aspectj.lang.JoinPoint;	
import org.aspectj.lang.ProceedingJoinPoint;	
import org.aspectj.lang.annotation.*;	
import org.slf4j.Logger;	
import org.slf4j.LoggerFactory;	
import org.springframework.stereotype.Component;	
import org.springframework.web.context.request.RequestContextHolder;	
import org.springframework.web.context.request.ServletRequestAttributes;	
import javax.servlet.http.HttpServletRequest;	
/**	
 * @author www.exception.site (exception 教程网)	
 * @date 2019/2/12	
 * @time 14:03	
 * @discription	
 **/	
@Aspect	
@Component	
public class WebLogAspect {	
    private final static Logger logger = LoggerFactory.getLogger(WebLogAspect.class);	
    /** 以 controller 包下定义的所有请求为切入点 */	
    @Pointcut("execution(public * site.exception.springbootaopwebrequest.controller..*.*(..))")	
    public void webLog() {}	
    /**	
     * 在切点之前织入	
     * @param joinPoint	
     * @throws Throwable	
     */	
    @Before("webLog()")	
    public void doBefore(JoinPoint joinPoint) throws Throwable {	
        // 开始打印请求日志	
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();	
        HttpServletRequest request = attributes.getRequest();	
        // 打印请求相关参数	
        logger.info("========================================== Start ==========================================");	
        // 打印请求 url	
        logger.info("URL            : {}", request.getRequestURL().toString());	
        // 打印 Http method	
        logger.info("HTTP Method    : {}", request.getMethod());	
        // 打印调用 controller 的全路径以及执行方法	
        logger.info("Class Method   : {}.{}", joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName());	
        // 打印请求的 IP	
        logger.info("IP             : {}", request.getRemoteAddr());	
        // 打印请求入参	
        logger.info("Request Args   : {}", new Gson().toJson(joinPoint.getArgs()));	
    }	
    /**	
     * 在切点之后织入	
     * @throws Throwable	
     */	
    @After("webLog()")	
    public void doAfter() throws Throwable {	
        logger.info("=========================================== End ===========================================");	
        // 每个请求之间空一行	
        logger.info("");	
    }	
    /**	
     * 环绕	
     * @param proceedingJoinPoint	
     * @return	
     * @throws Throwable	
     */	
    @Around("webLog()")	
    public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {	
        long startTime = System.currentTimeMillis();	
        Object result = proceedingJoinPoint.proceed();	
        // 打印出参	
        logger.info("Response Args  : {}", new Gson().toJson(result));	
        // 执行耗时	
        logger.info("Time-Consuming : {} ms", System.currentTimeMillis() - startTime);	
        return result;	
    }	
}

我们通过 @Aspect 声明了 WebLogAspect.java 为切面类，之后，通过 @Pointcut 定义了打印请求日志的切点，切点为 site.exception.springbootaopwebrequest.controller 包下所有的请求接口。

切点定义好后，我们通过 @Before 在切点之前打印请求的相关参数，通过 @Around 打印了请求接口的耗时时间，最后通过 @After 做了请求的收尾工作。

到这里，切面相关的代码就完成了！

三、测试

我们针对 GET, POST, 文件提交，以及多文件提交四种接口分别测试其效果, 接口定义如下：

package site.exception.springbootaopwebrequest.controller;	
import org.slf4j.Logger;	
import org.slf4j.LoggerFactory;	
import org.springframework.web.bind.annotation.*;	
import org.springframework.web.multipart.MultipartFile;	
import site.exception.springbootaopwebrequest.entity.User;	
/**	
 * @author www.exception.site (exception 教程网)	
 * @date 2019/2/16	
 * @time 21:03	
 * @discription	
 **/	
@RestController	
public class TestController {	
    private final static Logger logger = LoggerFactory.getLogger(TestController.class);	
    /**	
     * POST 方式接口测试	
     * @param user	
     * @return	
     */	
    @PostMapping("/user")	
    public User testPost(@RequestBody User user) {	
        logger.info("testPost ...");	
        return user;	
    }	
    /**	
     * GET 方式接口测试	
     * @return	
     */	
    @GetMapping("/user")	
    public String testGet(@RequestParam("username") String username,	
                          @RequestParam("password") String password) {	
        logger.info("testGet ...");	
        return "success";	
    }	
    /**	
     * 单文件上传接口测试	
     * @return	
     */	
    @PostMapping("/file/upload")	
    public String testFileUpload(@RequestParam("file") MultipartFile file) {	
        logger.info("testFileUpload ...");	
        return "success";	
    }	
    /**	
     * 多文件上传接口测试	
     * @return	
     */	
    @PostMapping("/multiFile/upload")	
    public String testMultiFileUpload(@RequestParam("file") MultipartFile[] file) {	
        logger.info("testMultiFileUpload ...");	
        return "success";	
    }	
}

User.java:

package site.exception.springbootaopwebrequest.entity;	
import java.io.Serializable;	
import java.util.Date;	
/**	
 * @author www.exception.site (exception 教程网)	
 * @date 2019/2/16	
 * @time 21:00	
 * @discription	
 **/	
public class User implements Serializable {	
    /**	
     * 用户名	
     */	
    private String username;	
    /**	
     * 密码	
     */	
    private String password;	
    /**	
     * 创建时间	
     */	
    private Date createTime;	
    public String getUsername() {	
        return username;	
    }	
    public void setUsername(String username) {	
        this.username = username;	
    }	
    public String getPassword() {	
        return password;	
    }	
    public void setPassword(String password) {	
        this.password = password;	
    }	
    public Date getCreateTime() {	
        return createTime;	
    }	
    public void setCreateTime(Date createTime) {	
        this.createTime = createTime;	
    }	
}

3.1 GET 接口测试

请求 http://localhost:8080/user?username=张三&password=123456接口，观察日志打印情况：

GET 接口正常打印日志！

3.2 POST 接口测试

通过 Postman 请求 http://localhost:8080/user POST 接口：

看看控制台输出效果：

POST 接口也是 OK 的!

3.3 单文件提交接口测试

请求单文件提交接口： http://localhost:8080/file/upload :

日志输出如下：

3.4 多文件提交接口测试

请求单文件提交接口： http://localhost:8080/multiFile/upload :

切面日志输出：

为何不用 FASTJSON

笔者在开始阶段的确使用的是阿里 FASTJSON 来做出入参的打印，但是对于文件上传接口，FASTJSON 转换会出错，故改用谷歌的 Gson。

GitHub 源码地址

https://github.com/weiwosuoai/spring-boot-tutorial/tree/master/spring-boot-aop-web-request

·END·

 近期热文：

• 如何在 Spring Boot 中自定义启动器 Starter
  

• Java8 新特性并发篇(一) | 线程与执行器

• 如何在 Java8 中风骚走位避开空指针异常

• 干货 | Java8 新特性指导手册
  

如果你喜欢本文

请长按二维码，关注小哈学Java

转发朋友圈，是对我最大的支持。

看完，赶紧点个“好看”鸭

点鸭点鸭

↓↓↓↓