AOP和AspectJ

墨蓝 2022-08-23 13:54 192阅读 0赞

需求和问题

以上篇《[AOP是什么][AOP]》中并发访问应用为例子：

多个访问类同时访问一个共享数据对象时，每个访问类在访问这个数据对象时，需要将数据对象上锁，访问完成后，再实行解锁，供其它并发线程访问，这是我们处理并发访问资源的方式。

为了实现这个需求，先实现传统的编程，这里我们假定有一个写锁，对数据对象实行写之前，首先对这个对象进行上写锁，写操作完毕后，必须释放写锁。

首先，我们需要一个锁，这个锁可以是数据对象中一个字段或其它，这里使用[Doug Le][]a的[ReentrantWriterPreferenceReadWriteLock][]作为我们的锁资源。

<table style="font-size:13px; line-height:20px; font-family:'Helvetica Neue',Helvetica,Arial,sans-serif; color:rgb(0,0,0); letter-spacing:0.5px"> 
 <tbody> 
 <tr> 
 <td style="font-size:13px; font-family:'Helvetica Neue',Helvetica,Arial,sans-serif"> import EDU.oswego.cs.dl.util.concurrent.*; public class Worker extends Thread { 　　Data data; 　　ReentrantWriterPreferenceReadWriteLock rwl =　 　　　　new ReentrantWriterPreferenceReadWriteLock();&nbsp; 　　public boolean createData() { 　　　try { 　　　　rwl.writeLock().acquire();　//上锁 　　　　//对data实行写逻辑操作　 　　　　　　　&nbsp; 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　 　 rwl.writeLock().release(); 　//解锁 　　　} 　　　return true; 　　} 　　public boolean updateData() { 　　　try { 　　　　rwl.writeLock().acquire();//上锁 　　　　//对data实行写逻辑操作　 　　　　　　　&nbsp; 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　 　 rwl.writeLock().release(); //解锁 　　　} 　　　return true; 　　} 　　public void run() { 　　　　//执行createData()或updateData() 　　} } 
 <div> 
 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

假设可能存在另外一个访问类，也将对数据对象实现写操作，代码如下：

<table style="font-size:13px; line-height:20px; font-family:'Helvetica Neue',Helvetica,Arial,sans-serif; color:rgb(0,0,0); letter-spacing:0.5px"> 
 <tbody> 
 <tr> 
 <td style="font-size:13px; font-family:'Helvetica Neue',Helvetica,Arial,sans-serif"> import EDU.oswego.cs.dl.util.concurrent.*; public class AnotherWorker extends Thread { 　　Data data; 　　ReentrantWriterPreferenceReadWriteLock rwl =　 　　　　new ReentrantWriterPreferenceReadWriteLock();&nbsp; 　　 　　public boolean updateData() { 　　　try { 　　　　rwl.writeLock().acquire();//上锁 　　　　//对data实行写逻辑操作　 　　　　　　　&nbsp; 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　 　 rwl.writeLock().release(); //解锁 　　　} 　　　return true; 　　} 　　public void run() { 　　　　//执行updateData() 　　} } </td> 
 </tr> 
 </tbody> 
</table>

以上是Java传统编程的实现，这种锁的实现方式是在每个具体类中实现，如下图：

<table style="font-size:13px; line-height:20px; font-family:'Helvetica Neue',Helvetica,Arial,sans-serif; color:rgb(0,0,0); letter-spacing:0.5px"> 
 <tbody> 
 <tr> 
 <td style="font-size:13px; font-family:'Helvetica Neue',Helvetica,Arial,sans-serif"> import EDU.oswego.cs.dl.util.concurrent.*; public class AnotherWorker extends Thread { 　　Data data; 　　ReentrantWriterPreferenceReadWriteLock rwl =　 　　　　new ReentrantWriterPreferenceReadWriteLock();&nbsp; 　　 　　public boolean updateData() { 　　　try { 　　　　rwl.writeLock().acquire();//上锁 　　　　//对data实行写逻辑操作　 　　　　　　　&nbsp; 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　 　 rwl.writeLock().release(); //解锁 　　　} 　　　return true; 　　} 　　public void run() { 　　　　//执行updateData() 　　} } </td> 
 </tr> 
 </tbody> 
</table>

以上是Java传统编程的实现，这种锁的实现方式是在每个具体类中实现，如下图：

![aop1.png][]

这种实现方式的缺点很多：

*  冗余：有很多重复的编码，如rwl.writeLock().acquire()等；
 *  减少重用：worker的updateData()方法重用性几乎为零。
 *  "数据对象写操作必须使用锁控制这个设计目的"不容易显现，如果更换了一个新的程序员，他可能编写一段不使用锁机制就对这个数据对象写操作的代码。
 *  如果上述代码有读功能，那么我们需要在代码中实现先上读锁，当需要写时，解读锁，再上写锁等等，如果稍微不小心，上锁解锁次序搞错，系统就隐含大的BUG，这种可能性会随着这个数据对象永远存在下去，系统设计大大的隐患啊！

那么我们使用AOP概念来重新实现上述需求，AOP并没有什么新花招，只是提供了观察问题的一个新视角度。

这里我们可以抛开新技术迷人雾障，真正核心还是新思维、新视点，人类很多问题如果换一个脑筋看待理解，也许结果真的是翻天覆地不一样啊，所以，作为人自身，首先要重视和你世界观和思维方式不一样的人进行交流和沟通。

现实生活中有很多"不公平"，例如某个小学毕业生成了千万富翁，你就怀疑知识无用，也许你认为他的机会好，其实你可能不知道，他的观察问题的视角比你独特，或者他可能会经常换不同的角度来看待问题和解决问题，而你由于过分陷入一个视角的具体实现细节中，迷失了真正的方向，要不说是读书人脑子僵化呢？

言归正传，我们看看AOP是如何从一个新的视角解决上述问题的。

如果说上面代码在每个类中实现上锁或解锁，类似横向解决方式，那么AOP是从纵向方面来解决上述问题，纵向解决之道示意图如下：

![aop2.png][]

AOP把这个纵向切面cross-cuts称为Aspect（方面），其实我认为AOP翻译成**面向切面编程**比较好，不知哪个糊涂者因为先行一步，翻译成“面向方面编程”如此抽象，故弄玄虚。

**AspectJ实现**

下面我们使用AOP的实现之一AspectJ来对上述需求改写。AspectJ是AOP最早成熟的Java实现，它稍微扩展了一下Java语言，增加了一些Keyword等，pointcut的语法如下：

public pointcut 方法名：call(XXXX)

AspectJ增加了pointcut, call是pointcut类型，有关AspectJ更多基本语法见[这里][Link 1]。因为AspectJ使用了一些特别语法，所以Java编译器就不能用SUN公司提供javac了，必须使用其专门的编译器，也许SUN在以后JDK版本中会引入AOP。

使用AspectJ如何实现上图所谓切面式的编程呢？首先,我们将上图纵向切面称为Aspect，那么我们建立一个类似Class的Aspect，Java中建立一个Class代码如下：

public class MyClass\{  
　　//属性和方法 ...  
\}

同样，建立一个Aspect的代码如下：

public aspect MyAspect\{  
　　//属性和方法 ...  
\}

建立一个Aspect名为Lock，代码如下：

<table style="font-size:13px; line-height:20px; font-family:'Helvetica Neue',Helvetica,Arial,sans-serif; color:rgb(0,0,0); letter-spacing:0.5px"> 
 <tbody> 
 <tr> 
 <td style="font-size:13px; font-family:'Helvetica Neue',Helvetica,Arial,sans-serif"> import EDU.oswego.cs.dl.util.concurrent.*; public aspect Lock { 　　...... 　　ReentrantWriterPreferenceReadWriteLock rwl =　 　　　　new ReentrantWriterPreferenceReadWriteLock(); 　　public&nbsp;pointcut&nbsp;writeOperations():&nbsp; 　　　　execution(public boolean Worker.createData()) || 　　　　execution(public boolean Worker.updateData()) || 　　　　execution(public boolean AnotherWorker.updateData()) ; 　　before() :&nbsp;writeOperations() {&nbsp; 　　　　rwl.writeLock().acquire();//上锁　advice body 　　} 　　after() :&nbsp;writeOperations() { 　　 　 rwl.writeLock().release(); //解锁 advice body 　　} 　　...... } </td> 
 </tr> 
 </tbody> 
</table>

上述代码关键点是pointcut，意味切入点或触发点，那么在那些条件下该点会触发呢？是后面红字标识的一些情况，在执行Worker的createData()方法，Worker的update方法等时触发。

before代表触发之前做什么事情？  
　　答案是上锁。

after代表触发之后做什么事情？  
　　答案是上锁。

通过引入上述aspect，那么Worker代码可以清洁如下：

Worker中关于“锁”的代码都不见了，纯粹变成了数据操作的主要方法。

**AOP术语**

通过上例已经知道AspectJ如何从切面crosscutting来解决并发访问应用需求的，其中最重要的是引入了一套类似事件触发机制。

Pointcut类似触发器，是事件Event发生源，一旦pointcut被触发，将会产生相应的动作Action，这部分Action称为Advice。

Advice在AspectJ有三种：before、 after、Around之分，上述aspect Lock代码中使用了Advice的两种before和after。

所以AOP有两个基本的术语：Pointcut和Advice。你可以用事件机制的Event和Action来类比理解它们。上述并发访问应用中pointcut和advice如下图所示：

![aop3.png][]

小结如下：  
advice - 真正的执行代码，或者说关注的实现。 类似Action。  
join point - 代码中激活advice被执行的触发点。  
pointcut - 一系列的join point称为pointcut，pointcut有时代指join point

其中advice部分又有：  
Interceptor - 解释器并没有在AspectJ出现，在使用JDK动态代理API实现的AOP框架中使用，解释有方法调用或对象构造或者字段访问等事件，是调用者和被调用者之间的纽带，综合了Decorator/代理模式甚至职责链等模式。

Introduction - 修改一个类，以增加字段、方法或构造或者执行新的接口，包括Mixin实现。

例如上述并发访问应用中，如果想为每个Data对象生成相应的aspect Lock，那么可以在aspect Lock中人为数据对象增加一个字段lock，如下：

上述代码等于在Data类中加入一行：

还有其它两个涉及AOP代码运行方式：

weaving - 将aspect代码插入到相应代码中的过程，一般是编译完成或在运行时动态完成。取决于具体AOP产品，例如AspectJ是使用特殊编译器在编译完成weaving，而nanning、JBoss AOP是使用动态代理API，因此在运行时动态完成weaving的。  
instrumentor - 用来实现weaving功能的工具。

<table style="font-size:13px; line-height:20px; font-family:'Helvetica Neue',Helvetica,Arial,sans-serif; color:rgb(0,0,0); letter-spacing:0.5px"> 
 <tbody> 
 <tr> 
 <td style="font-size:13px; font-family:'Helvetica Neue',Helvetica,Arial,sans-serif"> import EDU.oswego.cs.dl.util.concurrent.*; public class AnotherWorker extends Thread { 　　Data data; 　　ReentrantWriterPreferenceReadWriteLock rwl =　 　　　　new ReentrantWriterPreferenceReadWriteLock();&nbsp; 　　 　　public boolean updateData() { 　　　try { 　　　　rwl.writeLock().acquire();//上锁 　　　　//对data实行写逻辑操作　 　　　　　　　&nbsp; 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　 　 rwl.writeLock().release(); //解锁 　　　} 　　　return true; 　　} 　　public void run() { 　　　　//执行updateData() 　　} } </td> 
 </tr> 
 </tbody> 
</table>

以上是Java传统编程的实现，这种锁的实现方式是在每个具体类中实现，如下图：

[AOP]: http://www.jdon.com/AOPdesign/jdon-aop.htm
[Doug Le]: http://gee.cs.oswego.edu/dl/
[ReentrantWriterPreferenceReadWriteLock]: http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/ReentrantWriterPreferenceReadWriteLock.html
[aop1.png]: /images/20220823/69ca4b0b9b714900890b96e2f7b0dd63.png
[aop2.png]: /images/20220823/034658dbc2984d1799ffd09d9aea48d6.png
[Link 1]: http://today.java.net/pub/a/today/2003/12/26/ch3AspectJSyntaxBasics.html
[aop3.png]: /images/20220823/eb7148d23e894481bc0fd1a953e2f143.png