@After and @AfterReturning in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

Behavior of @After advice in Spring AOP

Consider a Spring AOP aspect with an @After advice on a method that throws an exception. What will happen when the advised method throws an exception?

Spring Boot

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

// The target method throws a RuntimeException.

A The @After advice will not execute if the method throws an exception.

B The @After advice will execute even if the method throws an exception.

C The @After advice will execute only if the method returns normally without exception.

D The @After advice will execute before the method is called.

💡 Hint

Think about whether @After runs regardless of method outcome.

The @After advice runs after the method execution regardless of its outcome, whether it returns normally or throws an exception.

❓ component_behavior

intermediate

Return value availability in @AfterReturning advice

In Spring AOP, which of the following is true about the return value in an @AfterReturning advice?

Spring Boot

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

A The return value is always null in @AfterReturning advice.

B The return value is available even if the method throws an exception.

C The return value is available only if the method completes normally without exception.

D The return value is available before the method executes.

💡 Hint

Consider when a method actually returns a value.

@AfterReturning advice runs only if the method completes successfully and provides the return value as a parameter.

📝 Syntax

advanced

Correct syntax for @AfterReturning with returning attribute

Which of the following @AfterReturning advice declarations is syntactically correct in Spring AOP?

A

@AfterReturning(pointcut = "execution(* com.example.*.*(..))", returning = retVal)
public void adviceMethod(Object retVal) {}

B

@AfterReturning(pointcut = "execution(* com.example.*.*(..))", return = "retVal")
public void adviceMethod(Object retVal) {}

C

@AfterReturning(pointcut = "execution(* com.example.*.*(..))", returning = "retVal")
public void adviceMethod() {}

D

@AfterReturning(pointcut = "execution(* com.example.*.*(..))", returning = "retVal")
public void adviceMethod(Object retVal) {}

💡 Hint

Check the attribute name and parameter matching.

The attribute name must be 'returning' as a string, and the advice method must have a parameter matching that name.

🔧 Debug

advanced

Why does @AfterReturning advice not execute?

Given this aspect code, why does the @AfterReturning advice never print its message? public class MyAspect { @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result") public void afterReturningAdvice(String result) { System.out.println("Returned: " + result); } } The target method returns an Integer.

A The advice method parameter type String does not match the actual return type Integer.

B The pointcut expression is incorrect and does not match the method.

C The @AfterReturning advice only works for void methods.

D The advice method must have no parameters.

💡 Hint

Check the parameter type of the advice method compared to the return type.

The advice method parameter type must be compatible with the actual return type. Mismatch causes advice not to run.

❓ lifecycle

expert

Order of execution: @After, @AfterReturning, and exception thrown

Consider a Spring AOP aspect with both @After and @AfterReturning advices on the same method. The method throws an exception. Which advice(s) will execute?

Spring Boot

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

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

A Only the @After advice executes; @AfterReturning does not execute because of the exception.

B Neither advice executes because the method threw an exception.

C Only the @AfterReturning advice executes; @After does not execute.

D Both @After and @AfterReturning advices execute regardless of exception.

💡 Hint

Recall when each advice runs relative to exceptions.

@After advice runs always after method execution, even if an exception occurs. @AfterReturning runs only if the method returns normally.