AOP for performance monitoring in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Output of a simple performance aspect

Given the following Spring Boot aspect code for measuring method execution time, what will be printed when the method processData() is called?

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 PerformanceAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object measureTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        System.out.println(joinPoint.getSignature().getName() + " executed in " + (end - start) + "ms");
        return result;
    }
}

// Assume processData() takes approximately 150ms to execute.

A processData executed in 150ms

B processData executed in 0ms

C processData executed in 150 seconds

D No output printed

💡 Hint

Think about what the aspect measures and prints after the method finishes.

The aspect measures the time before and after the method execution and prints the method name with the elapsed time in milliseconds. Since processData takes about 150ms, the output shows that time.

🧠 Conceptual

intermediate

Purpose of @Around advice in performance monitoring

What is the main reason to use @Around advice in Spring AOP for performance monitoring?

A To execute code before and after the target method to measure execution time

B To only execute code before the target method starts

C To replace the target method with a different implementation

D To execute code only if the target method throws an exception

💡 Hint

Performance monitoring needs to know how long the method takes in total.

The @Around advice wraps the method execution, allowing code to run before and after the method, which is essential to measure the total execution time.

❓ Troubleshoot

advanced

Why is the performance aspect not logging execution time?

A developer wrote this aspect to log execution time but sees no output in the console. What is the most likely 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 PerformanceAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object measureTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        System.out.println(joinPoint.getSignature().getName() + " executed in " + (end - start) + "ms");
        return result;
    }
}

A The method measureTime does not return the result

B The target methods are not in package com.example.service

C The @Aspect annotation is missing

D System.out.println does not print in Spring Boot

💡 Hint

Check if the pointcut matches the actual method location.

If the pointcut expression does not match any method, the advice never runs, so no output appears.

🔀 Workflow

advanced

Correct order of steps to add performance monitoring with AOP

Put these steps in the correct order to add performance monitoring using Spring AOP.

A 1,3,2,4

B 2,1,3,4

C 1,2,3,4

D 3,1,2,4

💡 Hint

Think about creating the aspect first, then defining what to monitor, then the advice, then testing.

First create the aspect class, then define the pointcut, then write the advice, finally run and verify.

✅ Best Practice

expert

Best practice for logging performance in production

Which is the best practice for implementing performance monitoring with AOP in a production Spring Boot application?

A Use System.out.println in the aspect to log execution times

B Throw exceptions if method execution exceeds a threshold

C Disable the aspect in production to avoid overhead

D Use a logging framework like SLF4J with log levels to control output

💡 Hint

Think about flexible and configurable logging in production environments.

Using a logging framework allows controlling log output via configuration without code changes, which is best for production.