AspectJ使用介绍（分享）

链接地址：
AspectJ 使用介绍

更新时间：2018-07-02

上一篇文章，我们介绍了 Spring AOP 的各种用法，包括随着 Spring 的演进而发展出来的几种配置方式。

但是我们始终没有使用到 AspectJ，即使是在基于注解的 @AspectJ 的配置方式中，Spring 也仅仅是使用了 AspectJ 包中的一些注解而已，并没有依赖于 AspectJ 实现具体的功能。

本文将介绍使用 AspectJ，介绍它的 3 种织入方式。

本文使用的测试源码已上传到 Github: hongjiev/aspectj-learning，如果你在使用过程中碰到麻烦，请在评论区留言。

目录：

AspectJ 使用介绍

AspectJ 作为 AOP 编程的完全解决方案，提供了三种织入时机，分别为

compile-time：编译期织入，在编译的时候一步到位，直接编译出包含织入代码的 .class 文件
post-compile：编译后织入，增强已经编译出来的类，如我们要增强依赖的 jar 包中的某个类的某个方法
load-time：在 JVM 进行类加载的时候进行织入

本节中的内容参考了《Intro to AspectJ》，Baeldung 真的是挺不错的一个 Java 博客。

首先，先把下面两个依赖加进来：

<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjrt</artifactId>
   <version>1.8.13</version>
</dependency>

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.13</version>
</dependency>

我们后面需要用到下面这个类，假设账户初始有 20 块钱，之后会调 account.pay(amount) 进行付款：

public class Account {

    int balance = 20;

    public boolean pay(int amount) {
        if (balance < amount) {
            return false;
        }
        balance -= amount;
        return true;
    }
}

下面，我们定义两个 Aspect 来进行演示：

AccountAspect：用 AspectJ 的语法来写，对交易进行拦截，如此次交易超过余额，直接拒绝。
ProfilingAspect：用 Java 来写，用于记录方法的执行时间

AccountAspect 需要以 .aj 结尾，如我们在 com.javadoop.aspectjlearning.aspectj 的 package 下新建文件 AccountAspect.aj，内容如下：

package com.javadoop.aspectjlearning.aspect;

import com.javadoop.aspectjlearning.model.Account;

public aspect AccountAspect {

    pointcut callPay(int amount, Account account):
            call(boolean com.javadoop.aspectjlearning.model.Account.pay(int)) && args(amount) && target(account);

    before(int amount, Account account): callPay(amount, account) {
        System.out.println("[AccountAspect]付款前总金额: " + account.balance);
        System.out.println("[AccountAspect]需要付款: " + amount);
    }

    boolean around(int amount, Account account): callPay(amount, account) {
        if (account.balance < amount) {
            System.out.println("[AccountAspect]拒绝付款!");
            return false;
        }
        return proceed(amount, account);
    }

    after(int amount, Account balance): callPay(amount, balance) {
        System.out.println("[AccountAspect]付款后，剩余：" + balance.balance);
    }

}

上面 .aj 的语法我们可能不熟悉，但是看上去还是简单的，分别处理了 before、around 和 after 的场景。

我们再来看用 Java 写的 ProfilingAspect.java:

package com.javadoop.aspectjlearning.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class ProfilingAspect {

    @Pointcut("execution(* com.javadoop.aspectjlearning.model.*.*(..))")
    public void modelLayer() {
    }

    @Around("modelLayer()")
    public Object logProfile(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        System.out.println("[ProfilingAspect]方法: 【" + joinPoint.getSignature() + "】结束，用时: " + (System.currentTimeMillis() - start));

        return result;
    }
}

接下来，我们讨论怎么样将定义好的两个 Aspects 织入到我们的 Account 的付款方法 pay(amount) 中，也就是三种织入时机分别是怎么实现的。

Compile-Time Weaving

这是最简单的使用方式，在编译期的时候进行织入，这样编译出来的 .class 文件已经织入了我们的代码，在 JVM 运行的时候其实就是加载了一个普通的被织入了代码的类。

