Spring Boot Aspect-Oriented Programming (AOP)

1. The Big Idea

AOP means Aspect-Oriented Programming. It is useful when the same behavior must apply across many classes or methods, such as logging, auditing, timing, security-related checks or transaction infrastructure.

Many business methods
        ↓
same cross-cutting concern
        ↓
        AOP
        ↓
one reusable aspect

2. OOP vs AOP

3. Spring Boot AOP Defaults

4. Cross-Cutting Concerns

A cross-cutting concern affects multiple unrelated parts of an application.

Without AOP, repeated infrastructure code can be placed inside every method. With AOP, the behavior can be defined once and applied through a pointcut.

5. Important AOP Terminology

6. How Spring AOP Works

Caller
  ↓
Spring AOP proxy
  ↓
Advice
  ↓
Target method
  ↓
Advice / return
  ↓
Caller

Spring AOP is proxy-based. The proxy intercepts eligible calls and applies the configured advice around the target method.

7. CGLIB Proxies

Spring Boot's default AOP proxy strategy is CGLIB. This is class-based proxying and is useful when the target is a concrete class.

public class OrderService {
    public void createOrder() {
        // business logic
    }
}

8. JDK Dynamic Proxies

To use JDK dynamic proxies instead:

spring.aop.proxy-target-class=false

9. AspectJ and Spring Boot

If AspectJ is on the classpath, Spring Boot's auto-configuration automatically enables AspectJ auto-proxy support. Therefore, you do not need to manually add:

@EnableAspectJAutoProxy

10. Creating a Basic Aspect

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service..*(..))")
    public void beforeServiceMethod() {
        System.out.println("Service method called");
    }
}

11. Advice Types

12. Before Advice

@Before("execution(* com.example.service..*(..))")
public void before() {
    System.out.println("Before service method");
}

Flow:

@Before → target method → return

13. After Returning Advice

@AfterReturning(
    pointcut = "execution(* com.example.service..*(..))",
    returning = "result"
)
public void afterReturning(Object result) {
    System.out.println("Result = " + result);
}

This advice runs only after normal completion.

14. After Throwing Advice

@AfterThrowing(
    pointcut = "execution(* com.example.service..*(..))",
    throwing = "ex"
)
public void afterThrowing(Exception ex) {
    System.out.println("Failure: " + ex.getMessage());
}

This advice runs when a matched method exits by throwing an exception.

15. After Advice

@After("execution(* com.example.service..*(..))")
public void after() {
    System.out.println("Method finished");
}

Think of @After as finally-like behavior: it runs regardless of normal or exceptional completion.

16. Around Advice

@Around("execution(* com.example.service..*(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {

    long start = System.currentTimeMillis();

    Object result = joinPoint.proceed();

    long time = System.currentTimeMillis() - start;

    System.out.println("Execution time: " + time + " ms");

    return result;
}

@Around starts
     ↓
before logic
     ↓
joinPoint.proceed()
     ↓
target method
     ↓
after logic
     ↓
return result

17. Pointcuts

A pointcut tells Spring which method executions should receive advice.

execution(* com.example.service..*(..))

Conceptually:

execution(
  any return type
  com.example.service package/subpackages
  any method
  any arguments
)

Examples:

execution(* com.example.service.OrderService.createOrder(..))

execution(* com.example.service..*(..))

execution(public * com.example.service..*(..))

18. Aspect = Pointcut + Advice

@Before("execution(* com.example.service..*(..))")
public void log() {
    System.out.println("Service called");
}

The pointcut answers where. The advice method answers what.

19. Practical Example: Performance Timing

@Aspect
@Component
public class PerformanceAspect {

    @Around("execution(* com.example.service..*(..))")
    public Object measure(ProceedingJoinPoint pjp) throws Throwable {

        long start = System.nanoTime();
        Object result = pjp.proceed();
        long duration = System.nanoTime() - start;

        System.out.println(
            pjp.getSignature().getName()
            + " took " + duration + " ns"
        );

        return result;
    }
}

One aspect can measure many service methods without putting timing code into each service.

20. Practical Example: Auditing

@AfterReturning(
    pointcut = "execution(* com.example.service.OrderService.create*(..))"
)
public void audit() {
    System.out.println("Order operation completed");
}

This illustrates a cross-cutting audit concern. In production, use an appropriate audit/logging infrastructure rather than relying only on System.out.

21. Practical Example: Security-Related Check

@Before("execution(* com.example.admin..*(..))")
public void checkAccess() {
    // check current user's permission
}

This demonstrates the AOP idea. For real authentication and authorization, Spring Security is generally the more appropriate dedicated solution.

22. Spring AOP vs Full AspectJ

23. Self-Invocation — Important Limitation

Because Spring AOP is proxy-based, an internal call from one method to another method on the same target object can bypass the proxy.

class OrderService {
    public void methodA() {
        methodB(); // direct internal call
    }

    public void methodB() {
        // advice may not run here
    }
}

external caller
     ↓
Spring proxy
     ↓
methodA()
     ↓
this.methodB()
     ↓
target object directly

24. AOP and Transactions

Transaction management is a classic cross-cutting concern.

@Transactional
public void placeOrder() {
    // database operations
}

caller
  ↓
proxy
  ↓
begin transaction
  ↓
placeOrder()
  ↓
commit / rollback

This is the type of infrastructure behavior AOP helps apply declaratively around business operations.

25. Good AOP Use Cases

26. When Not to Use AOP

• When behavior belongs to one business method.
• When normal composition is simpler.
• When AOP makes execution flow difficult to understand.
• When another Spring feature already solves the problem better.
• When a pointcut would unintentionally affect too many methods.

27. Spring Boot Configuration

spring.aop.proxy-target-class=true

This represents the default CGLIB/class-based strategy.

To use JDK proxies:

spring.aop.proxy-target-class=false

28. Common Mistakes

1. Thinking AOP intercepts everything. A pointcut must match.
2. Forgetting Spring bean registration. A typical aspect needs component registration.
3. Using overly broad pointcuts. They can affect unrelated methods.
4. Using @Around everywhere. Prefer simpler advice when possible.
5. Forgetting proceed(). The target may not execute.
6. Expecting self-invocation to trigger advice. Internal calls can bypass the proxy.
7. Changing proxy strategy without a reason. Boot's default is usually sufficient.
8. Adding @EnableAspectJAutoProxy unnecessarily. Boot can auto-configure it when AspectJ is present.

29. Best Practices

• Keep pointcuts narrow and intentional.
• Use meaningful aspect names.
• Prefer the simplest advice type that works.
• Keep business logic separate from infrastructure concerns.
• Document important aspects because they affect control flow indirectly.
• Test both intercepted and non-intercepted methods.
• Understand proxy behavior before debugging missing advice.
• Use dedicated Spring infrastructure when it already solves the problem.

30. Interview Questions

spring.aop.proxy-target-class=false

31. Practice Exercises

1. Create a service and a simple @Aspect.
2. Add @Before logging.
3. Add @AfterReturning result logging.
4. Add @AfterThrowing exception logging.
5. Create an @Around timing aspect.
6. Experiment with narrow and broad pointcuts.
7. Set spring.aop.proxy-target-class=false and inspect behavior.
8. Create a self-invocation example.
9. Explain aspect vs advice vs pointcut vs proxy.
10. Design an auditing aspect for service operations.

32. Quick Cheat Sheet

33. Memory Map

34. Final Takeaway

Aspect
  ↓
Pointcut = WHERE
  ↓
Advice = WHAT
  ↓
Spring Proxy
  ↓
Target Method