WEB开发网
开发学院WEB开发Jsp 面向方面编程AOP和JBoss(二) 阅读

面向方面编程AOP和JBoss(二)

 2008-01-05 10:06:13 来源:WEB开发网   
核心提示:访问Metadata为了用元数据,它在运行时间必须是可达的,面向方面编程AOP和JBoss(二),类的元数据是通过Invocation对象可达的,为了在我们的例子使用它,那会有一些惊异等着你,象我们已经在我们新的框架上实现了一套服务,TracingInterceptor必须要修改一点点,public class Tra

  访问Metadata
  为了用元数据,它在运行时间必须是可达的。类的元数据是通过Invocation对象可达的。为了在我们的例子使用它,TracingInterceptor必须要修改一点点。
  
  public class TracingInterceptor implements Interceptor
  {
    public String getName() { return TracingInterceptor; }
    public InvocationResponse invoke(Invocation invocation)
      throws Throwable
    {
     String filter = (String)invocation.getMetaData(tracing, filter);
     if (filter != null && filter.equals(true))
    return invocation.invokeNext();
  
     String message = null;
  
     if (invocation.getType() == InvocationType.METHOD)
     {
       Method method = MethodInvocation.getMethod(invocation);
       message    = method: + method.getName();
     }
     else if (invocation.getType() == InvocationType.CONSTRUCTOR)
     {
       Constructor c = ConstructorInvocation.getConstructor(invocation);
       message    = constructor: + c.toString();
     }
     else
     {
       // Do nothing for fields. Just too verbose.
       return invocation.invokeNext();
     }
  
     System.out.PRintln(Entering + message);
  
     // Continue on. Invoke the real method or constructor.
     InvocationResponse rsp = invocation.invokeNext();
     System.out.println(Leaving + message);
     return rsp;
    }
  }
  
  运行例子2
  
以下内容为程序代码 以下内容为程序代码
POJO类将扩展一点,增加get()和set()方法。
  public class POJO
  {
    public POJO() {}
    public void helloWorld() { System.out.println(Hello World!); }
  
    private int counter = 0;
  
    public int getCounter() { return counter; }
    public void setCounter(int val) { counter = val; }
    public static void main(String[] args)
    {
     POJO pojo = new POJO();
     pojo.helloWorld();
     pojo.setCounter(32);
     System.out.println(counter is: + pojo.getCounter());
    }
  }
  TracingInterceptor将拦截对main(),POJO()和helloWorld()调用。输出应该看起来如下:
  Entering constructor: public POJO()
  Leaving constructor: public POJO()
  Entering method: helloWorld
  Hello World!
  Leaving method: helloWorld
  

  
  你能够在这里下载JBoss AOP和离子代码。编译和执行:
  $ cd oreilly-aop/example2
  $ eXPort CLASSPATH=.;jboss-common.jar;jboss-aop.jar;javassist.jar
  $ javac *.java
  $ java -Djava.system.class.loader=org.jboss.aop.standalone.SystemClassLoader POJO
  
  例子3.使用导言
  假如我们能够为特定的实例关闭和打开,那将很酷。JBoss AOP有一个API,他绑定元数据到一个对象实例,但是让我们伪装一个实际的跟踪API是一个更好的方案。在这例子中,我们通过用一个导言,将改变POJO类的本身的定义。我们将强制POJO类去实现一个跟踪借口和提供混合类,这个混合类处理新的跟踪API。这将是跟踪借口:
  
  public interface Tracing
  {
    public void enableTracing();
    public void disableTracing();
  }
  
  定义一个混合的类
  Tracing接口将在混合类中实现。当一个POJO是实例时,一个混合对象混合类将绑定到POJO类。下面是实现:
  
  import org.jboss.aop.Advised;
  
  public class TracingMixin implements Tracing
  {
    Advised advised;
  
    Public TracingMixin(Object obj)
    {
     this.advised = (Advised)obj;
    }
  
    public void enableTracing()
    {
     advised._getInstanceAdvisor().getMetaData().addMetaData(
    "tracing", "filter", true);
    }
  
    public void disableTracing()
    {
     advised._getInstanceAdvisor().getMetaData().addMetaData(
    "tracing", "filter", false);
    }
  }
  
  enableTracing()方法绑定filter属性到对象实例。在disableTracing()方法作同样的事,但是制定filter属性为false。这两个方法是元数据能够怎么样用于超过一个类级别。元数据也能够实例级的应用。元数据应用在实例级别。
  
  绑定一个导言
  好了,所以我们定义跟踪接口,并且实现这个混合类。下一步是应用导言到POJO类。像拦截器,我们必须在xml中定义一个ponitcut。让我们看一下这项什么。
  
  <?xml version="1.0" encoding="UTF-8">
  <aop>
    <introduction-pointcut class="POJO">
     <mixin>
       <interfaces>Tracing</interfaces>
       <class>TracingMixin</class>
       <construction>new TracingMixin(this)</construction>
     </mixin>
    </introduction-pointcut>
  </aop>
  
  上面的pointcuts将强制POJO类实现Tracing接口。现在,当一个POJO实例被初始化,一个TracingMixin也将被实例化。TracingMixin被初始化的途径被定义在<contstruction>标签中。你能够把想要的任一行Java代码放入在<contstruction>标签中。
  
  运行例子3
  POJO类为了显示TracingAPI怎么被访问,它已经被扩展了一点。TracingInterceptor仍然和例子2一样。
  
  
以下内容为程序代码 以下内容为程序代码
public class POJO
  {
    public POJO() {}
    public void helloWorld() { System.out.println(Hello World!); }
  
    public static void main(String[] args)
    {
     POJO pojo   = new POJO();
     Tracing trace = (Tracing)this;
     pojo.helloWorld();
  
     System.out.println("Turn off tracing.");
  
     trace.disableTracing();
     pojo.helloWorld();
  
     System.out.println("Turn on tracing.");
  
     trace.enableTracing();
     pojo.helloWorld();
    }
  }
  

  注重我们转换POJO到Tracing接口。输出应该看起来这样:
  
  Entering constructor: POJO()
  Leaving constructor: POJO()
  Entering method: helloWorld
  Hello World!
  Leaving method: helloWorld
  Turn off tracing.
  Entering method: disableTracing
  Leaving method: disableTracing
  Hello World!
  Turn on tracing.
  Entering method: helloWorld
  Hello World!
  Leaving method: helloWorld
  
  注重被增加到TracingInterceptor 中的interceptor-pointcut也应用到那些通过Tracing 导言导入的方法中。
  为了编译和运行这个例子:
  
  $ cd oreilly-aop/example3
  $ export CLASSPATH=.;jboss-common.jar;jboss-aop.jar;javassist.jar
  $ javac *.java
  $ java -Djava.system.class.loader=org.jboss.aop.standalone.SystemClassLoader POJO
  
  结论
  面向方面编程对于软件开发是一个强有力的新工具。为了使你的软件开发过程更加动态和流畅,用JBoss4.0,你能够实现你自己的拦截器,元数据和导言。更具体的文档参见我们的站点www.jboss.org。那会有一些惊异等着你,象我们已经在我们新的框架上实现了一套服务。拥有它并恰当的使用。

Tags:面向 方面 编程

编辑录入:爽爽 [复制链接] [打 印]
赞助商链接