Java的字节代码

深入Java编程——Java的字节代码

Java程序员很少注意程序的编译结果。事实上，Java的字节代码向我们提供了非常有价值的信息。特别是在调试排除Java性能问题时，

编译结果让我们可以更深入地理解如何提高程序执行的效率等问题。其实JDK使我们研究Java字节代码变得非常容易。本文阐述怎样利

用JDK中的工具查看解释Java字节代码，主要包含以下方面的一些内容：

a) Java类分解器——javap

b) Java字节代码是怎样使程序避免程序的内存错误

c) 怎样通过分析字节代码来提高程序的执行效率

d) 利用第三方工具反编译Java字节代码

 

一、Java类分解器——javap

   大多数Java程序员知道他们的程序不是编译成本机代码的。实际上，程序被编译成中间字节代码，由Java虚拟机来解释执行。然而，很少程序员注意一下字节代码，因为他们使用的工具不鼓励他们这样做。大多数的Java调试工具不允许单步的字节代码调试。这些工具要么显示源代码，要么什么都不显示。幸好JDK提供了Java类分解器javap，一个命令行工具。javap对类名给定的文件（.class）提供的字节代码进行反编译，打印出这些类的一个可读版本。在缺省情况下，javap打印出给定类内的公共域、方法、构造函数，以及静态初始值。

 

1．javap的具体用法

语法： javap <选项> <类名>

 

2.应用实例

让我们来看一个例子来进一步说明如何使用javap。

// Imports

import java.lang.String;

 

public class ExampleOfByteCode {

  // Constructors

  public ExampleOfByteCode() { }

 

  // Methods

  public static void main(String[] args) {

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

  }

}

编译好这个类以后，可以用一个十六进制编辑器打开.class文件，再通过虚拟机说明规范来解释字节代码的含义，但这并不是好方法。

利用javap，可以将字节代码转换成人们可以阅读的文字，只要加上-c参数：

javap -c ExampleOfByteCode

输出结果如下：

Compiled from ExampleOfByteCode.java

public class ExampleOfByteCode extends java.lang.Object {

    public ExampleOfByteCode();

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

}

 

Method ExampleOfByteCode()

   0 aload_0

   1 invokespecial #6 <Method java.lang.Object()>

   4 return

 

Method void main(java.lang.String[])

   0 getstatic #7 <Field java.io.PrintStream out>

   3 ldc #1 <String "Hello world">

   5 invokevirtual #8 <Method void println(java.lang.String)>

   8 return

从以上短短的几行输出代码中，可以学到关于字节代码的许多知识。在main方法的第一句指令是这样的：

0 getstatic #7 <Field java.io.PrintStream out>

开头的初始数字是指令在方法中的偏移，所以第一个指令的偏移是0。紧跟偏移的是指令助记符。在本例中，getstatic指令将一个静态字段压入一个数据结构，我们称这个数据结构为操作数堆栈。后续指令可以通过此结构引用这个字段。紧跟getstatic指令后面的是压到哪个字段中去。这里的字段是“#7 <Field java.io.PrintStream out>”。如果直接察看字节代码，这些字段信息并没有直接存放到指令中去。事实上，就象所有Java类使用的常量一样，字段信息存储在共享池中。在共享池中存储字段信息可以减小字节代码的大小。这是因为指令仅仅需要存储的是整型索引号，而不是将整个常量存储到常量池中。本例中，字段信息存放在常量池的第七号位置。存放的次序是由编译器决定的，所以看到的是“#7”。通过分析第一行指令，我们可以看出猜测其它指令的含义还是比较简单的。“ldc”（载入常量）指令将常量“Hello, World.”压入操作数堆栈。“invokevirtual”激发println方法，此方法从操作数堆栈中弹出两个参数。不要忘记象println这样的方法有两个参数：明显的一个是字符串参数，加上一个隐含的“this”引用。

 

二、Java字节代码是怎样使程序避免程序的内存错误

Java程序设计语言一直被称为internet的安全语言。从表面上看，这些代码象典型的C++代码，安全从何而来？安全的重要方面是避免程序的内存错误。计算机罪犯利用程序的内存错误可以将他们的非法代码加到其它安全的程序中去。Java字节代码是站在第一线抵御这种攻击的

