发布于 由admin

Spring AOP：基于AspectJ的编译期织入（Compile-Time Weaving）性能优势

Spring AOP：基于AspectJ的编译期织入（Compile-Time Weaving）性能优势

大家好，今天我们来深入探讨Spring AOP中一个非常重要的方面：基于AspectJ的编译期织入（Compile-Time Weaving），以及它所带来的性能优势。在开始之前，我们先简要回顾一下AOP的基本概念，以及Spring AOP提供的几种织入方式，然后重点分析编译期织入的原理、实现方式，并通过实例对比不同织入方式的性能差异，最后讨论一些实际应用中的注意事项。

AOP 和 Spring AOP 的简要回顾

AOP (Aspect-Oriented Programming, 面向切面编程) 是一种编程范式，旨在通过将横切关注点（Cross-Cutting Concerns）从核心业务逻辑中分离出来，来提高代码的模块化程度和可维护性。横切关注点是指那些散布在整个应用程序中的，但又不是核心业务逻辑的一部分的功能，例如日志记录、安全认证、事务管理等。

Spring AOP 是 Spring 框架提供的一种 AOP 实现。它允许开发者使用 AOP 的思想来组织代码，并且提供了多种织入（Weaving）方式，将切面（Aspect）中的增强逻辑（Advice）应用到目标对象（Target Object）上。

织入 (Weaving) 是将切面应用到目标对象并创建增强对象的过程。 Spring AOP 支持以下几种织入方式：

  • JDK 动态代理 (JDK Dynamic Proxy)：基于接口的代理，只能对实现了接口的类进行增强。
  • CGLIB 代理 (CGLIB Proxy)：基于类的代理，可以对没有实现接口的类进行增强。
  • AspectJ 编译期织入 (AspectJ Compile-Time Weaving)：在编译时将切面织入到目标类中。
  • AspectJ 加载期织入 (AspectJ Load-Time Weaving)：在类加载时将切面织入到目标类中。

编译期织入：原理与优势

今天我们主要关注的是AspectJ 编译期织入。与运行时织入（如 JDK 动态代理和 CGLIB 代理）不同，编译期织入在编译阶段就将切面代码直接嵌入到目标类的字节码中。

原理:

  1. 编写 AspectJ 切面： 使用 AspectJ 语法定义切面，包括切点（Pointcut）和增强（Advice）。
  2. 使用 AspectJ 编译器 (ajc)： 使用 AspectJ 编译器编译源代码和切面。
  3. 生成增强后的字节码： AspectJ 编译器会将切面代码织入到目标类的字节码中，生成增强后的类文件。

优势:

  • 性能更高： 由于增强逻辑在编译时已经织入到目标类中，运行时不再需要进行代理创建和方法拦截等操作，因此性能更高。
  • 对现有代码无侵入性： 不需要修改现有的 Java 代码，只需要编写 AspectJ 切面即可。
  • 更强大的切点表达能力： AspectJ 提供了比 Spring AOP 更强大的切点表达式语言，可以更精确地定义切点。
  • 支持更广泛的增强类型： 除了 Spring AOP 支持的增强类型（Before, After, AfterReturning, AfterThrowing, Around）之外，AspectJ 还支持更丰富的增强类型，例如 perthis, pertarget, percflow 等。

劣势:

  • 需要使用 AspectJ 编译器： 需要引入 AspectJ 编译器，并将其集成到构建过程中。
  • 调试可能更复杂： 由于字节码已经被修改，调试时可能需要查看反编译后的代码。
  • 与某些框架可能存在兼容性问题： 某些框架可能对修改后的字节码有特殊要求，需要进行额外的配置才能兼容。

编译期织入的实现方式

要使用 AspectJ 编译期织入，需要进行以下步骤：

  1. 添加 AspectJ 依赖： 在 Maven 或 Gradle 项目中，添加 AspectJ 相关的依赖。

    <!-- Maven -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.9.1</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjtools</artifactId>
    <version>1.9.9.1</version>
</dependency>
    // Gradle
