Spring Boot中优雅地记录异常处理时的执行时间

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 ExecutionTimeAspect {

    private static final Logger logger = LoggerFactory.getLogger(ExecutionTimeAspect.class);

    /**
     * 定义一个切点，匹配所有在com.example.app.service包及其子包下的公共方法
     * 实际应用中可根据需求调整切点表达式
     */
    @Around("execution(public * com.example.app.service.*.*(..))")
    public Object logExecutionTimeAndHandleException(ProceedingJoinPoint joinPoint) throws Throwable {
        Instant start = Instant.now();
        Object result;
        try {
            // 执行目标方法
            result = joinPoint.proceed();
        } catch (Exception e) {
            Instant end = Instant.now();
            long executionTimeMillis = Duration.between(start, end).toMillis();
            logger.error("方法 {} 执行异常，耗时 {} ms. 异常信息: {}", 
                         joinPoint.getSignature().toShortString(), 
                         executionTimeMillis, 
                         e.getMessage(), 
                         e);
            // 重新抛出异常，以便ExceptionHandler能够捕获
            throw e; 
        } finally {
            // 无论是否发生异常，都会执行此处的逻辑
            // 如果没有异常，在这里记录成功执行的时间
            if (result != null) { // 简单判断，实际可能需要更复杂的逻辑
                Instant end = Instant.now();
                long executionTimeMillis = Duration.between(start, end).toMillis();
                logger.info("方法 {} 成功执行，耗时 {} ms.", 
                            joinPoint.getSignature().toShortString(), 
                            executionTimeMillis);
            }
        }
        return result;
    }
}

import java.time.Duration;

public class TimeMeasuredException extends RuntimeException {
    private final Duration executionTime;
    private final Throwable originalCause; // 用于存储原始异常

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

    public Duration getExecutionTime() {
        return executionTime;
    }

    public Throwable getOriginalCause() {
        return originalCause;
    }
}

import org.springframework.stereotype.Service;
import java.time.Duration;
import java.time.Instant;

@Service
public class MyBusinessService {

    public String performComplexOperation() {
        Instant start = Instant.now();
        try {
            // 模拟一些复杂的业务逻辑，可能抛出异常
            if (Math.random() > 0.5) {
                throw new IllegalArgumentException("随机参数错误！");
            }
            Thread.sleep(200); // 模拟耗时操作
            return "操作成功完成";
        } catch (Exception ex) {
            Instant end = Instant.now();
            Duration executionTime = Duration.between(start, end);
            // 捕获原始异常，并抛出自定义的TimeMeasuredException
            throw new TimeMeasuredException(executionTime, ex);
        }
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GlobalExceptionHandler {

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

    @ExceptionHandler(TimeMeasuredException.class)
    public ResponseEntity<ErrorResponse> handleTimeMeasuredException(TimeMeasuredException ex) {
        // 从自定义异常中获取执行时间
        long executionTimeMillis = ex.getExecutionTime().toMillis();
        // 获取原始异常
        Throwable originalCause = ex.getOriginalCause();

        logger.error("请求处理异常，耗时 {} ms. 原始异常类型: {}, 消息: {}", 
                     executionTimeMillis, 
                     originalCause.getClass().getSimpleName(), 
                     originalCause.getMessage(), 
                     originalCause);

        ErrorResponse errorResponse = new ErrorResponse(
                HttpStatus.INTERNAL_SERVER_ERROR.value(),
                "处理请求失败: " + originalCause.getMessage(),
                executionTimeMillis + " ms"
        );
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    // 也可以捕获所有Exception，然后检查是否是TimeMeasuredException的实例
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGenericException(Exception e) {
        if (e instanceof TimeMeasuredException) {
            return handleTimeMeasuredException((TimeMeasuredException) e);
        }
        // 处理其他未被TimeMeasuredException包装的通用异常
        logger.error("发生未知异常: {}", e.getMessage(), e);
        ErrorResponse errorResponse = new ErrorResponse(
                HttpStatus.INTERNAL_SERVER_ERROR.value(),
                "服务器内部错误",
                "未知"
        );
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    // 辅助类用于构建统一的错误响应
    static class ErrorResponse {
        public int status;
        public String message;
        public String executionTime;

        public ErrorResponse(int status, String message, String executionTime) {
            this.status = status;
            this.message = message;
            this.executionTime = executionTime;
        }
    }
}