2010十月2

AOP

?所谓AOP,即面向方面编程(Aspect Oriented Programming),方面(Aspect)”它就是将那些与业务无关,却为业务模块所共同调用的逻辑或责任,例如事务处理、日志管理、权限控制等,封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。它的作用更多地是关注于系统的某一方面

?? “设计模式”的触角始终在接口与抽象中大做文章,而对于对象内部则无能为力。AOP利用一种称为“横切”的技术,剖解开封装的对象内部,并将那些影响了多个类的行为封装到一个可重用模块,并将其名为“Aspect”

??? Spring AOP实现AOP技术从本质上来讲,是利用了JDK提供的动态代理技术。而从实际的实现方式来看,则是利用了IoC(Inversion of Control,反转模式)机制,同时采用了AOP联盟(AOP Alliance)的通用AOP接口。首先,Spring AOP通过xml配置文件配置了pointcut,并利用Interceptor(拦截机)作为设定的触发条件。Interceptor是由用户自定义的,它相当于是AOP中的advice,但该Interceptor需要实现AOP联盟的通用AOP接口,例如 org.aopalliance.intercept.MethodInterceptor。最后定义一个Spring AOP ProxyFactory用于加载执行AOP组件,并利用IoC机制将advice注入到接口以及实现类中。

?Spring AOP研究

Spring AOP使用纯Java实现,不需要特别的编译过程,也不需要控制类装载层次

。与JBoss AOP相同,它仍然利用了拦截器完成对方法的拦截。然而,Spring AOP

实现AOP的主要技术却主要来自于AOP联盟,如拦截器应实现

org.aopalliance.intercept.MethodInterceptor 接口,而所有advice必须实现

org.aopalliance.aop.Advice标签接口。此外,Spring实现AOP的目标也不同于其

他大部分AOP框架,它的目标不是提供及其完善的AOP实现,而是提供一个和

Spring IoC紧密整合的AOP实现,帮助解决企业应用中的常见问题。因此,Spring

AOP的功能通常是和Spring IoC容器联合使用的。AOP Advice是用普通的bean定义

语法来定义的,Advice和pointcut本身由Spring IoC 管理。这是一个重要的其他

AOP实现的区别。

3.2.3.1 切入点(pointcut)

Spring的切入点模型能够使pointcut独立于advice类型被重用。同样的pointcut

有可能接受不同的advice。将 Pointcut接口分成两个部分有利于重用类和方法的

匹配部分,并且组合细粒度的操作(如和另一个方法匹配器执行一个“并”的操

作)。

在Spring的切入点中,org.springframework.aop.Pointcut接口是重要的接口,

它用来指定通知到特定的类和方法目标。完整的接口定义如下:
public interface Pointcut
{
??? ClassFilter getClassFilter();
??? MethodMatcher getMethodMatcher();
}

ClassFilte类型也是一个接口,该接口被用来将切入点限制到一个给定的目标类

的集合。 如果matches()永远返回true,所有的目标类都将被匹配。
public interface ClassFilter
{
??? boolean matches(Class clazz);
}

MethodMatcher接口通常更加重要。完整的接口定义如下:
public interface MethodMatcher
{
??? boolean matches(Method m, Class targetClass);
??? boolean matches(Method m, Class targetClass, Object[] args);
??? boolean isRuntime();
}

matches(Method, Class) 方法被用来测试这个切入点是否匹配目标类的给定方法

。这个测试可以在AOP代理创建的时候执行,避免在所有方法调用时都需要进行测

试。如果2个参数的matches()方法对某个方法返回true,并且MethodMatcher的

isRuntime()也返回true,那么3个参数的matches()方法将在每次方法调用的时候

被调用。这使切入点能够在目标advice被执行之前立即查看传递给方法调用的参

数。由于大部分 MethodMatcher都是静态的,意味着isRuntime()方法会返回

false。此种情况下,3个参数的matches()方法永远不会被调用。

Spring AOP提供了几个实用的切入点实现,其中较为常用的是正则表达式切入点

:org.springframework.aop.support.RegexpMethodPointcut,它使用Perl 5的

正则表达式的语法。使用这个类你可以定义一个模式的列表。如果任何一个匹配

,那个切入点将被计算成 true。用法如下:
<bean id=”settersAndAbsquatulatePointcut”
???>
??? <property name=”patterns”>
??????? <list>
??????????? <value>.*get.*</value>
??????????? <value>.*absquatulate</value>
??????? </list>
??? </property>
</bean>

不过,更多情况下是直接使用RegexpMethodPointcut一个实用子类:

RegexpMethodPointcutAdvisor。它允许我们同时引用一个advice(在Spring AOP

中,advice可以是拦截器,也可以是before advice,throws advice等)。这就简