1.类型安全检测实例

以下的例子可以说明Java具体是怎样做的。

public float add(float f, int n) {

return f + n;

}

如果你将这段代码加到第一个例子中去，重新编译，运行javap，分析情况如下：

Method float add(float, int)

   0 fload_1

   1 iload_2

   2 i2f

   3 fadd

   4 freturn

在Java方法的开头，虚拟机将方法的参数放到一个被称为举办变量表的数据结构中。从名字就可以看出，局部变量表包含所有声明的局部变量。在本例中，方法从三个局部变量表实体开始，这些是add方法的三个参数。位置0保存该方法返回类型，位置1和2保存浮点和整型参数。为了真正操纵变量，它们必须被装载（压）到操作数堆栈。第一条指令fload_1将浮点参数压到操作数堆栈的位置1。第二条指令iload_2将整型参数压到操作数堆栈的位置2。有趣的是这些指令的前缀是以“i”和“f”开头的，这表明Java字节代码的指令按严格的类型划分的。如果参数类型与字节代码的参数类型不符合，虚拟机将拒绝不安全的字节代码。更妙的是，字节代码被设计成仅执行一次

类型安全检查——当加载类的时候。

2.Java中的类型安全检测

类型安全是怎样增强系统安全性的呢？如果攻击者可以让虚拟机将整型变量当成浮点变量，或更严重更多，很容易预见计算的崩溃。如果计算是发生在银行账户上的，牵连的安全问题是很明显的。更危险的是欺骗虚拟机将整型变量编程一个对象引用。在大多数情况下，虚拟机将崩溃，但是攻击者只要找到一个漏洞即可。不要忘记攻击者不需要手工查找——更好且容易的办法是写一个程序产生大量变换的坏的字节代码，直到找到一个可以危害虚拟机的。

另一种字节代码保护内存安全的是数组操作。“aastore”和“aaload”字节代码操作Java数组，而它们一直要检查数组的边界。当调用者超越数组边界时，这些字节代码将产生数组溢出错误（ArrayIndexOutOfBoundsException）。也许所有应用中最重要的检测是分支指令，例如，以“if.”开始的字节代码。在字节代码中，分支指令在同一个方法中只能跳转到另一条指令。向方法之外传递控制的唯一办法是返回，产生一个异常，或执行一个唤醒（invoke）指令。这不仅关闭了许多易受攻击的大门，也防止由伴随引用和堆栈的崩溃导致的可恶的程序错误。如果你曾经用系统调试器打开过代码中随机定位的程序，你对这些程序错误会很熟悉。需要着重指出的是：所有的这些检测是由虚拟机在字节代码级上完成的，不仅仅是编译器。其它编程语言的编译器象C++的，可以防止一些我们在上面讨论过的内存错误，但这些保护是基于源代码级的。操作系统将读入执行任何机器代码，而不管这些代码是由小心翼翼的C++编译器还是由邪恶的攻击者产生的。简单地说，C++是在源程序级上是面向对象的，而Java的面向对象特性扩展到已经编译好的字节代码上。

 

三、怎样通过分析字节代码来提高程序的执行效率

不管你注意它们与否，Java字节代码的内存和安全保护都客观存在，那为什么还要那么麻烦去看字节代码呢？其实，就如在DOS下深入理解汇编就可以写出更好的C++代码一样，了解编译器怎样将你的代码翻译成字节代码可帮助你写出更有效率的代码，有时候甚至可以防止不知不觉的程序错误。

 

1.为什么在进行字符串合并时要使用StringBuffer来代替String

我们看以下代码：

//Return the concatenation str1+str2

    String concat(String str1, String str2) {

        return str1 + str2;

    }

 

    //Append str2 to str1

    void concat(StringBuffer str1, String str2) {

        str1.append(str2);

    }

试想一下每个方法需要执行多少函数。编译该程序并执行javap，输出结果如下：

Method java.lang.String concat(java.lang.String, java.lang.String)

   0 new #6 <Class java.lang.StringBuffer>

   3 dup

   4 aload_1

   5 invokestatic #14 <Method java.lang.String valueOf(java.lang.Object)>

   8 invokespecial #9 <Method java.lang.StringBuffer(java.lang.String)>

  11 aload_2

  12 invokevirtual #10 <Method java.lang.StringBuffer append(java.lang.String)>

  15 invokevirtual #13 <Method java.lang.String toString()>

  18 areturn

 

