基于 Slf4j 和 AOP 的主动化方法实行时间日志记录方案

前言

实在这个需求很简朴，但是这个需求又是项目中必不可少的，尤其对于性能调优这块，但是使用哪种方式更加方便呢，这就是本篇博文需要讨论的重点
体系时间

可以通过 System.currentTimeMillis() 或 System.nanoTime() 来实现。
以下是一个简朴的示例，展示如何记录某段代码的实行时间并打印日志：

1. import java.util.logging.Logger;
3. public class TimeLogger {
4.     private static final Logger logger = Logger.getLogger(TimeLogger.class.getName());
6.     public static void main(String[] args) {
7.         long startTime = System.nanoTime(); // 记录开始时间
9.         // 你的代码逻辑
10.         performTask();
12.         long endTime = System.nanoTime(); // 记录结束时间
13.         long duration = endTime - startTime; // 计算耗时
15.         logger.info("Task executed in " + duration + " nanoseconds.");
16.     }
18.     private static void performTask() {
19.         try {
20.             Thread.sleep(2000); // 模拟耗时操作
21.         } catch (InterruptedException e) {
22.             e.printStackTrace();
23.         }
24.     }
25. }

复制代码

解释：

• System.nanoTime()：返回当前时间的纳秒值，适合计算时间差。
  
• 计算耗时后，通过日志框架（如 Logger）打印出来。
  

如果你使用的是其他日志框架（如 Log4j 或 SLF4J），可以相应地调整日志打印部分。
这个方法实用于丈量较精确的时间差。如果是需要秒级别的时间，可以使用 System.currentTimeMillis()。
使用 Instant 和 Duration（Java 8+）

Java 8 引入了 java.time 包，可以使用 Instant 来获取时间戳，并使用 Duration 来计算时间差。

1. import java.time.Duration;
2. import java.time.Instant;
3. import java.util.logging.Logger;
5. public class TimeLogger {
6.     private static final Logger logger = Logger.getLogger(TimeLogger.class.getName());
8.     public static void main(String[] args) {
9.         Instant start = Instant.now(); // 记录开始时间
11.         // 你的代码逻辑
12.         performTask();
14.         Instant end = Instant.now(); // 记录结束时间
15.         Duration duration = Duration.between(start, end); // 计算时间差
17.         logger.info("Task executed in " + duration.toMillis() + " milliseconds.");
18.     }
20.     private static void performTask() {
21.         try {
22.             Thread.sleep(2000); // 模拟耗时操作
23.         } catch (InterruptedException e) {
24.             e.printStackTrace();
25.         }
26.     }
27. }

复制代码

使用 StopWatch（Apache Commons Lang）

StopWatch 是 Apache Commons Lang 提供的一个便捷工具类，用于丈量时间。它简朴易用，并且可以多次启动和停止。
起首，你需要引入 Apache Commons Lang 库：

1. <dependency>
2.     <groupId>org.apache.commons</groupId>
3.     <artifactId>commons-lang3</artifactId>
4.     <version>3.12.0</version>
5. </dependency>

复制代码

然后，可以像如许使用 StopWatch：

1. import org.apache.commons.lang3.time.StopWatch;
2. import java.util.logging.Logger;
4. public class TimeLogger {
5.     private static final Logger logger = Logger.getLogger(TimeLogger.class.getName());
7.     public static void main(String[] args) {
8.         StopWatch stopWatch = new StopWatch();
9.         stopWatch.start(); // 开始计时
11.         // 你的代码逻辑
12.         performTask();
14.         stopWatch.stop(); // 停止计时
15.         logger.info("Task executed in " + stopWatch.getTime() + " milliseconds.");
16.     }
18.     private static void performTask() {
19.         try {
20.             Thread.sleep(2000); // 模拟耗时操作
21.         } catch (InterruptedException e) {
22.             e.printStackTrace();
23.         }
24.     }
25. }

复制代码

使用 AOP 进行日志记录（面向切面编程）

如果你希望在多个方法或类中都记录耗时，可以使用 Spring AOP 或其他 AOP 框架来主动化这一过程。如许，你就不需要在每个方法中显式地编写时间计算代码。
假设你使用的是 Spring 框架，可以通过 AOP 实现：
自界说一个注解

1. @Retention(RetentionPolicy.RUNTIME)
2. @Target(ElementType.METHOD)
3. public @interface PrintExecutionTime {
5. }

复制代码

面向切面

1. @Slf4j
2. @Aspect
3. @Component
4. @RequiredArgsConstructor
5. public class ExecutionTimeAspect {
7.     private final LogConfig logConfig;
9.     @Around("@annotation(PrintExecutionTime)")
10.     public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
11.         long startTime = System.currentTimeMillis();
13.         Object result = joinPoint.proceed();
15.         long endTime = System.currentTimeMillis();
16.         long executionTime = endTime - startTime;
18.         if (executionTime > logConfig.getTime()) {
19.             log.warn("Code method time-consuming, class: {}, executionTime: {} ms", joinPoint.getSignature().toString(),
20.                 executionTime);
21.         }
23.         return result;
24.     }
25. }