化了bean的装配,因为一个bean可以同时当作pointcut和advice,如下所示:
<bean id=”myPointcutAdvisor”

class=”org.springframework.aop.support.RegexpMethodPointcutAdvisor”>
??? <property name=”advice”>
??????? <ref local=”MyInterceptor” />
??? </property>
??? <property name=”patterns”>
??????? <list>
??????????? <value>.*save.*</value>
??????????? <value>.*do.*</value>
??????? </list>
??? </property>
</bean>

注意配置文件中的myPointcutAdvisor,在Spring AOP中,一个advisor就是一个

aspect完整的模块化表示。通过advisor,可以将pointcut和advice(在此处即为

MyInterceptor)绑定起来。

3.2.3.2 通知(advice)

Spring AOP的advice可以跨越多个被advice对象共享,或者每个被advice对象有

自己的advice。要实现advice,最简单的做法就是定义一个拦截器(Interceptor

)。它采用了AOP联盟(AOP Alliance)的通用AOP接口(接口定义为

aopalliance.jar)。要实现advice,需要实现aopalliance.jar中定义的

MethodInterceptor接口。

例如,我们定义了一个业务对象接口BusinessObject及其实现类

BusinessObjectImpl,该业务对象能够存储数据,其定义如下:
public interface BusinessObject
{
??? public void save();
}
public class BusinessObjectImpl implements BusinessObject
{
??? public void save()
??? {
???????? System.out.println(“saving domain object……”);
??? }
}

现在需要为业务对象BusinessObject的Save()方法,提供Lock机制。根据Spring

AOP的实现方式,我们可以定义一个LockInterceptor来实现MethodInterceptor接

口:
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class LockInterceptor implements MethodInterceptor
{
??? public Object invoke(MethodInvocation invocation) throws Throwable
??? {
??????? // TODO Auto-generated method stub
??????? lock();
??????? Object ret= invocation.proceed();
??????? unlock();
??????? return ret;
??? }
??? private void lock()
??? {
??????? System.out.println(“lock domain object…”);
??? }
??? private void unlock()
??? {
??????? System.out.println(“unlock domain object…”);
??? }
}

为将interceptor与具体的advice绑定起来,需要在配置文件中配置bean:
&lt;bean id=”MyInterceptor”

class=”test.aop.spring.LockInterceptor”/&gt;

3.2.3.3 AOP代理与IoC容器

由于Spring中提供了IoC容器(例如BeanFactory),因此我们可以通过Ioc机制,

利用ProxyFactoryBean来创建 AOP代理。ProxyFactoryBean和其他Spring的

FactoryBean实现一样,引入一个间接的层次。如果你定义一个名字为foo的

ProxyFactoryBean,引用foo的对象所看到的不是 ProxyFactoryBean实例本身,

而是由实现ProxyFactoryBean的类的 getObject()方法所创建的对象。这个方法

将创建一个包装了目标对象 的AOP代理。

AOP代理利用的是Java的动态代理技术,通过它就可以加载并执行AOP组件。同时

,还需要通过IoC的方式将advice注入到接口以及其实现类。以前面的业务对象

BusinessObject为例,在xml配置文件中的配置如下:
<bean id=”myAOPProxy”

class=”org.springframework.aop.framework.ProxyFactoryBean”>
??? <property name=”proxyInterfaces”>
?????? <value>test.aop.spring.BusinessObject</value>
??? </property>
??? <property name=”target”>
?????? <ref local=”impl” />
??? </property>
??? <property name=”interceptorNames”>
?????? <value>myPointcutAdvisor</value>
??? </property>
</bean>
<bean id=”impl”/>

通过上述对pointcut、advice、advisor和AOP代理的配置,我们就可以轻易地在

Spring中实现AOP,例如:
import org.springframework.context.ApplicationContext;
import

org.springframework.context.support.FileSystemXmlApplicationContext;

public class App
{
??? private BusinessObject bo = null;
??? public static void main(String[] args)
??? {
??????? ApplicationContext ctx=new FileSystemXmlApplicationContext

(“Bean.xml”);
??????? bo= (BusinessObject) ctx.getBean(“myAOPProxy”);
??????? bo.save();
??? }
}

首先,通过AOP代理获得BusinessObject对象。当调用BusinessObject对象的

save()方法时,拦截器 LockInterceptor根据RegexpMethodPointcutAdvisor配置

的pointcut和advice之间的关系,判定该方法的调用为join point,从而拦截该

方法调用,并注入advice的执行逻辑,即lock()和unlock(),最终实现了AOP。

3.2.3.4 引入(introduction)

在Spring AOP中,将introduction当作advice来处理。与一般的advice一样,

