Springboot如何使用面向切面编程AOP?

news/2025/2/2 2:12:14/

Springboot如何使用面向切面编程AOP?

在 Spring Boot 中使用面向切面编程（AOP）非常简单，Spring Boot 提供了对 AOP 的自动配置支持。以下是详细的步骤和示例，帮助你快速上手 Spring Boot 中的 AOP。

1. 添加依赖

首先，在 pom.xml（Maven）或 build.gradle.kts（Gradle）中添加 Spring Boot Starter AOP 依赖：

Maven
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId>
</dependency>
Gradle-Kotlin build.gradle.kts
dependencies {implementation("org.springframework.boot:spring-boot-starter-aop")
}

implementation("org.springframework.boot:spring-boot-starter-aop")
Gradle-Groovy build.gradle
dependencies {implementation 'org.springframework.boot:spring-boot-starter-aop'
}

implementation 'org.springframework.boot:spring-boot-starter-aop'

2. 编写切面类

切面类是一个普通的 Spring Bean，使用 @Aspect 注解标记。切面类中定义了切点（Pointcut）和通知（Advice）。

示例：记录方法执行日志的切面
java">import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;@Aspect // 标记为切面类
@Component // 标记为 Spring Bean
public class LoggingAspect {// 定义切点：拦截 com.example.service 包下的所有方法@Pointcut("execution(* com.example.service.*.*(..))")public void serviceMethods() {}// 前置通知：在目标方法执行前执行@Before("serviceMethods()")public void logBeforeMethod() {System.out.println("方法即将执行...");}
}

3. 定义目标服务类

编写一个普通的 Spring 服务类，作为 AOP 的目标对象。

示例：用户服务类
java">import org.springframework.stereotype.Service;@Service
public class UserService {public void createUser(String name) {System.out.println("创建用户: " + name);}public void deleteUser(String name) {System.out.println("删除用户: " + name);}
}

4. 启用 AOP 支持

Spring Boot 默认会自动启用 AOP 支持，无需额外配置。如果需要手动启用，可以在主应用类上添加 @EnableAspectJAutoProxy 注解：

java">import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;@SpringBootApplication
@EnableAspectJAutoProxy // 启用 AOP 支持
public class MyApplication {public static void main(String[] args) {SpringApplication.run(MyApplication.class, args);}
}

5. 运行并验证

启动 Spring Boot 应用，调用 UserService 的方法，观察切面是否生效。

示例：调用服务方法
java">import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;@Component
public class AppRunner implements CommandLineRunner {@Autowiredprivate UserService userService;@Overridepublic void run(String... args) throws Exception {userService.createUser("Alice");userService.deleteUser("Bob");}
}
输出结果
方法即将执行...
创建用户: Alice
方法即将执行...
删除用户: Bob

6. 常用 AOP 注解

Spring AOP 提供了多种通知类型，以下是常用的注解：

注解说明
@Before在目标方法执行前执行。
@After在目标方法执行后执行（无论是否抛出异常）。
@AfterReturning在目标方法成功返回后执行。
@AfterThrowing在目标方法抛出异常后执行。
@Around环绕通知，可以控制目标方法的执行（如修改参数、返回值或捕获异常）。
示例：环绕通知
java">import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;@Aspect
@Component
public class TimingAspect {@Around("execution(* com.example.service.*.*(..))")public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {long startTime = System.currentTimeMillis();Object result = joinPoint.proceed(); // 执行目标方法long endTime = System.currentTimeMillis();System.out.println("方法执行时间: " + (endTime - startTime) + "ms");return result;}
}

7. 切点表达式

切点表达式用于定义拦截的目标方法。以下是常见的表达式示例：

表达式说明
execution(* com.example.service.*.*(..))拦截 com.example.service 包下的所有方法。
execution(* com.example.service.UserService.*(..))拦截 UserService 类中的所有方法。
execution(* com.example.service.*.create*(..))拦截 com.example.service 包下以 create 开头的方法。
@annotation(com.example.LogExecutionTime)拦截带有 @LogExecutionTime 注解的方法。
自定义注解示例
java">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 LogExecutionTime {}

在方法上使用注解：

java">@Service
public class UserService {@LogExecutionTimepublic void createUser(String name) {System.out.println("创建用户: " + name);}
}

在切面中拦截注解：

java">@Aspect
@Component
public class LogExecutionTimeAspect {@Around("@annotation(com.example.LogExecutionTime)")public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {long startTime = System.currentTimeMillis();Object result = joinPoint.proceed();long endTime = System.currentTimeMillis();System.out.println("方法执行时间: " + (endTime - startTime) + "ms");return result;}
}

8. 总结

