AOP在Spring中的应用

一、什么是AOP<o:p></o:p>

为什么要区分J2EE容器(Tomcat,weblogic)和J2EE应用系统(开发的B/S架构的软件)？<o:p></o:p>

　　我们知道，J2EE应用系统只有部署在J2EE容器中才能运行，那么为什么划分为J2EE容器和J2EE应用系统(软件)？ 通过对J2EE容器运行机制的分析，我们可以发现：实际上J2EE容器分离了一般应用系统的一些通用功能，例如事务机制、安全机制以及对象池或线程池、日志、调试等性能优化机制。<o:p></o:p>

　　这些功能机制是每个应用系统几乎都需要的，因此可以从具体应用系统中分离出来，形成一个通用的框架平台[web应用服务器]，而且，这些功能机制的设计开发有一定难度，同时运行的稳定性和快速性都非常重要，必须经过长时间调试和运行经验积累而成，因此，形成了专门的J2EE容器服务器产品，如Tomcat 、JBoss、Resin、Websphere(Ibm)、WebLogic(Bea)、IAS(甲骨文)等。<o:p></o:p>

从J2EE系统划分为J2EE容器和J2EE应用系统两个方面，我们已经看到一种分散关注的思路（separation of concerns）。<o:p></o:p>

分散关注

　　将通用需求功能从不相关系统之中分离出来；同时，能够使得很多类共享一个功能行为(通用的类,通用的功能)，一旦功能行为发生变化，不必修改很多类，只要修改这个功能行为就可以。

　　 AOP就是这种实现分散关注的编程方法，它将“关注”封装在“方面”中。<o:p></o:p>

AOP是什么？<o:p></o:p>

　　AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP也是要实现该目标。<o:p></o:p>

　　举例：假设在一个应用系统中，有一个共享的数据必须被并发同时访问，首先，将这个数据封装在数据对象中，称为Data Class，同时，将有多个访问类，专门用于在同一时刻访问这同一个数据对象。<o:p></o:p>

　　为了完成上述并发访问同一资源的功能，需要引入锁Lock的概念，也就是说，某个时刻，当有一个访问类访问这个数据对象时，这个数据对象必须上锁Locked()(解锁)，用完后就立即解锁unLocked，再供其它并发的访问类访问。<o:p></o:p>

　　使用传统的编程习惯，我们会创建一个抽象类，所有的访问类继承这个抽象父类，如下：<o:p></o:p>

abstract class Worker{<o:p></o:p> 　　abstract void locked(); 　　abstract void accessDataObject(); 　　abstract void unlocked();<o:p></o:p> }<o:p></o:p>

<o:p> </o:p>

class AccessWorker extends Worker,Thread{ <o:p></o:p> abstract void locked(){<o:p></o:p> }<o:p></o:p> abstract void accessDataObject(){<o:p></o:p>   locked();<o:p></o:p>   、、、、、、具体访问代码<o:p></o:p>  unlocked();<o:p></o:p> }<o:p></o:p> abstract void unlocked(){<o:p></o:p> }<o:p></o:p> }<o:p></o:p>

<o:p> </o:p>

缺点： <o:p></o:p>

• accessDataObject()方法需要有“锁”状态之类的相关代码。 <o:p></o:p>
• Java只提供了单继承，因此具体访问类只能继承这个父类，如果具体访问类还要继承其它父类，比如另外一个如Worker的父类Thread，将无法方便实现。 <o:p></o:p>
• 重用被打折扣，具体访问类因为也包含“锁”状态之类的相关代码，只能被重用在相关有“锁”的场合，重用范围很窄。
  
  仔细研究这个应用的“锁”，它其实有下列特性： <o:p></o:p>
• “锁”功能不是具体访问类的首要或主要功能，访问类主要功能是访问数据对象，例如读取数据或更改动作。 <o:p></o:p>
• “锁”行为其实是和具体访问类的主要功能可以独立、区分开来的。 <o:p></o:p>
• “锁”功能其实是这个系统的一个纵向切面，涉及许多类、许多类的方法。如下图：
  <v:shapetype o:spt="75" coordsize="21600,21600" stroked="f" id="_x0000_t75" filled="f" o:preferrelative="t" path="m@4@5l@4@11@9@11@9@5xe"><v:stroke joinstyle="miter"></v:stroke><v:formulas><v:f eqn="if lineDrawn pixelLineWidth 0"></v:f><v:f eqn="sum @0 1 0"></v:f><v:f eqn="sum 0 0 @1"></v:f><v:f eqn="prod @2 1 2"></v:f><v:f eqn="prod @3 21600 pixelWidth"></v:f><v:f eqn="prod @3 21600 pixelHeight"></v:f><v:f eqn="sum @0 0 1"></v:f><v:f eqn="prod @6 1 2"></v:f><v:f eqn="prod @7 21600 pixelWidth"></v:f><v:f eqn="sum @8 21600 0"></v:f><v:f eqn="prod @7 21600 pixelHeight"></v:f><v:f eqn="sum @10 21600 0"></v:f></v:formulas><v:path gradientshapeok="t" o:extrusionok="f" o:connecttype="rect"></v:path><o:lock v:ext="edit" aspectratio="t"></o:lock></v:shapetype><v:shape type="#_x0000_t75" id="_x0000_i1025" alt="" style="WIDTH: 187.5pt; HEIGHT: 193.5pt"><v:imagedata o:href="file:///F:\文档精华(重要)\AOP是什么？什么是AOP.files\lock.png" src="file:///C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\msohtmlclip1\01\clip_image001.png"></v:imagedata></v:shape><o:p></o:p>

    因此，一个新的程序结构应该是关注系统的纵向切面，例如这个应用的“锁”功能，这个新的程序结构就是aspect（方面）<o:p></o:p>

