<think>我们正在使用Spring Boot
AOP实现接口请求
日志记录。根据引用内容，我们可以总结出以下步骤：
1. 添加依赖：在`pom.xml`中添加Spring Boot
AOP依赖。
2. 创建切面类：使用`@Aspect`注解标记的类，定义切面。
3. 定义切点：通过表达式指定哪些方法需要记录
日志（例如，所有Controller中的方法）。
4. 编写通知：在方法执行前后（或异常时）记录
日志，可以使用`@Before`、`@After`、`@Around`等注解。
5. 获取请求信息：在通知方法中，可以通过`JoinPoint`获取方法
名、
参数等信息，也可以注
入`HttpServletRequest`来获取请求信息。
6. 记录
日志：将获取的信息输出到
日志文件或数据库。
下面我们详细说明每个步骤。
### 1. 添加依赖
在`pom.xml`中添加以下依赖：
```xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-
aop</artifactId>
</dependency>
```
### 2. 创建切面类
创建一个类，用`@Aspect`和`@Component`注解标记，这样Spring就会将其识别为一个切面并管理。
### 3. 定义切点
使用`@Pointcut`注解定义切点表达式，例如：
```java
@Pointcut("execution(* com.example.demo.controller..*.*(..))")
public void controllerPointcut() {}
```
这个切点表示`com.example.demo.controller`包下所有类的所有方法。
### 4. 编写通知
我们通常使用`@Around`通知，因为它可以在方法执行前后都进行操作，并且可以控制方法是否执行。但也可以使用`@Before`和`@After`。
### 5. 获取请求信息
我们可以通过`JoinPoint`获取方法签
名、
参数等信息。同时，为了获取HTTP请求信息，我们可以注
入`HttpServletRequest`。
### 6. 记录
日志
在通知方法中，我们可以使用
日志框
架（如SLF4J）记录
日志，也可以将
日志存
入数据库（如引用[2]所述）。
下面是一个完整的切面类示例，记录每个Controller方法的请求信息（包括请求时间、方法
名、
参数等）和耗时：
```java
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
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;
import java.util.Arrays;
@Aspect
@Component
public class RequestLogAspect {
private static final Logger logger = LoggerFactory.getLogger(RequestLogAspect.class);
// 定义切点：controller包下的所有方法
@Pointcut("execution(* com.example.demo.controller..*.*(..))")
public void controllerPointcut() {}
@Around("controllerPointcut()")
public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
long startTime = System.currentTimeMillis();
// 获取请求信息
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
// 记录请求信息
logger.info("
URL: {}", request.getRequest
URL().toString());
logger.info("HTTP Method: {}", request.getMethod());
logger.info("IP: {}", request.getRemoteAddr());
logger.info("Class Method: {}.{}", joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName());
logger.info("Args: {}", Arrays.toString(joinPoint.getArgs()));
// 执行方法
Object result = joinPoint.proceed();
// 计算耗时
long endTime = System.currentTimeMillis();
logger.info("Response: {}", result); // 注意：如果
返回结果很大，可能不适合
打印，可以酌情处理
logger.info("Time Cost: {} ms", endTime - startTime);
return result;
}
}
```
注意：上面的示例中，我们
打印了
返回结果，这在生产环境中可能会因为
返回结果过大而不适合，所以可以根据实际情况调整。
### 扩展：记录到数据库
如果需要将
日志记录到数据库，可以按照引用[2]中的方法设计数据库表，并在切面中调用Service层将
日志信息保存到数据库。
### 总结
通过以上步骤，我们可以在Spring Boot应用中利用
AOP实现接口请求
日志记录。这种方法非侵
入式，只需添加一个切面类，即可统一处理所有Controller的请求
日志。
§§相关问题§§
1. 如何优化
AOP日志记录的性能?
2. 如何避免记录敏感信息的
日志?
3. 如何将
日志记录到数据库?</think>### Spring Boot
AOP 实现接口请求
日志记录方法
以下是使用 Spring Boot
AOP 实现接口请求
日志记录的完整步骤：
---
#### 1. **添加依赖**
在 `pom.xml` 中添加
AOP 依赖：
```xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-
aop</artifactId>
</dependency>
```
---
#### 2. **创建切面类**
定义切面类处理
日志记录逻辑：
```java
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
@Aspect
@Component
public class RequestLogAspect {
// 定义切点：拦截所有Controller层方法
@Pointcut("execution(* com.example.controller..*.*(..))")
public void requestLogPointcut() {}
// 前置通知：记录请求信息
@Before("requestLogPointcut()")
public void logRequest(JoinPoint joinPoint) {
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
// 构建
日志信息
String log = String.format("Request | Time: %s | IP: %s | Method: %s |
URI: %s | Args: %s",
LocalDateTime.now(),
request.getRemoteAddr(),
request.getMethod(),
request.getRequest
URI(),
Arrays.toString(joinPoint.getArgs()));
System.out.println(log); // 实际项目中替换为Logger
}
// 后置通知：记录响应信息
@AfterReturning(pointcut = "requestLogPointcut()", returning = "result")
public void logResponse(JoinPoint joinPoint, Object result) {
String log = String.format("Response | Time: %s | Method: %s | Result: %s",
LocalDateTime.now(),
joinPoint.getSignature().getName(),
result);
System.out.println(log); // 实际项目中替换为Logger
}
}
```
---
#### 3. **关键
配置说明**
- **切点表达式**：`execution(* com.example.controller..*.*(..))`
表示拦截 `com.example.controller` 包下所有类的所有方法。
- **获取请求信息**：通过 `RequestContextHolder` 获取当前 HTTP 请求对象。
- **
日志内容**：
- **请求
日志**：时间、客户端 IP、HTTP 方法、
URI、
参数。
- **响应
日志**：时间、方法
名、
返回值。
---
#### 4. **扩展功能**
##### (1) 记录到数据库（引用[2]）
设计
日志表结构：
```sql
CREATE TABLE api_log (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
ip VARCHAR(20),
method VARCHAR(10),
uri VARCHAR(255),
args TEXT,
result TEXT,
create_time DATETIME
);
```
在切面中注
入 `JdbcTemplate` 或 `Repository` 保存
日志。
##### (2) 添加 Trace ID（引用[5]）
实现分布式链路追踪：
```java
// 在请求头中添加 traceId
String traceId = UUID.randomUUID().toString();
MDC.put("traceId", traceId); // 使用 SLF4J 的 MDC
//
日志格式中增加 %X{traceId}
// 示例：logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} [%X{traceId}] %-5level %logger{36} - %msg%n
```
##### (3) 排除敏感
参数
使用自定义注解过滤敏感字段：
```java
@Before("requestLogPointcut()")
public void logRequest(JoinPoint joinPoint) {
Object[] args = joinPoint.getArgs();
for (int i = 0; i < args.length; i++) {
if (args[i] instanceof UserDTO) {
args[i] = ((UserDTO) args[i]).maskPassword(); // 脱敏处理
}
}
// 记录脱敏后的
参数
}
```
---
#### 5. **优化建议**
1. **性能优化**：
- 异步记录
日志：使用 `@Async` 注解异步保存
日志。
- 批量插
入：攒批处理数据库写
入（如每 10 条批量插
入）[^2]。
2. **动态开关**：
通过
配置中心动态启停
日志：
```java
@Before("requestLogPointcut() && @annotation(enableLogging)")
public void logIfEnabled(JoinPoint joinPoint, EnableLogging enableLogging) {
if (enableLogging.value()) { ... }
}
```
---
#### **总结**
通过
AOP 实现接口
日志记录的核心步骤：
1. 添加 `spring-boot-starter-
aop` 依赖。
2. 定义切面类，使用 `@Pointcut` 定位拦截范围。
3. 通过 `@Before` 记录请求信息，`@AfterReturning` 记录响应信息。
4. 结合 `HttpServletRequest` 和 `JoinPoint` 获取请求上下文。
5. 扩展功能：数据库存储、链路追踪、敏感信息过滤。
> 此方法避免了业务代码耦合，统一处理
日志逻辑[^1][^3]，适用于监控、审计、调试等场景[^5]。
---
本文介绍了如何在Spring应用中通过Maven配置依赖，使用javassist处理参数并结合Gson库，实现统一的日志打印。重点展示了AOP切面的配置和使用，以及如何在前后方法调用前后获取和打印参数信息。
扫一扫
1086
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
