Java字节码文件结构剖析（一）

已于 2023-07-16 14:14:05 修改
阅读量615 收藏 1
点赞数
分类专栏： jvm 文章标签： java python 数据库
于 2020-10-09 20:44:55 首次发布
自己的博客
本文链接：https://blog.csdn.net/quyixiao/article/details/108956956
版权

MyTest35.java

package com.spring_1_100.test_31_40.test35_resource_inject;

public class MyTest35 {
    private int a = 1;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }
}

反编译字节码文件
使用到java内置的一个反编译工具 javap 可以反编译字节码文件。 通过 javap -help 可了解javap的基本用法
用法: javap
其中, 可能的选项包括:

  • -help --help -? 输出此用法消息
  • -version 版本信息
  • -v -verbose 输出附加信息
  • -l 输出行号和本地变量表
  • -public 仅显示公共类和成员
  • -protected 显示受保护的/公共类和成员
  • -package 显示程序包/受保护的/公共 和成员 (默认)
  • -p -private 显示所有类和成员
  • -c对代码进行反汇编
  • -c 对代码进行反汇编 -s 输出内部类型签名
  • -sysinfo 显示正在处理的类的，系统信息 (路径, 大小, 日期, MD5 散列)
  • -constants 显示最终常量
  • -classpath 指定查找用户类文件的位置
  • -cp 指定查找用户类文件的位置
  • -bootclasspath 覆盖引导类文件的位置

运行 javap -verbose

Classfile /Users/quyixiao/project/spring_tiny/target/classes/com/spring_1_100/test_31_40/test35_resource_inject/MyTest35.class
  Last modified 2020-10-7; size 550 bytes
  MD5 checksum 321538c217c561494eb5f1b943ba8bce
  Compiled from "MyTest35.java"
public class com.spring_1_100.test_31_40.test35_resource_inject.MyTest35
  minor version: 0
  major version: 51
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #4.#20         // java/lang/Object."<init>":()V
   #2 = Fieldref           #3.#21         // com/spring_1_100/test_31_40/test35_resource_inject/MyTest35.a:I
   #3 = Class              #22            // com/spring_1_100/test_31_40/test35_resource_inject/MyTest35
   #4 = Class              #23            // java/lang/Object
   #5 = Utf8               a
   #6 = Utf8               I
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcom/spring_1_100/test_31_40/test35_resource_inject/MyTest35;
  #14 = Utf8               getA
  #15 = Utf8               ()I
  #16 = Utf8               setA
  #17 = Utf8               (I)V
  #18 = Utf8               SourceFile
  #19 = Utf8               MyTest35.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = NameAndType       #5:#6          // a:I
  #22 = Utf8               com/spring_1_100/test_31_40/test35_resource_inject/MyTest35
  #23 = Utf8               java/lang/Object
{
  public com.spring_1_100.test_31_40.test35_resource_inject.MyTest35();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."":()V
         4: aload_0
         5: iconst_1
         6: putfield      #2                  // Field a:I
         9: return
      LineNumberTable:
        line 3: 0
        line 4: 4
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      10     0  this   Lcom/spring_1_100/test_31_40/test35_resource_inject/MyTest35;

  public int getA();
    descriptor: ()I
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: getfield      #2                  // Field a:I
         4: ireturn
      LineNumberTable:
        line 7: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/spring_1_100/test_31_40/test35_resource_inject/MyTest35;

  public void setA(int);
    descriptor: (I)V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0
         1: iload_1
         2: putfield      #2                  // Field a:I
         5: return
      LineNumberTable:
        line 11: 0
        line 12: 5
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       6     0  this   Lcom/spring_1_100/test_31_40/test35_resource_inject/MyTest35;
            0       6     1     a   I
}
SourceFile: "MyTest35.java"

这里是构造方法:MyTest35()，返回值为void, 公开方法。 code内的主要属性为:

  • stack 最大操作数栈，JVM运行时会根据这个值来分配栈帧(Frame)中的操作栈深度,此处为2
  • 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是变量名称，然后是类型签名。
  • SourceFile 源码文件名称

打开class 文件的二进制

CA FE BA BE 00 00 00 33 00 18 0A 00 04 00 14 09 00 03 00 15 07 00 16 07 00 17 01 00 01 61 01 00 01 49 01 00 06 3C 69 6E 69 74 3E 01 00 03 28 29 56 01 00 04 43 6F 64 65 01 00 0F 4C 69 6E 65 4E 75 6D 62 65 72 54 61 62 6C 65 01 00 12 4C 6F 63 61 6C 56 61 72 69 61 62 6C 65 54 61 62 6C 65 01 00 04 74 68 69 73 01 00 3D 4C 63 6F 6D 2F 73 70 72 69 6E 67 5F 31 5F 31 30 30 2F 74 65 73 74 5F 33 31 5F 34 30 2F 74 65 73 74 33 35 5F 72 65 73 6F 75 72 63 65 5F 69 6E 6A 65 63 74 2F 4D 79 54 65 73 74 33 35 3B 01 00 04 67 65 74 41 01 00 03 28 29 49 01 00 04 73 65 74 41 01 00 04 28 49 29 56 01 00 0A 53 6F 75 72 63 65 46 69 6C 65 01 00 0D 4D 79 54 65 73 74 33 35 2E 6A 61 76 61 0C 00 07 00 08 0C 00 05 00 06 01 00 3B 63 6F 6D 2F 73 70 72 69 6E 67 5F 31 5F 31 30 30 2F 74 65 73 74 5F 33 31 5F 34 30 2F 74 65 73 74 33 35 5F 72 65 73 6F 75 72 63 65 5F 69 6E 6A 65 63 74 2F 4D 79 54 65 73 74 33 35 01 00 10 6A 61 76 61 2F 6C 61 6E 67 2F 4F 62 6A 65 63 74 00 21 00 03 00 04 00 00 00 01 00 02 00 05 00 06 00 00 00 03 00 01 00 07 00 08 00 01 00 09 00 00 00 38 00 02 00 01 00 00 00 0A 2A B7 00 01 2A 04 B5 00 02 B1 00 00 00 02 00 0A 00 00 00 0A 00 02 00 00 00 03 00 04 00 04 00 0B 00 00 00 0C 00 01 00 00 00 0A 00 0C 00 0D 00 00 00 01 00 0E 00 0F 00 01 00 09 00 00 00 2F 00 01 00 01 00 00 00 05 2A B4 00 02 AC 00 00 00 02 00 0A 00 00 00 06 00 01 00 00 00 07 00 0B 00 00 00 0C 00 01 00 00 00 05 00 0C 00 0D 00 00 00 01 00 10 00 11 00 01 00 09 00 00 00 3E 00 02 00 02 00 00 00 06 2A 1B B5 00 02 B1 00 00 00 02 00 0A 00 00 00 0A 00 02 00 00 00 0B 00 05 00 0C 00 0B 00 00 00 16 00 02 00 00 00 06 00 0C 00 0D 00 00 00 00 00 06 00 05 00 06 00 01 00 01 00 12 00 00 00 02 00 13

使用 javap -verbose 命令分析一个字节码文件时，将会分析该字节码文件魔数，版本号，常量池，类信息，类的构造方法，类中的方法信息，类变量与成员变量等信息。在分析字节码之前 ，我们先来了解一下关于字节码的基本概念。
1.魔数：所有的.class 文件字节码文件的前4个字节都是魔数，魔数的固定值是: 0xCAFEBABE 。
2.版本号：魔数之后的4个字节为版本信息，前两个字节为minor version(次版本号)，后两个字节为major version （主版本号），00 00 00 33 换算成10进制为 次版本号为0，主版本号为51 。java的版本号从45开始，除1.0和1.1都是使用45.x外,以后每升一个大版本，版本号加一。也就是说，编译生成该class文件的jdk版本为 1.7.0。 通过 java -version 命令稍加验证, 可得结果。
        java version “1.7.0_131”
        Java™ SE Runtime Environment (build 1.7.0_131-b11)
        Java HotSpot™ 64-Bit Server VM (build 25.131-b11, mixed mode)
3.常量池(constant pool) : 紧接着主版本号之后的就是常量池，一个 Java类中定义的很多的信息都是由常量池来维护和描述的，可以将常量池看作是 class 文件资源仓库，比如说 Java 类中定义的方法与变量信息，都是存储在常量池中，常量池中主要存储两类常量：字面量和符号引用

  • 字面量：字面量比如文本字符串，Java 中声明的 final 的常量值等。
  • 符号引用：符号引用如类和接口的全局限定名，字段的名称和描述符，方法的名称和描述符等。

字节码文件信息
开头的7行信息包括:Class文件当前所在位置，最后修改时间，文件大小，MD5值，编译自哪个文件，类的全限定名，jdk次版本号，主版本 号。 然后紧接着的是该类的访问标志:ACC_PUBLIC, ACC_SUPER，访问标志的含义如下:

