Spring通用异常处理方法咨询：现有项目异常日志优化需求

Absolutely! This is a classic scenario where AOP (Aspect-Oriented Programming) or global exception interceptors shine—they let you inject custom exception logging logic without touching a single line of your existing business code. Let’s walk through practical implementations, starting with the most common approach for enterprise Java apps (Spring):

AOP lets you define "cross-cutting concerns" (like logging) that apply across multiple classes/methods. You’ll create an aspect that catches exceptions after they’re thrown, logs them in your new format, and lets the exception propagate to its original handler.

Step 1: Add AOP Dependency (Spring Boot) #

If you’re using Spring Boot, include this in your pom.xml (Maven) or build.gradle:

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

Step 2: Create the Exception Logging Aspect #

Define a component class with @Aspect to handle exception logging:

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class ExceptionLoggingAspect {
    private static final Logger logger = LoggerFactory.getLogger(ExceptionLoggingAspect.class);

    // Define a pointcut to target all methods in your project's core package
    @AfterThrowing(
        pointcut = "execution(* com.yourcompany.yourproject..*.*(..))",
        throwing = "ex"
    )
    public void logException(JoinPoint joinPoint, Throwable ex) {
        // Build your custom error message format
        String detailedError = String.format(
            "Exception Details:\n" +
            "  Class: %s\n" +
            "  Method: %s\n" +
            "  Arguments: %s\n" +
            "  Exception Type: %s\n" +
            "  Message: %s",
            joinPoint.getTarget().getClass().getSimpleName(),
            joinPoint.getSignature().getName(),
            joinPoint.getArgs(),
            ex.getClass().getName(),
            ex.getMessage()
        );

        // Log using your new format (include stack trace for debugging)
        logger.error(detailedError, ex);

        // No need to rethrow— the exception will automatically continue to its original handler
    }
}

Step 3: Enable AOP (If Needed) #

Spring Boot enables AOP by default, but if you’re using a traditional Spring app, add @EnableAspectJAutoProxy to your configuration class.

If your project is a web app, you can use Spring’s @ControllerAdvice to catch exceptions at the controller layer, log them, and preserve the original flow:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalWebExceptionHandler {
    private static final Logger logger = LoggerFactory.getLogger(GlobalWebExceptionHandler.class);

    // Catch all exceptions thrown from controllers
    @ExceptionHandler(Throwable.class)
    public void logAndPropagateException(Throwable ex) {
        // Custom log format
        logger.error(
            "Web Exception Caught | Type: {} | Message: {}",
            ex.getClass().getName(),
            ex.getMessage(),
            ex
        );

        // Re-throw the exception to let the original error handling flow continue
        throw new RuntimeException(ex);
    }
}

• Targeted Pointcuts: Adjust the pointcut expression to avoid logging framework-internal exceptions or already-handled errors. For example, exclude methods with @ExceptionHandler annotations if needed.
• Preserve Original Flow: Never swallow exceptions unless you intend to—always let them propagate to their original handlers after logging.
• Non-Spring Apps: If you’re not using Spring, use Java’s dynamic proxy (InvocationHandler) or AspectJ’s compile-time weaving to wrap your classes and inject logging logic.
• Stack Traces: Always include the full stack trace in logs (the second argument to logger.error() does this) to make debugging easier.

This approach keeps your existing code untouched while adding consistent, structured exception logging across your entire application.

内容的提问来源于stack exchange，提问作者Nitin