　　在这个应用中，“锁”方面（aspect）应该有以下职责：<o:p></o:p>

　　提供一些必备的功能，对被访问对象实现加锁或解锁功能。以保证所有在修改数据对象的操作之前能够调用lock()加锁，在它使用完成后，调用unlock()解锁。<o:p></o:p>

AOP应用范围

　　很明显，AOP非常适合开发J2EE容器服务器，目前JBoss 4.0正是使用AOP框架进行开发。
　　具体通过AOP编程实现的功能如下：
Authentication 权限
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading　懒加载
Debugging　　调试
logging, tracing, profiling and monitoring　记录跟踪　优化　校准
Performance optimization　性能优化
Persistence　　持久化
Resource pooling　资源池<o:p></o:p>

Synchronization　同步<o:p></o:p>

Transactions 事务<o:p></o:p>

AOP有必要吗？<o:p></o:p>

　　当然，上述应用范例在没有使用AOP情况下，也得到了解决，例如JBoss 3.XXX也提供了上述应用功能，但是没有使用AOP。<o:p></o:p>

　　但是，使用AOP可以让我们从一个更高的抽象概念来理解软件系统，AOP也许提供一种有价值的工具。可以这么说：因为使用AOP结构，现在JBoss 4.0的源码要比JBoss 3.X容易理解多了，这对于一个大型复杂系统来说是非常重要的。<o:p></o:p>

　　从另外一个方面说，好像不是所有的人都需要关心AOP，它可能是一种架构设计的选择，如果选择J2EE系统，AOP关注的上述通用方面都已经被J2EE容器实现了，J2EE应用系统开发者可能需要更多地关注行业应用方面aspect。<o:p></o:p>

AOP具体实现<o:p></o:p>

　　AOP是一个概念，并没有设定具体语言的实现，它能克服那些只有单继承特性语言的缺点（如Java），目前AOP具体实现有以下几个项目(支持环境)：<o:p></o:p>

　　AspectJ (TM)：　创建于Xerox PARC. 有近十年历史，成熟
　　缺点：过于复杂；破坏封装；需要专门的Java编译器。<o:p></o:p>

动态AOP：使用JDK的动态代理API或字节码Bytecode处理技术.

二、需求实现<o:p></o:p>

以上面(一、AOP是什么)当中的并发访问数据的应用为例子：

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

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

首先，我们需要一个锁，这个锁可以是数据对象中一个属性或其它，这里使用Doug Lea的ReentrantWriterPreferenceReadWriteLock作为我们的锁资源。<o:p></o:p>

这是一个访问类<o:p></o:p>