标志名称标志值含义修饰对象
ACC_PUBLIC0x0001是否为Public类型class, field, method
ACC_PRIVATE0x0002是否为private类型class, field, method
ACC_PROTECTED0x0004是否为protected类型class, field, method
ACC_STATIC0x0008static 类型field, method
ACC_FINAL0x0010是否被声明为final，只有类可以设置class, field, method, parameter
ACC_SUPER0x0020是否允许使用invokespecial字节码指令的新语义.class
ACC_SYNCHRONIZED0x0020synchronized类型method
ACC_VOLATILE0x0040volatile类型field
ACC_BRIDGE0x0040bridge类型method
ACC_VARARGS0x0080varargs类型method
ACC_TRANSIENT0x0080transient类型field
ACC_NATIVE0x0100native 类型method
ACC_INTERFACE0x0200标志这是一个接口class
ACC_ABSTRACT0x0400是否为abstract类型，对于接口或者抽象类来说， 次标志值为真，其他类型为假class, method
ACC_STRICT0x0800strict类型method
ACC_SYNTHETIC0x1000标志这个类并非由用户代码产生class, field, method, parameter
ACC_ANNOTATION0x2000标志这是一个注解class
ACC_ENUM0x4000标志这是一个枚举class(?) field inner
ACC_MANDATED0x8000mandated类型parameter

4.常量池的总体结构：Java类所对应的常量池主要由常量池数量与常量池数组这两部分共同构成。常量池数量紧跟在主版本号后面，占据两个字节，常量池数组则紧跟在常量池数量之后。常量池数组与一般的数组不同的是，常量池数组中不同的元素的类型，结构都是不同的，长度当然也就不同，但是，每一种元素的第一个数据都是一个 u1类型，该字节是个标志位，占据1个字节，JVM在解析常量池时，会根据这个 u1类型来获取元素的具体类型，值得注意的是常量池数组中元素的个数=常量池数-1（其中0暂时不使用）。目的是满足某些常量池索引值的数据在特定情况下需要表达【不引用任何一个常量池】 的含义，根本原因在于，索引为0也是一个常量（保留常量），只不过它不位于常量表中，这个常量就对应 null 值，所以常量池的索引 从1而非0开始。

Class 文件结构中常量池中11种数据类型的结构总表
常量项目类型描述
CONSTANT_Utf8_infotagU1值为1
lengthU2UTF-8编码字符串长度
bytesU(length)长度为 length 的 UTF-8编码的字符串
CONSTANT_Integer_infotagU1值为3
bytesU4按照高位在前存储 int 值
CONSTANT_Float_infotagU1值为4
bytesU4按照高位在前存储 float 值
CONSTANT_Long_infotagU1值为5
bytesU8按照高位在前存储 long 值
CONSTANT_Double_infotagU1值为6
bytesU8按照高位在前存储 double 值
CONSTANT_Class_infotagU1值为7
indexU2指向全限定名常量项的索引
CONSTANT_String_infotagU1值为8
indexU2指向字符串字面量索引
CONSTANT_FieIdref_infotagU1值为9
indexU2指向声明字段的类或者接口描述符CONSTANT_Class_info的索引项
indexU2指向字段描述符 CONSTANT_NameAndType_Info 的索引项
CONSTANT_Methodref_infotagU1值为10
indexU2指向声明方法的类描述符CONSTANT_Class_info的索引项
indexU2指向名称及类型描述符 CONSTANT_NameAndType_Info 的索引项
CONSTANT_InterfaceMethodref_infotagU1值为11
indexU2指向声明方法的类描述符CONSTANT_Class_info的索引项
indexU2指向名称及类型描述符 CONSTANT_NameAndType_Info 的索引项
CONSTANT_NameAndType_infotagU1值为12
indexU2指向该字段或方法名称常量项索引
indexU2指向该字段或方法描述符常量项的索引

在这里插入图片描述

在 JVM 规范中，每个变量/字段都有描述信息，描述信息主要的作用是描述字段的数据类型，方法的参数列表（包括数量，类型与顺序） 与返回值，根据描述符规则，基本数据类型和代表无返回值的 void 类型都用一个大写的字符来表示的，对象类型则使用字符 L加对象的全限定名称来表示，为了压缩字节码文件的体积。对于基本的数据类型，JVM 都只使用一个大写的字母来表示，如下所示：

标识字符含义
B基本类型 byte
C基本类型 char
D基本类型 double
F基本类型 float
I基本类型 int
J基本类型 long
S基本类型 short
Z基本类型 boolean
V特殊类型 void
L对象类型，以分号结尾，如 java/lang/Object;
对于数组类型，每一位使用一个前置的"[“字符来描述，如定义一个 java.lang.String[][]类型的二维数组，将被记录为”[[Ljava/lang/String;"
5.用描述符来描述方法时，按照先参数列表，后返回值的顺序来描述，参数列表按照参数的严格顺序放在一组（）之内，如方法：String getRealnamelyIdAndNickname(int id ,String name ) 的描述符为：（I,Ljava/lang/String;）Ljava/lang/String;

对于上面字节码，魔数和版本号后面是常量池。对于常量池，我们一个一个来分析。
在Class 文件结构中常量池中11种数据类型的结构总表中，u1表示占用一个字节，u2表示占用两个字节。在分析之前我们先来了解一下 Java 字节码整体结构 ：

Magic Number4个字节魔数，值为0xCAFEBABE，Java创始人 James Gosling 制定
Version2+2 个字节包括 minor_version 和 major_version，minor_version:1.1(45),1.2(46),1.3(47),1.4(48),1.5(49),1.6(50),1.7(51)
Constant Pool2+n个字节包括字符串常量，数值常量等
Access Flags2 个字节访问标志，java 中一个类的的访问标志是多种多样的，比如 public ,static 等
This Class Name2个字节当前这个类的名字是什么
Super Class Name2个字节父类名字
Interfaces2 + n 个字节java 类可以多继承，因此，继承一个接口，消耗2个字节
Fields2 + n 个字节描述了关系类的属性的信息
Methods2 + n 个字节描述了一些方法的信息
Attributes2 + n 个字节一些编译器在编译时可以加入一些 Attritutes 信息，方便编译时使用
整体所占有的字节
类型名称数量
–––
u4magic(魔数)1
u2minor_version(次版本号)1
u2major_version(主版本号)1
u2constant_pool_count(常量个数 )1
cp_infoconstant_pool(常量池表)constant_pool_count -1
u2access_flags(类访问控制权限)1
u2this_class(类名)1
u2super_class(父类名)1
u2interfaces_count(接口个数)1
u2interfaces(接口名)interfaces_count
u2fields_count(域个数)1
field_infofields(域的表)fields_count
u2methods_count(方法的个数)1
method_infomethod(方法表)methods_count
u2attributes_count(附加属性的个数)1
attribute_infoattributes(附加属性的表)attributes_count

类字节码文件完整结构 ：
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];
}
Class 字节码中有两种数据类型

在这里插入图片描述

