Spring AOP 详解与实战：从入门到精通

回家路上绕了弯2025-08-14 18:17

Spring AOP 详解与实战：从入门到精通

面向切面编程（AOP）是 Spring 框架的两大核心技术之一，它通过将横切关注点（如日志记录、事务管理、安全控制）与业务逻辑分离，极大地提高了代码的模块化程度和可维护性。本文将从基础概念到实战应用，全面讲解 Spring AOP 的使用方法，帮助你在项目中灵活运用这一强大技术。

一、Spring AOP 核心概念

在深入使用之前，我们需要理解 AOP 的几个核心术语，这些概念是掌握 AOP 的基础：

术语 含义
切面（Aspect） 封装横切关注点的模块，由切点和通知组成
连接点（Joinpoint） 程序执行过程中的可插入点（如方法调用、异常抛出）
切点（Pointcut） 定义哪些连接点会被拦截的表达式
通知（Advice） 切面在特定连接点执行的操作（如前置、后置处理）
目标对象（Target） 被切面拦截的原始对象
代理对象（Proxy） Spring 为目标对象创建的代理实例，用于执行切面逻辑
织入（Weaving） 将切面应用到目标对象并创建代理对象的过程

Spring AOP 基于动态代理实现，支持两种代理方式：

  • JDK 动态代理：针对实现接口的类，创建接口的代理实例

  • CGLIB 代理：针对未实现接口的类，通过继承创建子类代理

Spring 会根据目标对象是否实现接口自动选择代理方式。

二、环境准备

要使用 Spring AOP，需在项目中添加相关依赖。以 Maven 为例，在pom.xml中添加：

xml

xml 复制代码 
<!-- Spring AOP 核心依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.20</version>
</dependency>
<!-- AOP 注解支持 -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>

Spring Boot 项目可直接使用 starter：

xml

xml 复制代码 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

三、Spring AOP 注解配置详解

Spring AOP 推荐使用注解方式配置，主要涉及以下核心注解：

1. @Aspect

标记一个类为切面类，需要配合@Component注解将其纳入 Spring 容器管理：

java

less 复制代码 
@Component
@Aspect
public class LogAspect {
    // 切面逻辑...
}

2. @Pointcut

定义切点表达式，用于匹配需要拦截的连接点。常用的切点表达式类型：

方法执行切点（最常用）

java

less 复制代码 
// 匹配指定包下所有类的所有方法
@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethods() {}

// 匹配指定类的所有public方法
@Pointcut("execution(public * com.example.service.UserService.*(..))")
public void userServicePublicMethods() {}

// 匹配指定类的特定方法（参数匹配）
@Pointcut("execution(* com.example.service.OrderService.createOrder(Long, String))")
public void createOrderMethod() {}

execution 表达式语法：execution(修饰符 返回值 包名.类名.方法名(参数) 异常)

其他常用切点类型

java

less 复制代码 
// 匹配标注了@Transactional注解的方法
@Pointcut("@annotation(org.springframework.transaction.annotation.Transactional)")
public void transactionalMethods() {}

// 匹配标注了@Service注解的类中的所有方法
@Pointcut("@within(org.springframework.stereotype.Service)")
public void serviceClassMethods() {}

// 匹配指定参数类型的方法
@Pointcut("args(Long, String)")
public void methodsWithLongAndStringArgs() {}

3. 通知类型注解

Spring AOP 提供五种通知类型，分别对应不同的执行时机：

@Before（前置通知）

在目标方法执行前执行：

java

typescript 复制代码 
@Before("serviceMethods()")
public void logBefore(JoinPoint joinPoint) {
    String methodName = joinPoint.getSignature().getName();
    Object[] args = joinPoint.getArgs();
    System.out.printf("方法%s开始执行，参数：%s%n", methodName, Arrays.toString(args));
}

JoinPoint参数提供了目标方法的信息（方法名、参数等）。

@After（后置通知）

在目标方法执行后执行（无论是否抛出异常）：

java

java 复制代码 
@After("serviceMethods()")
public void logAfter(JoinPoint joinPoint) {
    String methodName = joinPoint.getSignature().getName();
    System.out.printf("方法%s执行结束%n", methodName);
}
@AfterReturning（返回通知）

在目标方法正常返回后执行，可获取返回值：

java

