@Aspect annotation in Spring Boot - Performance & Optimization

Performance: @Aspect annotation

MEDIUM IMPACT

This affects application runtime performance by adding extra method interception and proxy creation overhead.

Applying cross-cutting concerns like logging or security checks

Spring Boot

@Aspect
public class LoggingAspect {
  @Before("execution(* com.example.service.UserService.getUser(..))")
  public void logBefore() {
    // logging logic
  }
}

Limits advice to only specific methods, reducing proxy count and interception overhead.

📈 Performance GainFewer proxies created and less runtime interception, improving method call speed.

Applying cross-cutting concerns like logging or security checks

Spring Boot

@Aspect
public class LoggingAspect {
  @Before("execution(* com.example..*(..))")
  public void logBefore() {
    // logging logic
  }
}

This applies advice to all methods in the package, creating many proxies and intercepting every call, causing unnecessary overhead.

📉 Performance CostTriggers proxy creation for many beans and adds interception overhead on every method call.

Performance Comparison

Pattern	Proxy Creation	Method Call Overhead	Memory Impact	Verdict
Broad @Aspect pointcut (e.g., all methods in package)	High (many proxies)	High (all calls intercepted)	Medium (proxy objects)	[X] Bad
Narrow @Aspect pointcut (specific methods only)	Low (few proxies)	Low (few calls intercepted)	Low (less proxy objects)	[OK] Good

Rendering Pipeline

At runtime, Spring creates proxies for beans with @Aspect advice. Method calls go through these proxies, adding interception steps before and after the actual method execution.

→Proxy Creation

→Method Invocation

→Advice Execution

⚠️ BottleneckMethod Invocation through proxies adds overhead compared to direct calls.

Optimization Tips

1Use @Aspect advice sparingly and target specific methods.

2Avoid broad pointcuts that intercept many methods unnecessarily.

3Profile your application to measure proxy and interception overhead.

Performance Quiz - 3 Questions

What is the main runtime cost of using @Aspect in Spring Boot?

A Increased database query time

B Extra proxy creation and method interception overhead

C Longer application startup due to XML parsing

D More network requests to external services

DevTools: Spring Boot Actuator / Java Flight Recorder

How to check: Enable Spring Boot Actuator metrics and use Java Flight Recorder to profile method call overhead and proxy creation.

What to look for: Look for increased method call duration and number of proxy instances to identify costly @Aspect usage.

Practice

1. What is the primary purpose of the @Aspect annotation in Spring Boot?

easy

A. To schedule tasks to run at fixed intervals

B. To define a REST controller for handling HTTP requests

C. To configure database connections automatically

D. To mark a class as an aspect that can add extra behavior to other parts of the program

Solution

1. Step 1: Understand the role of @Aspect

   The @Aspect annotation marks a class as an aspect, which means it can add extra behavior to other parts of the program without changing their code.

2. Step 2: Differentiate from other annotations

   Other options like REST controllers, database configuration, or scheduling are unrelated to @Aspect.

3. Final Answer:

   To mark a class as an aspect that can add extra behavior to other parts of the program -> Option D

4. Quick Check:

   @Aspect = marks aspect class [OK]

Hint: Remember: @Aspect marks classes for extra behavior [OK]

Common Mistakes:

• Confusing @Aspect with @Controller
• Thinking @Aspect manages database or scheduling
• Assuming @Aspect runs HTTP endpoints

2. Which of the following is the correct way to declare an aspect class in Spring Boot?

easy

A. @Aspect public class MyAspect {}

B. public class MyAspect @Aspect {}

C. @Aspect() void MyAspect() {}

D. class MyAspect @Aspect public {}

Solution

1. Step 1: Check correct annotation placement

   The @Aspect annotation must be placed before the class declaration, like @Aspect public class MyAspect {}.

2. Step 2: Identify invalid syntax

   Options A, B, and D place @Aspect incorrectly or misuse syntax, causing errors.

3. Final Answer:

   @Aspect public class MyAspect {} -> Option A

4. Quick Check:

   @Aspect before class name = correct syntax [OK]

Hint: Put @Aspect right before the class keyword [OK]

Common Mistakes:

• Placing @Aspect after class name
• Using @Aspect on methods instead of classes
• Incorrect parentheses or missing class keyword

3. Given this aspect code snippet, what will be printed when someMethod() is called?

@Aspect
public class LoggingAspect {
  @Before("execution(* someMethod())")
  public void logBefore() {
    System.out.println("Before method");
  }
}

medium

A. After method

B. No output

C. Before method

D. Compilation error

Solution

1. Step 1: Understand @Before advice

   The @Before annotation runs the logBefore() method before someMethod() executes, printing "Before method".

2. Step 2: Confirm no errors or other outputs

   There is no @After advice or errors, so only "Before method" prints.

3. Final Answer:

   Before method -> Option C

4. Quick Check:

   @Before runs before target method [OK]

Hint: @Before prints before method runs [OK]

Common Mistakes:

• Confusing @Before with @After
• Expecting no output if unaware of advice
• Assuming syntax errors without checking code

4. Identify the error in this aspect code:

@Aspect
public class MyAspect {
  @Before("execution(* someMethod())")
  public void logBefore() {
    System.out.println("Before method");
  }

  public void someMethod() {
    System.out.println("Inside someMethod");
  }
}

medium

A. The pointcut expression is incorrect

B. The aspect class must be annotated with @Component or registered as a bean

C. The advice method logBefore() must return a value

D. The someMethod() cannot be inside the aspect class

Solution

1. Step 1: Check aspect registration

   In Spring Boot, an aspect class must be a Spring bean to work. It needs @Component or manual bean registration.

2. Step 2: Validate other code parts

   The pointcut expression and advice method are correct. Having someMethod() inside the aspect is allowed but unusual.

3. Final Answer:

   The aspect class must be annotated with @Component or registered as a bean -> Option B

4. Quick Check:

   Aspect needs bean registration [OK]

Hint: Aspect classes must be Spring beans to work [OK]

Common Mistakes:

• Ignoring @Component or bean registration
• Thinking advice methods must return values
• Assuming pointcut syntax is wrong without checking

5. You want to log execution time of all methods in a service class using @Aspect. Which approach correctly applies this?

hard

A. Use @Around advice with a pointcut matching all methods in the service class and measure time before and after proceeding

B. Use @Before advice to start timer and @After advice to stop timer separately

C. Add logging code directly inside each service method instead of using @Aspect

D. Use @AfterThrowing advice to log execution time only when exceptions occur

Solution

1. Step 1: Understand timing with @Around advice

   @Around advice can run code before and after the target method, allowing precise measurement of execution time.

2. Step 2: Evaluate other options

   @Before and @After separately cannot measure total time easily; direct logging mixes concerns; @AfterThrowing only runs on exceptions, missing normal cases.

3. Final Answer:

   Use @Around advice with a pointcut matching all methods in the service class and measure time before and after proceeding -> Option A

4. Quick Check:

   @Around advice best for timing [OK]

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

Common Mistakes:

• Using separate @Before and @After for timing
• Mixing logging code inside business methods
• Logging only on exceptions with @AfterThrowing