基于AspectJ、Spring的AOP如何处理方法内部日志？

Great question! Handling logging at arbitrary points inside a method with AOP is a common hurdle when you’ve mastered the basics like @Before and @After advice. Let’s walk through practical solutions based on your setup:

1. Refactor with Custom Annotations (Spring AOP Friendly) #

If you want to stick with Spring AOP (proxy-based, easier to set up), you can’t directly target inline code inside a method—but you can refactor the logged segments into small helper methods and apply AOP to those. Here’s how:

Step 1: Create a custom annotation to mark loggable actions #

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Loggable {
    String message() default "";
    Level level() default Level.INFO;
}

Step 2: Rewrite your business method to use annotated helpers #

Instead of inline logging calls, call tiny helper methods marked with @Loggable. Your business logic stays clean, and the logging logic moves to the aspect:

public void doSomething(String name, Object someObj) { 
    logEntry("doSomething()");
    int result; 
    // 复杂业务代码
    if(result != 0) { 
        logIssue("There is some issues, fix it...");
        // 其他代码
    } 
    logTrace("Did some more work, value is " + value); 
    // 其他业务代码
    logExit("doSomething()");
}

@Loggable(message = "Just entered {0}", level = Level.INFO)
private void logEntry(String methodName) {
    // Empty body—logging is handled by AOP
}

@Loggable(message = "{0}", level = Level.SEVERE)
private void logIssue(String message) {}

@Loggable(message = "{0}", level = Level.TRACE)
private void logTrace(String message) {}

@Loggable(message = "Returning from {0}...", level = Level.INFO)
private void logExit(String methodName) {}

Step 3: Build an aspect to handle the annotation #

This aspect will intercept any call to a @Loggable method and handle the logging:

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

    @Around("@annotation(loggable)")
    public Object handleLogging(ProceedingJoinPoint joinPoint, Loggable loggable) throws Throwable {
        // Format the message using method arguments
        String formattedMessage = MessageFormat.format(loggable.message(), joinPoint.getArgs());
        logger.log(loggable.level(), formattedMessage);
        return joinPoint.proceed(); // Execute the original helper method (empty here)
    }
}

2. Use Full AspectJ for Direct In-Method Targeting #

If refactoring isn’t an option, AspectJ (which supports compile-time or load-time weaving) can target specific inline code blocks directly—something Spring AOP can’t do. It’s more powerful but requires extra setup.

Example: Target the if-block and trace log in your method #

Define an aspect with pointcuts that match the exact locations you want to log:

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

    // Pointcut matching the if(result != 0) block in doSomething
    @Pointcut("execution(* your.package.YourClass.doSomething(..)) && if()")
    public void doSomethingIfBlock() {}

    @Before("doSomethingIfBlock()")
    public void logBeforeIfBlock() {
        logger.severe("There is some issues, fix it...");
    }

    // Pointcut matching the trace log call inside doSomething
    @Pointcut("execution(* your.package.YourClass.doSomething(..)) && " +
              "withincode(* your.package.YourClass.doSomething(..)) && " +
              "call(* org.slf4j.Logger.trace(..))")
    public void doSomethingTraceLog() {}

    @Around("doSomethingTraceLog()")
    public Object replaceTraceLog(ProceedingJoinPoint joinPoint) throws Throwable {
        // Capture the original log message and replace it with AOP-handled logging
        String originalMessage = (String) joinPoint.getArgs()[0];
        logger.trace("AOP-managed trace: {}", originalMessage);
        return null; // Skip the original inline log call
    }
}

In a Spring app, you’ll need to enable load-time weaving (via @EnableLoadTimeWeaving) or use the AspectJ compiler for compile-time weaving to make this work.

Quick Tips #

• Spring AOP vs AspectJ: Stick with Spring AOP if you can—it’s lighter and more intuitive. Use AspectJ only when you absolutely need to target inline code without refactoring.
• Maintainability: Annotated helper methods make your logging points explicit in the code, which is easier for your team to follow than hidden AspectJ pointcuts targeting inline logic.

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