How to Use AOP for Logging in Spring Boot Applications

Use @Aspect to define a logging aspect class and @Around advice to intercept method calls in Spring Boot. Enable AOP with @EnableAspectJAutoProxy and create pointcuts to specify where logging should happen.

Syntax

To use AOP for logging in Spring Boot, you create an @Aspect class with advice methods like @Before, @After, or @Around. You define pointcuts to specify which methods to intercept. Enable AOP support with @EnableAspectJAutoProxy in your configuration.

• @Aspect: Marks the class as an aspect.
• @Around: Advice that wraps method execution, useful for logging before and after.
• ProceedingJoinPoint: Represents the method being intercepted, allowing control over execution.
• @EnableAspectJAutoProxy: Enables Spring’s AOP proxy support.

java

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
@Aspect
public class LoggingAspect {

    @Around("execution(* com.example..*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Entering method: " + joinPoint.getSignature().toShortString());
        Object result = joinPoint.proceed();
        System.out.println("Exiting method: " + joinPoint.getSignature().toShortString());
        return result;
    }
}

Example

This example shows a Spring Boot application with a logging aspect that logs method entry and exit for all methods in the com.example.service package.

java

package com.example;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;

@SpringBootApplication
@EnableAspectJAutoProxy
public class DemoApplication {
    public static void main(String[] args) {
        var context = SpringApplication.run(DemoApplication.class, args);
        SampleService service = context.getBean(SampleService.class);
        service.performTask("Test");
    }
}

@Component
class SampleService {
    public void performTask(String name) {
        System.out.println("Performing task for: " + name);
    }
}

@Aspect
@Component
class LoggingAspect {
    @Around("execution(* com.example..*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("[LOG] Entering: " + joinPoint.getSignature().toShortString());
        Object result = joinPoint.proceed();
        System.out.println("[LOG] Exiting: " + joinPoint.getSignature().toShortString());
        return result;
    }
}

Output

[LOG] Entering: void com.example.SampleService.performTask(String)
Performing task for: Test
[LOG] Exiting: void com.example.SampleService.performTask(String)

Common Pitfalls

• Not enabling @EnableAspectJAutoProxy causes aspects not to work.
• Using new to create beans bypasses Spring proxy, so aspects won’t apply.
• Incorrect pointcut expressions may miss target methods or include unwanted ones.
• Logging too much in @Around can slow down your app; keep it simple.

java

/* Wrong: Aspect without enabling proxy */
@Aspect
@Component
public class LoggingAspect {
    @Around("execution(* com.example..*(..))")
    public Object log(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("Log start");
        Object result = jp.proceed();
        System.out.println("Log end");
        return result;
    }
}

/* Right: Enable proxy in config */
@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
}

Quick Reference

• @Aspect: Define aspect class.
• @Around: Wrap method execution for logging.
• Pointcut: Use expressions like execution(* com.example..*(..)) to select methods.
• @EnableAspectJAutoProxy: Enable Spring AOP support.
• ProceedingJoinPoint: Control method execution inside advice.

Key Takeaways

Enable AOP in Spring Boot with @EnableAspectJAutoProxy to activate aspects.

Create an @Aspect class with @Around advice to log method entry and exit.

Use precise pointcut expressions to target the right methods for logging.

Avoid creating beans with new; always let Spring manage them for AOP to work.

Keep logging concise to prevent performance issues.