  • Spring Boot 通过 spring-boot-starter-aop 提供了对 AOP 的自动支持。
  • 使用 @Aspect 定义切面类，结合 @Before、@After、@Around 等注解实现通知。
  • 切点表达式（execution）用于定义拦截的目标方法。
  • 可以通过自定义注解实现更灵活的切面逻辑。

通过以上步骤，你可以在 Spring Boot 中轻松实现面向切面编程（AOP），增强代码的可维护性和可扩展性。







在Spring Boot中使用面向切面编程（AOP）通常涉及以下几个步骤：

1. 引入依赖

虽然Spring Boot的spring-boot-starter已经包含了AOP的依赖，但为了确保AOP功能被正确启用，你可以在pom.xml中显式添加spring-boot-starter-aop依赖（尽管这通常是可选的，因为spring-boot-starter-web等常用starter已经包含了它）。

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

2. 启用AOP

在Spring Boot中，你通常不需要显式启用AOP，因为@SpringBootApplication注解已经包含了@EnableAspectJAutoProxy，后者负责启用AOP代理。但是，如果你想要自定义AOP代理的行为（例如，使用CGLIB而不是JDK动态代理），你可以通过添加@EnableAspectJAutoProxy注解并设置其属性来实现。

java">@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true) // 使用CGLIB代理
public class MySpringBootApplication {public static void main(String[] args) {SpringApplication.run(MySpringBootApplication.class, args);}
}

然而，在大多数情况下，默认设置就足够了。

3. 定义切面类

切面类是一个用@Aspect注解标记的类，它包含了切点（pointcut）和通知（advice）。

  • 切点：定义了哪些方法将被拦截。
  • 通知：定义了拦截到方法时要执行的操作。
java">@Aspect
@Component
public class MyAspect {// 定义一个切点，匹配所有com.example.service包下的所有方法@Pointcut("execution(* com.example.service..*(..))")public void myPointcut() {// 这是一个空方法，仅用于定义切点表达式}// 在方法执行之前执行@Before("myPointcut()")public void beforeAdvice(JoinPoint joinPoint) {System.out.println("Before method: " + joinPoint.getSignature());}// 在方法执行之后执行（无论是否抛出异常）@After("myPointcut()")public void afterAdvice(JoinPoint joinPoint) {System.out.println("After method: " + joinPoint.getSignature());}// 在方法执行之后执行（仅当方法正常返回时）@AfterReturning(pointcut = "myPointcut()", returning = "result")public void afterReturningAdvice(JoinPoint joinPoint, Object result) {System.out.println("After returning method: " + joinPoint.getSignature() + " with result: " + result);}// 在方法抛出异常时执行@AfterThrowing(pointcut = "myPointcut()", throwing = "exception")public void afterThrowingAdvice(JoinPoint joinPoint, Throwable exception) {System.out.println("After throwing method: " + joinPoint.getSignature() + " with exception: " + exception);}// 环绕通知，可以在方法执行前后自定义逻辑@Around("myPointcut()")public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("Before proceeding method: " + joinPoint.getSignature());Object result = joinPoint.proceed(); // 执行目标方法System.out.println("After proceeding method: " + joinPoint.getSignature() + " with result: " + result);return result;}
}

4. 应用切面

一旦你定义了切面类并将其作为Spring组件（通过@Component注解）注册到Spring容器中，Spring AOP将自动应用这些切面到匹配的bean上。

注意事项

