Java AOP 面向切面编程技术详解。涵盖 AOP 基本概念、与 OOP 关系、核心组件术语如切面连接点通知切入点等。介绍 AspectJ 与 Spring AOP 实现方式及原理，重点解析 Spring AOP 的代理机制（JDK/CGLIB）、配置方式、切面表达式语法及五种通知类型。提供日志、事务、安全、缓存等实际应用场景代码示例。总结最佳实践与注意事项，包括单一职责、性能优化、内部调用陷阱及异常处理，帮助开发者有效分离横切关注点，提升系统模块化与维护性。
AOP (Aspect-Oriented Programming) 面向切面编程，是一种编程范式，旨在通过横切关注点的分离，提高代码的模块化程度。它允许开发者将横切关注点（如日志记录、事务管理、性能监控、安全控制等）与业务逻辑分离，使系统更加松耦合、可维护性更高。
AOP 的核心理念是：将那些与业务无关，但为业务模块所共同调用的逻辑或责任，封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可扩展性和可维护性。
面向对象编程（OOP）通过封装、继承和多态三大特性，帮助我们构建模块化、可复用的代码。然而，在实际开发中，OOP 仍然面临一些挑战：
AOP 不是 OOP 的替代品，而是对 OOP 的补充和完善：
AOP 允许我们在不修改原有代码的情况下，通过声明式方式为代码添加新的功能，实现了功能的横向扩展。
AOP 的概念最早由 Xerox PARC 的研究人员在 1990 年代提出，作为 AspectJ 项目的一部分。随着时间的推移，AOP 逐渐成为企业应用开发中的重要技术：
AOP 的工作原理主要基于以下几个关键技术：
代理模式是 AOP 实现的基础，通过创建目标对象的代理，在不修改目标对象代码的情况下，拦截其方法调用并添加额外功能。
织入是将切面应用到目标对象并创建新的代理对象的过程。根据织入时机的不同，可以分为：
AOP 实现通常需要对字节码进行操作，主要技术包括：
使用 AOP 可以带来以下显著优势：
AOP 在以下场景中特别有用：
通过 AOP，这些横切关注点可以被优雅地处理，而不会污染核心业务代码。
在 AOP 的世界里，有一些核心概念和术语需要理解。这些概念共同构成了 AOP 的基本理论框架，是学习和应用 AOP 的基础。
切面是横切关注点的模块化表示，它封装了横切逻辑和其应用范围的定义。在 Spring AOP 中，切面通常是一个带有 @Aspect 注解的类。
切面可以看作是包含了一组相关通知和切入点定义的模块化单元。例如，一个日志切面可能包含记录方法调用的各种通知，以及定义哪些方法需要被记录日志的切入点。
连接点是程序执行过程中可以被拦截并插入额外代码的点。在 Java 中，连接点通常是方法调用、字段访问、异常抛出等。
在 Spring AOP 中，连接点特指方法执行，因为 Spring AOP 主要关注方法级别的拦截。每个连接点代表程序执行流程中的一个特定位置。
通知是在连接点执行的代码，它定义了在特定时机需要执行的横切行为。通知可以分为几种不同的类型：
切入点是一组连接点的定义，它决定了通知将应用到哪些方法上。切入点通常使用表达式来指定目标方法的集合。
切入点表达式可以基于方法签名、注解、包路径等多种条件进行匹配。在 Spring AOP 中，常用的切入点表达式是 AspectJ 表达式。
目标对象是被一个或多个切面通知的对象，也称为被通知对象。在 Spring AOP 中，目标对象总是被代理的对象。
当客户端调用目标对象的方法时，实际上是调用代理对象的方法，代理对象再根据切面定义执行相应的通知，然后调用目标对象的实际方法。
代理是 AOP 框架创建的对象，它包装目标对象并拦截方法调用，根据切面定义执行相应的通知。
Spring AOP 有两种代理实现方式：
织入是将切面应用到目标对象并创建代理对象的过程。织入可以在不同的时机进行：
引介是一种特殊的通知，它允许向目标类添加新的方法或字段。通过引介，可以动态地修改类的行为，而不需要修改类的源代码。
在 Spring AOP 中，引介可以用于向目标对象添加新的接口实现。
横切关注点是指那些跨越多个模块、影响系统多个部分的功能，如日志、事务、安全等。这些关注点通常难以用传统的面向对象方法进行模块化。
AOP 的核心目标就是将这些横切关注点从业务逻辑中分离出来，实现更好的模块化。
织入器是负责将切面织入到目标对象中并创建代理对象的组件。在不同的 AOP 实现中，织入器的实现方式和工作时机可能不同。
这些 AOP 术语之间有着密切的关系：
理解这些核心概念和它们之间的关系，对于掌握 AOP 的工作原理和正确应用 AOP 至关重要。
可以用一个简单的比喻来理解这些术语：
AOP 可以通过多种方式实现，不同的实现方式有各自的特点和适用场景。下面介绍几种主要的 AOP 实现方式及其对比。
AspectJ是最成熟、功能最强大的 AOP 实现，它是一个独立的 AOP 框架，可以与任何 Java 项目集成。AspectJ 提供了完整的 AOP 功能，包括丰富的连接点类型、强大的切入点表达式和多种织入方式。
AspectJ 主要通过以下方式实现：
Spring AOP是 Spring 框架的一部分，它提供了基于代理的 AOP 实现，集成在 Spring 的依赖注入机制中。
Spring AOP 主要基于动态代理实现：
JBoss AOP是 JBoss 应用服务器提供的 AOP 框架，它提供了类似 AspectJ 的功能，但更紧密地集成在 JBoss 应用服务器中。
JBoss AOP 支持多种织入方式：
Google Guice是一个轻量级的依赖注入框架，它也提供了基本的 AOP 功能。
Guice AOP 基于 JDK 动态代理实现，只支持接口代理。
除了使用现成的 AOP 框架，还可以基于代理模式等设计模式实现自定义的 AOP 功能。
通过手动创建代理类，可以实现简单的 AOP 功能：
下表对几种主要的 AOP 实现方式进行了对比：
| 实现方式 | 织入时机 | 支持的连接点 | 性能 | 易用性 | 集成性 | 适用场景 |
|---|---|---|---|---|---|---|
| AspectJ | 编译时/加载时/运行时 | 全面（方法、字段、构造函数等） | 最好（编译时织入） | 中等（需要额外学习） | 可与任何框架集成 | 复杂 AOP 需求，对性能要求高 |
| Spring AOP | 运行时 | 仅方法 | 中等 | 高（与 Spring 无缝集成） | 与 Spring 框架紧密集成 | Spring 应用中的常见横切关注点 |
| JBoss AOP | 编译时/加载时/运行时 | 全面 | 较好 | 中等 | 与 JBoss 服务器集成 | JBoss 应用服务器中的应用 |
| Guice AOP | 运行时 | 仅方法（仅接口） | 中等 | 高 | 与 Guice DI 集成 | 使用 Guice 的轻量级应用 |
| 自定义 AOP | 视实现而定 | 通常仅方法 | 视实现而定 | 低 | 无依赖 | 学习或特定需求 |
选择 AOP 实现方式时，应考虑以下因素：
在实际项目中，Spring AOP 和 AspectJ 的结合使用是一种常见的模式：使用 Spring AOP 处理简单的方法拦截，对于更复杂的 AOP 需求，则使用 AspectJ 的能力。Spring 框架也提供了对 AspectJ 的集成支持，使得这种组合使用更加方便。
Spring AOP 是 Spring 框架的核心功能之一，它提供了声明式的企业级服务，如事务管理、安全控制等。下面详细介绍 Spring AOP 的核心概念、实现机制和使用方法。
Spring AOP 建立在动态代理机制之上，它使用代理拦截对目标对象的方法调用，并在代理中执行切面逻辑。Spring AOP 主要关注方法级别的拦截，提供了一种轻量级的 AOP 实现。
Spring AOP 会根据目标对象的类型自动选择适当的代理实现：
从 Spring 3.2 开始，Spring 可以通过配置强制使用 CGLIB 代理，即使目标对象实现了接口。
在 Spring 容器启动时，当一个 bean 被定义为切面或需要被切面增强时，Spring 会为其创建代理对象。代理对象在容器中被管理，客户端获取的是代理对象而不是原始目标对象。
Spring AOP 的核心组件对应于 AOP 的基本概念：
在 Spring 中，切面通常是一个带有 @Aspect 注解的类，它包含通知和切入点的定义。
@Aspect
@Component
public class LoggingAspect {
// 通知和切入点定义
}
Spring AOP 支持五种类型的通知，通过不同的注解来标识：
@Before：前置通知@After：后置通知@AfterReturning：返回通知@AfterThrowing：异常通知@Around：环绕通知Spring AOP 使用 AspectJ 的切入点表达式语言来定义切入点，通过 @Pointcut 注解来声明：
@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethods() {}
被代理的原始对象，它包含实际的业务逻辑。
Spring 创建的代理对象，它包装了目标对象并添加了切面逻辑。
Spring AOP 支持两种主要的配置方式：基于注解的配置和基于 XML 的配置。
基于注解的配置是 Spring AOP 推荐的配置方式，更加简洁和灵活。
步骤 1：启用 @AspectJ 支持
在配置类上添加 @EnableAspectJAutoProxy 注解：
@Configuration
@EnableAspectJAutoProxy
@ComponentScan("com.example")
public class AppConfig {}
或者在 XML 配置中启用：
<aop:aspectj-autoproxy/>
步骤 2：定义切面类
创建带有 @Aspect 和 @Component 注解的切面类：
@Aspect
@Component
public class LoggingAspect {
// 切面内容
}
步骤 3：定义切入点
使用 @Pointcut 注解定义切入点表达式：
@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethods() {}
步骤 4：定义通知
使用相应的通知注解和切入点来定义通知方法：
@Before("serviceMethods()")
public void logBefore(JoinPoint joinPoint) {
System.out.println("Method: " + joinPoint.getSignature().getName());
}
对于偏好 XML 配置的项目，Spring AOP 也提供了完整的 XML 配置支持。
<!-- 启用 AOP 命名空间支持 -->
<aop:config>
<!-- 定义切面 -->
<aop:aspect id="loggingAspect" ref="loggingAspectBean">
<!-- 定义切入点 -->
<aop:pointcut id="serviceMethods" expression="execution(* com.example.service.*.*(..))"/>
<!-- 定义通知 -->
<aop:before pointcut-ref="serviceMethods" method="logBefore"/>
<aop:after pointcut-ref="serviceMethods" method="logAfter"/>
</aop:aspect>
</aop:config>
<!-- 声明切面 bean -->
<bean id="loggingAspectBean" class="com.example.aspect.LoggingAspect"/>
虽然 Spring AOP 本身是一个轻量级实现，但它提供了与功能更强大的 AspectJ 的无缝集成。Spring 对 AspectJ 的集成主要体现在以下几个方面：
Spring AOP 使用 AspectJ 的切入点表达式语法，这使得 Spring AOP 和 AspectJ 之间的迁移更加容易。
Spring AOP 支持使用 AspectJ 的注解（如 @Aspect、@Before、@After 等）来定义切面，简化了配置。
对于需要更强大 AOP 功能的场景，Spring 提供了对 AspectJ LTW 的集成支持，可以在 JVM 类加载时织入切面。
配置 LTW 的步骤：
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.9.9.1</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.9.1</version>
</dependency>
@Configuration
@EnableLoadTimeWeaving
public class AppConfig {}
或者在 XML 中配置：
<context:load-time-weaver/>
在 JVM 启动参数中添加：
-javaagent:/path/to/aspectjweaver.jar
Spring AOP 的核心实现基于两个关键组件：
ProxyFactoryBean 是 Spring 创建 AOP 代理的核心类，它实现了 Spring 的 FactoryBean 接口，可以生成代理对象。ProxyFactoryBean 负责：
AspectJExpressionPointcut 是 Spring 对 AspectJ 切入点表达式的实现，它负责解析和评估切入点表达式，判断一个方法调用是否匹配给定的切入点。
JDK 动态代理是基于 java.lang.reflect.Proxy 类和 InvocationHandler 接口实现的。当使用 JDK 动态代理时：
InvocationHandler 的 invoke 方法invoke 方法中，Spring 执行相应的通知，然后调用目标对象的原始方法JDK 动态代理的优缺点：
CGLIB（Code Generation Library）是一个强大的代码生成库，它通过继承目标类来创建代理对象。当使用 CGLIB 代理时：
CGLIB 代理的优缺点：
Spring 在创建代理时的选择策略如下：
强制使用 CGLIB 代理的配置：
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AppConfig {}
或者在 XML 中：
<aop:aspectj-autoproxy proxy-target-class="true"/>
虽然 Spring AOP 是一个强大的工具，但它也有一些局限性：
对于需要突破这些限制的场景，可以考虑使用 AspectJ 的完整功能。
在使用 Spring AOP 时，遵循以下最佳实践可以提高代码质量和性能：
@Order 注解控制切面的执行顺序切点表达式是 AOP 中定义连接点的核心机制，它决定了哪些方法调用会被拦截和处理。在 Spring AOP 中，切点表达式使用 AspectJ 的表达式语言。
AspectJ 的切点表达式主要由以下几个部分组成：
execution(modifiers-pattern? return-type-pattern declaring-type-pattern? method-name-pattern(param-pattern) throws-pattern?)
其中，各个部分的含义如下：
* 表示任意返回类型* 表示任意方法名() 表示无参，(..) 表示任意参数，(String) 表示单个 String 参数AspectJ 支持以下通配符：
*：匹配任意数量的字符（但不包括包分隔符）..：匹配任意数量的字符，包括包分隔符，用于匹配子包或任意参数列表+：匹配指定类型及其子类或实现类以下是一些常用的切点表达式示例：
// 匹配 com.example.service 包下的所有 public 方法
@Pointcut("execution(public * com.example.service.*.*(..))")
// 匹配 com.example 包及其子包下的所有方法
@Pointcut("execution(* com.example..*.*(..))")
// 匹配所有以 Service 结尾的类中的所有方法
@Pointcut("execution(* *..*Service.*(..))")
// 匹配返回类型为 void 且参数为单个 String 的方法
@Pointcut("execution(void *.*(String))")
// 匹配抛出异常的方法
@Pointcut("execution(* *.*(..) throws Exception)")
除了使用 execution 表达式外，Spring AOP 还支持基于注解的切点表达式，这在实际开发中非常有用。
@annotation 表达式用于匹配被特定注解标注的方法：
// 匹配所有被 @Log 注解标注的方法
@Pointcut("@annotation(com.example.annotation.Log)")
@within 表达式用于匹配特定注解标注的类中的所有方法：
// 匹配所有被 @Service 注解标注的类中的方法
@Pointcut("@within(org.springframework.stereotype.Service)")
@args 表达式用于匹配参数被特定注解标注的方法：
// 匹配第一个参数被 @Valid 注解标注的方法
@Pointcut("@args(com.example.annotation.Valid)")
在实际应用中，我们经常需要组合多个切点表达式来满足复杂的需求。Spring AOP 支持使用逻辑运算符来组合切点表达式：
&&（或 and）：逻辑与，匹配同时满足两个表达式的连接点||（或 or）：逻辑或，匹配满足任一表达式的连接点!（或 not）：逻辑非，匹配不满足表达式的连接点// 匹配 Service 包下且被 @Log 注解标注的方法
@Pointcut("execution(* com.example.service.*.*(..)) && @annotation(com.example.annotation.Log)")
// 匹配 Service 或 Controller 包下的方法
@Pointcut("execution(* com.example.service.*.*(..)) || execution(* com.example.controller.*.*(..))")
// 匹配非 private 方法
@Pointcut("!execution(private * *.*(..))")
通知（Advice）是 AOP 中的核心概念，它定义了在连接点执行的代码。Spring AOP 支持以下几种通知类型：
前置通知在目标方法执行之前执行。它可以获取连接点的信息，但不能阻止目标方法的执行（除非抛出异常）。
@Component
@Aspect
public class LoggingAspect {
@Before("execution(* com.example.service.*.*(..))")
public void logBefore(JoinPoint joinPoint) {
String method = joinPoint.getSignature().getName();
Object[] args = joinPoint.getArgs();
System.out.println("Before method: " + method + ", arguments: " + Arrays.toString(args));
}
}
后置通知在目标方法成功执行后执行，它可以访问目标方法的返回值。
@Component
@Aspect
public class LoggingAspect {
@AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {
String method = joinPoint.getSignature().getName();
System.out.println("After returning method: " + method + ", result: " + result);
}
}
异常通知在目标方法抛出异常后执行，它可以访问抛出的异常。
@Component
@Aspect
public class LoggingAspect {
@AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "exception")
public void logAfterThrowing(JoinPoint joinPoint, Exception exception) {
String method = joinPoint.getSignature().getName();
System.out.println("After throwing method: " + method + ", exception: " + exception.getMessage());
}
}
最终通知在目标方法执行完成后执行，无论方法是正常返回还是抛出异常。它类似于 try-catch-finally 中的 finally 块。
@Component
@Aspect
public class LoggingAspect {
@After("execution(* com.example.service.*.*(..))")
public void logAfter(JoinPoint joinPoint) {
String method = joinPoint.getSignature().getName();
System.out.println("After method: " + method);
}
}
环绕通知是功能最强大的通知类型，它可以在目标方法执行前后执行自定义逻辑，甚至可以决定是否执行目标方法、修改方法的参数或返回值。
@Component
@Aspect
public class LoggingAspect {
@Around("execution(* com.example.service.*.*(..))")
public Object logAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
String method = proceedingJoinPoint.getSignature().getName();
Object[] args = proceedingJoinPoint.getArgs();
System.out.println("Around before: " + method + ", arguments: " + Arrays.toString(args));
try {
// 执行目标方法
Object result = proceedingJoinPoint.proceed();
System.out.println("Around after returning: " + method + ", result: " + result);
return result;
} catch (Throwable throwable) {
System.out.println("Around after throwing: " + method + ", exception: " + throwable.getMessage());
throw throwable;
} finally {
System.out.println("Around finally: " + method);
}
}
}
当同一个连接点匹配多个通知时，通知的执行顺序如下：
如果目标方法抛出异常，则执行顺序变为：
在通知方法中，我们可以绑定各种上下文信息，如连接点信息、方法参数、返回值等。
所有通知方法都可以绑定 JoinPoint 参数，用于获取连接点的信息：
@Before("execution(* com.example.service.*.*(..))")
public void logBefore(JoinPoint joinPoint) {
// 获取方法签名
Signature signature = joinPoint.getSignature();
// 获取方法名
String methodName = signature.getName();
// 获取目标对象
Object target = joinPoint.getTarget();
// 获取代理对象
Object thisObj = joinPoint.getThis();
// 获取方法参数
Object[] args = joinPoint.getArgs();
}
我们可以使用 args() 表达式来绑定方法参数：
@Before("execution(* com.example.service.*.*(String, ..)) && args(name, ..)")
public void logWithName(JoinPoint joinPoint, String name) {
System.out.println("Method called with name: " + name);
}
后置通知可以绑定目标方法的返回值：
@AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result")
public void logReturning(JoinPoint joinPoint, Object result) {
System.out.println("Method returned: " + result);
}
异常通知可以绑定目标方法抛出的异常：
@AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "exception")
public void logException(JoinPoint joinPoint, Exception exception) {
System.out.println("Method threw: " + exception.getMessage());
}
切点表达式的定义会直接影响 AOP 的性能，因此在编写切点表达式时，应考虑以下性能优化原则：
execution(* *.*(..))@Pointcut 定义并引用// 定义可重用的切点表达式
@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethods() {}
// 引用切点表达式
@Before("serviceMethods()")
public void logServiceMethod(JoinPoint joinPoint) {
// 实现逻辑
}
在实际开发中，编写正确的切点表达式可能会遇到挑战。以下是一些调试切点表达式的技巧：
org.springframework.aop 的日志级别为 DEBUG 或 TRACE，可以看到 AOP 的详细执行信息@Pointcut 定义并测试：将复杂的表达式分解为多个简单表达式，分别测试通过这些技巧，我们可以更有效地编写和调试切点表达式，确保它们正确地匹配所需的连接点。
AOP 在企业应用开发中有着广泛的应用，下面介绍一些常见的实际应用场景。
日志记录是 AOP 最常见的应用场景之一。通过 AOP，我们可以在不修改业务代码的情况下，统一记录方法的调用信息、参数、执行时间等。
记录用户的关键操作，如登录、修改数据、删除操作等，便于系统审计和问题追踪。
记录方法的执行时间，帮助识别系统性能瓶颈。
捕获并记录系统异常，便于问题排查和分析。
在企业应用中，事务管理是一个核心需求。通过 AOP，我们可以实现声明式事务管理，简化事务控制代码。
使用 AOP 在方法执行前后自动开启和提交事务，当方法抛出异常时自动回滚事务。
通过 AOP 控制事务的传播行为，如 REQUIRED、REQUIRES_NEW、SUPPORTS 等。
AOP 可以用于实现系统的安全控制，如权限验证、访问控制等。
在方法执行前验证用户是否有权限执行该操作。
控制对敏感资源的访问，如敏感数据的查看、修改等。
限制接口的调用频率，防止恶意攻击或资源滥用。
通过 AOP 实现方法级别的缓存，提高系统性能。
缓存方法的查询结果，避免重复计算或数据库查询。
在数据更新时自动使相关缓存失效，确保数据一致性。
通过 AOP 统一处理系统异常，提供友好的错误信息。
捕获业务方法抛出的异常，进行统一处理和转换。
对异常信息进行国际化处理，支持多语言环境。
在微服务架构中，AOP 可以用于实现分布式追踪，监控请求的流转过程。
记录请求的调用链路，包括服务间的调用关系和执行时间。
协调分布式事务的执行，确保数据一致性。
通过 AOP 实现方法参数的数据校验，确保数据的合法性。
验证方法输入参数的格式、长度、范围等。
根据业务规则对数据进行校验，确保业务逻辑的正确性。
通过 AOP 实现方法的异步执行，提高系统的并发处理能力。
将耗时的操作通过 AOP 异步化，不阻塞主流程。
通过 AOP 实现事件的自动发布，解耦事件的生产者和消费者。
本节提供一些常见 AOP 应用场景的完整代码示例，帮助读者更好地理解和应用 AOP。
package com.example.annotation;
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 Log {
String value() default "";
}
package com.example.aspect;
import com.example.annotation.Log;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
import java.util.Arrays;
@Aspect
@Component
public class LogAspect {
private static final Logger logger = LoggerFactory.getLogger(LogAspect.class);
// 定义切点：匹配被 @Log 注解标注的方法
@Pointcut("@annotation(com.example.annotation.Log)")
public void logPointCut() {}
// 前置通知
@Before("logPointCut()")
public void logBefore(JoinPoint joinPoint) {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
Log logAnnotation = method.getAnnotation(Log.class);
logger.info("[Log] 操作描述：{}", logAnnotation.value());
logger.info("[Log] 方法名：{}.{}", joinPoint.getTarget().getClass().getName(), method.getName());
logger.info("[Log] 参数：{}", Arrays.toString(joinPoint.getArgs()));
}
// 环绕通知
@Around("logPointCut()")
public Object logAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
long startTime = System.currentTimeMillis();
try {
// 执行目标方法
Object result = proceedingJoinPoint.proceed();
long endTime = System.currentTimeMillis();
logger.info("[Log] 执行时间：{}ms", (endTime - startTime));
logger.info("[Log] 返回结果：{}", result);
return result;
} catch (Throwable throwable) {
logger.error("[Log] 执行异常：{}", throwable.getMessage(), throwable);
throw throwable;
}
}
// 后置通知
@AfterReturning(pointcut = "logPointCut()", returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {
logger.info("[Log] 方法执行成功");
}
// 异常通知
@AfterThrowing(pointcut = "logPointCut()", throwing = "exception")
public void logAfterThrowing(JoinPoint joinPoint, Exception exception) {
logger.error("[Log] 方法执行异常：{}", exception.getMessage());
}
}
package com.example.service;
import com.example.annotation.Log;
import org.springframework.stereotype.Service;
@Service
public class UserService {
@Log("查询用户信息")
public User getUserById(Long userId) {
// 业务逻辑
return new User(userId, "张三", 25);
}
@Log("创建用户")
public User createUser(User user) {
// 业务逻辑
return user;
}
}
package com.example.annotation;
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 Transactional {
String propagation() default "REQUIRED";
String isolation() default "DEFAULT";
int timeout() default -1;
boolean readOnly() default false;
Class<? extends Throwable>[] rollbackFor() default {};
Class<? extends Throwable>[] noRollbackFor() default {};
}
package com.example.aspect;
import com.example.annotation.Transactional;
import com.example.transaction.TransactionManager;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
import java.util.Arrays;
@Aspect
@Component
public class TransactionAspect {
@Autowired
private TransactionManager transactionManager;
// 定义切点：匹配被 @Transactional 注解标注的方法
@Pointcut("@annotation(com.example.annotation.Transactional)")
public void transactionPointCut() {}
// 环绕通知
@Around("transactionPointCut()")
public Object transactionAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();
Method method = signature.getMethod();
Transactional transactional = method.getAnnotation(Transactional.class);
// 开始事务
transactionManager.beginTransaction();
try {
// 执行目标方法
Object result = proceedingJoinPoint.proceed();
// 提交事务
transactionManager.commit();
return result;
} catch (Throwable throwable) {
// 判断是否需要回滚
if (shouldRollback(throwable, transactional)) {
transactionManager.rollback();
} else {
transactionManager.commit();
}
throw throwable;
}
}
// 判断是否需要回滚
private boolean shouldRollback(Throwable throwable, Transactional transactional) {
// 检查 noRollbackFor
for (Class<? extends Throwable> noRollbackClass : transactional.noRollbackFor()) {
if (noRollbackClass.isAssignableFrom(throwable.getClass())) {
return false;
}
}
// 检查 rollbackFor
Class<? extends Throwable>[] rollbackClasses = transactional.rollbackFor();
if (rollbackClasses.length > 0) {
for (Class<? extends Throwable> rollbackClass : rollbackClasses) {
if (rollbackClass.isAssignableFrom(throwable.getClass())) {
return true;
}
}
return false;
}
// 默认情况下，所有 RuntimeException 都回滚
return throwable instanceof RuntimeException;
}
}
package com.example.service;
import com.example.annotation.Transactional;
import org.springframework.stereotype.Service;
@Service
public class OrderService {
@Autowired
private OrderRepository orderRepository;
@Autowired
private InventoryService inventoryService;
@Transactional(rollbackFor = Exception.class)
public Order createOrder(Order order) {
// 创建订单
Order savedOrder = orderRepository.save(order);
// 扣减库存
inventoryService.reduceStock(order.getProductId(), order.getQuantity());
return savedOrder;
}
}
package com.example.annotation;
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 RequirePermission {
String value();
}
package com.example.aspect;
import com.example.annotation.RequirePermission;
import com.example.exception.PermissionDeniedException;
import com.example.security.SecurityContext;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
@Aspect
@Component
public class PermissionAspect {
@Autowired
private SecurityContext securityContext;
// 定义切点：匹配被 @RequirePermission 注解标注的方法
@Pointcut("@annotation(com.example.annotation.RequirePermission)")
public void permissionPointCut() {}
// 前置通知
@Before("permissionPointCut()")
public void checkPermission(JoinPoint joinPoint) {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
RequirePermission requirePermission = method.getAnnotation(RequirePermission.class);
String requiredPermission = requirePermission.value();
// 检查用户是否拥有权限
if (!securityContext.hasPermission(requiredPermission)) {
throw new PermissionDeniedException("您没有权限执行此操作：" + requiredPermission);
}
}
}
package com.example.controller;
import com.example.annotation.RequirePermission;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/admin")
public class AdminController {
@RequirePermission("user:list")
@GetMapping("/users")
public List<User> listUsers() {
// 业务逻辑
}
@RequirePermission("user:create")
@PostMapping("/users")
public User createUser(@RequestBody User user) {
// 业务逻辑
}
@RequirePermission("user:delete")
@DeleteMapping("/users/{id}")
public void deleteUser(@PathVariable Long id) {
// 业务逻辑
}
}
package com.example.annotation;
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 Cacheable {
String key();
int expire() default 3600; // 默认过期时间：1 小时
}
package com.example.aspect;
import com.example.annotation.Cacheable;
import com.example.cache.CacheManager;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
import java.util.Arrays;
@Aspect
@Component
public class CacheAspect {
@Autowired
private CacheManager cacheManager;
// 定义切点：匹配被 @Cacheable 注解标注的方法
@Pointcut("@annotation(com.example.annotation.Cacheable)")
public void cachePointCut() {}
// 环绕通知
@Around("cachePointCut()")
public Object cacheAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();
Method method = signature.getMethod();
Cacheable cacheable = method.getAnnotation(Cacheable.class);
// 生成缓存键
String key = generateCacheKey(cacheable.key(), proceedingJoinPoint);
// 尝试从缓存获取
Object cachedValue = cacheManager.get(key);
if (cachedValue != null) {
return cachedValue;
}
// 执行目标方法
Object result = proceedingJoinPoint.proceed();
// 存入缓存
cacheManager.put(key, result, cacheable.expire());
return result;
}
// 生成缓存键
private String generateCacheKey(String keyPattern, ProceedingJoinPoint joinPoint) {
// 简单实现，实际项目中可以使用 SpEL 表达式解析
String className = joinPoint.getTarget().getClass().getName();
String methodName = joinPoint.getSignature().getName();
String args = Arrays.toString(joinPoint.getArgs());
return keyPattern + ":" + className + ":" + methodName + ":" + args;
}
}
package com.example.service;
import com.example.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class ProductService {
@Autowired
private ProductRepository productRepository;
@Cacheable(key = "product", expire = 7200)
public Product getProductById(Long productId) {
return productRepository.findById(productId).orElse(null);
}
@Cacheable(key = "product:list")
public List<Product> listProducts() {
return productRepository.findAll();
}
}
下面是一个完整的 Spring Boot 应用示例，展示如何在实际项目中使用 AOP。
<dependencies>
<!-- Spring Boot Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!-- Spring Boot Starter AOP -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!-- Spring Boot Starter Web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring Boot Starter Data JPA -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- H2 Database -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!-- Spring Boot Starter Test -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
package com.example;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AopDemoApplication {
public static void main(String[] args) {
SpringApplication.run(AopDemoApplication.class, args);
}
}
package com.example.entity;
import lombok.Data;
import javax.persistence.*;
@Data
@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String email;
private String password;
private String role;
}
package com.example.repository;
import com.example.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
User findByUsername(String username);
}
package com.example.service;
import com.example.annotation.Log;
import com.example.entity.User;
import com.example.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
@Log("获取用户列表")
public List<User> listUsers() {
return userRepository.findAll();
}
@Log("根据 ID 获取用户")
public User getUserById(Long id) {
return userRepository.findById(id).orElse(null);
}
@Log("创建用户")
@Transactional
public User createUser(User user) {
return userRepository.save(user);
}
@Log("更新用户")
@Transactional
public User updateUser(User user) {
return userRepository.save(user);
}
@Log("删除用户")
@Transactional
public void deleteUser(Long id) {
userRepository.deleteById(id);
}
}
package com.example.controller;
import com.example.annotation.RequirePermission;
import com.example.entity.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/api/users")
public class UserController {
@Autowired
private UserService userService;
@GetMapping
@RequirePermission("user:list")
public List<User> listUsers() {
return userService.listUsers();
}
@GetMapping("/{id}")
@RequirePermission("user:view")
public User getUserById(@PathVariable Long id) {
return userService.getUserById(id);
}
@PostMapping
@RequirePermission("user:create")
public User createUser(@RequestBody User user) {
return userService.createUser(user);
}
@PutMapping("/{id}")
@RequirePermission("user:update")
public User updateUser(@PathVariable Long id, @RequestBody User user) {
user.setId(id);
return userService.updateUser(user);
}
@DeleteMapping("/{id}")
@RequirePermission("user:delete")
public void deleteUser(@PathVariable Long id) {
userService.deleteUser(id);
}
}
package com.example.annotation;
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 Log {
String value() default "";
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequirePermission {
String value();
}
package com.example.aspect;
import com.example.annotation.Log;
import com.example.annotation.RequirePermission;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
import java.util.Arrays;
@Aspect
@Component
public class LoggingAspect {
private static final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);
@Pointcut("@annotation(com.example.annotation.Log)")
public void logPointCut() {}
@Around("logPointCut()")
public Object logAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
long startTime = System.currentTimeMillis();
MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();
Method method = signature.getMethod();
Log logAnnotation = method.getAnnotation(Log.class);
logger.info("[Log] 操作：{}", logAnnotation.value());
logger.info("[Log] 方法：{}.{}", proceedingJoinPoint.getTarget().getClass().getName(), method.getName());
logger.info("[Log] 参数：{}", Arrays.toString(proceedingJoinPoint.getArgs()));
try {
Object result = proceedingJoinPoint.proceed();
long endTime = System.currentTimeMillis();
logger.info("[Log] 耗时：{}ms", (endTime - startTime));
logger.info("[Log] 结果：{}", result);
return result;
} catch (Throwable throwable) {
logger.error("[Log] 异常：{}", throwable.getMessage(), throwable);
throw throwable;
}
}
}
@Aspect
@Component
public class PermissionAspect {
private static final Logger logger = LoggerFactory.getLogger(PermissionAspect.class);
@Pointcut("@annotation(com.example.annotation.RequirePermission)")
public void permissionPointCut() {}
@Before("permissionPointCut()")
public void checkPermission(JoinPoint joinPoint) {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
RequirePermission requirePermission = method.getAnnotation(RequirePermission.class);
String requiredPermission = requirePermission.value();
logger.info("[Permission] 检查权限：{}", requiredPermission);
// 这里简化处理，实际项目中应该从 SecurityContext 获取用户权限
// 为了演示，我们假设当前用户拥有所有权限
boolean hasPermission = true;
if (!hasPermission) {
throw new RuntimeException("权限不足，需要权限：" + requiredPermission);
}
}
}
@Aspect
@Component
public class PerformanceAspect {
private static final Logger logger = LoggerFactory.getLogger(PerformanceAspect.class);
@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethodPointCut() {}
@Around("serviceMethodPointCut()")
public Object performanceAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
long startTime = System.currentTimeMillis();
try {
Object result = proceedingJoinPoint.proceed();
long endTime = System.currentTimeMillis();
// 如果方法执行时间超过 100ms，记录警告日志
if (endTime - startTime > 100) {
logger.warn("[Performance] 方法执行较慢：{}.{}，耗时：{}ms", proceedingJoinPoint.getTarget().getClass().getName(), proceedingJoinPoint.getSignature().getName(), (endTime - startTime));
}
return result;
} catch (Throwable throwable) {
logger.error("[Performance] 方法执行异常：{}", throwable.getMessage());
throw throwable;
}
}
}
# application.yml
spring:
datasource:
url: jdbc:h2:mem:testdb
driverClassName: org.h2.Driver
username: sa
password:
jpa:
database-platform: org.hibernate.dialect.H2Dialect
hibernate:
ddl-auto: update
show-sql: true
h2:
console:
enabled: true
path: /h2-console
logging:
level:
root: INFO
com.example: DEBUG
org.springframework.aop: TRACE
通过这个完整的示例，我们可以看到如何在实际项目中使用 AOP 来实现日志记录、权限控制和性能监控等功能。这些切面可以帮助我们保持业务代码的简洁性，同时提供横切关注点的统一处理。
在使用 AOP 的过程中，遵循最佳实践可以帮助我们避免常见的陷阱，提高系统的可维护性和性能。本节将介绍 AOP 的最佳实践和需要注意的事项。
每个切面应该只关注一个横切关注点，避免在一个切面中实现多个不相关的功能。这样可以提高切面的内聚性和可维护性。
示例：
// 好的做法：每个切面只关注一个关注点
@Aspect
@Component
public class LoggingAspect {
// 只负责日志记录
// 日志记录相关代码
}
@Aspect
@Component
public class TransactionAspect {
// 只负责事务管理
// 事务管理相关代码
}
// 不好的做法：一个切面包含多个关注点
@Aspect
@Component
public class MultiPurposeAspect {
// 同时处理日志、事务、权限等多个关注点
// 混合的代码，难以维护
}
使用自定义注解来定义切点，可以提高代码的可读性和灵活性。通过注解，我们可以精确地控制哪些方法需要应用切面。
示例：
// 定义自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Loggable {
String value() default "";
}
// 在切面中使用注解定义切点
@Aspect
@Component
public class LoggingAspect {
@Pointcut("@annotation(com.example.annotation.Loggable)")
public void loggableMethods() {}
// 通知实现
}
// 在业务方法上使用注解
@Service
public class UserService {
@Loggable("获取用户信息")
public User getUserById(Long id) {
// 业务逻辑
}
}
根据需求选择合适的通知类型，避免滥用环绕通知。对于简单的前后处理，可以使用 @Before 和 @AfterReturning 等更简单的通知类型。
示例：
// 对于简单的前置检查，使用 @Before 更清晰
@Before("logPointCut()")
public void validateParameters(JoinPoint joinPoint) {
// 参数验证逻辑
}
// 对于需要控制方法执行的场景，使用 @Around
@Around("cachePointCut()")
public Object cacheAround(ProceedingJoinPoint pjp) throws Throwable {
// 缓存逻辑，可能会跳过方法执行
}
切面应该只负责横切关注点的处理，不应该包含业务逻辑。业务逻辑应该保留在目标对象中。
示例：
// 不好的做法：在切面中包含业务逻辑
@Around("orderPointCut()")
public Object processOrder(ProceedingJoinPoint pjp) throws Throwable {
// 这里包含了订单处理的业务逻辑
Order order = (Order) pjp.getArgs()[0];
if (order.getAmount() > 1000) {
order.setDiscount(0.9); // 业务逻辑
}
return pjp.proceed();
}
// 好的做法：业务逻辑应该在目标方法中
@Service
public class OrderService {
public Order createOrder(Order order) {
// 业务逻辑在目标方法中
if (order.getAmount() > 1000) {
order.setDiscount(0.9);
}
// 保存订单
return orderRepository.save(order);
}
}
对于多个切面中可能共享的逻辑，应该进行适当的抽象，避免代码重复。
示例：
// 抽象通用的日志记录逻辑
public class LogUtils {
public static void logMethodEntry(Logger logger, String methodName, Object[] args) {
logger.info("Entering method: {}, args: {}", methodName, Arrays.toString(args));
}
public static void logMethodExit(Logger logger, String methodName, Object result) {
logger.info("Exiting method: {}, result: {}", methodName, result);
}
}
// 在多个切面中使用
@Aspect
@Component
public class ServiceLoggingAspect {
private static final Logger logger = LoggerFactory.getLogger(ServiceLoggingAspect.class);
@Before("serviceMethods()")
public void logBefore(JoinPoint joinPoint) {
LogUtils.logMethodEntry(logger, joinPoint.getSignature().getName(), joinPoint.getArgs());
}
}
在 Spring AOP 中，可以使用 Spring 表达式语言 (SpEL) 来增强切点的灵活性，特别是在处理注解属性时。
示例：
@Around("@annotation(loggable) && args(.., @org.springframework.web.bind.annotation.RequestBody requestBody)")
public Object logWithRequestBody(ProceedingJoinPoint pjp, Loggable loggable, Object requestBody) throws Throwable {
logger.info("Operation: {}, Request Body: {}", loggable.value(), requestBody);
return pjp.proceed();
}
当多个切面应用于同一个连接点时，需要合理设置切面的执行顺序，以确保功能的正确性。
示例：
// 使用 @Order 注解设置切面优先级
@Aspect
@Component
@Order(1) // 数值越小，优先级越高
public class TransactionAspect {
// 事务切面通常应该在最外层
}
@Aspect
@Component
@Order(2)
public class LoggingAspect {
// 日志切面
}
@Aspect
@Component
@Order(3)
public class PerformanceAspect {
// 性能监控切面
}
为切面编写单元测试，确保切面的行为符合预期，特别是在异常处理等边缘情况下。
示例：
@SpringBootTest
public class LoggingAspectTest {
@Autowired
private UserService userService;
@MockBean
private UserRepository userRepository;
@Test
public void testLoggingAspect() {
// 配置 mock 行为
when(userRepository.findById(1L)).thenReturn(Optional.of(new User(1L, "test", "[email protected]")));
// 执行被切面增强的方法
User user = userService.getUserById(1L);
// 验证结果和日志（可以使用日志捕获或其他方式验证）
assertNotNull(user);
}
}
AOP 是一个强大的工具，但不应该过度使用。只有当功能确实是横切关注点且在多个地方重复出现时，才考虑使用 AOP。
判断标准：
AOP 会引入额外的代理对象和方法调用，可能会对性能产生一定影响。在性能敏感的场景中，需要谨慎使用。
性能优化建议：
Spring AOP 基于动态代理，有一定的局限性，如只能拦截方法级别的连接点、不能拦截构造方法等。在需要更强大功能时，考虑使用 AspectJ。
Spring AOP 的主要局限性：
在切点表达式中，this() 和 target() 有重要区别。this() 匹配代理对象类型，而 target() 匹配目标对象类型。
区别说明：
this(com.example.UserService): 匹配代理对象是 UserService 类型的所有方法target(com.example.UserService): 匹配目标对象是 UserService 类型的所有方法在使用接口代理时，这两者的区别尤为明显。
在使用 AOP 时，需要注意避免切面和目标对象之间的循环依赖，这可能导致 Spring 容器启动失败。
预防措施：
在环绕通知中，需要正确处理异常，确保不会吞掉目标方法抛出的异常，同时也要确保切面自身的异常不会影响目标方法的行为。
正确的异常处理示例：
@Around("logPointCut()")
public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
try {
logger.info("Before method execution");
Object result = pjp.proceed();
logger.info("After method execution");
return result;
} catch (Throwable throwable) {
logger.error("Exception in method: {}", throwable.getMessage());
// 重新抛出异常，而不是吞掉
throw throwable;
}
}
在环绕通知中，可以修改方法的参数和返回值，但这种做法应该谨慎使用，因为它可能会导致代码行为难以理解和调试。
修改参数的示例：
@Around("transactionalMethods()")
public Object modifyParameters(ProceedingJoinPoint pjp) throws Throwable {
Object[] args = pjp.getArgs();
// 修改参数
if (args.length > 0 && args[0] instanceof User) {
User user = (User) args[0];
user.setLastUpdated(new Date());
}
return pjp.proceed(args);
}
Spring AOP 基于动态代理，无法增强 static 方法和 final 方法。如果需要增强这些方法，需要使用 AspectJ 的编译时或加载时织入。
替代方案：
在同一个类中，方法内部调用其他方法时，被调用的方法不会被 AOP 增强，因为此时调用的是目标对象的方法，而不是代理对象的方法。
问题示例：
@Service
public class UserService {
@Transactional
public void updateUser(User user) {
// 内部调用，不会触发 AOP 增强
validateUser(user);
// 更新用户
}
@Loggable
public void validateUser(User user) {
// 验证逻辑
}
}
解决方案：
在多线程环境下使用 AOP 时，需要注意线程安全问题，特别是当切面中使用共享状态时。
线程安全建议：
精确的切点表达式可以减少需要代理的方法数量，提高 AOP 的性能。
优化建议：
execution(* *(..))@annotation(...)示例对比：
// 不好的做法：过于宽泛的表达式
execution(* com.example.service.*.*(..))
// 好的做法：更精确的表达式
execution(public*com.example.service.UserService.getUserById(Long))
// 更好的做法：使用注解
@annotation(com.example.annotation.Loggable)
过多的切面会增加代理对象的复杂性和方法调用的层级，影响性能。合理合并功能相似的切面。
合并建议：
在切面中执行耗时操作会直接影响目标方法的性能。应该避免在切面中进行网络请求、数据库操作等耗时操作。
耗时操作示例：
替代方案：
在切面中，如果有需要重复计算的逻辑，可以使用缓存来优化性能。
示例：
@Aspect
@Component
public class SecurityAspect {
private final LoadingCache<String, Boolean> permissionCache = CacheBuilder.newBuilder()
.maximumSize(1000)
.expireAfterWrite(10, TimeUnit.MINUTES)
.build(new CacheLoader<String, Boolean>() {
@Override
public Boolean load(String key) {
// 复杂的权限计算逻辑
return calculatePermission(key);
}
});
@Before("@annotation(requirePermission)")
public void checkPermission(JoinPoint joinPoint, RequirePermission requirePermission) {
String userId = getCurrentUserId();
String permissionKey = userId + ":" + requirePermission.value();
try {
boolean hasPermission = permissionCache.get(permissionKey);
if (!hasPermission) {
throw new AccessDeniedException("Access denied");
}
} catch (ExecutionException e) {
throw new RuntimeException("Failed to check permission", e);
}
}
}
根据需求选择合适的 AOP 实现，对于简单的需求，Spring AOP 已经足够；对于复杂的需求，可以考虑使用 AspectJ。
选择建议：
在使用 Spring AOP 时，由于使用了动态代理，可能会遇到代理对象不能转换为目标对象类型的问题。
问题示例：
@Service
public class UserService implements UserServiceInterface {
// 实现方法
}
// 在某处尝试类型转换
UserService userService = (UserService) applicationContext.getBean("userService");
// 可能会失败
解决方案：
AopContext.currentProxy() 获取当前代理对象@EnableAspectJAutoProxy(proxyTargetClass = true)如前所述，在同一个类中，方法内部调用其他方法时，被调用的方法不会被 AOP 增强。
解决方案：
@Service
public class UserService {
@Autowired
private ApplicationContext applicationContext;
private UserService selfProxy;
@PostConstruct
public void init() {
selfProxy = applicationContext.getBean(UserService.class);
}
public void updateUser(User user) {
// 调用代理对象的方法，会触发 AOP 增强
selfProxy.validateUser(user);
}
@Loggable
public void validateUser(User user) {
// 验证逻辑
}
}
AopContext.currentProxy()@Service
public class UserService {
public void updateUser(User user) {
// 需要配置 @EnableAspectJAutoProxy(exposeProxy = true)
UserService selfProxy = (UserService) AopContext.currentProxy();
selfProxy.validateUser(user);
}
@Loggable
public void validateUser(User user) {
// 验证逻辑
}
}
在环绕通知中，如果没有正确处理异常，可能会导致异常被吞掉，使问题难以排查。
问题示例：
@Around("logPointCut()")
public Object logAround(ProceedingJoinPoint pjp) {
try {
logger.info("Before method");
return pjp.proceed();
} catch (Throwable t) {
logger.error("Error: {}", t.getMessage());
// 没有重新抛出异常，导致异常被吞掉
return null;
}
}
解决方案：
@Around("logPointCut()")
public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
try {
logger.info("Before method");
return pjp.proceed();
} catch (Throwable t) {
logger.error("Error: {}", t.getMessage(), t);
// 重新抛出异常
throw t;
} finally {
logger.info("After method");
}
}
在使用声明式事务时，可能会遇到事务不回滚的情况，这通常是因为异常类型不匹配或异常被吞掉。
常见原因：
解决方案：
rollbackFor 属性指定需要回滚的异常类型@Transactional(rollbackFor = Exception.class)
public void saveUser(User user) {
// 业务逻辑
}
当多个切面应用于同一个连接点时，如果执行顺序不正确，可能会导致功能异常。
解决方案：
@Order 注解指定切面的执行顺序@Aspect
@Component
@Order(1) // 数值越小，优先级越高
public class FirstAspect {
// 实现
}
@Aspect
@Component
@Order(2)
public class SecondAspect {
// 实现
}
AOP 是一种强大的编程范式，可以有效地分离横切关注点，提高代码的模块化和可维护性。在使用 AOP 时，我们应该：
通过遵循这些最佳实践和注意事项，我们可以更好地利用 AOP 来构建可维护、高性能的应用程序。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online