AspectJ可以说是Java中当之无愧的黑魔法。说它是黑魔法，一方面是因为它很强大，能够解决一些传统编程方法论解决不了的问题，而另一方面，它也相当的晦涩，有着比较陡峭的学习曲线。

本文将带大家探索下AspectJ是什么，能做什么，以及如何来做，希望通过本文能够让大家初窥AspectJ之门道

相信很多人第一次听说AOP是在学习spring的时候，笔者也是。这个概念其实困扰了我很久，到底是AOP？AOP是Aspect Oriented Programming的缩写，和OOP(Object Oriented Programming)一样，都代表一种编程思想。不同的是，OOP是对世界万物的抽象，而AOP做的则是对业务处理过程的抽象，一定程度上说，AOP是OOP思想的一种延续，对程序进行了进一步的封装。

那么AOP到底能够解决什么问题呢？以在现有系统上增加一个安全策略为例，我们需要在各个模块的代码中不同地方添加代码，进行安全策略的检查。这种方式实现起来很复杂，容易出错，而且没法复用。这里描述的安全问题就是一个横切关注点问题，开发者需要找到所有需要关注的代码断，在现有代码中间插入新的业务代码(就好像对现有代码做了切分)。类似这里安全策略的问题还有很多，比如tracing等。

AspectJ是AOP的Java实现版本，定义了AOP的语法，可以说是对Java的一个扩展。相对于Java，AspectJ引入了join point(连接点)的概念，同时引入三个新的结构，pointcut(切点)， advice(通知)，inter-type declaration(跨类型声明)以及aspect。其中pointcut和advice是AspectJ中动态额部分，用来指定在什么条件下切断执行，以及采取什么动作来实现切面操作。顾名思义，这里的pointcut就是用来定义什么情况下进行横切，而advice则是指横切情况下我们需要做什么操作，所以说pointcut和advice会动态的影响程序的运行流程。从某种角度上说，pointcut(切点)和我们平时用IDE调试程序时打的断点很类似，当程序执行到我们打的断点的地方的时候(运行到满足我们定义的pointcut的语句的时候，也就是join point连接点)，我们可以执行一段脚本（执行advice中定义的行为）。

而AspectJ中的inter-type declaration(跨类型声明)则是AspectJ中静态的部分，它影响的是程序的静态结构，比如成员变量，类之间的关系等。Aspect则是对前三个结构的封装，类似于java中的类。

这里我们先不去具体探讨AspectJ的语法问题，而重点关注如何用AspectJ写一个简单的Demo。这里我用的开发环境是IntelliJ，且项目使用maven来构建。

要运行AspectJ程序，首先要引入AspectJ运行时的依赖：

  1. <!--aspectj runtime classes -->
  2. <dependency>
  3.     <groupId>org.aspectj</groupId>
  4.     <artifactId>aspectjrt</artifactId>
  5.     <version>1.8.9</version>
  6. </dependency>

除了运行时依赖，还需要aspectjweaver.jar：

  1. <!--to introduce aspect to java class in load time-->
  2. <dependency>
  3.     <groupId>org.aspectj</groupId>
  4.     <artifactId>aspectjweaver</artifactId>
  5.     <version>1.8.9</version>
  6. </dependency>

先写一个简单的类：

  1. package cc.databus.aspect;
  3. public class Account {
  4.     double balance = 200;
  6.     public boolean withdraw(int amount) {
  7.         if (balance < amount) {
  8.             return false;
  9.         }
  10.         balance = balance - amount;
  11.         return true;
  12.     }
  14.     @Override
  15.     public String toString() {
  16.         return "Account{" +
  17.                 "balance=" + balance +
  18.                 '}';
  19.     }
  20. }

该类定义了一个Account类，并提供了withdraw（取款）的方法。

创建一个AccountAspect.aj文件来记录取款前后的信息：

  1. // aspect 
  2. package cc.databus.aspect;
  4. public aspect AccountAspect {
  6.     // define a pointcut to pick up invoking Accont.withdraw 
  7.     pointcut callWithDraw(int amount, Account account):
  8.             call(boolean Account.withdraw(int)) 
  9.             && args(amount) 
  10.             && target(account);
  12.     // advice definition executing before enterring method body
  13.     before(int amount, Account acc): callWithDraw(amount, acc) {
  14.         System.out.println("Start withdraw " + amount + " from " + acc);
  15.     }
  18.     after(int amount, Account acc) returning (Object ret): callWithDraw(amount, acc) {
  19.         System.out.print("Finish withdraw, return " 
  20.         + ret +", account after withdraw is: " +  acc);
  21.     }
  22. }

通过IntelliJ可以很方便的创建aspect文件，在包上面右键->New->Aspect：

正如你所见，上面的AccountAspect.aj定义了AspectJ的pointcut，advice以及aspect。

Weaving….很奇怪的词。。。这里指的是将aspect中定义的advice植入到运行时的过程。这里我们使用一个maven插件来讲aspect织如，这个插件是Mojo AspectJ Maven Plugin:

  1. <plugins>
  2.     <plugin>
  3.         <groupId>org.codehaus.mojo</groupId>
  4.         <artifactId>aspectj-maven-plugin</artifactId>
  5.         <version>1.7</version>
  6.         <configuration>
  7.             <complianceLevel>1.8</complianceLevel>
  8.             <source>1.8</source>
  9.             <target>1.8</target>
  10.             <showWeaveInfo>true</showWeaveInfo>
  11.             <verbose>true</verbose>
  12.             <encoding>utf-8</encoding>
  13.         </configuration>
  14.         <executions>
  15.             <execution>
  16.                 <goals>
  17.                     <!--use this goal to weave all your main classes-->
  18.                     <goal>compile</goal>
  19.                     <!--use this goal to weave all your test classes-->
  20.                     <goal>test-compile</goal>
  21.                 </goals>
  22.             </execution>
  23.         </executions>
  24.     </plugin>
  25. </plugins>

OK，下面我们写一个UT来测试下aspect是否生效了：

  1. import cc.databus.aspect.Account;
  2. import org.junit.Before;
  3. import org.junit.Test;
  5. import static org.junit.Assert.assertFalse;
  6. import static org.junit.Assert.assertTrue;
  8. public class TestAccount {
  10.     private Account account;
  12.     @Before
  13.     public void before() {
  14.         account = new Account();
  15.     }
  17.     @Test
  18.     public void given20AndMin10_whenWithdraw5_thenSuccess() {
  19.         assertTrue(account.withdraw(5));
  20.     }
  21.     
  22.     @Test
  23.     public void given20AndMin10_whenWithdraw100_thenFail() {
  24.         assertFalse(account.withdraw(100));
  25.     }
  26. }

运行测试，如果命令行有如下的输出，则表示aspect成功织入我们的代码，并且pointcut成功切入了Account.withdraw的调用：

  1. Start withdraw 5 from Account{balance=200.0}
  2. Finish withdraw, return true, account after withdraw is: Account{balance=195.0}
  3. Process finished with exit code 0

总的来说，AspectJ是一个相当晦涩难懂的技术，但是不得不承认它很强大。本文在从理论出发，先介绍AOP以及AspectJ的基本概念，然后以一个简单的Demo程序介绍了如何在项目中使用AspectJ。

文章同步发布在我的个人博客https://jianyuan.me上，欢迎拍砖。
传送门： 初窥AspectJ

版权声明：本文为yflog原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/yflog/p/9582421.html