Why @After and @AfterReturning in Spring Boot? - Purpose & Use Cases

The Big Idea

Discover how to run code after any method finishes without cluttering your main code!

The Scenario

Imagine you have many methods in your application, and you want to run some code after each method finishes, like logging or cleaning up resources.

You try to add this code manually inside every method.

The Problem

Manually adding the same code after every method is boring, error-prone, and makes your code messy.

If you forget to add it somewhere, your app might behave inconsistently.

The Solution

@After and @AfterReturning let you write that extra code once and have it run automatically after methods finish, keeping your code clean and consistent.

Before vs After

✗ Before

public void someMethod() {
  // method logic
  System.out.println("Method finished");
}

✓ After

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

What It Enables

You can add behavior after methods run without touching their code, making maintenance easier and your app more reliable.

Real Life Example

Logging user actions after every service method completes, without adding logging code inside each method.

Key Takeaways

@After and @AfterReturning run code after methods finish.

They keep your code clean by separating extra tasks from main logic.

This helps maintain consistency and reduces errors.

Practice

1. What is the main difference between @After and @AfterReturning in Spring AOP?

easy

A. @After runs after method completion regardless of outcome; @AfterReturning runs only after successful return.

B. @After runs before the method; @AfterReturning runs after the method.

C. @After runs only if the method throws an exception; @AfterReturning runs always.

D. @After and @AfterReturning are exactly the same.

Solution

1. Step 1: Understand @After behavior

   @After advice runs after a method finishes, whether it returns normally or throws an exception.

2. Step 2: Understand @AfterReturning behavior

   @AfterReturning advice runs only if the method completes successfully without throwing exceptions.

3. Final Answer:

   @After runs after method completion regardless of outcome; @AfterReturning runs only after successful return. -> Option A

4. Quick Check:

   @After = always after, @AfterReturning = after success [OK]

Hint: Remember: @After always runs, @AfterReturning only on success [OK]

Common Mistakes:

• Confusing @After with @Before advice
• Thinking @AfterReturning runs on exceptions
• Believing both advices behave identically

2. Which of the following is the correct syntax to define an @AfterReturning advice method in Spring AOP?

easy

A. @AfterReturning(pointcut = "execution(* com.example.*.*(..))", returning = "result")
public void afterReturn(Object result) { }

B. @AfterReturning("execution(* com.example.*.*(..))")
public void afterReturn() { }

C. @AfterReturning(returning = "result")
public void afterReturn(Object result) { }

D. @AfterReturning(pointcut = "execution(* com.example.*.*(..))")
public void afterReturn(Object result) { }

Solution

1. Step 1: Check required attributes for @AfterReturning

   The @AfterReturning annotation requires a pointcut expression and optionally a returning attribute to capture the returned value.

2. Step 2: Match method signature with returning attribute

   The method must have a parameter matching the name in returning to receive the returned value.

3. Final Answer:

   @AfterReturning(pointcut = "execution(* com.example.*.*(..))", returning = "result") public void afterReturn(Object result) { } -> Option A

4. Quick Check:

   Use both pointcut and returning with matching parameter [OK]

Hint: Use both pointcut and returning with matching method parameter [OK]

Common Mistakes:

• Omitting pointcut attribute
• Not matching returning name with method parameter
• Using @AfterReturning without parameters

3. Given the following Spring AOP advice, what will be printed if someMethod() throws an exception?

@After("execution(* com.example.Service.someMethod(..))")
public void afterAdvice() {
    System.out.println("After advice executed");
}

@AfterReturning(pointcut = "execution(* com.example.Service.someMethod(..))", returning = "result")
public void afterReturningAdvice(Object result) {
    System.out.println("AfterReturning advice executed with: " + result);
}

medium

A. No advice executed

B. AfterReturning advice executed with: null

C. Both advices executed

D. After advice executed

Solution

1. Step 1: Analyze @After advice behavior on exception

   @After advice runs after method finishes regardless of success or exception, so it will execute and print its message.

2. Step 2: Analyze @AfterReturning advice behavior on exception

   @AfterReturning advice runs only if the method returns successfully, so it will NOT run if an exception is thrown.

3. Final Answer:

   After advice executed -> Option D

4. Quick Check:

   @After runs always, @AfterReturning skips on exceptions [OK]

Hint: @After runs always; @AfterReturning skips exceptions [OK]

Common Mistakes:

• Assuming @AfterReturning runs on exceptions
• Thinking both advices run always
• Confusing advice execution order

4. Identify the error in the following advice method:

@AfterReturning(pointcut = "execution(* com.example.Service.process(..))", returning = "retVal")
public void afterReturn() {
    System.out.println("Returned value: " + retVal);
}

medium

A. The method should be annotated with @After instead of @AfterReturning.

B. The pointcut expression is invalid.

C. The advice method must have a parameter named retVal to receive the returned value.

D. The method must return a value.

Solution

1. Step 1: Check method parameters for returning attribute

   The returning = "retVal" attribute requires the advice method to have a parameter named retVal to receive the returned value.

2. Step 2: Verify method signature

   The method currently has no parameters, so it cannot access retVal, causing a compile error.

3. Final Answer:

   The advice method must have a parameter named retVal to receive the returned value. -> Option C

4. Quick Check:

   Returning attribute needs matching method parameter [OK]

Hint: Match returning name with method parameter to avoid errors [OK]

Common Mistakes:

• Omitting method parameter for returning value
• Misnaming the parameter
• Using @AfterReturning without pointcut

5. You want to log the returned value of a service method only when it completes successfully, and also log a message after the method finishes regardless of outcome. Which advice combination should you use?

hard

A. Use two @AfterReturning advices for both logs.

B. Use @AfterReturning to log the returned value and @After to log after method completion.

C. Use @After advice only for both logs.

D. Use @Before advice to log returned value and @AfterReturning to log after completion.

Solution

1. Step 1: Log returned value only on success

   @AfterReturning advice runs only after successful method return, so it is suitable to log the returned value.

2. Step 2: Log after method finishes regardless of outcome

   @After advice runs after method completion whether success or exception, so it is suitable to log a message always.

3. Final Answer:

   Use @AfterReturning to log the returned value and @After to log after method completion. -> Option B

4. Quick Check:

   AfterReturning = success only, After = always after [OK]

Hint: Combine @AfterReturning for success and @After for always [OK]

Common Mistakes:

• Using @After for returned value logging
• Using @Before to log returned value
• Expecting @AfterReturning to run on exceptions