2019獨角獸企業重金招聘Python工程師標準>>>

2.2.2解析類
解析一個已存在的類僅需要ClassReader這個組件。下面讓我們以一個實例來展示如何解析類。假設，我們想要打印一個類的內容，我們可以使用javap這個工具。第一步，實現ClassVisitor這個接口，用來打印類的信息。下面是一個簡單的實現：
public class ClassPrinter implements ClassVisitor {
public void visit(int version, int access, String name,
String signature, String superName, String[] interfaces) {
System.out.println(name + " extends " + superName + " {");
}
public void visitSource(String source, String debug) {
}
public void visitOuterClass(String owner, String name, String desc) {
}
public AnnotationVisitor visitAnnotation(String desc,
boolean visible) {
return null;
}
public void visitAttribute(Attribute attr) {
}
public void visitInnerClass(String name, String outerName,
String innerName, int access) {
}
public FieldVisitor visitField(int access, String name, String desc,
String signature, Object value) {
System.out.println(" " + desc + " " + name);
return null;
}
public MethodVisitor visitMethod(int access, String name,
String desc, String signature, String[] exceptions) {
System.out.println(" " + name + desc);
return null;
}
public void visitEnd() {
System.out.println("}");
}
}
第二步，將ClassPrinter和ClassReader結合起來，這樣，ClassReader產生的事件就可以被我們的ClassPrinter消費了：
ClassPrinter cp = new ClassPrinter();
ClassReader cr = new ClassReader("java.lang.Runnable");
cr.accept(cp, 0);
上面的第二行代碼創建了一個ClassReader來解析Runnable類。最后一行代碼中的accept方法解析Runnable類的字節碼，并且調用cp上對應的方法。結果如下：
java/lang/Runnable extends java/lang/Object {
run()V
}
注意，這里有多種方式來構造一個ClassReader的實例。可以通過類名，例如上面的例子，或者通過類的字節數組。或者類的輸入流。類的輸入流可以通過ClassLoader的getResourceAdStream方法：
cl.getResourceAsStream(classname.replace(’.’, ’/’) + ".class");