{
  "magic_num":"u4(CA FE BA BE)->desc:魔数" ,
  "minor_version":"u2(00 00)->desc:jdk的次版本号",
  "major_version":"u2(00 34->desc:52对应jdk主版本号1.8)",
  "constant_pool_count":"u2(00 19->desc:25-1=24个常量第0个被jvm占用表示null)",
  "constant_pool":{
    "CONSTANT_Methodref_info(第一个常量)":{
      "tag":"u1(0A)->desc:表示方法引用类型常量结构",
      "class_index":"u2(00 04)->desc:表示指向常量池中第四个常量，所属class",
      "name_and_type_index":"u2(00 15)->desc:指向常量池第21的位置,表示方法的描述符"
    },
    "CONSTANT_Fieldref_info(第二个常量)": {
      "tag":"u1(09)->desc:表示字段引用类型常量结构",
      "class_index":"u2(00 03)->desc:表示指向常量池中第3个常量，所属class",
      "name_and_type_index":"u2(00 16)->desc:指向常量池第22的位置,表示字段的描述符"
    },
    "CONSTANT_Class_info(第三个常量)": {
      "tag":"u1(07)->desc:表示class类型常量结构",
      "name_index":"u2(00 17)->desc:表示指向常量池中第23个常量，class的名称"
    },
    "CONSTANT_Class_info(第四个常量)": {
      "tag":"u1(07)->desc:表示class类型常量结构",
      "name_index":"u2(00 18)->desc:表示指向常量池中第24个常量，class的名称"
    },
    "CONSTANT_Utf8_info(第五个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 08)->desc:紧接着后面8个字节表示的字面量",
      "byte[8]":"(75 73 65 72 4E 61 6D 65)->desc:userName "
    },
    "CONSTANT_Utf8_info(第六个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 12)->desc:紧接着后面18个字节表示的字面量",
      "byte[18]":"(4C 6A 61 76 61 2F 6C 61 6E 67 2F 53 74 72 69 6E  67 3B )->desc:Ljava/lang/String;"
    },
    "CONSTANT_Utf8_info(第七个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 06)->desc:紧接着后面6个字节表示的字面量",
      "byte[6]":"(3C 69 6E 69 74 3E)->desc:"
    },
    "CONSTANT_Utf8_info(第八个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 03)->desc:紧接着后面3个字节表示的字面量",
      "byte[6]":"(28 29  56 )->desc:()V"
    },
    "CONSTANT_Utf8_info(第九个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 04)->desc:紧接着后面4个字节表示的字面量",
      "byte[4]":"(43 6F 64 65)->desc:Code"
    },
    "CONSTANT_Utf8_info(第十个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 0F)->desc:紧接着后面15个字节表示的字面量",
      "byte[15]":"(4C 69 6E 65 4E  75 6D 62 65 72 54 61 62 6C 65 )-  >desc:LineNumberTable"
    },
    "CONSTANT_Utf8_info(第十一个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 12)->desc:紧接着后面18个字节表示的字面量",
      "byte[18]":"(4C 6F 63  61 6C 56 61 72 69 61 62 6C 65 54 61 62 6C 65)->desc:LocalVariableTable"
    },
    "CONSTANT_Utf8_info(第十二个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 04)->desc:紧接着后面4个字节表示的字面量",
      "byte[4]":"(74 68 69 73)->desc:this"
    },
    "CONSTANT_Utf8_info(第十三个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 33)->desc:紧接着后面51个字节表示的字面量",
      "byte[51]":"(4C 63 6F 6D 2F 74 75  6C 69 6E 67 2F 73 6D 6C 7A 2F 6A 76 6D 2F 63 6C  61 73 73 62 79 61 74 65 63 6F 64 65 2F 54 75 6C  69 6E 67 42 79 74 65 43 6F 64 65 3B )->desc:Lcom/tuling/smlz/jvm/classbyatecode/TulingByteCode;"
    },
    "CONSTANT_Utf8_info(第十四个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 0B)->desc:紧接着后面11个字节表示的字面量",
      "byte[11]":"(67  65 74 55 73 65 72 4E 61 6D 65 )->desc:getUserName"
    },
    "CONSTANT_Utf8_info(第十五个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 14)->desc:紧接着后面20个字节表示的字面量",
      "byte[20]":"(28 29 4C  6A 61 76 61 2F 6C 61 6E 67 2F 53 74 72 69 6E 67 3B )->desc:()Ljava/lang/String;"
    },
    "CONSTANT_Utf8_info(第十六个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 0B)->desc:紧接着后面11个字节表示的字面量",
      "byte[11]":"(73 65 74 55 73 65 72 4E 61 6D 65)->desc:setUserName"
    },
    "CONSTANT_Utf8_info(第十七个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 15)->desc:紧接着后面21个字节表示的字面量",
      "byte[21]":"(28 4C 6A 61 76 61 2F 6C 61 6E 67 2F 53 74  72 69 6E 67 3B 29 56 )->desc:(Ljava/lang/String;)V"
    },
    "CONSTANT_Utf8_info(第十八个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 10)->desc:紧接着后面16个字节表示的字面量",
      "byte[16]":"(28 4C 6A 61 76 61 2F 6C 61 6E 67 2F 53 74  72 69 6E 67 3B 29 56 )->desc:MethodParameters"
    },
    "CONSTANT_Utf8_info(第十九个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 0A)->desc:紧接着后面10个字节表示的字面量",
      "byte[10]":"(53 6F 75  72 63 65 46 69 6C 65  )->desc:SourceFile"
    },
    "CONSTANT_Utf8_info(第二十个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 13)->desc:紧接着后面19个字节表示的字面量",
      "byte[19]":"(54 75 6C 69 6E 67  42 79 74 65 43 6F 64 65 2E 6A 61 76 61)->desc:TulingByteCode.java"
    },
    "CONSTANT_NameAndType_info(第二十一个常量)": {
      "tag":"u1(0C)->desc:表示NameAndType_类型常量结构",
      "name_index":"u2(00 07)->desc:指向常量池第七个->",
      "descriptor_index":"u2(00 08)->指向常量池第八个->()V"
    },
    "CONSTANT_NameAndType_info(第二十二个常量)": {
      "tag":"u1(0C)->desc:表示NameAndType_类型常量结构",
      "name_index":"u2(00 05)->desc:指向常量池第五个->userName",
      "descriptor_index":"u2(00 06)->指向常量池第八个->Ljava/lang/String;"
    },
    "CONSTANT_Utf8_info(第二十三个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 31)->desc:紧接着后面49个字节表示的字面量",
      "byte[49]":"(63 6F 6D 2F 74 75  6C 69 6E 67 2F 73 6D 6C 7A 2F 6A 76 6D 2F 63 6C  61 73 73 62 79 61 74 65 63 6F 64 65 2F 54 75 6C  69 6E 67 42 79 74 65 43 6F 64 65 )->desc:com/tuling/smlz/jvm/classbyatecode/TulingByteCode"
    },
    "CONSTANT_Utf8_info(第二十四个常量)": {
      "tag":"u1(01)->desc:表示utf-8类型常量结构",
      "length":"u2(00 10)->desc:紧接着后面49个字节表示的字面量",
      "byte[49]":"(6A 61  76 61 2F 6C 61 6E 67 2F 4F 62 6A 65 63 74 )->desc:java/lang/Object"
    }

  },
  "access_flag" :"u2(00 21)->desc:由0x0020(ACC_SUPER)和0x0001(ACC_PUBLIC) 位运算",
  "this_class_name":"u2(00 03)->desc:当前的class的名称 索引位置指向常量池#3,发现#3指向#23值，#23的值com/tuling/smlz/jvm/classbyatecode/TulingByteCode",
  "super_class_name":"u2(00 04)->desc:父类的class的 索引位置指向的常量池#4,发现#4指向到#24,值位:java/lang/Object",
  "interfaces_count":"u2(00 00)此时表示的接口的个数为0个,若接口的信息表为null",
  "interface[interfaces_count=0]":{},
  "fields_count":"u2(00 01)表示当前的class文件的字段的个数1个 ",
  "Field_info":{
    "Field_info[0]": {
      "access_flag": "u2(00 02)desc:->0x0002 ACC_PRIVATE",
      "name_index": "u2(00 05)->desc:->指向常量池#5 userName",
      "descciptor_index": "u2(00 06)->desc指向常量的第六个#6 Ljava/lang/String;",
      "attribute_count": "u2(00 00) 字段属性的个数为0那么没有字段属性",
      "attribute_info": {}
    }
  },
  "method_count":"u2(00 03)->desc:表示我们的方法的个数为三个",
  "method_infos": {
    "method_info[0]": {
      "access_flag": "u2(00 01)->desc:表示我们的方法访问权限为ACC_PUBLIC",
      "name_index": "u2(00 07)->desc:表示方法名称的索引指向常量池第七个位置#7 表示 再编译时期生成的默认的构造函数",
      "descciptor_index": "u2(00 08)->desc:表示方法描述索引指向常量池#8 表示:()V 无参数,无返回值",
      "attribute_count": "u2(00 01)->desc:表示方法的属性个数",
      "attribute_infos": {
        "Code": {
          "attribute_name_index": "u2(00 09)->desc:我们属性的名称指向常量值索引的#9 位置 值为Code",
          "attribute_length": "u4(00 00 00 2F)-desc:表示我们的Code属性紧接着下来的47个字节是Code的内容",
          "max_stack": "u2(00 01)->desc：表示该方法的最大操作数栈的深度1",
          "max_locals": "u2(00 01)->desc:表示该方法的局部变量表的个数为1",
          "Code_length": "u4(00 00 00 05)->desc:指令码的长度为5",
          "Code[Code_length]": "2A B7 00 01 B1 其中0x002A->对应的字节码注记符是aload_0;0xB7->invokespecial;00 01表示表示是B7指令码操作的对象指向常量池中的#1(java/lang/Object.:()V);B1表示调用方法返回void",
          "exception_table_length": "u2(00 00)->表示该方法不抛出异常,故exception_info没有异常信息",
          "exception_info": {},
          "attribute_count": "u2(00 02)->desc表示code属性表的属性个数为2",
          "attribute_info": {
            "LineNumberTable": {
              "attribute_name_index": "u2(00 0A)当前属性表名称的索引指向我们的常量池#10(LineNumberTable)",
              "attribute_length": "u4(00 00 00 06)当前属性表属性的字段占用6个字节是用来描述line_number_info",
              "mapping_count": "u2(00 01)->desc:该方法指向的指令码和源码映射的对数  表示一对",
              "line_number_infos": {
                "line_number_info[0]": {
                  "start_pc": "u2(00 00)->desc:表示指令码的行数",
                  "line_number": "u2(00 06)->desc:源码的行号"
                }
              }
            },
            "localVariableTable": {
              "attribute_name_index": "u2(00 0B)当前属性表名称的索引指向我们的常量池#10(localVariableTable)",
              "attribute_length": "u4(00  00 00 0C)当前属性表属性的字段占用12个字节用来描述local_variable_info",
              "local_variable_length": "u2(00 01)->desc:表示局部变量的个数1个",
              "local_variable_infos": {
                "local_variable_info[0]": {
                  "start_pc": "u2(00 00 )->desc:这个局部变量的生命周期开始的字节码偏移量",
                  "length:": "u2(00 05)->作用范围覆盖的长度为5",
                  "name_index": "u2(00 0c)->字段的名称索引指向常量池12的位置 this",
                  "desc_index": "u2(00 0D)局部变量的描述符号索引->指向#13的位置Lcom/tuling/smlz/jvm/classbyatecode/TulingByteCode;",
                  "index": "u2(00 00)->desc:index是这个局部变量在栈帧局部变量表中Slot的位置"
                }
              }
            }
          }
        }
      }
    },
    "method_info[1]": {
      "access_flag": "u2(00 01)->desc:表示我们的方法访问权限为ACC_PUBLIC",
      "name_index": "u2(00 0E)->desc:表示方法名称的索引指向常量池第14个位置#14 表示getUserName ",
      "descciptor_index": "u2(00 0F)->desc:表示方法描述索引指向常量池#5 表示:()Ljava/lang/String;无参数,返回值是String",
      "attribute_count": "u2(00 01)->desc:表示方法的属性个数",
      "attribute_info": {
        "Code": {
          "attribute_name_index": "u2(00 09)->desc:我们属性的名称指向常量值索引的#9 位置 值为Code",
          "attribute_length": "u4(00 00 00 2F)-desc:表示我们的Code属性紧接着下来的47个字节是Code的内容",
          "max_stack": "u2(00 01)->desc：表示该方法的最大操作数栈的深度1",
          "max_locals": "u2(00 01)->desc:表示该方法的局部变量表的个数为1",
          "Code_length": "u4(00 00 00 05)->desc:指令码的长度为5",
          "Code[Code_length]": "2A B4 00 02 B0  其中0x002A->对应的字节码注记符是aload_0;0xB4->getfield 获取指定类的实例域，并将其值压入栈顶;00 02表示表示是B4指令码操作的对象指向常量池中的#2(com/tuling/smlz/jvm/classbyatecode/TulingByteCode.userName:Ljava/lang/String;);B0表示为aretrun 返回  从当前方法返回对象引用",
          "exception_table_length": "u2(00 00)->表示该方法不抛出异常,故exception_info没有异常信息",
          "exception_info": {},
          "attribute_count": "u2(00 02)->desc表示code属性表的属性个数为2",
          "attribute_info": {
            "LineNumberTable": {
              "attribute_name_index": "u2(00 0A)当前属性表名称的索引指向我们的常量池#10(LineNumberTable)",
              "attribute_length": "u4(00 00 00 06)当前属性表属性的字段占用6个字节是用来描述line_number_info",
              "mapping_count": "u2(00 01)->desc:该方法指向的指令码和源码映射的对数  表示一对",
              "line_number_infos": {
                "line_number_info[0]": {
                  "start_pc": "u2(00 00)->desc:表示指令码的行数",
                  "line_number": "u2(00 0B)->desc:源码12行号"
                }
              },
              "localVariableTable": {
                "attribute_name_index": "u2(00 0B)当前属性表名称的索引指向我们的常量池#10(localVariableTable)",
                "attribute_length": "u4(00  00 00 0C)当前属性表属性的字段占用12个字节用来描述local_variable_info",
                "local_variable_length": "u2(00 01)->desc:表示局部变量的个数1",
                "local_vabiable_infos": {
                  "local_vabiable_info[0]": {
                    "start_pc": "u2(00 00 )->desc:这个局部变量的生命周期开始的字节码偏移量",
                    "length:": "u2(00 05)->作用范围覆盖的长度为5",
                    "name_index": "u2(00 0c)->字段的名称索引指向常量池12的位置 this",
                    "desc_index": "u2(00 0D)局部变量的描述符号索引->指向#13的位置Lcom/tuling/smlz/jvm/classbyatecode/TulingByteCode;",
                    "index": "u2(00 00)->desc:index是这个局部变量在栈帧局部变量表中Slot的位置"
                  }
                }
              }
            }
          }
        }
      }
    },
    "method_info[2]": {
      "access_flag": "u2(00 01)->desc:表示我们的方法访问权限为ACC_PUBLIC",
      "name_index": "u2(00 10)->desc:表示方法名称的索引指向常量池第16个位置#16 表示setUserName ",
      "descciptor_index": "u2(00 11)->desc:表示方法描述索引指向常量池#17 表示:(Ljava/lang/String;)V;String参数,返回void",
      "attribute_count": "u2(00 02)->desc:表示方法的属性个数2",
      "attribute_info": {
        "Code": {
          "attribute_name_index": "u2(00 09)->desc:我们属性的名称指向常量值索引的#9 位置 值为Code",
          "attribute_length": "u4(00 00 00 3E)-desc:表示我们的Code属性紧接着下来的62个字节是Code的内容",
          "max_stack": "u2(00 02)->desc：表示该方法的最大操作数栈的深度2",
          "max_locals": "u2(00 02)->desc:表示该方法的局部变量表的个数为2",
          "Code_length": "u4(00 00 00 06)->desc:指令码的长度为6",
          "Code[Code_length]": "2A 2B B5 00 02 B1    其中0x002A->对应的字节码注记符是aload_0;0x2B->aload_1 将第二个引用类型本地变量推送至栈顶;B5:putfield 用栈顶的值为指定的类的实例域赋值,00 02表示的是B5指令操作的对象,指向常量池中#2位置com/tuling/smlz/jvm/classbyatecode/TulingByteCode.userName:Ljava/lang/String; B1指令表示返回void",
          "exception_table_length": "u2(00 00)->表示该方法不抛出异常,故exception_info没有异常信息",
          "exception_info": {},
          "attribute_count": "u2(00 02)->desc表示code属性表的属性个数为2",
          "attribute_info": {
            "LineNumberTable": {
              "attribute_name_index": "u2(00 0A)当前属性表名称的索引指向我们的常量池#10(LineNumberTable)",
              "attribute_length": "u4(00 00 00 0A)当前属性表属性的字段占用10个字节是用来描述line_number_info",
              "mapping_count": "u2(00 02)->desc:该方法指向的指令码和源码映射的对数  表示二对",
              "line_number_infos": {
                "line_number_info[0]": {
                  "start_pc": "u2(00 00)->desc:表示指令码的行数",
                  "line_number": "u2(00 15)->desc:源码21行号"
                },
                "line_number_info[1]": {
                  "start_pc": "u2(00 05)->desc:表示指令码的5行",
                  "line_number": "u2(00 16)->desc:源码22行号"
                }
              }
            },
            "localVariableTable": {
              "attribute_name_index": "u2(00 0B)当前属性表名称的索引指向我们的常量池#10(localVariableTable)",
              "attribute_length": "u4(00 00 00 16)当前属性表属性的字段占用22个字节用来描述local_variable_info",
              "local_variable_length": "u2(00 02)->desc:表示局部变量的个数2",
              "local_variable_infos": {
                "local_variable_info[0]": {
                  "start_pc": "u2(00 00 )->desc:这个局部变量的生命周期开始的字节码偏移量",
                  "length:": "u2(00 06)->作用范围覆盖的长度为6",
                  "name_index": "u2(00 0c)->字段的名称索引指向常量池12的位置 this",
                  "desc_index": "u2(00 0D)局部变量的描述符号索引->指向#13的位置Lcom/tuling/smlz/jvm/classbyatecode/TulingByteCode;",
                  "index": "u2(00 00)->desc:index是这个局部变量在栈帧局部变量表中Slot的位置"
                },
                "local_variable_info[1]": {
                  "start_pc": "u2(00 00 )->desc:这个局部变量的生命周期开始的字节码偏移量",
                  "length:": "u2(00 06)->作用范围覆盖的长度为6",
                  "name_index": "u2(00 05)->字段的名称索引指向常量池5的位置 userName",
                  "desc_index": "u2(00 06)局部变量的描述符号索引->指向#6的位置 Ljava/lang/String;",
                  "index": "u2(00 01)->desc:index是这个局部变量在栈帧局部变量表中Slot的1位置"
                }
              }
            }
          }
        },
        "MethodParameters": {
          "attribute_name_index": "u2(00 12)表示该属性的名称指向常量池#18的位置:MethodParameters",
          "attribute_length": "u4(00 00 00 05 )->desc:属性的长度5",
          "parameter_count": "u1(01)->desc参数的个数1个",
          "parameter_name_index": "u2(00 05)->desc:指向第五个常量池的常量userName",
          "ACC_FLAG": "U2(00 00 )->desc:表示任何权限都可以访问"
        }
      }
    }
  },
  "attribute_count(class文件的属性)": "u2(00 01)只有一个属性",
  "attribute_info(class文件属性的结构)": {
      "attribute_name_index": "u2(00 13) 指向常量池中#19 值为 SourceFile",
      "attribute_length": "u4(00 00 00 02) 表示属性接下来的长度为2",
      "sourceFile_index": "u2(00 14) 表示源文件的索引指向常量池20的位置:TulingByteCode.java"
  }
}
  • 字节数据直接量：这是基本的数据类型，其细分为u1,u2,u4,u8四种，分别代表连续的1个字节，2个字节，4个字节，8个字节组成的整体数据 。
  • 表（数组）：表是由多个基本数据或其他表，按照既定的顺序组成的大的数据集合，表是有结构的，它的结构体现在：组成表的成分所在的位置和顺序都是己经严格定义好的。

