Class文件的結構屬性

在理解之前先從整體看下java位元組碼文件包含了哪些類型的數據：

從一個例子開始

下面以一個簡單的例子來逐步講解位元組碼。

//Main.java
public class Main {
    
    private int m;
    
    public int inc() {
        return m + 1;
    }
}

通過以下命令, 可以在當前所在路徑下生成一個Main.class文件。

javac Main.java

以文本的形式打開生成的class文件，內容如下:

cafe babe 0000 0034 0013 0a00 0400 0f09
0003 0010 0700 1107 0012 0100 016d 0100
0149 0100 063c 696e 6974 3e01 0003 2829
5601 0004 436f 6465 0100 0f4c 696e 654e
756d 6265 7254 6162 6c65 0100 0369 6e63
0100 0328 2949 0100 0a53 6f75 7263 6546
696c 6501 0009 4d61 696e 2e6a 6176 610c
0007 0008 0c00 0500 0601 0010 636f 6d2f
7268 7974 686d 372f 4d61 696e 0100 106a
6176 612f 6c61 6e67 2f4f 626a 6563 7400
2100 0300 0400 0000 0100 0200 0500 0600
0000 0200 0100 0700 0800 0100 0900 0000
1d00 0100 0100 0000 052a b700 01b1 0000
0001 000a 0000 0006 0001 0000 0003 0001
000b 000c 0001 0009 0000 001f 0002 0001
0000 0007 2ab4 0002 0460 ac00 0000 0100
0a00 0000 0600 0100 0000 0800 0100 0d00
0000 0200 0e

• 文件開頭的4個位元組(“cafe babe”)稱之為 魔數，唯有以”cafe babe”開頭的class文件方可被虛擬機所接受，這4個位元組就是位元組碼文件的身份識別。
• 0000是編譯器jdk版本的次版本號0，0034轉化為十進位是52,是主版本號，java的版本號從45開始，除1.0和1.1都是使用45.x外,以後每升一個大版本，版本號加一。也就是說，編譯生成該class文件的jdk版本為1.8.0。

通過java -version命令稍加驗證, 可得結果。

Java(TM) SE Runtime Environment (build 1.8.0_131-b11)
Java HotSpot(TM) 64-Bit Server VM (build 25.131-b11, mixed mode)

繼續往下是常量池… 知道是這麼分析的就可以了，然後我們通過工具反編譯位元組碼文件繼續去看。

反編譯位元組碼文件

使用到java內置的一個反編譯工具javap可以反編譯位元組碼文件, 用法: javap <options> <classes>

其中<options>選項包括:

-help  --help  -?        輸出此用法消息
  -version                 版本資訊
  -v  -verbose             輸出附加資訊
  -l                       輸出行號和本地變數表
  -public                  僅顯示公共類和成員
  -protected               顯示受保護的/公共類和成員
  -package                 顯示程式包/受保護的/公共類
                           和成員 (默認)
  -p  -private             顯示所有類和成員
  -c                       對程式碼進行反彙編
  -s                       輸出內部類型簽名
  -sysinfo                 顯示正在處理的類的
                           系統資訊 (路徑, 大小, 日期, MD5 散列)
  -constants               顯示最終常量
  -classpath <path>        指定查找用戶類文件的位置
  -cp <path>               指定查找用戶類文件的位置
  -bootclasspath <path>    覆蓋引導類文件的位置

輸入命令javap -verbose -p Main.class查看輸出內容:

Classfile /E:/JavaCode/TestProj/out/production/TestProj/com/rhythm7/Main.class
  Last modified 2018-4-7; size 362 bytes
  MD5 checksum 4aed8540b098992663b7ba08c65312de
  Compiled from "Main.java"
