Spring Boot中优雅地记录方法执行时间并结合异常处理

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.time.Instant;

@Aspect
@Component
public class PerformanceMonitorAspect {

    private static final Logger log = LoggerFactory.getLogger(PerformanceMonitorAspect.class);

    // 定义切点，这里以所有Service层方法为例
    // 你可以根据需要调整切点表达式，例如特定注解、特定包下的所有方法等
    @Around("execution(* com.example.app.service.*.*(..))")
    public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        Instant start = Instant.now();
        Object result;
        String methodName = joinPoint.getSignature().toShortString();

        try {
            result = joinPoint.proceed(); // 执行目标方法
        } catch (Throwable e) {
            Instant end = Instant.now();
            long executionTime = Duration.between(start, end).toMillis();
            log.error("方法 {} 执行异常，耗时 {} ms. 异常信息: {}", methodName, executionTime, e.getMessage(), e);
            throw e; // 重新抛出异常，以便ExceptionHandler能够捕获
        }

        Instant end = Instant.now();
        long executionTime = Duration.between(start, end).toMillis();
        log.info("方法 {} 正常执行完成，耗时 {} ms", methodName, executionTime);
        return result;
    }
}

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {

    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleAllExceptions(Exception e) {
        // 这里的e就是由PerformanceMonitorAspect重新抛出的原始异常
        // 在切面中已经记录了执行时间，这里可以专注于异常响应的构建
        log.error("全局异常处理器捕获到异常: {}", e.getMessage(), e);
        return new ResponseEntity<>("服务器内部错误：" + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

import java.time.Duration;

public class TimeMeasuredException extends RuntimeException {

    private final Duration executionDuration;
    private final Throwable originalCause; // 存储原始异常

    public TimeMeasuredException(Duration executionDuration, Throwable originalCause) {
        super("方法执行异常，耗时 " + executionDuration.toMillis() + " ms", originalCause);
        this.executionDuration = executionDuration;
        this.originalCause = originalCause;
    }

    public Duration getExecutionDuration() {
        return executionDuration;
    }

    public Throwable getOriginalCause() {
        return originalCause;
    }
}

import java.time.Duration;
import java.time.Instant;

public class MyService {

    public void doSomeFancyStuff() {
        Instant start = Instant.now();
        try {
            // ... 你的业务逻辑代码 ...
            if (Math.random() > 0.5) {
                throw new RuntimeException("模拟业务异常");
            }
            // ...
        } catch (Exception e) {
            Instant end = Instant.now();
            Duration executionTime = Duration.between(start, end);
            // 捕获到原始异常后，计算时间并抛出自定义异常
            throw new TimeMeasuredException(executionTime, e);
        }
    }
}

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.time.Instant;

@Aspect
@Component
public class TimeMeasuringAspectWithCustomException {

    @Around("execution(* com.example.app.service.*.*(..))")
    public Object measureAndWrapException(ProceedingJoinPoint joinPoint) throws Throwable {
        Instant start = Instant.now();
        Object result;
        try {
            result = joinPoint.proceed(); // 执行目标方法
        } catch (Throwable e) {
            Instant end = Instant.now();
            Duration executionTime = Duration.between(start, end);
            // 捕获到原始异常后，计算时间并抛出自定义异常
            throw new TimeMeasuredException(executionTime, e);
        }
        return result;
    }
}

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {

    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler(TimeMeasuredException.class)
    public ResponseEntity<String> handleTimeMeasuredException(TimeMeasuredException e) {
        log.error("捕获到带有执行时间的异常，耗时 {} ms. 原始异常信息: {}", 
                  e.getExecutionDuration().toMillis(), e.getOriginalCause().getMessage(), e.getOriginalCause());
        return new ResponseEntity<>("业务处理失败，耗时 " + e.getExecutionDuration().toMillis() + " ms. 错误详情: " + e.getOriginalCause().getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }

    // 仍然可以保留一个通用的异常处理器来捕获其他未被TimeMeasuredException包装的异常
    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleAllOtherExceptions(Exception e) {
        log.error("捕获到其他未处理的异常: {}", e.getMessage(), e);
        return new ResponseEntity<>("服务器内部错误：" + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}