Usage of @Before, @After, @Around, @AfterReturning and @AfterThrowing in a Single Spring AOP Project

Spring AOP (Aspect-Oriented Programming) helps separate cross-cutting concerns like logging, security, and transaction management from the main business logic of an application. It allows developers to execute additional code at specific points during method execution.

• Provides advice annotations such as @Before, @After, @Around, @AfterReturning, and @AfterThrowing.
• Helps keep the code modular, clean, and easier to maintain by separating concerns.

Commonly used AOP advice annotations

Let’s discuss some commonly used Spring AOP advice annotations that define when the aspect code should be executed during method execution.

1. @Before 

@Before advice is used when you want to run some code before a specific method executes like a pre-processing step. @Before advice runs before the execution of a method. It is mainly used for validation or logging before the actual method runs.

• Executes before the target method starts.
• Used for validation, authentication, or logging.

Example:

@Before("execution(* com.example.service.*.*(..))")
public void beforeMethod() {
System.out.println("Method is about to execute");
}

2. @After

@After advice runs after the method execution, whether the method completes successfully or throws an exception.

• Executes after the method finishes.
• Runs for both success and failure cases.

Example:

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

3. @Around

@Around is an advice type that allows you to run code both before and after the actual method execution.@Around advice runs both before and after the method execution and can control the execution of the method.

• Executes before and after the method.
• Can control whether the method should run.

Example:

@Around("execution(* com.example.service.*.*(..))")
public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("Before method");
Object result = joinPoint.proceed();
System.out.println("After method");
return result;
}

4. @AfterReturning

@AfterReturning advice runs only when the method executes successfully and returns a result.

• Executes only after successful method completion.
• Used for logging results or sending notifications.

Example:

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

5. @AfterThrowing

@AfterThrowing will be executed whenever there is an exception in the code. We need to handle that by putting try-catch blocks and always it is a good practice to handle exceptions.

• Executes when the method throws an exception.
• Used for exception logging or error handling.

Example:

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

Steps to Build the Project with All Advice

Step 1: Create a Spring Boot Maven Project

Create a Spring Boot project using Spring Initializer with these details:

• Project: Maven
• Language: Java
• Spring Boot Version: Latest stable version
• Group: com.example
• Artifact: different-advice-example
• Packaging: Jar
• Java Version: 17
• Dependencies: Spring Web, Spring AOP

Project structure

pom.xml

Step 2: Add Main Class

Create the main Spring Boot application file.DifferentAdviceExampleApplication.java

DifferentAdviceExampleApplication.java

Step 3: Create the Aspect Class

Create DifferentAspect.java and add AOP advice annotations:

• @Around
• @Before
• @After
• @AfterReturning
• @AfterThrowing

This class contains logging and monitoring logic for the service methods.

DifferentAspect.java

Step 4: Create the Service Class

Create GeneralService.java which contains methods on which AOP advice will run.

GeneralService.java

Step 5 :Program Execution Flow

Program execution and output:

Output:

Explanation:

1. @Around Advice (Before): Logs before the method runs.
2. @Before Advice: Executes just before the actual method logs a general message for all methods.
3. Actual Method Execution: checkEmployeeExistence() runs then Prints: "A123 is currently active".
4. @Around Advice (After): Logs after the method runs.
5. @After Advice: Executes after the method finishes (whether success or error).
6. @AfterReturning Advice: Executes only if the method completes successfully then Logs method return information.

Let us see when an exception throws for getBalance method by just passing accountnumber to null

Explanation:

1. @Around Advice: Logs before getBalance() is called.
2. @Before Advice: Executes before every method (here, before getBalance()).
3. Inside Method: Execution enters the getBalance() method.
4. Exception Occurs: A NullPointerException happens because accNum is null and accNum.equals(...) is called.
5. @After Advice: Still runs after the method (regardless of exception).
6. @AfterThrowing Advice: Specifically handles the exception, logs method info and exception message.
7. Final Output: Exception message- Cannot invoke "String.equals(Object)" because "accNum" is null.