字节码增强技术系列-1

最新推荐文章于 2022-10-12 14:17:16 发布

zl.qian

最新推荐文章于 2022-10-12 14:17:16 发布

阅读量317

点赞数

文章标签： java jvm

本文链接：https://blog.csdn.net/weixin_37512224/article/details/109545598

版权

字节码修改是什么？

java开发人员都了解，java代码是需要经过javac编译成字节码，最后经过jvm的加载、连接、初始化，才最终被运行。这三个环节的主要工作如下：

加载：从网络、磁盘等存储中读取class文件到内存，并通过类加载器加载成class对象
连接： class的验证、静态变量的存储空间准备、常量池中的符号解析成真实的引用
初始化：静态变量的初始化、静态代码块的执行

了解这些后，我们可以思考下，如果要动态修改已经编译好的class文件，然后通知jvm重新加载，该怎么做呢？这就是字节码修改技术。

class文件格式是什么样的？

在开始了解这些字节码技术原理前，先简单过下class文件的格式。一个class文件包含以下项：

项	包含内容
header	魔数，用来表明是个class文件
constant pool	类中各种文字字符串：类名、方法名、接口名、常量值等
access right	类或者接口的访问权限
this class	指向该类全限名称的字符串常量
super class	指向父类的全限名称的字符串常量
implement interfaces	一个数组，指向所有接口对应的字符串常量
fields	类或者接口中的属性描述
methods	方法描述
class attributes	例如类文件名等信息

这看起来还能接受，还有更加复杂的内容…
我们编写的源码中，运算、赋值等操作对应着编译后的jvm各种指令，想要详细了解相关指令的，点击：jvm指令。

所以对于普通开发者来说，做字节码修改是非常困难的事情。那么是否可以借助其他技术来帮助我们实现呢？

字节码修改有哪些技术手段？

目前业界主流有多种字节码修改手段，下面先来进行一些对比。

技术	厂商	原理	优点
BCEL	Apache Software Foundation	字节码操作修改	丰富的jvm指令集支持
javaassist	jboss	抽象出源码修改	使用者更加容易，性能比反射好，较直接操作字节码弱
asm	objectweb	字节码操作修改	性能最好，因为是直接操作jvm指令，所以难度也更大
CGLib	基于asm的开源项目	基于asm	参考asm

接下来我们依次简单使用这些技术，来了解其能力。

BCEL

BCEL用来帮助开发者操作class文件，而不用详细了解class文件的格式。官网

应用场景

BCEL广泛应用于编译器、优化器、分析工具、代码生成器。例如：

api介绍

bcel的api主要分为3个部分

bcel.classfile.*：主要用于class文件分析
bcel.generic.* : 主要用于class文件修改
其他：工具和样例代码

主要数据结构

JavaClass
通常通过JavaParser解析字节码文件生成，包含了类的字段、方法、父类和实现的接口的符合引用。
Repository
用于保存JavaClass对象，以避免重复生成JavaClass对象。以上2者使用方式如下：

JavaClass javaClass = Repository.lookupClass("java.lang.Integer");
Method[] ms = javaClass.getMethods();
for (Method m : ms) {
    System.out.println(m.getCode());
}

ClassGen
用于动态创建或者修改类。
InstructionConstants
由于大部分指令都是不可变的，因此可以直接使用此接口中的指令。
InstructionList
由一组指令句柄组成。使用方式如下：

InstructionList il = new InstructionList();
...
GOTO g = new GOTO(null);
il.append(g);
...
InstructionHandle ih = il.append(InstructionConstants.ACONST_NULL); // 复用不可变指令
g.setTarget(ih);

InstructionFactory
指令创建工厂，用于简化质量创建。

看了这些API后，可能和我一样有点懵，我们通过一个Demo来进行学习这些API是如何使用的。

使用demo

假如我们现在需要通过BCEL来生成一个简单的类，其内容包括：

public class HelloWorld {
    public static void main(String[] argv) {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String name = null;
        try {
            System.out.print("Please enter your name> ");
            name = in.readLine();
        } catch (IOException var3) {
            return;
        }
        System.out.println("Hello, " + name);
    }
}

我们可以通过如下代码完成：

// 使用ClassGen，创建类HelloWorld，父类为Object
ClassGen cg = new ClassGen("HelloWorld", "java.lang.Object",
                "<generated>", // 源文件名称
                ACC_PUBLIC | ACC_SUPER, null); // 访问权限
ConstantPoolGen cp = cg.getConstantPool(); // 获取常量池
InstructionList il = new InstructionList(); // 创建指令集
// 创建方法
MethodGen mg = new MethodGen(ACC_STATIC | ACC_PUBLIC, // public static 
        Type.VOID, // void : 返回值
        new Type[] {new ArrayType(Type.STRING, 1) }, // 入参：String[] 
        new String[] { "argv" }, // 入参：argv
        "main", "HelloWorld", // 函数名，类名
        il, cp); 
// 创建指令工厂，简化指令创建
InstructionFactory factory = new InstructionFactory(cg);
// 定义对象类型，后面使用
ObjectType i_stream = new ObjectType("java.io.InputStream");
ObjectType p_stream = new ObjectType("java.io.PrintStream");
// 开始添加main方法中的指令
il.append(factory.createNew("java.io.BufferedReader")); // 创建一个BufferReader对象
// 上个步骤会生成一个 对象的引用，压入栈顶，这个步骤为了复制引用也压入栈顶，后续使用
il.append(InstructionConstants.DUP); 
// 创建InputStreamReader对象
il.append(factory.createNew("java.io.InputStreamReader"));
// 同上复制引用，后续使用
il.append(InstructionConstants.DUP);
// 访问System的静态方法，返回InputStream对象类型
il.append(factory.createFieldAccess("java.lang.System", "in", i_stream, Constants.GETSTATIC));
// 调用InputStreamReader的构造器，这里消耗一次InputStreamReader引用
il.append(factory.createInvoke("java.io.InputStreamReader", "<init>",
        Type.VOID, new Type[] { i_stream },
        Constants.INVOKESPECIAL));
