Core Concepts of Spring AOP

Spring AOP is a framework that modularizes cross-cutting concerns like logging, security, and transactions in Spring applications.

It is based on seven core concepts:

Understanding these concepts helps in building clean, maintainable, and scalable Spring applications without mixing business logic with cross-cutting code.

1. Aspect

A module that encapsulates a cross-cutting concern, such as logging, security, or transaction management.

• Purpose: Keeps cross-cutting logic separate from business logic.
• Contains:
  • Advice: Actions to perform at specific points.
  • Pointcuts: Expressions specifying where advice applies.
• Annotation: @Aspect

Example:

@Aspect
@Component
publicclassLoggingAspect {

@Before("execution(* com.example.service.*.*(..))")
publicvoidlogBefore(JoinPoint joinPoint) {
        System.out.println("Executing method: " + joinPoint.getSignature());
    }
}

LoggingAspect encapsulates all logging-related behavior and can contain multiple advice methods.

2. Join Point

A specific point in program execution where an aspect can be applied.

• Common join points:
  • Method execution
  • Method call
  • Exception thrown
• In Spring AOP: Join points are always method executions (Spring AOP is proxy-based).

Example:

@Before("execution(* com.example.service.PaymentService.*(..))")
publicvoidlogBefore(JoinPoint joinPoint) {
    System.out.println("Method called: " + joinPoint.getSignature().getName());
}

Here, Each method execution in the service package is a join point.

3. Advice

Advice is the action taken by an aspect at a join point.

Types of Advice: Spring AOP provides different Advice types that define when cross-cutting logic (logging, security, transactions, etc.) executes relative to a method call.

a) @Before Advice

• Runs before the target method executes.
• Used for logging, validation, security checks before business logic.
• Cannot change return value or stop execution (unless exception is thrown).

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

b) @After Advice

• Runs after method execution, whether it succeeds or fails.
• Similar to a finally block.
• Used for cleanup and logging.

@After("execution(* com.example.service.*.*(..))")
publicvoidafter() {
    System.out.println("After method execution");
}

c) @AfterReturning Advice

• Runs only when the method returns successfully.
• Used to log or process returned data.
• Does not run if an exception occurs.

@AfterReturning(pointcut="execution(* com.example.service.*.*(..))",
                returning="result")
publicvoidafterReturn(Object result) {
    System.out.println("Returned: " + result);
}

d) @AfterThrowing Advice

• Runs only when an exception is thrown.
• Used for error logging and monitoring.
• Exception still propagates to caller.

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

e) @Around Advice

• Runs before and after method execution.
• Gives full control over method execution.
• Can modify inputs, outputs, or stop execution.

@Around("execution(* com.example.service.*.*(..))")
public Objectaround(ProceedingJoinPoint pjp)throws Throwable {
return pjp.proceed();
}

Quick Comparison Summary

4. Pointcut

Expression defining which join points an advice should apply to.

• Purpose: Selects where cross-cutting logic applies without changing business code.
• Reusability: Can be used across multiple advices.

Example:

@Pointcut("execution(* com.example.service.*.*(..))")
publicvoidserviceMethods() {}

@Before("serviceMethods()")
publicvoidlogBefore() { ... }

✅ All methods in the service package are selected for logging.

• Advanced: Combine multiple pointcuts using &&, ||, !.

5. Weaving

Process of linking aspects to target objects so that advice runs at join points.

Types of Weaving: Weaving is the process of linking an aspect (cross-cutting logic) with the target object at specific join points.

a) Compile-Time Weaving

• Aspects are woven during compilation of source code.
• Requires AspectJ compiler (ajc).
• Produces already-woven .class files.

Example:

Aspect

@Aspect
publicclassLogAspect {
@Before("execution(* com.example.service.*.*(..))")
publicvoidlog() {
        System.out.println("Logging before method");
    }
}

b) Load-Time Weaving (LTW)

• Aspects are woven when classes are loaded into JVM.
• Uses a Java agent / classloader.
• Flexible and powerful, but complex to configure.

Example:

Configuration

@EnableLoadTimeWeaving
@Configuration
publicclassAppConfig {}

Aspect

@Aspect
publicclassSecurityAspect {
@Before("execution(* com.example.service.*.*(..))")
publicvoidcheckSecurity() {
        System.out.println("Security check");
    }
}

c) Runtime Weaving (Proxy-Based)

• Aspects are woven at runtime using proxies.
• Used by Spring AOP.
• Supports only method-level interception.

Example:

Service

@Service
publicclassOrderService {
publicvoidplaceOrder() {
        System.out.println("Order placed");
    }
}

Aspect

@Aspect
@Component
publicclassLoggingAspect {

@Before("execution(* com.example.service.OrderService.*(..))")
publicvoidlogBefore() {
        System.out.println("Before Order Service");
    }
}

Output

BeforeOrderService
Orderplaced

6. Target Object

The actual bean/object being advised by an aspect.

Example:

@Service
publicclassPaymentService {
public Stringpay(String user, double amount) { ... }
}

✅ PaymentService is the target object whose methods are intercepted by aspects.

7. Proxy

A Spring-generated wrapper around the target object.

• Purpose: Intercepts method calls to apply advice transparently.

Types: Spring AOP uses proxies to implement aspects at runtime. There are two main proxy types:

a) JDK Dynamic Proxy

• Interface-based proxy.
• Creates proxy for interfaces implemented by target class.
• Can only advise methods declared in interfaces.
• Default if target class implements an interface.

Example

publicinterfaceOrderService {
voidplaceOrder();
}

@Service
publicclassOrderServiceImplimplementsOrderService {
publicvoidplaceOrder() {
        System.out.println("Order placed");
    }
}

@Aspect
@Component
publicclassLoggingAspect {
@Before("execution(* com.example.service.OrderService.*(..))")
publicvoidlog() {
        System.out.println("Logging before method");
    }
}

Output

Loggingbeforemethod
Order placed

b) CGLIB Proxy

• Class-based proxy.
• Creates a subclass of the target class.
• Can advise any method, even if no interface is implemented.
• Used automatically if target class does not implement an interface.

Example

@Service
publicclassPaymentService {
publicvoidprocessPayment() {
        System.out.println("Payment processed");
    }
}

@Aspect
@Component
publicclassLoggingAspect {
@Before("execution(* com.example.service.PaymentService.*(..))")
publicvoidlog() {
        System.out.println("Logging before method");
    }
}

Output

Loggingbeforemethod
Payment processed

Flow Example:

[ClientCall]
      |
      v
[ProxyObject]--> Executes @Before Advice
      |
      v
[TargetObjectMethod Execution]
      |
      v
[ProxyObject]--> Executes @After / @Around Advice
      |
      v
[Returnto Client]

8. How These Concepts Work Together

1. Aspect contains advice and pointcuts.
2. Pointcut defines which join points are affected.
3. JoinPoint is the execution point matched by the pointcut.
4. Spring generates a proxy for the target object.
5. Advice executes before/after/around the target method.
6. Weaving ensures aspects are applied transparently.

Summary Table

Conclusion:

Spring AOP allows developers to modularize cross-cutting concerns like logging, security, and transactions without cluttering business logic. By using aspects, advice, pointcuts, proxies, and weaving, Spring ensures clean, reusable, and maintainable code. Proper use of AOP improves readability, enforces separation of concerns, and enhances the scalability and robustness of Spring applications.