一、
AOP
介绍
AOP
提供了另外一种思考程序结构的角度,弥补了
OOP
(面向对象编程)的不足。大家可以参看夏昕编写的《
Spring
开发指南》中的
AOP
部分,有简单明晰的对比和解释。就像刚开始理解
OO
概念一样,对于新手来说
AOP
也是非常抽象难以理解的,不能仅从一个概念上去定义
AOP
。假如我们有一个系统,分为好多个模块,每个模块都负责处理一项重要的功能。但是每个模块都需要一些相似的辅助功能如安全、日志输出等等。这就是一种交叉业务,而这种
“
交叉
”
非常适合用
AOP
来解决。(在
AOP
刚出现的时候被大家翻译成面向方面,而后来一部分人翻译成面向切面。谁更正确?也许在真正理解了
AOP
以后才能判断出来。)
1
.
AOP
术语
l
切面(
Aspect
):切面是你要实现的交叉功能。它是应用系统模块化的一个切面领域。
l
连接点(
Join point
):连接点是应用程序执行过程中插入切面的地点(在程序执行过程中某个特定的点)。在
Spring AOP
中一个连接点代表一个方法的执行。这个点可以是方法调用,异常抛出或者是要修改的字段。通过申明一个
import
org.aspectj.lang.JoinPoint
类型的参数可以使通知(
Advice
)的主体部分获得连接点信息。
l
通知
(
Advice
):通知切面的实际实现(参考手册:
Action taken by an aspect at a particular join point.
)。它通知应用系统新的行为。通知包括好多种类,在后面单独列出。(
Advice
一词在夏昕的《
Spring
开发指南》中被翻译为
“
处理逻辑
”
)
l
切入点(
Pointcut
):切入点定义了通知应该应用在哪些连接点。通知(
Advice
)可以应用到
AOP
的任何连接点。通知(
Advice
)将和一个切入点表达式关联,并在满足这个连接点的切入点上运行(例如:在执行一个特定名称的方法时)切入点表达式如何和连接点匹配是
AOP
的核心
Spring
使用缺省的
AspectJ
切入点的语法。
l
引入(
Introduction
):(也被叫做内部类型声明
“inter-type declaration”
)引入允许你为已经存在的类添加新的方法和属性。
Spring
允许引入新的接口(以及一个对应的实现)到任何被代理的对象。
l
目标对象(
Target Object
):目标对象是被通知对象。
Spring AOP
是运行时代里实现的,所以这个对象永远是一个被代理对象。
l
AOP
代理(
AOP Proxy
):代理是将通知(
Advice
)应用到目标对象后创建的对象。在
Spring2.0
中对于使用最新引入的基于模式(
schema-based
)风格和
@AspectJ
风格切面声明的用户来说,代理的创建是透明的。(要理解这里的代理
“Proxy”
,需要理解代理
“Proxy”
模式:
http://blog.csdn.net/qutr/archive/2006/07/27/987253.aspx
)
l
织入(
Weaving
):
把切面(
Aspect
)连接到其它的应用程序类型或者对象上来创建一个被通知(
advised
)的对象。可以在编译时做这件事(例如使用
AspectJ
编译器),也可以在类加载或运行时完成。
Spring
和其他纯
Java AOP
框架一样,
在运行时完成织入。
通知(
Advice
)类型:
l
前置通知(
Before Advice
):在一个连接点之前执行的通知,但这个通知不能阻止连接点钱的执行(除非它抛出异常)
l
返回后通知(
After returning advice
):在一个连接点正常完成后执行的通知。例如:一个方法正常返回,没有抛出任何异常。
l
抛出后通知(
After throwing advice
):在一个方法抛出异常时执行的通知。
l
Finally
后通知(
After finally advice
):当某连接点退出的时候执行的通知(不论是正常返回还是抛出异常)。
l
环绕通知(
Around advice
):包围一个连接点的通知,就像方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回他们自己的返回值域或抛出异常来结束执行。
2
.
Spring
的
AOP
实现
在
Spring
中所有的通知都以
Java
类的形式编写。所以你可以像普通
Java
开发那样在
IDE
(
Eclipse
或
NetBeans
)中开发切面。而且,定义在什么地方应用通用的切入点通常在
Spring
的配置文件中配置。
Spring
有两种代理创建方式:
(
1
)
如果目标对象(
Target Object
)实现了一个或多个接口暴露的方法,
Spring
将使用
JDK
的
java.lang.reflect.Proxy
类创建代理。
(
2
)
如果
目标对象(
Target Object
)没有实现任何接口,
Spring
使用
CGLIB
(
http://cglib.sourceforge.net/
)库生成目标对象的子类。在创建这个子类的时候,
Spring
将通知织入,并且将对目标对象的调用委托给这个子类。注意用这种方式创建代理时需要将
Spring
发行包中
lib/cglib
文件加下的
jar
文件加载到工程文件中。使用这种代理时注意两点:
l
对接口创建代理优于对类创建代理,这样会产生更加松耦合的系统。
l
标记为
final
的方法不能被通知。
通过上面的一大堆名词解释应该对
AOP
以及
Spring
中的
AOP
有了一个大概的了解了。下面进一步详细解释
Spring
中的
AOP
。
二、创建通知
1
.前置通知(
Before Advice
)
创建前置通知需要实现
org.springframework.aop.MethodBeforeAdvice
接口,该接口只有
before(Method method, Object[] args, Object target)
throws
Throwable
这个方法。我们可以这样理解前置通知:比如你到一个比较高档的饭店去吃饭,进门时会有礼仪小姐给你开门并且向您问好,这个礼仪小姐的行为就可以视为
“
前置通知
”
。
package
springinaction.chapter03.createadvice;
import
java.lang.reflect.Method;
import
org.springframework.aop.MethodBeforeAdvice;
publicclass
BeforeAdvice
implements
MethodBeforeAdvice
{
//
实现
MethodBeforeAdvice
的
before
方法
publicvoid
before(Method method, Object[] args, Object target)
{
System.
out
.println(
"befor advice"
);
}
//end before
}
//end class BeforeAdvic
e
2
.返回后通知(
After returning advice
)
创建返回后通知需要实现
org.springframework.aop.AfterReturningAdvice
接口,该接口也只有一个方法:
void
afterReturning(Object returnValue, Method method, Object[] args, Object target)
throws
Throwable
。同样我们也可以这样理解
After returning advice
:当你在这家饭店用餐完后,礼仪小姐还会为您开门,并且欢迎您下次再来。这时礼仪小姐的行为就是
“After returning advice”
。
package
springinaction.chapter03.createadvice;
import
java.lang.reflect.Method;
import
org.springframework.aop.AfterReturningAdvice;
publicclass
AfterReturningAdviceImp
implements
AfterReturningAdvice
{
publicvoid
afterReturning(Object returnValue, Method method, Object[] arg2, Object target)
throws
Throwable
{
System.
out
.println(
"afterReturning"
);
}
}
3
.环绕通知(
Around advice
)
创建环绕通知需要实现
org.aopalliance.intercept.MethodInterceptor
接口,同样要实现一个
invoke
方法,该方法有一个
MethodInvocation
类型的参数。
MethodInterceptor
能够控制目标方法是否真的被调用。通过调用
MethodInterceptor.proceed()
方法来调用目标方法。
MethodInterceptor
让你可以控制返回的对象,你可以返回一个与
proceed()
方法返回对象完全不同的对象。我们可以这样理解环绕通知:当你用餐完后,饭店要确保你已经付款了,在付款后停止再出售食物给你。
package
springinaction.chapter03.createadvice;
import
org.aopalliance.intercept.MethodInterceptor;
import
org.aopalliance.intercept.MethodInvocation;
publicclass
AroundAdvice
implements
MethodInterceptor
{
public
Object invoke(MethodInvocation mi)
{
Object obj =
null
;
//do something....
return
obj;
}
//end invoke(...)
}
//end class AroundAdvice(
)
4
.抛出后通知(
After throwing advice
)
创建抛出后通知需要实现
org.springframework.aop.ThrowsAdvice
接口,该接口没有任何方法,但是要实现这个接口的类必须实现
afterThorwing(Throwable throwable)
或者
afterThrowing(Method method, Object[] args, Object target)
形式的一种,根据抛出的异常的类型恰当的方法将被调用。如果你在该饭店用餐后没有付钱就走或者多给钱他们没有找给你大概异常通知也就发生了。
J
package
springinaction.chapter03.createadvice;
import
java.lang.reflect.Method;
import
org.springframework.aop.ThrowsAdvice;
publicclass
AfterThorwsAdvice
implements
ThrowsAdvice
{
publicvoid
afterThorwing(Throwable throwable)
{
//do something....
}
publicvoid
afterThrowing(Method method, Object[] args, Object target)
{
//do something....
}
}
一般来说环绕通知是用的最广泛的一个通知类型,但是他们(
Spring
小组)鼓励我们用最合适的通知。例如我们有一个简单的验证身份的功能,那么我们只需要前置通知就可能实现我们要求的功能了。
三、定义切入点
在上面我们定义了各种通知。可以看到一个通知是要被执行的一个方法。光把通知定义出来不行,我们还要确定这些通知在我们的系统什么地方应用,否则通知是毫无用处的。这就是切入点的用处。切入点决定了一个特定的类的特定方法是否满足一条特定规则。如果确实符合,通知就应用到该方法上。
Spring
根据需要织入通知的类和方法来定义切入点。
Advice
根据他们的特性织入目标类和方法。
Spring
的切入点框架的核心接口是
Pointcut
。
publicinterface
Pointcut
{
ClassFilter getClassFilter();
MethodMatcher getMethodMatcher();
}
ClassFilter
接口决定了一个类是否符合通知的要求:
package
org.springframework.aop;
publicinterface
ClassFilter
{
boolean
matches(Class clazz);
ClassFilter
TRUE
= TrueClassFilter.
INSTANCE
;
}
实现这个接口的类决定了以参数传入进来的类是否应该被通知。
ClassFilter.
TRUE
是规范的的适合任何类的
ClassFilter
实例,他适用于创建只根据方法决定时候符合要求的切入点。
ClassFilter
接口利用类过滤切面,
MethodMactcher
接口可以通过方法过滤切面:
package
org.springframework.aop;
import
java.lang.reflect.Method;
publicinterface
MethodMatcher
{
boolean
matches(Method method, Class targetClass);
boolean
isRuntime();
boolean
matches(Method method, Class targetClass, Object[] args);
MethodMatcher
TRUE
= TrueMethodMatcher.
INSTANCE
;
}
MethodMactcher
接口有三个方法。
matches(Method, Class)
根据目标类和方法决定一个方法是否该被通知。
isRuntime()
方法被调用来决定
MethodMatcher
的类型。有两种类型:静态类型和动态类型。静态
pointcut
的意思是
Advice
总是被执行,此时的
isRuntime()
方法返回
false
。动态
pointcut
根据运行时方法的参数值决定通知是否需要执行,
isRuntime()
方法返回
true
。
有一个非常重要的名词
Advisor
:大多数切面是由定义切面行为的通知和定义切面在什么地方执行的切入点组合而成的。在
Spring
中把通知和切入点组合到一个对象中。
PointcutAdvisor
提供这些功能。
package
org.springframework.aop;
publicinterface
PointcutAdvisor
extends
Advisor
{
Pointcut getPointcut();
}
Spring
中的
RegexpMethodPointcut
让你利用正则表达式来定义切入点。如果你对正则表达式不了解的话,赶快去学学吧,非常重要的内容。(开个玩笑的说,用了正则表达式能使你的代码上档次
J
)
,
下面列出定义切入点时经常使用的符号:
符号
|
描述
|
示例
|
·
|
(英文点
“.”
)匹配任何单个字符
|
setFoo.
匹配
setFooB
,但不匹配
setFoo
或
setFooBar
|
+
|
匹配前一个字符一次或多次
|
setFoo.+
匹配
setFooB
或
setFooBar
,但不匹配
setFoo
|
*
|
匹配前一个字符
0
次或多次
|
setFoo.*
匹配
setFooB
、
setFooBar
和
setFoo
|
/
|
匹配任何正则表达式符号
|
/.setFoo.+
匹配
setFoo
,但不匹配
setFoo
|
下面引用《精通
Srping
》中的例子,这个例子讲的还是比较清晰的。如果前面的
Ioc
一章理解的很好的话,理解这个例子不是很难。难点在于
ProxyFactoryBean
这个类。
package
jingtongspring;
import
org.apache.commons.logging.Log;
import
org.apache.commons.logging.LogFactory;
import
org.springframework.aop.MethodBeforeAdvice;
import
java.lang.reflect.Method;
publicclass
LoggingBeforAdvice
implements
MethodBeforeAdvice
{
protectedstaticfinal
Log
log
= LogFactory.
getLog
(LoggingBeforAdvice.
class
);
publicvoid
before(Method arg0, Object[] arg1, Object arg2)
throws
Throwable
{
log
.info(
"before: The invocation of getContent()"
);
}
}
下面是配置文件:
<?
xml
version
=
"1.0"
encoding
=
"UTF-8"
?>
<!
DOCTYPE
beans
PUBLIC
"-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd"
>
<
beans
>
<
bean
id
=
"helloworldbean"
class
=
"org.springframework.aop.framework.ProxyFactoryBean"
>
<
property
name
=
"proxyInterfaces"
>
<
value
>
jingtongspring.IHelloWord
</
value
>
</
property
>
<
property
name
=
"target"
>
<
ref
local
=
"helloworldbeanTarget"
/>
</
property
>
<
property
name
=
"interceptorNames"
>
<
list
>
<
value
>
loggingBerforeAdvisor
</
value
>
</
list
>
</
property
>
</
bean
>
<
bean
id
=
"helloworldbeanTarget"
class
=
"jingtongspring.HelloWord"
/>
<
bean
id
=
"loggingBeforAdbisor"
class
=
"org.springframework.aop.support.RegexpMethodPointcutAdvisor"
>
<
property
name
=
"advice"
>
<
ref
local
=
"loggingBeforeAdvice"
/>
</
property
>
<
property
name
=
"pattern"
>
<
value
>
.*
</
value
>
</
property
>
</
bean
>
<
bean
id
=
"loggingBeforeAdvice"
class
=
"jingtongspring.LoggingBeforeAdvice"
/>
</
beans
>
四、创建引入
在前面我们列出了
Spring
的四种通知类型,并且有相应的简单例子。但是引入(
Introduction
)通知与其他类型的通知有所不同,它影响整个类。通过给需要消息的类添加方法和属性来实现。(看上去很神气,因为说道类那就是已经封装好了的,给类添加方法除非是继承该类。
Spring
中怎样实现?)
Spring
通过一个特殊的方法拦截器接口
IntroductionInterceptor
来实现引入。这个接口添加一个方法:
boolean implementsInterface(Class intf)
这个方法对于引入如何工作非常关键。如果
IntroductionInterceptor
是为了实现指定接口,那么方法
implementsInterface
应该返回
true
。也就是说,对用这个接口声明的方法的任何调用将被委托给
IntroductionInterceptor
的
invoke()
方法。
invoke()
方法负责实现这个方法,不能调用
MethodInvocation.proceed()
。它引入了新的借口,调用目标对象是没有用的。(注意:在本书中提到了一个
IntroductionMethodInterceptor
接口,我查看
Spring2.0 rc3
的源代码并没有该类,可能是在
Spring1.x
中存在的,
IntroductionInterceptor
接口的定义形式是这样的:
publicinterface
IntroductionInterceptor
extends
MethodInterceptor, DynamicIntroductionAdvice {}
,
invoke()
方法估计是在它的两个父接口之一中存在。
)
下面看例子:
先实现一个接口:
package
springinaction.chapter03.createadvice;
import
java.util.Date;
publicinterface
Auditable
{
void
setLastModifiedDate(Date date);
Date getLastModifiedDate();
}
再实现一个类:
package
springinaction.chapter03.createadvice;
import
java.util.Date;
import
org.aopalliance.intercept.MethodInvocation;
import
org.springframework.aop.IntroductionInterceptor;
publicclass
AuditableMixin
implements
IntroductionInterceptor, Auditable
{
private
Date
lastModifiedDate
;
publicboolean
implementsInterface(Class intf)
{
return
intf.isAssignableFrom(Auditable.
class
);
}
//end implementsInterface(...)
public
Object invoke(MethodInvocation m)
throws
Throwable
{
if
(
this
.implementsInterface(m.getMethod().getDeclaringClass())){
return
m.getMethod().invoke(
this
, m.getArguments());
}
else
{
return
m.proceed();
}
}
//end invoke(...)
public
Date getLastModifiedDate()
{
returnthis
.
lastModifiedDate
;
}
//end getLastModifiedDate()
publicvoid
setLastModifiedDate(Date lastModifiedDate)
{
this
.
lastModifiedDate
= lastModifiedDate;
}
}
//end class AuditableMixi
n
在
AuditableMixin
类中实现了
IntroductionInterceptor
接口和业务接口
Auditable
。如果被申明调用方法的类型是
Auditable
类型,
implementsInterface
方法返回
true
。这说明,对于
Auditable
的两个方法,拦截器必须提供实现,在
invoke
方法中实现。对于任何
Auditable
接口方法的调用,调用我们的拦截器。对于其他方法的调用我们让
Method Invocation
处理。
Spring
提供了一个一个方便的类来处理我们的大多数应用,这个类是:
DelegatingIntroductionInterceptor
应用这个类我们不再需要实现
invoke
这个方法了因为在
DelegatingIntroductionInterceptor
类中已经实现好了(可以参看一下源代码)。看下面的例子:
package
springinaction.chapter03.createadvice;
import
java.util.Date;
import
org.springframework.aop.support.DelegatingIntroductionInterceptor;
publicclass
ImmutableMixin
extends
DelegatingIntroductionInterceptor
implements
Auditable
{
private
Date
lastModifiedDate
;
public
Date getLastModifiedDate()
{
returnthis
.
lastModifiedDate
;
}
//end getLastModifiedDate()
publicvoid
setLastModifiedDate(Date lastModifiedDate)
{
this
.
lastModifiedDate
= lastModifiedDate;
}
//end setLastModifiedDate(...)
}
//end class ImmutableMixi
n
DelegatingIntroductionInterceptor
类也要实现你的混合类暴露的任何方法,并且将任何对这些方法的调用委托给这个混合类。因为
ImmutableMixin
类实现了
Auditable
接口,对这个接口的方法的所有调用都将调用我们的拦截器。任何其他方法委托给目标对象。如果你的拦截器要实现一个接口,你不想把它暴露成一个混合体,那么只要简单的将这个接口传递给
DelegatingIntroductionInterceptor
类的
suppressInterface()
方法就可以了(该方法在
DelegatingIntroductionInterceptor
类的父类
IntroductionInfoSupport
中实现)。还有一点:如果你的混合体要改变任何目标对象方法的行为的话,你就需要实现
invoke()
方法。
有了自己的引入通知后,我们需要创建
Advisor
。因为引入通知之应用在类层次上,所以引入有他们自己的
Advisor
:
IntroductionAdvisor
。
Spring
也提供了一个适合大多数情况的缺省实现。名为:
DefaultIntroductionAdvisor
,它有一个以
IntroductionInterceptor
作为参数的构造函数。
在本章中使用了大量的
ProxyFactoryBean
来创建一个被通知的类。当你想明确的控制你的通知类如何组合时,这种是方法最好、最简单的选择。
ProxyFactoryBean
有很多控制行为的属性。在书中作者列出了一个详细的表格进行了说明,这里就不罗列了。详细的
ProxyFactoryBean
大家也可以看一下它的源代码。