  • 切面类本身必须是一个Spring管理的bean，因此通常会在切面类上使用@Component或其他相关的Spring注解。
  • 切点表达式定义了哪些方法将被拦截。你可以使用AspectJ的切点表达式语言（Pointcut Expression Language, PEL）来编写复杂的切点表达式。
  • 通知方法可以有参数，这些参数可以是JoinPoint、ProceedingJoinPoint（对于环绕通知）或任何由切点表达式捕获的参数（通过@Args注解）。
  • 环绕通知必须处理目标方法的调用（通过ProceedingJoinPoint.proceed()），并且可以返回结果或抛出异常。

通过以上步骤，你就可以在Spring Boot项目中成功使用AOP来实现横切关注点（如日志记录、事务管理、权限校验等）的分离。







在 Spring Boot 中使用面向切面编程（AOP）可以帮助你分离横切关注点，如日志记录、事务管理等，从主要业务逻辑中分离出来。Spring AOP 是基于代理的实现，默认情况下支持方法级别的拦截。下面是如何在 Spring Boot 应用中配置和使用 AOP 的步骤：

1. 添加依赖

首先，确保你的 build.gradle 或 pom.xml 文件中包含了 spring-boot-starter-aop 依赖。

对于 Gradle，添加如下依赖到你的 build.gradle 文件：

dependencies {implementation 'org.springframework.boot:spring-boot-starter-aop'
}

对于 Maven，在你的 pom.xml 文件中添加：

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

2. 启用 AOP 支持

Spring Boot 自动配置了 AOP 支持，所以通常不需要额外的手动配置。但是，如果你的应用有多个配置类，确保它们被正确扫描到。一般情况下，只需保证主应用程序类或配置类上包含 @EnableAspectJAutoProxy 注解（尽管大多数情况下自动配置已经足够）。

java">import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;@Configuration
@EnableAspectJAutoProxy
public class AopConfig {
}

不过，如果你只是简单地使用 Spring Boot，并且没有特别复杂的配置需求，这个注解通常是不必要的，因为 Spring Boot 已经为你自动启用了 AOP 支持。

3. 创建一个切面

创建一个类并使用 @Aspect 注解标记它。然后，定义切入点（Pointcut）和通知（Advice），例如前置通知（@Before）、后置通知（@After）、返回通知（@AfterReturning）、异常通知（@AfterThrowing）和环绕通知（@Around）。

示例代码：

java">import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;@Aspect
@Component
public class LoggingAspect {@Before("execution(* com.example.demo.service.*.*(..))")public void beforeMethodExecution() {System.out.println("A method in the service layer is about to be called.");}
}

4. 定义切入点表达式

上述例子中的 "execution(* com.example.demo.service.*.*(..))" 是一个切入点表达式，表示匹配 com.example.demo.service 包下的所有类的所有方法。你可以根据需要调整此表达式来精确控制哪些方法会被拦截。

5. 测试你的切面

最后，编写一些测试用例或者运行你的应用来验证 AOP 切面是否按预期工作。确保目标方法被调用时，相应的通知也会被执行。

通过以上步骤，你应该能够在 Spring Boot 应用中成功配置并使用 AOP。这种方式不仅能够帮助你清晰地分离关注点，还能使代码更加简洁和易于维护。







在 Spring Boot 中使用面向切面编程（AOP）可以高效地实现日志记录、事务管理、权限校验等横切关注点。以下是 详细步骤和实际应用场景 的总结：

1. 添加依赖

Spring Boot 默认通过 spring-boot-starter-aop 提供对 AOP 的自动配置支持：

Maven
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId>
</dependency>
Gradle
dependencies {implementation("org.springframework.boot:spring-boot-starter-aop")
}

2. 编写切面类

切面类需用 @Aspect 和 @Component 注解标记，定义切点和通知。

示例：日志记录切面
java">import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;@Aspect
@Component
public class LoggingAspect {// 定义切点：拦截 service 包下的所有方法@Pointcut("execution(* com.example.service.*.*(..))")public void serviceMethods() {}// 前置通知：方法执行前记录日志@Before("serviceMethods()")public void logMethodStart() {System.out.println("方法开始执行...");}// 后置通知：方法执行后记录日志（无论是否异常）@After("serviceMethods()")public void logMethodEnd() {System.out.println("方法执行结束。");}// 环绕通知：计算方法执行时间@Around("serviceMethods()")public Object measureTime(ProceedingJoinPoint joinPoint) throws Throwable {long start = System.currentTimeMillis();Object result = joinPoint.proceed(); // 执行目标方法long end = System.currentTimeMillis();System.out.println("方法执行耗时: " + (end - start) + "ms");return result;}
}

3. 定义目标服务

编写一个普通的 Spring Bean 作为切面拦截的目标。

示例：用户服务
java">@Service
public class UserService {public void createUser(String name) {System.out.println("创建用户: " + name);}
}

4. 验证效果

调用 UserService 的方法时，切面逻辑自动生效：

java">@SpringBootApplication
public class Application {public static void main(String[] args) {ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);UserService userService = context.getBean(UserService.class);userService.createUser("Alice");}
}
输出结果
方法开始执行...
创建用户: Alice
方法执行结束。
方法执行耗时: 2ms

