GluonJ

GluonJ是一个简单的面向切面编程(AOP)的java工具.GluonJ针对面向对象的语言(OOP)结构提供了一个极其简单的扩展方式实现了AOP的特性,非常独特：不同于其他流行的AOP框架,没有采用pointcut-advice,而是采用了revisers 和 within methods.

Gluonj是较高级别的API,底层使用javassist进行java类文件处理.

有意思的项目名称：Gluon+J,J指的是java,Gluon翻译后是胶子(物理名词),gluonJ的特性与胶子还真是有几分相似之处.项目的作者对物理也有研究?

Gluonj的HelloWold

原始类:Person

扩展类:SayHello

package test;
public class Person {
    public void greet() {
        System.out.println("Hi!");
    }
    public static void main(String[] args) {
        new Person().greet();
    }
}

package sample;
public class SayHello revises test.Person {
    public void greet() {
        System.out.println("Hello!");
    }
}

编译&运行:

#编译类文件
java -jar GluonJCompiler.jar test/Person.java sample/SayHello.java
#织入代码
java -jar gluonj.jar test/Person.class sample/SayHello.class
#运行
java test.Person
#输出:
Hello!

注意:

revises不是java原语(在java中通过注解@revises使用gluonJ会在下文中介绍),在eclipse中会显示错误,编译需要通过GluonJCompiler内置的编译器进行解析编译.

理解GluonJ

简单来讲,GluonJ 编译器把reviser 转换为一个普通的java 子类.所有target class(原始类)实例的行为将转换(通过调用)为该子类实例的行为.(在下文反编译后的文件可看到)

术语

reviser:中文翻译为修订者或校对者
扩展类,类似java继承.该类中使用revises( within、requires、using等 )语句对原始类(target)进行扩展。
target class:原始类,编译后target class的字节码将被修改.

compilation&post-compile transformation
gluonJ编译包含两步:source-to-bytecode translation 和 bytecode-to-bytecode translation,我们称之为compilation 和 post-compile transformation.
compilation 过程使用GluonJCompiler.jar完成源码(文本文件)到字节码的转换
过程类似javac,参数(option)与javac也基本兼容.
post-compile 过程使用gluonj.jar完成字节码修改,以实现代码织入
该过程接受三个选项:-debug(开启调试模式),-d(输出文件夹),-cp(class path)。并注意参数是.class文件不是.java文件.
代码织入并非将reviser中代码放入原始类中,而是在原始类中加入reviser的执行句柄.

反编译后的Person.class文件

反编译后的SayHello.class文件

package test;
import java.io.PrintStream;
import sample.SayHello;

public class Person
{
  public void greet()
    throws 
  {
    System.out.println("Hi!");
  }
  public static void main(String[] args) throws  {
    new SayHello().greet();
  }
}

package sample;

import java.io.PrintStream;
import javassist.gluonj.Reviser;
import test.Person;

@Reviser
public class SayHello extends Person
{
  public void greet()
    throws 
  {
    System.out.println("Hello!");
  }

  private void _init()
    throws 
  {
  }
}

每次都是new一个对象么?是否会影响效率,如何保持数据状态,需要做进一步实验或查看相关gluonj的实现.

功能&特性

reviser与子类(subclass)很像(但不是).可基本(出去下文中的限制部分)按照子类的方式实现reviser类.
可扩展的行为(这些行为都将附加到原始类中)包括:
添加新方法、重写方法（可通过super调用原方法），实现新的接口
reviser的安全性遵从java，可访问target class可见成员,不能访问私有(private)成员,不能重写final方法.
可以重写static方法

限制

target class中的每个构造函数都需要在reviser中声明(可以理解为overriding).
reviser不能重载(overloading)或添加构造函数
reviser不能声明构造函数，当你需要一个新的构造函数时，只能在reviser中使用工厂方法（factory method）
reviser不能声明多个within 方法
可以通过使用多个reviser（revise相同类）的方式实现此目的。
reviser不能被实例化.
不能定义reviser的子类(subclass)

各种详细用法:

Ant task

load-time weaving

Load-time weaving without a Java agent

Override static methods

Requires

Using

WithIn methods

Using a reviser in Java

--Grouping

--Accessing new members added by revisers

--Constructors of an @Reviser class

