罗昭成-csdn
罗昭成-csdn

解密Java Class文件不为人知的秘密

Java 诞生多年，因此在网络上，有关 Java Class 文件格式解析的文章有很多，但他们大多数都是在列举《Java 虚拟机》中定义的格式，通读下来，好像所有的东西都讲清楚了，但是我个人好像并没有看懂，不知道定义的这些东西到底是用来存储什么东西的。本文仍然是在讲《Java 虚拟机》中定义的 Class 文件的格式，但会更多的从一个应用开发者的角度，将字节码文件中定义的字段与原始的 Java 代码信息进行一些关联，让应用开发者能够更好的理解其中的内容。当然，文中也存在部分知识点，不太常用或者我也没有了解清楚的，可能会一笔带过。当然，作为经久不衰的 Java ，其强大之处远不是一篇文章能讲清楚的，文中肯定会有疏漏的地方，如果你对其内容感兴趣，可以有针对性的进行深入研究。当然，本文内容近 1.6 万字，也很枯燥，建议大体浏览一遍即可，无需太过深究，如以后遇到相关问题后，在回来查阅即可。 下面为本文正文内容：

Java 诞生 28 年，能够一直保持良好的兼容性，其 Class 文件结构的稳定性起到了很重要的作用。在我们现在使用的 Class 文件中，其结构定义绝大部分都是在 1997 年发布的第一版 《Java 虚拟机规范》中就已经定义好了。虽然定义的时间距今已经 20 多年过去， Java 发展经历十多个大版本的迭代 以及无数字小的更新，最开始定义好的各项细节几乎没有出现任何改变。

Class 文件是一组以 8 个比特位为基础的二进制流，各个数据项都是按照固定的顺序紧密的排列在一起。先来看下一整体结构，以及每一个字段的长度信息如下：

解密Java Class文件不为人知的秘密_第1张图片 Class 文件格式

一、Magic Number 魔数

魔数， 如魔法一样神奇的数字。当我们写代码时，都建议不要使用魔数，因为它在你刚写完代码的时候只有“你和上帝”知道是什么意思，但过一段时间后，就只有“上帝”知道了。而为了区分文件格式，在文件内容的开头，都会使用一些魔数，用于标记和识别文件。如常见的 JPEG 的格式，文件头为 FFD8FF。在 Java 的字节码文件中，其魔数为 CAFEBABE，它是一个4字节的标识符，用于表明该文件是一个 Java 字节码文件。Java 虚拟机可以通过魔数来判断该文件是否为一个有效的 Java 字节码文件，如果不是，则无法被正确加载并执行。

而关于 CAFEBABE 这个魔数的起源，还有一些小故事，Java 创始人 James Gosling 曾透露：

我们以前经常去一个叫 St Michael's Alley 餐厅吃饭， 当地传说，美国著名的摇滚乐队 Grateful Dead 在其大火之前，曾在这里面演出过，可以说这家餐厅就是 Grateful Dead 的起源之地。在 Jerry 去世后，他们甚至为建立了一个小型神龛用于纪念。当我们在次来到这家餐厅的时候，发现它已经被改名为 Cafe Dead 。 我注意到这个名字是 16 进制字符串，而那时我正需要用一对魔数去表示 Class 文件和 Object 文件。最终我使用 CAFEBDEAD 表示了 Object 文件，与之对应，Class 文件头我以 CAFE 开始，去查找另外 4 个 16 进制字符，并在不经意间发现了BABE，于是我决定使用它们， 因此 CAFEBABE 成为了 Class 文件的文件格式。

—— 来源：维基百科 https://en.wikipedia.org/wiki/Java_class_file

二、版本号

在 Class 文件中，版本号分为主版本号和次版本号，第 5、6 两位是次版本号，第 7 和第 8 两位是主版本号。主版本号是从 45 开始的，从 JDK 1.1 之后的每一个 JDK 大版本发布，主版本号都会加 1 。

PS： 在 JDK 最早期的版本中，JDK 1.0 ~ 1.1 使用了 45.0 ~ 45.3 的版本号

关于次版本号，曾经在 Java 1.2 之前曾被短暂使用过，但从 Java 1.2 后到 Java 12 之前，次版本号均未使用，全部固定为 0 。而到了 Java 12 后，由于JDK提供的功能集已经非常庞大，有一些复杂的新特性需要以“公测”的形式放出，因此设计者重新启用了副版本号，将它用于标识“技术预览版”功能特性的支持。如果 Class 文件中使用了该版本 JDK 尚未列入正式特性清单中的预览功能，则必须把次版本号标识为 65535，以便Java虚拟机在加载类文件时能够区分出来。

三、常量池

顾名思义，常量池是用来放常量的，但这个常量与我们在 Java 代码中的常量一样吗？这个常量到底包含有哪些信息呢？

在 Class 文件中的常量池里，主要存放两大类常量：字面量（Literal）和符号引用（Symbolic References）。字面量比较接近于Java语言层面的常量概念，如文本字符串、被声明为 final 的常量值等。而符号引用是属于编译原理方面的概念，主要有 类和接口的全限定名、字段的名称和描述符、方法的名称和描述符 等，到目前为止，JDK 中共定义了 17 种不同类型的常量，如下表所示：

常量类型 Tag Class 文件版本号
CONSTANT_Utf8_info 1 45.3
CONSTANT_Integer_info 3 45.3
CONSTANT_Float_info 4 45.3
CONSTANT_Long_info 5 45.3
CONSTANT_Double_info 6 45.3
CONSTANT_Class_info 7 45.3
CONSTANT_String_info 8 45.3
CONSTANT_Fieldref_info 9 45.3
CONSTANT_Methodref_info 10 45.3
CONSTANT_InterfaceMethodref_info 11 45.3
CONSTANT_NameAndType_info 12 45.3
CONSTANT_MethodHandle_info 15 51.0
CONSTANT_MethodType_info 16 51.0
CONSTANT_Dynamic_info 17 55.0
CONSTANT_InvokeDynamic_info 18 51.0
CONSTANT_Module_info 19 53.0
CONSTANT_Package_info 20 53.0

为了更好的理解字面量、符号引用，以及他们与 Java 代码的关系，我写以下的一段测试代码，来看看 Java 中哪些数据会被放在 Class 文件的常量池中：

package com.example;
class ClassFormat {
    public final int finalVerbose = 1;
    public int verbose = 100;
    public int verboseV2 = 32768;
    public double doubleVerbose = 1;
    public double doubleVerboseV2 = 1.1;
    public float floatVerbose = 1f;
    public float floatVerboseV2 = 1.00001f; 
    public long longVerbose = 1L;
    public long longVerboseV2 = 2L;
    public char charVerbose = 'Z';
    public String strVerbose = "This is a string.";
    public void testMethod() {
    }
}

在这段代码中，我们使用了常见的基本数据类型，它们都有各自的初始化值。在执行 Javac 进行编译的过程中，会将代码中的一些值放入常量区，而一另外一些不会。先说结论，上面示例中的代码中，finalVerbose、strVerbose 和以 V2 结尾的变量的初始值都会写入常量池。

解密Java Class文件不为人知的秘密_第2张图片 基本数据类型中写入到常量池中的变量

编译后，使用  javap -v ClassFormat 查看常量池，具体内容如上图所示，图中圈出来的是我们在 Java 代码中定义的值，这些需要放在常量池满足以下条件：

  • 定义变量时，有 final 修饰的值，如   public final int finalVerbose = 1，此时数字 1 就会放到常量池中。

  • int 型的值范围在 -32768 到 32767 之间的数是不会放入常量池，即两个字节可以表示的整形数字不会放进去，其它都会放进去。

  • long /  float / double 中除了 0  和 1 以外的其它值都会放出常量池。

  • String 中定义的字符串都会放入常量池。

上面这些放入常量池中的字段，是与代码中写的 值 直接相关。除了这些，常量池中还会保存很多符号引用，在上图中还可以看到如下信息：

#1 = Methodref          #2.#3          // java/lang/Object."":()V
 #2 = Class              #4             // java/lang/Object
 #3 = NameAndType        #5:#6          // "":()V
 #5 = Utf8               
 #6 = Utf8               ()V
 #8 = Class              #10            // ClassFormat
#10 = Utf8               ClassFormat
#12 = Utf8               I 
#17 = Fieldref           #8.#18         // ClassFormat.verboseV2:I
#18 = NameAndType        #19:#12        // verboseV2:I
#19 = Utf8               verboseV2

其中 #1 表示常量池中的第一个常量，此处为一个 Methodref ， 即一个方法的引用，根据 《Java虚拟机规范》中的描述，他有两个字段，分别指向此方法所属的类，和方法的名称和类型描述，此例中为 java.lang.Object 的 () 方法，按其结构绘制图如下：

解密Java Class文件不为人知的秘密_第3张图片 Objct 的方法引用

需要注意的是，我们在类中定义的方法，只有在被调用时，才会生成 Methodref 引用。用于表示方法引用的还有一个常量类型： InterfaceMethodref，此常量用来标记为接口的方法，例如下面代码中的 commonMethod 的调用：

public interface CommonInterface {
    public void commonMethod();
}

public class CommonImplementation implements CommonInterface{
    @Override
    public void commonMethod() {
    }
}

class ClassFormat {
    CommonInterface common = new CommonImplementation();
    public void testMethod() {
        common.commonMethod();
    }
}

编译后，便会生成一个 InterfaceMethodref，其结构与 Methodref 一致，其指向的类名为 CommonInterface。

