Spring AOP详解

AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。

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

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

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

　　abstract class Worker{

　　abstract void locked();

　　abstract void accessDataObject();

　　abstract void unlocked();

　　}

　　缺点：

　　* accessDataObject()方法需要有“锁”状态之类的相关代码。

　　* Java只提供了单继承，因此具体访问类只能继承这个父类，如果具体访问类还要继承其它父类，比如另外一个如Worker的父类，将无法方便实现。

　　* 重用被打折扣，具体访问类因为也包含“锁”状态之类的相关代码，只能被重用在相关有“锁”的场合，重用范围很窄。

　　仔细研究这个应用的“锁”，它其实有下列特性：

　　* “锁”功能不是具体访问类的首要或主要功能，访问类主要功能是访问数据对象，例如读取数据或更改动作。

　　“锁”行为其实是和具体访问类的主要功能可以独立、区分开来的

　　“锁”功能其实是这个系统的一个纵向切面，涉及许多类、许多类的方法。

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

　　在这个应用中，“锁”方面（aspect）应该有以下职责：

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

　　AOP应用范围

　　很明显，AOP非常适合开发J2EE容器服务器，目前JBoss 4.0正是使用AOP框架进行开发。

　　具体功能如下：

　　Authentication 权限

　　Caching 缓存

　　Context passing 内容传递

　　Error handling 错误处理

　　Lazy loading　懒加载

　　Debugging　　调试

　　logging, tracing, profiling and monitoring　记录跟踪　优化　校准

　　Performance optimization　性能优化

　　Persistence　　持久化

　　Resource pooling　资源池

　　Synchronization　同步

　　Transactions 事务

　　AOP有必要吗？

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

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

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

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------

此前对于AOP的使用仅限于声明式事务，除此之外在实际开发中也没有遇到过与之相关的问题。最近项目中遇到了以下几点需求，仔细思考之后，觉得采用AOP来解决。一方面是为了以更加灵活的方式来解决问题，另一方面是借此机会深入学习SpringAOP相关的内容。本文是权当本人的自己AOP学习笔记，以下需求不用AOP肯定也能解决，至于是否牵强附会，仁者见仁智者见智。

1. 对部分函数的调用进行日志记录，用于观察特定问题在运行过程中的函数调用情况
2. 监控部分重要函数，若抛出指定的异常，需要以短信或邮件方式通知相关人员
3. 金控部分重要函数的执行时间

事实上，以上需求没有AOP也能搞定，只是在实现过程中比较郁闷摆了。

1. 需要打印日志的函数分散在各个包中，只能找到所有的函数体，手动添加日志。然而这些日志都是临时的，待问题解决之后应该需要清除打印日志的代码，只能再次手动清除^_^!
2. 类似1的情况，需要捕获异常的地方太多，如果手动添加时想到很可能明天又要手动清除，只能再汗。OK，该需求相对比较固定，属于长期监控的范畴，并不需求临时添加后再清除。然而，客户某天要求，把其中20%的异常改为短信提醒，剩下的80%改用邮件提醒。改之，两天后，客户抱怨短信太多，全部改成邮件提醒...
3. 该需求通常用于监控某些函数的执行时间，用以判断系统执行慢的瓶颈所在。瓶颈被解决之后，烦恼同情况1

终于下定决心，采用AOP来解决！代码如下：

切面类TestAspect

packagecom.spring.aop;
/**
*切面
*
*/
publicclassTestAspect{

publicvoiddoAfter(JoinPointjp){
System.out.println("logEndingmethod:"
+jp.getTarget().getClass().getName()+"."
+jp.getSignature().getName());
}

publicObjectdoAround(ProceedingJoinPointpjp)throwsThrowable{
longtime=System.currentTimeMillis();
ObjectretVal=pjp.proceed();
time=System.currentTimeMillis()-time;
System.out.println("processtime:"+time+"ms");
returnretVal;
}

publicvoiddoBefore(JoinPointjp){
System.out.println("logBeginingmethod:"
+jp.getTarget().getClass().getName()+"."
+jp.getSignature().getName());
}

publicvoiddoThrowing(JoinPointjp,Throwableex){
System.out.println("method"+jp.getTarget().getClass().getName()
+"."+jp.getSignature().getName()+"throwexception");
System.out.println(ex.getMessage());
}

privatevoidsendEx(Stringex){
//TODO发送短信或邮件提醒
}
}