dependencies {
    implementation 'org.aspectj:aspectjrt:1.9.9.1'
    implementation 'org.aspectj:aspectjtools:1.9.9.1'
}

  2. 编写 AspectJ 切面： 使用 @Aspect 注解定义切面，使用 @Pointcut 注解定义切点，使用 @Before, @After, @Around 等注解定义增强。

    import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethods() {}

    @Before("serviceMethods()")
    public void beforeServiceMethod() {
        System.out.println("Before executing service method");
    }

    @After("serviceMethods()")
    public void afterServiceMethod() {
        System.out.println("After executing service method");
    }

    @Around("serviceMethods()")
    public Object aroundServiceMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("Around - Before executing: " + joinPoint.getSignature().getName());
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        System.out.println("Around - After executing: " + joinPoint.getSignature().getName() + ", Execution time: " + (end - start) + "ms");
        return result;
    }
}

  3. 配置 AspectJ 编译器： 在 Maven 或 Gradle 构建文件中，配置 AspectJ 编译器。

    Maven:

    <build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>aspectj-maven-plugin</artifactId>
            <version>1.14.0</version>
            <configuration>
                <complianceLevel>17</complianceLevel>
                <source>17</source>
                <target>17</target>
                <showWeaveInfo>true</showWeaveInfo>
                <verbose>true</verbose>
                <Xlint>ignore</Xlint>
                <encoding>UTF-8</encoding>
                <aspectLibraries>
                    <aspectLibrary>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-aspects</artifactId>
                    </aspectLibrary>
                </aspectLibraries>
                <weaveDependencies>
                    <weaveDependency>
                        <groupId>com.example</groupId>
                        <artifactId>my-app</artifactId>
                    </weaveDependency>
                </weaveDependencies>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>       <!-- use this goal to weave all your main classes -->
                        <goal>test-compile</goal>  <!-- use this goal to weave all your test classes -->
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

    Gradle:

    dependencies {
    compileOnly("org.aspectj:aspectjweaver:${aspectjVersion}")
    implementation("org.aspectj:aspectjrt:${aspectjVersion}")
}

tasks.withType(JavaCompile) {
    options.compilerArgs += ["-Xlint:ignore", "-Xbootclasspath/p:${configurations.compileClasspath.asPath}"]
}

tasks.register('weave') {
    doLast {
        javaexec {
            main = 'org.aspectj.tools.ajc.Main'
            classpath = configurations.compileClasspath
            args = [
                    "-17",
                    "-d", sourceSets.main.output.classesDirs.singleFile.absolutePath,
                    "-inpath", sourceSets.main.output.classesDirs.singleFile.absolutePath,
                    "-aspectpath", configurations.compileClasspath.asPath,
                    "-classpath", configurations.compileClasspath.asPath,
                    "-source", "17",
                    "-target", "17",
                    "src/main/java" // or wherever your aspects are
            ]
        }
    }
}

compileJava.dependsOn('weave')

  4. 编写目标类： 定义需要增强的目标类。

    package com.example.service;

import org.springframework.stereotype.Service;

@Service
public class MyService {

    public String doSomething() {
        System.out.println("Executing doSomething method");
        return "Hello, World!";
    }

    public void doAnotherThing() {
        System.out.println("Executing doAnotherThing method");
    }
}

  5. 测试： 运行应用程序，观察切面是否生效。

    import com.example.service.MyService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.example")
@EnableAspectJAutoProxy(proxyTargetClass = true) // Important for CGLIB if you're not using interfaces
public class AppConfig {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myService = context.getBean(MyService.class);
        myService.doSomething();
        myService.doAnotherThing();
        context.close();
    }
}

    预期输出：

    Before executing service method
Around - Before executing: doSomething
Executing doSomething method
Around - After executing: doSomething, Execution time: 0ms
After executing service method
Before executing service method
Around - Before executing: doAnotherThing
Executing doAnotherThing method
Around - After executing: doAnotherThing, Execution time: 0ms
After executing service method

性能对比：编译期织入 vs. 运行时织入

为了更直观地了解编译期织入的性能优势，我们可以进行简单的性能测试，对比编译期织入和运行时织入（例如 CGLIB 代理）的性能差异。

测试代码:

import com.example.service.MyService;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Configuration
@ComponentScan("com.example")
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AppConfig {

    public static void main(String[] args) throws Exception {
        int iterations = 1000000;

        // 编译期织入测试
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myServiceCompileTime = context.getBean(MyService.class);
        long startCompileTime = System.currentTimeMillis();
        for (int i = 0; i < iterations; i++) {
            myServiceCompileTime.doSomething();
        }
        long endCompileTime = System.currentTimeMillis();
        System.out.println("Compile-Time Weaving: " + (endCompileTime - startCompileTime) + "ms");
        context.close();

        // CGLIB 代理测试
        MyService myServiceTarget = new MyService();
        LoggingInterceptor interceptor = new LoggingInterceptor();
        ProxyFactory proxyFactory = new ProxyFactory(myServiceTarget);
        proxyFactory.addAdvice(interceptor);
        MyService myServiceCglib = (MyService) proxyFactory.getProxy();

        long startCglib = System.currentTimeMillis();
        for (int i = 0; i < iterations; i++) {
            myServiceCglib.doSomething();
        }
        long endCglib = System.currentTimeMillis();
        System.out.println("CGLIB Proxy: " + (endCglib - startCglib) + "ms");
    }

    @Component
    static class LoggingInterceptor implements org.aopalliance.intercept.MethodInterceptor {
        @Override
        public Object invoke(org.aopalliance.intercept.MethodInvocation invocation) throws Throwable {
            long start = System.currentTimeMillis();
            Object result = invocation.proceed();
            long end = System.currentTimeMillis();
            //System.out.println("CGLIB - Method " + invocation.getMethod().getName() + " executed in " + (end - start) + "ms");
            return result;
        }
    }
}

注意: LoggingInterceptor 需要实现 org.aopalliance.intercept.MethodInterceptor 接口。 并且，为了避免编译期织入和CGLIB代理的日志输出互相干扰， CGLIB的日志输出被注释掉了。

测试结果 (示例):

织入方式 执行时间 (ms)
编译期织入 (AspectJ) 1200
CGLIB 代理 2500

注意：以上结果仅为示例，实际执行时间会受到硬件环境、JVM 配置等因素的影响。 多次运行取平均值可以得到更准确的结果。

从测试结果可以看出，编译期织入的性能明显优于 CGLIB 代理。 这是因为编译期织入在编译时就将增强逻辑织入到目标类中，避免了运行时的代理创建和方法拦截开销。

更细粒度的分析:

实际上，性能差异体现在以下几个方面：

  1. 代理对象的创建： CGLIB需要在运行时创建代理对象，这会带来额外的开销。 编译期织入则不需要。
  2. 方法拦截： CGLIB 在每次调用目标方法时，都需要进行方法拦截，并调用 MethodInterceptor 接口的 invoke 方法。 编译期织入直接将增强代码嵌入到目标方法中，避免了方法拦截的开销。
  3. 方法调用： 尽管 JVM 对方法内联做了优化，但运行时代理仍然会增加方法调用的层级，可能导致性能下降。 编译期织入则不存在这个问题。

实际应用中的注意事项

在使用 AspectJ 编译期织入时，需要注意以下几点：

  1. 构建工具的配置： 确保正确配置 Maven 或 Gradle 构建文件，以便使用 AspectJ 编译器进行编译。
  2. 切点表达式的编写： 编写精确的切点表达式，避免不必要的增强。 错误的切点表达式可能导致性能下降，甚至引发运行时异常。
  3. 与其他框架的兼容性： 某些框架可能对修改后的字节码有特殊要求，需要进行额外的配置才能兼容。 例如，在使用 Spring Boot 时，可能需要配置 spring-boot-maven-plugin 或 spring-boot-gradle-plugin 来支持 AspectJ 编译期织入。
  4. 调试： 由于字节码已经被修改，调试时可能需要查看反编译后的代码。 可以使用 IDE 的反编译功能，或者使用 javap 命令查看类文件的字节码。
  5. 类加载器问题： 在某些复杂的类加载器环境中，可能会出现 AspectJ 切面无法正确织入的问题。 这种情况下，需要仔细检查类加载器的配置，并确保 AspectJ 相关的类库能够被正确加载。
  6. 避免过度使用AOP： 尽管 AOP 可以提高代码的模块化程度和可维护性，但过度使用 AOP 可能会导致代码难以理解和调试。 应该根据实际情况，合理地使用 AOP。

一个更完整的示例

