1. 程式人生 > >class檔案的基本結構及proxy原始碼分析二

class檔案的基本結構及proxy原始碼分析二

前文地址:https://www.cnblogs.com/tera/p/13267630.html

本系列文章主要是博主在學習spring aop的過程中瞭解到其使用了java動態代理,本著究根問底的態度,於是對java動態代理的本質原理做了一些研究,於是便有了這個系列的文章

 

接上文,我們需要了解class位元組碼的結構,才能更好地理解後面的程式碼,這裡我直接引用jvm文件中的內容

jvm文件地址:https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html
下面對位元組碼的結構簡單地做了個說明,大部分都是顧名思義

ClassFile {
    u4             magic;//固定的開頭,值為0xCAFEBABE
    u2             minor_version;//版本號,用來標記class的版本
    u2             major_version;//版本號,用來標記class的版本
    u2             constant_pool_count;//靜態池大小,是靜態池物件數量+1
    cp_info        constant_pool[constant_pool_count-1];//靜態池物件,有效索引是1 ~ count-1
    u2             access_flags;//public、final等描述
    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];//屬性物件
}

為了不成為一篇枯燥的文件翻譯,並且儘快進入Proxy的原始碼,這裡並不會對每一個部分做特別詳細的說明,以把握整體為主

回想上篇文章最後,原始碼我們看到了這裡

ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
final byte[] var4 = var3.generateClassFile();

接下去我們就可以進入generateClassFile()方法了

把握整體,我們先跳過一部分細節程式碼,先看下面這部分(這裡我做了一個可讀性的變數名修改)

注意對照著Class的位元組結構來看

最終輸出的位元組流

ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
DataOutputStream data = new DataOutputStream(byteStream);

寫入固定開頭magic,這裡-889275714就是對應0xCAFEBABE

data.writeInt(-889275714);

寫入版本號

data.writeShort(0);//minor_version
data.writeShort(49);//major_version

寫入常量池,這裡cp就是指constant pool

this.cp.write(data);

這裡我們需要進入cp的write方法看一下,也先不要糾結Entry的細節,我們還是先把握整體

public void write(OutputStream var1) throws IOException {
DataOutputStream var2 = new DataOutputStream(var1);
/**
* 這裡寫入cp的大小,注意size()+1,可以和之前Class結構中的constant_pool_count對應
*/
var2.writeShort(this.pool.size() + 1);
Iterator var3 = this.pool.iterator();
/**
* 遍歷cp中的物件,寫入詳細資訊,對應Class結構中的cp_info
*/
while(var3.hasNext()) {
ProxyGenerator.ConstantPool.Entry var4 = (ProxyGenerator.ConstantPool.Entry)var3.next();
var4.write(var2);
}
}

接著我們回到外層方法,繼續往下看

寫入access_flag

data.writeShort(this.accessFlags);

寫入當前類的資訊

data.writeShort.writeShort(this.cp.getClass(dotToSlash(this.className)));

寫入父類的資訊(回想類的屬性第一條,繼承了Proxy類)

data.writeShort.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));

寫入介面數量

data.writeShort.writeShort(this.interfaces.length);

遍歷介面,寫入介面資訊

Class[] interfaces = this.interfaces;
int interfaceLength = interfaces.length;
for (int i = 0; i < interfaceLength; ++i) {
    Class intf = interfaces[i];
    data.writeShort(this.cp.getClass(dotToSlash(intf.getName())));
}

寫入欄位數量

data.writeShort(this.fields.size());

遍歷欄位,寫入欄位資訊

fieldInerator = this.fields.iterator();
while(fieldInerator.hasNext()) {
    ProxyGenerator.FieldInfo fieldInfo = (ProxyGenerator.FieldInfo) fieldInerator.next();
    fieldInfo.write(data);
}

寫入方法數量

data.writeShort(this.methods.size());

遍歷方法,寫入方法資訊

methodIterator = this.methods.iterator();
while(methodIterator.hasNext()) {
    ProxyGenerator.MethodInfo methodInfo = (ProxyGenerator.MethodInfo) methodIterator.next();
    methodInfo.write(data);
}

因為該類沒有特別的attribute,因此attribute數量直接寫0

data.writeShort(0);

正和之前的類結構完全一一對應,此時我們對proxy所做的事情就有了一個整體的把握

 


 

瞭解了整體之後,下面再深入介紹一下位元組碼中部分物件的具體格式,為後面進一步看Proxy的原始碼做一些準備
為了更好地理解下面的內容,我們先定義一個簡單的類Test.java

public class Test implements TestInt {
    private int field = 1;

public int add(int a, int b) {
return a + b;
}
}

interface TestInt {
}

生成.class檔案

javac Test.java

檢視.class檔案

javap -v Test.class

得到結果

Classfile /Users/tianjiyuan/Documents/jvm/Test.class
  Last modified 2020-7-3; size 292 bytes
  MD5 checksum 1afecf9ea44088238bc8aa9804b28208
  Compiled from "Test.java"
public class Test implements TestInt
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #4.#16         // java/lang/Object."<init>":()V
   #2 = Fieldref           #3.#17         // Test.field:I
   #3 = Class              #18            // Test
   #4 = Class              #19            // java/lang/Object
   #5 = Class              #20            // TestInt
   #6 = Utf8               field
   #7 = Utf8               I
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               add
  #13 = Utf8               (II)I
  #14 = Utf8               SourceFile
  #15 = Utf8               Test.java
  #16 = NameAndType        #8:#9          // "<init>":()V
  #17 = NameAndType        #6:#7          // field:I
  #18 = Utf8               Test
  #19 = Utf8               java/lang/Object
  #20 = Utf8               TestInt
{
  public Test();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: iconst_1
         6: putfield      #2                  // Field field:I
         9: return
      LineNumberTable:
        line 1: 0
        line 2: 4

  public int add(int, int);
    descriptor: (II)I
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=3
         0: iload_1
         1: iload_2
         2: iadd
         3: ireturn
      LineNumberTable:
        line 5: 0
}
SourceFile: "Test.java"