Method void concat(java.lang.StringBuffer, java.lang.String)

   0 aload_1

   1 aload_2

   2 invokevirtual #10 <Method java.lang.StringBuffer append(java.lang.String)>

   5 pop

   6 return

第一个concat方法有五个方法调用：new，invokestatic，invokespecial和两个invokevirtual。这比第二个cacat方法多了好多些工作，而第二个cacat只有一个简单的invokevirtual调用。String类的一个特点是其实例一旦创建，是不能改变的，除非重新给它赋值。在我们学习Java编程时，就被告知对于字符串连接来说，使用StringBuffer比使用String更有效率。使用javap分析这点可以清楚地看到它们的区别。如果你怀疑两种不同语言架构在性能上是否相同时，就应该使用javap分析字节代码。不同的Java编译器，其产生优化字节代码的方式也不同，利用javap也可以清楚地看到它们的区别。以下是JBuilder产生字节代码的分析结果：

Method java.lang.String concat(java.lang.String, java.lang.String)

   0 aload_1

   1 invokestatic #5 <Method java.lang.String valueOf(java.lang.Object)>

   4 aload_2

   5 invokestatic #5 <Method java.lang.String valueOf(java.lang.Object)>

   8 invokevirtual #6 <Method java.lang.String concat(java.lang.String)>

  11 areturn

可以看到经过JBuilder的优化，第一个concat方法有三个方法调用：两个invokestatic invokevirtual。这还是没有第二个concat方法简洁。

不管怎样，熟悉即时编译器(JIT, Just-in-time)。因为当某个方法被第一次调用时，即时编译器将对该虚拟方法表中所指向的字节代码进行编译，编译完后表中的指针将指向编译生成的机器码，这样即时编译器将字节代码重新编译成本机代码，它可以使你进行更多javap分析没有揭示的代码优化。除非你拥有虚拟机的源代码，你应当用性能基准来进行字节代码分析。

2.防止应用程序中的错误以下的例子说明如何通过检测字节代码来帮助防止应用程序中的错误。首先创建两个公共类，它们必须存放在两个不同的文件中。

public class ChangeALot {

    // Variable

    public static final boolean debug=false;

    public static boolean log=false;

}

 

public class EternallyConstant {

    // Methods

    public static void main(String [] args) {

        System.out.println("EternallyConstant beginning execution");

        if (ChangeALot.debug)

            System.out.println("Debug mode is on");

        if (ChangeALot.log)

            System.out.println("Logging mode is on");

    }

}

如果运行EternallyConstant类，应该得到如下信息：

EternallyConstant beginning execution.

现在我们修改ChangeALot文件，将debug和log变量的值都设置为true。只重新编译ChangeALot文件，再运行EternallyConstant，输出

结果如下：

EternallyConstant beginning execution

Logging mode is on

在调试模式下怎么了？即使设置debug为true，“Debug mode is on”还是打印不出来。答案在字节编码中。运行javap分析EternallyConstant类，可看到如下结果：

Compiled from EternallyConstant.java

public class EternallyConstant extends java.lang.Object {

    public EternallyConstant();

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

}

 

Method EternallyConstant()

   0 aload_0

   1 invokespecial #1 <Method java.lang.Object()>

   4 return

 

Method void main(java.lang.String[])

   0 getstatic #2 <Field java.io.PrintStream out>

   3 ldc #3 <String "EternallyConstant beginning execution">

   5 invokevirtual #4 <Method void println(java.lang.String)>

   8 getstatic #5 <Field boolean log>

  11 ifeq 22

  14 getstatic #2 <Field java.io.PrintStream out>

  17 ldc #6 <String "Logging mode is on">

  19 invokevirtual #4 <Method void println(java.lang.String)>

  22 return

