Java字节码揭秘——第一部分

 

写在前面

这一两年，在 JVM 上使用其他替代语言越来越热门了。现在至少有三门语言有幸在 Java Community Process 中得到了官方认可： JRuby 、 Groovy 和 Bean-Shell 。另外，代号为野马 (Mustang) 的 Java 6 发布了包含了一个专为封装不同脚本引擎的 API 层，就像 JDBC 访问数据库的模式一样。再加上 Java 版本 5 也在语言本身上做了很大的调整。总之，就像我之前翻译的一篇 BLOG 一样， Java 平台的编程语言的前景已经发生了巨大的改变。虽然如此，只有一样东西没有变，它是所有这些语言的基础，无论这些语言有多么吸引人的特性和功能，最终都会在 JVM 的混合语言中运行，即 JVM 字节码。这又提起了我在 JVM/Java 字节码方面的兴趣。所以书写本文，在其中将介绍 JVM 字节码集合，用一些代码来描述它的工作方式，也将介绍一些可以直接操纵字节码的工具。

 

首先我要说明的是，直接了解 JVM 字节码感觉是奇怪的事情，因为我们总不可能自己来书写字节码。但是，我们如果知道编译器干了些什么可能会更好一点。比如，你肯定想知道编译后的 StringBuffer 和 String 的区别、编译器到底有没有给你加上默认构造函数……当你了解了 JVM 字节码——这是我看见过的最简单的“可装配语言”——你就能够验证你的这些假设是否正确。

 

 

分解Java

考虑到大家对 Java 都已经比较熟悉了，所以我们这样开始可能比较容易：我们从编译后的 Java 代码开始，然后对其进行分解。这样可能比一开始就直接讲述 Java 字节码的规则要好一些。我们先从最简单的 Hello World 程序开始。

 

public class HelloWorld

{

        public static void main(String[] args)

        {

               System.out.println("Hello, world!");

        }

}

 

我们通过两种方式来一起研究 Java 字节码。第一个是太久时间都没有见到过的 javap 。 javap 是字节码分解器，意思就是它编译 .class 文件并将文件结构输出到控制台，其中包括组成方法的字节码。如下例：

 

$ javap -verbose -c -private HelloWorld

Compiled from "HelloWorld.java"

public class HelloWorld extends java.lang.Object

        SourceFile: "HelloWorld.java"

        minor version: 0

        major version: 50

        Constant pool:

const #1 = Method #6.#15; // java/lang/Object."<init>":()V

const #2 = Field #16.#17; // java/lang/System.out:Ljava/io/PrintStream;

const #3 = String #18; // Hello, world!

const #4 = Method #19.#20; // java/io/PrintStream.println:(Ljava/lang/String;)V

const #5 = class #21; // HelloWorld

const #6 = class #22; // java/lang/Object

const #7 = Asciz <init>;

const #8 = Asciz ()V;

const #9 = Asciz Code;

const #10 = Asciz LineNumberTable;

const #11 = Asciz main;

const #12 = Asciz ([Ljava/lang/String;)V;

const #13 = Asciz SourceFile;

const #14 = Asciz HelloWorld.java;

const #15 = NameAndType #7:#8;// "<init>":()V

const #16 = class #23; // java/lang/System

const #17 = NameAndType #24:#25;// out:Ljava/io/PrintStream;

const #18 = Asciz Hello, world!;

const #19 = class #26; // java/io/PrintStream

const #20 = NameAndType #27:#28;// println:(Ljava/lang/String;)V

const #21 = Asciz HelloWorld;

const #22 = Asciz java/lang/Object;

const #23 = Asciz java/lang/System;

const #24 = Asciz out;

const #25 = Asciz Ljava/io/PrintStream;;

const #26 = Asciz java/io/PrintStream;

const #27 = Asciz println;

const #28 = Asciz (Ljava/lang/String;)V;

{

public HelloWorld();

        Code:

               Stack=1, Locals=1, Args_size=1

               0: aload_0

               1: invokespecial #1; //Method java/lang/Object."<init>":()V

               4: return

        LineNumberTable:

               line 1: 0

public static void main(java.lang.String[]);

        Code:

               Stack=2, Locals=1, Args_size=1

               0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;

               3: ldc #3; //String Hello, world!

               5: invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V

               8: return

        LineNumberTable:

               line 5: 0

               line 6: 8

}

 

 

在刚才讲述的 .class 文件实际并不准确， JVM 无所谓输入的二进制流从哪儿来，只不过因为我们的习惯和 JDK 1.0 的发布所以我们说成是 .class 文件。所以，所谓的“ .class 文件”应该被理解为符合 JVM 标准的二进制格式流。

 