与方法对应的便是我们常用的变量，与之不同的是，在代码中定义的类变量以及属性变量，都会生成一个 Fieldref 属性，其结构与 Methodref 一致，此例中的 #17 便是代码中的 public int verboseV2 = 32768;。按其结构绘制图如下：

解密Java Class文件不为人知的秘密_第4张图片 Fieldref 结构图

上述常量池中信息除了上述两个字段以外，还有 Class、Utf8 以及 NameAndType， 它们分别用来表示类常量、Utf8 常量以及描述方法/字段名称和类型的常量。

Utf8 常量应该是常量池中使用最多的字段，在代码中定义的 变量名、方法名 都会以该常量的形式将名称存储在常量池中，当在进行 javac 编译时，可添加参数 -g:vars让方法参数名称、局部变量名称也存储在常量池中。

内容到这儿，在 Java 1.2 中定义的 11 个基本常量类型已经完全涉及到了。在后续的 JDK 版本中，随着功能升级，也新增了其它常量。

在 JDK 7 中，添加了  InvokeDynamic 指令，随之添加了三个常量：CONSTANT_MethodHandle_info、CONSTANT_MethodType_info 和 CONSTANT_InvokeDynamic_info。而我们使用的 Java 代码，在  Java SE 1.8 及以上代码才被使用到，其中我们常用的 lambda 就是基于这几条指令实现的，例如下面的代码：

public class LambdaExample {
    public void print() {
        TestLambdaInterface ii = (i, b) -> i++;
        ii.print(10, "");
    }
}
interface TestLambdaInterface {
    void print(int i, String b);
}

根据这几个常量的结构，可以生成如下关联关系图：

解密Java Class文件不为人知的秘密_第5张图片 InvokeDynamic 相关常量结构

上述代码，在 JVM 中进行执行时，首先会找到常量池中 #7 的常量，通过它指向的 bootstrapMethod ，JVM 会调用这个引导方法，并将参数值传递给引导方法。从而获得一个 CallSite 对象，此对象中包含被真实执行的方法句柄，最终调用到真实的方法。动态调用方法在 Groovy 中使用比较多，有兴趣可使用 Groovy 进行深度研究。此处是用于动态方法调用，与之对应还有动动变量，在 JDK 11 的版本中，添加了 CONSTANT_Dynamic_info，用于实现动态变量的逻辑，但对于 Java 语言， 暂未找到使用此指令实现的逻辑。

在 Java 9 中引入了模块系统，用来组织和管理代码，从而使得应用程序更加安全、可维护和高效。这两个常量分别为 CONSTANT_Module_info 和  CONSTANT_Package_info，分别用来存储模块信息与包信息，并且他们仅能用于 module-info.java 中。先来看以下代码：

// module-info.java
module JavaClassFileStructure {
    requires java.base;
    requires java.desktop;
    exports com.example.clazz;
}

此段代码，编译后会生成 CONSTANT_Module_info 以及 CONSTANT_Package_info，分别用来记录模块信息

JavaClassFileStructure、java.base、java.desktop 和包信息 com/example/clazz 。

以上是现在已有的 17 种常量类型，这里面的这些常量类型，有一部分是原子的，比如 CONSTANT_Utf8_info、CONSTANT_Integer_info，但还有部分，是通过 _index 对象指向其它常量， 如 CONSTANT_Class_info 、CONSTANT_Fieldref_info，在《Java虚拟机规范》中，各常量定义的结构如下：

常量类型 Tag 字段
CONSTANT_Utf8_info 1 tag:u1
length:u2
bytes:u1[length]
CONSTANT_Integer_info 3 tag:u1
bytes:u4
CONSTANT_Float_info 4 tag:u1
bytes:u4
CONSTANT_Long_info 5 tag:u1
high_bytes:u4
low_bytes:u4
CONSTANT_Double_info 6 tag:u1
high_bytes:u4
low_bytes:u4
CONSTANT_Class_info 7 tag:u1
name_index:u2
CONSTANT_String_info 8 tag:u1
string_index:u2
CONSTANT_Fieldref_info 9 tag:u1
class_index:u2
name_and_type_index:u2
CONSTANT_Methodref_info 10 tag:u1
class_index:u2
name_and_type_index:u2
CONSTANT_InterfaceMethodref_info 11 tag:u1
class_index:u2
name_and_type_index:u2
CONSTANT_NameAndType_info 12 tag:u1
name_index:u2
descriptor_index:u2
CONSTANT_MethodHandle_info 15 tag:u1
reference_kind:u1
reference_index:u2
CONSTANT_MethodType_info 16 tag:u1
descriptor_index:u2
CONSTANT_Dynamic_info 17 tag:u1
bootstrap_method_attr_index:u2
name_and_type_index:u2
CONSTANT_InvokeDynamic_info 18 tag:u1
bootstrap_method_attr_index:u2
name_and_type_index:u2
CONSTANT_Module_info 19 tag:u1
name_index:u2
CONSTANT_Package_info 20 tag:u1
name_index:u2

传送门， 常量池结构: https://docs.oracle.com/javase/specs/jvms/se14/html/jvms-4.html#jvms-4.4

看到这里，在 Class 文件中定义的常量结构，基本上都了解清楚了。在回到上一层的结构：

解密Java Class文件不为人知的秘密_第6张图片 常量池在 Class 文件中的格式

常量池是一个表类型的数据项目，常量池中常量的数量也是不固定的，因此在常量池的入口是一个 2 字节数据，代表常量池中常量的数量。在这里需要注意的是，常量的索引是从 index 为 1 开始的。因此，常量池中的常量个数加 1 后为 constant_pool_count。

注：在 Class 文件格式规范制定之时，设计者将第 0 项常量空出来是有特殊考虑的，这样做的目的在于，如果后面某些指向常量池的索引值的数据在特定情况下需要表达"不引用任何一个常量池项目"的含义，可以把索引值设置为 0 来表示。

四、访问标志

在常量池后，紧接着两个字节是用来标识类的访问标识（access_flags），表示这个类的可访问性，如常见的 public 、final 等信息，具体标识位的值及其含义如下：

标志名称 值 解释
ACC_PUBLIC 0x0001 声明为公共的；可以从包外访问。
ACC_FINAL 0x0010 声明为最终的；不允许有子类。
ACC_SUPER 0x0020 当通过 invokespecial 指令调用超类方法时，对其进行特殊处理。
ACC_INTERFACE 0x0200 是一个接口，而非类。
ACC_ABSTRACT 0x0400 声明为抽象的；不能被实例化。
ACC_SYNTHETIC 0x1000 声明为生成的；在源代码中不存在。
ACC_ANNOTATION 0x2000 声明为注解接口。
ACC_ENUM 0x4000 声明为枚举类。
ACC_MODULE 0x8000 是一个模块，而非类或接口。

这些访问标志中， 其中一些字段与 Java 代码中的关键字一致，根据其名字就知道其在什么场景会出现，我在这儿就不做过多介绍。下面来看一下，两个没有出现在平时的代码中的两个关键字：

第一个为 ACC_SYNTHETIC，此字段就是用来标记此类是编译器生成的，没有与之对应的源代码码。

第二个为 ACC_SUPER，它用于解决调用 super 方法时的问题。 在 JDK 1.1 之前， 编译出来的 Class 文件是不包含 ACC_SUPER 字段的，并且 invokespecial 指令在那时的功能与现在不一致。从 JDK 1.1 开始，编译产生的 Class 文件始终都会添加 ACC_SUPPER，在 《Java虚拟机规范》中描述，  Java SE 8 及以上版本中，Java 虚拟机认为在每个类文件中都设置了 ACC_SUPER 标志，无论该标志在类文件中的实际值和类文件版本如何。

五、 类索引、父类索引、接口索引列表

在 Class 结构中，会分别有两个字节来表示当前类索引（this_class） 和父类索引（super_class），这两个字节分别存储的两个指向常量值的索引。除此之外，Java 中继承的接口可以是多个，因此在 Class 文件中定义了一个与常量池类似的表结构，用于存储所有的接口，需要注意的是， 它的索引是从 0 开始，即 interfaces_count 的值与 interfaces[] 数据中元素个数一致。表结构中存储的每一个接口的信息与 this_class 一样，也是用两个字节来存储指向常量池的索引。比如代码

public class ClassFormat implements Serializable, Cloneable {
}

中的结构如下图所示：

解密Java Class文件不为人知的秘密_第7张图片 this、super、interface 的引用

六、字段集合

在使用 Java 语言编写代码时，变量有三种，一种是类级别变量，如 public static int staticVerbose = 1; ，第二种是实例变量，如 public int verbose = 2; ，还有一个是局部变量，如定义在方法代码块中的变量。前两种变量从 Class 文件的角度来看，他们并没有太大的区别 ，变量编译后，编译后都会放到字段集合中进行存储。而局部变量不会放到字段集合中去。与常量池类似，字段集合也是一个表结构，下图为字段的结构表：

解密Java Class文件不为人知的秘密_第8张图片 字段结构

从图中可以看到，每一个字段信息中包含有 5 个字段，属性是一个嵌套的表结构。从上到下，第一个是 access_flags，里面存储着字段修饰符，它与类中的 access_flags 值是非常类似的，都是使用两个字节的数据类型，但他们之间值范围有略微的差别，字段可以设置的标志位和含义如下所示：

