Java ASM系列：（043）StaticInitMerger介绍
作者：互联网
本文属于[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`类的工作原理。
- 第三点，将两个类文件合并，有什么样的应用场景、需要注意哪些内容、经过哪些步骤，以及如何编码进行实现。
标签：Java,String,Cla,class,StaticInitMerger,import,043,public 来源： https://blog.51cto.com/lsieun/3006499