Java ASM系列：（043）StaticInitMerger介绍

原创

lsieun 2021-07-07 20:18:25 博主文章分类：Java ASM ©著作权

文章标签 Java ASM ClassFile ByteCode Core API 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者lsieun的原创作品，如需转载，请与作者联系，否则将追究法律责任

对于《Java ASM系列一：Core API》有配套的视频讲解，可以点击这里和这里进行查看；同时，也可以点击这里查看源码资料。

StaticInitMerger类的特点是，可以实现将多个<clinit>()方法合并到一起。

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类时，应该避免定义重复的字段和方法。
第二点，在合并两个类时，对于重复的接口信息进行处理。
第三点，在合并两个类时，对于重复的<init>()方法进行处理。对于sample/GoodChild.class里面的<init>()方法直接忽略就好了，只保留sample/HelloWorld.class定义的<init>()方法。
第四点，在合并两个类之后，对于重复的<clinit>()方法进行处理。对于sample/HelloWorld.class定义的<clinit>()方法和sample/GoodChild.class里面定义的<clinit>()方法，则需要合并到一起。StaticInitMerger类的作用，就是将多个<clinit>()方法进行合并。

最后，合并两个类文件，需要经历哪些步骤呢？ 在这里，我们列出了四个步骤：

第一步，读取两个类文件。
第二步，将sample.GoodChild类重命名为sample.HelloWorld。在代码实现上，会用到Cla***emapper类。
第三步，合并两个类。在这个过程中，要对重复的接口（interface）和<init>()方法。在代码实现上，会用到ClassNode类（Tree API）。
第四步，处理重复的<clinit>()方法。在代码实现上，会用到StaticInitMerger类。

2. StaticInitMerger类

2.1 class info

第一个部分，StaticInitMerger类继承自ClassVisitor类。

public class StaticInitMerger extends ClassVisitor {
}

2.2 fields

第二个部分，StaticInitMerger类定义的字段有哪些。

在StaticInitMerger类里面，定义了4个字段：

owner字段，表示当前类的名字。
renamedClinitMethodPrefix字段和numClinitMethods字段一起来确定方法的新名字。
mergedClinitVisitor字段，负责生成新的<clinit>()方法。

public class StaticInitMerger extends ClassVisitor {
    // 当前类的名字
    private String owner;
    
    // 新方法的名字
    private final String renamedClinitMethodPrefix;
    private int numClinitMethods;
    
    // 生成新方法的MethodVisitor
    private MethodVisitor mergedClinitVisitor;
}

2.3 constructors

第三个部分，StaticInitMerger类定义的构造方法有哪些。

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()方法，负责将原来的<clinit>()方法进行重新命名成renamedClinitMethodPrefix + numClinitMethods，并在新的<clinit>()方法中对renamedClinitMethodPrefix + numClinitMethods方法进行调用。
visitEnd()方法，为新的<clinit>()方法添加return语句。

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 ("<clinit>".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类，代码如下：

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类，代码如下：

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()方法的代码逻辑中，忽略掉了<init>()方法，这样就避免新生成的类当中包含重复的<init>()方法。

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<FieldNode> fields = anotherClass.fields;
        for (FieldNode fn : fields) {
            fn.accept(this);
        }

        List<MethodNode> methods = anotherClass.methods;
        for (MethodNode mn : methods) {
            String methodName = mn.name;
            if ("<init>".equals(methodName)) {
                continue;
            }
            mn.accept(this);
        }
        super.visitEnd();
    }
}

下面的ClassAddInterfaceVisitor类是负责为类添加“接口信息”。

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<String> 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 进行转换

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<String> 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 验证结果

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类的特点是可以将多个<clinit>()方法合并。
第二点，了解StaticInitMerger类各个部分的信息，以便理解StaticInitMerger类的工作原理。
第三点，将两个类文件合并，有什么样的应用场景、需要注意哪些内容、经过哪些步骤，以及如何编码进行实现。

上一篇：Java ASM系列：（042）Cla***emapper介绍

下一篇：Java ASM系列：（044）SerialVersionUIDAdder介绍

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