跟我学AspectJ（四）

 

第二章          AspectJ 语言 office:office" />

 

通知 (Advice)

       通知定义几个方面的实现，以便于在特定的程序运行段执行。这些特定段可以使用命名的切点给出也可以使用匿名切点。下面是一个使用命名切点的通知的例子：

 pointcut setter(Point p1, int newval): target(p1) && args(newval)

                                         (call(void setX(int) ||

                                          call(void setY(int)));

 

 before(Point p1, int newval): setter(p1, newval) {

      System.out.println("About to set something in " + p1 +

                         " to the new value " + newval);

 }

使用匿名切点也可以实现同样的通知，如下

 before(Point p1, int newval): target(p1) && args(newval)

                                (call(void setX(int)) ||

                                 call(void setY(int))) {

      System.out.println("About to set something in " + p1 +

                         " to the new value " + newval);

 }

下面是一些不同的通知

这个before 通知在匿名切点捕捉到连接点之前运行

 before(Point p, int x): target(p) && args(x) && call(void setX(int)) {

      if (!p.assertX(x)) return;

 }

这个after 通知在匿名切点捕捉各个连接点之后运行，无论程序是正常返回还是抛出异常。

 after(Point p, int x): target(p) && args(x) && call(void setX(int)) {

      if (!p.assertX(x)) throw new PostConditionViolation();

 }

下面的after 通知在匿名切点捕捉到连接点后且仅仅在程序正常返回的情况下在运行。

 after(Point p) returning(int x): target(p) && call(int getX()) {

      System.out.println("Returning int value " + x + " for p = " + p);

 }

下面的after 通知在匿名切点捕捉到连接点后且程序抛处异常的情况下运行。

 after() throwing(Exception e): target(Point) && call(void setX(int)) {

      System.out.println(e);

 }

around 通知可以取代被捕捉的连接点而执行它自己定义的逻辑，程序原有的逻辑可以通过调用一个特定的方法proceed 执行。

void around(Point p, int x): target(p)

                          && args(x)

                          && call(void setX(int)) {

    if (p.assertX(x)) proceed(p, x);

    p.releaseResources();

}

 

类型间声明 (Inter-type declarations)

       方面能够声明属于其他类型的成员（字段、方法和构造子）。这些被称为类型间成员。方面也能够声明实现新接口或扩展一个新类的其他类型。这里有一些这样的声明的例子。

 

下述声明每个Server 对象有一个名为disabled 的boolean 类型字段，其初始值为false ：

       private boolean Server.disabled=false;

这里声明了一个私有的字段，只有这个方面能够访问这个字段。就算是Server 对象本身有另一个私有字段disabled （在Server 内或其他方面里定义）也不会产生名字冲突，因为对于disabled 引用没有二义性。

 

下面代码段声明每个Point 对象有一个名为getX 的方法，它返回各自x 变量的值：

       public int Point.getX(){ return this.x;}

在方法内部，this 就是当前执行的Point 对象。因为方法声明为公共方法，所以任何代码都能调用它，但是如果有另一个Point.getX() 声明，那么就会产生编译期的冲突。

 

下面的公有声明定义Point 对象的一个构造函数，它有两个整型参数：

       public Point.new(int x,int y){       this.x=x;this.y=y;     }

 

下面是一个公有字段声明：

       public int Point.x=0;

它为 Point 对象声明了一个 x 公有字段并初始化为 0 ，因为字段是公有的，在任何地方都可以访问它，所以如果还有另一个 x 字段，则会产生冲突。

 

下面声明了 Point 类实现的接口 Comparable

       declare parents : Point implement Comparable;

当然，除非 Point 类实现了接口的方法，否则会有错误。

 

下面则为 Point 类声明了其扩展的类 GeometricObject

       declare parents : Point extends GeometricObject;

 

一个方面可以有多个类型间声明。例如下面的声明。

       Public String Point.name;

       Public void Point.setName(String name){       this.name=name; }

类型间成员仅仅能够有一个目标类型，但是通常你可能想要在多个类型上声明相同的成员。这可以通过联合使用类型间成员和一个私有接口实现。

 aspect A {

    private interface HasName {}

    declare parents: (Point || Line || Square) implements HasName;

 

    private String HasName.name;

    public String HasName.getName() { return name; }

 }

这里声明了一个 HasName 接口，并声明 Point 、 Line 或 Square 都实现这个接口。而且为接口声明了私有字段 name 和公有方法 getName 。

 

类型间变量的作用域

       AspectJ 允许私有、包保护（缺省）以及公有的类型间声明。私有意味着与 aspect 有私有关系，而与目标对象无关（即目标对象不知道变量或方法的存在）。因此，如果一个方面作出一个字段的私有类型间声明

       Private int Foo.x;

那么方面中的代码可以访问 Foo 的 x 字段，其他类或方面都不行。类似地，如果一个方面作出一个包保护类型间声明

       int Foo.x;

那么在包中的任何代码都可以访问它，包外的代码无权访问。

 

举例： PointAssertions

这个例子包括一个类和一个方面。方面为 Point 声明了私有的 assertion 方法 assertX 和 assertY 。利用这两个断言方法方面对 setX 和 setY 方法的调用提供了保护。断言方法声明为私有是因为没有其他地方需要用到它们，只有方面内部可以使用这些方法。

 class Point {

      int x, y;

      public void setX(int x) { this.x = x; }

      public void setY(int y) { this.y = y; }

 

      public static void main(String[] args) {

          Point p = new Point();

          p.setX(3);

p.setY(333);// 非法的 Y 值

      }

 }

 

 aspect PointAssertions {

           // 如果 X 或 Y 的值不在 0 到 100 之间，则视为非法。

      private boolean Point.assertX(int x) {

          return (x <= 100 && x >= 0);

      }

      private boolean Point.assertY(int y) {

          return (y <= 100 && y >= 0);

      }

      before(Point p, int x): target(p) && args(x) && call(void setX(int)) {

          if (!p.assertX(x)) {      // 若非法输入 X ，则输出提示信息

              System.out.println("Illegal value for x"); return;

          }

      }

      before(Point p, int y): target(p) && args(y) && call(void setY(int)) {

          if (!p.assertY(y)) {      // 若非法输入 Y ，则输出提示信息

              System.out.println("Illegal value for y"); return;

          }

      }

 }

 

thisJoinPoint

       AspectJ 提供了一个特别的引用变量， thisJoinPoint ，它包含了当前连接点处的相关信息并可以被通知使用。 ThisJoinPoint 变量仅仅可以在通知环境中被使用，就象 this 仅能用于非静态方法和构造函数环境中一样。在通知中， thisJoinPoint 是 org.aspectj.lang.JoinPoint 类型的变量。使用它的一个简单作用是直接输出它。和其他 Java 对象一样， thisJoinPoint 有一个 toString() 方法简化了格式化的输出：

 class TraceNonStaticMethods {

      before(Point p): target(p) && call(* *(..)) {

          System.out.println("Entering " + thisJoinPoint + " in " + p);

      }

 }

thisJoinPoint 可以被用来访问静态和动态信息，比如说参数等：

       thisJoinPoint.getArgs();

另外，它持有一个包括所有静态信息的对象，可以通过以下方法得到该对象的引用：

       thisJoinPoint.getStaticPart();

如果你仅需要关于连接点处的静态信息，你可能访问连接点的静态部分直接使用变量 thisJoinPointStaticPart 。使用它将避免运行时直接使用 thisJoinPoint 创建连接点对象。

 

通常情况下

   thisJoinPointStaticPart == thisJoinPoint.getStaticPart()

 

   thisJoinPoint.getKind() == thisJoinPointStaticPart.getKind()

   thisJoinPoint.getSignature() == thisJoinPointStaticPart.getSignature()

   thisJoinPoint.getSourceLocation() == thisJoinPointStaticPart.getSourceLocation()

还有一个相关变量： thisEnclosingJoinPointStaticPart 。它与 thisJoinPointStaticPart 类似，使用它可以打印调用者的位置，例如

   before() : execution (* *(..)) {

     System.err.println(thisEnclosingJoinPointStaticPart.getSourceLocation())

   }

 

导读

本系列下一章将使用 AspectJ 实现一些具体的例子，以便读者可以加强对 AspectJ 的理解并熟悉各种语法。