Java Class文件詳解

作者：禪樓望月（ http://www.cnblogs.com/yaoyinglong ）

Java Class文件中包含以下信息：

[+] view code

ClassFile {

u4 magic;                                                                               //模數
u2 minor_version;                                                             //次版本號
u2 major_version;                                                             //主版本號
u2 constant_pool_count;                                                 //常量池大小
cp_info constant_pool[constant_pool_count-1];    //常量池
u2 access_flags;                                                                   //類和接口層次的訪問標志（通過|運算得到）
u2 this_class;                                                                        //類索引（指向常量池中的類常量）
u2 super_class;                                                                   //父類索引（指向常量池中的類常量）
u2 interfaces_count;                                                         //接口索引計數器
u2 interfaces[interfaces_count];                                  //接口索引集合
u2 fields_count;                                                                  //字段數量計數器
field_info fields[fields_count];                                      //字段表集合
u2 methods_count;                                                           //方法數量計數器
method_info methods[methods_count];                  //方法表集合
u2 attributes_count;                                                          //屬性個數
attribute_info attributes[attributes_count];             //屬性表

}

1. 通過實例來看

[+] view code

public interface InterA {

    void interA();

}  

public interface InterB {

    String interB(int i);

}

public interface InterC {

    void interC();

}

public class Base implements InterA {

 

    private int baseInt;

    protected String baseString;

   

    public int getBaseInt() {

        return baseInt;

    }

    public void setBaseInt(int baseInt) {

        this.baseInt = baseInt;

    }

 

    @Override

    public void interA() {

        System.out.println("the interA in Base");

    }

} 

 

 public class Sub extends Base implements InterB, InterC {

 

    private int subInt;

    private static String subString;

    private static Object subObject;

   

    public int getSubInt() {

        return subInt;

    }

    public void setSubInt(int subInt) {

        this.subInt = subInt;

    }

    public static String getSubString() {

        return subString;

    }

    public static void setSubString(String subString) {

        Sub.subString = subString;

    }

    public static Object getSubObject() {

        return subObject;

    }

    public static void setSubObject(Object subObject) {

        Sub.subObject = subObject;

    }

 

    @Override

    public void interC() {

        System.out.println("the interC in Sub");

    }

 

    @Override

    public String interB(int i) {

        return "the interB in Sub";

    }

}

我們使用WinHex查看Sub類的.class文件：

2. 魔數

作用：確定該文件是否是虛擬機可接受的class文件。java的魔數統一為 0xCAFEBABE (來源於一款咖啡)。

區域：文件第0~3字節。

3. 版本號

作用：表示class文件的版本，由minorversion和majorversion組成。

區域：文件第4~7字節。
如

51代表，jdk為1.7.0

需要注意的是java版本號是從45開始的，大版本發布，主版本號+1.高版本的jdk能向下兼容以前版本的class文件，但不兼容以后版本的class文件。

4. 常量池

常量池的大小是不固定的，根據你的類中的常量的多少而定，所以在常量池的入口，放置了一個u2類型的表示常量池中常量個數的常量池容量計數器。計數器從1開始，第0位有特殊含義，表示指向常量池的索引值數據不引用任何一個常量池項目。池中的數據項就像數組一樣是通過索引訪問的。

我們可以清楚的看到，我們常量池中有63-1=62個常量。這些常量是什么呢？

要存放字面量Literal和符號引用Symbolic References。

字面量可能是文本字符串，或final的常量值。
符號引用包括以下：

• 類或接口全限定名 Full Qualified Name
• 字段名稱和描述符 Descriptor
• 方法名稱和描述符

我們使用反編譯工具查看一下：

[+] view code

E:\program\JVM\bin\com\gissky\clazz>javap -v Sub.class
Classfile /E:/program/JVM/bin/com/gissky/clazz/Sub.class
  Last modified 2015-2-22; size 1363 bytes
  MD5 checksum 2dc77c79e4790422407eb7092085883c
  Compiled from "Sub.java"
