Why AOP matters in Spring Boot - See It in Action

Why AOP matters

📖 Scenario: You are building a simple Spring Boot application that logs method execution times to improve performance monitoring.

🎯 Goal: Create a Spring Boot project that uses Aspect-Oriented Programming (AOP) to log the execution time of a service method without changing the method's code.

📋 What You'll Learn

Create a service class with a method that simulates work by sleeping for 1 second

Create a configuration variable to enable AOP logging

Create an aspect class that logs the execution time of the service method

Apply the aspect to the service method and complete the Spring Boot application setup

💡 Why This Matters

🌍 Real World

AOP helps add features like logging, security, and transactions without changing the main business code, making maintenance easier.

💼 Career

Understanding AOP is important for Java developers working with Spring Boot to write clean, modular, and maintainable code.

1

Create the service class

Create a Spring service class called WorkService with a method performTask() that sleeps for 1000 milliseconds to simulate work.

Spring Boot

import org.springframework.stereotype.Service;

// Your code here

Hint

Use @Service annotation and a method that calls Thread.sleep(1000) inside a try-catch block.

2

Enable AOP logging configuration

Create a configuration class called AopConfig and add the @EnableAspectJAutoProxy annotation to enable AOP support in the Spring Boot application.

Spring Boot

import org.springframework.stereotype.Service;

@Service
public class WorkService {
    public void performTask() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

import org.springframework.context.annotation.Configuration;

// Add @EnableAspectJAutoProxy annotation here
// Your code here

Hint

Use @Configuration and @EnableAspectJAutoProxy annotations on the AopConfig class.

3

Create the logging aspect

Create an aspect class called LoggingAspect with a method logExecutionTime() that uses @Around advice to log the execution time of performTask() method in WorkService.

Spring Boot

import org.springframework.stereotype.Service;

@Service
public class WorkService {
    public void performTask() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class AopConfig {
}

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

// Your code here

Hint

Use @Aspect and @Component annotations. Use @Around advice with the pointcut for performTask().

4

Complete the Spring Boot application

Create the main Spring Boot application class called Application with the @SpringBootApplication annotation and a main method that runs the application. Autowire WorkService and call performTask() inside the main method.

Spring Boot

import org.springframework.stereotype.Service;

@Service
public class WorkService {
    public void performTask() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class AopConfig {
}

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 LoggingAspect {
    @Around("execution(* WorkService.performTask(..))")
    public Object logExecutionTime(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;
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

// Your code here

Hint

Use @SpringBootApplication on the main class. Use SpringApplication.run() to start. Get WorkService bean and call performTask().

Practice

1. What is the main purpose of Aspect-Oriented Programming (AOP) in Spring Boot?

easy

A. To separate common tasks like logging and security from business logic

B. To replace the need for writing any business logic

C. To make the application run faster by skipping method calls

D. To store data in the database automatically

Solution

1. Step 1: Understand AOP's role

   AOP helps keep common tasks like logging or security separate from the main business code.

2. Step 2: Identify the main benefit

   This separation makes the code easier to read and maintain without changing the business logic itself.

3. Final Answer:

   To separate common tasks like logging and security from business logic -> Option A

4. Quick Check:

   AOP separates concerns = D [OK]

Hint: AOP separates cross-cutting tasks from main code [OK]

Common Mistakes:

• Thinking AOP replaces business logic
• Believing AOP speeds up method execution
• Confusing AOP with database operations

2. Which of the following is the correct way to define an aspect in Spring Boot using AOP?

easy

A. @Component
public class MyAspect { }

B. @Aspect
public class MyAspect { }

C. @Service
public class MyAspect { }

D. @Repository
public class MyAspect { }

Solution

1. Step 1: Recognize the annotation for aspects

   In Spring AOP, the @Aspect annotation marks a class as an aspect.

2. Step 2: Confirm the correct syntax

   Only @Aspect correctly defines an aspect; @Component alone does not define aspect behavior.

3. Final Answer:

   @Aspect public class MyAspect { } -> Option B

4. Quick Check:

   @Aspect marks aspect classes = B [OK]

Hint: Use @Aspect to define aspects in Spring Boot [OK]

Common Mistakes:

• Using @Component alone without @Aspect
• Confusing @Service or @Repository with aspects
• Missing the @Aspect annotation

3. Given this Spring Boot aspect code snippet, what will be printed when myService.doWork() is called?

@Aspect
@Component
public class LoggingAspect {
  @Before("execution(* com.example.MyService.doWork(..))")
  public void logBefore() {
    System.out.println("Starting work");
  }
}

@Service
public class MyService {
  public void doWork() {
    System.out.println("Doing work");
  }
}

medium

A. Starting work
Doing work

B. Doing work
Starting work

C. Doing work

D. Starting work

Solution

1. Step 1: Understand @Before advice

   The @Before advice runs before the target method, so "Starting work" prints first.

2. Step 2: Trace method call output

   Then the actual method prints "Doing work" after the advice.

3. Final Answer:

   Starting work Doing work -> Option A

4. Quick Check:

   @Before runs before method = A [OK]

Hint: @Before advice runs before method call output [OK]

Common Mistakes:

• Assuming advice runs after method
• Mixing order of printed lines
• Ignoring advice output

4. Identify the error in this Spring Boot aspect code that prevents the advice from running:

@Aspect
@Component
public class SecurityAspect {
  @Before("execution(* com.example.MyService.secureMethod())")
  public void checkSecurity() {
    System.out.println("Checking security");
  }
}

@Service
public class MyService {
  public void secureMethod(String user) {
    System.out.println("Secure method for " + user);
  }
}

medium

A. secureMethod should be private

B. Missing @Component annotation on MyService

C. Advice method must return a value

D. The pointcut expression does not match the method signature

Solution

1. Step 1: Compare pointcut and method signature

   The pointcut expects a method with no parameters, but secureMethod takes a String parameter.

2. Step 2: Understand pointcut matching rules

   Because the signature does not match, the advice never runs.

3. Final Answer:

   The pointcut expression does not match the method signature -> Option D

4. Quick Check:

   Pointcut must match method signature = A [OK]

Hint: Match pointcut exactly to method signature [OK]

Common Mistakes:

• Ignoring method parameters in pointcut
• Thinking @Component missing on service blocks advice
• Believing advice must return a value

5. You want to add logging before and after all methods in your service without changing each method. Which AOP approach best achieves this in Spring Boot?

hard

A. Create a new service class that duplicates all methods with logging

B. Manually add logging code inside every service method

C. Use @Before and @After advices with a pointcut matching all service methods

D. Use @Transactional annotation on service methods

Solution

1. Step 1: Identify the goal

   You want to add logging around all service methods without modifying them individually.

2. Step 2: Choose the correct AOP approach

   @Before and @After advices with a pointcut covering all service methods allow running code before and after each method automatically.

3. Final Answer:

   Use @Before and @After advices with a pointcut matching all service methods -> Option C

4. Quick Check:

   AOP advices automate cross-cutting tasks = C [OK]

Hint: Use @Before and @After with pointcut for all methods [OK]

Common Mistakes:

• Adding logging manually in every method
• Duplicating service classes unnecessarily
• Confusing logging with transaction management