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);

    // 定义切点，可以根据实际需求调整，例如只作用于特定包下的方法
    // @Pointcut("within(com.example.myapp.service..*)")
    // public void serviceMethods() {}

    // 使用 @Around 通知环绕目标方法
    @Around("@annotation(com.example.myapp.annotation.LogExecutionTime)") // 假设我们定义了一个自定义注解
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        Instant start = Instant.now();
        Object result;
        try {
            // 执行目标方法
            result = joinPoint.proceed();
        } catch (Exception ex) {
            // 捕获异常，记录执行时间
            Instant end = Instant.now();
            long executionTimeMillis = Duration.between(start, end).toMillis();
            logger.error("方法 {} 执行异常，耗时 {} ms. 异常信息: {}", 
                         joinPoint.getSignature().toShortString(), 
                         executionTimeMillis, 
                         ex.getMessage(), 
                         ex);
            // 重新抛出异常，以便ExceptionHandler可以捕获
            throw ex; 
        }

        Instant end = Instant.now();
        long executionTimeMillis = Duration.between(start, end).toMillis();
        logger.info("方法 {} 执行成功，耗时 {} ms.", 
                    joinPoint.getSignature().toShortString(), 
                    executionTimeMillis);
        return result;
    }
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogExecutionTime {
}

@Service
public class MyService {

    @LogExecutionTime
    public String doSomeFancyStuff() throws Exception {
        // 模拟耗时操作
        Thread.sleep(500); 
        // 模拟可能抛出异常
        // if (true) throw new RuntimeException("Something went wrong!");
        return "Task Completed";
    }
}

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.getMessage(), originalCause);
        this.executionDuration = executionDuration;
        this.originalCause = originalCause;
    }

    public Duration getExecutionDuration() {
        return executionDuration;
    }

    public Throwable getOriginalCause() {
        return originalCause;
    }
}

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

@Service
public class MyLegacyService {

    public String doSomethingWithTimingAndException() {
        Instant start = Instant.now();
        try {
            // 模拟一些业务逻辑
            Thread.sleep(300);
            if (true) { // 模拟抛出异常的条件
                throw new IllegalArgumentException("Invalid input data!");
            }
            return "Operation successful";
        } catch (Exception e) {
            Instant end = Instant.now();
            Duration executionTime = Duration.between(start, end);
            // 封装原始异常和执行时间
            throw new TimeMeasuredException(executionTime, e);
        }
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler(TimeMeasuredException.class)
    public ResponseEntity<ErrorResponse> handleTimeMeasuredException(TimeMeasuredException ex) {
        long executionTimeMillis = ex.getExecutionDuration().toMillis();
        String originalErrorMessage = ex.getOriginalCause().getMessage();

        logger.error("捕获到TimeMeasuredException，方法执行耗时: {} ms. 原始错误: {}", 
                     executionTimeMillis, 
                     originalErrorMessage, 
                     ex);

        ErrorResponse errorResponse = new ErrorResponse(
            HttpStatus.INTERNAL_SERVER_ERROR.value(),
            "操作失败，耗时: " + executionTimeMillis + " ms. 详情: " + originalErrorMessage
        );
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    // 如果希望捕获所有异常并检查是否为TimeMeasuredException
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGeneralException(Exception e) {
        if (e instanceof TimeMeasuredException) {
            return handleTimeMeasuredException((TimeMeasuredException) e);
        }

        logger.error("捕获到通用异常: {}", e.getMessage(), e);
        ErrorResponse errorResponse = new ErrorResponse(
            HttpStatus.INTERNAL_SERVER_ERROR.value(),
            "服务器内部错误：" + e.getMessage()
        );
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    // 假设的错误响应类
    static class ErrorResponse {
        public int status;
        public String message;

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