2.2.3生成類
生成一個類只需要ClassWriter組件即可。下面將使用一個例子來展示?？紤]下面的接口:
package pkg;
public interface Comparable extends Mesurable {
int LESS = -1;
int EQUAL = 0;
int GREATER = 1;
int compareTo(Object o);
}
上面的類可以通過調用ClassVisitor的6個方法來生成：
ClassWriter cw = new ClassWriter(0);
cw.visit(V1_5, ACC_PUBLIC + ACC_ABSTRACT + ACC_INTERFACE,
"pkg/Comparable", null, "java/lang/Object",
new String[] { "pkg/Mesurable" });
cw.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC, "LESS", "I",
null, new Integer(-1)).visitEnd();
cw.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC, "EQUAL", "I",
null, new Integer(0)).visitEnd();
cw.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC, "GREATER", "I",
null, new Integer(1)).visitEnd();
cw.visitMethod(ACC_PUBLIC + ACC_ABSTRACT, "compareTo",
"(Ljava/lang/Object;)I", null, null).visitEnd();
cw.visitEnd();
byte[] b = cw.toByteArray();
第一行代碼用于創建一個ClassWriter實例，由它來構建類的字節數組（構造方法中的參數將在后面章節介紹）。
首先，通過調用visit方法來定義類的頭部。其中，V1_5是一個預先定義的常量（與定義在ASM Opcodes接口中的其它常量一樣），它定義了類的版本，Java 1.5.ACC_XX常量與java中的修飾符對應。在上面的代碼中，我們指定了類是一個接口，因此它的修飾符是public和abstract（因為它不能實例化）。接下來的參數以內部名稱形式定義了類的名稱，（見2.1.2章節）。因為編譯過的類中不包含package和import段，因此，類名必須使用全路徑。接下來的參數與泛型對應（見4.1章節）。在上面的例子中，它的值為null，因為這個接口沒有使用泛型。第五個參數指定了父類，也是以內部形式（接口隱式地繼承自Object）。最后一個參數指定了該接口所繼承的所有接口，該參數是一個數組。
接下來三次調用visitField方法，都是用來定義接口中三個字段的。visitField方法的第一個參數是描述字段的訪問修飾符。在這里，我們指定這些字段為public，final和static。第二個參數是字段的名稱，與在源代碼中的名稱一樣。第三個參數，以類型描述符的形式指定了字段的類型。上面的字段是int類型，因此它的類型描述符是I。第四個參數與該字段的泛型對應，在這里為空，因為這個字段沒有使用泛型。最后一個參數是這些字段的常量值，這個參數只能針對常量字段使用，如final static類型的字段。對于其他字段，它必須為空。因為這里沒有使用注解，所以沒有調用任何visitAnnotation和visitAttribute方法，而是直接調用返回的FieldVisitor的visitEnd方法。
visitMethod方法是用來定義compareTo方法的。該方法的第一個參數也是定義訪問修飾符的，第二個參數是方法的名稱，在源代碼中指定的。第三個參數是該方法的描述符，第三個參數對應泛型，這里仍然為空，因為沒有使用泛型。最后一個參數是指定該方法所聲明的異常類型數組，在這個方法中為null，因為compareTo方法沒有聲明任何異常。visitMethod方法返回一個MethodVisitor（參見圖3.4），它可以用來定義方法的注解和屬性，以及方法的代碼。在這里沒有注解，因為這個方法是抽象的，因此我們直接調用了MethodVisitor的visitEnd方法。
最后，調用ClassWriter的visitEnd方法來通過cw類已經完成，然后調用toByteArray方法，返回該類的字節數組形式。
使用生成的類
前面獲取的字節數組可以保存到Comparable.class文件中，以便在以后使用。此外它也可以被ClassLoader動態加載。可以通過繼承ClassLoader，并重寫該類的defineClass方法來實現自己的ClassLoader：
class MyClassLoader extends ClassLoader {
public Class defineClass(String name, byte[] b) {
return defineClass(name, b, 0, b.length);
}
}
然后可以通過下面的代碼來加載：
Class c = myClassLoader.defineClass("pkg.Comparable", b);
另一種加載生成的類的方法是通過定義一個ClassLoader的子類，并重寫其中的findClass方法來生成需要的類：
class StubClassLoader extends ClassLoader {
@Override
protected Class findClass(String name)
throws ClassNotFoundException {
if (name.endsWith("_Stub")) {
ClassWriter cw = new ClassWriter(0);
...
byte[] b = cw.toByteArray();
return defineClass(name, b, 0, b.length);
}
return super.findClass(name);
}
}
實際上使用生成類的方式取決于使用的上下文，它超出了ASM API的范圍。如果你打算寫一個編譯器，那么類的生成過程將被一個即將被編譯的類的抽象的語法樹驅動，并且生成的類將被保存到磁盤上。如果你打算編寫一個動態的類代理生成工具或者在面向切面編程中使用，那么選擇ClassLoader比較合適。
2.2.4轉換類
到目前為止，ClassReader和ClassWriter都是獨立使用。手工產生事件，然后被ClassWriter直接消費，或者對稱地，事件由ClassReader產生，然后手工地消費，如通過一個自定義的ClassVisitor來實現。當把這些組件組合在一起使用時，將變得很有趣。第一步，將ClassReader產生的事件導入到ClassWriter，結果就是類將被ClassReader解析，然后再由ClassWriter重組為Class。
byte[] b1 = ...;
ClassWriter cw = new ClassWriter();
ClassReader cr = new ClassReader(b1);
cr.accept(cw, 0);
byte[] b2 = cw.toByteArray(); // b2 represents the same class as b1
當然，有趣的并不是這個過程本身（因為有更簡單的方式來復制一個字節數組）。但是，接下來介紹的ClassAdapter，它處于ClassReader和ClassWriter之間，將會帶來變化：
byte[] b1 = ...;
ClasssWriter cw = new ClassWriter();
ClassAdapter ca = new ClassAdapter(cw); // ca forwards all events to cw
ClassReader cr = new ClassReader(b1);
cr.accept(ca, 0);
byte[] b2 = cw.toByteArray(); // b2 represents the same class as b1
與上面代碼對應的結構圖如如2.6.在下面的圖中，組件以方形表示，事件以箭頭表示（在序列圖中是一個垂直的時間線）。
圖2.6 轉換鏈

執行結果沒有任何變化，因為這里使用的ClassAdapter 事件過濾器沒有過濾任何東西。但是，現在可以重寫這個類來過濾一些事件，以實現轉換類。例如，考慮下面這個ClassAdapter的子類：
public class ChangeVersionAdapter extends ClassAdapter {
public ChangeVersionAdapter(ClassVisitor cv) {
super(cv);
}
@Override
public void visit(int version, int access, String name,
String signature, String superName, String[] interfaces) {
cv.visit(V1_5, access, name, signature, superName, interfaces);
}
}
這個類僅重寫了ClassAdapter的一個方法。因此，所有的調用都未經過改變直接傳遞給了ClassVisitor實例cv，cv通過構造方法傳遞給自定義的ClassAdapter，除了visit方法，visit方法修改了類的版本號。對應的序列圖如下：
圖2.7