5. 核心注解详解

(1) 切点表达式（Pointcut）
  • 语法：execution(修饰符 返回类型 包名.类名.方法名(参数类型))
  • 常用示例：
    • execution(* com.example.service.*.*(..))：拦截 service 包下所有类的所有方法。
    • execution(* com.example.service.UserService.create*(..))：拦截 UserService 中以 create 开头的方法。
    • @annotation(com.example.LogTrack)：拦截带有 @LogTrack 注解的方法。
(2) 通知类型（Advice）
注解说明
@Before目标方法执行前触发。
@After目标方法执行后触发（无论是否抛出异常）。
@AfterReturning目标方法成功返回后触发（可获取返回值）。
@AfterThrowing目标方法抛出异常后触发（可捕获异常对象）。
@Around包裹目标方法，可控制方法执行、修改参数或返回值。
示例：获取方法参数和返回值
java">@Aspect
@Component
public class DataAspect {@AfterReturning(pointcut = "execution(* com.example.service.*.*(..))",returning = "result")public void logResult(Object result) {System.out.println("方法返回值: " + result);}@Before("execution(* com.example.service.*.*(..)) && args(name)")public void logArgument(String name) {System.out.println("方法参数: " + name);}
}

6. 高级用法

(1) 自定义注解实现切面

定义注解标记需要拦截的方法，提高代码可读性。

步骤1：定义注解
java">@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogTrack {}
步骤2：在方法上使用注解
java">@Service
public class OrderService {@LogTrackpublic void placeOrder(String orderId) {System.out.println("下单成功: " + orderId);}
}
步骤3：切面拦截注解
java">@Aspect
@Component
public class LogTrackAspect {@Around("@annotation(com.example.LogTrack)")public Object trackMethod(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("开始追踪方法...");Object result = joinPoint.proceed();System.out.println("追踪结束。");return result;}
}
(2) 处理异常

在 @AfterThrowing 中捕获并处理异常。

java">@Aspect
@Component
public class ExceptionAspect {@AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))",throwing = "ex")public void handleException(Exception ex) {System.out.println("捕获异常: " + ex.getMessage());// 发送报警邮件或记录日志}
}

7. 常见问题与解决

问题1：切面未生效
  • 原因：
    • 切面类未被 Spring 管理（缺少 @Component）。
    • 切点表达式未匹配到目标方法。
    • 目标方法未被 Spring 代理（如直接通过 new 创建对象）。
  • 解决：
    • 确保切面类添加了 @Component。
    • 使用 @Autowired 获取 Bean，而非直接实例化。
问题2：环绕通知未调用 proceed()
  • 现象：目标方法未执行。
  • 解决：在 @Around 方法中必须调用 joinPoint.proceed()。

8. 实际应用场景

  1. 日志记录：自动记录方法入参、返回值、执行时间。
  2. 事务管理：结合 @Transactional 实现声明式事务。
  3. 权限校验：在方法执行前检查用户权限。
  4. 性能监控：统计接口耗时，优化慢查询。
  5. 缓存管理：在方法执行前后操作缓存（如 Redis）。

总结

Spring Boot 通过简化配置和自动代理机制，使得 AOP 的实现非常便捷。核心步骤：

  1. 添加 spring-boot-starter-aop 依赖。
  2. 使用 @Aspect 和 @Component 定义切面类。
  3. 通过切点表达式精准定位目标方法。
  4. 选择合适的通知类型（@Before、@Around 等）实现横切逻辑。

