Understanding and Implementing AOP in Spring Boot: Concepts, Annotations, and Practical Examples

AOP (Aspect Oriented Programming) is one of the three core concepts of Spring, alongside IoC and DI, and is used to modularize cross‑cutting concerns such as permission checks, logging, and statistics that would otherwise be scattered throughout business logic.

The article first introduces what AOP is, why it matters, and how it differs from traditional object‑oriented approaches. It explains that AOP separates non‑business code from business code by defining pointcuts (where to weave), advice (what to do and when), aspects (the combination of pointcut and advice), join points (specific execution points), and weaving (the process of applying aspects).

Next, the article provides concrete examples. The first example shows a minimal AOP setup that logs a message before any method annotated with @GetMapping is executed. The required Maven dependency is shown:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

The aspect class LogAdvice defines a pointcut for @GetMapping methods and a @Before advice that prints "get请求的advice触发了". A simple controller with a GET and a POST endpoint demonstrates that the advice only applies to the GET method.

The second example introduces a custom annotation @PermissionAnnotation and shows how to create two separate aspects that perform sequential permission checks. The first aspect validates the id field, while the second validates that the name equals "admin". Execution order is controlled by the @Order annotation (lower numbers run first). Sample code snippets for the custom annotation, the two aspect classes, and the controller are included, and test results (including error responses) are illustrated with screenshots.

Finally, the article details the most common Spring AOP annotations:

@Pointcut : defines where to intercept, using either execution(...) or @annotation(...) expressions.

@Around : wraps the target method, allowing pre‑ and post‑processing, argument modification, and return‑value alteration.

@Before and @After : run respectively before and after the target method, useful for logging and statistics.

@AfterReturning : captures the method's return value for further processing.

@AfterThrowing : handles exceptions thrown by the target method.

Each annotation is demonstrated with concise code examples that show how to obtain method signatures, request URLs, IP addresses, and how to manipulate ProceedingJoinPoint arguments.

The article concludes with a link to the full GitHub repository (https://github.com/ThinkMugz/aopDemo) where all the demo projects and source code can be downloaded.