复制代码

使用 Slf4j + Logback 配合计时器（比方，通过 MDC 传递信息）

如果你已经在使用 SLF4J 和 Logback，SLF4J 提供了一些扩展，可以通过 MDC 来传递方法的实行时间等信息。

1. import org.slf4j.MDC;
2. import org.slf4j.Logger;
3. import org.slf4j.LoggerFactory;
5. public class TimeLogger {
6.     private static final Logger logger = LoggerFactory.getLogger(TimeLogger.class);
8.     public static void main(String[] args) {
9.         long startTime = System.nanoTime(); // 记录开始时间
11.         // 你的代码逻辑
12.         performTask();
14.         long endTime = System.nanoTime(); // 记录结束时间
15.         long duration = endTime - startTime; // 计算耗时
17.         MDC.put("executionTime", String.valueOf(duration)); // 将耗时信息放入 MDC
18.         logger.info("Task executed.");
19.         MDC.clear(); // 清理 MDC
20.     }
22.     private static void performTask() {
23.         try {
24.             Thread.sleep(2000); // 模拟耗时操作
25.         } catch (InterruptedException e) {
26.             e.printStackTrace();
27.         }
28.     }
29. }

复制代码

在 Logback 设置中，你可以使用 %X{executionTime} 来输出 MDC 中的 executionTime：

1. <layout class="ch.qos.logback.classic.pattern.PatternLayout">
2.     <Pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg - Execution Time: %X{executionTime}ms%n</Pattern>
3. </layout>

复制代码

Slf4j + Logback +MDC+AOP

在实际项目中使用 Slf4j + Logback 配合计时器 并通过 MDC (Mapped Diagnostic Context) 传递信息来记录方法实行时间是一个很常见且高效的方案。如允许以在日志输出中直接查看方法的实行时间，而无需在每个方法中显式记录时间。

1. import org.aspectj.lang.annotation.Aspect;
2. import org.aspectj.lang.annotation.Around;
3. import org.aspectj.lang.annotation.Pointcut;
4. import org.aspectj.lang.ProceedingJoinPoint;
5. import org.slf4j.MDC;
6. import org.springframework.stereotype.Component;
8. import java.time.Duration;
9. import java.time.Instant;
11. @Aspect
12. @Component
13. public class PerformanceAspect {
15.     @Pointcut("execution(* com.example..*(..))") // 定义切点，匹配指定包下的所有方法
16.     public void performanceLogging() {
17.     }
19.     @Around("performanceLogging()") // 环绕通知
20.     public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
21.         // 记录方法开始时间
22.         Instant start = Instant.now();
24.         // 执行目标方法
25.         Object proceed = joinPoint.proceed();
27.         // 记录方法结束时间
28.         Instant end = Instant.now();
29.         long executionTime = Duration.between(start, end).toMillis();
31.         // 将耗时信息传入 MDC
32.         MDC.put("executionTime", String.valueOf(executionTime));
34.         // 打印日志
35.         String methodName = joinPoint.getSignature().toShortString();
36.         // 如果你在日志中想要包括方法名称、类名等，可以在这里添加
37.         logger.info("Method {} executed in {} ms", methodName, executionTime);
39.         // 清除 MDC，避免 MDC 数据影响其他日志
40.         MDC.clear();
42.         return proceed;
43.     }
44. }

复制代码

1. <configuration>
3.     <!-- Define the pattern for logging -->
4.     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
5.         <encoder>
6.             <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg - Execution Time: %X{executionTime}ms%n</pattern>
7.         </encoder>
8.     </appender>
10.     <!-- Root logger definition -->
11.     <root level="debug">
12.         <appender-ref ref="console"/>
13.     </root>
15. </configuration>

复制代码

使用 @EnableAspectJAutoProxy
如果你使用 Spring Boot，可以通过 @EnableAspectJAutoProxy 启用 AOP
在 @SpringBootApplication 或设置类中添加：

1. import org.springframework.boot.SpringApplication;
2. import org.springframework.boot.autoconfigure.SpringBootApplication;
3. import org.springframework.context.annotation.EnableAspectJAutoProxy;
5. @SpringBootApplication
6. @EnableAspectJAutoProxy
7. public class Application {
8.     public static void main(String[] args) {
9.         SpringApplication.run(Application.class, args);
10.     }
11. }

复制代码

总结

1. [开始方法] → [AOP 拦截] → [开始计时] → [业务逻辑执行] → [结束计时] → [MDC 存储时间]
2.                                ↓
3.                              [日志输出] ← [MDC 输出时间]  

复制代码

通过团结 Slf4j + Logback 和 AOP，我们可以主动化地记录方法实行的时间，并将其通过 MDC 传递到日志体系中，而无需手动添加时间记录的代码。这种方式在生产环境中非常方便，可以让你实时相识应用的性能瓶颈，且对代码的侵入性非常低。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。