@After and @AfterReturning in Spring Boot - Step-by-Step Execution

Concept Flow - @After and @AfterReturning

Method Execution Start

↓

Method Runs Normally

↓

@AfterReturning

↓

Method Execution End

Shows how @After runs always after a method finishes, while @AfterReturning runs only if the method completes without exception.

Execution Sample

Spring Boot

@After("execution(* com.example.service.*.*(..))")
public void afterAdvice() {
    System.out.println("After advice runs always");
}

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

Defines two advices: one runs always after methods in service package, the other runs only if method returns normally.

Execution Table

Step	Method Outcome	@After Triggered	@AfterReturning Triggered	Output
1	Method starts	No	No	Method execution begins
2	Method runs normally	No	No	Method logic executes
3	Method returns value	No	No	Method returns 'Success'
4	After method finishes	Yes	Yes	Print: After advice runs always
5	After method finishes	Yes	Yes	Print: AfterReturning advice runs with result: Success
6	Method starts	No	No	Method execution begins
7	Method throws exception	No	No	Exception thrown
8	After method finishes	Yes	No	Print: After advice runs always
9	End	No	No	No AfterReturning because of exception

💡 Execution stops after method finishes; @After always runs, @AfterReturning runs only if no exception.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 7	After Step 8	Final
Method Outcome	Not started	Returns 'Success'	Returns 'Success'	Throws Exception	Throws Exception	Finished
@After Triggered	False	False	True	False	True	True
@AfterReturning Triggered	False	False	True	False	False	False

Key Moments - 2 Insights

Why does @After run even if the method throws an exception?

@After is designed to run always after the method finishes, regardless of success or exception, as shown in execution_table rows 8 and 9.

Why doesn't @AfterReturning run when the method throws an exception?

@AfterReturning only runs if the method completes normally without exceptions, so it skips running in rows 8 and 9 where an exception occurs.

Visual Quiz - 3 Questions

Look at the execution_table, at which step does @AfterReturning advice run?

A Step 5

B Step 8

C Step 3

D Step 9

💡 Hint

Check the '@AfterReturning Triggered' column in execution_table rows.

At which step does the method throw an exception?

A Step 3

B Step 7

C Step 5

D Step 1

💡 Hint

Look at the 'Method Outcome' column for exception occurrence.

If the method never throws exceptions, which advice always runs?

A @AfterReturning only

B @After only

C Both @After and @AfterReturning

D Neither advice

💡 Hint

Refer to execution_table rows 4 and 5 where both advices run after normal completion.

Concept Snapshot

@After and @AfterReturning in Spring AOP:
- @After runs always after method finishes (success or exception).
- @AfterReturning runs only if method returns normally.
- Use @After for cleanup tasks.
- Use @AfterReturning to access method return value.
- Both can target same methods with different triggers.

Full Transcript

This visual execution trace shows how Spring AOP's @After and @AfterReturning advices behave. When a method starts, it runs its logic. If it returns normally, both @After and @AfterReturning advices run after it finishes, printing messages. If the method throws an exception, only @After runs, while @AfterReturning does not. Variables track method outcome and advice triggers step-by-step. Key moments clarify why @After always runs and @AfterReturning only runs on success. Quiz questions test understanding of when each advice triggers. The snapshot summarizes their usage and differences.

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