Spring AOP (Aspect-Oriented Programming)

Spring AOP allows developers to separate cross-cutting concerns (like logging, security, transactions) from the main business logic. This improves modularity, readability, and maintainability of applications.

Cross-cutting concerns are features that affect multiple modules:

• Logging
• Security / authentication
• Transaction management
• Caching
• Metrics / monitoring
• Performance tracking

In simple words:

AOP = Add reusable behavior to your code without modifying the core business logic.

What is AOP?

Aspect-Oriented Programming (AOP) is a programming paradigm that:

• Separates cross-cutting concerns from core business logic.
• Applies behaviors across multiple classes without code duplication.

Spring AOP provides declarative aspect programming, allowing behaviors to run before, after, or around method execution.

Core Concepts / Terminology

Types of Advice in Spring AOP

In Spring AOP, advice defines what action to take and when during the execution of a program. It is the code that runs at a join point (like a method call).

1. Before Advice

• Runs: Before the matched method executes.
• Annotation: @Before
• Use Case: Logging, security checks, validation.

Example:

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

2. After Advice

• Runs: After the matched method executes (regardless of method outcome).
• Annotation: @After
• Use Case: Cleanup, releasing resources.

Example:

@After("execution(* com.example.service.*.*(..))")
publicvoidlogAfter(JoinPoint joinPoint) {
    System.out.println("After method: " + joinPoint.getSignature().getName());
}

3. AfterReturning Advice

• Runs: After a method successfully returns a result.
• Annotation: @AfterReturning
• Use Case: Logging return values, post-processing results.

Example:

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

4. AfterThrowing Advice

• Runs: After a method throws an exception.
• Annotation: @AfterThrowing
• Use Case: Exception handling, auditing errors.

Example:

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

5. Around Advice

• Runs: Before and after the method execution. Can control whether the method executes at all.
• Annotation: @Around
• Use Case: Performance monitoring, transactions, conditional execution.

Example:

@Around("execution(* com.example.service.*.*(..))")
public ObjectlogAround(ProceedingJoinPoint joinPoint)throws Throwable {
    System.out.println("Before method: " + joinPoint.getSignature().getName());
Objectresult= joinPoint.proceed();// Execute the method
    System.out.println("After method: " + joinPoint.getSignature().getName());
return result;
}

Setting Up a Spring AOP Example

Spring AOP allows you to implement cross-cutting concerns (like logging, security, transactions) without modifying the business logic.

Step 1: Add Dependency (Spring Boot)

If you are using Spring Boot, add this dependency in pom.xml:

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

Step 2: Create an Aspect

Aspects define the cross-cutting logic and when it should run.

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

@Aspect
@Component
publicclassLoggingAspect {

// Pointcut for all methods in the service package
@Pointcut("execution(* com.example.service.*.*(..))")
publicvoidserviceMethods() {}

// Before advice
@Before("serviceMethods()")
publicvoidlogBefore(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }

// AfterReturning advice
@AfterReturning(pointcut = "serviceMethods()", returning = "result")
publicvoidlogAfterReturning(Object result) {
        System.out.println("Method returned: " + result);
    }
}

Explanation:

• @Aspect → marks this class as an aspect
• @Pointcut → defines which methods to intercept
• @Before → runs before matched method execution
• @AfterReturning → runs after method successfully returns

Step 3: Create a Target Service

This is the business logic class that will be advised by the aspect.

import org.springframework.stereotype.Service;

@Service
publicclassPaymentService {

public Stringpay(String user, double amount) {
        System.out.println("Processing payment for " + user);
return"Payment Successful";
    }
}

Step 4: Create a Controller to Test the Aspect

The controller is used to trigger the target service method, so we can see the aspect in action.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
publicclassPaymentController {

@Autowired
private PaymentService paymentService;

@GetMapping("/pay")
public Stringpay() {
return paymentService.pay("John",500);
    }
}

Explanation:

