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`类。
![](http://www.icode9.com/i/li/?n=2&i=images/20210707/1625660086263737.png?,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
## 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`类的工作原理。
- 第三点,将两个类文件合并,有什么样的应用场景、需要注意哪些内容、经过哪些步骤,以及如何编码进行实现。