本文属于[Java ASM系列一：Core API](https://blog.51cto.com/lsieun/2924583)当中的一篇。 `StaticInitMerger`类的特点是，可以实现将多个`()`方法合并到一起。 ## 1. 如何合并两个类文件 **首先，什么是合并两个类文件？** 假如有两个类，一个是`sample.HelloWorld`类，另一个是`sample.GoodChild`类，我们想将`sample.GoodChild`类里面定义的字段（fields）和方法（methods）全部放到`sample.HelloWorld`类里面，这样就是将两个类合并成一个新的`sample.HelloWorld`类。 **其次，合并两个类文件，有哪些应用场景呢？** 假如`sample/HelloWorld.class`是来自于第三方的软件产品，但是，我们可能会发现它的功能有些不足，所以想对这个类进行扩展。 - 第一种情况，如果扩展的功能比较简单，那么可以直接使用`ClassVisitor`和`MethodVisitor`类可以进行Class Transformation操作。 - 第二种情况，如果扩展的功能比较复杂，例如，需要添加的方法比较多、方法实现的代码逻辑比较复杂，那么使用`ClassVisitor`和`MethodVisitor`类直接修改就会变得比较麻烦。这个时候，如果我们把想添加的功能，使用Java语言编写代码，放到一个全新的`sample.GoodChild`类，将其编译成`sample/GoodChild.class`文件；再接下来，只要我们将`sample/GoodChild.class`定义的字段（fields）和方法（methods）全部迁移到`sample/HelloWorld.class`就可以了。 **再者，合并两个类文件，需要注意哪些地方呢？** 因为主要迁移的内容有接口（interface）、字段（fields）和方法（methods），那么就应该避免出现“重复”的接口、字段和方法。 - 第一点，在编写Java代码时，在编写`sample.GoodChild`类时，应该避免定义重复的字段和方法。 - 第二点，在合并两个类时，对于重复的接口信息进行处理。 - 第三点，在合并两个类时，对于重复的`()`方法进行处理。对于`sample/GoodChild.class`里面的`()`方法直接忽略就好了，只保留`sample/HelloWorld.class`定义的`()`方法。 - 第四点，在合并两个类之后，对于重复的`()`方法进行处理。对于`sample/HelloWorld.class`定义的`()`方法和`sample/GoodChild.class`里面定义的`()`方法，则需要合并到一起。`StaticInitMerger`类的作用，就是将多个`()`方法进行合并。 **最后，合并两个类文件，需要经历哪些步骤呢？** 在这里，我们列出了四个步骤： - 第一步，读取两个类文件。 - 第二步，将`sample.GoodChild`类重命名为`sample.HelloWorld`。在代码实现上，会用到`Cla***emapper`类。 - 第三步，合并两个类。在这个过程中，要对重复的接口（interface）和`()`方法。在代码实现上，会用到`ClassNode`类（Tree API）。 - 第四步，处理重复的`()`方法。在代码实现上，会用到`StaticInitMerger`类。  ## 2. StaticInitMerger类 ### 2.1 class info 第一个部分，`StaticInitMerger`类继承自`ClassVisitor`类。 ```java public class StaticInitMerger extends ClassVisitor { } ``` ### 2.2 fields 第二个部分，`StaticInitMerger`类定义的字段有哪些。 在`StaticInitMerger`类里面，定义了4个字段： - `owner`字段，表示当前类的名字。 - `renamedClinitMethodPrefix`字段和`numClinitMethods`字段一起来确定方法的新名字。 - `mergedClinitVisitor`字段，负责生成新的`()`方法。 ```java public class StaticInitMerger extends ClassVisitor { // 当前类的名字 private String owner; // 新方法的名字 private final String renamedClinitMethodPrefix; private int numClinitMethods; // 生成新方法的MethodVisitor private MethodVisitor mergedClinitVisitor; } ``` ### 2.3 constructors 第三个部分，`StaticInitMerger`类定义的构造方法有哪些。 ```java public class StaticInitMerger extends ClassVisitor { public StaticInitMerger(final String prefix, final ClassVisitor classVisitor) { this(Opcodes.ASM9, prefix, classVisitor); } protected StaticInitMerger(final int api, final String prefix, final ClassVisitor classVisitor) { super(api, classVisitor); this.renamedClinitMethodPrefix = prefix; } } ``` ### 2.4 methods 第四个部分，`StaticInitMerger`类定义的方法有哪些。 在`StaticInitMerger`类里面，定义了3个`visitXxx()`方法： - `visit()`方法，负责将当前类的名字记录到`owner`字段 - `visitMethod()`方法，负责将原来的`()`方法进行重新命名成`renamedClinitMethodPrefix + numClinitMethods`，并在新的`()`方法中对`renamedClinitMethodPrefix + numClinitMethods`方法进行调用。 - `visitEnd()`方法，为新的`()`方法添加`return`语句。 ```java public class StaticInitMerger extends ClassVisitor { public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { super.visit(version, access, name, signature, superName, interfaces); this.owner = name; } public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) { MethodVisitor methodVisitor; if ("".equals(name)) { int newAccess = Opcodes.ACC_PRIVATE + Opcodes.ACC_STATIC; String newName = renamedClinitMethodPrefix + numClinitMethods++; methodVisitor = super.visitMethod(newAccess, newName, descriptor, signature, exceptions); if (mergedClinitVisitor == null) { mergedClinitVisitor = super.visitMethod(newAccess, name, descriptor, null, null); } mergedClinitVisitor.visitMethodInsn(Opcodes.INVOKESTATIC, owner, newName, descriptor, false); } else { methodVisitor = super.visitMethod(access, name, descriptor, signature, exceptions); } return methodVisitor; } public void visitEnd() { if (mergedClinitVisitor != null) { mergedClinitVisitor.visitInsn(Opcodes.RETURN); mergedClinitVisitor.visitMaxs(0, 0); } super.visitEnd(); } } ``` ## 3. 示例：合并两个类文件 ### 3.1 预期目标 假如有一个`HelloWorld`类，代码如下： ```java public class HelloWorld { static { System.out.println("This is static initialization method"); } private String name; private int age; public HelloWorld() { this("tomcat", 10); } public HelloWorld(String name, int age) { this.name = name; this.age = age; } public void test() { System.out.println("This is test method."); } @Override public String toString() { return String.format("HelloWorld { name='%s', age=%d }", name, age); } } ``` 假如有一个`GoodChild`类，代码如下： ```java import java.io.Serializable; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; public class GoodChild implements Serializable { private static final DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public void printDate() { Date now = new Date(); String str = df.format(now); System.out.println(str); } } ``` 我们想实现的预期目标：将`HelloWorld`类和`GoodChild`类合并成一个新的`HelloWorld`类。 ### 3.2 编码实现 下面的`ClassMergeVisitor`类的作用是负责将两个类合并到一起。我们需要注意以下三点： - 第一点，`ClassNode`、`FieldNode`和`MethodNode`都是属于ASM的Tree API部分。 - 第二点，将两个类进行合并的代码逻辑，放在了`visitEnd()`方法内。为什么要把代码逻辑放在`visitEnd()`方法内呢？因为参照`ClassVisitor`类里的`visitXxx()`方法调用的顺序，`visitField()`方法和`visitMethod()`方法正好位于`visitEnd()`方法的前面。 - 第三点，在`visitEnd()`方法的代码逻辑中，忽略掉了`()`方法，这样就避免新生成的类当中包含重复的`()`方法。 ```java import org.objectweb.asm.ClassVisitor; import org.objectweb.asm.tree.ClassNode; import org.objectweb.asm.tree.FieldNode; import org.objectweb.asm.tree.MethodNode; import java.util.List; public class ClassMergeVisitor extends ClassVisitor { private final ClassNode anotherClass; public ClassMergeVisitor(int api, ClassVisitor classVisitor, ClassNode anotherClass) { super(api, classVisitor); this.anotherClass = anotherClass; } @Override public void visitEnd() { List fields = anotherClass.fields; for (FieldNode fn : fields) { fn.accept(this); } List methods = anotherClass.methods; for (MethodNode mn : methods) { String methodName = mn.name; if ("".equals(methodName)) { continue; } mn.accept(this); } super.visitEnd(); } } ``` 下面的`ClassAddInterfaceVisitor`类是负责为类添加“接口信息”。 ```java import org.objectweb.asm.ClassVisitor; import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class ClassAddInterfaceVisitor extends ClassVisitor { private final String[] newInterfaces; public ClassAddInterfaceVisitor(int api, ClassVisitor cv, String[] newInterfaces) { super(api, cv); this.newInterfaces = newInterfaces; } @Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { Set set = new HashSet<>(); // 注意，这里使用Set是为了避免出现重复接口 if (interfaces != null) { set.addAll(Arrays.asList(interfaces)); } if (newInterfaces != null) { set.addAll(Arrays.asList(newInterfaces)); } super.visit(version, access, name, signature, superName, set.toArray(new String[0])); } } ``` ### 3.3 进行转换 ```java import lsieun.utils.FileUtils; import org.objectweb.asm.Cla***eader; import org.objectweb.asm.ClassVisitor; import org.objectweb.asm.ClassWriter; import org.objectweb.asm.Opcodes; import org.objectweb.asm.commons.Cla***emapper; import org.objectweb.asm.commons.Remapper; import org.objectweb.asm.commons.SimpleRemapper; import org.objectweb.asm.commons.StaticInitMerger; import org.objectweb.asm.tree.ClassNode; import java.util.List; public class StaticInitMergerExample01 { private static final int API_VERSION = Opcodes.ASM9; public static void main(String[] args) { // 第一步，读取两个类文件 String first_class = "sample/HelloWorld"; String second_class = "sample/GoodChild"; String first_class_filepath = getFilePath(first_class); byte[] bytes1 = FileUtils.readBytes(first_class_filepath); String second_class_filepath = getFilePath(second_class); byte[] bytes2 = FileUtils.readBytes(second_class_filepath); // 第二步，将sample/GoodChild类重命名为sample/HelloWorld byte[] bytes3 = renameClass(second_class, first_class, bytes2); // 第三步，合并两个类 byte[] bytes4 = mergeClass(bytes1, bytes3); // 第四步，处理重复的class initialization method byte[] bytes5 = removeDuplicateStaticInitMethod(bytes4); FileUtils.writeBytes(first_class_filepath, bytes5); } public static String getFilePath(String internalName) { String relative_path = String.format("%s.class", internalName); return FileUtils.getFilePath(relative_path); } public static byte[] renameClass(String origin_name, String target_name, byte[] bytes) { //（1）构建Cla***eader Cla***eader cr = new Cla***eader(bytes); //（2）构建ClassWriter ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); //（3）串连ClassVisitor Remapper remapper = new SimpleRemapper(origin_name, target_name); ClassVisitor cv = new Cla***emapper(cw, remapper); //（4）两者进行结合 int parsingOptions = Cla***eader.SKIP_DEBUG | Cla***eader.SKIP_FRAMES; cr.accept(cv, parsingOptions); //（5）重新生成Class return cw.toByteArray(); } public static byte[] mergeClass(byte[] bytes1, byte[] bytes2) { //（1）构建Cla***eader Cla***eader cr = new Cla***eader(bytes1); //（2）构建ClassWriter ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); //（3）串连ClassVisitor ClassNode cn = getClassNode(bytes2); List interface_list = cn.interfaces; int size = interface_list.size(); String[] interfaces = new String[size]; for (int i = 0; i < size; i++) { String item = interface_list.get(i); interfaces[i] = item; } ClassMergeVisitor cmv = new ClassMergeVisitor(API_VERSION, cw, cn); ClassAddInterfaceVisitor cv = new ClassAddInterfaceVisitor(API_VERSION, cmv, interfaces); //（4）两者进行结合 int parsingOptions = Cla***eader.SKIP_DEBUG | Cla***eader.SKIP_FRAMES; cr.accept(cv, parsingOptions); //（5）重新生成Class return cw.toByteArray(); } public static ClassNode getClassNode(byte[] bytes) { Cla***eader cr = new Cla***eader(bytes); ClassNode cn = new ClassNode(); int parsingOptions = Cla***eader.SKIP_DEBUG | Cla***eader.SKIP_FRAMES; cr.accept(cn, parsingOptions); return cn; } public static byte[] removeDuplicateStaticInitMethod(byte[] bytes) { //（1）构建Cla***eader Cla***eader cr = new Cla***eader(bytes); //（2）构建ClassWriter ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); //（3）串连ClassVisitor ClassVisitor cv = new StaticInitMerger("class_init$", cw); //（4）结合Cla***eader和ClassVisitor int parsingOptions = Cla***eader.SKIP_DEBUG | Cla***eader.SKIP_FRAMES; cr.accept(cv, parsingOptions); //（5）生成byte[] return cw.toByteArray(); } } ``` ### 3.4 验证结果 ```java import java.lang.reflect.Method; public class HelloWorldRun { public static void main(String[] args) throws Exception { Class<? > clazz = Class.forName("sample.HelloWorld"); Object instance = clazz.newInstance(); System.out.println(instance); invokeMethod(clazz, "test", instance); invokeMethod(clazz, "printDate", instance); } public static void invokeMethod(Class<? > clazz, String methodName, Object instance) throws Exception { Method m = clazz.getDeclaredMethod(methodName); m.invoke(instance); } } ``` ## 4. 总结 本文对`StaticInitMerger`类进行了介绍，内容总结如下： - 第一点，`StaticInitMerger`类的特点是可以将多个`()`方法合并。 - 第二点，了解`StaticInitMerger`类各个部分的信息，以便理解`StaticInitMerger`类的工作原理。 - 第三点，将两个类文件合并，有什么样的应用场景、需要注意哪些内容、经过哪些步骤，以及如何编码进行实现。