下面来一一分析字节码，【字节码都是16进制数，这里需要我们手动转化为10进制数】：

  1. CA FE BA BE ： 魔数

  2. 00 00     00 33 ：次版本号(minor version: 0) ，主版本号 (major version: 51)

  3. 00 18 : 10进制数是 24，表示常量池的数量，常量池数组中元素的个数=常量池数-1（其中0暂时不使用）。目的是满足某些常量池索引值的数据在特定情况下需要表达【不引用任何一个常量池】 的含义，根本原因在于，索引为0也是一个常量（保留常量），只不过它不位于常量表中，这个常量就对应 null 值，所以常量池的索引 从1而非0开始。

  4. 0A     00 04     00 14 : 0A 10进制数是10，在【Class 文件结构中常量池中11种数据类型的结构总表】中对应的是CONSTANT_Methodref_info，00 04 （占两个字节）指向声明方法的类描述符CONSTANT_Class_info的索引项，从下图中可以看出，#4 指向了#23 ，而#23对应的是 java.lang.Object 类型。 00 14 （占两个字节，10进制是20）指向名称及类型描述符 CONSTANT_NameAndType_Info 的索引项，#20索引项指向了#7和#8, #7表示构造函数，#8表示void 类型，因此。常量池中的第一个常量方法引用表示的是：

    #1 = Methodref #4.#20 // java/lang/Object.“”: ()V ：表示构造方法，()V 表示 void 类型，表示的是定义一个 void 类型的构造方法，并且父类为 java.lang.Object
    在这里插入图片描述

  5. 09     00 03     00 15：我们继续来解析常量池中的第二个常量，第一位（09）对应的10进制是#9，而9在【Class 文件结构中常量池中11种数据类型的结构总表】对应的是CONSTANT_FieIdref_info，FieIdref后面第一位(index U2) 占两个字节 ，而 00 03 的10进制对应是3 ,因此，指向了 #3，而#3代表常量com/spring_1_100/test_31_40/test35_resource_inject/MyTest35 。 而 00 15 转化为10进制指向了#21，而#21分别指向了#5:#6，而#5表示 a，#6表示 I(int 类型)，如下图所示
    在这里插入图片描述
    因此第二个常量的意思就是 （#2 = Fieldref #3.#21 // com/spring_1_100/test_31_40/test35_resource_inject/MyTest35.a:I）在MyTest35中定义一个int 类型的属性 a。

  6. 07     00 16 ：07在【Class 文件结构中常量池中11种数据类型的结构总表】表示的是CONSTANT_Class_info，而后面占两个字节（index U2）指向全限定名常量项的索引，16的十进制数是22，表示指向常量 #22，而#22表示的是com/spring_1_100/test_31_40/test35_resource_inject/MyTest35。

  7. 07     00 17 ：07在【Class 文件结构中常量池中11种数据类型的结构总表】表示的是CONSTANT_Class_info，而后面占两个字节（index U2）指向全限定名常量项的索引，17的十进制数是23，表示指向常量 #23，而#23代表 java.lang.Object 。

  8. 01     00 01     61 ：01在【Class 文件结构中常量池中11种数据类型的结构总表】表示的是CONSTANT_Utf8_info，代表是一个 utf-8的字符编码，UTF-8编码字符串长度占两个字节（length U2）00 01 ，00 01 转化为10进制数为1，因此字符串本身占1个字节，从 00 01 向后数1个字节，得到61 ，61转化为10进制数是97，而97对应的ascii 码是 a, 因此，01 00 01 61 代表的是字符串常量 a，如下图所示:
    在这里插入图片描述

  9. 01     00 01     49 : 01在【Class 文件结构中常量池中11种数据类型的结构总表】表示的是CONSTANT_Utf8_info，代表是一个 utf-8的字符编码，UTF-8编码字符串长度占两个字节（length U2）00 01 ，00 01 转化为10进制数为1，因此字符串本身占1个字节，从 00 01 向后数1个字节，得到49，49对应的 ascii 码是 I，如下图所示：
    在这里插入图片描述

  10. 01     00 06     3C 69 6E 69 74 3E：01在【Class 文件结构中常量池中11种数据类型的结构总表】表示的是CONSTANT_Utf8_info，代表是一个 utf-8的字符编码，UTF-8编码字符串长度占两个字节（length U2）00 06 ，00 06 转化为10进制数为6，因此字符串本身占6个字节，从00 06 向后数6个字节，得到3C 69 6E 69 74 3E 在这里插入图片描述
    因此上面的组合起来就是<init>
    在这里插入图片描述

  11. 01     00 03     28 29 56 : 略 ，UTF-8编码字符串长度占两个字节（length U2）00 03 ，00 03 转化为10进制数为3，因此字符串本身占3个字节，从00 03 向后数3个字节，得到28 29 56 ,而28 29 56对应的是()V。

  12. 01     00 04     43 6F 64 65 ：略。00 04 转化为10进制数为4，因此字符串本身占4个字节，从00 04 向后数4个字节，得到43 6F 64 65 ,而43 6F 64 65对应的是 Code

  13. 01     00 0F     4C 69 6E 65 4E 75 6D 62 65 72 54 61 62 6C 65 ：略。UTF-8编码字符串长度占两个字节（length U2）00 0F ，00 0F 转化为10进制数为15，字符串本身占15个字节，从 00 0F 向后数15个字节，得到4C 69 6E 65 4E 75 6D 62 65 72 54 61 62 6C 65,而4C 69 6E 65 4E 75 6D 62 65 72 54 61 62 6C 65对应的是 LineNumberTable，（LineNumberTable表示行号表，主要用来记录字节码中的位置和源码的行号对应关系，方便在抛出异常时，打印出行号）。

  14. 01     00 12     4C 6F 63 61 6C 56 61 72 69 61 62 6C 65 54 61 62 6C 65 ：略，UTF-8编码字符串长度占两个字节（length U2）00 02，00 12 转化为10进制数为18，因此字符串本身占18字节，从00 12 向后数18个字节，得到4C 6F 63 61 6C 56 61 72 69 61 62 6C 65 54 61 62 6C 65，【4C 6F 63 61 6C 56 61 72 69 61 62 6C 65 54 61 62 6C 65】对应的字符串是LocalVariableTable(局部变量表)。

  15. 01     00 04     74 68 69 73 ：略，UTF-8编码字符串长度占两个字节（length U2）00 04 ，00 04 转化为10进制数为4，因此字符串本身占4字节，从 00 04 向后数4个字节，得到74 68 69 73 ，表示 this 字符串。

  16. 01     00 3D     4C 63 6F 6D 2F 73 70 72 69 6E 67 5F 31 5F 31 30 30 2F 74 65 73 74 5F 33 31 5F 34 30 2F 74 65 73 74 33 35 5F 72 65 73 6F 75 72 63 65 5F 69 6E 6A 65 63 74 2F 4D 79 54 65 73 74 33 35 3B ：略， 00 3D后面的字符串对应的是Lcom/spring_1_100/test_31_40/test35_resource_inject/MyTest35;

  17. 01     00 04     67 65 74 41 ：略，00 04 后面对应的是getA。

  18. 01     00 03     28 29 49 ：略 ()I，方法描述符，传入参数为空，返回值为 Int类型。

  19. 01     00 04     73 65 74 41 ：setA 方法。

  20. 01     00 04     28 49 29 56 ：略 (I)V，方法描述符，表示传入一个 In类型的参数，返回值为 void 类型。

  21. 01     00 0A     53 6F 75 72 63 65 46 69 6C 65 ：略 SourceFile，表示的是源文件。

  22. 01 00 0D 4D 79 54 65 73 74 33 35 2E 6A 61 76 61 ：SourceFile MyTest35.java，表示当前的字节码是由哪个源文编译出来的。

  23. 0C     00 07     00 08 ：0C在【Class 文件结构中常量池中11种数据类型的结构总表】表示的是CONSTANT_NameAndType_info,10进制表示12，00 07 (index U2)占两个字节，指向该字段或方法名称常量项索引#7，而#7表示<init>，表示构造方法。00 08 (index U2) 占两个字节，指向该字段或方法描述符常量项的索引#8，而#8，表示()V，返回值为 void 类型的方法。而这个常量的意思就是表示一个 void 类型的构造方法。

  24. 0C     00 05      00 06：0C在【Class 文件结构中常量池中11种数据类型的结构总表】表示的是CONSTANT_NameAndType_info,0C 10进制表示12，00 05 (index U2)占两个字节，指向该字段或方法名称常量项索引#5，而#5表示字符串 a, 而00 06（#6） 表示 Int 类型。此常量，描述了一个 int a 。

  25. 01     00 3B     63 6F 6D 2F 73 70 72 69 6E 67 5F 31 5F 31 30 30 2F 74 65 73 74 5F 33 31 5F 34 30 2F 74 65 73 74 33 35 5F 72 65 73 6F 75 72 63 65 5F 69 6E 6A 65 63 74 2F 4D 79 54 65 73 74 33 35 ：3B 表示59，从00 3B 向后数59个字节，com/spring_1_100/test_31_40/test35_resource_inject/MyTest35，表示这个类的全额限定名。

  26. 01     00 10     6A 61 76 61 2F 6C 61 6E 67 2F 4F 62 6A 65 63 74 ：略 ，java/lang/Object，描述当前类的父类的完全限定名。到这里，常量池己经分析完成。在这里插入图片描述

  27. 00 21 ：Acess_Flag 访问标志，访问标志信息包括该 Class 文件是类还是接口，是否被定义为 public,是否是 abstract，如果是类，是否被声明成 final，通过上面的源代码，我们知道该文件是类并且是 public 。
    类的访问标志符,下面将是类的访问标识符和16进制对应关系。

