Spring Boot 面向切面编程(AOP) 入门

艾伦耶格尔

发布于 2025-08-28 14:42:55

1900

想象一下，你的代码库像一座精心设计的城市，各个模块各司其职。但随着项目规模扩大，一些必要的"城市设施"，比如安全检查站（日志记录）、交通信号灯（性能监控）却遍布城市的每个角落，导致交通拥堵，难以维护。Spring AOP 就是为了解决这个问题而生的"城市规划师"，它将这些横切关注点抽离出来，统一管理，让你的代码库重归整洁。

本文将对于AOP "展开说说" ！

1. AOP：面向切面编程 -> 代码解耦

AOP（Aspect Oriented Programming），即面向切面编程，是OOP（面向对象编程）的一种补充。OOP 擅长将程序分解成一个个模块化的单元（类），而 AOP 则致力于将横切关注点与业务逻辑分离。

横切关注点是指那些与业务逻辑无关，却影响多个模块的功能，例如：

安全性检查
日志记录
性能统计
事务管理

试想，如果将这些代码都写在业务逻辑中，就会出现代码冗余、耦合度高、维护困难等问题。

AOP 的作用就是将这些横切关注点从业务逻辑中剥离出来，形成独立的模块（切面），然后通过配置的方式，将这些切面动态地织入到目标代码中。

2. AOP 的好处

使用 AOP 的好处就像拥有一个健康的体魄：

提高代码模块化： 将横切关注点与业务逻辑分离，提高代码的可读性和可维护性。
减少代码重复： 将通用功能封装成切面，避免重复编写代码。
增强代码灵活性： 通过配置的方式动态地织入切面，方便地添加或移除功能。
提高代码可重用性： 切面可以被多个模块共享，提高代码的复用率。

3. Spring AOP

Spring AOP 是 Spring 框架中一个重要的模块，它基于动态代理机制，在运行时将切面织入到目标对象中。

Spring AOP 的核心概念：

切面（Aspect）： 横切关注点的模块化实现，例如日志切面、安全切面。
连接点（Join Point）： 程序执行过程中可以被拦截的点，例如方法调用、异常抛出。
切点（Pointcut）： 匹配连接点的表达式，定义哪些连接点需要被拦截。
通知（Advice）： 切面在连接点上执行的操作，例如记录日志、校验权限。
目标对象（Target Object）： 被切面织入的业务逻辑对象。
织入（Weaving）： 将切面应用到目标对象的过程。

4. Spring Boot 中 AOP 的使用

在 Spring Boot 中使用 AOP 非常简单，只需几步即可完成：

步骤一：引入 Spring AOP Starter 依赖

在 pom.xml 文件中添加如下依赖：

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

步骤二：定义切面

创建一个类，并使用 @Aspect 注解标记，表明这是一个切面类。

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
   // ...
}

步骤三：定义切点

使用 @Pointcut 注解定义切点，即哪些方法需要被增强。

@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethods() {}

上述代码定义了一个名为 serviceMethods 的切点，它匹配 com.example.service 包下所有类的所有方法。

步骤四：定义通知

总体示例：

public class MyAspect {

    @Pointcut("execution(* com.test.service.*.*(..))")   //切入点表达式
    public void pt(){}   //定义此表达式为方法，后面直接使用方法，不用每次都写表达式

    //前置通知
    @Before("pt()")
    public void before(JoinPoint joinPoint){
        log.info("before ...");

    }

    //环绕通知
    @Around("pt()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        log.info("around before ...");

        //调用目标对象的原始方法执行
        Object result = proceedingJoinPoint.proceed();

        //原始方法如果执行时有异常，环绕通知中的后置代码不会在执行了

        log.info("around after ...");
        return result;
    }

    //后置通知
    @After("pt()")
    public void after(JoinPoint joinPoint){
        log.info("after ...");
    }

    //返回后通知（程序在正常执行的情况下，会执行的后置通知）
    @AfterReturning("pt()")
    public void afterReturning(JoinPoint joinPoint){
        log.info("afterReturning ...");
    }

    //异常通知（程序在出现异常的情况下，执行的后置通知）
    @AfterThrowing("pt()")
    public void afterThrowing(JoinPoint joinPoint){
        log.info("afterThrowing ...");
    }
}

使用 @Before、@After、@AfterReturning、@AfterThrowing、@Around 注解定义通知，即如何增强目标方法。

@Before("serviceMethods()")
public void logBefore(JoinPoint joinPoint) {
    String methodName = joinPoint.getSignature().getName();
    Object[] args = joinPoint.getArgs();
    log.info("方法 {} 开始执行，参数: {}", methodName, Arrays.toString(args));
}

上述代码定义了一个名为 logBefore 的前置通知，它会在目标方法执行之前打印方法名和参数。

注意事项：

/**
 * 多个切面类运行，与类名有关
 * 目标方法前，字母排前先执行
 * 目标方法后，字母排前后执行
 * 可以通过@order注解实现自定义执行顺序
 */

5. 使用方式总结

Spring Boot 对 Spring AOP 提供了自动配置，让你使用 AOP 更加方便快捷。

引入依赖： 在 pom.xml 中添加 spring-boot-starter-aop 依赖。
定义切面： 创建一个类，使用 @Aspect 注解标记为切面，并使用 @Component 注解将其注册为 Spring Bean。
定义切点： 使用 @Pointcut 注解定义切点表达式，指定要拦截哪些方法。
定义通知： 使用 @Before、@After、@Around 等注解定义通知，实现增强逻辑。

示例：

@Aspect
@Component
public class LoggingAspect {

    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethods() {}

    @Before("serviceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        log.info("方法 {} 开始执行...", methodName);
    }
}