AOP for performance monitoring in Spring Boot

Introduction

AOP helps measure how long parts of your program take to run without changing the main code. This makes it easy to find slow spots.

You want to check how fast a method runs in your app.

You need to log the time taken by database calls.

You want to monitor performance without adding timing code everywhere.

You want to find slow parts in your service methods.

You want to keep your main code clean and separate timing logic.

Syntax

Spring Boot

@Aspect
@Component
public class PerformanceAspect {

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

@Aspect marks the class as an aspect for AOP.

@Around lets you run code before and after the method you watch.

Examples

This example measures time in nanoseconds and converts to milliseconds.

Spring Boot

@Around("execution(* com.example.service.*.*(..))")
public Object logTime(ProceedingJoinPoint joinPoint) throws Throwable {
    long start = System.nanoTime();
    Object result = joinPoint.proceed();
    long end = System.nanoTime();
    System.out.println(joinPoint.getSignature() + " took " + (end - start) / 1_000_000 + " ms");
    return result;
}

This example only measures methods marked with @TrackTime annotation.

Spring Boot

@Around("@annotation(com.example.TrackTime)")
public Object trackAnnotatedMethods(ProceedingJoinPoint joinPoint) throws Throwable {
    long start = System.currentTimeMillis();
    Object result = joinPoint.proceed();
    long end = System.currentTimeMillis();
    System.out.println("Method " + joinPoint.getSignature() + " took " + (end - start) + " ms");
    return result;
}

Sample Program

This aspect measures and prints how long any method in com.example.demo.service package takes to run.

Spring Boot

package com.example.demo;

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.demo.service.*.*(..))")
    public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object proceed = joinPoint.proceed();
        long executionTime = System.currentTimeMillis() - start;
        System.out.println(joinPoint.getSignature() + " executed in " + executionTime + " ms");
        return proceed;
    }
}

Important Notes

Make sure to enable AspectJ auto proxy in your Spring Boot app with @EnableAspectJAutoProxy.

Use ProceedingJoinPoint.proceed() to run the original method.

Keep performance logging lightweight to avoid slowing down your app.

Summary

AOP lets you add timing code without changing your main methods.

Use @Around advice to measure method execution time.

This helps find slow parts and improve app speed easily.

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