掌握 AOP 后，可以大幅减少重复代码，提升系统的可维护性和扩展性。








http://www.ppmy.cn/news/1568570.html

相关文章

Elasticsearch：如何搜索含有复合词的语言

Elasticsearch：如何搜索含有复合词的语言

作者&#xff1a;来自 Elastic Peter Straer 复合词在文本分析和标记过程中给搜索引擎带来挑战&#xff0c;因为它们会掩盖词语成分之间的有意义的联系。连字分解器标记过滤器等工具可以通过解构复合词来帮助解决这些问题。 德语以其长复合词而闻名&#xff1a;Rindfleischetik…
阅读更多...
deepseek无辅助损失的负载均衡策略

deepseek无辅助损失的负载均衡策略

无辅助损失的负载均衡策略 是一种用于解决深度学习中专家混合系统（MoE）负载不均衡问题的方法，它不依赖额外的辅助损失函数来实现负载均衡，而是通过直接调整专家接收输入的概率来平衡各个专家的负载，以下是具体介绍及举例： 策略原理 动态调整接收概率：系统会根据每个专…
阅读更多...
lightgbm做分类

lightgbm做分类

python import pandas as pd#导入csv文件的库 import numpy as np#进行矩阵运算的库 import json#用于读取和写入json数据格式#model lgb分类模型,日志评估,早停防止过拟合 from lightgbm import LGBMClassifier,log_evaluation,early_stopping #metric from sklearn.metrics …
阅读更多...
2006-2021年 省级数字经济与实体经济融合水平计算代码及原始数据-社科数据

2006-2021年 省级数字经济与实体经济融合水平计算代码及原始数据-社科数据

省级数字经济与实体经济融合水平计算代码及原始数据2006-2021年-社科数据https://download.csdn.net/download/paofuluolijiang/90028609 https://download.csdn.net/download/paofuluolijiang/90028609 数字经济与实体经济的融合是推动现代经济发展的关键力量。从2006年至20…
阅读更多...
Vue.js 生命周期钩子在 Composition API 中的应用

Vue.js 生命周期钩子在 Composition API 中的应用

Vue.js 生命周期钩子在 Composition API 中的应用 今天我们来聊聊在 Vue 3 的组合式 API&#xff08;Composition API&#xff09;中&#xff0c;如何使用生命周期钩子。如果你对如何在 setup() 函数中处理组件的生命周期事件感到困惑&#xff0c;那么这篇文章将为你解答。 什…
阅读更多...
vulfocus/thinkphp:6.0.12 命令执行

vulfocus/thinkphp:6.0.12 命令执行

本次测试是在vulfocus靶场上进行 漏洞介绍 在其6.0.13版本及以前，存在一处本地文件包含漏洞。当多语言特性被开启时，攻击者可以使用lang参数来包含任意PHP文件。 虽然只能包含本地PHP文件，但在开启了register_argc_argv且安装了pcel/pear的环境下，可以包含/usr/local/lib/…
阅读更多...
遗传算法【Genetic Algorithm（GA）】求解函数最大值(MATLAB and Python实现）

遗传算法【Genetic Algorithm（GA）】求解函数最大值(MATLAB and Python实现）

一、遗传算法基础知识 来自B站视频的笔记&#xff1a; 【超容易理解】手把手逐句带你解读并实现遗传算法的MATLAB编程&#xff08;结合理论基础&#xff09;_哔哩哔哩_bilibili 1、遗传算法 使用“适者生存”的原则&#xff0c;在遗传算法的每一代中&#xff0c;…
阅读更多...
MATLAB中extractAfter函数用法

MATLAB中extractAfter函数用法

目录 语法 说明 示例 选择子字符串后的文本 使用模式提取路径后的文件名 选择指定位置后的子字符串 选择字符向量中位置之后的文本 extractAfter函数的用法是提取指定位置后的子字符串。 语法 newStr extractAfter(str,pat) newStr extractAfter(str,pos) 说明 new…
阅读更多...
最新文章

Copyright @ 2022~2023