public class com.rhythm7.Main
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #4.#18         // java/lang/Object."<init>":()V
   #2 = Fieldref           #3.#19         // com/rhythm7/Main.m:I
   #3 = Class              #20            // com/rhythm7/Main
   #4 = Class              #21            // java/lang/Object
   #5 = Utf8               m
   #6 = Utf8               I
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcom/rhythm7/Main;
  #14 = Utf8               inc
  #15 = Utf8               ()I
  #16 = Utf8               SourceFile
  #17 = Utf8               Main.java
  #18 = NameAndType        #7:#8          // "<init>":()V
  #19 = NameAndType        #5:#6          // m:I
  #20 = Utf8               com/rhythm7/Main
  #21 = Utf8               java/lang/Object
{
  private int m;
    descriptor: I
    flags: ACC_PRIVATE

  public com.rhythm7.Main();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/rhythm7/Main;

  public int inc();
    descriptor: ()I
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: getfield      #2                  // Field m:I
         4: iconst_1
         5: iadd
         6: ireturn
      LineNumberTable:
        line 8: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       7     0  this   Lcom/rhythm7/Main;
}
SourceFile: "Main.java"

位元組碼文件資訊

開頭的7行資訊包括:Class文件當前所在位置，最後修改時間，文件大小，MD5值，編譯自哪個文件，類的全限定名，jdk次版本號，主版本號。

然後緊接著的是該類的訪問標誌：ACC_PUBLIC, ACC_SUPER，訪問標誌的含義如下:

常量池

Constant pool意為常量池。

常量池可以理解成Class文件中的資源倉庫。主要存放的是兩大類常量：字面量(Literal)和符號引用(Symbolic References)。字面量類似於java中的常量概念，如文本字元串，final常量等，而符號引用則屬於編譯原理方面的概念，包括以下三種:

• 類和介面的全限定名(Fully Qualified Name)
• 欄位的名稱和描述符號(Descriptor)
• 方法的名稱和描述符

不同於C/C++, JVM是在載入Class文件的時候才進行的動態鏈接，也就是說這些欄位和方法符號引用只有在運行期轉換後才能獲得真正的記憶體入口地址。當虛擬機運行時，需要從常量池獲得對應的符號引用，再在類創建或運行時解析並翻譯到具體的記憶體地址中。 直接通過反編譯文件來查看位元組碼內容：

#1 = Methodref          #4.#18         // java/lang/Object."<init>":()V
#4 = Class              #21            // java/lang/Object
#7 = Utf8               <init>
#8 = Utf8               ()V
#18 = NameAndType        #7:#8          // "<init>":()V
#21 = Utf8               java/lang/Object

第一個常量是一個方法定義，指向了第4和第18個常量。以此類推查看第4和第18個常量。最後可以拼接成第一個常量右側的注釋內容:

java/lang/Object."<init>":()V

這段可以理解為該類的實例構造器的聲明，由於Main類沒有重寫構造方法，所以調用的是父類的構造方法。此處也說明了Main類的直接父類是Object。 該方法默認返回值是V, 也就是void，無返回值。

第二個常量同理可得:

#2 = Fieldref           #3.#19         // com/rhythm7/Main.m:I
#3 = Class              #20            // com/rhythm7/Main
#5 = Utf8               m
#6 = Utf8               I
#19 = NameAndType        #5:#6          // m:I
#20 = Utf8               com/rhythm7/Main

複製程式碼此處聲明了一個欄位m，類型為I, I即是int類型。關於位元組碼的類型對應如下：