上面我们使用了 javap 。其中， -c 指示需要显示方法字节码； -private 指示无论可访问性显示所有成员； -verbose 是需要显示类的常量池。检查 HelloWorld 分解后的内容，会觉得非常有趣，我们立马就可以验证一些假设。例如，第一，如果类没有显式声明其父类的话，它将继承于 java.lang.Object 。第二， javap 也验证了如果类中没有显式声明构造函数的话，编译器会插入一个缺省无参的构造函数 ( 构造函数在 JVM 级别是显示成 <init> 的普通函数 ) 。

 

加上了 -verbose 选项的 javap 输出中一个重要的部分就是常量池。每个类都会有个常量池，所有的常量——比如字符串、类名、方法名、属性名——都是保存在类的中心位置，通过对该池的索引进行参照访问。通常，这些特殊的细节内容都是由工具来处理的，这也是 javap 通过注释来显示这些常量值的原因。但是这些内容对我们认识常量池非常有用，也能够简化我们对分解代码的理解。例如，第 5 行代码 System.out.println("Hello, world!"); 它调用了 println 方法，显示在常量池的编号为 4 的分片 (const #4) ，它依次由编号为 19 的分片和编号为 20 的分片组成 (const #4 = Method #19.#20;) ，这样就最终解决了 java.io.PrintStream.println(String[]) 的问题。你可以 参照JVM标准 来了解所有不同的常量类型以及他们在 .class 文件中的格式。

 

在这里，我们主要来分析自动生成的 HelloWorld 构造函数：

 

public HelloWorld();

        Code:

               Stack=1, Locals=1, Args_size=1

               0: aload_0

               1: invokespecial #1; //Method java/lang/Object."<init>":()V

               4: return

        LineNumberTable:

               line 1: 0

 

在 JVM 中，所有字节码都是通过一个基本的原则来进行堆栈操作的：每个操作符可能会消费一个或多个操作计数，并可能最后将一个操作计数推送到执行堆栈。需要注意的是，每个分片 (slot) 都是 32 位的，这就意味着 long 或者是 double 的值会消耗两个分片 (slot)( 很多人认为这个是 JVM 实现中的最大缺憾 ) 。另外，每个方法都会有一个本地的结合，本地变量和参数都在此保存。因此，例如“ aload_0 ”指示符将第一个参数带入方法，并将其推送至执行堆栈。“ invokespecial ”指示符，不言而喻，它将调用实例的方法，但是忽略传统的动态绑定 ( 因为我们显示调用基类版本的覆盖方法，该特殊的操作符用在父“ super ”调用 ) 。因为 Object 的构造函数需要一个参数 (this 指针 ) ，所以它将消耗执行堆栈中的一个分片 ( 记住，这是我们刚才推送的参数—— this 指针，指向我们自己的实例的 this 指针 ) ，而且它不返回任何值 ( 最后有一个 V 字 ) ，当方法返回时它将不往堆栈内推送任何内容。此时， HelloWorld 的构造函数已完成任务，所以它通过“ return ”操作符进行简单返回。

 

我们接下来在看看写在 HelloWorld 里面的主方法 (main) ：

 

public static void main(java.lang.String[]);

        Code:

               Stack=2, Locals=1, Args_size=1

               0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;

               3: ldc #3; //String Hello, world!

               5: invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V

               8: return

        LineNumberTable:

               line 5: 0

               line 6: 8

 

因为它是静态方法，所以最显著的区别就是第一个参数并不是 this 指针，除此之外，它和 HelloWorld 的构造函数看起来都差不多。第一个操作符“ getstatic ”将获取一个 static 区域并将其值推送至堆栈中，在本例中是 System.out 的引用，由 #2 常量池分片描述，并在操作符后使用注释显示。接下来，就对字符串“ Hello, World! ”进行加载，它在 #3 常量池分片中存储。通过堆栈上的两个引用，我们就可以调用“ invokevirtual ” PrintStream.println(String[]) 方法了。因其需要一个参数，再加上调用该方法需要的初始 this 引用，我们刚才推送至堆栈的这两项就被消费了， println(String[]) 不返回任何值，所以完成后堆栈上就为空了。一个简单的“ return ”操作符中止了该方法，任务完成了。

 

后面的内容会比现在的复杂一些，但总的来说，了解 Java 字节码的重要部分是需要了解每个操作符是如何操作执行堆栈的。

未完待续……

参考资料下载：

The Java Virtual Machine Specification(2nd Edition) JVM规范(第二版)