Ant task

GluonJ程序的编译过程(当前只有post-compile)可以配置为一个ant task.示例如下

<?xml version="1.0"?>
<project name="hello" basedir=".">
    <taskdef name="weave" classname="javassist.gluonj.ant.taskdefs.Weave">
        <classpath>
            <pathelement location="./gluonj.jar"/>
        </classpath>
    </taskdef>

    <target name="weave">
        <weave destdir="./out" debug="false" >
            <classpath>
                <pathelement path="./classes"/>
            </classpath>
            <fileset dir="./classes" includes="test/**/*" />
        </weave>
    </target>
</project>

熟悉ant的童鞋一看就明白了,在此就不多介绍了.(debug参数同post-compile中debug参数).

load-time weaving 加载时织入

post-compile可以在加载时在执行.采用此方式时,需要在jvm启动参数中添加-javaagent.示例如下:

java -javaagent:gluonj.jar=sample.SayHello test.Person

注意事项:

"gluonj.jar=”后是reviser的名字(注意没有后缀).多个riviser时,使用英文逗号进行分割.
-javaagent:…是一个VM参数,在使用ecilpse或其他IDE启动时需要注意进行相应配置.
如果需要查看详细的日志信息,需要使用debug参数,类似:
```
java -javaagent:gluonj.jar=debug:sample.SayHello test.Person
```
注意debug的位置.

Load-time weaving without a Java agent 不使用java agent在加载时织入

不适用VM参数-javaagent 而在加载时织入的办法是,写类似如下的启动类:

import javassist.gluonj.util.Loader;
public class Runner {
    public static void main(String[] args) throws Throwable {
        Class mainClass = test.Person.class;
        Class[] revisers = { sample.SayHello.class };
        Loader.run(mainClass, args, revisers);
    }
}

编译及运行:

javac -cp .:gluonj.jar Runner.java 
java -cp gluonj.jar Runner

此方法的思路是编写自定义的启动类,该启动类中调用gluon的api,以实现类的织入.此方法支持在运行期间动态织入,但需要注意原始类(Person.class)需要之前没有被当前classloader加载过,否则可能会织入失败.运行期间做类的修改建议直接调用javassist或其他classworking的工具进行修改.

Override static methods 重写static方法

不同于普通class,reviser可重写target class的static方法,例如:

target clas

reviser

package test;
public class Fact {
    public static int fact(int n) {
        if (n == 1)
            return 1;
        else
            return n * fact(n - 1);
    }
    public static void main(String[] args) {
        System.out.println(fact(5));
    }
}

package sample;
import test.Fact;
public class FactLogger revises Fact {
    public static int fact(int n) {
        System.out.println("* " + n);
        return Fact.fact(n);
    }
}

编译在反编译后:

Fact.class

FactLogger.class

package test;

import java.io.PrintStream;
import sample.FactLogger;

public class Fact
{
  public static int fact(int n)
    throws 
  {
    if (n == 1) {
      return 1;
    }
    return n * FactLogger.fact(n - 1);
  }
  public static void main(String[] args) throws  {
    System.out.println(FactLogger.fact(5));
  }
}

package sample;

import java.io.PrintStream;
import javassist.gluonj.Reviser;
import test.Fact;

@Reviser
public class FactLogger extends Fact
{
  public static int fact(int n)
    throws 
  {
    System.out.println("* " + n);
    return Fact.fact(n);
  }

  private void _init()
    throws 
  {
  }
}

可以看到Fact.fact方法被修改了.细心的童鞋会发现这里可能会有个疑问:main方法中的Fact.fact的调用也被改成了FactLogger.fact,如果有一个类比如TestA也调用了Fact.fact方法,由于编译的时候没有将TestA.class列入到参数列表中,那么TestA中的Fact.fact(5)调用不会被修改,那么结果将产生4条输出.log还好,那如果FactLogger在return时做了 -1操作,那就会有问题了.读者可做个测试.在实际应用中要注意此问题.(当然如果只是log不会有啥大问题).

Requires

gluonJ允许在同一个target class上有多个reviser,在这种情况下,需要通过requires语句指定revisers的顺序.

package sample;
public class GoodDay requires SayHello revises test.Person {
    public void greet() {
        super.greet();
        System.out.println("It's a good day today.");
    }
}