我們先看下面這3個部分正對應minor_version,major_version,access_flags

minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER

接著看Constant Pool

Constant pool:
   #1 = Methodref          #4.#16         // java/lang/Object."<init>":()V
   #2 = Fieldref           #3.#17         // Test.field:I
   #3 = Class              #18            // Test
   ...
   #6 = Utf8               field
...
#16 = NameAndType #8:#9 // "<init>":()V

其中有如下幾種型別

Methodref :方法的引用
Fieldref:欄位的引用
Class :類的引用
Utf8 :字串的引用
NameAndType 型別的描述

 

下面一個一個介紹

Class結構

CONSTANT_Class_info {
    u1 tag;
    u2 name_index;
}

表示一個類的引用
tag:表示自身的編號
name_index:必須是常量池中的有效索引,用來表示類的名字
例如

#3 = Class              #18            // Test

tag = 3,表示自身索引為3

name_index = 18,表示名字的索引是18

此時我們檢視#18,即這個類的名字是Test

#18 = Utf8               Test

 

Field、Method、Interface結構

文件中這3者是放在一起的

CONSTANT_Fieldref_info {
    u1 tag;
    u2 class_index;
    u2 name_and_type_index;
}

CONSTANT_Methodref_info {
    u1 tag;
    u2 class_index;
    u2 name_and_type_index;
}

CONSTANT_InterfaceMethodref_info {
    u1 tag;
    u2 class_index;
    u2 name_and_type_index;
}

表示一個欄位、方法、介面方法的引用

tag:表示自身編號
class_index:表示常量池中的一個有效索引
  如果是Methodref_info必須是Class型別的
  如果是InterfaceMethodref_info則必須是一個Interface
  如果是Fieldref_info則可以是Class或者是Interface
name_and_type_index:表示常量池中的一個有效索引(表示方法的名字、返回型別、引數)
  如果是Fieldref_info,則必須是一個對欄位的描述,否則必須是一個對方法的描述

例如

#1 = Methodref          #4.#16         // java/lang/Object."<init>":()V

tag = 1,表示自身索引為1
class_index = 4,表示型別是索引為4的類
name_and_type_index = 16,表示方法的描述為索引16

檢視4和16

   #4 = Class              #19            // java/lang/Object
  #16 = NameAndType        #8:#9          // "<init>":()V

即表示這個方法是Object類中的建構函式

 

NameAndType結構

CONSTANT_NameAndType_info {
    u1 tag;
    u2 name_index;
    u2 descriptor_index;
}

用來表示一個方法或者欄位,其中不包括該欄位或方法所屬的類

tag:表示自身編號
name_index:常量池中的一個有效索引,必須是Utf8型別(表示方法或欄位的名字)
descriptor_index:常量池中的一個有效索引,必須是Utf8型別(表示方法的返回型別和引數)

例如

#16 = NameAndType        #8:#9          // "<init>":()V

tag = 16
name_index = 8
descriptor_index = 9

檢視索引8和9

   #8 = Utf8               <init>
   #9 = Utf8               ()V

方法名為<init>表示建構函式,引數0個,返回值為void

 

UTF-8結構

CONSTANT_Utf8_info {
    u1 tag;
    u2 length;
    u1 bytes[length];
}

表示一個字串常量

tag:表示自身編號
length:表示byte陣列的長度
bytes[length]:表示具體資料內容
這個部分其實還有很多細節,不過這裡就不展開了,有興趣的可以自行檢視jvm文件,後面會有文章詳細分析

 

常量池的內容就介紹到這裡,接下去我們還需要看下類結構的其他成員

this_class,必須是一個有效的常量池索引,需要是CONSTANT_Class_info型別的
super_class,必須是一個有效的常量池索引,需要是CONSTANT_Class_info型別的或者為0,表示沒有父類
interfaces_count,介面數量,一個int值
interfaces[],介面陣列,陣列中的值必須是一個常量池的有效索引,需要是CONSTANT_Class_info型別
fields_count,欄位數量

fields[],欄位陣列,陣列中的值都是field_info結構

field_info {
    u2             access_flags;//access_flag
    u2             name_index;//常量池中的一個有效索引,必須是Utf8型別(表示方法或欄位的名字)
    u2             descriptor_index;//常量池中的一個有效索引,必須是Utf8型別(表示欄位的描述)
    u2             attributes_count;//跳過,本文不涉及
    attribute_info attributes[attributes_count];//跳過,本文不涉及
}

methods_count,方法數量
methods[],方法陣列,結構如下

method_info {
    u2             access_flags;//access_flag
    u2             name_index;//常量池中的一個有效索引,必須是Utf8型別(表示方法或欄位的名字)
    u2             descriptor_index;//常量池中的一個有效索引,必須是Utf8型別(表示方法的描述)
    u2             attributes_count;//屬性數量
    attribute_info attributes[attributes_count];//屬性的具體內容
}

class檔案的一些基本結構就介紹到這裡,下一篇文章中會繼續結合Proxy的原始碼,進一步深入瞭解class的各種結構究竟是怎麼被構造的

&n