面向方面编程的annotation简介

人气：1258 2007-11-17

　　annotation概述

　　首先让我们给出这两项技术的一个概述。annotation是jdk5.0的新功能，它在jsr-175规范中有详细定义。它们允许您以安全的方法定义元数据并应用到类，方法，构造程序，字段或参数中。对于你们中熟悉xdoclet的人来说，annotation将非常直观，您可以用来声明标签以产生代码。两者的主要不同是annotation是java语言的一部分而xdoclet标签可能会打错并且难以创建。我喜欢用例子来说明，所以让我们展示一个简单的例子。

　　要定义一个annotation，您所要做的就是声明一个特殊类型的java接口。

　　清单1：orange.java

package org.jboss.collors;
public @interface orange{}

　　定义了这个接口，您就可以用来提供更多的描述给您的java元素。

　　清单2：foo.java

package org.jboss.examples;
public class foo
{
@orange void somemethod();
@orange private int somefield;
}

　　那么我们可以用annotation来干什么呢？一些人想用annotation来产生代码并替代xdoclet，其他人，象j2ee和ejb3.0专家组，将它视为部署描述符的替代。本文谈论在aop中如何使用annotation

　　aop概述

　　有许多的文章和书籍解释aop到底是什么，例如graham o'regan的onjava文章“introduction to aspect-oriented programming."我将在本文给出一个快速的概览，但我鼓励您在线做更多的研究。

　　假设您要添加代码到一个应用程序去测试调用一个特定的java方法所需的总的时间。该代码可能看起来如下：

清单3：

public class bankaccount
{
public void withdraw(double amount)
{
long starttime = system.currenttimemillis();
try
{
// actual method body...
}
finally
{
long endtime = system.currenttimemillis() - starttime;
system.out.println("withdraw took: " + endtime);
}
}
}

　　虽然这些代码能够正常工作，但这个方法有一些问题：1.它难以打开和关闭测试，您必须在try/finally块中对每个方法或购置函数手工增加代码以进行基准测试。

　　2.这一轮廓代码并不真正属于贯穿整个应用的代码。它使得您的代码臃肿并难以理解，因为您必须将计时放在try/finally块中。

　　3、如果您想扩展它的功能以包含一个方法或是失败计数，或甚至是注册这些统计数据到一个更为复杂的报告机制中，您必须修改大量不同文件（又一次）。

　　metrics类提供了一个什么是横切（cross-cutting）关系的完美，简洁的小例子。jboss aop以一种含蓄的方式提供了一个简单的方法来封装和应用这样的关系，这样某些象度量操作代码不会弄乱您的编码。让我们稍为深入到jboss aop一些来看看如何实现。

　　为了使用jboss aop封装度量功能，您首先需要定义一个方面来指出该度量行为。

　　清单4：

public class metrics
{
public object profile(methodinvocation invocation) throws throwable
{
long starttime = system.currenttimemillis();
try
{
return invocation.invokenext();
}
finally
{
long endtime = system.currenttimemillis() - starttime;
java.lang.reflect.method m = invocation.getmethod();
system.out.println("method " + m.tostring() +
" time: " + endtime + "ms");
} }
}

　　一个方面只是一个具有定义了您想要附加到您的对象模型的行为的普通java类。这些方法的签名必须返回一个java.lang.object并且必须具有一个（并且只有一个）jboss aop 调用对象参数，它被用来封装方法，构造函数或字段调用。方法名可以是任何你想要的并且当您绑定该方面到您的代码片断时被引用。

　　下面要做的事情就是实际应用方面到您想要它勾勒一个方法的执行的某个程序点。大多数aop框架提供了一个指向表达式语言，在此处您可以定义您想要某个方面行为被附加到的位置。下面是在jboss aop中的做法。

　　清单5：jboss-aop.xml

<aop>
<aspect class="metrics"/>

<bind pointcut="execution(public void bankaccount->withdraw(double amount))">
<advice name="profile" aspect="metrics"/>
</bind>
</aop>

　　采用在metrics.java中对方面的定义和jboss-aop.xml中的指向定义，该度量代码现在以含蓄而又透明地应用到bankaccount.withdraw（）方法中并能在勾勒代码不再需要时轻易地移除。

　　对于jboss aop更多的信息，请查询分发包中的指南。其中具有大约20个例子来带领您漫游如何使用jboss aop框架。

　　嘘！现在我们已经进行了一个概览，让我们深入到本文的中心内容。我将再次给您提供一些例子，因为这是我所知道的讲授一个新的概念的最好的方法。

　　正如我前面说的，annotation加上aop几乎是给予您扩展java语言的能力。annotation提供了声明新的，可兼容的，类型安全的语法机制。aop提供了封装和应用新的行为到一个语法表达式的机制。

　　方法annotation和aop