gluon将按照顺序对target class进行扩展.方法调用的顺序采用Last In First Out(LIFO)的方式.在上例中,调用Greet方式时,GoodDay中的greet将首先被调用,由于方法中调用super.greet(),所以SayHello中的greet方法被调用.所以输出结果会是:Hello! It's a good day today. 反编译后的文件.

可以理解为:GoodDay extend SayHello,SayHello extend test.Person .(实际上也类似)

编译(post compile)时,也需要保持顺序:

java -jar gluonj.jar test/Person.class sample/SayHello.class sample/GoodDay.class

load time weaving:

java -javaagent:gluonj.jar=sample.GoodDay test.Person

load time weaving模式下 GluonJ 会自动加载所有的required revisers,所以不必:

java -javaagent:gluonj.jar=sample.GoodDay,sample.SayHello test.Person

既然在l-t-w模式下,gluonj会自动加载所有的requires revisers,所以你可以写一个reviser,该reviser直接或间接的requires 所有必要的revisers,这样在运行程序是只需要指定该reviser做为load time weaver的参数.

Using

Reviser R可以访问 R requires的其他revisers添加的可见成员.例如:

LinkNode:

package test;
public class LinkNode {
    protected LinkNode next = null;
    public static void main(String[] args) {
        LinkNode n = new LinkNode();
        System.out.println(n);
    }
}

IntNode:

package sample;
import test.LinkNode;
public class IntNode revises LinkNode {
    public int value;
    public int get() { return value; }
}

PrintableNode:

package sample;
import test.LinkNode;
public class PrintableNode requires IntNode  revises LinkNode {
    public String toString() { return "Node:" + get() + " " + value; }
}

PrintableNode requires IntNode,就可以访问IntNode中的get方法. 通过前面的分析可知,PrintableNode在编译后继承了IntNode,当然就可以调用IntNode中的get方法了.

Normal class 可通过Using声明访问Reviser成员.

package test;
using sample.IntNode;
public class NodeTest {
    public static void main(String[] args) {
        LinkNode n = new LinkNode();
        System.out.println(n.value);
    }
}

using语句类似import语句,声明了要访问的reviser.

编译(编译后class及反编译下载)&执行语句:

java -jar GluonJCompiler.jar test/LinkNode.java sample/IntNode.java sample/PrintableNode.java test/NodeTest.java
java -jar gluonj.jar test/LinkNode.class sample/IntNode.class sample/PrintableNode.class test/NodeTest.class
java -cp . test/NodeTest
结果:0

反编译后的程序还是挺有意思的.试想如果在编译的时候去掉printableNode,会是什么结果呢?

WithIn methods

reviser中可以声明一个within方法.声明了with的方法当调用者是指定的方法或类才生效.用法类似aspectj的pointcut.示例如下:

Position类

package test;
public class Position {
    public int x;
    public void rmove(int dx) { setX(x + dx); }
    public void setX(int newX) {
        System.out.println("setX");
        x = newX;
    }
}

PosTest类

package test;
public class PosTest {
    public static void main(String[] args) {
        Position p = new Position();
        p.setX(5);
        p.rmove(11);
    }
}

PosLgger类

package sample;
public class PosLogger revises test.Position {
    public void setX(int newX) within test.PosTest.main(String[]) {
        System.out.println("x: " + x + ", newX: " + newX);
        super.setX(newX);
    }
}

编译&运行:

java -jar GluonJCompiler.jar test/Position.java sample/PosLogger.java  test/PosTest.java
java -jar gluonj.jar test/Position.class sample/PosLogger.class test/PosTest.class 
java -cp . test/PosTest
输出:
x: 0, newX: 5
setX
setX

可发现PosTest.main方法调用的setX增加了日志输出,rmove调用的setX没有增加日志输出.

通过反编译可知,within语句在reviser和target class中增加了setX_aop1的方法,reviser中的setX_aop1方法中做了日志输出.

within只能声明一个class name,如果希望该类中所有调用该方法的方法都触发,上例中做如下修改即可:

package sample;
public class PosLogger revises test.Position {
    public void setX(int newX) within test.PosTest {
        System.out.println("x: " + x + ", newX: " + newX);
        super.setX(newX);
    }
}