1. @RestController → Marks this class as a REST controller.
2. @Autowired → Injects the PaymentService bean (the target service).
3. @GetMapping("/pay") → Exposes a GET endpoint to trigger the pay method.
4. When /pay is called, Spring AOP automatically executes the aspect (LoggingAspect) before and after the method.

Step 5: Expected Output

When you access /pay endpoint:

Beforemethod: pay
Processing paymentfor John
Method returned: Payment Successful

Observation:

• The aspect advice runs automatically without modifying the PaymentService logic.
• Logging is handled separately by the LoggingAspect, keeping business logic clean and maintainable.
• Demonstrates cross-cutting concern separation, which is the key benefit of Spring AOP.

Enable AOP in Spring

@Configuration
@EnableAspectJAutoProxy
publicclassAppConfig {}

• @EnableAspectJAutoProxy instructs Spring to create proxies for beans with aspects.

How Spring AOP Works Internally

1. Spring creates a proxy for beans with aspects.
2. When a method is called on the proxy:
   • @Before advice executes.
   • Target method runs.
   • @AfterReturning, @After, or @AfterThrowing executes.
3. Proxies ensure cross-cutting concerns are applied without modifying the target code.

Types of Aspects in Spring AOP

An aspect in Spring AOP is a modular unit of cross-cutting concern (like logging, security, transactions). Spring supports different types of aspects depending on the instance management and scope.

Singleton Aspect (Default)

Default in Spring; only one instance of the aspect exists per Spring container. All advised beans share the same aspect instance. Efficient and commonly used.

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

@Aspect
@Component
publicclassSingletonLoggingAspect {

privateintcount=0;// Shared across all target beans

@Before("execution(* com.example.service.*.*(..))")
publicvoidlogBefore() {
        count++;
        System.out.println("Singleton Aspect executed. Count: " + count);
    }
}

Behavior

• Only one instance of SingletonLoggingAspect exists.
• count is shared among all advised beans.
• Efficient and commonly used.

Per-Target Aspect

A new aspect instance is created for each advised target object. Useful when the aspect maintains state specific to each target instance. Less common and uses more memory.

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

@Aspect
@Component
@Scope("prototype")// Create new instance for each advised object
publicclassPerTargetLoggingAspect {

privateintcount=0;// Unique to each target bean

@Before("execution(* com.example.service.*.*(..))")
publicvoidlogBefore() {
        count++;
        System.out.println("Per-Target Aspect executed. Count: " + count);
    }
}

Behavior

• New instance of PerTargetLoggingAspect is created for each target bean.
• count is specific to that bean.
• Uses more memory; useful if aspect maintains per-bean state.

Comparison Table

Real-World Use Cases

• Logging method execution and input/output
• Security checks before execution
• Transaction management
• Error handling or auditing
• Performance monitoring

Advantages of Spring AOP

• Reduces code duplication
• Improves modularity and readability
• Makes cross-cutting logic reusable
• Declarative and non-intrusive

Limitations

• Works only on Spring-managed beans
• Proxy-based (runtime)
• Cannot advise private methods
• Class-based proxies require CGLIB

Spring AOP vs AspectJ

• Spring AOP
  • Uses dynamic proxies at runtime.
  • Works only with Spring beans.
  • Lightweight and easier to configure.
  • Ideal for most enterprise applications.
• AspectJ
  • Performs weaving at compile-time, post-compile, or load-time.
  • Can advise any class/method, not just Spring beans.
  • More powerful and flexible, but requires extra configuration.
  • Suitable for advanced scenarios like low-level performance monitoring or bytecode manipulation.

Best Practices

• Keep aspects focused and reusable
• Avoid aspects on performance-critical methods unnecessarily
• Combine AOP with @Profile or @Conditional for environment-specific behavior
• Use @Around advice sparingly
• Prefer declarative pointcuts over complex programmatic ones

Conclusion

Spring AOP allows you to apply cross-cutting concerns declaratively, keeping business logic clean and reusable. Using aspects, advice, and pointcuts, Spring AOP automatically handles repetitive tasks like logging, security, and transaction management without modifying the target classes.