@After and @AfterReturning in Spring Boot

Introduction

@After and @AfterReturning help you run extra code after a method finishes. This is useful to add actions like logging or cleanup without changing the main method.

You want to log a message every time a method ends, no matter if it worked or threw an error.

You want to do something only after a method successfully returns a result.

You want to clean up resources after a method runs.

You want to track method execution for debugging or monitoring.

You want to add behavior after a method without changing its code.

Syntax

Spring Boot

@After("pointcutExpression")
public void afterAdvice() {
    // code to run after method
}

@AfterReturning(pointcut = "pointcutExpression", returning = "result")
public void afterReturningAdvice(Object result) {
    // code to run after method returns successfully
}

@After runs after the method finishes, whether it throws an error or not.

@AfterReturning runs only if the method finishes successfully and can access the returned value.

Examples

This runs after any method in the service package finishes, printing a message.

Spring Boot

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

This runs only after getUser method returns successfully and prints the returned user.

Spring Boot

@AfterReturning(pointcut = "execution(* com.example.service.UserService.getUser(..))", returning = "user")
public void logUser(Object user) {
    System.out.println("Returned user: " + user);
}

Sample Program

This Spring Boot app has a service with two methods: process and getData. The aspect runs code after process finishes and after getData returns successfully. It prints messages to show when these happen.

Spring Boot

package com.example.demo;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @After("execution(* com.example.demo.MyService.process(..))")
    public void afterProcess() {
        System.out.println("Process method finished.");
    }

    @AfterReturning(pointcut = "execution(* com.example.demo.MyService.getData(..))", returning = "result")
    public void afterReturningGetData(Object result) {
        System.out.println("getData returned: " + result);
    }
}

package com.example.demo;

import org.springframework.stereotype.Service;

@Service
public class MyService {

    public void process() {
        System.out.println("Processing...");
    }

    public String getData() {
        System.out.println("Getting data...");
        return "Hello";
    }
}

package com.example.demo;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan("com.example.demo")
public class DemoApplication implements CommandLineRunner {

    private final MyService myService;

    public DemoApplication(MyService myService) {
        this.myService = myService;
    }

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        myService.process();
        String data = myService.getData();
    }
}

Important Notes

Use @After when you want to run code no matter if the method succeeds or fails.

Use @AfterReturning when you need the method's return value to do something extra.

Make sure your pointcut expressions match the methods you want to advise.

Summary

@After runs code after a method ends, always.

@AfterReturning runs code only after a method returns successfully.

Both help add extra behavior without changing the original method.

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