introduction advice相当于一种特殊类型的拦截通知,需要实现

IntroductionAdvisor和IntroductionInterceptor接口,而

IntroductionInterceptor接口继承自MethodInterceptor:
public interface IntroductionInterceptor extends MethodInterceptor
{
??? boolean implementsInterface(Class intf);
}

Introduction通知不能被用于任何pointcut,因为它只能作用于类层次上,而不

是方法。我们可以只用InterceptionIntroductionAdvisor来实现导入通知,它有

下面的方法:
public interface InterceptionIntroductionAdvisor extends

InterceptionAdvisor
{
??? ClassFilter getClassFilter();
??? IntroductionInterceptor getIntroductionInterceptor();
??? Class[] getInterfaces();
}

接下来,我以JBoss AOP一节中的例子来说明introduction在Spring AOP中的应用

。我们的目标仍然是为一个已有的业务对象引入第三方接口Tracing:
public interface Tracing
{
??? void enableTracing();
??? void disableTracing();
??? boolean enabled();
}

首先,我们需要一个做大量转化的IntroductionInterceptor。在这里,我们继承

org.springframework.aop.support.DelegatingIntroductionInterceptor 实现

类。当然我们可以直接实现IntroductionInterceptor接口,但是大多数情况下

DelegatingIntroductionInterceptor是最合适的。

DelegatingIntroductionInterceptor的设计是将introduction委托到真正实现

introduction 接口的接口,隐藏完成这些工作的拦截器。委托可以使用构造方法

参数设置到任何对象中;默认的委托就是自己(当无参数的构造方法被使用时)

。这样在下面的例子里,委托是DelegatingIntroductionInterceptor的子类

TracingMixin。给定一个委托(默认是自身)的

DelegatingIntroductionInterceptor实例寻找被这个委托(而不是

IntroductionInterceptor)实现的所有接口,并支持它们中任何一个导入。子类

如TracingMixi也可能调用suppressInterflace(Class intf) 方法来隐藏不应暴

露的接口。然而,不管IntroductionInterceptor 准备支持多少接口,

IntroductionAdvisor将控制哪个接口将被实际暴露。一个导入的接口将隐藏目标

的同一个接口的所有实现。

这样,TracingMixin继承DelegatingIntroductionInterceptor并自己实现接口

Tracing。父类自动选择支持introduction的Tracing,所以我们不需要指定它。

用这种方法我们可以导入任意数量的接口。
public class TracingMixin extends DelegatingIntroductionInterceptor

implements Tracing
{
??? private boolean enabled;
??? public void enableTracing ()
??? {
??????? this.enabled = true;
??? }

??? public void disableTracing ()
??? {
??????? this. enabled = false;
??? }

??? public boolean enabled()
??? {
??????? return this.enabled;
??? }
??? public Object invoke(MethodInvocation invocation) throws Throwable
??? {?????
??????? return super.invoke(invocation);
??? }
}

通常不要需要改写invoke()方法:实现DelegatingIntroductionInterceptor就足

够了,如果是引入的方法,DelegatingIntroductionInterceptor实现会调用委托

方法, 否则继续沿着连接点处理。

所需的introduction advisor是很简单的。只需保存一个独立的TracingMixin实

例,并指定导入的接口,在这里就是Tracing。此时,TracingMixin没有相关配置

,所以我们简单地使用new来创建它。

public class TracingMixinAdvisor extends DefaultIntroductionAdvisor
{
??? public TracingMixinAdvisor() {
??????? super(new TracingMixin(),Tracing.class);
??? }
}

我们可以非常简单地使用这个advisor。它不需要任何配置。(但是,有一点是必

要的:就是不可能在没有IntroductionAdvisor 的情况下使用

IntroductionInterceptor。) 和引入一样,通常 advisor必须是针对每个实例

的,并且是有状态的。我们会有不同的TracingMixinAdvisor。每个被通知对象,

会有不同的 TracingMixin。advisor组成了被通知对象的状态的一部分。

在Spring中,Spring AOP的核心API已经基本稳定了。和Spring的其它部分一样,

AOP框架是模块化的,在保留基础设计的同时提供扩展。在Spring 1.1到1.2阶段

有很多地方可能会有所提高,但是这些地方也保留了向后兼容性。它们是:

(一)性能的提高:AOP代理的创建由工厂通过策略接口处理。因此能够支持额外

的AOP 代理类型而不影响用户代码或核心实现。
(二)更具表达力的pointcut:Spring目前提供了一个具有表达力的切入点接口

,同时添加了更多的切入点实现。Spring正在考虑提供一个简单但具有强大表达

式语言的实现。

本文地址:http://enjoyasp.net/?p=1001 , 转载请保留.

本文的评论功能被关闭了.