一个简单的例子介绍 JDK 自带的工具 javap 的使用方法

javap是JDK自带的工具：

这篇文章使用下面这段简单的Java代码作为例子进行讲解。

class Outer {
	Nested nested;
	Nested getNested() {
		return nested;
	}
}
class Nested {
	Inner inner;
	Inner getInner() {
		return inner;
	}
}
class Inner {
	String foo;
	String getFoo() {
		return foo;
	}
}
public class NullableTest {
	public static Outer getInitializedOuter(){
		Outer outer = new Outer();
		outer.nested = new Nested();
		outer.nested.inner = new Inner();
		outer.nested.inner.foo = "Jerry";
		return outer;
	}
	/* null pointer exception
private static void way0(){
Outer outer = new Outer();
System.out.println(outer.nested.inner.foo);
}*/
	public static void way1(){
		Outer outer = getInitializedOuter();
		if (outer != null && outer.nested != null && outer.nested.inner != null) {
			System.out.println(outer.nested.inner.foo);
		}
	}
	public static void main(String[] args) {
		//way0();
		way1();
	}
}

使用下面的命令行对NullableTest进行反编译，以java编译器生成的字节码：

javap -v NullableTest >c:\code\1.txt

查看方法way1()对应的字节码：

下面这个wiki包含了java字节码里每个指令的具体说明：

https://en.wikipedia.org/wiki/Java_bytecode_instruction_listings

下面对NullableTest反编译得到的字节码做一些说明：

0: invokestatic #42 // Method getInitializedOuter:()Ljava8/Outer;

代表静态方法getInitializedOuter的调用, Ljava8/Outer意思是该方法的返回类型是Outer

3: astore_0

将上述静态方法调用返回的outer引用存储到局部变量中，局部变量的id为0.

4: aload_0

因为在我前面的Java源代码中，我将静态方法返回的对象引用同null做了比较，因此使用指令aload_0将存储在代号为0的局部变量中的对象引用重新加载到栈上，此后才能和null做比较。

5: ifnull 41

这就是我在Java源代码里书写的IF分支。如果IF分支里检测的outer引用为null，则直接返回了。体现在字节码就是，如果ifnull为true，则跳转到第41行字节码，即直接返回。

如果ifnull不为true，则继续执行下去。又将outer引用加载到栈上。

从字节码的分析可以观察到一个有趣的现象，再次看看我们的IF语句。

Java编译时，编译器实际将其转换成了下面的写法：

if (outer == null )

return;

if( outer.nested == null )

return;

if( outer.nested.inner == null)

return;

System.out.println(outer.nested.inner.foo);

这个事实可以通过下图得到确认。

javap生成的字节码里的LineNumberTable也很有用。这张表里每行的line后面的数字代表Java源代码的序号，line XX冒号后面的数字代表字节码里每行指令的序号。看看下图中Java源代码和对应的字节指令在LineNumberTable中的映射关系。

LineNumberTable维护了Java源代码同字节指令的映射关系，确保了Java代码调试的顺利进行。

另外介绍一个好用的工具：使用工具Source Monitor测量您Java代码的环复杂度。

代码的环复杂度(Cyclomatic complexity，有时也翻译成圈复杂度)是一种代码复杂度的衡量标准，在1976年由Thomas J. McCabe, Sr. 提出。

来看看计算公式。

代码环复杂度 = E − N + 2

E = 程序控制流图中边的个数

N = 程序控制流图中点的个数

很容易得出这样的结论：代码环复杂度越高，越容易出bug。

可以想象如果需要开发人员自己去把一段代码的控制流图画出来，然后去数图中边和点的个数，这种做法效率太低了也容易出错。

好消息是，有一款名为Source Monitor的免费软件，能够帮我们来度量Java代码的环复杂度。当然这款软件也支持C++和C#。

为了说明如何使用这款软件，我写了一段简单的Java代码。

package test;

import java.util.ArrayList;

public class monthTool {

static ArrayList<String> monthCollection = new ArrayList<String>();

public static void main(String[] args) {

monthTool tool = new monthTool();

tool.printV1(1);

tool.printV2(2);

tool.printV1(0);

tool.printV2(-1);

tool.printV3(3);

tool.printV3(13);

}

public monthTool(){

monthCollection.add("Invalid");

monthCollection.add("January");

monthCollection.add("Febrary");

monthCollection.add("March");

monthCollection.add("April");

monthCollection.add("May");

monthCollection.add("June");

monthCollection.add("July");

monthCollection.add("August");

monthCollection.add("September");

monthCollection.add("October");

monthCollection.add("November");

monthCollection.add("December");

}

public void printV1(int month){

System.out.println("Month is: " + getMonthNameV1(month));

}

public void printV2(int month){

if( month >= 1 && month <= 12)

System.out.println("Month is: " + getMonthNameV2(month));

else

System.out.println("Please specify a valid month");

}

public void printV3(int month) {

System.out.println("Month is: " + getMonthNameV3(month));

}

public String getMonthNameV2(int month){

if( month == 1)

return "January";

else if( month == 2)

return "Febrary";

else if( month == 3)

return "March";

else if( month == 4)

return "April";

else if( month == 5)

return "May";

else if( month == 6)

return "June";

else if( month == 7)

return "July";

else if( month == 8)

return "August";

else if( month == 9)

return "September";

else if( month == 10)

return "October";

else if( month == 11)

return "November";

else if( month == 12)

return "December";

else

return "Invalid";

}

public String getMonthNameV1(int month){

switch (month){

case 1:

return "January";

case 2:

return "Febrary";

case 3:

return "March";

case 4:

return "April";

case 5:

return "May";

case 6:

return "June";

case 7:

return "July";

case 8:

return "August";

case 9:

return "September";

case 10:

return "October";

case 11:

return "November";

case 12:

return "December";

default:

return "Invalid";

}

}

public String getMonthNameV3(int month){

try {

return monthCollection.get(month);

}

catch (java.lang.IndexOutOfBoundsException e){

return "Invalid";

}

}

}

其中我用了三种不同的方式实现了同一个逻辑，将一个代表月份的整数转成了月份名称。

下面是Source Monitor的具体用法。

1. 创建一个新的项目：

这里能看到所有Source Monitor支持的编程语言。

2. 指定您本地的Java项目文件地址：

3. 指定您的Java项目文件夹内，您希望SourceMonitor计算哪些Java文件的环复杂度。

4. 点OK，就可以开始扫描啦。

很快Source Monitor就将我们指定的Java文件的环复杂度计算完毕。点击菜单“Display Method Metrics”来查看结果：

从环复杂度扫描结果能看出，明显第三种从月份名称集合里通过ArrayList自带的get方法取得月份名称是最优的解法——环复杂度仅为2。

也可以通过图表的方式更直观得看到方法的环复杂度比较：

X轴的值代表每个方法的环复杂度，Y轴代表这些环复杂度的不同值出现的次数。

比如下图的意思是，环复杂度为1的方法（X轴刻度为1的节点)共有4个(Y轴刻度为4），环复杂度为2的方法（X轴刻度为2的节点）有1个（Y轴刻度为1）。以此类推。