// 调用BufferReader构造器，这里消耗一次InputStreamReader引用，这就是为啥上面要通过dup复制引用的原因
il.append(factory.createInvoke("java.io.BufferedReader", "<init>", Type.VOID,
        new Type[] {new ObjectType("java.io.Reader")},
        Constants.INVOKESPECIAL));
// 创建本地变量： in，类型为BufferReader 
LocalVariableGen lg = mg.addLocalVariable("in",
        new ObjectType("java.io.BufferedReader"), null, null);
int in = lg.getIndex(); // 获取变量的索引
// 使用栈顶，给本地变量赋值
lg.setStart(il.append(new ASTORE(in))); // "i" valid from here
// 添加本地变量: name 
lg = mg.addLocalVariable("name", Type.STRING, null, null);
// 获取本地变量索引
int name = lg.getIndex();
// 栈顶添加null
il.append(InstructionConstants.ACONST_NULL);
// 将栈顶null复制给本地变量
lg.setStart(il.append(new ASTORE(name))); // "name" valid from here
// 获取System的静态变量out
InstructionHandle try_start =
        il.append(factory.createFieldAccess("java.lang.System", "out", p_stream, Constants.GETSTATIC));
// 常量池添加常量，并添加到栈顶
il.append(new PUSH(cp, "Please enter your name> "));
// 调用对象方法print
il.append(factory.createInvoke("java.io.PrintStream", "print", Type.VOID,
        new Type[] { Type.STRING },
        Constants.INVOKEVIRTUAL));
// 从in本地变量值压入栈
il.append(new ALOAD(in));
// 调用对象方法in.readline
il.append(factory.createInvoke("java.io.BufferedReader", "readLine",
        Type.STRING, Type.NO_ARGS,
        Constants.INVOKEVIRTUAL));
// 将栈顶值装入name
il.append(new ASTORE(name));
// 创建分支指令
GOTO g = new GOTO(null);
InstructionHandle try_end = il.append(g);
// 创建return指令 
InstructionHandle handler = il.append(InstructionConstants.RETURN);
// 添加异常处理
mg.addExceptionHandler(try_start, try_end, handler, ObjectType.getInstance("java.io.IOException"));
// 访问System静态变量out  
InstructionHandle ih =
        il.append(factory.createFieldAccess("java.lang.System", "out", p_stream, Constants.GETSTATIC));
// 设置分支命令跳转目标
g.setTarget(ih);
// 创建StringBuffer对象类型
il.append(factory.createNew(Type.STRINGBUFFER));
// 同上，将栈顶引用复制并再压入栈
il.append(InstructionConstants.DUP);
// 在常量池增加常量
il.append(new PUSH(cp, "Hello, "));
// 使用栈顶的 StringBuffer引用和常量引用 进行构造对象
il.append(factory.createInvoke("java.lang.StringBuffer", "<init>",
        Type.VOID, new Type[] { Type.STRING },
        Constants.INVOKESPECIAL));
// name引用压入栈
il.append(new ALOAD(name));
// 调用Stringbuffer对象的append方法
il.append(factory.createInvoke("java.lang.StringBuffer", "append",
        Type.STRINGBUFFER, new Type[] { Type.STRING },
        Constants.INVOKEVIRTUAL));
// 调用对象的 toString方法
il.append(factory.createInvoke("java.lang.StringBuffer", "toString",
        Type.STRING, Type.NO_ARGS,
        Constants.INVOKEVIRTUAL));
// 调用out对象的printtln方法
il.append(factory.createInvoke("java.io.PrintStream", "println",
        Type.VOID, new Type[] { Type.STRING },
        Constants.INVOKEVIRTUAL));
// 添加return命令
il.append(InstructionConstants.RETURN);
// 设置方法最大栈大小
mg.setMaxStack();
// 方法加入类
cg.addMethod(mg.getMethod());
// 释放资源
il.dispose(); 
try {
    cg.getJavaClass().dump("HelloWorld.class");
} catch (IOException e) {
    System.err.println(e);
}

执行上面的代码，我们就能得到HelloWorld.class，可以通过java HelloWorld执行，也可以反编译查看。

总结
这些API可能看起来是有点晦涩，但是如果我们按照注释一步一步理解，还是能够理解其使用。 bcel我们就介绍到这里。

预告

下一篇，我们继续了解另一种字节码增强技术：javaassist。

参考

https://segmentfault.com/a/1190000008722128

zl.qian

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
字节码增强技术系列-1

字节码修改是什么？java开发人员都了解，java代码是需要经过javac编译成字节码，最后经过jvm的加载、连接、初始化，才最终被运行。这三个环节的主要工作如下：加载：从网络、磁盘等存储中读取class文件到内存，并通过类加载器加载成class对象连接： class的验证、静态变量的存储空间准备、常量池中的符号解析成真实的引用初始化：静态变量的初始化、静态代码块的执行了解这些后，我们可以思考下，如果要动态修改已经编译好的class文件，然后通知jvm重新加载，该怎么做呢？这就是字节码修改
复制链接

扫一扫