Flag名称 值 解释
ACC_PUBLIC 0x0001 声明为公共的；可以从其它包外部访问。
ACC_PRIVATE 0x0002 声明为私有的；只能在定义该类和属于同一个nest（§5.4.4）的其他类中访问。
ACC_PROTECTED 0x0004 声明为受保护的；可以在子类中访问。
ACC_STATIC 0x0008 声明为静态的。
ACC_FINAL 0x0010 声明为final；在对象构造之后不会被直接赋值（JLS §17.5）。
ACC_VOLATILE 0x0040 声明为volatile；不能被缓存。
ACC_TRANSIENT 0x0080 声明为transient；不会被持久化对象管理器写入或读取。
ACC_SYNTHETIC 0x1000 声明为synthetic；不在源代码中存在，编译时生成，如内部类中持有的外部类引用变量
ACC_ENUM 0x4000 声明为枚举的元素。

关于这几个标志位中，基本都能根据名称知道其含义。在 Class 文件中的访问标识符里面，我没有找到 ACC_SYNTHETIC 修饰的 Class 示例，但字段中还是可以举个例子。在写代码时，应该都使用过匿名内部类，在匿名内部类中，编译器就会为我们生成一些字段 。举个例子：

class ClassFormat {
    int verbose = 1;
    public void testMethod() {
        TestInterface innerVerbose = new TestInterface() {
            @Override
            public void testMethodV1() {
                System.out.println(verbose);
            }
            @Override
            public void testMethodV2() {
                verbose ++;
            }
        };
    }
}

上述代码会生成一个内部类，名叫  ClassFormat$1.class 的文件，而编译器为了解决内部类能访问外部类的信息，实现相互访问，编译器会生成一个变量用于支持这种情况。针对这种情况，我们来看一下，其中生成的类结构信息，如下图所示：

解密Java Class文件不为人知的秘密_第9张图片 ACC_SYNTHETIC 示例

从图中可以看到，在 ClassFormat$1  中有一个名叫 this$0 的字段，类型为 com.example.clazz.format.ClassFormat ， 此字段就是由编译器生成，因此其访问标识符中有 ACC_SYNTHETIC 。

在访问标识符后面，紧接着的两个字段分别会 name_index、descriptor_index ，各占两个字节，它们将指向常量池中的字段，上例中，name_index 的值为 5 ，即指向了常量池中第五个常量，其类型为 Utf8 ，存储的值为 this$0，descriptor_index 的值为 6， 类型同样为 Utf8，存储的值为 Lcom/example/clazz/format/classFormat;。

紧随其后的便是字段的属性表数据，属性表是一个非常复杂的结构，并且字段、方法、类都有对应的属性，此处先跳过属性的内容，后文中将进行统一梳理。

七、方法表

与字段表类似，整个方法字段的结构体与字段结构体一模一样，方法的结构体如下：

解密Java Class文件不为人知的秘密_第10张图片 方法表结构体

虽然结构体中字段定义一样，但其值包含的内容与范围还是有一些区别的，先看 access_flags ，此字段依然是用来定义其访问修饰符的，包含信息如下：

Flag名称 值 解释
ACC_PUBLIC 0x0001 声明为public，可以从包外访问。
ACC_PRIVATE 0x0002 声明为private，只能在定义类和其他属于同一嵌套的类中访问。
ACC_PROTECTED 0x0004 声明为protected，可以在子类中访问。
ACC_STATIC 0x0008 声明为static。
ACC_FINAL 0x0010 声明为final，不能被覆盖。
ACC_SYNCHRONIZED 0x0020 声明为synchronized，方法调用将被封装在一个监视器使用中。
ACC_BRIDGE 0x0040 桥接方法，由编译器生成。
ACC_VARARGS 0x0080 声明具有可变数量的参数。
ACC_NATIVE 0x0100 声明为native，实现使用的是Java编程语言之外的语言。
ACC_ABSTRACT 0x0400 声明为abstract，没有提供实现。
ACC_STRICT 0x0800 声明为strictfp，浮点模式为FP-strict。
ACC_SYNTHETIC 0x1000 声明为synthetic，在源代码中不存在

这些修饰符大部分都是常见的，看其名就能知其意，其中 ACC_BRIDGE 以及 ACC_SYNTHETIC 是由编译器生成的，平时基本不会关注到。其中 ACC_BRIDGE  用于范型中，标识该方法为编译器自动生成的桥接方法，用于兼容范型，在这里，先来看一下泛型的示例代码：

interface GenericInterface {
    T testBridgeMethod();
}

class ClassFormat implements GenericInterface {
    @Override
    public String testBridgeMethod() {
        return null;
    }
}

代码中，testBridgeMethod 返回的是一个泛型，在 ClassFormat 中使用的具体类型为 String，将此代码进行编译，编译后的产物  ClassFormat.class 文件中会生成一个 bridge 的方法，因此编译器会在此方法中加入 ACC_BRIDGE 和 ACC_SYNTHETIC 这两个方法修饰符。最终 ClassFormat.class 方法表结构如下所示：

283f757551675dd01fa59745323f7355.png ACC_BRIDGE方法示例

从结构中可以看到，在 ClassFormat.class 文件中的方法表里面有两个方法，用 Java 代码表示如下所示：

public String testBridgeMethod(){
 return null;
}
public Object testBridgeMethod() {
  // 此方法即为编译器生成的代理方法
  // 通过 invokevirtual 调用方法 testBridgeMethod:()Ljava/lang/String;
 // invokevirtual #2     // Method testBridgeMethod:()Ljava/lang/String;
}

上述代码在 Java 中并不合法，Java 中的方法重载时需要方法名相同，却需要拥有一个与原方法不同的特征签名。在 Java 源代码中的特征签名只包含方法名称、参数顺序以及参数类型。而在 Class 文件中，字节码中的特征签名还包含方法返回值以及异常表，因此上述逻辑在 Class 文件中是合法的。

另一个访问标志位 ACC_STRICT 也很少用到，在 java 中有一个关键字 strictfp 与之对应。在虚拟机执行时，浮点运算有两种运行模式：严格浮点模式和非严格浮点模式。当我们执行严格浮点运算时，在所有的Java虚拟机实现上运行结果都是精确相等的。需要注意的是，在 Java 17 及以后，此关键字已经不在使用了。

在访问标识符后面，紧接着的四个字段信息name_index、descriptor_index、attributes_count、attributes 与字段表中的格式一致，在此处就不在赘述。

八、属性表

属性表（attribute_info） 在 Class 文件中用于多处地方，在 Class 文件最末尾是属性表，在字段（field_info）和方法（method_info）里面也都包含属性表。与Class文件中其他的数据项要求严格的顺序、长度和内容不同，属性表中的限制稍微宽松一些，不再要求各个属性表具有严格顺序，并且《Java虚拟机规范》允许只要不与已有属性名重复，任何人实现的编译器都可以向属性表中写入自己定义的属性信息，Java虚拟机运行时会忽略掉它不认识的属性。先来看一下属性字段中定义的结构：

解密Java Class文件不为人知的秘密_第11张图片 属性结构体

到目前为止，一共定义了 30 个属性，信息如下：

属性名 版本号 位置 解释
ConstantValue 45.3 字段属性中 由 final 关键字定义的常量值
Code 45.3 方法属性中 Java 代码编译后的字节码指令
StackMapTable 50.0 Code属性中 JDK 6 中新增属性，用于类型检查器验证
Exceptions 45.3 方法属性中 方法抛出的异常列表
InnerClasses 45.3 Class文件属性表结构 内部类列表
EnclosingMethod 49.0 Class文件属性表结构 仅当类为局部类或者匿名内时才会有这个属性，用于标示这个类所在的外围方法
Synthetic 45.3 Class文件属性表结构，字段属性中, 方法属性中 表示方法、字段是由编译器生成
Signature 49.0 字段属性中, 方法属性中 JDK 5 中新增，用于支持泛型情况下的方法签名。
SourceFile 45.3 Class文件属性表结构 记录源文件名称
SourceDebugExtension 49.0 Class文件属性表结构 源调试信息扩展，如 JSP 文件行号
LineNumberTable 45.3 Code属性中 Java 源代码行号与字节码指令的对应关系
LocalVariableTable 45.3 Code属性中 方法局部变量表
LocalVariableTypeTable 49.0 Code属性中 局部变量类型表
Deprecated 45.3 Class文件属性表结构，字段属性中, 方法属性中 被申明为弃用的方法
RuntimeVisibleAnnotations 49.0 Class文件属性表结构，字段属性中, 方法属性中 运行时可见注释
RuntimeInvisibleAnnotations 49.0 字段属性中, 方法属性中 运行时不可见注释
RuntimeVisibleParameterAnnotations 49.0 方法属性中 运行时可见参数注释
RuntimeInvisibleParameterAnnotations 49.0 方法属性中 运行时不可见参数注释
RuntimeVisibleTypeAnnotations 52.0 字段属性中, 方法属性中 运行时可见类型注释
RuntimeInvisibleTypeAnnotations 52.0 字段属性中, 方法属性中 运行时不可见类型注释
AnnotationDefault 49.0 方法属性中 记录注解类元素默认值
BootstrapMethods 51.0 Class文件属性表结构 保存 invokedynamic 指令引用的引导方法限定符
MethodParameters 52.0 方法属性中 在 JDK 8 中增加，记录方法名称，可运行时获取 。
Module 53.0 Class文件属性表结构 记录一个 Module 的名称及相关信息
ModulePackages 53.0 Class文件属性表结构 记录模块中被 exports 或 opens 的包
ModuleMainClass 53.0 Class文件属性表结构 记录一个模块的主类
NestHost 55.0 Class文件属性表结构 用于支持嵌套类的反射和控制的 API ，内部类通过此属性得知自己的宿主类
NestMembers 55.0 Class文件属性表结构 用于支持嵌套类的反射和控制的 API ，宿主类通过此属性得知自己的内部类
Record 60.0 Class文件属性表结构 表示当前类是记录类，存储记录组件信息
PermittedSubclasses 61.0 Class文件属性表结构 属性记录了被授权直接扩展或实现当前类或接口的类和接口。