为了更具体地说明编译期织入的应用，我们提供一个更完整的示例，包括日志记录、异常处理和性能监控。

1. AspectJ 切面 (PerformanceAspect.java):

package com.example.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

@Aspect
@Component
public class PerformanceAspect {

    private static final Logger logger = LoggerFactory.getLogger(PerformanceAspect.class);

    @Around("execution(* com.example.service.*.*(..))")
    public Object logPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        String className = joinPoint.getTarget().getClass().getSimpleName();

        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        Object result = null;

        try {
            result = joinPoint.proceed();
            return result;
        } catch (Throwable e) {
            logger.error("Exception in {}.{}: {}", className, methodName, e.getMessage());
            throw e; // Re-throw the exception to be handled further up the call stack
        } finally {
            stopWatch.stop();
            long executionTime = stopWatch.getTotalTimeMillis();
            logger.info("{}.{} executed in {} ms", className, methodName, executionTime);
        }
    }
}

2. 目标 Service (MyService.java):

package com.example.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    private static final Logger logger = LoggerFactory.getLogger(MyService.class);

    public String doSomething(String input) {
        logger.info("doSomething called with input: {}", input);
        try {
            Thread.sleep(100); // Simulate some processing time
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            logger.error("Interrupted!", e);
        }
        return "Processed: " + input;
    }

    public void doAnotherThing() {
        logger.info("doAnotherThing called");
        // Simulate an exception
        if (Math.random() > 0.5) {
            throw new RuntimeException("Simulated exception");
        }
        logger.info("doAnotherThing completed successfully");
    }
}

3. 配置类 (AppConfig.java):

package com.example;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

import com.example.service.MyService;

@Configuration
@ComponentScan("com.example")
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AppConfig {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myService = context.getBean(MyService.class);

        System.out.println(myService.doSomething("Hello"));

        try {
            myService.doAnotherThing();
        } catch (Exception e) {
            System.err.println("Caught exception in main: " + e.getMessage());
        }

        context.close();
    }
}

4. Maven 配置 (pom.xml):

<project>
    <!-- ... other configurations ... -->
    <dependencies>
        <!-- Spring dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.9</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>6.0.9</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.19</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.19</version>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>2.0.9</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.4.11</version>
            <scope>runtime</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>aspectj-maven-plugin</artifactId>
                <version>1.14.0</version>
                <configuration>
                    <complianceLevel>17</complianceLevel>
                    <source>17</source>
                    <target>17</target>
                    <showWeaveInfo>true</showWeaveInfo>
                    <verbose>true</verbose>
                    <Xlint>ignore</Xlint>
                    <encoding>UTF-8</encoding>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

说明:

  • PerformanceAspect 切面使用 @Around 增强来记录方法执行时间，处理异常，并进行日志记录。
  • 使用了 SLF4J 和 Logback 作为日志框架。
  • MyService 模拟了一些业务逻辑，包括睡眠和异常抛出。
  • Maven 配置包含了 AspectJ 编译器插件的配置。

预期输出:

运行 AppConfig 的 main 方法后，你将看到类似以下的输出（实际输出可能因随机数而异）：

2023-10-27 14:30:00.123  INFO [main] com.example.service.MyService - doSomething called with input: Hello
2023-10-27 14:30:00.224  INFO [main] com.example.aspect.PerformanceAspect - MyService.doSomething executed in 101 ms
Processed: Hello
2023-10-27 14:30:00.224  INFO [main] com.example.service.MyService - doAnotherThing called
2023-10-27 14:30:00.225  INFO [main] com.example.aspect.PerformanceAspect - MyService.doAnotherThing executed in 1 ms
Caught exception in main: Simulated exception

这个示例展示了如何使用 AspectJ 编译期织入来实现通用的横切关注点，例如日志记录、性能监控和异常处理。 通过编译期织入，可以避免运行时代理的开销，提高应用程序的性能。

一些思考

编译期织入是一种强大的 AOP 技术，它提供了更高的性能和更强大的切点表达能力。 然而，它也带来了一些复杂性，例如需要配置 AspectJ 编译器，以及可能存在的兼容性问题。 在实际应用中，需要根据具体的需求和场景，权衡各种织入方式的优缺点，选择最适合的方案。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注