框架结构

　　asm字节码处理框架是用java开发的而且使用基于访问者模式生成字节码及驱动类到字节码的转换。这允许开发人员避免直接处理方法字节码中的类常量池及偏移，因此为开发人员隐藏了字节码的复杂性并且相对于其他类似工具如bcel, serp, or javassist提供了更好的性能。
asm分为几个包更方便灵活地构建。包结构图如图1。

　　figure 1. arrangement of asm packages

　　?core包提供了读/写/转换字节码的api而且是其他包的基础。这个包已经足够生成java字节码而且能够实现大部分的字节码转换。
　　?tree包提供了java字节码的内存内表示。
　　?analysis包为存储在来自tree包结构中的java方法字节码提供了基础的数据流分析和类型检查算法。
　　?commons包（asm2.0增加）提供了几个通用的字节码转换和简化字节码生成的适配器。
　　?util包包含几个助手类和简单的字节码较验器来方便开发和测试。
　　?xml包提供了与xml文件相互转换的字节码结构适配器，及兼容sax而且允许使用xslt来定义字节码转换方式的适配器。

　　后面几节会给出asm框架中core包的介绍。为了更好地理解这个包的组织结构，你最好有一些在jvm规范中定义的字节码结构的基础了解。下面是较高级别的类文件格式图（[*]标识重复的结构）
    
  [1]-------------------------------------------+
   | header and constant stack                  |
   +--------------------------------------------+
   | [*] class attributes                       |
  [2]------------+------------------------------+
   | [*] fields  | field name, descriptor, etc  |
   |             +------------------------------+
   |             | [*] field attributes          |
  [3]------------+------------------------------+
   | [*] methods | method name, descriptor, etc |
   |             +------------------------------|
   |             | method max stack and locals  |
   |             |------------------------------|
   |             | [*] method code table        |
   |             |------------------------------|
   |             | [*] method exception table   |
   |             |------------------------------|
   |             | [*] method code attributes   |
   |             +------------------------------|
   |             | [*] method attributes        |
   +-------------+------------------------------+

　　需要注意的一些地方:

　　?所有使用在类结构中的描述符，字符串和其他常量都存储在类文件开始的常量堆栈中，来自其他结构的引用是基于堆栈的序号。

　　?每一个类必须包含头部（包括类名，父类，接口等）和常量堆栈。而其他元素如字段列表/方法列表/属性列表都是可选的。

　　?每一个方法段包含相同的头信息和最大最小局部变量数的信息，这些是用来校验字节码的。对非抽象和非原生方法，还包含一个方法指令表，一个异常表及代码属性。此外，还可能有其他的方法属性。

　　?类的每一个属性，成员/方法/方法代码都有自己的名字，具体细节可参考jvm规范的类文件格式部分。这些属性代表字节码的各种信息，如源文件名/内部类/标识（用来存储泛型）/行号/局部变量表和注解。jvm规范也允许定义自定义的属性来包含更多的信息但标准实现的vm不会识别。注：java5注解实际上已经废弃了那些自定义属性，因为注解在主义上允许你表达更多的东西。

　　?方法代码表包含jvm的指令列表。一些指令（就像异常/行号/局部变量表）使用代码表中的偏移值并且所有这些偏移的值可能需要在指令从方法代码表中增删时相应调整。

　　如你所见，字节码转换并不容易。但是，asm框架减少了潜在的结构复杂性并且提供简化的api允许所有字节码信息的访问和复杂的转换。

　　基于事件的字节码处理

　　core包使用推方案（类似访问者模式，在sax api就使用了这种模式处理xml）来遍历复杂的字节码结构。asm定义了几个接口，如classvisitor，fieldvisitor，methodvisitor和annotationvisitor。annotationvisitor是一个特殊的接口允许你表达层次的注解结构。下面的几幅图显示这些接口是如何相互交互及配合使用实现字节码转换和从字节码获取信息。

　　core包逻辑上可怜分为两大部分：

　　1、字节码生产者，如classreader或者按正确顺序调用了上面的访问者类的方法的自定义类。
　　2、字节码消费者，如输出器（classwriter, fieldwriter, methodwriter, and annotationwriter），适配器（classadapter and methodadapter）或者其他实现了访问者接口的类。