1. ConstantValue

在 Class 文件中的字段里面，可能会包含 ConstantValue ，它是一个固定长度的属性值，其结构如下所示：

字段名 数据类型 描述
attribute_name_index 2 字节 属性名常量索引
attribute_length 4 字节 常量属性的长度， 此处固定为 0x00000010
constantvalue_index 2 字节 常量属性的值的索引

在  ClassFormat 中定义两个 final 的字段，代码如下：

class ClassFormat {
    public final String CONSTANT_STRING = "constant_string";
    public static final String STATIC_CONSTANT_STRING = "static_constant_string";
}

最终生成的字段信息中，会包含一个 ConstantValue 的属性，下图为 STATIC_CONSTANT_STRING 的关联关系图，可以更清晰的看清楚其关系：

解密Java Class文件不为人知的秘密_第12张图片 ConstantValue 关联关系

ConstantValue 的作用是通知虚拟机自动为静态变量赋值，对于非静态变量虚拟机会自动忽略此常量值。上例中的 CONSTANT_STRING 与 STATIC_CONSTANT_STRING 都包含有 ConstantValue 的属性，这是  Java 编译器做的事，但《Java虚拟机规范》中仅要求使用 ACC_STATIC 标志的 STATIC_CONSTANT_STRING 中的 ConstantValue 属性。

2. Code

我们编写的 Java 代码中的方法，经过编译器编译后，会生成字节码指令，这此指令会直接存储在 Code 属性中。但是并非所有的方法都会有  Code 属性，如 abstract 修饰的抽象方法就没有 Code 属性。先来看一下 Code 属性的结构：

字段名 数据长度 描述
attribute_name_index 2 字节 属性名常量索引，指向 Code
attribute_length 4 字节 常量属性的长度，
max_stack 2 字节 操作数栈的最大深度
max_locals 2 字节 局部变量表的大小
code_length 4 字节 字节码指令的长度
code code_length 字节 字节码指令序列
exception_table_length 2 字节 异常表的长度
exception_table exception_table_length 个 异常处理表
attributes_count 2 字节 属性表的数量
attributes attributes_count 个 属性表

从表中，可以看到 Code 属性中的字段还是比较多的，下面来看一下，其中的一些关键字段：

  • max_stack 字段表示该方法所需的操作数栈的最大深度。在执行该方法时，Java 虚拟机会为该方法分配一个大小为 max_stack 的操作数栈。当方法调用结束后，该操作数栈会被自动释放。

  • max_locals 字段是指该方法所需的局部变量表的大小，当方法被调用时，Java 虚拟机会为该方法分配一个大小为 max_locals 的局部变量表， 执行期间，会用它来存储方法中的局部变量。局部变量表的大小以变量槽为单位计算，一个变量槽可以存储一个类型为 boolean、byte、char、short、int、float、reference 或 returnAddress 的值。对于类型为 long 或 double 的值，需要使用两个变量槽来存储。方法参数（包括实例方法中的隐藏参数 this ）、显式异常处理程序的参数（就是try-catch语句中catch块中所定义的异常）、方法体中定义的局部变量都需要依赖局部变量表来存放。但并不是方法体中使用了多少个变量，就会使用多少个变量槽。Java 虚拟机会对局部变量的变量槽进行重用，当代码执行超出一个局部变量的作用域时，这个局部变量所占的变量槽可以被其他局部变量所使用，示例如下：

    public void testMaxLocals(int indicate, File file) {
    for (int i = 0; i < indicate; i++) {
        System.out.println("--");
    }
    File[] listFile = file.listFiles();
    System.out.println(listFile);
}

    此段代码的变量槽个数为 4，for 循环中的 i 在循环执行完后，就会释放掉，后面定义的 listFile 就会重用这个变量槽。

  • code 是一个 u1 类型的数组，存储着方法执行所需的所有字节码指令序列，字节码指令是一种特殊的机器指令，Java 虚拟机对其进行解释执行。每个字节码指令都具有特定的操作码和操作数。操作码用于指定该指令执行的具体操作，而操作数则用于指定该指令所需的参数。举个例子，代码如下：

    public class EmptyClass {
}

    对于这样一个空的类， javac 在编译的时候，会为他添加一个默认的构造方法，此方法比较简单，就以他为例，看看 code 中都包含哪些信息。按照前面所说的结构，可以解析出来 code_length 为 5，也就是 code 块中的内容为 5 byte 。紧接着按位读取，首先读入的指令是 0x2a，其助记符为 aload_0，此指令的含义是将第 0 个变量槽中为引用类型的本地变量推送到操作数栈顶，在其后无操作数。第二个读入的指令为 0xb7 ，其助记符为 invokespecial，此指令的作用是以栈顶的引用类型所指向的对象作为方法的接收者，调用对象的实例构造器方法、私有方法或者是其父类的方法，在其后会有两个字节的 index ， 指向常量池中类型为 CONSTANT_MethodRef 的常量，在此处指向的是 java.lang.Object 的 方法。在其后读入的指令是 0xb1，其助记符为 return，在此处返回值为 void。此构造方法生成的的结构图如下：

    解密Java Class文件不为人知的秘密_第13张图片 构造方法的 Code 结构

  • exception_table 在字节码指令之后，用于存储此方法的显示异常处理表。异常表并非所有的 code 字段中都含有，仅代码中有显式处理异常的才会有，即有 try{ } catch(Exception e){} 的代码。先来看一下它的结构：

    字段名 数据长度 描述
    start_pc 2 字节 字节码code 中的下标，从此条指令开始
    end_pc 2 字节 字节码code 中的下标，到此条指令前结束
    handler_pc 2 字节 字节码code 中的下标，当遇到异常时，转到此条指令开始执行
    catch_type 2 字节 指向常量池中异常类的索引，如果为 0， 代表任意异常

    看一段异常表运作的例子， Java 代码如下：

    public int setup()  {
    int x;
    try {
        x = 1;
        return x;
    } catch (Exception e) {
        x = 2;
        return x;
    } finally {
        x = 3;
    }
}

    代码很简单，执行逻辑是先执行 try {} 中代码块，然后执行 finally {} 中代码块。虽然上述代码不会出现异常，但假设执行中会出现异常会怎么样？

    从 java 代码的角度来看，一共以下几种执行路径

    这四条路径，有一条正确的路径以及三条异常路径。在来看一下编译后的字节码指令：

    0 iconst_1  # x=1
 1 istore_1  # 将1存入变量表[1]
 2 iload_1   # 将变量表[1]的值压入栈顶
 3 istore_2  # 将1存入变量表[2]
 4 iconst_3  # x=3
 5 istore_1  # 将3存入变量表[1]
 6 iload_2   # 将变量表[2]的值压入栈顶
 7 ireturn   # 返回
 8 astore_2  # 将 Exception 存入变量表[2]
 9 iconst_2  # x=2
10 istore_1  # 将2存入变量表[1]
11 iload_1   # 将变量表[1]压入栈顶
12 istore_3  # 将栈顶值存入变量表[3]
13 iconst_3  # x = 3
14 istore_1  # 将3存入变量表[1]
15 iload_3   # 将变量表[3]压入栈顶
16 ireturn   # 返回
17 astore 4  # 将其它异常放入变量表[4]
19 iconst_3  # x = 3
20 istore_1  # 将3存入变量表[1]
21 aload 4   # 将变量表[4]中的异常压入栈顶
23 athrow    # 抛出异常

    源码中的 Exception Table 如下：

    Exception table:
    from    to  target type
       0     4     8   Class java/lang/Exception
       0     4    17   any
       8    13    17   any
      17    19    17   any

    第一条为 try{} 代码块抛出异常，且类型为 java/lang/Exception 或其子类时，去执行 catch 的逻辑。

    第二条为  try{} 代码块抛出异常，且其类型无法被 catch 时，会跳转到 17, 即将异常存储到变量表中，然后执行  finally 的块中的逻辑。

    第三条为 catch{} 代码块中会抛出异常，会跳转到 17, 即将异常存储到变量表中，然后执行  finally 的块中的逻辑。

    第四条为将异常存储到变量表中时，出现异常，此时会继续跳转到 17。

  1. try 中的代码块正常执行完成，在执行 finally 中的代码块

  2. try 代码块中抛出了 Exception 后，会执行 catch 中的代码块，仅接着会执行 finally 中的代码快

  3. 如果执行 catch 代码快时，也抛出了异常，会继续执行 finally 中的代码块

  4. try 代码块中执行的代码抛出的异常不是 catch 中定义的Exception 或其子类时，此时会继续执行 finally 中的代码块

3. StackMapTable

StackMapTable 属性是存储在方法表中 Code 属性 里的属性字段里面。它是一个相当复杂的变长属性，在字节码验证阶段，类型检查验证器（Type Checker）会通过 StackMapTable 中的信息，用于确定一段字节码指令是否符合逻辑约束。StackMapTable 的结构如下：

字段名 数据长度 描述
attribute_name_index 2 字节 属性名常量索引，指向 StackMapTable
attribute_length 4 字节 常量属性的长度
number_of_entries 2 字节 栈帧数量
stack_map_frame number_of_entries 个 栈帧数量