import EDU.oswego.cs.dl.util.concurrent.*;<o:p></o:p> public class Worker extends Thread {<o:p></o:p> 　　Data data;//要访问的数据<o:p></o:p> 　　ReentrantWriterPreferenceReadWriteLock rwl =　 　　　　new ReentrantWriterPreferenceReadWriteLock(); 　　public boolean createData() { 　　　try { 　　　　rwl.writeLock().acquire();　//上锁 　　　　//对data实行写逻辑操作　 　　　　　　　 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　 　 rwl.writeLock().release(); 　//解锁 　　　} 　　　return true; 　　} 　　public boolean updateData() { 　　　try { 　　　　rwl.writeLock().acquire();//上锁 　　　　//对data实行写逻辑操作　 　　　　　　　 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　 　 rwl.writeLock().release(); //解锁 　　　} 　　　return true; 　　} 　　public void run() { 　　　　//执行createData()或updateData() 　　} }<o:p></o:p>

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

import EDU.oswego.cs.dl.util.concurrent.*;<o:p></o:p> public class AnotherWorker extends Thread {<o:p></o:p> 　　Data data; 　　ReentrantWriterPreferenceReadWriteLock rwl =　 　　　　new ReentrantWriterPreferenceReadWriteLock(); 　　 　　public boolean updateData() { 　　　try { 　　　　rwl.writeLock().acquire();//上锁 　　　　//对data实行写逻辑操作　 　　　　　　　 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　 　 rwl.writeLock().release(); //解锁 　　　} 　　　return true; 　　} 　　public void run() { 　　　　//执行updateData() 　　} }<o:p></o:p>

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

<o:p></o:p>

<v:shape type="#_x0000_t75" id="_x0000_i1026" alt="" style="WIDTH: 187.5pt; HEIGHT: 193.5pt"><v:imagedata o:href="file:///F:\文档精华(重要)\AOP学习资源和AspectJ.files\aop1.png" src="file:///C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\msohtmlclip1\01\clip_image004.png"></v:imagedata></v:shape><o:p></o:p>

这种实现方式的缺点很多：<o:p></o:p>

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

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

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

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

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

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

<o:p>    </o:p>

<v:shape type="#_x0000_t75" id="_x0000_i1027" alt="" style="WIDTH: 187.5pt; HEIGHT: 193.5pt"><v:imagedata o:href="file:///F:\文档精华(重要)\AOP学习资源和AspectJ.files\aop2.png" src="file:///C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\msohtmlclip1\01\clip_image006.png"></v:imagedata></v:shape><o:p></o:p>

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

AspectJ实现<o:p></o:p>

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

public pointcut 方法名：call(XXXX)<o:p></o:p>

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

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

public class MyClass{
　　//属性和方法 ...
}<o:p></o:p>

　　同样，建立一个Aspect的Class代码如下：<o:p></o:p>

public aspect MyAspect{
　　//属性和方法 ...
}<o:p></o:p>

建立一个AspectJ名为Lock，代码如下：<o:p></o:p>

import EDU.oswego.cs.dl.util.concurrent.*;<o:p></o:p> public aspect Lock { 　　...... 　　ReentrantWriterPreferenceReadWriteLock rwl =　 　　　　new ReentrantWriterPreferenceReadWriteLock(); <o:p></o:p> 　　public pointcut writeOperations(): 　　　　execution(public boolean Worker.createData()) || 　　　　execution(public boolean Worker.updateData()) || 　　　　execution(public boolean AnotherWorker.updateData()) ; 　　before() : writeOperations() { 　　　　rwl.writeLock().acquire();    //上锁　advice body 　　}<o:p></o:p> after() : writeOperations() { 　　 　 rwl.writeLock().release();     //解锁 advice body 　　}<o:p></o:p> <o:p> </o:p> arround():writeOperations(){<o:p></o:p>    println();<o:p></o:p> }<o:p></o:p> 　　...... }<o:p></o:p>

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

　　before代表触发之前做什么事情？
　　答案是上锁。 <o:p></o:p>

　　after代表触发之后做什么事情？
　　答案是解锁。 <o:p></o:p>

　　通过引入上述aspect，那么Worker代码可以清洁如下：<o:p></o:p>

public class Worker extends Thread {<o:p></o:p> 　　Data data; 　　public boolean createData() { 　　　try { 　　　　//对data实行写逻辑操作　　　　　　　　 　　　}catch() { 　　 　 return false; 　　　} 　　　return true; 　　} 　　public boolean updateData() { 　　　try { 　　　　//对data实行写逻辑操作　　　　　　　　 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　　} 　　　return true; 　　} 　　public void run() { 　　　　//执行createData()或updateData() 　　} }<o:p></o:p>

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

AOP术语<o:p></o:p>

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

　　Pointcut类似触发器，是事件Event发生源，一旦pointcut被触发，将会产生相应的动作Action(对于本例来说指的是:rwl.writeLock().acquire();和rwl.writeLock().release())，这部分Action称为Advice。<o:p></o:p>

　　Advice（action或功能）在AspectJ有三种：before、 after、Around之分，上述aspect Lock代码中使用了Advice的三种before、after、arround。<o:p></o:p>

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

<v:shape type="#_x0000_t75" id="_x0000_i1028" alt="" style="WIDTH: 187.5pt; HEIGHT: 193.5pt"><v:imagedata o:href="file:///F:\文档精华(重要)\AOP学习资源和AspectJ.files\aop3.png" src="file:///C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\msohtmlclip1\01\clip_image008.png"></v:imagedata></v:shape><o:p></o:p>

小结如下：
advice - 真正的执行代码，或者说关注(焦点即pointcut被执行了，通过拦截器得知)的实现。 类似Action。<o:p></o:p>

  关注焦点(pointcut)被执行了，通过拦截器得知，那么这个时候执行一个advice(执行事务或日志信息)<o:p></o:p>

join point - 代码中激活advice被执行的触发点。
pointcut - 一系列的join point称为pointcut，pointcut有时代指join point<o:p></o:p>