@Aspect annotation in Spring Boot - Mini Project: Build & Apply

Using @Aspect Annotation in Spring Boot

📖 Scenario: You are building a Spring Boot application where you want to log method calls automatically without changing the business logic code.

🎯 Goal: Create an aspect using the @Aspect annotation that logs a message before any method in the com.example.service package runs.

📋 What You'll Learn

Create a Spring component class annotated with @Aspect

Define a pointcut expression targeting all methods in com.example.service package

Create a @Before advice that logs a message before the targeted methods execute

Register the aspect as a Spring bean using @Component

💡 Why This Matters

🌍 Real World

Aspects help add common behaviors like logging, security checks, or transactions without cluttering business logic code.

💼 Career

Understanding @Aspect and AOP is important for building maintainable Spring Boot applications and is a common requirement in Java backend developer roles.

1

Create the Aspect Class

Create a class called LoggingAspect in package com.example.aspect and annotate it with @Aspect and @Component.

Spring Boot

package com.example.aspect;

// Your code here

Hint

Use @Aspect to mark the class as an aspect and @Component to make it a Spring bean.

2

Define the Pointcut Expression

Inside LoggingAspect, create a method called allServiceMethods annotated with @Pointcut that matches execution of any method in package com.example.service.

Spring Boot

package com.example.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    // Define pointcut here
    // Your code here
}

Hint

The pointcut expression execution(* com.example.service..*(..)) matches all methods in com.example.service and its subpackages.

3

Create a Before Advice

Add a method called logBefore annotated with @Before("allServiceMethods()") that logs the message "Method is about to execute" using System.out.println.

Spring Boot

package com.example.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @Pointcut("execution(* com.example.service..*(..))")
    public void allServiceMethods() {}

    // Add @Before advice here
    // Your code here
}

Hint

The @Before annotation runs the method before the matched methods execute.

4

Complete and Register the Aspect

Ensure the LoggingAspect class is properly annotated with @Aspect and @Component so Spring Boot can detect and register it as a bean.

Spring Boot

package com.example.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

// Verify annotations here
// Your code here

Hint

Both @Aspect and @Component annotations are needed for Spring to recognize the aspect.

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