　　让我们看看如何使用方法annotation和aop.使用annotation和aop并应用到一个方法类似于使用java的synchronized关键字。当您设定一个方法为synchronized，您在告诉jvm：您想该方法在被调用时以一种特殊的方式进行。annotation允许您定义一个新的关键字来触发您自己的特殊的定制行为。aop给予您封装这一行为的能力并将其“编织”进该方法的执行中。再次的，这一概念的最佳描述是通过一个例子。

　　让我们假设我们想要添加新的语法，使用该语法使得我们可以在方法被标签为@oneway时，在后台以另一个线程调用这个void方法。可以象这样使用新的语法：

　　清单6：

import org.jboss.aspects.oneway；
public class foo
{
@oneway public static void somemethord（）{…}
public static void main(string[] args){
sommethod();//executes in
backgroud
}
}

　　当somemethod（）在main中被调用，它将异步运行，这样main中的代码可以并行执行其他任务。

　　要实现这一功能，首先要在一个annotation中为我们的@oneway标签定义新的java语法。

清单7：oneway.java

package org.jboss.aspects;

import java.lang.annotation.elementtype;
import java.lang.annotation.target;

@target({elementtype.method})
public @interface oneway {}

够简单的。@target标签允许您缩小annotation可以应用的地方。在本例中，我们的@onewayannotation只能应用到一个方法。记住，这些都是j2se5.0百分之百可用的纯java。

下面要做的事是定义一个封装我们的@oneway行为的方面类。

清单8：onewayaspect.java

package org.jboss.aspects;

public onewayaspect
{
private static class task implements runnable
{
private methodinvocation invocation;

public task(methodinvocation invocation)
{
this.invocation = invocation;
}
public void run()
{
try { invocation.invokenext(); }
catch (throwable ignore) { }
}
}

public object oneway(methodinvocation invocation) throws throwable
{
methodinvocation copy = invocation.copy();
thread t = new thread(new task(copy));
t.setdaemon(false);
t.start();
return null;
}
}

　　这个方面够简单。oneway（）方法拷贝invocation，创建一个线程，在后台启动整个调用并返回。我们可以想象一个更为复杂的例子：使用j2se 5.0 java.util.concurrent包中的某些新的executors，但这些代码很有希望阐明了如何基于这个例子构建更为复杂的实现。

　　最后必须要做的事情是指定当@onewayannotation在一个方法中声明时触发onewayaspect应用的指向表达式。

清单9：jboss-aop.xml

<aop>
<aspect class="org.jboss.aspects.onewayaspect"/>
<bind pointcut="execution(void *->@org.jboss.oneway(..))">
<advice name="oneway"
aspect="org.jboss.aspects.onewayaspect"/>
</bind>
</aop>

　　该指向表达式规定任何具有@oneway标签的void方法都应该有onewayaspect.oneway（）方法在它本身执行前被执行。随着annotation，方面和现在定义的指向表达式，@oneway语法现在可以用于您的应用程序中。一个简单，清晰，易于实现的方法来扩展java 语言！

　　字段annotation和aop

　　让我们看看如何使用字段annotation和aop.使用annotation和aop，您可以改变一个对象的字段或是作为一个类的静态成员的实际存储方式。在这个例子里我们要完成的是当您将一个字段（静态或是成员）标记上@threadbased，尽管是将它存储在java.lang.threadlocal，但它的值依然正常。当然，您可以直接使用threadlocal变量，但问题是threadlocal并非一个类型并且您必须使用“麻烦的”（好，它们并没有那么罗嗦）get（）和set（）方法。那么我们现在做的就是创建一个threadlocal类型的字段。我们主要的将创建一个称为@thradbased变量的新的java字段类型。

　　象这样使用新的类型：

清单10：

import org.jboss.aspects.threadbased;
public class foo
{
@threadbased private int counter;
}

　　为了实现这个功能，我们必须先定义annotation

清单11：threadbased.java

package org.jboss.aspects;
import java.lang.annotation.elementtype;
import java.lang.annotation.target;
@target({elementtype.field})
public @interface threadbased {}

　　够简单。@target标签允许您缩小annotation可以应用的地方。在本例中，我们的@threadbasedannotation只能应用到字段。

　　下面的事情是定义封装我们的threadlocal行为的方面。

清单12：threadbasedaspect.java

package org.jboss.aspects;
import org.jboss.aop.joinpoint.*;
import java.lang.reflect.field;
public class threadbasedaspect
{
private threadlocal threadbased = new threadlocal();
public object access(fieldreadinvocation invocation)
throws throwable
{
// just in case we have a primitive,
// we can't return null
if (threadbased.get() == null)
return invocation.invokenext();
return threadbased.get();
}
public object access(fieldwriteinvocation invocation)
throws throwable
{
threadbased.set(invocation.getvalue());
return null;
}
}