typescript 复制代码 
@AfterReturning(pointcut = "serviceMethods()", returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {
    String methodName = joinPoint.getSignature().getName();
    System.out.printf("方法%s执行成功，返回值：%s%n", methodName, result);
}

returning属性指定接收返回值的参数名。

@AfterThrowing（异常通知）

在目标方法抛出异常时执行，可获取异常信息：

java

typescript 复制代码 
@AfterThrowing(pointcut = "serviceMethods()", throwing = "ex")
public void logAfterThrowing(JoinPoint joinPoint, Exception ex) {
    String methodName = joinPoint.getSignature().getName();
    System.out.printf("方法%s执行异常，异常信息：%s%n", methodName, ex.getMessage());
}

throwing属性指定接收异常的参数名。

@Around（环绕通知）

环绕目标方法执行，可控制目标方法的执行时机，功能最强大：

java

java 复制代码 
@Around("serviceMethods()")
public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
    String methodName = pjp.getSignature().getName();
    long startTime = System.currentTimeMillis();
    
    try {
        // 执行目标方法
        Object result = pjp.proceed();
        long endTime = System.currentTimeMillis();
        System.out.printf("方法%s执行耗时：%dms%n", methodName, (endTime - startTime));
        return result;
    } catch (Throwable e) {
        System.out.printf("方法%s执行异常：%s%n", methodName, e.getMessage());
        throw e; // 继续抛出异常，不掩盖原异常
    }
}

ProceedingJoinPoint的proceed()方法用于执行目标方法，必须显式调用。

四、实战案例：实现日志切面

下面通过一个完整案例展示如何使用 Spring AOP 实现日志记录功能。

1. 定义业务服务

java

typescript 复制代码 
@Service
public class UserService {
    public User getUserById(Long id) {
        if (id == null || id <= 0) {
            throw new IllegalArgumentException("用户ID无效");
        }
        return new User(id, "张三", 25);
    }
    
    public User createUser(String name, Integer age) {
        User user = new User(System.currentTimeMillis(), name, age);
        return user;
    }
}

// 用户实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private Integer age;
}

2. 实现日志切面

java

java 复制代码 
@Component
@Aspect
public class LoggingAspect {
    // 定义切点：匹配UserService的所有方法
    @Pointcut("execution(* com.example.service.UserService.*(..))")
    public void userServiceMethods() {}
    
    // 前置通知
    @Before("userServiceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        String method = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("【前置日志】方法：" + method + "，参数：" + Arrays.toString(args));
    }
    
    // 返回通知
    @AfterReturning(pointcut = "userServiceMethods()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        String method = joinPoint.getSignature().getName();
        System.out.println("【返回日志】方法：" + method + "，结果：" + result);
    }
    
    // 异常通知
    @AfterThrowing(pointcut = "userServiceMethods()", throwing = "ex")
    public void logAfterThrowing(JoinPoint joinPoint, Exception ex) {
        String method = joinPoint.getSignature().getName();
        System.out.println("【异常日志】方法：" + method + "，异常：" + ex.getMessage());
    }
    
    // 环绕通知：记录方法执行时间
    @Around("userServiceMethods()")
    public Object logExecutionTime(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = pjp.proceed();
        long end = System.currentTimeMillis();
        System.out.println("【性能日志】方法：" + pjp.getSignature().getName() + "，耗时：" + (end - start) + "ms");
        return result;
    }
}

3. 配置类与测试

java

less 复制代码 
@Configuration
@ComponentScan("com.example")
@EnableAspectJAutoProxy // 启用AOP注解支持
public class AppConfig {
}

// 测试类
public class AopTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean(UserService.class);
        
        // 测试正常方法
        userService.getUserById(1L);
        
        // 测试异常方法
        try {
            userService.getUserById(-1L);
        } catch (Exception e) {
            // 预期异常，不处理
        }
        
        // 测试创建用户
        userService.createUser("李四", 30);
    }
}

4. 输出结果

plaintext

ini 复制代码 
【前置日志】方法：getUserById，参数：[1]
【性能日志】方法：getUserById，耗时：1ms
【返回日志】方法：getUserById，结果：User(id=1, name=张三, age=25)
【前置日志】方法：getUserById，参数：[-1]
【异常日志】方法：getUserById，异常：用户ID无效
【性能日志】方法：getUserById，耗时：0ms
【前置日志】方法：createUser，参数：[李四, 30]
【性能日志】方法：createUser，耗时：0ms
【返回日志】方法：createUser，结果：User(id=1655234567890, name=李四, age=30)

从输出可以看到，切面成功拦截了目标方法，并在不同时机执行了相应的日志逻辑。

五、切面优先级与重用

1. 切面优先级