　　图2给出了通用生产者/消费者交互过程的时序图。

　　figure 2. sequence diagram for producer-consumer interaction

　　在这个交互过程中，客户端应用首先创建了classreader并调用accept()方法（以classvisitor实例作为参数）。然后classreader解析类并对每一个字节码断发送“visit”事务给classvisitor。对循环的上下文，如成员/方法/注解，classvisitor可以创建继续扑克相应接口（fieldvisitor, methodvisitor, or annotationvisitor）的子访问者并返回给生产者。如果生产者接收到一个空值，他简单地忽略类的那部分（如在由访问者驱动的“延迟加载”特性时就不需要解析相应的字节码部分）；否则相应的子上下文事件就传递给子访问者实例。当子上下文结束时，生产者调用visitend()方法然后移到下一部分。

　　字节码消费者可以通过手工传递事件给下一个链中的访问者或者使用来自传递所有访问方法给内部的访问者的classadapter/ methodadapter的访问者通过“响应链”模式连接起来。这些代理者一方面字节码的消费者方面另一方面也作为字节码的生产者。他们在实现特定的字节码转换时可以修改原始的代理方式：
　　1、访问调用代理可以在删除类成员/方法/方法指令时被忽略。
　　2、访问调用参数可以在重命名类/方法/类型时被修改。
　　3、新访问调用可以在引入新成员/方法/注入新代码到现存代码时被增加。

　　classwriter访问者可以终结整个处理链，他也是最终字节码的生成者。例如：

  classwriter cw = new classwriter(computemax);
  classvisitor cc = new checkclassadapter(cw);
  classvisitor tv = 
    new traceclassvisitor(cc, new printwriter(system.out));
  classvisitor cv = new transformingclassadapter(tv);
  classreader cr = new classreader(bytecode);
  cr.accept(cv, skipdebug);
  byte[] newbytecode = cw.tobytearray();

　　在上面的代码中，实现了自定义的类转换并且将结果人作为参数传给traceclassvisitor的构造函数。traceclassvisitor打印转换的类并传递给checkclassadapter（这是用来作简单的字节校验后传递给classwriter）。

　　大部分的访问方法接收简单的参数如int,boolean和string。在所有的方法中string参数是字节码中常量的引用，asm使用与jvm一致的方式。例如，所有类名都应该定义在内部格式中。成员和方法描述符应该跟jvm表示一致。泛型信息的表示也类似。这种方式避免了在没有转换时不必要的计算。为了便于构建和解析这样的描述，系统提供了包含一些静态方法的type类：
　　?string getmethoddescriptor(type returntype, type[] argumenttypes)
　　?string getinternalname(class c)
　　?string getdescriptor(class c)
　　?string getmethoddescriptor(method m)
　　?type gettype(string typedescriptor)
　　?type gettype(class c)
　　?type getreturntype(string methoddescriptor)
　　?type getreturntype(method m)
　　?type[] getargumenttypes(string methoddescriptor)
　　?type[] getargumenttypes(method m)

　　注意这些描述符使用了“简单”表示，这意味着不包含泛型信息。泛型信息实际上作为一个单独的字节属性存储，但asm专门对待这个属性并且在相应访问方法中传递泛型标识串作为参数。这个标识串的值也是参照jvm规范，与java代码中的泛型定义唯一映射，并且为工具增加获取额外细节的机会。asm提供了与其他访问者类似的signaturevisitor, signaturereader, and signaturewriter类，如图3所示。

　　figure 3. sequence diagram for signature classes

　　util包中包含了tracesignaturevisitor，已经实现了signaturevisitor而且可以将一个标识值转换成java的泛型定义。下面的例子将一个方法标识转换为java方法定义。

  tracesignaturevisitor v = 
      new tracesignaturevisitor(access);
  signaturereader r = new signaturereader(sign);
  r.accept(v);
  string genericdecl = v.getdeclaration();
  string genericreturn = v.getreturntype();
  string genericexceptions = v.getexceptions();

  string methoddecl = genericreturn + " " + 
    methodname + genericdecl;
  if(genericexceptions!=null) {
    methoddecl += " throws " + genericexceptions;
  }

　　到目前为止，我们已经讨论了asm框架的基本设计方式及类结构处理。但最有趣的部分是asm如何处理方法代码。

