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

核心提示：Java程序员很少注意程序的编译结果，事实上，深入Java编程：Java的字节代码，Java的字节代码向我们提供了非常有价值的信息，特别是在调试排除Java性能问题时，结合Enterprise JavaBean、Servlet以及COBRA、RMI技术，Java的功能会越来越强大，编译结果让我们可以更深入地理解如何提高

Java程序员很少注意程序的编译结果。事实上，Java的字节代码向我们提供了非常有价值的信息。特别是在调试排除Java性能问题时，编译结果让我们可以更深入地理解如何提高程序执行的效率等问题。其实JDK使我们研究Java字节代码变得非常容易。本文阐述怎样利用JDK中的工具查看解释Java字节代码，主要包含以下方面的一些内容：

l　　　　　　　　 Java类分解器——javap

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

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

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

一、Java类分解器——javap

大多数Java程序员知道他们的程序不是编译成本机代码的。实际上，程序被编译成中间字节代码，由Java虚拟机来解释执行。然而，很少程序员注意一下字节代码，因为他们使用的工具不鼓励他们这样做。大多数的Java调试工具不允许单步的字节代码调试。这些工具要么显示源代码，要么什么都不显示。

幸好JDK提供了Java类分解器javap，一个命令行工具。javap对类名给定的文件（.class）提供的字节代码进行反编译，打印出这些类的一个可读版本。在缺省情况下，javap打印出给定类内的公共域、方法、构造函数，以及静态初始值。

1．javap的具体用法

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

其中选项包括：

参数	含义
b	向后兼容JDK 1.1中的javap
c	反编译代码，打印出每个给定类中方法的Java虚拟机指令。使用该选项后，将对包括私有及受保护方法在内的所有方法进行反编译
classpath <pathlist>	指明到哪里查找用户的类文件。这个选项值覆盖了缺少路径以及由CLASSPATH环境变量定义的路径。此处给出的路径是一个目录及zip文件有序列表，其元素在Unix中以“:”，在Windows中以“;”分隔。要想在不覆盖缺省系统类路径的情况下增加一些要查找的目录或zip文件，应使用CLASSPATH环境变量，使用方法与编译器的-classpath相同。
extdirs <dirs>	覆盖安装扩展目录
help	显示帮助信息
J<flag>	将<flag>直接传递给运行系统
l	在原来打印信息的基础上，增加行号和局部变量表
public	只显示公共类及其成员
protected	显示受保护/公共类及其成员
package	显示包受保护/公共类及其成员（缺省）
private	显示所有类及其成员
s	打印内部类型标记
bootclasspath <pathlist>	覆盖由引导类加载器加载的类文件位置
verbose	打印堆栈大小，方法的局部变量和参数的数目。若可验证，打印出错原因

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的功能会越来越强大，其应用也将日益广泛。