Spring Framework AOP织入（Weaving）方式 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

AOP 织入：Spring 舞台上的魔术师，谁在幕后操纵？

各位尊敬的听众，未来的架构师们，大家好！我是今天的主讲人，江湖人称“代码诗人”，哦不，是“架构段子手”。欢迎来到今天的 AOP 奇妙之旅！

今天，我们要一起揭开 Spring AOP 织入的神秘面纱，看看这个在 Spring 框架中负责“偷梁换柱”、“移花接木”的家伙，究竟是怎么施展魔法的。

想象一下，你正在排练一场盛大的舞台剧，演员们正卖力表演。突然，导演发现演员的服装不够华丽，台词不够精彩，甚至有些动作不够到位。怎么办？难道要推倒重来？No No No！导演拿起他的“魔杖”（也就是 AOP），轻轻一挥，演员的服装瞬间变得金光闪闪，台词变得妙语连珠，动作也变得行云流水。这就是 AOP 织入的魅力！

什么是 AOP 织入？ ♂

简单来说，AOP 织入就是将横切关注点（Cross-Cutting Concerns，比如日志、安全、事务等）的代码，动态地添加到目标对象（也就是我们的舞台剧演员）的执行流程中，而不需要修改目标对象的源代码。

更通俗一点？就像变魔术！魔术师（AOP）在观众毫无察觉的情况下，悄悄地改变了舞台（目标对象）上的某些东西，让表演更加精彩。

AOP 织入，为何如此重要？

在传统的面向对象编程中，如果我们需要在多个地方添加相同的逻辑（比如日志记录），就需要在每个地方都复制粘贴这段代码。这样做，代码冗余不说，一旦需要修改，就要到处修改，简直是程序员的噩梦！

AOP 的出现，拯救了我们于水火之中。它可以将这些横切关注点的代码集中管理，然后通过织入的方式，动态地添加到目标对象的执行流程中。

优点：

代码解耦： 将横切关注点与业务逻辑分离，降低代码耦合度，提高代码可维护性。
代码复用： 横切关注点的代码可以被多个目标对象复用，减少代码冗余。
易于维护： 修改横切关注点的代码，只需要修改一处，所有应用该切面的目标对象都会同步更新。
动态性： 可以在运行时动态地添加或移除切面，无需重新编译代码。

AOP 织入的几种方式：

好了，铺垫了这么多，终于要进入正题了！Spring AOP 提供了三种主要的织入方式：

编译期织入（Compile-Time Weaving）：
类加载期织入（Load-Time Weaving）：
运行时织入（Runtime Weaving）：

下面，我们来逐一讲解这三种织入方式，看看它们各自的特点和适用场景。

1. 编译期织入 (Compile-Time Weaving)：编译器大显神通！

想象一下，你是一位建筑设计师，在设计图纸完成后，交给建筑工人施工。而编译期织入，就像设计师在图纸上就预先标记好了哪些地方需要添加额外的装饰，比如在墙壁上预留了安装灯具的位置。

原理： 在编译源代码时，AOP 编译器（比如 AspectJ 编译器）会将切面的代码直接织入到目标类的字节码文件中。

优点：

性能最高： 因为织入发生在编译期，所以运行时不需要额外的处理，性能是最高的。
功能强大： 可以织入任何代码，包括方法体内部的代码。

缺点：

侵入性强： 需要使用特定的编译器，比如 AspectJ 编译器。
部署复杂： 需要将编译后的带有切面的字节码文件部署到生产环境。

适用场景：

对性能要求极高的应用。
需要织入方法体内部代码的场景。
可以使用 AspectJ 编译器的项目。

举个栗子：

假设我们有一个 UserService 类，需要添加日志记录功能。

public class UserService {
    public void createUser(String username, String password) {
        System.out.println("Creating user: " + username);
    }
}

我们可以使用 AspectJ 定义一个切面，来记录 createUser 方法的执行日志。

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class LoggingAspect {

    @Before("execution(* UserService.createUser(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Log: Before executing " + joinPoint.getSignature().getName());
    }
}

然后，使用 AspectJ 编译器编译 UserService 类和 LoggingAspect 类，就可以得到带有切面的 UserService 类的字节码文件。

注意： 使用编译期织入，需要在构建过程中配置 AspectJ 编译器。

特性	编译期织入 (Compile-Time Weaving)
性能	最高
侵入性	强
复杂度	较高
适用场景	性能敏感，允许使用特定编译器的项目
代表技术	AspectJ

2. 类加载期织入 (Load-Time Weaving)：JVM 的秘密武器！

想象一下，你是一位海关检查员，在货物进入仓库之前，你可以在货物的包装上贴上标签，标记货物的属性和注意事项。类加载期织入，就像海关检查员一样，在类加载到 JVM 之前，将切面的代码织入到目标类的字节码文件中。

原理： 在类加载到 JVM 时，通过类加载器（ClassLoader）的拦截器，将切面的代码织入到目标类的字节码文件中。

优点：

非侵入性： 不需要修改源代码，也不需要使用特定的编译器。
灵活性高： 可以在运行时动态地配置切面。

缺点：

