Mastering AOP in Spring Boot: From Basics to Practical Code

AOP (Aspect Oriented Programming) is a programming paradigm that focuses on separating cross‑cutting concerns from core business logic, complementing traditional OOP (Object Oriented Programming).

While OOP treats everything as objects, developers often encounter repeated logic across multiple objects, making further abstraction cumbersome. AOP addresses this by defining aspects —points in the program where additional behavior can be injected.

For example, teachers, civil servants, and computers all need daily time‑tracking. Implementing separate logic for each leads to duplication, while a unified interface becomes overly complex. AOP allows these common tasks to be handled as a single aspect, reducing redundancy.

Implementing AOP in Spring Boot

The process involves three basic steps:

Define the aspect (where to place it).

Write the additional behavior to be injected.

Weave the aspect into existing business logic.

Assume a simple Spring Boot project that concatenates two strings. First, add the required Maven dependencies:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>

Next, create a custom annotation to mark methods for AOP processing:

package com.example.demo.learnaop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogAop {
}

Define an aspect class with a pointcut that targets the desired method:

public class AopAdvice {
    @Pointcut("execution(* com.example.demo.learnaop.DoService.learnMinus(..))")
    public void logAopCut() {
        int a = 1;
        System.out.println("point cut 123 ");
    }
}

Apply the annotation to the business method:

@LogAop
@Override
public String learnMinus(String para1, String para2) {
    System.out.println("service learn minus " + para1 + para2);
    return para1 + "-" + para2;
}

Alternatively, you can skip the custom annotation and use an execution expression directly in the pointcut, which works like a regular expression to match join points.

The following diagram illustrates the structure of an execution expression:

By leveraging annotations and execution expressions, AOP reduces configuration complexity and enhances modularity in Spring Boot applications.