如果你是采用 maven 进行管理，可以在 <build> 中加入以下的插件：

<!-- 编译期织入 -->
<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>1.7</version>
    <configuration>
        <complianceLevel>1.8</complianceLevel>
        <source>1.8</source>
        <target>1.8</target>
        <showWeaveInfo>true</showWeaveInfo>
        <verbose>true</verbose>
        <Xlint>ignore</Xlint>
        <encoding>UTF-8</encoding>
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>compile</goal>
                <goal>test-compile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

AccountAspect.aj 文件 javac 是没法编译的，所以上面这个插件其实充当了编译的功能。

然后，我们就可以运行了：

public class Application {

    public static void main(String[] args) {
        testCompileTime();
    }
    public static void testCompileTime() {
        Account account = new Account();
        System.out.println("==================");
        account.pay(10);
        account.pay(50);
        System.out.println("==================");
    }
}

输出：

==================
[AccountAspect]付款前总金额: 20
[AccountAspect]需要付款: 10
[ProfilingAspect]方法: 【boolean com.javadoop.aspectjlearning.model.Account.pay(int)】结束，用时: 1
[AccountAspect]付款后，剩余：10
[AccountAspect]付款前总金额: 10
[AccountAspect]需要付款: 50
[AccountAspect]拒绝付款!
[AccountAspect]付款后，剩余：10
==================

结果看上去就很神奇（我们知道是 aop 搞的鬼当然会觉得不神奇），其实奥秘就在于 main 函数中的代码被改变了，不再是上面几行简单的代码了，而是进行了织入：

我们的 Account 类也不再像原来定义的那样了：

编译期织入理解起来应该还是比较简单，就是在编译的时候先修改了代码再进行编译。

Post-Compile Weaving

Post-Compile Weaving 和 Compile-Time Weaving 非常类似，我们也是直接用场景来说。

我们假设上面的 Account 类在 aspectj-learning-share.jar 包中，我们的工程 aspectj-learning 依赖了这个 jar 包。

由于 Account 这个类已经被编译出来了，我们要对它的方法进行织入，就需要用到编译后织入。

为了方便大家测试，尽量让前面的用例也能跑起来。我们定义一个新的类 User，代码和 Account 一样，但是在 aspectj-learning-share.jar 包中，这个包就这一个类。

同时也复制 AccountAspect 一份出来，命名为 UserAspect，稍微修改修改就可以用来处理 User 类了。

首先，我们注释掉之前编译期织入使用的插件配置，增加以下插件配置（其实还是同一个插件）：

<!--编译后织入-->
<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>1.11</version>
    <configuration>
        <complianceLevel>1.8</complianceLevel>
        <weaveDependencies>
            <weaveDependency>
                <groupId>com.javadoop</groupId>
                <artifactId>aspectj-learning-share</artifactId>
            </weaveDependency>
        </weaveDependencies>
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>compile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

注意配置中的 <weaveDependency>，我们在 <dependencies> 中要配置好依赖，然后在这里进行配置。这样就可以对其进行织入了。

接下来，大家可以手动用 mvn clean package 编译一下，然后就会看到以下结果：

从上图我们可以看到，上面的配置会把相应的 jar 包中的类加到当前工程的编译结果中（User 类原本是在 aspectj-learning-share.jar 中的）。

运行一下：

java -jar target/aspectj-learning-1.0-jar-with-dependencies.jar

运行结果也会如预期的一样，UserAspect 对 User 进行了织入，这里就不赘述了。感兴趣的读者自己去跑一下，注意一定要用 mvn 命令，不要用 IDE，不然很多时候发现不了问题。

Intellij 在 build 的时候会自己处理 AspectJ，而不是用我们配置的 maven 插件。

Load-Time Weaving

最后，我们要介绍的是 LTW 织入，正如 Load-Time 的名字所示，它是在 JVM 加载类的时候做的织入。AspectJ 允许我们在启动的时候指定 agent 来实现这个功能。