此字段从  JDK6 级以上的版本都存在。在 《JVM 虚拟机规范》中，Code 属性 中可以不包含 StackMapTable 属性，虚拟机处理时，如果不包含 StackMapTable 属性，虚拟机会把它当作有一个隐式的 StackMapTable 属性，属性中的number_of_entries 值为 0。

此结构主要是在 javac 以及虚拟机运行时使用，与代码无关，暂无需要过多关注，在此也不过多赘述，并于 stack_map_frame 内的结构信息，如你感兴趣，可以去查阅 《Java 虚拟机规范》。

4. Exceptions

Exception 是在写代码中非常常见的， Exceptions 属性的作用是记录方法中可能抛出的受查异常（Checked Excepitons），也就是在写代码时，throws 关键字后面写的所有异常类型。它的结构见表6-17。

字段名 数据长度 描述
attribute_name_index 2 字节 属性名常量索引，指向 Exceptions
attribute_length 4 字节 常量属性的长度
number_of_exceptions 2 字节 表示当前类抛出的异常个数
exception_index_table number_of_exceptions个 指向常量池类的名称

此结构比较简单，下面是我创建的内部类的测试代码：

public void config() throws IOException, InterruptedException {

}

编译后，生成的 Exceptions 属性结构如下图所示：

解密Java Class文件不为人知的秘密_第14张图片 方法抛出异常申明结构图

可以看到，在 Exceptions 属性中，有两个元素，分别是 IOException 和 ClassNotFoundException，它们都是对常量池中的 CONSTANT_Class_info 常量的引用。

5. LineNumberTable

LineNumberTable 属性中存储的是 Java 代码中的行号信息，使用它们，可以将Class 文件中的字节码指令与  Java 源文件中的代码关联起来。当我们将  Java 源代码编译成字节码时，每行代码都会被编译成一段二进制字节码指令，并且这些指令在字节码文件中是按照顺序排列的。编译时，编译器会为每个指令记录下它在源代码中的行号，当代码运行时发生异常时，就可以根据行号定位到源代码中出错的地方。下面表格中为 LineNumberTable 属性结构：

字段名 数据长度 描述
attribute_name_index 2 个字节 属性名常量池索引，指向值为 LineNumberTable
attribute_length 4 个字节 属性长度
line_number_table_length 2 个字节 行号表长度
line_number_table line_number_table_length * 4 字节 行号表信息

其中，line_number_table_length 表示行号表的长度，line_number_table 是一个数组，每个元素表示一个字节码指令和它在源代码中对应的行号。每个元素包含了以下两个字段：

字段名 数据类型 描述
start_pc 2 字节 指令在字节码中的位置
line_number 2 字节 源代码中的行号

下面是一个简单的 Java 示例代码：

package com.example.clazz.format;

public class LineNumberTableExample {

    public static void main(String[] args) {
        int a = 0;
        int b = 1;
        System.out.println(a + b);
    }
}

编译后，生成的 Class 文件中包含了 LineNumberTable 属性信息，如下所示：

stack=3, locals=3, args_size=1
   0: iconst_0
   1: istore_1
   2: iconst_1
   3: istore_2
   4: getstatic     #7                 
   7: iload_1
   8: iload_2
   9: iadd
  10: invokevirtual #13                
  13: return
LineNumberTable:
  line 6: 0
  line 7: 2
  line 8: 4
  line 9: 13

这意味着，在 main 方法中第 6 行代码int a = 0;对应的字节码指令的位置是 0，第 7 行代码对应的字节码指令的位置是 2，第 4 行代码对应的字节码指令的位置是 4。

这样，当在运行时出现异常时，就可以根据行号表中的信息追溯到源代码中出错的位置了。

6. LocalVariableTable

LocalVariableTable 属性用于描述局部变量表中的变量与  java 源码中定义的变量之前的关系。对于 JVM 虚拟机来说，他并不是必须参数，编译进可使用参数来去掉这项信息。如没有此项信息，在运行调试时，IDE 会使用如 arg0、arg1 等不具有意义的占位符来替代原有的参数名。下面表格为其属性结构：

字段名 数据长度 描述
attribute_name_index 2 个字节 属性名常量池索引，指向值为 LocalVariableTable
attribute_length 4 个字节 属性长度
local_variable_table_length 2 个字节 局部变量表长度
local_variable_table local_variable_table_length * 10 字节 局部变量表信息

其中，local_variable_table_length 表示局部变量表的长度，local_variable_table 是一个数组，其中每个元素表示一个局部变量的信息，包含了以下 5 个字段：

字段名 数据长度 描述
start_pc 2 字节 字节码中中第一次出现的位置
length 2 字节 代码中出现的长度，及该字段的作用域
name_index 2 字节 局部变量名称在常量池中的索引
descriptor_index 2 字节 局部变量类型在常量池中的索引
index 2 字节 在局部变量表中所在的位置

在 JDK 5 引入泛型后，新增了 LocalVeriableTypeTable，此属性与LocalVariableTable 及其相似，只是它用来修饰的是泛型变量，在此处就不在赘述了。

7. InnerClasses

InnerClasses 属性是用来记录内部类与宿主类之间的关联关系的。 当我们在代码中定义内部类的时候，编译器会为当前类以及它的内部类上添加  InnerClasses 属性。

解密Java Class文件不为人知的秘密_第15张图片 InnerClasses 属性结构

在此结构中， inner_class_info_index 和 outer_class_info_index 指向了常量池中 CONSTANT_Class_info 型常量的索引，分别代表内部类和宿主类。inner_name_index 是指向了内部类名称的索引，为 CONSTANT_Utf8_info 类型。

需要注意的是，outer_class_info_index 在局部类、匿名类中，它的值为 0 。同时，在匿名类中，inner_name_index 也为 0 。

下面是我创建的内部类的测试代码：

public class InnerClassExample {
    public class InnerClassDemo {
    }
}

编译后，生成的 InnerClasses 属性结构如下图所示：

解密Java Class文件不为人知的秘密_第16张图片 InnerClasses 结构

8. EnclosingMethod

EnclosingMethod 属性是在 Class 文件结构的属性块中，他是一个定长的属性。在 Java 中，局部类（LocalClass） 与匿名内部类的 Class 文件中，必须包含 EnclosingMethod 属性值。

匿名内部类是非常常见，但在写代码时，去很少有使用局部类。局部类一种特殊的内部类， 它定义在一个代码块中（如方法、构造函数、初始化块等）而不是类的主体中，它只在该代码块中可见，对于外部代码块是不可见的。 示例如下：

public class EnclosingMethodExample {
    public void setup() {
        class A {
            String a = "10";
        }
        A a = new A();
        System.out.println(a.a);
    }
}

在 setup 方法中，定义了 class A ， 编译后会生成 EnclosingMethodExample$1A.class 文件。

EnclosingMethod 属性结构也非常的简单，在结构中，包含两个指向外部类和方法的字段，具体结构如下：

字段名 数据长度 描述
attribute_name_index 2 字节 属性名常量索引，指向 EnclosingMethod
attribute_length 4 字节 常量属性的长度， 此处固定为 0x00000100
class_index 2 字节 类常量索引，指向常量池中 Class 字段
method_index 2 字节 方法常量索引，指向常量池中 MethodRef 字段

上述 EnclosingMethodExample$1A.class  文件中，属性字段中的第二个属性（下标为 1 的那个）便是 EnclosingMethod  属性，其关联结构如下图所示：

解密Java Class文件不为人知的秘密_第17张图片 EnclosingMethod 结构图

通过属性表，可以看到此局部类在 EnclosinMethodExample.setup 方法中。

9. Synthetic

Synthetic 是用来修饰类、方法、变量，表示它们不是由  Java 源代码直接产生，而是由编译器生成。它是一个标志类型的布尔属性，因此其结构中的 infos 长度为 0 ，因此它的内容总共只有 6 个字节，结构如下：

字段名 数据长度 描述
attribute_name_index 2 字节 属性名常量索引， 指向常量池中 Utf8 的常量，其值为 Synthetic
attribute_length 4 字节 常量属性的长度， 此处固定为 0x00000000

不过在 JDK 5 之后，也可以使用访问标志 ACC_SYNTHETIC 来表示相同的功能。我尝试了 Java 中匿名内部类生成的变量，并没有 Synthetic 属性。

编译器通过生成一些在源代码中不存在的方法、字段甚至是整个类的方式，实现了越权访问（如访问 private 修饰的变量）或其他绕开了语言限制的功能。除了刚提到的匿名内部类，枚举类也是一个非常典型的例子，在编译时，会生 $VALUES  方法，存放所有枚举元素的数组。

下面是我创建的枚举类型的测试代码：

enum TestEnum {
    TEST_ENUM_V1,
    TEST_ENUM_V2
}

最后生成的类结构图如下所示：

48dfe0aea988c656b9b0917372d3fb87.png $VALUES字段结构

10. Signature

在 Java 1.5 后的版本中， Java 支持了泛型，而这个 Signature 属性就是用来记录类、方法、变量中的类型变量（Type Variable） 或者参与化类型（Parameterized Type）。Signature 是一个固定长度的属性值，结构非常简单，结构如下表：

字段名 数据长度 描述
attribute_name_index 2 字节 属性名常量索引，指向值为 Signature
attribute_length 4 字节 常量属性的长度， 此处固定为 0x00000010
signature_index 2 字节 签名的常量索引

Java 在编译的过程中，会进行泛型擦除，而 Signature 就是用来存储这些被擦除的信息，让虚拟机能够正确处理其类型。在使用的过程中，泛型有两类，一类是自己定义的泛型参数， 如下示例代码中的 T typeVariable，一类是使用已经定义好的泛型类，使用时指定的具体类型，如下示例代码中的 Map parameterizedType。

