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.

Practice

1. What is the main purpose of using AOP for performance monitoring in Spring Boot?

easy

A. To measure method execution time without changing the method code

B. To change the business logic of methods

C. To add new REST endpoints automatically

D. To replace database queries with cached results

Solution

1. Step 1: Understand AOP's role in performance monitoring

   AOP allows adding extra code around methods without modifying their original code.

2. Step 2: Identify the purpose of timing code

   Timing code measures how long methods take to run, helping find slow parts.

3. Final Answer:

   To measure method execution time without changing the method code -> Option A

4. Quick Check:

   AOP measures time without code changes [OK]

Hint: AOP adds timing code outside main methods [OK]

Common Mistakes:

• Thinking AOP changes method logic
• Confusing AOP with adding endpoints
• Assuming AOP caches database queries

2. Which annotation is used in Spring AOP to wrap method execution for timing?

easy

A. @Before

B. @After

C. @Around

D. @Pointcut

Solution

1. Step 1: Recall Spring AOP advice types

   @Before runs before method, @After runs after, @Around wraps method execution.

2. Step 2: Identify which advice can measure execution time

   @Around can run code before and after method, so it can measure duration.

3. Final Answer:

   @Around -> Option C

4. Quick Check:

   @Around wraps method for timing [OK]

Hint: Use @Around to wrap and time methods [OK]

Common Mistakes:

• Using @Before or @After which can't measure duration
• Confusing @Pointcut with advice annotation
• Assuming @After runs before method

3. Given this AOP method, what will be printed if the target method takes 150ms to execute?

@Around("execution(* com.example.service.*.*(..))")
public Object measureTime(ProceedingJoinPoint pjp) throws Throwable {
  long start = System.currentTimeMillis();
  Object result = pjp.proceed();
  long end = System.currentTimeMillis();
  System.out.println("Execution time: " + (end - start) + " ms");
  return result;
}

medium

A. Execution time: 0 ms

B. No output printed

C. Execution time: 300 ms

D. Execution time: 150 ms

Solution

1. Step 1: Understand timing calculation

   The code records start time, runs the method, then records end time and prints the difference.

2. Step 2: Match timing with method duration

   If method takes 150ms, printed time is 150 ms.

3. Final Answer:

   Execution time: 150 ms -> Option D

4. Quick Check:

   Printed time matches method duration [OK]

Hint: Printed time equals method run duration [OK]

Common Mistakes:

• Assuming time is zero or double counted
• Thinking no output prints
• Confusing start and end time order

4. What is wrong with this AOP advice for measuring execution time?

@Around("execution(* com.example..*(..))")
public void measure(ProceedingJoinPoint pjp) throws Throwable {
  long start = System.currentTimeMillis();
  pjp.proceed();
  long end = System.currentTimeMillis();
  System.out.println("Time: " + (end - start));
}

medium

A. The pointcut expression is invalid

B. The method should return Object, not void

C. System.currentTimeMillis() cannot be used for timing

D. ProceedingJoinPoint cannot be used in @Around advice

Solution

1. Step 1: Check method signature for @Around advice

   @Around advice must return the result of pjp.proceed() to maintain method behavior.

2. Step 2: Identify missing return statement

   Method returns void but should return Object from pjp.proceed().

3. Final Answer:

   The method should return Object, not void -> Option B

4. Quick Check:

   @Around advice must return method result [OK]

Hint: @Around methods must return Object from proceed() [OK]

Common Mistakes:

• Forgetting to return pjp.proceed() result
• Thinking pointcut syntax is wrong
• Believing System.currentTimeMillis() is invalid

5. You want to monitor execution time of all service methods but exclude methods annotated with @SkipTiming. Which AOP pointcut expression correctly achieves this?

hard

A. execution(* com.example.service..*(..)) && !@annotation(com.example.SkipTiming)

B. execution(* com.example.service..*(..)) || @annotation(com.example.SkipTiming)

C. execution(* com.example.service..*(..)) && @annotation(com.example.SkipTiming)

D. !execution(* com.example.service..*(..)) && !@annotation(com.example.SkipTiming)

Solution

1. Step 1: Understand pointcut logic for inclusion and exclusion

   We want all service methods except those with @SkipTiming annotation.

2. Step 2: Use && with negation to exclude annotated methods

   Use 'execution(...) && !@annotation(...)' to include methods but exclude those annotated.

3. Final Answer:

   execution(* com.example.service..*(..)) && !@annotation(com.example.SkipTiming) -> Option A

4. Quick Check:

   Exclude annotated methods with !@annotation [OK]

Hint: Use && !@annotation to exclude methods [OK]

Common Mistakes:

• Using || which includes annotated methods
• Using && @annotation which includes only annotated
• Negating execution pointcut incorrectly