当多个切面作用于同一个目标方法时，可通过@Order注解指定优先级，值越小优先级越高：

java

less 复制代码 
@Order(1) // 优先级高于Order(2)
@Component
@Aspect
public class SecurityAspect { ... }

@Order(2)
@Component
@Aspect
public class LogAspect { ... }

2. 切点重用

可以在一个切面中定义通用切点，供多个通知使用，也可以通过@Pointcut的组合实现复杂切点：

java

less 复制代码 
// 通用切点：所有服务层方法
@Pointcut("within(com.example.service..*)")
public void serviceLayer() {}

// 通用切点：所有public方法
@Pointcut("execution(public * *(..))")
public void publicMethods() {}

// 组合切点：服务层的public方法
@Pointcut("serviceLayer() && publicMethods()")
public void publicServiceMethods() {}

六、Spring AOP 注意事项

  1. 方法可见性：Spring AOP 默认只拦截 public 方法，非 public 方法的切面可能不生效。

  2. 自调用问题：目标对象内部方法调用（如 A.method1 () 调用 A.method2 ()）不会触发切面，因为绕过了代理对象。解决方法：

    • 注入自身代理对象（@Autowired private A a;）
    • 使用AopContext.currentProxy()获取代理对象

  3. 性能考虑：AOP 会增加一定的性能开销，避免对高频调用的方法使用复杂切面。

  4. 异常处理：环绕通知中捕获异常后应重新抛出，避免掩盖业务异常。

  5. 构造方法拦截：Spring AOP 不支持拦截构造方法，如需此功能可考虑使用 AspectJ。

七、Spring AOP 应用场景

AOP 适合处理具有横切特性的功能，常见应用场景包括：

  1. 日志记录：记录方法调用、参数、返回值和执行时间
  2. 事务管理：声明式事务的开启、提交和回滚
  3. 安全控制：权限验证、接口访问控制
  4. 异常处理：统一异常捕获和处理
  5. 缓存控制：方法结果缓存、缓存失效处理
  6. 性能监控：方法执行时间统计、性能瓶颈分析

总结

Spring AOP 通过注解配置实现了强大而灵活的切面编程能力，它将横切关注点与业务逻辑分离，极大地提高了代码的可维护性和复用性。本文介绍了 Spring AOP 的核心概念、注解配置、实战案例和注意事项，希望能帮助你在实际项目中灵活运用 AOP 技术。

掌握 AOP 的关键在于理解切点表达式和各种通知类型的适用场景，通过多实践不同的应用场景（如日志、事务、缓存），可以逐渐熟练掌握这一强大技术，写出更优雅、更模块化的代码。

相关推荐
坐吃山猪1 小时前
SpringBoot01-配置文件
java·开发语言
我叫汪枫2 小时前
《Java餐厅的待客之道：BIO, NIO, AIO三种服务模式的进化》
java·开发语言·nio
yaoxtao2 小时前
java.nio.file.InvalidPathException异常
java·linux·ubuntu
Swift社区3 小时前
从 JDK 1.8 切换到 JDK 21 时遇到 NoProviderFoundException 该如何解决？
java·开发语言
DKPT4 小时前
JVM中如何调优新生代和老生代？
java·jvm·笔记·学习·spring
phltxy4 小时前
JVM——Java虚拟机学习
java·jvm·学习
seabirdssss6 小时前
使用Spring Boot DevTools快速重启功能
java·spring boot·后端
喂完待续6 小时前
【序列晋升】29 Spring Cloud Task 微服务架构下的轻量级任务调度框架
java·spring·spring cloud·云原生·架构·big data·序列晋升
benben0446 小时前
ReAct模式解读
java·ai
热门推荐
012025 年高教社杯全国大学生数学建模竞赛C 题 NIPT 的时点选择与胎儿的异常判定 完整成品思路模型代码分享，全网首发高质量！！！022025年数学建模国赛C题超详细解题思路032025全国大学生数学建模C题保姆级思路模型（持续更新）：NIPT 的时点选择与胎儿的异常判定042025高教社杯国赛数学建模选题建议+初步分析052025国赛B题保姆级教程思路分析 碳化硅外延层厚度的确定06不再让Windows更新！&Edge游戏助手卸载及关闭自动更新07KGG转MP3工具|非KGM文件|解密音频08UV安装并设置国内源09奈飞工厂官网，国内Netflix影视在线看|中文网页电脑版入口10（E题｜AI 辅助智能体测）2025年高教杯全国大学生数学建模国赛解题思路|完整代码论文集合