public class VerboseSignature {
    public T typeVariable;
    Map parameterizedType;
}

最终生成的 Class 文件中的，这两个字段的属性块中，都会有一个 Signature 的结构，其中 typeVariable  的签名信息为 TT; ，另一个为 Ljava/util/Map;，详细信息如下图所示：

解密Java Class文件不为人知的秘密_第18张图片 Signature 结构示例图

11. SourceFile/SourceDebugExtension

这个属性是用来记录生成 此 Class 文件的源文件名称，此属性的结构是固定长度，结构如下：

字段名 数据长度 描述
attribute_name_index 2 字节 属性名常量索引，指向值为 SourceFile
attribute_length 4 字节 常量属性的长度， 此处固定为 0x00000010
sourcefile_index 2 字节 源文件名称的常量池索引

在使用  Java 的过程中，大部份情况下，类名与文件名是一致的，但是诸如内部类等时会出现例外。此参数对于 Class 文件来说，是一个非必须参数 ，当使用 javac 编译时添加  -g:none 时，生成 Class 文件时，会去掉 SourceFile 等调试信息，可以减少程序体积并提高性能，但是需要注意的时，如果去掉后，出现异常时，不会输出错误代码对应的文件名。最后，下图为 ClassFormat.class 文件中的 SourceFile 属性结构：

解密Java Class文件不为人知的秘密_第19张图片 ClassFormat.class 文件中的 SourceFile 属性

除了 SourceFile 属性，在 JDK 5 时，为了方便在编译器和动态生成的 Class 中加入供程序员使用的自定义内容，新增了 SourceDebugExtension 属性用于存储额外的代码调试信息。典型的场景是在进行 JSP 文件调试时，无法通过 Java 堆栈来定位到 JSP 文件的行号。此时就可以用到 SourceDebugExtension  属性，它的结构如下：

字段名 数据长度 描述
attribute_name_index 2 字节 属性名常量索引，指向值为 SourceDebugExtension
attribute_length 4 字节 常量属性的长度， 此处固定为
debug_extension attribute_length字节 额外调试信息，整个区域是二进制数据，可以按需进行任意填充

12. Deprecated

在写 Java 代码时，使用注解 @Deprecated 标记的类、变量、方法，就会有这个属性值。它是一个标志类型的布尔属性，与 Synthetic 的结构一样，用来表示某个类、字段或者方法已经不在推荐使用。这个属性的存在不会改变类或接口的语义。它的结构如下：

字段名 数据长度 描述
attribute_name_index 2 字节 属性名常量索引， 指向常量池中 Utf8 的常量，其值为 Deprecated
attribute_length 4 字节 常量属性的长度， 此处固定为 0x00000000

13.  Annotations

注解，是 Java 中一个非常常用的功能。 注解有几类：

  • SOURCE：仅在源码中出现，编译时会被丢掉

  • CLASS： 编译后会存储在Class 文件中，但是 JVM 加载时会丢掉，运行时获取不到。注解默认为此行为

  • RUNTIME：在 Class 文件中存在， 在运行时 JVM 会加载进来，运行时可获取到

根据定义，可以知道 SOURCE 类型的是无法写入到 Class 文件中的， 而 CLASS 与 RUTIME 的区别是一个可以在运行时使用，一个不可以。在 Class 文件中，也根据这个不同定义了 RuntimeVisibleAnnotations 和 RuntimeInvisibleAnnotations，他们俩的结构一致， 结构相对比较复杂，结构图如下：

解密Java Class文件不为人知的秘密_第20张图片 RuntimeVisibleAnnotations 的结构图

针对这两类注解，attribute_name_index 指向的是值为 RuntimeVisibleAnnotations 或 RuntimeInvisibleAnnotations 的 CONSTANT_Utf8_info 常量值索引。针对 Runtime 的注解，前面刚提到的的 Deprecated 也是是运行时的，但是他并不包含值。除了它，我还定义了一个包含值的运行时注解，代码如下：

@Retention(RUNTIME)
@Target({METHOD, PARAMETER, FIELD, LOCAL_VARIABLE, ANNOTATION_TYPE})
public @interface IntRange {
    /**
     * Smallest value, inclusive
     */
    long from() default Long.MIN_VALUE;

    /**
     * Largest value, inclusive
     */
    long to() default Long.MAX_VALUE;
}

public class VerboseAttributes {

    @Deprecated
    public int deprecatedVerbose = 1;

    @IntRange(from = 1, to = 10)
    public int value = 32767;
}

这段代码最终生成的字段属性相关的关系如下图所示：

解密Java Class文件不为人知的秘密_第21张图片 字段属性结构

从 Class 结构中的定义中，可以看到，注解里面定义的 Vaule 只能使用常量。终于从底层知道为什么以前写注解的时候，注解值只能为常量了。

14. ParameterAnnotations

在方法中，参数的注解与写到方法上的注解还有一点区别，在《Java虚拟机规范》里面还定义了另外两个 RuntimeVisibleParameterAnnotations 和 RuntimeInvisibleParameterAnnotations，用来描述方法参数的结构， 结构如下图所示：

解密Java Class文件不为人知的秘密_第22张图片 ParameterAnnotations 结构

可以看到，在最上层，会有一个多参数的数组结构，而每一个参数对应的注解信息与前面的 RuntimeVisibleAnnotations 的逻辑一致。在代码中添加如下方法：

@Deprecated
public void setValue(@IntRange(from = 40, to = 60) int value, @IntRange(from = 20, to = 30) int other) {
    this.value = value;
}

最终编译生成的 Class 文件中，方法体中关于注解生成的结构图如下所示：

解密Java Class文件不为人知的秘密_第23张图片 参数注解图形

15. AnnotationDefault

在自定义注解时，某些注解元素会存在默认值，在使用的时候不进行设置就可以直接使用，如下代码中的注解定义：

@Retention(CLASS)
@Target({METHOD, PARAMETER, FIELD, LOCAL_VARIABLE, ANNOTATION_TYPE, TYPE})
public @interface IntRange {
    /**
     * Smallest value, inclusive
     */
    long from() default Long.MIN_VALUE;

    /**
     * Largest value, inclusive
     */
    long to() default Long.MAX_VALUE;
}

在这段代码中， from 指定默认值为 Long.MIN_VALUE，to 指定默认值为 Long.MAX_VALUE 。

根据《Java虚拟机规范》中的定义，注解中的元素默认值会被存储在名为 AnnotationDefault 的注解属性中，上述代码最终生成的结构如下所示：

解密Java Class文件不为人知的秘密_第24张图片 AnnotationDefault 结构

16. TypeAnnotations

在 JDK 8 的版本中，进一步加强了 Java 语言的注解使用范围，添加 TYPE_USE 和 TYPE_PARAMETER 两个注解，在之前，Java 中的注解只能用于类、方法、变量等成员上，而不能用于泛型类型上。加入这两个注解，使得注解可以用于更加丰富的场景中。与其它注解类似，它也分为运行时可见与运行时不可见，即  RuntimeVisibleTypeAnnotations 和 RuntimeInvisibleTypeAnnotations 两个属性。其结构与 RuntimeVisibleAnnotations 略有区别，下图为其结构：

解密Java Class文件不为人知的秘密_第25张图片 TypeAnnotations 的结构

图中加粗的 target_info 也是一个符合类型，有兴趣的同学可以参考《Java 虚拟机规范》。下面列举一个例子，其中 A、B、C、D 四个注解除名称外都一样，具体代码如下：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE_USE})
@interface A {
}
// 此处省略 B 、C 、D 的代码
public @A Map<@B ? extends @C String, @D List<@E Object>> verbose;

最后，生成出来的结构图如下所示：

af02d60d02b119abfa87bb00dfd5c7c4.png 复杂的 TypeAnnotation 结构

17. NestHost 和 NestMembers

NestHost 和 NestMembers 是 Java 11 引入的新特性，用于支持嵌套类的访问控制。在 Java 11 之前，判断一个类是否为嵌套类主要通过查看其访问修饰符和包名来确定。这些属性的引入使得 JVM 能够更好地进行嵌套类的访问控制，从而提高了代码的安全性和性能。先来看一下段示例代码：

public class InnerClassExample {
    public class InnerClassDemo {   
    }
}

上述代码编译后，会产生两个 Class 文件，它们的名称分别为 InnerClassExample.class 和 InnerClassExample。其中属性会出现在InnerClassDemo.class 的属性列表中，用于标识所属的封装类，即此处的 InnerClassExample，它是一个可选属性。而 NestMembers 属性会出现在 InnerClassExample.class 的属性列表中，用于标识一个所有嵌套类的列表，此处示例中仅一个嵌套类，所以将只会有一个值  InnerClassExample$InnerClassDemo，它也是一个可选属性。它们的结构也相对简单，如下表所示，

NestHost：

字段名 数据长度 描述
attribute_name_index 2 字节 属性名常量索引， 指向常量池中 Utf8 的常量，其值为 NestHost
attribute_length 4 字节 常量属性的长度， 此处固定为 0x00000010
host_class_index 2 字节 指向类属性常量值

NestMembers：

字段名 数据长度 描述
attribute_name_index 2 字节 属性名常量索引， 指向常量池中 Utf8 的常量，其值为 NestHost
attribute_length 4 字节 常量属性的长度
number_of_classes 2 字节 嵌套类个数
classes 2 * number_of_classes 字节 指向类属性常量值

将示例中的代码编译后生成如下结构：