對於數組類型，每一位使用一個前置的[字元來描述，如定義一個java.lang.String[][]類型的維數組，將被記錄為[[Ljava/lang/String;

方法表集合

在常量池之後的是對類內部的方法描述，在位元組碼中以表的集合形式表現，暫且不管位元組碼文件的16進位文件內容如何，我們直接看反編譯後的內容。

private int m;
  descriptor: I
  flags: ACC_PRIVATE

此處聲明了一個私有變數m，類型為int，返回值為int

public com.rhythm7.Main();
   descriptor: ()V
   flags: ACC_PUBLIC
   Code:
     stack=1, locals=1, args_size=1
        0: aload_0
        1: invokespecial #1                  // Method java/lang/Object."<init>":()V
        4: return
     LineNumberTable:
       line 3: 0
     LocalVariableTable:
       Start  Length  Slot  Name   Signature
           0       5     0  this   Lcom/rhythm7/Main;

這裡是構造方法：Main()，返回值為void, 公開方法。

code內的主要屬性為:

• stack: 最大操作數棧，JVM運行時會根據這個值來分配棧幀(Frame)中的操作棧深度,此處為1

• locals: 局部變數所需的存儲空間，單位為Slot, Slot是虛擬機為局部變數分配記憶體時所使用的最小單位，為4個位元組大小。方法參數(包括實例方法中的隱藏參數this)，顯示異常處理器的參數(try catch中的catch塊所定義的異常)，方法體中定義的局部變數都需要使用局部變數表來存放。值得一提的是，locals的大小並不一定等於所有局部變數所佔的Slot之和，因為局部變數中的Slot是可以重用的。

• args_size: 方法參數的個數，這裡是1，因為每個實例方法都會有一個隱藏參數this

• attribute_info: 方法體內容，0,1,4為位元組碼”行號”，該段程式碼的意思是將第一個引用類型本地變數推送至棧頂，然後執行該類型的實例方法，也就是常量池存放的第一個變數，也就是注釋里的”java/lang/Object.””😦)V”, 然後執行返回語句，結束方法。

• LineNumberTable: 該屬性的作用是描述源碼行號與位元組碼行號(位元組碼偏移量)之間的對應關係。可以使用 -g:none 或-g:lines選項來取消或要求生成這項資訊，如果選擇不生成LineNumberTable，當程式運行異常時將無法獲取到發生異常的源碼行號，也無法按照源碼的行數來調試程式。

• LocalVariableTable: 該屬性的作用是描述幀棧中局部變數與源碼中定義的變數之間的關係。可以使用 -g:none 或 -g:vars來取消或生成這項資訊，如果沒有生成這項資訊，那麼當別人引用這個方法時，將無法獲取到參數名稱，取而代之的是arg0, arg1這樣的佔位符。 start 表示該局部變數在哪一行開始可見，length表示可見行數，Slot代表所在幀棧位置，Name是變數名稱，然後是類型簽名。

同理可以分析Main類中的另一個方法”inc()”:

方法體內的內容是：將this入棧，獲取欄位#2並置於棧頂, 將int類型的1入棧，將棧內頂部的兩個數值相加，返回一個int類型的值。

類名

最後很顯然是源碼文件：

SourceFile: "Main.java"

載入時類載入過程的第一個階段，在載入階段，虛擬機需要完成以下三件事情:

• 通過一個類的全限定名來獲取其定義的二進位位元組流。
• 將這個位元組流所代表的靜態存儲結構轉化為方法區的運行時數據結構。
• 在Java堆中生成一個代表這個類的java.lang.Class對象，作為對方法區中這些數據的訪問入口。

相對於類載入的其他階段而言，載入階段(準確地說，是載入階段獲取類的二進位位元組流的動作)是可控性最強的階段，因為開發人員既可以使用系統提供的類載入器來完成載入，也可以自定義自己的類載入器來完成載入。

載入階段完成後，虛擬機外部的 二進位位元組流就按照虛擬機所需的格式存儲在方法區之中，而且在Java堆中也創建一個java.lang.Class類的對象，這樣便可以通過該對象訪問方法區中的這些數據。

類載入器並不需要等到某個類被「首次主動使用」時再載入它，JVM規範允許類載入器在預料某個類將要被使用時就預先載入它，如果在預先載入的過程中遇到了.class文件缺失或存在錯誤，類載入器必須在程式首次主動使用該類時才報告錯誤(LinkageError錯誤)如果這個類一直沒有被程式主動使用，那麼類載入器就不會報告錯誤。

載入.class文件的方式

• 從本地系統中直接載入
• 通過網路下載.class文件
• 從zip，jar等歸檔文件中載入.class文件
• 從專有資料庫中提取.class文件
• 將Java源文件動態編譯為.class文件

連接

驗證: 確保被載入的類的正確性

驗證是連接階段的第一步，這一階段的目的是為了確保Class文件的位元組流中包含的資訊符合當前虛擬機的要求，並且不會危害虛擬機自身的安全。驗證階段大致會完成4個階段的檢驗動作:

• 文件格式驗證: 驗證位元組流是否符合Class文件格式的規範；例如: 是否以0xCAFEBABE開頭、主次版本號是否在當前虛擬機的處理範圍之內、常量池中的常量是否有不被支援的類型。

• 元數據驗證: 對位元組碼描述的資訊進行語義分析(注意: 對比javac編譯階段的語義分析)，以保證其描述的資訊符合Java語言規範的要求；例如: 這個類是否有父類(除了java.lang.Object之外)、是否是抽象類，是否實現了父類或介面的方法等。

• 位元組碼驗證: 通過數據流和控制流分析，確定程式語義是合法的、符合邏輯的。對類方法體進行校驗分析，保證被校驗類的方法在運行時不會做危害虛擬機安全的事件

• 符號引用驗證: 確保解析動作能正確執行。對類自身以外的資訊進行匹配性校驗

驗證階段是非常重要的，但不是必須的，它對程式運行期沒有影響，如果所引用的類經過反覆驗證，那麼可以考慮採用-Xverify:none參數來關閉大部分的類驗證措施，以縮短虛擬機類載入的時間。

準備: 為類的靜態變數分配記憶體，並將其初始化為默認值

準備階段是正式為類變數分配記憶體並設置類變數初始值的階段，這些記憶體都將在方法區中分配。對於該階段有以下幾點需要注意:

• 這時候進行記憶體分配的僅包括類變數(static)，而不包括實例變數，實例變數會在對象實例化時隨著對象一塊分配在Java堆中。

• 這裡所設置的初始值通常情況下是數據類型默認的零值(如0、0L、null、false等)，而不是被在Java程式碼中被顯式地賦予的值。

假設一個類變數的定義為: public static int value = 3；那麼變數value在準備階段過後的初始值為0，而不是3，因為這時候尚未開始執行任何Java方法，而把value賦值為3的put static指令是在程式編譯後，存放於類構造器<clinit>()方法之中的，所以把value賦值為3的動作將在初始化階段才會執行。

這裡還需要注意如下幾點

• 對基本數據類型來說，對於類變數(static)和全局變數，如果不顯式地對其賦值而直接使用，則系統會為其賦予默認的零值，而對於局部變數來說，在使用前必須顯式地為其賦值，否則編譯時不通過。
• 對於同時被static和final修飾的常量，必須在聲明的時候就為其顯式地賦值，否則編譯時不通過；而只被final修飾的常量則既可以在聲明時顯式地為其賦值，也可以在類初始化時顯式地為其賦值，總之，在使用前必須為其顯式地賦值，系統不會為其賦予默認零值。
• 對於引用數據類型reference來說，如數組引用、對象引用等，如果沒有對其進行顯式地賦值而直接使用，系統都會為其賦予默認的零值，即null。
• 如果在數組初始化時沒有對數組中的各元素賦值，那麼其中的元素將根據對應的數據類型而被賦予默認的零值。
• 如果類欄位的欄位屬性表中存在ConstantValue屬性，即同時被final和static修飾，那麼在準備階段變數value就會被初始化為ConstValue屬性所指定的值。假設上面的類變數value被定義為: public static final int value = 3；編譯時Javac將會為value生成ConstantValue屬性，在準備階段虛擬機就會根據ConstantValue的設置將value賦值為3。我們可以理解為static final常量在編譯期就將其結果放入了調用它的類的常量池中

解析: 把類中的符號引用轉換為直接引用

解析階段是虛擬機將常量池內的符號引用替換為直接引用的過程，解析動作主要針對類或介面、欄位、類方法、介面方法、方法類型、方法句柄和調用點限定符7類符號引用進行。

符號引用就是一組符號來描述目標，可以是任何字面量。
直接引用就是直接指向目標的指針、相對偏移量或一個間接定位到目標的句柄。

初始化

初始化，為類的靜態變數賦予正確的初始值，JVM負責對類進行初始化，主要對類變數進行初始化。在Java中對類變數進行初始值設定有兩種方式:

• 聲明類變數是指定初始值
• 使用靜態程式碼塊為類變數指定初始值

JVM初始化步驟

• 假如這個類還沒有被載入和連接，則程式先載入並連接該類
• 假如該類的直接父類還沒有被初始化，則先初始化其直接父類
• 假如類中有初始化語句，則系統依次執行這些初始化語句

類初始化時機: 只有當對類的主動使用的時候才會導致類的初始化，類的主動使用包括以下六種:

• 創建類的實例，也就是new的方式
• 訪問某個類或介面的靜態變數，或者對該靜態變數賦值
• 調用類的靜態方法
• 反射(如Class.forName(“com.pdai.jvm.Test”))
• 初始化某個類的子類，則其父類也會被初始化
• Java虛擬機啟動時被標明為啟動類的類(Java Test)，直接使用java.exe命令來運行某個主類

使用

類訪問方法區內的數據結構的介面， 對象是Heap區的數據。

卸載

Java虛擬機將結束生命周期的幾種情況

• 執行了System.exit()方法
• 程式正常執行結束
• 程式在執行過程中遇到了異常或錯誤而異常終止
• 由於作業系統出現錯誤而導致Java虛擬機進程終止

package com.pdai.jvm.classloader;
public class ClassLoaderTest {
     public static void main(String[] args) {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        System.out.println(loader);
        System.out.println(loader.getParent());
        System.out.println(loader.getParent().getParent());
    }
}

sun.misc.Launcher$AppClassLoader@64fef26a
sun.misc.Launcher$ExtClassLoader@1ddd40f3
null

package com.pdai.jvm.classloader;
public class loaderTest { 
        public static void main(String[] args) throws ClassNotFoundException { 
                ClassLoader loader = HelloWorld.class.getClassLoader(); 
                System.out.println(loader); 
                //使用ClassLoader.loadClass()來載入類，不會執行初始化塊 
                loader.loadClass("Test2"); 
                //使用Class.forName()來載入類，默認會執行初始化塊 
//                Class.forName("Test2"); 
                //使用Class.forName()來載入類，並指定ClassLoader，初始化時不執行靜態塊 
//                Class.forName("Test2", false, loader); 
        } 
}

public class Test2 { 
        static { 
                System.out.println("靜態初始化塊執行了！"); 
        } 
}

public Class<?> loadClass(String name)throws ClassNotFoundException {
            return loadClass(name, false);
    }
    protected synchronized Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException {
            // 首先判斷該類型是否已經被載入
            Class c = findLoadedClass(name);
            if (c == null) {
                //如果沒有被載入，就委託給父類載入或者委派給啟動類載入器載入
                try {
                    if (parent != null) {
                         //如果存在父類載入器，就委派給父類載入器載入
                        c = parent.loadClass(name, false);
                    } else {
                    //如果不存在父類載入器，就檢查是否是由啟動類載入器載入的類，通過調用本地方法native Class findBootstrapClass(String name)
                        c = findBootstrapClass0(name);
                    }
                } catch (ClassNotFoundException e) {
                 // 如果父類載入器和啟動類載入器都不能完成載入任務，才調用自身的載入功能
                    c = findClass(name);
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }

package com.pdai.jvm.classloader;
import java.io.*;

public class MyClassLoader extends ClassLoader {

    private String root;

    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            return defineClass(name, classData, 0, classData.length);
        }
    }

    private byte[] loadClassData(String className) {
        String fileName = root + File.separatorChar
                + className.replace('.', File.separatorChar) + ".class";
        try {
            InputStream ins = new FileInputStream(fileName);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int bufferSize = 1024;
            byte[] buffer = new byte[bufferSize];
            int length = 0;
            while ((length = ins.read(buffer)) != -1) {
                baos.write(buffer, 0, length);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public String getRoot() {
        return root;
    }

    public void setRoot(String root) {
        this.root = root;
    }

    public static void main(String[] args)  {

        MyClassLoader classLoader = new MyClassLoader();
        classLoader.setRoot("D:\\temp");

        Class<?> testClass = null;
        try {
            testClass = classLoader.loadClass("com.pdai.jvm.classloader.Test2");
            Object object = testClass.newInstance();
            System.out.println(object.getClass().getClassLoader());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}