类文件结构 || JVM类加载与字节码技术

最新推荐文章于 2025-12-11 20:04:44 发布
原创 最新推荐文章于 2025-12-11 20:04:44 发布 · 347 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#jvm #java #开发语言

本文详细介绍了Java HelloWorld案例的Class文件结构，包括魔数、版本号、常量池等内容。通过od和javap命令解析二进制字节码，展示了如何理解方法、字段、字符串等常量信息。此外，还探讨了访问标识与继承信息，如类、父类、接口、方法等的表示方式。

类文件结构

HelloWorld案例

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

一个最简单的 HelloWorld 代码, 使用 javac 编译后会生成 HelloWorld.class 文件

二进制字节码文件

执行 od -t xC HelloWorld.class 可以得到下面的二进制字节码文件


0000000 ca fe ba be 00 00 00 34 00 22 0a 00 06 00 14 09
0000020 00 15 00 16 08 00 17 0a 00 18 00 19 07 00 1a 07
0000040 00 1b 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29
0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e
0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63
0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01
0000140 00 04 74 68 69 73 01 00 20 4c 63 6e 2f 6b 6e 69
0000160 67 68 74 7a 7a 2f 65 78 61 6d 70 6c 65 2f 48 65
0000200 6c 6c 6f 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e
0000220 01 00 16 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f
0000240 53 74 72 69 6e 67 3b 29 56 01 00 04 61 72 67 73
0000260 01 00 13 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53
0000300 74 72 69 6e 67 3b 01 00 0a 53 6f 75 72 63 65 46
0000320 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64
0000340 2e 6a 61 76 61 0c 00 07 00 08 07 00 1c 0c 00 1d
0000360 00 1e 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64
0000400 07 00 1f 0c 00 20 00 21 01 00 1e 63 6e 2f 6b 6e
0000660 02 00 01 00 07 00 08 00 01 00 09 00 00 00 2f 00
0000700 01 00 01 00 00 00 05 2a b7 00 01 b1 00 00 00 02
0000720 00 0a 00 00 00 06 00 01 00 00 00 0c 00 0b 00 00
0000740 00 0c 00 01 00 00 00 05 00 0c 00 0d 00 00 00 09
0000760 00 0e 00 0f 00 01 00 09 00 00 00 37 00 02 00 01
0001000 00 00 00 09 b2 00 02 12 03 b6 00 04 b1 00 00 00
0001020 02 00 0a 00 00 00 0a 00 02 00 00 00 0f 00 08 00
0001040 10 00 0b 00 00 00 0c 00 01 00 00 00 09 00 10 00
0001060 11 00 00 00 01 00 12 00 00 00 02 00 13
0001075

常量池

使用 javap -v HelloWorld.class 得到字节码

$ javap -v HelloWorld.class
Classfile /F:/JavaCode/hm-jvm-codes/jvm-chapter-03/target/classes/cn/knightzz/example/HelloWorld.class
  Last modified 2022-10-14; size 573 bytes
  MD5 checksum 98ee61ec018245a2c46adf53ab20f1c0
  Compiled from "HelloWorld.java"
