Apache Byte Code Engineering Library (BCEL)简介

官方主页：http://jakarta.apache.org/bcel/index.html

简介：http://www.ibm.com/developerworks/cn/java/j-dyn0414/

以下代码改编(转载)自：http://www.cppblog.com/wmuu/archive/2008/01/04/7947.html

代码如下：

1. package test;
3. import java.io.FileOutputStream;
4. import java.io.IOException;
6. import org.apache.bcel.Constants;
7. import org.apache.bcel.classfile.ClassParser;
8. import org.apache.bcel.classfile.JavaClass;
9. import org.apache.bcel.classfile.Method;
10. import org.apache.bcel.generic.ClassGen;
11. import org.apache.bcel.generic.ConstantPoolGen;
12. import org.apache.bcel.generic.InstructionConstants;
13. import org.apache.bcel.generic.InstructionFactory;
14. import org.apache.bcel.generic.InstructionList;
15. import org.apache.bcel.generic.MethodGen;
16. import org.apache.bcel.generic.ObjectType;
17. import org.apache.bcel.generic.PUSH;
18. import org.apache.bcel.generic.Type;
20. public class BcelTest {
22.     private static void addWrapper(ClassGen cgen, Method method) {
24.         // set up the construction tools
25.         InstructionFactory ifact = new InstructionFactory(cgen);
26.         InstructionList ilist = new InstructionList();
27.         ConstantPoolGen pgen = cgen.getConstantPool();
28.         String cname = cgen.getClassName();
29.         MethodGen wrapgen = new MethodGen(method, cname, pgen);
30.         wrapgen.setInstructionList(ilist);
32.         // rename a copy of the original method
33.         MethodGen methgen = new MethodGen(method, cname, pgen);
34.         cgen.removeMethod(method);
35.         String iname = methgen.getName() + "$impl";
36.         methgen.setName(iname);
37.         cgen.addMethod(methgen.getMethod());
38.         //以上是一下初始化的工作
39.         
40.         // compute the size of the calling parameters
41.         // operand stack操作数堆栈
42.         Type[] types = methgen.getArgumentTypes(); // 取出参数类型数组
44.         // solt代表本地变量的堆栈偏移量,里头储存了调用methen代表的函数的参数
45.         int slot = methgen.isStatic() ? 0 : 1; // 这种方式与Java如何处理方法调用有关。对于非静态的方法，每次调用的第一个（隐藏的）参数是目标对象的this引用（就是位置0储存的内容）。
46.         for (int i = 0; i < types.length; i++) {
47.             slot += types[i].getSize();// 累计个个参数类型的长度，
48.         }
49.         // 现在solt指向最后一个参数的下一个位置
51.         // save time prior to invocation
52.         // 调用静态的long java.lang.System.currentTimeMillis()方法,调用结束后函数的返回的long类型的值会压入operand stack操作数堆栈
53.         ilist.append(ifact.createInvoke("java.lang.System",
54.                 "currentTimeMillis", Type.LONG, Type.NO_ARGS,
55.                 Constants.INVOKESTATIC));
56.         ilist.append(InstructionFactory.createStore(Type.LONG, slot));// 将operand stack的top保存到本地变量堆栈的slot位置,operand stack弹出long值
58.         // call the wrapped method
59.         int offset = 0; // 偏移量
60.         short invoke = Constants.INVOKESTATIC; // 预先设置为调用静态函数
61.         if (!methgen.isStatic()) { // 如果不是调用静态函数,将调用的第一个（隐藏的）参数(目标对象的this引用)压入operand stack
62.             ilist.append(InstructionFactory.createLoad(Type.OBJECT, 0));
63.             offset = 1;// 偏移量加1
64.             invoke = Constants.INVOKEVIRTUAL;// 设置为调用非静态函数
65.         }
66.         for (int i = 0; i < types.length; i++) { // 遍历所有参数
67.             Type type = types[i];
68.             ilist.append(InstructionFactory.createLoad(type, offset)); // 按参数类型把参数一个个从本地变量堆栈取出，压入operand stack
69.             offset += type.getSize();
70.         }
71.         Type result = methgen.getReturnType();// 取得要调用函数的返回值类型
72.         ilist.append(ifact.createInvoke(cname, iname, result, types, invoke));// 调用方法名为iname的函数
74.         // store result for return later
75.         if (result != Type.VOID) {
76.             ilist.append(InstructionFactory.createStore(result, slot + 2)); // 将名为iname的函数返回值复制到本地变量堆栈的slot+2的位置上
77.         }
79.         // print time required for method call
80.         // 获取静态对象java.lang.System.out的引用,返回值压入operand stack
81.         ilist.append(ifact.createFieldAccess("java.lang.System", "out",
82.                 new ObjectType("java.io.PrintStream"), Constants.GETSTATIC));
83.         ilist.append(InstructionConstants.DUP);// 取operand stack的top,压入operand stack。完成后load_stack的头两个元素是静态对象java.lang.System.out的引用
84.         ilist.append(InstructionConstants.DUP);// 取operand stack的top,压入operand stack。现在有3个java.lang.System.out的引用。供下面3次调用out.print()函数使用
85.         String text = "Call to method " + methgen.getName() + " took ";
86.         ilist.append(new PUSH(pgen, text));// 将text放入pgen（代表常量池）,并把其在pgen的引用压入operand stack(供out.print(Sting)调用的参数)
87.         ilist.append(ifact.createInvoke("java.io.PrintStream", "print",
88.                         Type.VOID, new Type[] { Type.STRING },
89.                         Constants.INVOKEVIRTUAL));// 调用结束，operand stack弹出一个String的引用和一个out的引用(还剩2个out),函数没有返回值
91.         ilist.append(ifact.createInvoke("java.lang.System",
92.                 "currentTimeMillis", Type.LONG, Type.NO_ARGS,
93.                 Constants.INVOKESTATIC));// 调用java.lang.System.currentTimeMillis()方法,调用结束后函数的返回的long类型的值会压入堆栈operand stack
94.         ilist.append(InstructionFactory.createLoad(Type.LONG, slot));// 从本地变量堆栈的slot位置载入先前储存的long值，压入operand stack
95.         ilist.append(InstructionConstants.LSUB);// 调用long的减法指令,弹出2个long值，并把结果压入operand stack,现在operand stack的top第一个是long，第二个是out的引用
96.         ilist.append(ifact.createInvoke("java.io.PrintStream", "print",
97.                 Type.VOID, new Type[] { Type.LONG }, Constants.INVOKEVIRTUAL));// 调用out.print(long)方法
98.         ilist.append(new PUSH(pgen, " ms."));// 将String对象" ms."放入pgen,并把其在pgen的引用压入operand stack(供out.print(Sting)调用的参数)
99.         ilist
100.                 .append(ifact.createInvoke("java.io.PrintStream", "println",
101.                         Type.VOID, new Type[] { Type.STRING },
102.                         Constants.INVOKEVIRTUAL));
104.         // return result from wrapped method call
105.         if (result != Type.VOID) {
106.             ilist.append(InstructionFactory.createLoad(result, slot + 2));// 处理返回值,如果不为空，从本地对象堆栈的slot+2位置读取指定类型的返回值压入operand stack
107.         }
108.         ilist.append(InstructionFactory.createReturn(result)); //调用处理返回值的指令，result为返回值的类型
110.         //下面是一下扫尾工作
111.         // finalize the constructed method
112.         wrapgen.stripAttributes(true);
113.         wrapgen.setMaxStack();
114.         wrapgen.setMaxLocals();
115.         cgen.addMethod(wrapgen.getMethod());
116.         ilist.dispose();
117.     }
119.     public static void main(String[] argv) {
120.         if (argv.length == 2 && argv[0].endsWith(".class")) {
121.             try {
122.                 JavaClass jclas = new ClassParser(argv[0]).parse();
123.                 ClassGen cgen = new ClassGen(jclas);
124.                 Method[] methods = jclas.getMethods();
125.                 int index;
126.                 for (index = 0; index < methods.length; index++) {
127.                     if (methods[index].getName().equals(argv[1])) {
128.                         break;
129.                     }
130.                 }
131.                 if (index < methods.length) {
132.                     addWrapper(cgen, methods[index]);
133.                     FileOutputStream fos = new FileOutputStream(argv[0]);
134.                     cgen.getJavaClass().dump(fos);
135.                     fos.close();
136.                 } else {
137.                     System.err.println("Method " + argv[1] + " not found in "
138.                             + argv[0]);
139.                 }
140.             } catch (IOException ex) {
141.                 ex.printStackTrace(System.err);
142.             }
144.         } else {
145.             System.out.println("Usage: BCELTiming class-file method-name");
146.         }
147.     }
148. }

代码比较难懂，有待日后深入讨论。