性能稍逊： 织入发生在类加载时，会增加类加载的时间。
配置复杂： 需要配置类加载器。

适用场景：

不需要修改源代码，但又需要织入切面的场景。
可以使用类加载器的项目。
OSGi 环境。

举个栗子：

我们可以使用 Spring 的 LoadTimeWeaver 接口来实现类加载期织入。

首先，在 applicationContext.xml 文件中配置 LoadTimeWeaver。

<context:load-time-weaver aspectj-weaving="on"/>

然后，定义一个切面。

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class LoggingAspect {

    @Before("execution(* UserService.createUser(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Log: Before executing " + joinPoint.getSignature().getName());
    }
}

最后，将 LoggingAspect 类声明为 Spring 的 Bean。

<bean id="loggingAspect" class="LoggingAspect"/>

当 UserService 类被加载到 JVM 时，LoadTimeWeaver 会自动将 LoggingAspect 切面的代码织入到 UserService 类的字节码文件中。

注意： 使用类加载期织入，需要在 classpath 中添加 aspectjweaver.jar 包。

特性	类加载期织入 (Load-Time Weaving)
性能	较编译期稍低
侵入性	低
复杂度	中等
适用场景	不想修改源码，需要动态配置的项目，OSGi环境
代表技术	Spring LoadTimeWeaver, AspectJ

3. 运行时织入 (Runtime Weaving)：Spring AOP 的拿手好戏！

想象一下，你是一位电影特效师，在电影拍摄完成后，你可以通过软件对电影进行后期处理，添加特效、修改画面等等。运行时织入，就像电影特效师一样，在程序运行时，动态地创建代理对象，将切面的代码织入到代理对象中。

原理： 使用动态代理技术（JDK 动态代理或 CGLIB 代理），在运行时动态地创建目标对象的代理对象，并将切面的代码织入到代理对象中。

优点：

非侵入性： 不需要修改源代码，也不需要使用特定的编译器。
配置简单： 只需要配置 Spring 的 AOP 即可。
灵活性高： 可以在运行时动态地添加或移除切面。

缺点：

性能最低： 织入发生在运行时，会增加运行时的开销。
功能受限： 只能织入方法级别的代码，无法织入方法体内部的代码。

适用场景：

不需要修改源代码，也不需要使用特定的编译器的场景。
对性能要求不高的应用。
只需要织入方法级别的代码的场景。

举个栗子：

我们可以使用 Spring AOP 来实现运行时织入。

首先，在 applicationContext.xml 文件中配置 AOP。

<aop:aspectj-autoproxy/>

然后，定义一个切面。

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class LoggingAspect {

    @Before("execution(* UserService.createUser(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Log: Before executing " + joinPoint.getSignature().getName());
    }
}

最后，将 LoggingAspect 类声明为 Spring 的 Bean。

<bean id="loggingAspect" class="LoggingAspect"/>

当调用 UserService 类的 createUser 方法时，Spring AOP 会自动创建 UserService 类的代理对象，并将 LoggingAspect 切面的代码织入到代理对象中。

注意： 使用运行时织入，需要在 classpath 中添加 aspectjrt.jar 包。

特性	运行时织入 (Runtime Weaving)
性能	最低
侵入性	低
复杂度	最低
适用场景	大部分 Spring AOP 使用场景
代表技术	Spring AOP (JDK Proxy, CGLIB)

三种织入方式的对比：

为了方便大家理解，我们用一张表格来总结一下这三种织入方式的特点：

特性	编译期织入 (Compile-Time Weaving)	类加载期织入 (Load-Time Weaving)	运行时织入 (Runtime Weaving)
性能	最高	较编译期稍低	最低
侵入性	强	低	低
复杂度	较高	中等	最低
灵活性	低	中等	高
功能	最强	较强	较弱
适用场景	性能敏感，允许使用特定编译器的项目	不想修改源码，需要动态配置的项目，OSGi环境	大部分 Spring AOP 使用场景
代表技术	AspectJ	Spring LoadTimeWeaver, AspectJ	Spring AOP (JDK Proxy, CGLIB)

选择哪种织入方式？

选择哪种织入方式，取决于具体的应用场景和需求。

如果对性能要求极高，并且可以使用 AspectJ 编译器，那么编译期织入是最佳选择。
如果不想修改源代码，但又需要织入切面，并且可以使用类加载器，那么类加载期织入是一个不错的选择。
如果不需要修改源代码，也不需要使用特定的编译器，并且对性能要求不高，那么运行时织入是最简单方便的选择。

总结：

今天，我们一起学习了 Spring AOP 的三种织入方式：编译期织入、类加载期织入和运行时织入。

编译期织入：性能最高，但侵入性强。
类加载期织入：非侵入性，但配置复杂。
运行时织入：最简单方便，但性能最低。

希望通过今天的讲解，大家能够对 Spring AOP 的织入方式有更深入的理解，并在实际项目中灵活运用。

记住，AOP 织入就像舞台上的魔术师，它可以让你的代码更加优雅、高效、易于维护。 ♂

感谢大家的聆听！下次再见！

AOP 织入：Spring 舞台上的魔术师，谁在幕后操纵？

发表回复 取消回复

发表回复取消回复