　　访问方法代码

　　在asm中，方法定义是由classvisitor.visitmethod()来表示，剩下的方法字节码则由methodvisitor中的许多访问方法来表示。这些方法按照下面的顺序来调用，“*”表示重复的方法而“?”表示方法只能被调用一次。此外，visit...insn 和visitlabel方法必须按照访问代码的字节码指令顺序调用，而visittrycatchblock, visitlocalvariable和visitlinenumber方法必须在标签作为参数传递被访问后才能调用。

　　注意visitend方法必须在方法处理完成后被调用。虽然classreader已经做了这一步，但在使用自定义字节码生产者时要注意一点。还要注意如果一个方法包含字节码（也就是说方法是非抽象或非源生的），那么visitcode必须在第一个visit...insn调用前被调用，而visitmaxs必须在最后一个visit...insn调用后被调用。

　　每一个visitiincinsn, visitldcinsn, visitmultianewarrayinsn, visitlookupswitchinsn, and visittableswitchinsn方法唯一对应一个字节码指令。剩下的visit...insn方法对应多个字节码指令，他们的操作码作为第一个方法参数被传入。所有这些操作码常量被定义在opcodes接口中。这种方式对字节码的解析和格式化非常有效率。不幸的是，这给开发人员生成非法代码的可能，因为classwriter不会校验这些限制。但是，还是有一个checkclassadapter可以被用来在开发期间测试生成的代码。

　　另一个机会是对所有字节码生成或转换可以修改方法代码的偏移并且在方法代码中增删额外的指令时应该自动调整。这对所有的跳转伪指令的参数都兼容的，就如try-catch块，行号和局部变量定义及一些特殊属性一样。但是，asm为开发人员隐藏了这些复杂性。为了定义方法字节码中的位置且不需要使用绝对偏移值，需要传递一个唯一的标签类的实例给visitlabel方法。其他methodvisitor方法如visitjumpinsn, visitlookupswitchinsn, visittableswitchinsn, visittrycatchblock, visitlocalvariable, and visitlinenumber可以使用这些标签实例在visitlabel调用之前，就像实例后在方法后被调用。

　　上面的内容看起来很复杂，好像需要很深奥的字节码指令知识。但是在编译的类上使用asmifierclassvisitor就可以让你知道如何用asm生成给定的字节码。此外，在两个编译的类上（一个原始的和另一个应用特定的转换）使用然后进行比较就可以给出什么样的asm调用应该被使用在转换器上。这个过程在几篇文章中已经详细解释了（可以参看最后的资源部分）。目前已经有了eclipse使用的插件了，如图4，提供了从java源生成asm代码及比较asmifier输出的良好支持，还包含了上下文字节码的参考。

点击查看大图

　　figure 4. eclipse asm plugin (click on the picture to see a full-size image)

　　用asm的访问者来跟踪类的依赖

　　已经有一些文章介绍了如何用asm生成字节码。现在，我们来看一下如何用asm分析已有的类。我们来做一个有趣的应用来获取给定的.jar文件中使用的外部类和包。简单起见，这个例子仅获取外部的依赖而不会取依赖的类型（如父类/方法参数/局部变量类型等）。仅为分析，我们不会创建那些注解/成员/方法的子访问者实例。所有使用的访问者（包括类和标识访问者）都在一个类中实现：