很奇怪吧！由于有“ifep”检测log字段，代码一点都不检测debug字段。因为debug字段被标记为final，编译器知道debug字段在运行过程中不会改变。所以“if”语句被优化，分支部分被移去了。这是一个非常有用的优化，因为这使你可以在引用程序中嵌入调试代码，而设置为false时不用付出代价，不幸的是这会导致编译混乱。如果改变了final字段，记住重新编译其它引用该字段的类。这就是引用有可能被优化的原因。Java开发工具不是每次都能检测这个细微的改变，这些可能导致临时的非常程序错误。在这里，古老的C++格言对于Java环境来说一样成立：“每当迷惑不解时，重新编译所有程序。

 

四、利用第三方工具反编译Java字节代码

以上介绍了利用javap来分析Java字节代码，实际上，利用第三方的工具，可以直接得到源代码。这样的工具有很多，其中NMI's Java Code Viewer (NJCV)是其中使用起来比较方便的一种。

1．NMI's Java Code Viewer简介

NJCV针对编译好的Java字节编码，即.class文件、.zip或.jar文件。.jar文件实际上就是.zip文件。利用NJCV这类反编译工具，可以进一步调试、监听程序错误，进行安全分析等等。通过分析一些非常优秀的Java代码，我们可以从中学到许多开发Java程序的技巧。

NMI's Java Code Viewer 的最新版本是4.8.3，而且只能运行在以下Windows平台：

l         Windows 95/98

l         Windows 2000

l         Windows NT 3.51/4.0

2. NMI's Java Code Viewer应用实例

我们以前面例举到的ExampleOfByteCode.class作为例子。打开File菜单中的open菜单，打开Java字节代码文件，Java class files中列出了所有与该文件在同一个目录的文件。选择要反编译的文件，然后在Process菜单中选择Decompile或Dissasemble，反编译好的文件列在Souce-code files一栏。用NMI's Java Code Viewer提供的Programmer’s File Editor打开该文件，瞧，源代码都列出来了。

// Processed by NMI's Java Code Viewer 4.8.3 © 1997-2000 B. Lemaire

// Website: http://njcv.htmlplanet.com  E-mail: info@njcv.htmlplanet.com

// Copy registered to Evaluation Copy

// Source File Name:   ExampleOfByteCode.java

 

import java.io.PrintStream;

 

public class ExampleOfByteCode {

 

    public ExampleOfByteCode() {

    }

 

    public static void main(String args[]) {

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

    }

 

    public float add(float f, int n) {

        return f + (float)n;

    }

 

    String concat(String str1, String str2) {

        return str1 + str2;

    }

 

    void concat(StringBuffer str1, String str2) {

        str1.append(str2);

    }

}

NMI's Java Code Viewer也支持直接从jar/zip文件中提取类文件。反编译好的文件缺省用.nmi扩展名存放，用户可以设置.java扩展名。编辑源文件时可以使用NJCV提供的编辑器，用户可以选择自己喜欢的编辑器。其结果与原文件相差不大，相信大家会喜欢它。

 

五、结束语

了解一些字节代码可以帮助从事Java程序编程语言的程序员们编程。javap工具使察看字节代码变得非常容易，第三方的一些工具使代码的反编译易如反掌。经常使用javap检测代码，利用第三方工具反编代码，对于找到特别容易忘记的程序错误、提高程序运行效率、提高系统的安全性和性能来说，其价值是无法估量的。随着Java编程技术的发展，Java类库不断完善，利用Java优越的跨平台性能开发的应用软件也越来越多。Oracle用Java编写了Oracle

8i的Enterprise Manager，以及其数据库的安装程序；Inprise公司的Borland JBuilder 3.5也用Java写成；一些Internet电话也使用了Java技术，如MediaRing、DialPad的网络电话采用了Java的解决方案；甚至以上提到的NMI's Java Code Viewer也是用Java写成的。Java2已使Java得运行性能基本接近C++程序的执行速度，结合Enterprise JavaBean、Servlet以及COBRA、RMI技术，Java的功能会越来越强大，其应用也将日益广泛。

 

参考文献：

1.       Think in Java (Prentice Hall) Bruce Eckel

2.       Sun Java Web Site – JDC Tech Tips

3.       Java in a Nutshell (O`eilly and Assoc.) Mike Loukides, ed.

4.       Just Java 2 (Prentice Hall) Peter van der Linden

5.       The Java Virtual Machine Specifications (Addison Wesley) Tim Lindholm and Frank Yellin

 

 

转自： http://www.comprg.com.cn/detail.asp?hw_id=2632