In this AOP with Spring Boot (Aspect-Oriented Programming) post, we will delve into the world of aspect-oriented programming and understand how it works to apply it in our applications.

What is AOP?

AOP, or Aspect-Oriented Programming, is a programming paradigm that aims to increase modularity within our applications. The idea behind this programming type is to add new behaviors without modifying the existing code. Spring provides a module to simplify this for us.

AOP Concepts

What is an Aspect in AOP?

An aspect can be defined as a common functionality within our application. For example, if we want to log a list every time one of our methods returns a specific type.

What is a Joinpoint in AOP?

A joinpoint in aspect-oriented programming is a point or controller of the program’s execution, such as a method, etc.

What is an Advice?

An advice is an action that occurs at specific moments in our code to execute an aspect.

What is a Pointcut in AOP?

A pointcut in AOP defines specific areas in our code where an advice should be executed.

When to use AOP?

As mentioned earlier, we want to use AOP as common functionality in our code that we can implement without making any changes or adding a behavior. For example, we could create an aspect to calculate the execution time of a method and determine if it takes too long. Let’s see a clearer example.

Example with AOP in Spring Boot

Let’s consider the use case we discussed earlier, calculating the execution time of a method.

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.2.RELEASE<version>
</parent>
 
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
</dependencies>

Example Method

package com.refactorizando.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
@Slf4j
public class AspectoTiempo {
 
    @Around("execution(* com.refactorizando.facade.*.*(..))")
       public Object processTime(ProceedingJoinPoint joinPoint) throws Throwable {
         
         long startTime=System.currentTimeMillis();
     
        Object methodProceed=joinPoint.proceed(); 
         
        long endTime=System.currentTimeMillis();
         
        var totalTime = startTime - endTime;

        if (totalTime > 1000) {
             
            log.debug("joinPoint.getTarget().getClass()+"."+joinPoint.getSignature().getName() +": with a total time of  "+ totalTime);
        }
         return methodProceed;
         
     }
 
}

Reasons to use AOP

1. Separation of concerns: AOP allows developers to separate the core business logic (primary concerns) from cross-cutting concerns. This makes the codebase cleaner and more maintainable.
2. Code reusability: By encapsulating cross-cutting concerns into reusable aspects or modules, AOP promotes code reusability across different parts of the application. This can reduce code duplication and improve overall code quality.
3. Modularity: AOP allows developers to organize and manage cross-cutting concerns in a modular manner. This makes it easier to add or remove functionalities without affecting the core business logic.
4. Improved maintainability: Since cross-cutting concerns are isolated in aspects, any changes or updates needed in those concerns can be made in a single place, thus reducing the impact on the rest of the codebase and making maintenance more straightforward.
5. Better readability and understanding: With AOP, the core business logic becomes more focused, and the cross-cutting concerns are extracted and defined separately as aspects. This separation improves code readability and makes it easier to understand the purpose of each module.
6. Cross-cutting concern abstraction: AOP abstracts cross-cutting concerns, providing a higher-level view of the application’s behavior. The scattered implementation of cross-cutting concerns does not distract developers, allowing them to focus on the primary concerns.
7. Dynamic runtime weaving: AOP allows the weaving of aspects at runtime, which means that aspects can be added or removed without recompiling the entire application. This dynamic nature is particularly beneficial for situations where cross-cutting concerns may change frequently or need to be applied selectively.

Conclusion

In this AOP with Spring Boot post, we have covered an introduction to the basic concepts and use cases of this type of programming.