标志名称标志值含义修饰对象
ACC_PUBLIC0x0001是否为Public类型class, field, method
ACC_PRIVATE0x0002是否为private类型class, field, method
ACC_PROTECTED0x0004是否为protected类型class, field, method
ACC_STATIC0x0008static 类型field, method
ACC_FINAL0x0010是否被声明为final，只有类可以设置class, field, method, parameter
ACC_SUPER0x0020是否允许使用invokespecial字节码指令的新语义.class
ACC_SYNCHRONIZED0x0020synchronized类型method
ACC_VOLATILE0x0040volatile类型field
ACC_BRIDGE0x0040bridge类型method
ACC_VARARGS0x0080varargs类型method
ACC_TRANSIENT0x0080transient类型field
ACC_NATIVE0x0100native 类型method
ACC_INTERFACE0x0200标志这是一个接口class
ACC_ABSTRACT0x0400是否为abstract类型，对于接口或者抽象类来说， 次标志值为真，其他类型为假class, method
ACC_STRICT0x0800strict类型method
ACC_SYNTHETIC0x1000标志这个类并非由用户代码产生class, field, method, parameter
ACC_ANNOTATION0x2000标志这是一个注解class
ACC_ENUM0x4000标志这是一个枚举class(?) field inner
ACC_MANDATED0x8000mandated类型parameter

