【Spring Boot】通过AOP拦截Spring Boot日志并将其存入数据库

前言

在软件开发中，常常需要记录系统运行时的日志。日志记录有助于排查系统问题、优化系统性能、监控操作行为等。本文将介绍如何使用Spring Boot和AOP技术实现拦截系统日志并保存到数据库中的功能。

摘要

本文将通过以下步骤实现拦截系统日志并保存到数据库中的功能：

1. 配置数据库连接
2. 定义日志实体类
3. 定义日志拦截器
4. 使用AOP拦截日志并保存到数据库中

AOP介绍

AOP，全称是Aspect Oriented Programming，即面向切面编程。AOP的目的是将那些与业务无关，但是业务模块都需要的功能，如日志统计、安全控制、事务处理等，封装成可重用的组件，从而将它们从业务逻辑代码中划分出来，编写成独立的切面。这样做，既可以保持业务逻辑的纯净和高内聚性，又可以使得系统的多个模块都可以共享这些公共的功能。

Spring框架提供了对AOP的支持，Spring Boot自然也不例外。使用Spring Boot的AOP功能，我们可以在运行时动态地将代码横向切入到各个关注点（方法或者类）中。这种横向切面的方式，比传统的纵向切面（继承）更加灵活。

AOP的实现

添加依赖

在pom.xml中添加以下依赖：

<dependency>

<groupId>org.springframework.bootgroupId>

<artifactId>spring-boot-starter-aopartifactId>

dependency>

<dependency>

<groupId>org.mybatis.spring.bootgroupId>

<artifactId>mybatis-spring-boot-starterartifactId>

dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这样我们就可以使用Spring Boot的AOP功能和MyBatis框架。

配置数据库连接

首先需要在Spring Boot项目的application.properties文件中配置数据库连接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false

spring.datasource.username=root

spring.datasource.password=123456

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
1
2
3
4
5
6
7

或者你也可以使用YAML的配置格式：

定义日志实体类

定义一个Log实体类用于保存日志信息，并使用@Entity和@Table注解指定对应的数据库表和字段：

@Entity

@Table(name = "sys_log")

public class Log {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String username;

private String operation;

private String method;

private String params;

private String ip;

private Date createTime;

// 省略getter和setter方法

}
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

定义日志拦截器

定义一个日志拦截器LogInterceptor，通过实现HandlerInterceptor接口来拦截请求并记录日志：

@Component

public class LogInterceptor implements HandlerInterceptor {

@Autowired

private LogRepository logRepository;

@Override

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

// 获取请求的IP地址

String ip = getIpAddress(request);

// 获取当前用户

String username = getCurrentUsername();

// 获取请求的方法名

String method = request.getMethod();

// 获取请求的URL

String url = request.getRequestURI();

// 获取请求的参数

String params = getParams(request);

// 创建日志实体

Log log = new Log();

log.setIp(ip);

log.setMethod(method);

log.setOperation("访问");

log.setParams(params);

log.setUsername(username);

log.setCreateTime(new Date());

// 保存日志到数据库中

logRepository.save(log);



return true;

}

// 省略实现HandlerInterceptor接口的其他方法

/**

* 获取请求的IP地址

*/

private String getIpAddress(HttpServletRequest request) {

String ip = request.getHeader("X-Forwarded-For");

if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {

ip = request.getHeader("Proxy-Client-IP");

}

if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {

ip = request.getHeader("WL-Proxy-Client-IP");

}

if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {

ip = request.getHeader("HTTP_CLIENT_IP");

}

if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {

ip = request.getHeader("HTTP_X_FORWARDED_FOR");

}

if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {

ip = request.getRemoteAddr();

}

return ip;

}

/**

* 获取当前用户

*/

private String getCurrentUsername() {

Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

if (authentication != null) {

return authentication.getName();

}

return null;

}

/**

* 获取请求的参数

*/

private String getParams(HttpServletRequest request) {

Map<String, String[]> parameterMap = request.getParameterMap();

if (parameterMap == null || parameterMap.isEmpty()) {

return null;

}

StringBuilder sb = new StringBuilder();

for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {

sb.append(entry.getKey()).append("=").append(Arrays.toString(entry.getValue())).append("&");

}

return sb.toString();

}

}
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
146
147
148
149
150
151
152
153

使用AOP拦截日志并保存到数据库中

使用AOP技术拦截所有Controller类中的方法，并执行LogInterceptor中的preHandle方法，记录日志并保存到数据库中。
定义一个LogAspect切面类，通过实现@Aspect注解和@Before注解来实现方法拦截：

@Aspect

@Component

public class LogAspect {

@Autowired

private LogInterceptor logInterceptor;

@Pointcut("execution(public * com.example.demo.controller..*.*(..))")

public void logAspect() {}

@Before("logAspect()")

public void doBefore(JoinPoint joinPoint) {

ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

if (attributes == null) {

return;

}

HttpServletRequest request = attributes.getRequest();

HttpServletResponse response = attributes.getResponse();

HandlerMethod handlerMethod = (HandlerMethod) joinPoint.getSignature();

try {

logInterceptor.preHandle(request, response, handlerMethod);

} catch (Exception e) {

e.printStackTrace();

}

}

}
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

代码方法介绍

• LogInterceptor.preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)方法：拦截请求并记录日志的方法。
• LogInterceptor.getIpAddress(HttpServletRequest request)方法：获取请求的IP地址。
• LogInterceptor.getCurrentUsername()方法：获取当前用户。
• LogInterceptor.getParams(HttpServletRequest request)方法：获取请求的参数。
• LogAspect.logAspect()方法：定义AOP切入点，拦截Controller类中的所有方法。
• LogAspect.doBefore(JoinPoint joinPoint)方法：执行方法拦截操作，并调用LogInterceptor.preHandle方法来记录日志。

测试用例

可以使用Postman等工具发起请求来测试拦截器是否生效，并查看数据库中是否保存了对应的日志信息。这里就不直接演示了，毕竟使用起来非常的简单易上手。

全文小结

本文介绍了如何使用Spring Boot和AOP技术实现拦截系统日志并保存到数据库中的功能，包括配置数据库连接、定义日志实体类、定义日志拦截器、使用AOP拦截日志并保存到数据库中等步骤。通过本文的介绍，可以更好地理解Spring Boot和AOP的应用，为开发高效、稳定的系统提供参考。
注：
环境说明：Windows10 + Idea2021.3.2 + Jdk1.8 + SpringBoot 2.3.1.RELEASE