public class dependencyvisitor implements 
    annotationvisitor, signaturevisitor, 
    classvisitor, fieldvisitor, methodvisitor {
...

　　在这个例子中，我们会跟踪包之间的依赖，因此私有类必须包含包名：

  private string getgroupkey(string name) {
    int n = name.lastindexof('/');
    if(n>-1) name = name.substring(0, n);
    packages.add(name);
    return name;
  }

　　为了获取依赖关系，访问者接口如classvisitor, annotationvisitor, fieldvisitor, and methodvisitor应该选择性地集成方法的参数。几个常见的样例如下：

  private void addname(string name) {
    if(name==null) return;
    string p = getgroupkey(name);
    if(current.containskey(p)) {
      current.put(p, current.get(p)+1);
    } else {
      current.put(p, 1);
    }
  }

　　在这个例子中，current是依赖的当前包。另一个例子是类型描述符（注解/枚举/成员类型/newarray指令的参数等）；如ljava/lang/string;, j, and [[[i。这些可以用type.gettype( desc)来获取内部格式的类名：

  private void adddesc(string desc) {
    addtype(type.gettype(desc));
  }

  private void addtype(type t) {
    switch(t.getsort()) {
      case type.array:
        addtype(t.getelementtype());
        break;
      case type.object:
        addname(t.getclassname().replace('.','/'));
        break;
    }
  }

　　在方法定义中的方法描述法及激活指令中的描述参数类型及返回类型。可以通过type.getreturntype(methoddescriptor) 和type.getargumenttypes(methoddescriptor)来解析并取得参数和返回类型。

  private void addmethoddesc(string desc) {
    addtype(type.getreturntype(desc));
    type[] types = type.getargumenttypes(desc);
    for(int i = 0; i < types.length; i++) {
      addtype(types[ i]);
    }
  }

　　而使用在许多“访问”方法中的用来定义java5泛型信息的标识参数是个特例。如果存在，这个参数重写描述符参数并包含编码后的泛型信息。可以被用signaturereader来解析这个值。所以我们可以实现signaturevisitor来被每一个标识工件来调用。

  private void addsignature(string sign) {
    if(sign!=null) {
      new signaturereader(sign).accept(this);
    }
  }
  
  private void addtypesignature(string sign) {
    if(sign!=null) {
      new signaturereader(sign).accepttype(this);
    }
  }

　　实现classvisitor接口的方法，如such as visit(), visitfield(), visitmethod(), and visitannotation()就可以获取在父类/接口/成员类型/方法参数/返回值/异常上的依赖信息，就如注解一样。例如：

  public void visit(int version, int access, 
      string name, string signature, 
      string supername, string[] interfaces) {
    string p = getgroupkey(name);
    current = groups.get(p);
    if(current==null) {
      current = new hashmap();
      groups.put(p, current);
    }
    
    if(signature==null) {
      addname(supername);
      addnames(interfaces);
    } else {
      addsignature(signature);
    }
  }

  public fieldvisitor visitfield(int access, 
      string name, string desc, 
      string signature, object value) {
    if(signature==null) {
      adddesc(desc);
    } else {
      addtypesignature(signature);
    }
    if(value instanceof type) {
      addtype((type) value);
    }
    return this;
  }
  
  public methodvisitor visitmethod(int access, 
      string name, string desc, 
      string signature, string[] exceptions) {
    if(signature==null) {
      addmethoddesc(desc);
    } else {
      addsignature(signature);
    }
    addnames(exceptions);
    return this;
  }
  
  public annotationvisitor visitannotation(
      string desc, boolean visible) {
    adddesc(desc);
    return this;
  }

　　实现methodvisitor接口的方法就可以获取关于参数注解类型和使用在可以使用对象引用的字节码指令上的依赖：

  public annotationvisitor 
      visitparameterannotation(int parameter, 
          string desc, boolean visible) {
    adddesc(desc);
    return this;
  }

  /**
   * visits a type instruction 
   * new, anewarray, checkcast or instanceof.
   */
  public void visittypeinsn(int opcode, 
        string desc) {
    if(desc.charat(0)=='[') {
      adddesc(desc);
    } else {
      addname(desc);
    }
  }

  /**
   * visits a field instruction 
   * getstatic, putstatic, getfield or putfield.
   */
  public void visitfieldinsn(int opcode, 
        string owner, string name, string desc) {
    addname(owner);
    adddesc(desc);
  }

  /**
   * visits a method instruction invokevirtual, 
   * invokespecial, invokestatic or 
   * invokeinterface.
   */
  public void visitmethodinsn(int opcode, 
        string owner, string name, string desc) {
    addname(owner);
    addmethoddesc(desc);
  }

  /**
   * visits a ldc instruction.
   */
  public void visitldcinsn(object cst) {
    if(cst instanceof type) {
      addtype((type) cst);
    }
  }

  /**
   * visits a multianewarray instruction.
   */
  public void visitmultianewarrayinsn(
        string desc, int dims) {
    adddesc(desc);
  }

  /**
   * visits a try catch block.
   */
  public void visittrycatchblock(label start, 
        label end, label handler, string type) {
    addname(type);
  }

　　现在我们可以用dependencyvisitor来获取整个.jar文件的依赖关系了。例如：

  dependencyvisitor v = new dependencyvisitor();
  zipfile f = new zipfile(jarname);
  enumeration en = f.entries();
  while(en.hasmoreelements()) {
    zipentry e = en.nextelement();
    string name = e.getname();
    if(name.endswith(".class")) {
      classreader cr = 
          new classreader(f.getinputstream(e));
      cr.accept(v, false);
    }
  }

　　可以用很多不同的方式来表示得到的信息。一种方式是构建依赖树并计算相关数据或者创建可视化的东西。例如，图5显示了ant1.6.5 jar包中的依赖关系的可视化表现，这是我使用一些简单的java2d代码写的。下面的图在水平轴上显示包，在垂直轴上显示依赖。阴影部分表示包被多次引用。

　　figure 5. dependencies in ant.1.6.5.jar, as discovered with asm

　　这个工具的全部代码会被包含在下一个asm发布中。你可以从asm cvs获取。

　　asm1.x后的改变

　　如果你没有使用asm1.x可以略过这个段。2.0中主要的结构变化是所有j2se5.0的特性都被内建到访问者/过滤器的事件流中。因此新的api允许你用更轻便和自然的方式来处理泛型和注解。不需要显式创建注解属性实例，因为在事件流中已经包含了泛型和注解数据。例如，在1.x，classvisitor接口如下使用：

  codevisitor visitmethod(int access, string name, 
      string desc, string[] exceptions, 
      attribute attrs);
this has been split into several methods in asm 2.0:
　　在2.0中已经分为多个方法：
  methodvisitor visitmethod(int access, 
      string name, string desc, string signature,
      string[] exceptions)

  annotationvisitor visitannotation(string desc,
      boolean visible)

  void visitattribute(attribute attr)

　　在1.x api中，为了定义泛型信息，你必须创建signatureattribute的实例，而定义注解你需要runtimeinvisibleannotations, runtimeinvisibleparameterannotations, runtimevisibleannotations, runtimevisibleparameterannotations, and annotationdefault的实例。然后你可以将这些实例放在相应的访问方法的attrs参数中。

　　在2.0，增加了新的标识参数来表示泛型信息。新的annotationvisitor接口被用来处理所有的注解。不再需要创建attrs集合了，而且注解数据是强类型的。然而在移植现有代码时，特别是在“适配器”类被使用时，必须注意确保所有来自适配器的方法需要重写来适应新的标识，因为编译器不用对这种情况给出警告。

　　asm2.0还有些其他的改变。
　　1、增加了新的接口fieldvisitor 和annotationvisitor
　　2、codevisitor合并到methodvisitor中了。
　　3、在methodvisitor中增加了visitcode()方法简化检测首个指令。
　　4、constants接口重构为opcodes。
　　5、所有来自attrs包的属性被包含到asm的事件模型中。
　　6、treeclassadapter and treecodeadapter被包含到classnode and methodnode中。
　　7、增加labelnode类使指令集合的元素成为abstractinsnnode的通用类型。
　　通常，建议使用如jdiff这样的工具来比较两个版本之间的区别。

　　小结

　　asm2.0为开发人员屏蔽了字节码的复杂性，因而使开发人员更有效在字节码级别上使用java的特性。这个框架不仅允许你转换和生成字节码，而且可以从现有的类中取得具体的信息。他的api继续改善，现在已经包含了j2se5.0中的泛型和注解。接下来，还会增加mustang(j2se6)中的新特性。

　　资源

　　?java virtual machine specification java虚拟机规范•?"“修订的类文件格式”（jvm规范的第4章）。包含j2se5.0中支持的jsr-14/jsr-175/jsr-201中要求的修改及其他小的更正和调整。
　　?“使用asm工具集来处理字节码”
　　?“使用asm工具集来创建和读写j2se5.0注解”
　　?字节码指令（bci）。

　　eugene kuleshov是一个独立咨询师，拥有超过15年的软件设计开发经验。

　　版权声明：任何获得matrix授权的网站，转载时请务必保留以下作者信息和链接
　　原文:http://www.javaworld.com/
　　译文:http://www.matrix.org.cn/