解密Java Class文件不为人知的秘密_第26张图片 InnerClassExample 的属性结构 解密Java Class文件不为人知的秘密_第27张图片 InnerClassExample$InnerClassDemo 的属性结构

18. Record

使用String、Integer等类型的时候，这些类型都是不变类，一个不变类具有以下特点：

  1. 定义class时使用final，无法派生子类；

  2. 每个字段使用final，保证创建实例后无法修改任何字段。

假设我们有一个 Person 类，有 name 、age 和 hometown 三个字段 ，如果要把他变成一个不变类，代码会这么写：

public final class Person {
  private final String name;
  private final int age;
  private final String hometown;
  public Person(String name, int age, String hometown) {
    this.name = name;
    this.age = age;
    this.hometown = hometown;
  }
  
  public String name() {
    return this.name;
  }
  //... 省略部分代码
}

代码写起来还比较多，从 Java 14 开始，引入了一种新的数据类型，Record 类。定义类的时候，使用 record 关键字即可，代码如下：

public record Person(String name, int age, String hometown) {
}

此类与前面手写的那个类一样，字段都会标记成 final ，编译器还自动为我们创建了构造方法，和字段名同名的方法，以及覆写toString()、equals()和hashCode()方法。使用一行代码就实现了一个不变类。

此类编译会生成 Record 属性，结构如下：

解密Java Class文件不为人知的秘密_第28张图片 属性字段格式

上面的示例代码，编译后，生成的属性 Record 的结构如下图所示：

解密Java Class文件不为人知的秘密_第29张图片 Record 属性结构

19. MethodParameters

MethodParameters 是在 JDK 8 时新加入到 Class 文件格式中的，字段是放到方法块中的属性字段里面，是一个变长属性。MethodParameters 的作用是记录方法的各个形参名称和信息。

在虚拟机中，执行代码时，给参数用什么名字对计算机来说没有任何区别。因此在 JDK 8 之前，基于存储空间考虑，Class 文件中默认并不存储任何方法参数名称。但没有名字就会引起如下问题：

解密Java Class文件不为人知的秘密_第30张图片 左图 Class 文件包含 MethodParameters, 右图不包含

上图中右边部分是不带参数的反编译结果，方法中的参数全部变成了 var1、var2 中这种无用的字段，那别人在调用的时候，就必须得通过 JavaDoc 才能知道每一个参数的含义，使用起来很不方便。

在我本地 IDE 编译时，默认输出的代码依然是不带 MethodParameters 属性的。在编译时需要添加 -parameters 参数，示例命令如下：

javac -parameters  MethodParameter.java

当然，在 IntelliJ IDEA 中也可以添加对应参数，如下图所示：

解密Java Class文件不为人知的秘密_第31张图片 添加参数示例

通过上述设置，编译出来的代码可以生成 MethodParameters 参数了。在来看一下它的结构：

字段名 数据长度 描述
attribute_name_index 2 字节 属性名常量索引， 指向值为 MethodParameters
attribute_length 4 字节 常量属性的长度
parameters_count 1 字节 参数个数
parameters parameters_count * 4 字节 参数字段信息，见下表

其中 parameters 是一个数组，里面可能会包含有多个参数，每一个参数中包含有其名字的信息和访问标识，结构如下图所示：

字段名 数据长度 描述
name_index 2 字节 参数名称索引， 可能为0，非0时指向常量池中字段名字
access_flags 2 字节 访问标识，ACC_FINAL、ACC_SYNTHETIC、ACC_MANDATED

针对刚提到的代码 public MethodParameter(String name, int age, String hometown) {} 生成后的结构如下所示：

解密Java Class文件不为人知的秘密_第32张图片 Method Parameters 结构

20. BootstrapMethods

BootstrapMethods 属性是在 JDK 7 时增加的，用于保存 invokedynamic 指令引用的引导方法限定符。在 《Java虚拟机规范》 中规定，如果常量池中出现 CONSTANT_InvokeDynamic_info 类型的常量时，那么类文件的属性中必须存在 BootstrapMethod 属性。BootstrapMethod  结构如下：

字段名 数据长度 描述
attribute_name_index 2 个字节 属性名常量池索引，指向值为 BootstrapMethods
attribute_length 4 个字节 属性长度
num_bootstrap_methods 2 个字节 引导方法数量
bootstrap_methods num_bootstrap_methods * 2字节 引导方法数组

其中，num_bootstrap_methods 表示该属性中引导方法的数量，bootstrap_methods 数组中包含了所有的引导方法。每个引导方法都包含一个引导方法引用和一组引导方法参数。引导方法的结构如下：

字段名 数据长度 描述
bootstrap_method_ref 2 字节 对常量池中的 CONSTANT_MethodHandle_info 或 CONSTANT_MethodType_info 常量的引用
num_bootstrap_arguments 2 字节 引导方法的参数数量
bootstrap_arguments 2 * num_bootstrap_arguments 字节 引导方法的参数列表，每个元素都是对常量池中的一个常量的引用

其中，bootstrap_method_ref 是对常量池中的 CONSTANT_MethodHandle_info 或 CONSTANT_MethodType_info 常量的引用。num_bootstrap_arguments 是引导方法的参数数量，bootstrap_arguments 是引导方法的参数列表，每个元素都是对常量池中的一个常量的引用。

下面是我写的一段代码，用来查看  BootstrapMethods 的最终结构：

public void print() {
    Runnable r = () -> System.out.println("Hello world");
    r.run();
}

最终生成的结构图如下：

解密Java Class文件不为人知的秘密_第33张图片 BootstrapMethods 的结构图

21. 模块化相关属性

JDK 9 发布了一个非常重要的功能，那就是 Java 的模块化，模块化描述文件 module-info.java 最终也会编译成独立的 Class 文件来存储，Class 文件属性中扩展了 Module 、ModulePackages 和 ModuleMainClass  三个属性用于支持 Java 模块化的相关功能。其属性结构也相对较复杂，但模块化功能在开发中基本没有使用过，在此也不过多赘述，其结构信息，如你感兴趣，可以去查阅 《Java 虚拟机规范》。

22. PermittedSubclasses

在 Java 17 正式发布了 Sealed Classes， 翻译为密封类、封闭类。代表该类/接口是一个封闭的类/接口，只有许可的类/接口才能继承或实现该类/接口。如果是 sealed 修饰的类，就会有 PermittedSubclasses 属性。

在没有封闭类之前，Java 控制类继承有两种方式：

  1. 用关键字 final 修饰类，类就成了终态类，无法被继承；比如我们经常使用的 String 类

  2. package-private 的类， 即非 public 类，这样只有同包下的类才能继承

针对package-private 的类， 还是能被继承后并进行扩展，而封闭类能够提供了更精细粒度的可扩展性。 PermittedSubclasses 属性就是用来记录这些信息的：

字段名 数据长度 说明
attribute_name_index 2 个字节 属性名索引
attribute_length 4 个字节 属性长度
number_of_classes 2 个字节 允许的子类数量
classes number_of_classes * 2 字节 子类集合

其中，number_of_classes 表示该类允许被继承的类的个数，classes 数组中包含了所有的指定的继承类，里面存储的为常量池指针，指向的为 CONSTANT_Class_info 字段。

下面是我写的一段代码，用来查看  PermittedSubclasses 的最终结构：

public sealed interface SealedClassInterface 
  permits SealedClassInterfaceImpl1, SealedClassInterfaceImpl2 {
}

最终生成的结构图如下：

解密Java Class文件不为人知的秘密_第34张图片 PermittedSubclasses 属性结构