首先，我们先注释掉之前在 pom.xml 中用于编译期和编译后织入使用的插件，免得影响我们的测试。

我们要知道，一旦我们去掉了 aspectj 的编译插件，那么 .aj 的文件是不会被编译的。

然后，我们需要在 JVM 的启动参数中加上以下 agent（或在 IDE 中配置 VM options），如：

-javaagent:/Users/hongjie/.m2/repository/org/aspectj/aspectjweaver/1.8.13/aspectjweaver-1.8.13.jar

之后，我们需要在 resources 中配置 aop.xml 文件，放置在 META-INF 目录中（resource/META-INF/aop.xml）：

<!DOCTYPE aspectj PUBLIC "-//AspectJ//DTD//EN" "http://www.eclipse.org/aspectj/dtd/aspectj.dtd">
<aspectj>
    <aspects>
        <aspect name="com.javadoop.aspectjlearning.aspect.ProfilingAspect"/>
        <weaver options="-verbose -showWeaveInfo">
            <include within="com.javadoop.aspectjlearning..*"/>
        </weaver>
    </aspects>
</aspectj>

aop.xml 文件中的配置非常容易理解，只需要配置 Aspects 和需要被织入的类即可。

我们用以下程序进行测试：

public class Application {
    public static void main(String[] args) {
        testLoadTime();
    }
    public static void testLoadTime() {
        Account account = new Account();
        System.out.println("==================");
        account.pay(10);
        account.pay(50);
        System.out.println("==================");
    }
}

万事具备了，我们可以开始跑起来了。

第一步，编译

mvn clean package

第二步，检查编译结果

我们通过 IDE 查看编译出来的代码（IDE反编译），可以看到，Application 类并未进行织入，Account 类也并未进行织入。

第三步，运行

从第二步我们可以看到，在运行之前，AspectJ 没有做任何的事情。

那么可以肯定的就是，AspectJ 会在运行期利用 aop.xml 中的配置进行织入处理。

在命令行中执行以下语句：

java -jar target/aspectj-learning-1.0-jar-with-dependencies.jar

输出为：

==================
==================

可以看到没有任何织入处理，然后执行以下语句再试试：

java -javaagent:/Users/hongjie/.m2/repository/org/aspectj/aspectjweaver/1.8.13/aspectjweaver-1.8.13.jar -jar target/aspectj-learning-1.0-jar-with-dependencies.jar

启动的时候指定了 -javaagent:/.../aspectjweaver-1.8.13.jar，然后再看输出结果：

==================
[ProfilingAspect]方法: 【boolean com.javadoop.aspectjlearning.model.Account.pay(int)】结束，用时: 1
[ProfilingAspect]方法: 【boolean com.javadoop.aspectjlearning.model.Account.pay(int)】结束，用时: 0
==================

我们可以看到 ProfilingAspect 已经进行了织入处理，这就是 Load-time Weaving。

到这里，就要结束这一小节了，这里顺便再介绍下如果用 maven 跑测试的话怎么搞。

首先，我们往 surefire 插件中加上 javaagent：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.10</version>
    <configuration>
        <argLine>
            -javaagent:/xxx/aspectjweaver-1.8.13.jar
        </argLine>
        <useSystemClassLoader>true</useSystemClassLoader>
        <forkMode>always</forkMode>
    </configuration>
</plugin>

然后，我们就可以用 mvn test 看到织入效果了。还是那句话，不要用 IDE 进行测试，因为 IDE 太“智能”了。

小结

AspectJ 的三种织入方式中，个人觉得前面的两种会比较实用一些，因为第三种需要修改启动脚本，对于大型公司来说会比较不友好，需要专门找运维人员配置。

在实际生产中，我们用得最多的还是纯 Spring AOP，通过本文的介绍，相信大家对于 AspectJ 的使用应该也没什么压力了。

大家如果对于本文介绍的内容有什么不清楚的，请直接在评论区留言，如果对于 Spring + AspectJ 感兴趣的读者，碰到问题也可以在评论区和大家互动讨论。