Using a reviser in Java 在java中使用reviser

我们还可以通过java注解的方式对plain java使用Gluonj.因此也可以使用一般的java编译器(javac)编译,完成源代码对字节码的转换.然后使用post-compile的方式运行.事实上之前的第一步(compiletation)就是将gluonj程序转换为使用了注解的java 字节码.

使用注解重写SayHello reviser:

package sample;
import javassist.gluonj.Reviser;

@Reviser public class SayHello extends test.Person {
    public void greet() {
        System.out.println("Hello!");
    }
}

编译&run:

javac -cp .:gluonj.jar test/Person.java sample/SayHello.java
java -jar gluonj.jar test/Person.class sample/SayHello.class
java test.Person

--load-time weaving:

javac -cp .:gluonj.jar test/Person.java sample/SayHello.java
java -javaagent:gluonj.jar=sample.SayHello test.Person

--require:

package sample;
import javassist.gluonj.Reviser;
import javassist.gluonj.Require;

@Reviser @Require(SayHello.class)
public class GoodDay extends test.Person {
    public void greet() {
        super.greet();
        System.out.println("It's a good day today.");
    }
}

多个requires的情况(需要注意顺序):

@Require({SayHello.class, SayChao.class})

@require是个java.lang.Class的数组.

--within method:

package sample;
import javassist.gluonj.Reviser;
import javassist.gluonj.Within;
import javassist.gluonj.Code;

@Reviser public class PosLogger extends test.Position {
    @Within(test.PosTest.class) @Code("main(java.lang.String[])")
    public void setX(int newX) {
        System.out.println("x: " + x + ", newX: " + newX);
        super.setX(newX);
    }
}

@Within的参数是java.lang.Class

@Code是可选的,描述一个方法的标识(signature),表明只有这个方法的调用才会被revise,如果没有此参数,标识@within描述的Class的所有方法对此方法的调用都会被revise.

注意@Code的参数必须是全路径名称(fully qualified class name).

--Grouping

一个源文件中应该存放多个关注于"同样事情"的revisers.这样做的好处是显而易见的.

可通过在注解了@Reviser的类中使用内嵌static类(也注解了@Reviser)来实现.即相关的reviser通过这样的方式分组到同一个类文件中.内嵌的reviser不必是相同的target class.例如:

package sample;
import javassist.gluonj.Reviser;

@Reviser public class Say {
    @Reviser public static class SayHello extends test.Person {
        public void greet() {
            System.out.println("Hello!");
        }
    }

    @Reviser public static class GoodDay extends test.Person {
        public void greet() {
            super.greet();
            System.out.println("It's a good day today.");
        }
    }
}

test.Say是Person的reviser的聚合类.这些static nested classes非显示被Say所require.require的顺序是按照字母顺序(此顺序依赖编译器).值得注意的是,Say的父类(或target class)并没有显示的描述.这样一个@Reviser的类并没有revise任何类.Say只是requires其内嵌的static且注解了@Reviser的类.

内嵌的SayHello与GoodDay并须是static类.Inner class不能注解@Reviser.

运行:

javac -cp .:gluonj.jar test/Person.java sample/Say.java
java -javaagent:gluonj.jar=sample.Say test.Person

在第二行执行语句中sample.Say作为参数传入,它自动将其@Require的类织入.
--Accessing new members added by revisers

使用java注解的方式实现reviser,使访问reviser新增的成员变得繁琐。由于java编译器不解析reviser的语义，当需要访问一个由reviser添加的成员时，你必须显示的将对象实例转化为reviser类型来绕过(欺骗)java编译器.见下面的例子:

package sample;
import test.LinkNode;
import javassist.gluonj.Reviser;
import javassist.gluonj.Require;
import static javassist.gluonj.GluonJ.revise;

@Reviser @Require(IntNode.class)
public class PrintableNode extends LinkNode {
    public String toString() {
        IntNode in = (IntNode)revise(this);
        return "Node:" + in.get() + " " + in.value;
    }
}

为了访问IntNode添加的get方法（PrintableNode继承了LinkNode,get方法对其是不可见的）,toString方法中将this从PrintableNode转换为IntNode。

revise是GluonJ中的静态方法,将对象实例转做类型转换.revise方法等同于:

public String toString() {
    IntNode in = (IntNode)(Object)this;
    return "Node:" + in.get() + " " + in.value;
}

在jdk1.6的java编译器中支持这种转换方式.(先转换为Object,在转换为IntNode来绕过方法的继承检验?)

注意:

@Require注解仍然是需要的,以描述reviser的优先顺序.如果不指定IntNode与PrintableNode的顺序,将会报错.
using语句没有对应的java注解,using只是控制reviser添加成员的可见性.

--Constructors of an @Reviser class

在上文reviser的限制中介绍了关于构造函数的限制:不能有子类,不能实例化,构造函数必须实现target class中所有的构造函数等.下面用实例来说明:

target class Counter

reviser:Incrementable

package test;
import sample.Incrementable;
import static javassist.gluonj.GluonJ.revise;

public class Counter {
    protected int counter;
    public Counter(int c) { counter = c; }
    public int get() { return counter; }
    public void decrement() {
        if (--counter <= 0)
            throw new RuntimeException("Bang!");
    }
    public static void main(String[] args) {
        Counter c = new Counter(1);
        ((Incrementable)revise(c)).increment();
        c.decrement();
        System.out.println(c.get());
    }
}

package sample;
import javassist.gluonj.Reviser;

@Reviser public class Incrementable extends test.Counter {
    private int delta;
    public Incrementable(int c) {
        super(c);
        delta = 1;
    }
    public void increment() {
        counter += delta;
    }
}

Counter中定义了一个构造函数,所以reviser中也定义了一个构造函数.如果Counter中定义了多个构造函数,那Incrementable中也需要定义同样数量(请同样参数)的构造函数.

为了方便,如果target class定义了多一个构造函数,Reviser可以只定义一个默认的无参的构造函数.如果target class没有定义无参构造函数,那么reviser必须调用(call)target class的其他构造函数,然而,当reviser织入后,这个调用将被忽略。示例：

package sample;
import javassist.gluonj.Reviser;

@Reviser public class Incrementable extends test.Counter {
    private int delta;
    public Incrementable() {
        super(0);
        delta = 1;
    }
    public void increment() {
        counter += delta;
    }
}

当Incrementable织入后，Incrementable构造函数的方法体将被添加到Counter的构造函数中，同时super(0)的调用也被删除了.例如上例中Counter的构造函数将被修改为:

public Counter(int c) {
    counter = c;
    delta = 1;          // copied from the @Reviser class
}

编译代码:

javac -cp .:GluonJCompiler.jar:gluonj.jar test/Counter.java sample/Incrementable.java 
java -jar gluonj.jar test/Counter.class sample/Incrementable.class

源码编译和反编译后的代码下载

反编译后的的class是这样的:

Counter.class

Incrementable.class

package test;

import java.io.PrintStream;
import javassist.gluonj.GluonJ;
import sample.Incrementable;

public class Counter
{
  protected int counter;

  public Counter(int paramInt)
  {
    this.counter = paramInt; } 
  public int get() { return this.counter; } 
  public void decrement() {
    if (--this.counter <= 0)
      throw new RuntimeException("Bang!"); 
  }

  public static void main(String[] paramArrayOfString) {
    Incrementable localIncrementable = new Incrementable(1);
    ((Incrementable)GluonJ.revise(localIncrementable)).increment();
    localIncrementable.decrement();
    System.out.println(localIncrementable.get());
  }
}

package sample;

import javassist.gluonj.Reviser;
import test.Counter;

@Reviser
public class Incrementable extends Counter
{
  private int delta;

  public void increment()
  {
    this.counter += this.delta;
  }

  private void _init()
  {
    0;
    this.delta = 1;
  }

  public Incrementable(int paramInt)
  {
    super(paramInt);
    Object localObject = null;
    super._init();
  }
}

实在是有意思,和官方文档描述的差别还是挺大的:

Counter构造函数没有发生变化,调用构造函数的地方被修改成了调用reviser的构造函数
Reviser中的无参构造函数改成了有参构造函数.

童鞋们在使用的时候一定要注意此处,特别是有其他代码调用构造函数的情况.

posted @ 2011-06-03 15:05 redcreen 阅读(2676) 评论(0) 编辑收藏举报

刷新页面返回顶部

redcreen的专栏

GluonJ