public class com.gissky.clazz.Sub extends com.gissky.clazz.Base implements com.gissky.clazz.InterB,com.gissky.clazz.InterC
  SourceFile: "Sub.java"
  minor version: 0
  major version: 51
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Class              #2             //  com/gissky/clazz/Sub    →類和接口的全限定名   
   #2 = Utf8               com/gissky/clazz/Sub
   #3 = Class              #4             //  com/gissky/clazz/Base
   #4 = Utf8               com/gissky/clazz/Base
   #5 = Class              #6             //  com/gissky/clazz/InterB
   #6 = Utf8               com/gissky/clazz/InterB
   #7 = Class              #8             //  com/gissky/clazz/InterC
   #8 = Utf8               com/gissky/clazz/InterC
   #9 = Utf8               subInt
  #10 = Utf8              I
  #11 = Utf8              subString
  #12 = Utf8               Ljava/lang/String;
  #13 = Utf8               subObject
  #14 = Utf8               Ljava/lang/Object;
  #15 = Utf8               <init>
  #16 = Utf8               ()V
  #17 = Utf8               Code
  #18 = Methodref          #3.#19         //  com/gissky/clazz/Base."<init>":()V
  #19 = NameAndType        #15:#16        //  "<init>":()V
  #20 = Utf8               LineNumberTable
  #21 = Utf8               LocalVariableTable
  #22 = Utf8               this
  #23 = Utf8               Lcom/gissky/clazz/Sub;
  #24 = Utf8               getSubInt
  #25 = Utf8               ()I
  #26 = Fieldref           #1.#27         //  com/gissky/clazz/Sub.subInt:I         → 類中字段的符號引用
  #27 = NameAndType        #9:#10         //  subInt:I                                           → 類中字段的部分符號引用之名稱和類型
  #28 = Utf8               setSubInt
  #29 = Utf8               (I)V
  #30 = Utf8               getSubString
  #31 = Utf8               ()Ljava/lang/String;
  #32 = Fieldref           #1.#33         //  com/gissky/clazz/Sub.subString:Ljava/lang/String;
  #33 = NameAndType        #11:#12        //  subString:Ljava/lang/String;
  #34 = Utf8               setSubString
  #35 = Utf8               (Ljava/lang/String;)V
  #36 = Utf8               getSubObject
  #37 = Utf8               ()Ljava/lang/Object;
  #38 = Fieldref           #1.#39         //  com/gissky/clazz/Sub.subObject:Ljava/lang/Object;
  #39 = NameAndType        #13:#14        //  subObject:Ljava/lang/Object;
  #40 = Utf8               setSubObject
  #41 = Utf8               (Ljava/lang/Object;)V
  #42 = Utf8               interC
  #43 = Fieldref           #44.#46        //  java/lang/System.out:Ljava/io/PrintStream;
  #44 = Class              #45            //  java/lang/System
  #45 = Utf8               java/lang/System
  #46 = NameAndType        #47:#48        //  out:Ljava/io/PrintStream;
  #47 = Utf8               out
  #48 = Utf8               Ljava/io/PrintStream;
  #49 = String             #50            //  the interC in Sub
  #50 = Utf8               the interC in Sub
  #51 = Methodref          #52.#54        //  java/io/PrintStream.println:(Ljava/lang/String;)V
  #52 = Class              #53            //  java/io/PrintStream
  #53 = Utf8               java/io/PrintStream
  #54 = NameAndType        #55:#35        //  println:(Ljava/lang/String;)V
  #55 = Utf8               println
  #56 = Utf8               interB
  #57 = Utf8               (I)Ljava/lang/String;
  #58 = String             #59            //  the interB in Sub                                    →方法中用到的String常量
  #59 = Utf8               the interB in Sub
  #60 = Utf8               i
  #61 = Utf8               SourceFile
  #62 = Utf8               Sub.java

常量池中的項目類型如下：

• CONSTANT_Utf8_info      tag標志位為1,   UTF-8編碼的字符串
• CONSTANT_Integer_info  tag標志位為3， 整形字面量
• CONSTANT_Float_info     tag標志位為4， 浮點型字面量
• CONSTANT_Long_info     tag標志位為5， 長整形字面量
• CONSTANT_Double_info  tag標志位為6， 雙精度字面量
• CONSTANT_Class_info    tag標志位為7， 類或接口的符號引用
• CONSTANT_String_info    tag標志位為8，字符串類型的字面量
• CONSTANT_Fieldref_info  tag標志位為9,  字段的符號引用
• CONSTANT_Methodref_info  tag標志位為10，類中方法的符號引用
• CONSTANT_InterfaceMethodref_info tag標志位為11, 接口中方法的符號引用
• CONSTANT_NameAndType_info tag 標志位為12，字段和方法的名稱以及類型的符號引用

5. 類或接口訪問標志

表示類或者接口方面的訪問信息，比如Class表示的是類還是接口，是否為public、static、final等。，下面我們就來看看TestClass的訪問標示。Class的訪問標志值為0x0021：

根據前面說的各種訪問標示的標志位，我們可以知道：0x0021=0x0001|0x0020 也即ACC_PUBLIC 和 ACC_SUPER為真，其中ACC_PUBLIC大家好理解，ACC_SUPER是jdk1.2之后編譯的類都會帶有的標志。

6. 類索引、父類索引與接口索引集合

Class文件中由這3項數據來確定類的繼承關系。

類索引和父類索引都是指向常量池中的常量索引：

緊接着后面是一個接口的計數器和接口描述符：

7. 字段表集合

作用：描述接口或者類中聲明的類變量以及實例變量，不包括方法中的局部變量。