0x00 21 ：是0x0020和0x0001的并集，表示 ACC_PUBLIC 与 ACC_SUPER的合并。

  • 00 03 ：表示当前类的类名，指向常量池中的#3 ,而#3对应是com/spring_1_100/test_31_40/test35_resource_inject/MyTest35。
  • 00 04 ：父类的名字，指向常量池中#4 ，java/lang/Object
  • 00 00 ：接口数量，当前类没有实现接口。因为接口数为0，后面的接口名就在字节码中无显示 。
  • 00 01 ：属性个数，类中只声明了一个 int a ,因此属性个数为1。
  • 00 02     00 05     00 06     00 00：字段表集合，fields_count：u2
    字段表结构
类型名称数量
u2access_flags1
u2name_index1
u2descriptor_index1
u2attributes_count1
attribute_infoattributesattributes_count
field_info{
        u2 access_flags; 0002
        u2 name_index; 0006
        u2 descriptor_index; 0006
        u2 attributes_count; 0000
        attribute_info attributes[attributes_count];
}

  • 00 02：表示属性的访问标识符为ACC_PRIVATE类型

  • 00 05：指向常量池中第5个常量#5，是字符串 a

  • 00 06：属性类型描述，指向常量池中第6个常量#6，I ,表示 int 类型

  • 00 00：属性个数为0，因此attributes在字节码中不体现。
    通过上面的分析，我们得到，MyTest35中有一个属性，属性的名称为 a,类型为 int,访问标识符为 private。

  • 00 03 ：方法个数，表示 Mytest35中有3个方法，构造方法，get，set 方法。

  • 00 01 00 07 00 08 00 01 00 09 00 00 00 38 00 02 00 01 00 00 00 0A 2A B7 00 01 2A 04 B5 00 02 B1 00 00 00 02 00 0A 00 00 00 0A 00 02 00 00 00 03 00 04 00 04 00 0B 00 01 00 00 00 0A 00 0C 00 0D 00 00：方法表 methods_count:u2

1.方法表结构

类型名称数量
u2access_flags1
u2name_index1
u2descriptor_index1
u2attributes_count1
attribute_infoattributesattributes_count
method_info{
        u2         access_flags;
        u2         name_index;
        u2         descriptor_index;
        u2         attributes_count;
        attribute_info         attributes[attributes_count];
}

2.方法的属性结构，方法中每个属性都是一个 attribute_info 结构 ，JVM预定义了部分 attribute，但是编译器自己也可以实现了自己的 attribute 写入 class 文件里，供运行时使用。不同的 attribute 通过attribute_name_index 来区分。
attribute_info{
        u2        attribute_name_index;
        u4        attribute_length;
        u1        info[attribute_length];
}

3.Code结构:Code Attribute 的作用是保存该方法的结构，如所对应的字节码
Code_attribute {
        u2        attribute_name_index;
        u4        attribute_length;
        u2        max_stack;
        u2        max_locals;
        u4        code_length;
        u1        code[code_length];
        u2        exception_table_length;
        {
                u2        start_pc;
                u2        end_pc;
                u2        handler_pc;
                u2        catch_type;
        } exception_table[exception_table_lenght];
        u2        attributes_count;
        attribute_info        attributes[attributes_count];
}

  • attribute_length：表示 attribute所包含的字节数，不包含 attribute_name_index 和attribute_length 字段 。
  • max_stack：表示这个方法运行的任何时刻所能达到的操作数栈的最大深度。
  • max_locals：表示方法执行期间创建的局部变量的数目，包含用来表示传入的参数的局部变量。
  • code_length:表示该方法所包含的字节码的字节数以及具体的指令码。具体字节码即是该方法被调用时，虚拟机所执行的字节码。
  • exception_table：这里存放的是处理异常的信息。每个exception_table 表项由start_pc,end_pc,handler_pc,catch_type 组成
  • start_pc 和 end_pc ：表示在 code数组中的从 start_pc 到 end_pc （包含 start_pc，不包含 end_pc） 的指令抛出的异常会由这个表项来处理。
  • handler_pc：表示处理异常的代码的开始处。 catch_type:表示会被处理的异常类型，它指向常量池里的一个异常类，当 catch_type 为0时，表示处理所有的异常。

附加属性

        LineNumberTable:这个属性用来表示 code 数组中的字节码和 Java 代码行数之间的关系，这个属性可以用来在调试的时候定位代码执行的行数。
LineNumberTable 的结构录下：

LineNumberTable_attribute{
        u2        attribute_name_index;
        u4        attribute_length;
        u2        line_number_table_length;
        {
                u2        start_pc;
                u2        line_number;
        }
}

助记符

  • aload_0 = 42 (0x2a) : 将索引为0的元素推送到操作栈的栈顶。
  • invokespecial ：调用实例方法，后面可以接参数。
  • iconst_<i>： 定义常量。
  • putfield：将栈顶的元素赋值。
  • return : 表示返回。