你可能感兴趣的:(java,jvm,开发语言)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
  • 常见的 JVM 调优方法有哪些？ 爪哇天下 jvm
    常见的JVM调优方法有哪些？可以具体到调整哪个参数，调成什么值？对年轻代的EdenSurvivor的比例进行配置-XX:SurvivorRatio=8：表示设置2个Survivor区：1个Eden区的大小比值为2:8，这意味着Survivor区占整个年轻代的1/5，这个参数默认为8如果经常性的SurvivorTo放不下YGC的剩余的对象时候，可以适当的调整比例常用的CMS收集器：设置回收阈值，需要
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 切换淘宝最新npm镜像源是 hai40587 npm前端node.js
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
  • 如何用ruby来写hadoop的mapreduce并生成jar包 wudixiaotie mapreduce
    ruby来写hadoop的mapreduce，我用的方法是rubydoop。怎么配置环境呢： 1.安装rvm：     不说了 网上有 2.安装ruby：     由于我以前是做ruby的，所以习惯性的先安装了ruby，起码调试起来比jruby快多了。 3.安装jruby：     rvm install jruby然后等待安
  • java编程思想 -- 访问控制权限 百合不是茶 java访问控制权限单例模式
    访问权限是java中一个比较中要的知识点,它规定者什么方法可以访问,什么不可以访问   一:包访问权限;   自定义包: package com.wj.control; //包 public class Demo { //定义一个无参的方法 public void DemoPackage(){ System.out.println("调用
  • [生物与医学]请审慎食用小龙虾 comsci 生物
         现在的餐馆里面出售的小龙虾,有一些是在野外捕捉的,这些小龙虾身体里面可能带有某些病毒和细菌,人食用以后可能会导致一些疾病,严重的甚至会死亡.....      所以,参加聚餐的时候,最好不要点小龙虾...就吃养殖的猪肉,牛肉,羊肉和鱼,等动物蛋白质     
  • org.apache.jasper.JasperException: Unable to compile class for JSP: 商人shang maven2.2jdk1.8
    环境： jdk1.8    maven  tomcat7-maven-plugin  2.0 原因： tomcat7-maven-plugin  2.0 不知吃 jdk 1.8，换成 tomcat7-maven-plugin  2.2就行，即     <plugin>
  • 你的垃圾你处理掉了吗?GC oloz GC
    前序:本人菜鸟，此文研究学习来自网络，各位牛牛多指教　 1.垃圾收集算法的核心思想 　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。 　　垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别
  • shiro 和 SESSSION 杨白白 shiro
    shiro 在web项目里默认使用的是web容器提供的session，也就是说shiro使用的session是web容器产生的，并不是自己产生的，在用于非web环境时可用其他来源代替。在web工程启动的时候它就和容器绑定在了一起，这是通过web.xml里面的shiroFilter实现的。通过session.getSession()方法会在浏览器cokkice产生JESSIONID，当关闭浏览器，此
  • 移动互联网终端 淘宝客如何实现盈利 小桔子 移動客戶端淘客淘寶App
           2012年淘宝联盟平台为站长和淘宝客带来的分成收入突破30亿元，同比增长100%。而来自移动端的分成达1亿元，其中美丽说、蘑菇街、果库、口袋购物等App运营商分成近5000万元。 可以看出，虽然目前阶段PC端对于淘客而言仍旧是盈利的大头，但移动端已经呈现出爆发之势。而且这个势头将随着智能终端(手机，平板)的加速普及而更加迅猛
  • wordpress小工具制作 aichenglong wordpress小工具
    wordpress 使用侧边栏的小工具，很方便调整页面结构 小工具的制作过程 1 在自己的主题文件中新建一个文件夹(如widget)，在文件夹中创建一个php(AWP_posts-category.php) 小工具是一个类,想侧边栏一样，还得使用代码注册，他才可以再后台使用，基本的代码一层不变 <?php class AWP_Post_Category extends WP_Wi
  • JS微信分享 AILIKES js
    // 所有功能必须包含在 WeixinApi.ready 中进行    WeixinApi.ready(function(Api) {        // 微信分享的数据            var wxData = {       &nb
  • 封装探讨 百合不是茶 JAVA面向对象 封装
    //封装   属性 方法 将某些东西包装在一起，通过创建对象或使用静态的方法来调用，称为封装；封装其实就是有选择性地公开或隐藏某些信息，它解决了数据的安全性问题，增加代码的可读性和可维护性   在 Aname类中申明三个属性，将其封装在一个类中：通过对象来调用   例如   1： //属性 将其设为私有 姓名 name 可以公开
  • jquery radio/checkbox change事件不能触发的问题 bijian1013 JavaScriptjquery
    我想让radio来控制当前我选择的是机动车还是特种车，如下所示：  <html> <head> <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript"><
  • AngularJS中安全性措施 bijian1013 JavaScriptAngularJS安全性XSRFJSON漏洞
            在使用web应用中，安全性是应该首要考虑的一个问题。AngularJS提供了一些辅助机制，用来防护来自两个常见攻击方向的网络攻击。 一.JSON漏洞         当使用一个GET请求获取JSON数组信息的时候（尤其是当这一信息非常敏感，
  • [Maven学习笔记九]Maven发布web项目 bit1129 maven
    基于Maven的web项目的标准项目结构 user-project     user-core     user-service     user-web        src      
  • 【Hive七】Hive用户自定义聚合函数(UDAF) bit1129 hive
    用户自定义聚合函数，用户提供的多个入参通过聚合计算(求和、求最大值、求最小值)得到一个聚合计算结果的函数。 问题：UDF也可以提供输入多个参数然后输出一个结果的运算，比如加法运算add(3，5)，add这个UDF需要实现UDF的evaluate方法,那么UDF和UDAF的实质分别究竟是什么？   Double evaluate(Double a, Double b)  
  • 通过 nginx-lua 给 Nginx 增加 OAuth 支持 ronin47
    前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGeek 在过去几年中取得了发展，我们已经积累了不少针对各种任务的不同管理接口。我们通常为新的展示需求创建新模块，比如我们自己的博客、图表等。我们还定期开发内部工具来处理诸如部署、可视化操作及事件处理等事务。在处理这些事务中，我们使用了几个不同的接口来认证： &n
  • 利用tomcat-redis-session-manager做session同步时自定义类对象属性保存不上的解决方法 bsr1983 session
    在利用tomcat-redis-session-manager做session同步时，遇到了在session保存一个自定义对象时，修改该对象中的某个属性，session未进行序列化，属性没有被存储到redis中。 在 tomcat-redis-session-manager的github上有如下说明： Session Change Tracking As noted in the &qu
  • 《代码大全》表驱动法-Table Driven Approach-1 bylijinnan java算法
    关于Table Driven Approach的一篇非常好的文章： http://www.codeproject.com/Articles/42732/Table-driven-Approach package com.ljn.base; import java.util.Random; public class TableDriven { public
  • Sybase封锁原理 chicony Sybase
           昨天在操作Sybase IQ12.7时意外操作造成了数据库表锁定，不能删除被锁定表数据也不能往其中写入数据。由于着急往该表抽入数据，因此立马着手解决该表的解锁问题。     无奈此前没有接触过Sybase IQ12.7这套数据库产品，加之当时已属于下班时间无法求助于支持人员支持，因此只有借助搜索引擎强大的
  • java异常处理机制 CrazyMizzz java
    java异常关键字有以下几个，分别为 try catch final throw throws 他们的定义分别为 try：    Opening exception-handling statement. catch：  Captures the exception. finally： Runs its code before terminating
  • hive 数据插入DML语法汇总 daizj hiveDML数据插入
    Hive的数据插入DML语法汇总1、Loading files into tables语法：1) LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename [PARTITION (partcol1=val1, partcol2=val2 ...)]解释：1)、上面命令执行环境为hive客户端环境下： hive>l
  • 工厂设计模式 dcj3sjt126com 设计模式
      使用设计模式是促进最佳实践和良好设计的好办法。设计模式可以提供针对常见的编程问题的灵活的解决方案。 工厂模式 工厂模式（Factory）允许你在代码执行时实例化对象。它之所以被称为工厂模式是因为它负责“生产”对象。工厂方法的参数是你要生成的对象对应的类名称。 Example #1 调用工厂方法（带参数） <?phpclass Example{ 
  • mysql字符串查找函数 dcj3sjt126com mysql
      FIND_IN_SET(str,strlist) 假如字符串str 在由N 子链组成的字符串列表strlist 中，则返回值的范围在1到 N 之间。一个字符串列表就是一个由一些被‘,’符号分开的自链组成的字符串。如果第一个参数是一个常数字符串，而第二个是type SET列，则   FIND_IN_SET() 函数被优化，使用比特计算。如果str不在strlist 或st
  • jvm内存管理 easterfly jvm
    一、JVM堆内存的划分 分为年轻代和年老代。年轻代又分为三部分：一个eden,两个survivor。 工作过程是这样的：e区空间满了后，执行minor gc，存活下来的对象放入s0, 对s0仍会进行minor gc，存活下来的的对象放入s1中，对s1同样执行minor gc，依旧存活的对象就放入年老代中； 年老代满了之后会执行major gc，这个是stop the word模式，执行
  • CentOS-6.3安装配置JDK-8 gengzg centos
    JAVA_HOME=/usr/java/jdk1.8.0_45 JRE_HOME=/usr/java/jdk1.8.0_45/jre PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib export JAVA_HOME
  • 【转】关于web路径的获取方法 huangyc1210 Web路径
    假定你的web application 名称为news,你在浏览器中输入请求路径：  http://localhost:8080/news/main/list.jsp  则执行下面向行代码后打印出如下结果：  1、 System.out.println(request.getContextPath()); //可返回站点的根路径。也就是项
  • php里获取第一个中文首字母并排序 远去的渡口 数据结构PHP
    很久没来更新博客了，还是觉得工作需要多总结的好。今天来更新一个自己认为比较有成就的问题吧。 最近在做储值结算，需求里结算首页需要按门店的首字母A-Z排序。我的数据结构原本是这样的： Array ( [0] => Array ( [sid] => 2885842 [recetcstoredpay] =&g
  • java内部类 hm4123660 java内部类匿名内部类成员内部类方法内部类
         　在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。内部类可以间接解决多继承问题,可以使用内部类继承一个类，外部类继承一个类，实现多继承。      &nb
  • Caused by: java.lang.IncompatibleClassChangeError: class org.hibernate.cfg.Exten zhb8015
    maven pom.xml关于hibernate的配置和异常信息如下，查了好多资料，问题还是没有解决。只知道是包冲突，就是不知道是哪个包....遇到这个问题的分享下是怎么解决的。。   maven pom:   <dependency> <groupId>org.hibernate</groupId> <ar
  • Spark 性能相关参数配置详解－任务调度篇 Stark_Summer sparkcachecpu任务调度yarn
    随着Spark的逐渐成熟完善, 越来越多的可配置参数被添加到Spark中来, 本文试图通过阐述这其中部分参数的工作原理和配置思路, 和大家一起探讨一下如何根据实际场合对Spark进行配置优化。   由于篇幅较长，所以在这里分篇组织，如果要看最新完整的网页版内容，可以戳这里：http://spark-config.readthedocs.org/，主要是便
  • css3滤镜 wangkeheng htmlcss
    经常看到一些网站的底部有一些灰色的图标，鼠标移入的时候会变亮，开始以为是js操作src或者bg呢，搜索了一下，发现了一个更好的方法：通过css3的滤镜方法。 html代码： <a href='' class='icon'><img src='utv.jpg' /></a> css代码： .icon{-webkit-filter: graysc
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他