Spring AOP vs AspectJ：从源码角度看AOP的前世今生与未来之路

// 目标类 
@Component 
public class UserService {
    public void createUser(String username) {
        System.out.println("Creating  user: " + username);
    }
}
 
// 切面类 
@Component 
@Aspect 
public class LoggingAspect {
    @Around("execution(* com.example.UserService.createUser(..))") 
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Entering  method: " + joinPoint.getMethod().getName()); 
        Object result = joinPoint.proceed(); 
        System.out.println("Exiting  method: " + joinPoint.getMethod().getName()); 
        return result;
    }
}

1.2 Spring AOP 的源码分析

Spring AOP 的核心在于 ProxyFactory 和 Advisor。

ProxyFactory 负责创建代理对象。
Advisor 是切面的抽象，包含了切点和通知逻辑。

1.2.1 ProxyFactory 的工作流程

目标对象：需要被代理的对象（如 UserService）。
切点：定义代理的目标方法（如 execution(* com.example.UserService.createUser(..)) ）。
通知：在目标方法执行前后插入的逻辑（如日志记录）。

1.2.2 Spring AOP 的性能瓶颈

由于 Spring AOP 依赖动态代理，每次方法调用都会通过代理层，这会导致一定的性能损失。对于性能要求极高的场景（如金融交易系统），Spring AOP 可能不是最佳选择。

第二部分：AOP的“万能补丁”——AspectJ

2.1 什么是 AspectJ？

AspectJ 是 Java 社区中最强大的 AOP 框架，它通过编译时织入（Compile-Time Weaving, CTW）或运行时织入（Load-Time Weaving, LTW）的方式，将切面逻辑直接织入目标类的字节码中。

2.1.1 AspectJ 的实现原理

AspectJ 的核心是字节码操作技术。它通过 ASM 等工具直接修改目标类的字节码，将切面逻辑嵌入其中。这种方式使得 AspectJ 的性能远高于 Spring AOP。

2.1.2 AspectJ 的优点

强大的切点表达式：支持字段、构造方法、静态初始化块等多种切点类型。
高性能：由于切面逻辑直接织入字节码，性能损失极小。
适用范围广：不仅可以用于 Spring 管理的 Bean，还可以用于普通 Java 对象（POJO）。

2.1.3 AspectJ 的缺点

学习成本高：需要掌握 AspectJ 的专用语法和工具链。
部署复杂：需要配置 AspectJ 编译器（ajc）或 LTW 工具。

2.1.4 AspectJ 的代码示例

// 目标类 
public class UserService {
    public void createUser(String username) {
        System.out.println("Creating  user: " + username);
    }
}
 
// 切面类 
public aspect LoggingAspect {
    pointcut loggingPointcut() : execution(* com.example.UserService.createUser(..)); 
 
    around(loggingPointcut()): Object proceed() {
        System.out.println("Entering  method: " + thisJoinPoint.getSignature().getName()); 
        Object result = proceed();
        System.out.println("Exiting  method: " + thisJoinPoint.getSignature().getName()); 
        return result;
    }
}

2.2 AspectJ 的源码分析

AspectJ 的核心在于 Ajc 编译器和 Weaver。

Ajc：AspectJ 的专用编译器，负责将切面代码编译为标准的 Java 字节码。
Weaver：在编译或运行时，将切面逻辑织入目标类的字节码中。

2.2.1 AspectJ 的性能优势

由于 AspectJ 直接操作字节码，切面逻辑的执行效率接近原生代码。这种方式非常适合对性能要求极高的场景。

第三部分：Spring AOP 与 AspectJ 的对比

3.1 对比维度

特性	Spring AOP	AspectJ
织入时机	运行时织入（Runtime Weaving）	编译时织入（CTW）或运行时织入（LTW）
代理方式	动态代理（JDK/CGLIB）	字节码操作（ASM）
切点支持	方法级别	方法、字段、构造方法等
性能	较低	较高
适用场景	Spring 管理的 Bean	Spring 管理的 Bean 或 POJO
学习成本	低	高

3.2 选择指南

如果你在使用 Spring 框架：
- 如果切面逻辑简单，且目标对象是 Spring 管理的 Bean，选择 Spring AOP。
- 如果需要对 POJO 或字段进行切面增强，选择 AspectJ。
如果你追求高性能：
- 选择 AspectJ，尤其是在对性能要求极高的场景（如高频交易系统）。

第四部分：源码对比与实际案例

4.1 源码对比

Spring AOP 的代理机制

// Spring AOP 代理工厂 
ProxyFactory proxyFactory = new ProxyFactory(userService);
proxyFactory.addAdvisor(advisor); 
UserService proxy = (UserService) proxyFactory.getProxy();

AspectJ 的字节码织入

<!-- AspectJ LTW 配置 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId> 
            <artifactId>aspectj-maven-plugin</artifactId>
            <version>1.14.0</version>
            <configuration>
                <weaveDependencies>
                    <include>com.example:*</include> 
                </weaveDependencies>
            </configuration>
        </plugin>
    </plugins>
</build>

4.2 实际案例

案例 1：日志记录

// Spring AOP 方案 
@Aspect 
@Component 
public class LoggingAspect {
    @Around("execution(* com.example.UserService.createUser(..))") 
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 日志记录逻辑 
 }
   }
 
// AspectJ 方案 
public aspect LoggingAspect {
    pointcut loggingPointcut() : execution(* com.example.UserService.createUser(..)); 
    
    around(loggingPointcut()): Object proceed() {
        // 日志记录逻辑 
    }
}

案例 2：字段监控

// AspectJ 支持字段监控 
public aspect FieldMonitor {
    pointcut fieldAccess() : get(* com.example.User.name); 
 
    before(): fieldAccess() {
        System.out.println("Field  accessed: User.name"); 
    }
}