AOP (Aspect-Oriented Programming) with Spring

Picture Source

However, layers have common concerns called cross-cutting concerns (monitoring, caching, etc.). One of the most common ways to implement them would be with aspect-oriented programming. Spring is a popular framework that implements AOP. In the following, we will focus on Spring AOP.

Terminology

There are three fundamental concepts in Aspect-Oriented Programming (AOP):

1. Advice is the action performed by an aspect at a particular join point in the application. Join points are specific points in the program flow, such as method invocations, exception handling, or field access. There are several types of advice in AOP, including @Before, @After, @Around, @AfterReturning, and @AfterThrowing. Each type of advice determines when an action should be taken in relation to the join point.
2. Pointcuts are expressions that select a set of join points in the application where an aspect’s advice should be applied. Pointcut expressions can be based on method signatures, annotations, class hierarchies, etc.
3. Inter-type declarations allow you to add new members, methods, and interfaces to an existing class at a compile time. This means that you can add new behaviors to a class without directly changing its source code.

Example

A well-known example of a cross-cutting concern is logging. It is safe to say that every application has it in some form. From API’s controller actions or middleware to the execution of specific tasks, it is a part of several layers.

Consider the following example of a class Calculator that performs arithmetic operations:

public class Calculator {
    public int add(final int a, final int b) {
        return a + b;
    }

    public int subtract(final int a, final int b) {
        return a - b;
    }
}

Now, logging each time these methods are called would require the following:

1. Creation of an aspect class that defines the behavior we want to add to the Calculator class. For example, create a logging aspect that logs every method call:

@Aspect
public class LoggingAspect {

    @Before("execution(* com.example.Calculator.*(..))")
    public void logMethodCall(final JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Method " + methodName + " called");
    }
}

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

    @Bean
    public Calculator calculator() {
        return new Calculator();
    }

    @Bean
    public LoggingAspect loggingAspect() {
        return new LoggingAspect();
    }
}

The @EnableAspectJAutoProxy annotation enables Spring to use AspectJ to apply AOP. The calculator() method defines the Calculator bean, and the loggingAspect() method defines the LoggingAspect bean.

[1] Used: Java 20 and Spring Boot 3.1.0 (with Spring Framework 6.0.9)

3. Usage of the Calculator bean. For example, the Main class that uses the Calculator to perform some operations:

public class Main {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        Calculator calculator = context.getBean(Calculator.class);
        int result = calculator.add(2, 3);
        System.out.println(result);
        context.close();
    }
}

After running the Main class, the following output will be provided: 

Method add called
5

As can be seen, the LoggingAspect logged the method call before the add() method was called. This demonstrates the use of AOP to add behaviors to classes without directly modifying them.

With this AOP, we were able to modularize a cross-cutting concern into a separate aspect that could then be applied to the appropriate components or modules through pointcut expressions. This makes managing and maintaining cross-cutting concerns easier since they are encapsulated in separate aspects that can be reused across the codebase.

Conclusion

AOP is a programming paradigm/technique that aims to increase modularity by allowing the separation of cross-cutting concerns. It is very powerful and must be handled carefully. Otherwise, it can create difficult situations to track down because it can introduce hidden behavior into the codebase, making it difficult to understand and debug. It’s important to carefully evaluate which parts of the codebase would truly benefit from AOP and avoid using it unnecessarily.