了解到了上面基本概念以后，我们继续来跟进解析方法表结构 ： 00 01     00 07     00 08     00 01     00 09     00 00 00 38     00 02     00 01     00 00 00 0A     2A B7 00 01 2A 04 B5 00 02 B1     00 00     00 02     00 0A     00 00 00 0A     00 02 00 00 00 03 00 04 00 04     00 0B     00 00 00 0C     00 01 00 00 00 0A 00 0C 00 0D 00 00

  • 00 01：表示方法是一个 public 方法

  • 00 07：表示方法名称索引，指向常量池中的#7, #7是<init>

  • 00 08：表示方法返回值索引，指向常量池中#8，#8指向常量池中()V

  • 00 01：表示方法的属性个数，说明只有一个属性。

  • 00 09：表示方法属性名称索引 ，这里指向#9,表示是一个 Code 类型。Code 表示要执行的代码。

  • 00 00 00 38：Attribute length ,属性长度56。

  • 00 02 ：max_stack 为2

  • 00 01 ：max_locals 为1

  • 00 00 00 0A ：code_length 代码长度10，向后面取10个长度，如下：

  • 2A B7 00 01 2A 04 B5 00 02 B1：如果不懂，可以到 Oracle 官网查看助记符对应关系表。

    1. 2A ：表示 aload_0 ，将索引为0的元素推送到操作栈栈顶。
    2. B7 00 01：B7 表示 invokespecial ，00 01 指向常量池中的#1 ，这里表示的是调用 Object 类的构造方法。
    3. 2A ：表示 aload_0 ，将索引为0的元素推送到操作栈栈顶。
    4. 04 ：表示 iconst_1, 在构造方法将常量压入栈中。
    5. B5 00 02 ：B5 表示putfield ，后带参数，指向常量池中的#2 ，将栈顶的元素，保存到 field 中。
    6. B1 ：表示 return ，构造函数没有返回值。
      在这里插入图片描述

  • 00 00 : 异常表，在这里，没有定义 try_catch 信息，因此异常表为0.

  • 00 02 : 表示两个属性。

  • 00 0A：attribute_name_index 指向常量池中的#10，表示行号（LineNumberTable）表。

  • 00 00 00 0A ：attribute_length占4个节节（可参照上面行号表结构）， 表示属性长度。向后数10个字节

  • 00 02 00 00 00 03 00 04 00 04 ：line_number_table_length 表示行号表的实际长度。

在这插入图片描述

    

  1. 00 02 ：表示有两对映射
  2. 00 00 00 03 ：start_pc 为0，Line Number 3 ，3行源码对应指令 0： aload_0
  3. 00 04 00 04：start_pc 为4 ，Line Number 4 , 4 行源码对应 aload_0

在这里插入图片描述

  • 00 0B： 指向常量池中#11，表示的是局部变量表 （LocalVariableTable）。

  • 00 00 00 0C : 表示局部变量表所点字节个数 。这里是12。

  • 00 01 00 00 00 0A 00 0C 00 0D 00 00 ：

    1. 00 01 ：局部变量的个数为1.
    2. 00 00 00 0A ：局部变量作用范围0-9 ，也就是说在
      0: aload_0
      1: invokespecial #1 // Method java/lang/Object.“”😦)V
      4: aload_0
      5: iconst_1
      6: putfield #2 // Field a:I
      9: return
      在上面的范围之内都可以使用局部变量
    3. 00 0C ：局部变量对应常量池中的索引#10，而对应的就是 this，从字节码的角度上来看，对于每一个非 static 方法，都会隐式的传递一个局部变量 this 到这个方法里 。这一点和 python 类似。
    4. 00 0D ：对当前局部变量描述，指向常量池中的#13，而#13指的是当前类Lcom/spring_1_100/test_31_40/test35_resource_inject/MyTest35;
      在这里插入图片描述
  1. 00 00 ：表示的是 exception stack label table ,为0

        

  1. 00 01     00 0E     00 0F     00 01     00 09     00 00 00 2F     00 01     00 01     00 00 00 05     2A B4 00 02 AC 00 00     00 02     00 0A     00 00 00 06     00 01     00 00 00 07     00 0B     00 00 00 0C     00 01 00 00 00 05 00 0C 00 0D 00 00

  • 00 01 ：表示的是method_info的access_flags，占两个字节，0x0001 表示是 public

  • 00 0E：表示的是name_index，名称索引#14,而常量池中的#14表示的是 getA 方法。

  • 00 0F：表示的是descriptor_index，属性描述符，而常量池中的#15,而#15表示的是I,int 类型。

  • 00 01：方法属性个数。

  • 00 09 ：指向常量池中#9，表示方法的属性 Code。

  • 00 00 00 2F ：attribute_length ，属性长度 47

  • 00 01：max_stack,最大操作数栈个数为1

  • 00 01：max_locals，局部变量最大个数

  • 00 00 00 05 ：code_length ，助记符长度。

  • 2A B4 00 02 AC 00 00 :

    1. 2A ：助记符 aload_0 。
    2. B4 00 02 ： 助记符 getfield ，从对象获取字段
    3. AC ：对应的助记符是ireturn， 从方法返回 int
    4. 00 00 ：表示的是exception stack label table

  • 00 02 ：有两个属性

  • 00 0A : 行号表 ，LineNumberTable

  • 00 00 00 06 ：行号表中属性长度attribute_length,占4个字节。

  • 00 01 ：行号表的长度1

  • 00 00 00 07 ：前两个字节为start_pc，值为0 ，后两个字节为Line Number，值为7,源码中的第7行指向start_pc 为 aload_0
    在这里插入图片描述

  • 00 0B ：指向常量池中#11，而#11表示局部变量表。

  • 00 00 00 0C ：局部变量表长度12。

  • 00 01 00 00 00 05 00 0C 00 0D 00 00：

  1. 00 01：局部变量表的个数1
  2. 00 00 00 05：start_pc 为0 ，Length为5 ，局部变量表的作用范围为0-4。
  3. 00 0C ：指向常量池#12 ，值为 this。
  4. 00 0D ：指向常量池#13，值为Lcom/spring_1_100/test_31_40/test35_resource_inject/MyTest35;也就是说，局部变量表 this,是MyTest35对象。
  5. 00 00 :表示异常堆栈信息为0
    在这里插入图片描述

        

  1. 00 01     00 10     00 11     00 01     00 09     00 00 00 3E     00 02     00 02     00 00 00 06     2A 1B B5 00 02 B1 00 00     00 02     00 0A     00 00 00 0A     00 02     00 00 00 0B     00 05 00 0C     00 0B     00 00 00 16     00 02 00 00 00 06 00 0C 00 0D 00 00 00 00 00 06 00 05 00 06 00 01
  • 00 01 ：表示的是method_info的access_flags，占两个字节，0x0001 表示是 public
  • 00 10 ：表示的是name_index，名称索引#16,而常量池中的#16表示的是 setA 方法。
  • 00 11 ：表示的是descriptor_index，属性描述符，而常量池中的#17,而#17表示的是(I)V,void 类型。
  • 00 01 :方法属性个数1
  • 00 09 ：指向常量池中#9，表示方法的属性 Code。
  • 00 00 00 3E ：attribute_length ，属性长度62
  • 00 02 ：max_stack,最大操作数栈个数为2
  • 00 02 ：max_locals，局部变量最大个数为2
  • 00 00 00 06：code_length ，助记符长度为6。
  • 2A 1B B5 00 02 B1 00 00：
  1. 2A ：助记符 aload_0 。
  2. 1B ：助记符 iload_1
  3. B5 00 02 ： 助记符 putfield ，从对象获取字段 ，方法参数#2，而#2代表的是#com/spring_1_100/test_31_40/test35_resource_inject/MyTest35.a:I，MyTest35中的 int 类型的属性a
  4. B1 ：助记符是return,无返回值
  5. 00 00： 表示无exception_table_length
  • 00 02 ：有两个属性
  • 00 0A : 行号表 ，LineNumberTable
  • 00 00 00 0A ：行号表中属性长度attribute_length,占10个字节。
  • 00 02 ：行号表的长度2

在这里插入图片描述

  • 00 00 00 0B：Start_pc 为0 ，LineNumber11 ，源码中11行指向aload_0

  • 00 05 00 0C: Start_pc 为5 ，LineNumber12,源码中的第12行指向 return 。
    在这里插入图片描述

  • 00 0B ：指向常量池中#11，而#11表示局部变量表。

  • 00 00 00 16 ：局部变量表长度22。

  • 00 02 00 00 00 06 00 0C 00 0D 00 00 00 00 00 06 00 05 00 06 00 01 ：

在这里插入图片描述

  1. 00 02：局部变量表的个数2
  2. 00 00 00 06 ：start_pc 为0 ,Length为6 ，局部变量表的作用范围为 0-6
  3. 00 0C ：指向常量池#12 ，值为 this。
  4. 00 0D ：指向常量池#13，值为Lcom/spring_1_100/test_31_40/test35_resource_inject/MyTest35;
  5. 00 00 ：exception_table_length 为0
  6. 00 00 00 06 : start_pc 为0 ,Length为6，局部变量表的作用范围为 0-6
  7. 00 05 ：指向常量池#5 ，值为 a。
  8. 00 06 : 指向常量池#6，值为 I,Int 类型。
  9. 00 01 ：这个，我也不知道。