packagecom.spring.service;
/**
*接口A
*/
publicinterfaceAService{

publicvoidfooA(String_msg);

publicvoidbarA();
}

packagecom.spring.service;
/**
*接口A的实现类
*/
publicclassAServiceImplimplementsAService{

publicvoidbarA(){
System.out.println("AServiceImpl.barA()");
}

publicvoidfooA(String_msg){
System.out.println("AServiceImpl.fooA(msg:"+_msg+")");
}
}

packagecom.spring.service;

/**
*Service类B
*/
publicclassBServiceImpl{

publicvoidbarB(String_msg,int_type){
System.out.println("BServiceImpl.barB(msg:"+_msg+"type:"+_type+")");
if(_type==1)
thrownewIllegalArgumentException("测试异常");
}

publicvoidfooB(){
System.out.println("BServiceImpl.fooB()");
}

}

ApplicationContext

<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"
default-autowire="autodetect">
<aop:config>
<aop:aspectid="TestAspect"ref="aspectBean">
<!--配置com.spring.service包下所有类或接口的所有方法-->
<aop:pointcutid="businessService"
expression="execution(*com.spring.service.*.*(..))"/>
<aop:beforepointcut-ref="businessService"method="doBefore"/>
<aop:afterpointcut-ref="businessService"method="doAfter"/>
<aop:aroundpointcut-ref="businessService"method="doAround"/>
<aop:after-throwingpointcut-ref="businessService"method="doThrowing"throwing="ex"/>
</aop:aspect>
</aop:config>

<beanid="aspectBean"class="com.spring.aop.TestAspect"/>
<beanid="aService"class="com.spring.service.AServiceImpl"></bean>
<beanid="bService"class="com.spring.service.BServiceImpl"></bean>

</beans>

测试类AOPTest

publicclassAOPTestextendsAbstractDependencyInjectionSpringContextTests{

privateAServiceaService;

privateBServiceImplbService;

protectedString[]getConfigLocations(){
String[]configs=newString[]{"/applicationContext.xml"};
returnconfigs;
}


/**
*测试正常调用
*/
publicvoidtestCall()
{
System.out.println("SpringTestJUnittest");
aService.fooA("JUnittestfooA");
aService.barA();
bService.fooB();
bService.barB("JUnittestbarB",0);
}

/**
*测试After-Throwing
*/
publicvoidtestThrow()
{
try{
bService.barB("JUnitcallbarB",1);
}catch(IllegalArgumentExceptione){

}
}

publicvoidsetAService(AServiceservice){
aService=service;
}

publicvoidsetBService(BServiceImplservice){
bService=service;
}
}

运行结果如下：

logBeginingmethod:com.spring.service.AServiceImpl.fooA
AServiceImpl.fooA(msg:JUnittestfooA)
logEndingmethod:com.spring.service.AServiceImpl.fooA
processtime:0ms
logBeginingmethod:com.spring.service.AServiceImpl.barA
AServiceImpl.barA()
logEndingmethod:com.spring.service.AServiceImpl.barA
processtime:0ms
logBeginingmethod:com.spring.service.BServiceImpl.fooB
BServiceImpl.fooB()
logEndingmethod:com.spring.service.BServiceImpl.fooB
processtime:0ms
logBeginingmethod:com.spring.service.BServiceImpl.barB
BServiceImpl.barB(msg:JUnittestbarBtype:0)
logEndingmethod:com.spring.service.BServiceImpl.barB
processtime:0ms

logBeginingmethod:com.spring.service.BServiceImpl.barB
BServiceImpl.barB(msg:JUnitcallbarBtype:1)
logEndingmethod:com.spring.service.BServiceImpl.barB
methodcom.spring.service.BServiceImpl.barBthrowexception
测试异常

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Spring中AOP

链接地址

http://www.cnblogs.com/frankliiu-java/archive/2010/01/05/1639664.html