緊接着接口索引集合之后的2字節是字段計數器：

表示我們類中有3個字段，這里便是subInt、subString、subObject 3個字段。緊接其后的是字段表，字段表結構為：

[+] view code

field_info
{
    u2                               access_flags;
    u2                               name_index;
    u2                               descriptor_index;
    u2                               attributes_count;
    attribute_info          attributes[attributes_count];
}

access_flags項的值是用於定義字段被訪問權限和基礎屬性的掩碼標志。取值范圍如下表：

描述符標識字符含義：

V 表示特殊類型void。

對於數組類型，每一個維度將使用一個前置的”["字符來描述，如一個定義的"java.lang.String[][]“類型的二維數組，將被記錄為:”[[Ljava/lang/String;",一個整型數組"int[]“將被記錄為”[I"

父類中的字段不會出現在子類的字段表中。

8. 方法表集合

字段表集合結束后便是方法表集合。

作用：描述該類中的方法。

和字段表一樣，使用一個u2類型的方法計數器，記錄該類中方法的個數。

表示我們的類中有9個方法。

方法表的結構如下圖所示

其中name_index和descriptor_index表示的是方法的名稱和描述符，他們分別是指向常量池的索引。這里需要結解釋一下方法的描述符，方法的描述符的結構為：（參數列表）返回值，比如public int instanceMethod(int param)的描述符為：（I）I，表示帶有一個int類型參數且返回值也為int類型的方法，方法java.lang.String.toString()的描述符為"()Ljava/lang/String;"，int IndexOf(char[] source,int sourceOffset,int sourceCount,char[] target int targetOffset,int targetCount,int fromIndex) 表示為([CII[CII)I。接下來就是屬性數量以及屬性表了，方法表和字段表雖然都有 屬性數量和屬性表，但是他們里面所包含的屬性是不同。

如果父類方法在子類中沒有被重寫（@Override），方法表中就不會出現來自父類的方法信息。

9. 屬性表集合

上面的方法表中我們就看到<init>方法有一個Code的屬性。在本節我們將闡述這些屬性：

Code屬性：

該屬性里主要存放由javac編譯器處理后得到的字節碼指令。

其中attribute_name_index指向常量池中值為Code的常量，attribute_length的長度表示Code屬性表的長度（這里 需要注意的時候長度不包括attribute_name_index和attribute_length的6個字節的長度）。

max_stack表示最大棧深度，虛擬機在運行時根據這個值來分配棧幀中操作數的深度，而max_locals代表了局部變量表所需的存儲空間。

max_locals的單位為slot，slot是虛擬機為局部變量分配內存的最小單元，在運行時，對於不超過32位類型的數據類型，比如 byte,char,int等占用1個slot，而double和Long這種64位的數據類型則需要分配2個slot，另外max_locals的值並不是所有局部變量所需要的內存數量之和，因為slot是可以重用的，當局部變量超過了它的作用域以后，局部變量所占用的slot就會被重用。方法參數、顯示異常處理器的參數、方法體中定義的局部變量都要使用局部變量表來存放。

code_length代表了字節碼指令的數量，而code表示的是字節碼指令，從上圖可以知道code的類型為u1,一個u1類型的取值為0x00-0xFF,對應的十進制為0-255，目前虛擬機規范已經定義了200多條指令。

exception_table_length以及exception_table分別代表方法對應的異常信息。

attributes_count和attribute_info分別表示了Code屬性中的屬性數量和屬性表，從這里可以看出Class的文件結構中，屬性表是很靈活的，它可以存在於Class文件，方法表，字段表以及Code屬性中。

修改一下Sub中的InterB方法：

[+] view code

    @Override

    public int interB(int i){

        int x=0;

        try{

            x+=i;

            return x;

        }catch(Exception e){

            x=-1;

            return x;

        }finally{

            x=3;

        }

    }  

大家不妨先猜一下這個函數的結果是什么？假如在try塊中發生異常，結構又是什么？我相信對Java語言熟悉的朋友，肯定知道答案。

使用反編譯工具查看：

[+] view code

  public int interB(int);

    flags: ACC_PUBLIC

    Code:

      stack=2, locals=6, args_size=2

         0: iconst_0

         1: istore_2

         2: iload_2

         3: iload_1

         4: iadd

         5: istore_2

         6: iload_2

         7: istore        5

         9: iconst_3

        10: istore_2

        11: iload         5

        13: ireturn

        14: astore_3

        15: iconst_m1

        16: istore_2

        17: iload_2

        18: istore        5

        20: iconst_3

        21: istore_2

        22: iload         5

        24: ireturn

        25: astore        4

        27: iconst_3

        28: istore_2

        29: aload         4

        31: athrow

      Exception table:

         from    to   target    type

             2       9       14         Class java/lang/Exception

             2       9       25         any

            14      20    25         any

      LineNumberTable:

        line 35: 0

        line 37: 2

        line 38: 6

        line 43: 9

        line 38: 11

        line 39: 14

        line 40: 15

        line 41: 17

        line 43: 20

        line 41: 22

        line 42: 25

        line 43: 27

        line 44: 29

      LocalVariableTable:

        Start  Length  Slot  Name   Signature

               0      32        0      this         Lcom/gissky/clazz/Sub;

               0      32        1        i             I

               2      30        2        x            I

              15    10        3        e            Ljava/lang/Exception;

      StackMapTable: number_of_entries = 2

           frame_type = 255 /* full_frame */

          offset_delta = 14

          locals = [ class com/gissky/clazz/Sub, int, int ]

          stack = [ class java/lang/Exception ]

           frame_type = 74 /* same_locals_1_stack_item */

          stack = [ class java/lang/Throwable ]

}

從 args_size=2這條反編譯代碼，我們可以知道，在public int interB(int i)這個方法中有6個局部變量，2個參數，可是我們的函數中明明只有一個參數么……這是因為編譯器會為每一個實例函數包括構造器添加一個參數this，在JVM調用該方法的時候會該形參傳遞一個實參—方法所在對象的自身。

      Exception table:

         from    to   target    type

             2       9       14         Class java/lang/Exception

             2       9       25         any

            14      20    25         any

上表表頭表示，當字節碼在form行到to行（不包括to行）出現類型為type的異常，則轉到第target行繼續處理。

從方法的異常表中，我們可以看到這個函數有3條執行路徑：

這里我們插入闡述一下LineNumberTable表的含義：它表示Java源碼行號與字節碼行號之間的對應關系。

對照上圖，我們能清晰的看出這3條路徑。

知道了該方法執行的3條路徑，我們也就知道剛才我們的那個問題有3個答案：沒有異常是為x+i；try塊中出現Exception類型的錯誤時，返回-1；出現Exception以外的任何異常方法非正常結束，沒有返回值。

      LocalVariableTable:

        Start  Length  Slot  Name   Signature

               0      32        0      this         Lcom/gissky/clazz/Sub;

               0      32        1        i             I

               2      30        2        x            I

              15    10        3        e            Ljava/lang/Exception;

LocalVariableTable表示局部變量表，描述方法中局部變量。

如果你對返回的答案能理解的話，那么我相信你也肯定知道，我們函數中只有4個參數，但max_locals卻等於6。不懂的話仔細看一下Code中字節碼的執行過程變可以理解了。

一個方法在執行時需要多大的局部變量空間在編譯時期就知道了，方法執行期間不會改變局部變量表的大小。

Signature 屬性：

該屬性是在JDK1.5新增的。該屬性可用於類、屬性表和方法表結構的屬性表中。使用泛型簽名如果包含了類型變量（Type Variables）或參數化類型（Parameterized Types），則Signature 屬性會為它記錄泛型簽名信息。當我們要泛型類中拿到泛型的實際類型的時候非常有用。

實例：

在使用Hibernate時，我習慣將為Dao層封裝一個泛型基類，來放置一些通用的方法，而Hibernate有很多方法都要傳遞一個POJO的類型，然后進行查詢，如load方法。我們構建這樣的一個基類：

public abstract class BaseDaoImpl<T, PK extends Serializable> extends HibernateDaoSupport implements BaseDao<T, PK>

那么load中要使用的POJO類型便是T的實際類型。怎么來那倒這個屬性呢？這里邊要使用到Signature屬性了。

[+] view code

public abstract class BaseDaoImpl<T, PK extends Serializable> extends HibernateDaoSupport implements BaseDao<T, PK> {

 

    private Class<T> entityClass;

   

    @SuppressWarnings("unchecked")

    public BaseDaoImpl() {

        //class OrgDao extends BaseDaoImpl<Organization, String> implements OrgDao {}

        Class c = this.getClass(); //返回的是使用new創建的泛型類對應的對象的class對象。

        Type type = c.getGenericSuperclass(); //取得該對象的泛型類

        //取得泛型對應的真正的class，並放到數組中

        Type[] types = ((ParameterizedType)type).getActualTypeArguments();

        entityClass = (Class<T>) types[0];

    }  

這時，getById中就可以直接使用了：

    public T getById(PK id) {

        return (T) getHibernateTemplate().load(entityClass, id);

    } 

感謝有您，讓我成長的更快：

深入理解Java虛擬機:JVM高級特性與最佳實踐(第2版)

實例分析Java Class的文件結構

深入JVM的Class文件結構

《Java虛擬機規范》閱讀（三）:Class文件格式

談談Java虛擬機——Class文件結構

Java字節碼（.class文件）格式詳解（三）