可以通過修改visit方法的其它參數來實現其它轉換，而不僅僅是修改類的版本號。例如，你可以給類增加一個借口。當然也可以修改類的名稱，但是這需要修改很多東西，而不只是修改visit方法中類的名稱。實際上，類名可能在很多地方存在，所有這些出現的地方都需要修改。
優化
前面的轉換只改變了原始類中的四個字節。盡管如此，通過上面的代碼，b1被完整的解析，產生的事件被用來從頭構造b2，盡管這樣做不高效。另一種高效的方式是直接復制不需要轉換的部分到b2，這樣就不需要解析這部分同時也不產生對應的事件。ASM會自動地對下面的方法進行優化：
? 如果ClassReader檢測到一個MethodVisitor直接被ClassVisitor返回，而這個ClassVisitor（如ClassWriter）是通過accept的參數直接傳遞給ClassReader，這就意味著這個方法的內容將不會被轉換，并且對應用程序也是不可見的。
? 在上面的情形中，ClassReader組件不會解析這個方法的內容，也不會產生對應的事件，而只是在ClassWriter中復制該方法的字節數組。
這個優化由ClassReader和ClassWriter來執行，如果它們擁有彼此的引用，就像下面的代碼：
byte[] b1 = ...
ClassReader cr = new ClassReader(b1);
ClassWriter cw = new ClassWriter(cr, 0);
ChangeVersionAdapter ca = new ChangeVersionAdapter(cw);
cr.accept(ca, 0);
byte[] b2 = cw.toByteArray();
經過優化，上面的代碼將比前面例子中的代碼快兩倍。因為ChangeVersionAdapter沒有轉換任何方法。對于轉換部分或者所有方法而言，這種對速度的提高雖然很小，但確實顯著的，可以達到10%到20%。不幸地是，這種優化需要復制在原始類中定義的所有常量到轉換后的類中。這對于在轉換中增加字段，方法或者指令什么的不是一個問題，但是相對于未優化的情形，這會導致在大的類轉換過程中刪除或者重命名很多類的元素。因此，這種優化適合于
需要添加代碼的轉換。
使用轉換后的類
轉換后的類b2可以保存到磁盤或者被ClassLoader加載，如前面章節描述的。但是在一個ClassLoader中只能轉換被該ClassLoader加載的類。如果你想轉換所有的類，你需要把轉換的代碼放置到一個ClassFileTransformer中，該類定義在java.lang.instrment包中（可以參看該報的文檔獲得詳細信息）：
public static void premain(String agentArgs, Instrumentation inst) {
inst.addTransformer(new ClassFileTransformer() {
public byte[] transform(ClassLoader l, String name, Class c,
ProtectionDomain d, byte[] b)throws IllegalClassFormatException {
ClassReader cr = new ClassReader(b);
ClassWriter cw = new ClassWriter(cr, 0);
ClassVisitor cv = new ChangeVersionAdapter(cw);
cr.accept(cv, 0);
return cw.toByteArray();
}
});

2.2.5移除類成員
前面例子中用來修改類版本號的方法也可以用在ClassVisitor接口中的其它方法上。例如，通過修改visitField和visitMethod方法中的access核name，你可以修改一個字段或者方法的訪問修飾符和名稱。更進一步，除了轉發修改該參數的方法調用，你也可以選擇不轉發該方法調用，這樣做的效果就是，對應的類元素將被移除。
例如，下面的類適配器將移除外部類和內部類，同時移除源文件的名稱（修改過的類仍然是功能完整的，因為這些元素僅用作調試）。這主要是通過保留visit方法為空來實現。
public class RemoveDebugAdapter extends ClassAdapter {
public RemoveDebugAdapter(ClassVisitor cv) {
super(cv);
}
@Override
public void visitSource(String source, String debug) {
}
@Override
public void visitOuterClass(String owner, String name, String desc) {
}
@Override
public void visitInnerClass(String name, String outerName,
String innerName, int access) {
}
}
上面的策略對字段和方法不起作用，因為visitField和visitMethod方法必須返回一個結果。為了移除一個字段或者一個方法，你不能轉發方法調用，而是返回一個null。下面的例子，移除一個指定了方法名和修飾符的方法（單獨的方法名是不足以確定一個方法，因為一個類可以包含多個相同方法名的但是參數個數不同的方法）：
public class RemoveMethodAdapter extends ClassAdapter {
private String mName;
private String mDesc;
public RemoveMethodAdapter(
ClassVisitor cv, String mName, String mDesc) {
super(cv);
this.mName = mName;
this.mDesc = mDesc;
}
@Override
public MethodVisitor visitMethod(int access, String name,
String desc, String signature, String[] exceptions) {
if (name.equals(mName) && desc.equals(mDesc)) {
// do not delegate to next visitor -> this removes the method
return null;
}
return cv.visitMethod(access, name, desc, signature, exceptions);
}
}
2.2.6增加類成員
除了傳遞較少的方法調用，你也可以傳遞更多的方法調用，這樣可以實現增加類元素。新的方法調用可以插入到原始方法調用之間，同時visitXxx方法調用的順序必須保持一致（參看2.2.1）。
例如，如果你想給類增加一個字段，你需要在原始方法調用之間插入一個visitField調用，并且你需要將這個新的調用放置到類適配器的其中一個visit方法之中（這里的visit是指以visit打頭的方法）。你不能在方法名為visit的方法中這樣做，因為這樣會導致后續對visitSource，visitOuterClass，visitAnnotation或者visitAttribute方法的調用，這樣做是無效的。同樣，你也不能將對visitField方法的調用放置到visitSource，visitOuterClass，visitAnnotation或者visitAttribute方法中?？赡艿奈恢檬莢isitInnerClass，visitField，visitMethod和visitEnd方法。
如果你將這個調用放置到visitEnd中，字段總會被添加，除非你添加了顯示的條件，因為這個方法總是會被調用。如果你把它放置到visitField或者visitMethod中，將會添加好幾個字段，因為對原始類中每個字段或者方法的調用都會導致添加一個字段。兩種方案都能實現，如何使用取決于你的需要。例如，你惡意增加一個單獨的counter字段，用來統計對某個對象的調用次數，或者針對每個方法，添加一個字段，來分別統計對每個方法的調用。
注意：事實上，添加成員的唯一正確的方法是在visitEnd方法中增加額外的調用。同時，一個類不能包含重復的成員，而確保新添加的字段是唯一的方法就是比較它和已經存在的成員，這只能在所有成員都被訪問之后來操作，例如在visitEnd方法中。程序員一般不大可能會使用自動生成的名字，如_counter$或者_4B7F_可以避免出現重復的成員，這樣就不需要在visitEnd中添加它們。注意，如在第一章中講的，tree API就不會存在這樣的限制，使用tree API就可以在轉換的任何時間點添加新成員。
為了展示上面的討論，下面是一個類適配器，用來給一個類增加一個字段，除非這個字段已經存在：
public class AddFieldAdapter extends ClassAdapter {
private int fAcc;
private String fName;
private String fDesc;
private boolean isFieldPresent;
public AddFieldAdapter(ClassVisitor cv, int fAcc, String fName,
String fDesc) {
super(cv);
this.fAcc = fAcc;
this.fName = fName;
this.fDesc = fDesc;
}
@Override
public FieldVisitor visitField(int access, String name, String desc,
String signature, Object value) {
if (name.equals(fName)) {
isFieldPresent = true;
}
return cv.visitField(access, name, desc, signature, value);
}
@Override
public void visitEnd() {
if (!isFieldPresent) {
FieldVisitor fv = cv.visitField(fAcc, fName, fDesc, null, null);
if (fv != null) {
fv.visitEnd();
}
}
cv.visitEnd();
}
}
這個字段是在visitEnd方法中添加的。重寫visitField方法不是為了修改已經存在的字段，而是為了檢測我們希望添加的字段是否已經存在。注意，在調用fv.visitEnd之前，我們測試了fv是否為空，如我們前面所講，一個class visitor的visitField方法可以返回null。
2.2.6轉換鏈
到目前為止，我們看到了一些有ClassReader，一個類適配器和ClassWriter組成的轉換鏈。當然，也可以將多個類適配器連接在一起，來實現更復雜的轉換鏈。鏈接多個類適配器運行你組合多個獨立的類轉換，以實現更復雜的轉換。注意，一個轉換鏈條沒必要是線性的，你可以編寫一個ClassVisitor，然后同時轉發所有的方法調用給多個ClassVisitor：
public class MultiClassAdapter implements ClassVisitor {
protected ClassVisitor[] cvs;
public MultiClassAdapter(ClassVisitor[] cvs) {
this.cvs = cvs;
}
@Override public void visit(int version, int access, String name,
String signature, String superName, String[] interfaces) {
for (ClassVisitor cv : cvs) {
cv.visit(version, access, name, signature, superName, interfaces);
}
}
...
}
相對地，多個類適配器也可以將方法調用都委托給相同的ClassVisitor（這需要額外的小心，以確保visit和visitEnd方法只被調用一次）。如圖2.8這樣的轉換鏈也是可能地。

轉載于:https://my.oschina.net/u/2292306/blog/3005938

總結

以上是生活随笔為你收集整理的ASM3.0学习（二）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。