@Aspect annotation in Spring Boot - Cheat Sheet & Quick Revision

Recall & Review

beginner

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

The <code>@Aspect</code> annotation marks a class as an aspect, which contains cross-cutting concerns like logging or security that can be applied across multiple parts of an application.

intermediate

How does an <code>@Aspect</code> class interact with other parts of the application?

An <code>@Aspect</code> class defines advice (code to run) and pointcuts (where to run it). Spring uses these to weave the advice into the application at specified join points like method calls.

beginner

Which Spring Boot module must be included to use @Aspect?

You need to include spring-boot-starter-aop in your project dependencies to enable Aspect-Oriented Programming features like @Aspect.

intermediate

Can an <code>@Aspect</code> class have state (fields) that change during execution?

It's best to keep @Aspect classes stateless or thread-safe because Spring may create a single instance shared across threads.

beginner

What is a common real-life example of using @Aspect in an application?

Logging method execution time is a common use. An @Aspect can measure how long methods take and log this info without changing the method code itself.

What does the @Aspect annotation do in Spring Boot?

A Marks a class as containing cross-cutting logic

B Defines a REST controller

C Marks a class as a database entity

D Enables caching for a method

@Aspect marks a class as an aspect for cross-cutting concerns like logging.

Which dependency is needed to use @Aspect in Spring Boot?

A spring-boot-starter-aop

B spring-boot-starter-data-jpa

C spring-boot-starter-web

D spring-boot-starter-security

spring-boot-starter-aop enables Aspect-Oriented Programming features.

What is a 'pointcut' in the context of an @Aspect?

A A method that runs advice

B A type of exception

C A place where advice is applied

D A database query

A pointcut defines where the advice should be applied in the program.

Which advice type runs before a method execution in an @Aspect?

A @After

B @Before

C @Around

D @AfterReturning

@Before advice runs before the target method.

Why should @Aspect classes be stateless or thread-safe?

A Because Spring creates multiple instances

B Because aspects cannot have fields

C Because aspects run only once

D Because Spring shares a single instance across threads

Spring usually creates one instance of an aspect shared by many threads, so it must be thread-safe.

Explain what the @Aspect annotation does and how it helps in a Spring Boot application.

Think about how you can add logging or security checks without changing every method.

Describe the relationship between an @Aspect class, advice, and pointcuts.

Consider how the aspect knows when and where to run extra code.

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