在这里插入图片描述

  1. 00 01     00 12     00 00 00 02     00 13：
  • 00 01 ：属性个数为1个
  • 00 12 ：指向常量池中#18，而18对应的源文件SourceFile。
  • 00 00 00 02：源文件占2个字节，向后数两个字节。
  • 00 13：指向常量池中#13，而13对应的是Lcom/spring_1_100/test_31_40/test35_resource_inject/MyTest35;类。

到这里，我们终于完成了一个简单的字节码解析。
下面我们来对 Class 结构总结一下。

  1. 先是魔数解析magic
  2. 主版本号
  3. 次版本号
  4. 访问标志位
  5. 常量池的解析
  6. 从字节码中获取当前类
  7. 从字节码中获取父类
  8. 从字节码中获取接口
  9. 属性获取
  10. 方法提取
  11. 编译器植入attribute
  12. 当前字节码的源文件名
    到这里，己经将一个类全部解析完成，但是在解析之前，一定要对 JVM规范中的基础知识了解，方法表结构，属性结构，行号表结构等，结构中有几个属性，每个属性占几个字节，等都要有一定印象，才去后面字节码的解析，不然，你会觉得云里雾里。不知所以。不过还要耐心，一个字节一个字节的去读取，也许你会花一天，或者多天来解析字节码，但是，只要你解析过一遍以后，将是你学习 java 中宝贵的财富。
    个人总结，还是希望读者自己去尝试一下，不然，看了也没有什么用。

本文的 github 地址是https://github.com/quyixiao/spring_tiny/blob/master/src/main/java/com/spring_1_100/test_31_40/test35_resource_inject/MyTest35.java

柳擎
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java字节码文件查看工具,查看class文件
01-15
Java字节码文件查看工具，如JD-GUI，是开发者们深入理解Java应用程序内部机制的重要辅助工具。这类工具能够帮助我们查看并分析.class文件，这些文件是Java源代码经过编译后的二进制形式，包含了运行时所需的所有指令...
JVM基础：字节码文件详解①
siaok的博客
10-28 1282
👉概述。
字节码文件（.class文件）
weixin_47414034的博客
11-03 3021
前四个字节（也就是第0号字节到第3号字节） ca fe ba be叫做魔数，表示这个文件是一个class类型的文件（如果是其他字母，可能就表示是其他类型的文件）这个构造方法对应的字节码指令为： 2a b7 00 01 b1。接下来两个字节（8~9）：00 23 表示常量池的长度 十六进制的23等于35，由于#0项不计入，所以实际上有#1~#34。接下来四个字节（4~7）：00 00 00 34表示版本，表示是Jdk 8版本。1.字节码文件（.class文件)结构解析:字节码文件长啥样，里面有什么。
初探Java字节码格式，编程解析字节码文件
qq_44525150的博客
04-18 2414
本文较为详细的探讨了Java字节码文件(.class文件)的格式，并以HelloWorld.java的字节码文件为例，带读者逐个字节对文件进行解析，最后使用Java编程实现了对.class文件的解析过程 本文比较直观的对读者阅读字节码文件，对于初学者是一个字节码格式学习较好的入门教程，对于OG来说，这也是比较好的复习资料
字节码文件
真滴不可理喻的博客
08-05 1135
详解类文件结构、字节码指令
字节码文件结构
m0_62609939的博客
06-01 846
字节码文件结构
java字节码文件反编译
01-17
Java字节码文件反编译是一项重要的技术，它允许开发者查看和理解已编译的Java类文件（.class文件）内部的源代码结构。在Java中，源代码被编译成字节码，这是一种中间语言，由Java虚拟机（JVM）执行。然而，有时我们...
Recaf一个现代Java字节码编辑器
08-06
**Recaf：现代Java字节码编辑器** 在Java开发领域，字节码编辑器是一种不可或缺的工具，它允许开发者查看、分析并修改Java类文件的字节码，从而实现对程序运行时行为的深入控制。Recaf是这样一个现代、用户友好的...
java字节码框架ASM的深入学习
08-31
ASM是一个底层的库，它直接操作Java字节码，这使得开发者能够在运行时改变类的行为或创建新的类。本文将深入探讨ASM框架的核心概念、如何使用ASM以及一个简单的代码示例。 一、ASM框架介绍 ASM是一个开源的Java...
【JVM篇】分析并讲解字节码文件
小吉妙妙屋
02-07 1926
其中，常量池是字节码文件中最重要的部分之一，它包含了几乎所有的字面量和符号引用，并为虚拟机执行字节码提供了必要的信息。对于Java语言而言，编译Java源代码后会生成字节码文件（以.class为扩展名），其中包含了Java虚拟机（JVM）可理解的指令集。字节码文件可以在不同的平台上运行，因为它们是跨平台的中间表示形式。通过将源代码编译成字节码文件，可以实现代码的平台无关性，并提供更高层次的安全性和运行时的灵活性。通过这些部分的组合，Java虚拟机可以读取和执行字节码文件中的指令，并最终完成程序的执行。
字节码（.class）文件解读
jackzhang11的博客
12-02 7638
字节码文件是什么 我们在命令后使用 java 命令，就能将java源文件（.java）编译成对应的字节码文件（.class）。字节码文件是一种八位字节的二进制流文件，各个数据项按照一定顺序从前到后紧密排列。因此，这样的安排会使得字节码文件非常紧凑，可以被jvm快速的加载到内存中，并且占用较少的内存空间。 java源文件在被编译器编译之后，每个类（或者接口）都单独占据一个字节码文件。类中所有信息都在字节码文件中有所描述，由于字节码文件非常灵活，它对类的描述能力甚至强于java源文件。 字节码文件中的信息是一项
access建立两个字段唯一索引_Java .class文件 访问标志，索引，字段表，方法表
weixin_39560002的博客
11-21 275
访问标志在常量池结束之后紧接着的两个字符代表访问标志，这个标志用于识别一些类或者接口的访问信息，比如是个类还是一个接口，是否是public等 两个字节一共有16个标志位可以使用，目前只定义了9个，没有标志位的时候要按照0处理，按照上一接的内容进行查找可以发现访问标志是0x0021，能够读出来是0x0001 | 0x0020，所以他对应的是public + class，和我们的代码相吻合类索引、父类...
字节码文件及字节码指令
Earl_yuan的专栏
05-21 4648
我记得开始学习Java的第一堂课时，我的大学老师是这样说的，Java号称是“一次编写，到处运行”，为什么有底气这样说，是因为Java程序并不是直接运行在操作系统上的，它通过不同操作系统上的Java虚拟机实现了“到处运行”的美好愿景。而且我的老师当时还说过，不止Java程序可以在Java虚拟机上运行，其他的程序也同样可以在Java虚拟机上运行。Java虚拟机并不认识具体的某种编程语言，而是编程语言要...
JVM 字节码文件结构
xiangxiongfly
03-03 1085
Java源代码通过 javac 命令编译生产 .class 字节码文件。 使用javap命令查看字节码文件。如：javap -v Person.class 输出字节码信息，或 javap -v -p Person.class 输出完整字节码信息。 可以安装 jclasslib 插件查看。
详解JAVA字节码
Joker_ZJN的博客
03-03 2630
一文详解JAVA字节码
【JVM基础篇（二）】字节码文件详解
最新发布
shybiubiuccy的博客
03-04 769
讲述了如何用正确的姿势打开字节码文件、字节码文件的组成以及玩转字节码的工具都有哪些
字节码文件简介
weixiaohuai的博客
08-14 1528
目录 一、概述 二、透过字节码查看代码执行细节之Integer判断相等 三、透过字节码查看代码执行细节之String判断相等 四、透过字节码查看代码执行细节之类初始化 一、概述 想要让一个Java程序正确地运行在JVM中，Java源码就必须要被编译为符合JVM规范的字节码。 前端编译器的主要任务就是负责将符合Java语法规范的Java代码转换为符合JVM规范的字节码文件。 javac是一种能够将Java源码编译为字节码的前端编译器。 Javac编译器在将Java源码编译为一个有效的字节码文
字节码文件详解
xlshi1996的博客
10-24 4896
前言 我们都知道，Java程序最终是转换成class文件执行在虚拟机上的，那么class文件是个怎样的结构，虚拟机又是如何处理去执行class文件里面的内容呢，这篇文章带你深入理解Java字节码中的结构。 1.Demo源码 首先，编写一个简单的Java源码： package com.april.test; public class Demo { private int num = 1; public int add() { num = num + 2; r
"深入理解Java字节码文件结构及其重要性
字节码文件结构详解.docx是一篇详细讲解了Java字节码文件结构的文章。Java诞生之时，就有了“一次编写，到处运行（Write Once, Run Anywhere）“的口号。这意味着我们编写的.java文件会被编译成.class文件，然后可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值