public class cn.knightzz.example.HelloWorld
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#20         // java/lang/Object."<init>":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // hello world
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // cn/knightzz/example/HelloWorld
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcn/knightzz/example/HelloWorld;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               HelloWorld.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               hello world
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               cn/knightzz/example/HelloWorld
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
{
  public cn.knightzz.example.HelloWorld();
    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 12: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcn/knightzz/example/HelloWorld;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String hello world
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 16: 0
        line 17: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "HelloWorld.java"

JVM规范

参考文章

类文件结构

U4表示前4个字节, 后面的 U2 表示后面两个字节表示的含义, 以此类推, 这是所有虚拟机厂商在构建自己的JVM的时候必须要尊守的规则

ClassFile {
    u4             magic; //Class 文件的标志
    u2             minor_version;//Class 的小版本号
    u2             major_version;//Class 的大版本号
    u2             constant_pool_count;//常量池的数量
    cp_info        constant_pool[constant_pool_count-1];//常量池
    u2             access_flags;//Class 的访问标记
    u2             this_class;//当前类
    u2             super_class;//父类
    u2             interfaces_count;//接口
    u2             interfaces[interfaces_count];//一个类可以实现多个接口
    u2             fields_count;//Class 文件的字段属性
    field_info     fields[fields_count];//一个类会可以有多个字段
    u2             methods_count;//Class 文件的方法数量
    method_info    methods[methods_count];//一个类可以有个多个方法
    u2             attributes_count;//此类的属性表中的属性数
    attribute_info attributes[attributes_count];//属性表集合
}

魔数

每个Class文件的头4个字节称为魔数（Magic Number），它的唯一作用是确定这个文件是否为一个能被虚拟机接受的Class文件.

紧接着魔数的4个字节存储的是Class文件的版本号：第5和第6个字节是次版本号 （Minor Version），第7和第8个字节是主版本号（Major Version）。


0000000 ca fe ba be 00 00 00 34 00 22 0a 00 06 00 14 09
0000020 00 15 00 16 08 00 17 0a 00 18 00 19 07 00 1a 07
0000040 00 1b 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29
0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e
0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63
0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01
0000140 00 04 74 68 69 73 01 00 20 4c 63 6e 2f 6b 6e 69
0000160 67 68 74 7a 7a 2f 65 78 61 6d 70 6c 65 2f 48 65
0000200 6c 6c 6f 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e
0000220 01 00 16 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f
0000240 53 74 72 69 6e 67 3b 29 56 01 00 04 61 72 67 73
0000260 01 00 13 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53
0000300 74 72 69 6e 67 3b 01 00 0a 53 6f 75 72 63 65 46
0000320 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64
0000340 2e 6a 61 76 61 0c 00 07 00 08 07 00 1c 0c 00 1d
0000360 00 1e 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64
0000400 07 00 1f 0c 00 20 00 21 01 00 1e 63 6e 2f 6b 6e
0000660 02 00 01 00 07 00 08 00 01 00 09 00 00 00 2f 00
0000700 01 00 01 00 00 00 05 2a b7 00 01 b1 00 00 00 02
0000720 00 0a 00 00 00 06 00 01 00 00 00 0c 00 0b 00 00
0000740 00 0c 00 01 00 00 00 05 00 0c 00 0d 00 00 00 09
0000760 00 0e 00 0f 00 01 00 09 00 00 00 37 00 02 00 01
0001000 00 00 00 09 b2 00 02 12 03 b6 00 04 b1 00 00 00
0001020 02 00 0a 00 00 00 0a 00 02 00 00 00 0f 00 08 00
0001040 10 00 0b 00 00 00 0c 00 01 00 00 00 09 00 10 00
0001060 11 00 00 00 01 00 12 00 00 00 02 00 13
0001075

第一行 : 0000000 ca fe ba be 00 00 00 34 00 22 0a 00 06 00 14 09

0~3 字节 ==> ca fe ba be ，表示它是否是【class】类型的文件 , 它的唯一作用是确定这个文件是否为一个能被虚拟机接受的Class文件

4~7 字节 ==> 00 00 00 34 , 第5和第6个字节 00 00 是次版本号, 第7和第8个字节 00 34 是主版本号 转换成十进制是 52 ,

常量池

常量池中常量的项目类型

img

上面的 HelloWorld 编译后的常量池的代码

Constant pool:
   #1 = Methodref          #6.#20         // java/lang/Object."<init>":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // hello world
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // cn/knightzz/example/HelloWorld
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcn/knightzz/example/HelloWorld;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               HelloWorld.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               hello world
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               cn/knightzz/example/HelloWorld
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
{

二进制码分析

第一行 : 0000000 ca fe ba be 00 00 00 34 00 22 0a 00 06 00 14 09

8~9 字节 ==> ，表示常量池长度，00 22 （34） 表示常量池有 #1 ~ #34项

第 #1 项 0a 表示一个 Method 信息，00 06 和 00 14（20） 表示它引用了常量池中 #6 和 #20 项来获得 这个方法的【所属类】和【方法名】

0000000 ca fe ba be 00 00 00 34 00 22 0a 00 06 00 14 09

  • 0a => #1 = Methodref #6.#20 // java/lang/Object."<init>":()V

  • 00 06 (#6) ==> #6 = Class #27 // java/lang/Object

  • 00 14（#20）==> #20 = NameAndType #7:#8 // "<init>":()V

第 #2 项 09 表示 一个 Field 信息 , 第二行的 00 15 (#21), 00 16(#22)

第二行 0000020 00 15 00 16 08 00 17 0a 00 18 00 19 07 00 1a 07

  • 00 15 ==> #21 = Class #28 // java/lang/System
  • 00 16 ==> #22 = NameAndType #29:#30 // out:Ljava/io/PrintStream;

第 #3 项 08 表示一个字符串常量名称，00 17（23）表示它引用了常量池中 #23 项

0000020 00 15 00 16 08 00 17 0a 00 18 00 19 07 00 1a 07

  • 00 17 ==> #23 = Utf8 hello world

第#4项 0a 表示一个 Method 信息，00 18（24） 和 00 19（25） 表示它引用了常量池中 #24 和 #25 项来获得这个方法的【所属类】和【方法名】

0000020 00 15 00 16 08 00 17 0a 00 18 00 19 07 00 1a 07

  • 00 18 ==> #24 = Class #31 // java/io/PrintStream
  • 00 19 ==> #25 = NameAndType #32:#33 // println:(Ljava/lang/String;)V

第#5项 07 表示一个 Class 信息，00 1a（26） 表示它引用了常量池中 #26 项

0000020 00 15 00 16 08 00 17 0a 00 18 00 19 07 00 1a 07

  • 00 1a ==> #26 = Utf8 cn/knightzz/example/HelloWorld

第#6项 07 表示一个 Class 信息，00 1b（27） 表示它引用了常量池中 #27 项

0000020 00 15 00 16 08 00 17 0a 00 18 00 19 07 00 1a 07
0000040 00 1b 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29

  • 00 1b ==> #27 = Utf8 java/lang/Object

第#7项 01 表示一个 utf8 串，00 06 表示长度，3c 69 6e 69 74 3e 是【 】

0000040 00 1b 0100 063c 69 6e 69 74 3e 01 00 03 28 29

  • 01 ==> utf8 串
  • 00 06 ==> 表示长度为 6 字节
  • 3c 69 6e 69 74 3e ==> <init>

第#8项 01 表示一个 utf8 串，00 04 表示长度，28 29 56 是【()V】其实就是表示无参、无返回值

0000040 00 1b 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29

0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e

第#9项 01 表示一个 utf8 串(常量池的项目类型)，00 04 表示长度，43 6f 64 65 是【Code】

0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e

  • 01 ==> 对应常量池的项目类型, utf8的字符串
  • 04 ==> 表示 长度为 4个字节
  • 43 6f 64 65 ==> 67

剩下的省略 …


0000000 ca fe ba be 00 00 00 34 00 22 0a 00 06 00 14 09
0000020 00 15 00 16 08 00 17 0a 00 18 00 19 07 00 1a 07
0000040 00 1b 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29
0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e
0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63
0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01
0000140 00 04 74 68 69 73 01 00 20 4c 63 6e 2f 6b 6e 69
0000160 67 68 74 7a 7a 2f 65 78 61 6d 70 6c 65 2f 48 65
0000200 6c 6c 6f 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e
0000220 01 00 16 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f
0000240 53 74 72 69 6e 67 3b 29 56 01 00 04 61 72 67 73
0000260 01 00 13 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53
0000300 74 72 69 6e 67 3b 01 00 0a 53 6f 75 72 63 65 46
0000320 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64
0000340 2e 6a 61 76 61 0c 00 07 00 08 07 00 1c 0c 00 1d
0000360 00 1e 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64
0000400 07 00 1f 0c 00 20 00 21 01 00 1e 63 6e 2f 6b 6e
0000660 02 00 01 00 07 00 08 00 01 00 09 00 00 00 2f 00
0000700 01 00 01 00 00 00 05 2a b7 00 01 b1 00 00 00 02
0000720 00 0a 00 00 00 06 00 01 00 00 00 0c 00 0b 00 00
0000740 00 0c 00 01 00 00 00 05 00 0c 00 0d 00 00 00 09
0000760 00 0e 00 0f 00 01 00 09 00 00 00 37 00 02 00 01
0001000 00 00 00 09 b2 00 02 12 03 b6 00 04 b1 00 00 00
0001020 02 00 0a 00 00 00 0a 00 02 00 00 00 0f 00 08 00
0001040 10 00 0b 00 00 00 0c 00 01 00 00 00 09 00 10 00
0001060 11 00 00 00 01 00 12 00 00 00 02 00 13
0001075

// 上面的其实是常量池的二进制表示

Constant pool:
   #1 = Methodref          #6.#20         // java/lang/Object."<init>":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // hello world
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // cn/knightzz/example/HelloWorld
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcn/knightzz/example/HelloWorld;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               HelloWorld.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               hello world
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               cn/knightzz/example/HelloWorld
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
{

上面的 和 下面的 是对应的 第九项是 Code ==> #9 = Utf8 Code

访问标识与继承信息

image-20221015172617259 
[root@localhost ~]# od -t xC HelloWorld.class 
	0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09 
    0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07 
    0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29 
    0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e 
    0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63 
    0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01 
    0000140 00 04 74 68 69 73 01 00 1d 4c 63 6e 2f 69 74 63 
    0000160 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 6f 
    0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e 01 00 16 
    0000220 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 
    0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13 
    0000260 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 
    0000300 6e 67 3b 01 00 10 4d 65 74 68 6f 64 50 61 72 61 
    0000320 6d 65 74 65 72 73 01 00 0a 53 6f 75 72 63 65 46 
    0000340 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64 
    0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e 
    0000400 00 1f 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64 
    0000420 07 00 20 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74 
    0000440 63 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 
    0000460 6f 57 6f 72 6c 64 01 00 10 6a 61 76 61 2f 6c 61 
    0000500 6e 67 2f 4f 62 6a 65 63 74 01 00 10 6a 61 76 61 
    0000520 2f 6c 61 6e 67 2f 53 79 73 74 65 6d 01 00 03 6f 
    0000540 75 74 01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72 
    0000560 69 6e 74 53 74 72 65 61 6d 3b 01 00 13 6a 61 76 
    0000600 61 2f 69 6f 2f 50 72 69 6e 74 53 74 72 65 61 6d 
    0000620 01 00 07 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a 
    0000640 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 
    0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01 
    0000700 00 07 00 08 00 01 00 09 00 00 00 2f 00 01 00 01 
    0000720 00 00 00 05 2a b7 00 01 b1 00 00 00 02 00 0a 00 
    0000740 00 00 06 00 01 00 00 00 04 00 0b 00 00 00 0c 00 
    0000760 01 00 00 00 05 00 0c 00 0d 00 00 00 09 00 0e 00 
    0001000 0f 00 02 00 09 00 00 00 37 00 02 00 01 00 00 00 
    0001020 09 b2 00 02 12 03 b6 00 04 b1 00 00 00 02 00 0a 
    0001040 00 00 00 0a 00 02 00 00 00 06 00 08 00 07 00 0b 
    0001060 00 00 00 0c 00 01 00 00 00 09 00 10 00 11 00 00 
    0001100 00 12 00 00 00 05 01 00 10 00 00 00 01 00 13 00 
    0001120 00 00 02 00 14

21 表示该 class 是一个类，公共的

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

05 表示根据常量池中 #5 找到本类全限定名

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

06 表示根据常量池中 #6 找到父类全限定名

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

表示接口的数量，本类为 0

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

Field 信息

表示成员变量数量，本类为 0

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

image-20221015173115557

Method 信息

表示方法数量，本类为 2

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

一个方法由 访问修饰符，名称，参数描述，方法属性数量，方法属性组成 :

  • 红色代表访问修饰符（本类中是 public）

  • 蓝色代表引用了常量池 #07 项作为方法名称

  • 绿色代表引用了常量池 #08 项作为方法参数描述

  • 黄色代表方法属性数量，本方法是 1

  • 红色代表方法属性

    • 00 09 表示引用了常量池 #09 项，发现是【Code】属性

    • 00 00 00 2f 表示此属性的长度是 47

    • 00 01 表示【操作数栈】最大深度

    • 00 01 表示【局部变量表】最大槽（slot）数

    • 00 00 00 05 表示字节码长度，本例是 5

    • 2a b7 00 01 b1 是字节码指令

    • 00 00 00 02 表示方法细节属性数量，本例是 2

    • 00 0a 表示引用了常量池 #10 项，发现是【LineNumberTable】属性

      • 00 00 00 06 表示此属性的总长度，本例是 6
      • 00 01 表示【LineNumberTable】长度
      • 00 00 表示【字节码】行号 00 04 表示【java 源码】行号

    • 00 0b 表示引用了常量池 #11 项，发现是【LocalVariableTable】属性

      • 00 00 00 0c 表示此属性的总长度，本例是 12
      • 00 01 表示【LocalVariableTable】长度
      • 00 00 表示局部变量生命周期开始，相对于字节码的偏移量
      • 00 05 表示局部变量覆盖的范围长度
      • 00 0c 表示局部变量名称，本例引用了常量池 #12 项，是【this】
      • 00 0d 表示局部变量的类型，本例引用了常量池 #13 项，是 【Lcn/itcast/jvm/t5/HelloWorld;】
      • 00 00 表示局部变量占有的槽位（slot）编号，本例是 0

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

0000700 00 07 00 08 00 01 00 09 00 00 00 2f 00 01 00 01

0000720 00 00 00 05 2a b7 00 01 b1 00 00 00 02 00 0a 00

0000740 00 00 06 00 01 00 00 00 04 00 0b 00 00 00 0c 00

0000760 01 00 00 00 05 00 0c 00 0d 00 00 00 09 00 0e 00

附加属性

  • 00 01 表示附加属性数量
  • 00 13 表示引用了常量池 #19 项，即【SourceFile】
  • 00 00 00 02 表示此属性的长度
  • 00 14 表示引用了常量池 #20 项，即【HelloWorld.java】

0001100 00 12 00 00 00 05 01 00 10 00 00 00 01 00 13 00

0001120 00 00 02 00 14

参考 : https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html

JVM字节码class文件和类的加载
希望和大家多多交流技术！
02-21 1300
每一个java类被编译后都会生成一个对应的.class字节码文件，通常以16进制来查看，数据是以二进制流的形式存储的，中间没有分隔符。 .class文件是编译的结果，只加载了常量、静态成员变量、静态成员方法、static代码块等。在程序运行时才会加载进JVM内存。 .class字节码文件由十个部分组成： MagicNumber(魔数) ： 位于.class字节码文件最开头的四个字节，是固定值0xCAFEBABE。虚拟机加载.class文件时会先检查魔数是不是0xCAFEBAB...
JVM 字节码文件与类加载
Vincent的博客
04-16 3291
文章目录前端编译器与后端编译器解释执行和 JIT&AOT字节码文件结构（.class 和 .dex 文件结构）代码编译成字节码后是怎样的？程序想要运行代码，做了什么？（类的生命周期概述）类加载器的分类loadClassAndroid 类加载器热修复原理 该篇文章是建立在 JVM 运行时数据区（栈和堆） 、JVM GC 和 JVM Hotspot 虚拟机与 Dalvik&ART 虚拟机堆栈的区别 三篇文章的基础上讲解，所以在阅读前建议先理解看完上述文章，会对该篇文章的理解很有帮助。 在之前的篇
JVM——字节码文件的加载过程（类的加载过程）以及双亲委派机制
保暖透气大裤衩LeoLee的博客
12-22 1509
JVM运行加载字节码文件 简图如下 类加载器子系统 类加载器： 负责从文件系统（简单说就是硬盘）或者网络上加载class文件，class文件在文件开头有特点的标识。 ClassLoader只负责class文件的加载，只要是符合JVM对字节码文件规范的要求就可以，至于它是否可以运行，由执行引擎决定。 加载的类信息存放在方法区（一块内存空间），除了类信息之外，方法区中还会存放运行时常量池信息，可能还会包括字符串字面量和数字常量（这部分常量信息是class文件中常量池部分的内存映射） 例如一个磁盘
JVM类加载机制—JVM类加载过程
weixin_44991038的博客
08-21 1401
JVM类加载过程分析
【JVM】类加载与字节码技术
小皮皮LL的博客
10-18 2656
文章目录JVM-类加载与字节码技术1.类文件结构1-1 魔数1-2 版本1-3 常量池2.字节码指令2-1 javap工具2-2 图解方法执行流程（1）原始 Java 代码（2）编译后的字节码文件（3）常量池载入运行时常量池（4）方法字节码载入方法区（5）main 线程开始运行，分配栈帧内存（6）执行引擎开始执行字节码2-3 练习-判断结果2-4 构造方法（1）cinit()V（2）init()V2-5 方法调用2-6 多态的原理2-7 异常处理（1）try-catch（2）多个 single-catch
JVM 中篇：字节码与类的加载
weixin_49561445的博客
10-30 2180
文章目录字节码的跨平台性前端编译器Class 文件结构Class类的本质Class文件格式Class 文件结构Magic Number(魔数)文件版本号常量池constant_ pool count(常量池计数器)constant_pool[] 常量池表字面量和符号引用全限定名简单名称描述符符号引用和直接引用的区别与关联小结访问标识类索引、父类索引、接口索引集合字段表集合方法表集合属性表集合解析Class 文件解析字节码方式javap字节码指令集加载与存储指令局部变量压栈指令常量入栈指令出栈装入局部变量表指
JVM解密: 解构类加载与GC垃圾回收机制
trong_ 的烂笔头
08-30 2094
介绍JVM的内存划分，类加载过程以及GC垃圾回收机制中的查找垃圾和回收垃圾的算法。
JVM基础之字节码文件
weixin_44021343的博客
04-19 839
JVM基础之字节码文件
JVM的类加载和字节码执行引擎
Public Static Void Main
02-27 1782
在上篇《JVM的Class文件结构》中，简单梳理了Class文件内容，然而这只是一个小小的开始。Class文件只是一个你所编写的程序信息的等价完备的存储，它是死的，若要让它活起来，就需要将Class文件加载到虚拟机中并运行。Class文件的类加载过程是怎样？进入到虚拟机中的Class文件信息又会以什么样的形式存储？虚拟机如何找到应该执行的方法？虚拟机如何执行Class文件中的字节码？这些都是需要思考
JVM之类加载过程
积跬步，至千里。
10-10 1141
类加载会经过：`加载，验证，准备，解析，初始化`等5个阶段，顺序是确定的（并发执行，不一定按顺序结束），而解析不确定，有些情况下可以在初始化之后进行。
Java安全基于类加载机制的代码加密与反编译防护：字节码加密还原实战技术解析
09-30
适合人群：具备一定Java开发基础，熟悉JVM原理、类加载机制及Web项目结构的中初级研发人员或安全技术爱好者；适合从事代码防护、软件版权保护或逆向分析相关工作的技术人员。; 使用场景及目标：① 学习Java字节码...
Java中的JVM类加载机制详解
10-30
首先，类加载是指将Java类的字节码加载到JVM内存中的过程。JVM通过类加载器完成这一任务，常见的加载方式包括命令行方式、类加载器方式和动态代理方式。命令行方式使用`javac`命令编译Java源文件，随后使用`java`...
jvm字节码自动加载
02-07
了解JVM如何自动加载字节码对于深入理解Java应用程序的执行机制至关重要。 首先，我们要知道Java程序的类加载过程通常分为三个阶段：加载、验证、准备、解析和初始化。其中，加载阶段就是JVM查找并解析字节码文件的...
3_类加载与字节码技术2
08-03
Java 类加载与字节码技术是理解Java程序运行机制的关键环节。本文将深入探讨类文件结构、字节码指令、编译期处理、类加载阶段、类加载器以及运行期优化。 1. **类文件结构** Java 类文件是二进制格式的，其结构...
Java虚拟机JVM类加载初始化
10-03
Java虚拟机JVM类加载初始化是Java程序运行过程中的关键环节，它负责将类的字节码文件加载到内存中并进行相应的处理，以便程序能够正确执行。在Java中，类加载器（Classloader）扮演着核心角色。下面将详细讨论类加载...
大规模微服务下的 JVM 调优实战指南
最新发布
qq_43414012的博客
12-11 365
大规模微服务JVM调优实战指南摘要 本文针对大规模微服务环境下的JVM调优挑战，提出了一套系统化的解决方案。主要内容包括： 新挑战分析：识别了资源碎片化、性能波动同步、故障传播放大和运维复杂性四大核心挑战 优化策略： 实例数与内存模型的精细平衡 集群级GC选型与协调策略 分布式架构对JVM性能的影响分析 实践方案： 提出集群级JVM管理框架 实现智能实例调度算法 提供核心服务与边缘服务的差异化配置模板 实施效果：通过动态资源分析和最优分布计算，有效避免了资源热点问题，显著提升了集群整体性能稳定性。
如何实现jvm中自定义加载器？
qsxxlc的博客
12-11 568
java运行/*** 基础自定义类加载器（遵循双亲委派）*/// 自定义类加载的根路径// 父加载器默认是应用类加载器（Application ClassLoader）/*** 重写findClass：实现从自定义路径加载.class文件的字节码*/@Overridetry {// 1. 将类全限定名转换为文件路径（如com.example.TestClass → com/example/TestClass.class）// 2. 读取.class文件的字节码。
GC 调优实战：从慢到快的真实案例
qq_43414012的博客
12-09 715
GC调优实战：从慢到快的真实案例 摘要 本文记录了一个电商系统在大促期间遇到的GC性能问题及优化过程。系统在双11高峰时出现频繁Full GC（3-5次/小时），最大停顿时间达3.5秒，导致响应时间从50ms飙升至800ms。通过深度分析业务内存模型（分配速率500MB/s，95%短命对象）和G1收集器配置问题（并发线程不足、IHOP设置不合理），最终采用七种优化策略：调整堆区大小、优化并发线程数、修改IHOP阈值等。优化后Full GC频率降为0，停顿时间缩短至200ms以内，CPU使用率降低60%，成功
JVM 元空间
weixin_37926313的博客
12-09 745
参数作用生产建议首次 Full GC 触发阈值设为稳态使用量（如 256m）元空间硬上限必须设置，容器中尤其关键🌟黄金法则“可观测 + 有上限 + 留余量”在生产环境中，永远不要依赖 JVM 的默认无限制行为。通过合理配置这两个参数，你不仅能避免 Metaspace OOM，还能减少不必要的 Full GC，提升应用的稳定性与性能。
深入理解JVM：类加载与字节码验证
"本次分享主要围绕JVM相关技术展开，特别是验证阶段的四个步骤：文件格式验证、语义检查、字节码验证和符号引用验证。此外，还涵盖了虚拟机的概念、分类，Java虚拟机（JVM）的多层含义以及不同实现，JDK中的组件如...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

兀坐晴窗独饮茶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值