@Around advice for full control in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this @Around advice code?

Consider this Spring Boot @Around advice that logs method execution time. What will be printed when the advised method completes successfully?

Spring Boot

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class TimingAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object proceed = joinPoint.proceed();
        long duration = System.currentTimeMillis() - start;
        System.out.println("Execution time: " + duration + " ms");
        return proceed;
    }
}

A Throws a runtime exception because proceed() is not called.

B Prints nothing and returns null regardless of the method result.

C Prints 'Execution time: X ms' where X is the method duration, then returns the method result.

D Prints 'Execution time: 0 ms' always and returns the method result.

💡 Hint

Remember that joinPoint.proceed() runs the original method and returns its result.

The @Around advice calls proceed() to execute the original method, measures time before and after, prints the duration, and returns the original method's result.

📝 Syntax

intermediate

Which option correctly uses @Around advice to modify the returned value?

You want to intercept a method and multiply its integer return value by 10 before returning it. Which @Around advice code snippet is correct?

A

@Around("execution(int com.example.*.*(..))")
public Object multiplyReturn(ProceedingJoinPoint pjp) throws Throwable {
    Object result = pjp.proceed();
    return (int) result * 10;
}

B

@Around("execution(int com.example.*.*(..))")
public Object multiplyReturn(ProceedingJoinPoint pjp) throws Throwable {
    int result = (int) pjp.proceed();
    return result * 10;
}

C

@Around("execution(int com.example.*.*(..))")
public int multiplyReturn(ProceedingJoinPoint pjp) {
    int result = (int) pjp.proceed();
    return result * 10;
}

D

@Around("execution(int com.example.*.*(..))")
public Object multiplyReturn(ProceedingJoinPoint pjp) throws Throwable {
    int result = pjp.proceed();
    return result * 10;
}

💡 Hint

Check method signature and casting carefully.

Option B correctly declares the method to throw Throwable, casts proceed() result to int, and returns the multiplied value as Object.

🔧 Debug

advanced

Why does this @Around advice cause a StackOverflowError?

This advice is intended to log method calls but causes a StackOverflowError at runtime. What is the cause?

Spring Boot

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object log(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("Before method");
        Object result = log(pjp); // recursive call instead of proceed()
        System.out.println("After method");
        return result;
    }
}

A The advice returns null instead of the method result, causing a NullPointerException.

B The pointcut expression is invalid, so the advice never runs and causes an error.

C The advice does not declare 'throws Throwable', causing a compile error.

D The advice calls itself recursively instead of calling pjp.proceed(), causing infinite recursion.

💡 Hint

Look at the method call inside the advice method.

The advice method calls itself recursively instead of calling pjp.proceed(), leading to infinite recursion and StackOverflowError.

❓ state_output

advanced

What is the value of 'count' after this @Around advice runs three times?

This advice counts how many times methods in the service package are called. What is the value of 'count' after three method calls?

Spring Boot

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class CounterAspect {
    private int count = 0;

    @Around("execution(* com.example.service.*.*(..))")
    public Object countCalls(ProceedingJoinPoint pjp) throws Throwable {
        count++;
        return pjp.proceed();
    }

    public int getCount() {
        return count;
    }
}

A 3

B 0

C 1

D Throws an error because 'count' is not thread-safe.

💡 Hint

Each method call increments count by one.

The advice increments 'count' every time a matched method is called. After three calls, count is 3.

🧠 Conceptual

expert

Which statement about @Around advice full control is TRUE?

Select the true statement about the capabilities of @Around advice in Spring AOP.

A @Around advice can modify method arguments, control method execution, and change the return value.

B @Around advice can only log method execution time but cannot alter method behavior or return values.

C @Around advice automatically retries the method on exceptions without extra code.

D @Around advice cannot access the original method's arguments or return value.

💡 Hint

Think about what full control means in this context.

@Around advice wraps the method call, allowing you to change arguments, decide whether to call the method, and modify the return value.