class文件格式中的属性信息

最新推荐文章于 2022-04-08 22:17:49 发布
最新推荐文章于 2022-04-08 22:17:49 发布
阅读量308 收藏
点赞数
文章标签： java 数据结构与算法
原文链接：https://my.oschina.net/roccn/blog/1552792
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

附加属性（Attributes）被用于ClassFile, field_info, method_info，Code_attribute结构中。

数据结构：

attribute_info {
    u2 attribute_name_index;        //unsigned 16-bit ->  CONSTANT_Utf8_info
    u4 attribute_length;            //bytes
    u1 info[attribute_length];
}

aadfadfadfadfadf

属性 | class版本 | Java SE版本 | 位置 | 类型 | 作用 | 说明 ---|---|---|---|--|---|---- ConstantValue | 45.3 | 1.0.2 | field_info | F | 用于常量初始化赋值,如没有常量字段则忽略 | 必有 Code | 45.3 | 1.0.2 | method_info | V | JVM指令，包括构造器 | 必有 StackMapTable | 50.0 | 6 | Code | V | 在运行时，提供类型检查（可直接通过table，而不需要类型推测） | 必有 Exceptions | 45.3 | 1.0.2 | method_info | V | 方法可能抛出的异常（checked） | 必有 InnerClasses | 45.3 | 1.0.2 | ClassFile | V | 内部类 | 可选，JavaSE EnclosingMethod | 49.0 | 5.0 | ClassFile | F | 仅当局部类、匿名内部类 | 可选，JavaSE Synthetic | 45.3 | 1.1 | ClassFile, field_info, method_info | F | 非源码/编译器产生（不包括实例初始化方法；类/接口初始化方法；Enum.values();Enum.valueOf()）|可选，JavaSE Signature | 49.0 | 5.0 | ClassFile, field_info, method_info | F | 签名；主要用于反射/DEBUG/{B C D F I J S Z;V;...} | 可选，JavaSE SourceFile | 45.3 | 1.0.2 | ClassFile | F | 最多一个 | 可选，JavaSE SourceDebugExtension | 49.0 | 5.0 | ClassFile | V | 可选，最多一个；扩展的DEBUG信息 | 可选，元数据，JavaSE LineNumberTable | 45.3 | 1.0.2 | Code | V | code对应的源码行数 | 可选，JavaSE LocalVariableTable | 45.3 | 1.0.2 | Code | V | 在运行期方便的跟踪局部变量/参数（槽位Slot分布） | 可选，JavaSE LocalVariableTypeTable | 49.0 | 5.0 | Code | V | 在运行期方便的跟踪局部变量/参数 | 可选，JavaSE Deprecated | 45.3 | 1.1 | ClassFile, field_info, method_info | F | 标记性 | 可选，元数据，JavaSE RuntimeVisibleAnnotations | 49.0 | 5.0 | ClassFile,field_info,method_info | V | 声明注解运行时可见 | 可选，元数据，JavaSE RuntimeInvisibleAnnotations | 49.0 | 5.0 | ClassFile,field_info,method_info | V | 声明注解运行时不可见 | 可选，元数据，JavaSE RuntimeVisibleParameterAnnotations | 49.0 | 5.0 | method_info | V | 运行时，参数的注解可见 | 可选，元数据，JavaSE RuntimeInvisibleParameterAnnotations | 49.0 | 5.0 | method_info | V | 运行时，参数的注解不可见 | 可选，元数据，JavaSE RuntimeVisibleTypeAnnotations | 52.0 | 8 | ClassFile,field_info,method_info, Code | V | 用于声明式/表达式的运行时可见注解 | 可选，元数据，JavaSE RuntimeInvisibleTypeAnnotations | 52.0 | 8 | ClassFile,field_info,method_info, Code | V | 用于声明式/表达式的运行时不可见注解 | 可选，元数据，JavaSE AnnotationDefault | 49.0 | 5.0 | method_info | V | 注解默认值（default关键字） | 可选，元数据，JavaSE BootstrapMethods | 51.0 | 7 | ClassFile | V | 记录动态方法信息（被invokedynamic指令调用）；需要与CONSTANT_InvokeDynamic_info对应 | 必有 MethodParameters | 52.0 | 8 | method_info | V | 用于记录表达式形式的方法参数 | 可选，元数据，JavaSE Module | 53.0 | 9 | ClassFile | V | 用于标记JAVA 9的模块 | 可选，元数据，JavaSE ModulePackages | 53.0 | 9 | ClassFile | V | 包括所有exported或opened的Module属性 | 可选，元数据，JavaSE ModuleMainClass | 53.0 | 9 | ClassFile | F | 指明Module的主类 | 可选，元数据，JavaSE

  • ConstantValue
ConstantValue_attribute {
    u2 attribute_name_index;        //CONSTANT_Utf8_info
    u4 attribute_length;
    u2 constantvalue_index;         //constant_pool中的一个值
}

Constant value attribute types：

Field TypeEntry Type
longCONSTANT_Long
floatCONSTANT_Float
doubleCONSTANT_Double
int, short, char, byte, booleanCONSTANT_Integer
StringCONSTANT_String
  • Code
Code_attribute {
    u2 attribute_name_index;                        // CONSTANT_Utf8_info -> constant_pool -> "Code"
    u4 attribute_length;                            // excluding the initial six bytes
    u2 max_stack;                                   
    u2 max_locals;                                  // local variables/parameters/long or double is max_locals - 2
    u4 code_length;                                 // (0,65536)
    u1 code[code_length];                           // 读入内存后可按字节寻址（byte-addressable），
                                                    // 数组起始（第一个字节）位置按4字节对齐
                                                    //（tableswitch and lookupswitch 32-bit offsets will be 4-byte aligned）
    u2 exception_table_length;                      // number of entries in the exception_table table
    { 
        u2 start_pc;                                // ranges in the code array [start_pc, end_pc)
        u2 end_pc;                                  // ranges in the code array [start_pc, end_pc)
        u2 handler_pc;                              // 
        u2 catch_type;                              // CONSTANT_Class_info -> constant_pool
                                                    // zero, => finally
    } exception_table[exception_table_length];  
    u2 attributes_count;                            // 
    attribute_info attributes[attributes_count];    // optional
}
  • StackMapTable
    • 栈图，其方法的code属性中存储了局部变量和操作数的类型验证以及字节码的偏移量
    • 必须准确知道每个字节码指令对应的局部变量和操作数栈的类型
    • 因为Java7在编译的时期做了一些验证期间要做的事情，那就是类型检查，也就是栈图包含的内容
    • 代码跳转，分支，goto时，对变量和指令进行校验
    • 第一个隐式
StackMapTable_attribute {
    u2 attribute_name_index;                        // CONSTANT_Utf8_info -> constant_pool -> "StackMapTable"
    u4 attribute_length;                            // excluding the initial six bytes
    u2 number_of_entries;                           // the number of stack_map_frame entries in the entries table
    stack_map_frame entries[number_of_entries];     // stack map frame
}

union verification_type_info {
    Top_variable_info;
    Integer_variable_info;
    Float_variable_info;
    Long_variable_info;
    Double_variable_info;
    Null_variable_info;
    UninitializedThis_variable_info;
    Object_variable_info;
    Uninitialized_variable_info;
}

Top_variable_info {
    u1 tag = ITEM_Top; /* 0 */
}

Integer_variable_info {
    u1 tag = ITEM_Integer; /* 1 */
}

Float_variable_info {
    u1 tag = ITEM_Float; /* 2 */
}

Double_variable_info {
    u1 tag = ITEM_Double; /* 3 */
}

Long_variable_info {
    u1 tag = ITEM_Long; /* 4 */
}

Null_variable_info {
    u1 tag = ITEM_Null; /* 5 */
}

UninitializedThis_variable_info {
    u1 tag = ITEM_UninitializedThis; /* 6 */
}

Object_variable_info {
    u1 tag = ITEM_Object; /* 7 */
    u2 cpool_index;
}

Uninitialized_variable_info {
    u1 tag = ITEM_Uninitialized; /* 8 */
    u2 offset;
}

frame_type:

union stack_map_frame {
    same_frame;                                     // [0-63]
                                                    // 表示与前一个栈帧有着同样的局部变量，且前一个操作栈为空
                                                    // offset_delta = frame_type
    same_locals_1_stack_item_frame;                 // [64, 127] 
                                                    // 表示与前一个栈帧有着同样的局部变量，且前一个操作栈有一个实体
                                                    // offset_delta = frame_type - 64
    same_locals_1_stack_item_frame_extended;        // 247
                                                    // 表示与前一个栈帧有着同样的局部变量，且前一个操作栈有一个实体
                                                    // 与上一个不同的是，偏移量明确给出
    chop_frame;                                     // [248-250]
                                                    // 表示与前一个栈帧除了最后K个变量不同，其他局部变量不变，且操作栈为空
                                                    // K = 251 - frame_type
    same_frame_extended;                            // 251
                                                    // 表示与前一个栈帧有着同样的局部变量，且操作栈为空
    append_frame;                                   // [252-254]
                                                    // 表示与前一个栈帧除了K个变量不同，其他局部变量不变，且操作栈为空
                                                    // K = frame_type - 251
    full_frame;                                     // 255
                                                    //
}

same_frame {
    u1 frame_type = SAME; /* 0-63 */
}

same_locals_1_stack_item_frame {
    u1 frame_type = SAME_LOCALS_1_STACK_ITEM; /* 64-127 */
    verification_type_info stack[1];
}

same_locals_1_stack_item_frame_extended {
    u1 frame_type = SAME_LOCALS_1_STACK_ITEM_EXTENDED; /* 247 */
    u2 offset_delta;
    verification_type_info stack[1];
}

chop_frame {
    u1 frame_type = CHOP; /* 248-250 */
    u2 offset_delta;
}

same_frame_extended {
    u1 frame_type = SAME_FRAME_EXTENDED; /* 251 */
    u2 offset_delta;
}

append_frame {
    u1 frame_type = APPEND; /* 252-254 */
    u2 offset_delta;
    verification_type_info locals[frame_type - 251];        // locals[M+1] represents local variable N+1 / N+2（Long_variable_info or Double_variable_info）
}

full_frame {
    u1 frame_type = FULL_FRAME; /* 255 */
    u2 offset_delta;
    u2 number_of_locals;
    verification_type_info locals[number_of_locals];        // locals[M+1] represents local variable N+1 / N+2（Long_variable_info or Double_variable_info）
    u2 number_of_stack_items;
    verification_type_info stack[number_of_stack_items];    // stack[M+1] represents stack entry N+1 / N+2（Long_variable_info or Double_variable_info）
}
  • Exceptions
Exceptions_attribute {
    u2 attribute_name_index;                            // CONSTANT_Utf8_info -> constant_pool -> "Exceptions"
    u4 attribute_length;                                // excluding the initial six bytes 
    u2 number_of_exceptions;                            // the number of entries in the exception_index_table
    u2 exception_index_table[number_of_exceptions];     // CONSTANT_Class_info -> constant_pool
}
  • InnerClasses
InnerClasses_attribute {
    u2 attribute_name_index;                    // CONSTANT_Utf8_info -> constant_pool -> "InnerClasses"
    u4 attribute_length;                        // excluding the initial six bytes
    u2 number_of_classes;                       // the number of entries in the classes array
    { 
        u2 inner_class_info_index;              // CONSTANT_Class_info -> constant_pool
        u2 outer_class_info_index;              // zero => [anonymous class , local class ,top-level class or interface]
                                                // CONSTANT_Class_info - constant_pool
        u2 inner_name_index;                    // zero => anonymous class
                                                // anonymous class -> constant_pool
        u2 inner_class_access_flags;            // Table 4.7.6-A. Nested class access and property flags
    } classes[number_of_classes];               // 
}
Flag NameFlag NameInterpretation
ACC_PUBLIC0x0001public
ACC_PRIVATE0x0002private
ACC_PROTECTED0x0004protected
ACC_STATIC0x0008static
ACC_FINAL0x0010final
ACC_INTERFACE0x0200interface
ACC_ABSTRACT0x0400abstract
ACC_SYNTHETIC0x1000非源码提供
ACC_ANNOTATION0x2000注解类型
ACC_ENUM0x4000枚举类型
  • EnclosingMethod
EnclosingMethod_attribute {
    u2 attribute_name_index;        // CONSTANT_Utf8_info -> constant_pool -> "EnclosingMethod"
    u4 attribute_length;            // 4
    u2 class_index;                 // CONSTANT_Utf8_info -> constant_pool
    u2 method_index;                // zero => current class is not immediately enclosed by a method or constructor
                                    // CONSTANT_NameAndType_info -> constant_pool
}
  • Synthetic
Synthetic_attribute {
    u2 attribute_name_index;        // CONSTANT_Utf8_info -> constant_pool -> "Synthetic" 
    u4 attribute_length;            // must be zero
}
  • Signature
Signature_attribute {
    u2 attribute_name_index;        // CONSTANT_Utf8_info -> constant_pool -> "Signature" 
    u4 attribute_length;            // 2
    u2 signature_index;             // CONSTANT_Utf8_info -> constant_pool
}

MethodSignature:
[TypeParameters] ( {JavaTypeSignature} ) Result {ThrowsSignature}
  • SourceFile
SourceFile_attribute {
    u2 attribute_name_index;        // CONSTANT_Utf8_info -> constant_pool -> "SourceFile" 
    u4 attribute_length;            // 2
    u2 sourcefile_index;            // CONSTANT_Utf8_info -> constant_pool
}
  • SourceDebugExtension
SourceDebugExtension_attribute {
    u2 attribute_name_index;                // CONSTANT_Utf8_info -> constant_pool -> "SourceDebugExtension"
    u4 attribute_length;                    // excluding the initial six bytes
    u1 debug_extension[attribute_length];   // modified UTF-8 string
}
  • LineNumberTable
LineNumberTable_attribute {
    u2 attribute_name_index;                        // CONSTANT_Utf8_info -> constant_pool -> "LineNumberTable"
    u4 attribute_length;                            // excluding the initial six bytes
    u2 line_number_table_length;                    
    {
        u2 start_pc;                                // 
        u2 line_number;
    } line_number_table[line_number_table_length];
}
  • LocalVariableTable
    • 可以有多个，不要求顺序
LocalVariableTable_attribute {
    u2 attribute_name_index;                                // CONSTANT_Utf8_info -> constant_pool -> "LocalVariableTable"
    u4 attribute_length;                                    // excluding the initial six bytes
    u2 local_variable_table_length;                         // the number of entries in the local_variable_table array
    { 
        u2 start_pc;                                        // 局部变量的作用域：[start_pc, start_pc + length)
        u2 length;
        u2 name_index;                                      // CONSTANT_Utf8_info -> constant_pool
        u2 descriptor_index;                                // CONSTANT_Utf8_info -> constant_pool
        u2 index;                                           // 槽位，遇到long / double 顺延 + 1
    } local_variable_table[local_variable_table_length];
}
  • LocalVariableTypeTable
    • 可以有多个，不要求顺序
LocalVariableTypeTable_attribute {
    u2 attribute_name_index;                                                // CONSTANT_Utf8_info -> constant_pool -> "LocalVariableTypeTable"
    u4 attribute_length;                                                    // excluding the initial six bytes
    u2 local_variable_type_table_length;
    { 
        u2 start_pc;                                                        //
        u2 length;
        u2 name_index;
        u2 signature_index;                                                 // CONSTANT_Utf8_info -> constant_pool
        u2 index;
    } local_variable_type_table[local_variable_type_table_length];
}
  • Deprecated
Deprecated_attribute {
    u2 attribute_name_index;        // CONSTANT_Utf8_info -> constant_pool -> "Deprecated"
    u4 attribute_length;            // must be zero
}
  • RuntimeVisibleAnnotations
RuntimeVisibleAnnotations_attribute {   
    u2 attribute_name_index;                        // CONSTANT_Utf8_info -> constant_pool -> "RuntimeVisibleAnnotations"
    u4 attribute_length;                            // excluding the initial six bytes
    u2 num_annotations;                             // 
    annotation annotations[num_annotations];        // annotation结构
}

annotation结构：

annotation {
    u2 type_index;                                      // CONSTANT_Utf8_info -> constant_pool -> descriptor
    u2 num_element_value_pairs;
    { 
        u2 element_name_index;                          // CONSTANT_Utf8_info -> constant_pool
        element_value value;                            // element_value结构
    } element_value_pairs[num_element_value_pairs];
}

element_value结构：

element_value {
    u1 tag;                                         // single ASCII
                                                    // Table 4.7.16.1-A
    union {
        u2 const_value_index;                       // CONSTANT_Utf8_info -> constant_pool
        { 
            u2 type_name_index;                     // CONSTANT_Utf8_info -> constant_pool
            u2 const_name_index;
        } enum_const_value;
        u2 class_info_index;                        // CONSTANT_Utf8_info -> constant_pool -> descriptor
                                                    // BaseType character
                                                    // void : V
        annotation annotation_value;                // nested annotation
        { 
            u2 num_values;
            element_value values[num_values];
        } array_value;                              // element-value pair
    } value;
}

Table 4.7.16.1-A. Interpretation of tag values as types

tag ItemTypevalue ItemConstant Type
Bbyteconst_value_indexCONSTANT_Integer
Ccharconst_value_indexCONSTANT_Integer
Ddoubleconst_value_indexCONSTANT_Double
Ffloatconst_value_indexCONSTANT_Float
Iintconst_value_indexCONSTANT_Integer
Jlongconst_value_indexCONSTANT_Long
Sshortconst_value_indexCONSTANT_Integer
Zbooleanconst_value_indexCONSTANT_Integer
sStringconst_value_indexCONSTANT_Utf8
eEnumtypeenum_const_value
cClassclass_info_indexNot applicable
@Annotationtypeannotation_value
[Arraytypearray_value
  • RuntimeInvisibleAnnotations
    • 类似RuntimeVisibleAnnotations
RuntimeInvisibleAnnotations_attribute {
    u2 attribute_name_index;
    u4 attribute_length;
    u2 num_annotations;
    annotation annotations[num_annotations];
}
  • RuntimeInvisibleParameterAnnotations
RuntimeInvisibleParameterAnnotations_attribute {
    u2 attribute_name_index;                        // CONSTANT_Utf8_info -> constant_pool -> "RuntimeInvisibleParameterAnnotations"
    u4 attribute_length;
    u1 num_parameters;
    { 
        u2 num_annotations;
        annotation annotations[num_annotations];
    } parameter_annotations[num_parameters];
}
  • RuntimeVisibleTypeAnnotations
RuntimeVisibleTypeAnnotations_attribute {
    u2 attribute_name_index;                        // CONSTANT_Utf8_info -> constant_pool -> "RuntimeVisibleTypeAnnotations"
    u4 attribute_length;
    u2 num_annotations;
    type_annotation annotations[num_annotations];   // type_annotation结构
}

type_annotation结构：

type_annotation {
    u1 target_type;                                         // Table 4.7.20-A 
                                                            // Table 4.7.20-B
                                                            // Table 4.7.20-C 
    union {
        type_parameter_target;
        supertype_target;
        type_parameter_bound_target;
        empty_target;
        formal_parameter_target;
        throws_target;
        localvar_target;
        catch_target;
        offset_target;
        type_argument_target;
    } target_info;                                          // target_info结构
    type_path target_path;                                  // type_path结构
    u2 type_index;
    u2 num_element_value_pairs;
    { 
        u2 element_name_index;
        element_value value;
    } element_value_pairs[num_element_value_pairs];
}

target_info结构：

type_parameter_target {
    u1 type_parameter_index;
}

supertype_target {
    u2 supertype_index;
}

type_parameter_bound_target {
    u1 type_parameter_index;
    u1 bound_index;
}

empty_target {
}

formal_parameter_target {
    u1 formal_parameter_index;
}

throws_target {
    u2 throws_type_index;
}

localvar_target {
    u2 table_length;
    {
        u2 start_pc;
        u2 length;
        u2 index;
    } table[table_length];
}

catch_target {
    u2 exception_table_index;
}

offset_target {
    u2 offset;
}

type_argument_target {
    u2 offset;
    u1 type_argument_index;
}

type_path结构：

type_path {
    u1 path_length;
    { 
        u1 type_path_kind;              // Table 4.7.20.2-A
        u1 type_argument_index;
    } path[path_length];
}
  • RuntimeInvisibleTypeAnnotations
RuntimeInvisibleTypeAnnotations_attribute {
    u2 attribute_name_index;
    u4 attribute_length;
    u2 num_annotations;
    type_annotation annotations[num_annotations];
}
  • AnnotationDefault
AnnotationDefault_attribute {
    u2 attribute_name_index;        // CONSTANT_Utf8_info -> constant_pool -> "AnnotationDefault"
    u4 attribute_length;            // excluding the initial six bytes
    element_value default_value;
}
  • BootstrapMethods
BootstrapMethods_attribute {
    u2 attribute_name_index;                                // CONSTANT_Utf8_info -> constant_pool -> "BootstrapMethods" 
    u4 attribute_length;                                    // excluding the initial six bytes
    u2 num_bootstrap_methods;
    { 
        u2 bootstrap_method_ref;                            // CONSTANT_MethodHandle_info
        u2 num_bootstrap_arguments;
        u2 bootstrap_arguments[num_bootstrap_arguments];    // constant_pool index
    } bootstrap_methods[num_bootstrap_methods];             // 
}
  • MethodParameters
MethodParameters_attribute {
    u2 attribute_name_index;            // CONSTANT_Utf8_info -> constant_pool -> "MethodParameters" 
    u4 attribute_length;                // excluding the initial six bytes
    u1 parameters_count;
    { 
        u2 name_index;                  // CONSTANT_Utf8_info -> constant_pool
        u2 access_flags;                // 0x0010 (ACC_FINAL)
                                        // 0x1000 (ACC_SYNTHETIC)
                                        // 0x8000 (ACC_MANDATED)
    } parameters[parameters_count];
}
  • Module
Module_attribute {
    u2 attribute_name_index;                    // CONSTANT_Utf8_info -> constant_pool -> "Module" 
    u4 attribute_length;                        // excluding the initial six bytes
    u2 module_name_index;                       // CONSTANT_Module_info -> constant_pool
    u2 module_flags;                            // 0x0020 (ACC_OPEN)
                                                // 0x1000 (ACC_SYNTHETIC)
                                                // 0x8000 (ACC_MANDATED)
    u2 module_version_index;                    // CONSTANT_Utf8_info -> constant_pool
    u2 requires_count;
    { 
        u2 requires_index;                      // CONSTANT_Module_info -> constant_pool
        u2 requires_flags;                      // 0x0020 (ACC_TRANSITIVE)
                                                // 0x0040 (ACC_STATIC_PHASE)
                                                // 0x1000 (ACC_SYNTHETIC)
                                                // 0x8000 (ACC_MANDATED)
        u2 requires_version_index;              // CONSTANT_Utf8_info -> constant_pool
    } requires[requires_count];
    u2 exports_count;
    { 
        u2 exports_index;                       // CONSTANT_Package_info -> constant_pool
        u2 exports_flags;                       // 0x1000 (ACC_SYNTHETIC)
                                                // 0x8000 (ACC_MANDATED)
        u2 exports_to_count;
        u2 exports_to_index[exports_to_count];  // CONSTANT_Module_info -> constant_pool
    } exports[exports_count];
    u2 opens_count;
    { 
        u2 opens_index;                         // CONSTANT_Package_info -> constant_pool
        u2 opens_flags;                         // 0x1000 (ACC_SYNTHETIC)
                                                // 0x8000 (ACC_MANDATED)
        u2 opens_to_count;
        u2 opens_to_index[opens_to_count];      // CONSTANT_Module_info -> constant_pool
    } opens[opens_count];
    u2 uses_count;
    u2 uses_index[uses_count];                  // CONSTANT_Class_info -> constant_pool
    u2 provides_count;
    { 
        u2 provides_index;                              // CONSTANT_Class_info -> constant_pool
        u2 provides_with_count;
        u2 provides_with_index[provides_with_count];    // CONSTANT_Class_info -> constant_pool
    } provides[provides_count];
}
  • ModulePackages
ModulePackages_attribute {
    u2 attribute_name_index;            // CONSTANT_Utf8_info -> constant_pool -> "ModulePackages" 
    u4 attribute_length;                // excluding the initial six bytes
    u2 package_count;
    u2 package_index[package_count];    // CONSTANT_Package_info -> constant_pool
}
  • ModuleMainClass
ModuleMainClass_attribute {
    u2 attribute_name_index;        // CONSTANT_Utf8_info -> constant_pool -> "ModuleMainClass" 
    u4 attribute_length;            // excluding the initial six bytes
    u2 main_class_index;            // CONSTANT_Class_info -> constant_pool
}

转载于:https://my.oschina.net/roccn/blog/1552792

SimminonGarcia
关注
【SpringBoot】47、SpringBoot中如何静态加载配置文件
Asurplus
03-24 21万+
前言 我们知道在 SpringBoot 中有默认的配置文件 application.yml 或 application.properties，我们可以通过 @ConfigurationProperties(prefix = “test”) 或 @Value("${test}") 等方式获取到配置内容，那有的时候我们需要通过静态的方式读取配置文件的内容，这种方式就不能实现了 1、创建配置文件 我们将配置文件放在根目录下，里面配置的是微信公众平台的一些信息 2、读取配置文件 package com.asurp
java读取class 内容_解析Java Class 文件过程
weixin_33205735的博客
02-13 2127
前言：身为一个java程序员，怎么能不了解JVM呢，倘若想学习JVM，那就又必须要了解Class文件，Class之于虚拟机，就如鱼之于水，虚拟机因为Class而有了生命。《深入理解java虚拟机》中花了一整个章节来讲解Class文件，可是看完后，一直都还是迷迷糊糊，似懂非懂。正好前段时间看见一本书很不错：《自己动手写Java虚拟机》，作者利用go语言实现了一个简单的JVM，虽然没有完整实现JVM的...
ClassFile之Attributes
kongkong的专栏
04-15 373
Attributes Attributesare used in theClassFile,field_info,method_info, andCode_attributestructures of theclassfile format (§4.1,§4.5,§4.6,§4.7.3). All attributes have the following general format: attribute_info { u2 attribute_name_inde...
Class文件属性表集合详解
qq_35892775的博客
01-05 1824
1.code属性 最常用的属性恐怕就是Code属性了，因为大多数的方法都会有编译后的字节码指令，这些指令就存储在方法表中的Code属性中。如果一个Java程序的信息可以分为代码（方法体中的代码）和元数据（包括类、字段、方法定义以及其它信息），那么Code属性存储的就是代码，其它所有的结构存储的都是元数据。不过并非所有的方法表都有这个Code属性，比如接口或抽象类中的方法表就不存在Code属性（J...
类文件结构之三：属性表(attribute_info)集合
0_o_c
10-20 1593
1、Code属性表结构： 数据类型 名称 数量 u2 attribute_name_index 1 u4 attribute_length 1 u2 max_stack 1 u2 max_locals 1 u4 code_length 1 u1 code code_length u2 exception_tab
class 第一个元素_Class文件属性表-Code属性
weixin_29732737的博客
01-18 678
属性表中各个属性都有固定的格式，如下图所示：u2的属性名称索引(在常量池中的位置)u4属性表内容的长度u1具体的属性内容Code属性Code属性是整个Class文件中最重要的属性，Code属性只作用于方法表中，在Code属性中存储了Java方法体经过编译后Java的字节码指令，Code属性的结构如下：max_stack操作数栈的最大深度。虚拟机运行的时候需要根据这个值来分配栈帧中的操作栈深度。ma...
Jvm（40），class文件结构----- 属性表集合（这里内容比较多，等jvm写完之后看这里还有什么补充的吗）...
weixin_33726943的博客
09-22 144
  属性表集合 属性表（attribute_info）在前面的讲解之中已经出现过数次，在Class文件、字段表、方法表都可以携带自己的属性表集合，以用于描述某些场景专有的信息。 例如在39，class文件结构----- 方法表集合 我们讲到的exception属性就属于方法表属性。 38，class文件结构----字段表集合讲到的ConstantValue类型的属性表就属于字段表属性。 在这里...
class 属性表
实践求真知
08-05 1512
一 class 属性计数器 attributes_count 的值表示当前 class 文件属性表的成员个数。属性表中每一项都是一个 attribute_info 结构。 二 属性表 attributes[]（属性表）的每个项的值必须是 attribute_info 结构。属性表的结构比较灵活，各种不同的属性只要满足以下结构即可。 1 属性的通用格式 类型 名称 数量 含义 u2 ..
详解.class文件
热门推荐
isbn0123的博客
07-10 1万+
详解.class文件 话不多说，直接上图 .class文件理解： 在 Java 中，JVM 可以理解的代码就叫做字节码（即扩展名为 .class 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题并且保留了解释型语言可移植的特点，而通过即时编译器(jit)又有编译型语言执行效率高的特点。所以 Java 程序运行时比较高效。Java通过字节码文件和虚拟机jvm之间的关系，做到了平台无关性，一次编译，各平台都可运行。
Class文件解析
Aur_ora的博客
07-03 1885
1. Class文件的介绍 1.1 本质 Class 文件是一组以一个字节为基础单位的二进制流。 任何一个 Class 文件都对应着唯一一个类或接口的定义信息 1.2 格式 Class 文件格式采用一种类似于 C 语言结构体的方式进行数据存储，这种结构中只有两种数据类型：无符号数和表 无符号数属于基本的数据类型，以 u1、u2、u4、u8 来分别代表 1 个字节、2 个字节、4 个字节、8 个字节的无符号数，无符号数可以用来描述数字、索引引用、数量值或者按照 UTF-8 编码构成字符串值。 表是由多
java虚拟机class类文件的结构
逆水行舟，不进则退
12-18 266
java虚拟机类文件的结构，首先来看一下大概框架。此文章中的u1，u2，u4，u8分别表示一个字节，两个字节，四个字节和八个字节的无符号数。 一.魔数 1.类文件的头4个字节为魔数。 2.唯一作用是确定这个文件能否能被虚拟机接受，即身份识别。 3.不用扩展名的原因是这样更加的安全。 二.版本号 1.紧接着魔数后面的4个字节，56字节是次版本号，78字节是主版本号。 三.常量池 ...
Class文件解读（六）
weixin_34014277的博客
05-28 66
2019独角兽企业重金招聘Python工程师标准>>> ...
Class文件格式之各属性名详解
08-20 564
ConstantValue 在编译时，javac将会为被static和final修饰的常量生成ConstantValue属性，且只限于基本类型和String类型。编译时javac将会为该常量生成ConstantValue属性，在类加载的准备阶段虚拟机便会根据ConstantValue为常量设置响应的值，如果该变量没有被final修饰，或者并非基本类型及字段串，则选择在类构造器中进行初始化。 ConstantValue 属性的格式： ConstantValue_attribute { u2 a
class文件内容解析
yzb808的专栏
11-01 1015
class文件基本数据结构： 使用javac编译后的文件是.class文件，程序运行时，class文件被classLoader加载到JVM成为class对象，随后便可以创建该类的对象。 class文件是二进制文件流，记录类相关信息，可以被JVM解析。class文件内容并不复杂，结构如下： ClassFile { u4 magic; u2 ...
jvm signature 属性_Signature属性
weixin_27017211的博客
12-31 342
本视频课程已申请版权保护。未经合法授权，任何单位和个人不得进行复制、转载、改编或其它侵权行为。本课程的标题是Java8ClassFile，主要是对Java的字节码(ByteCode)进行讲解，所依据是Java8这个版本。为什么要学习字节码(ByteCode)？从总体上而言，Java的架构可以分为四个独立且相关的部分：JavaProgrammingLanguage、JavaClassF...
Java多线程编程技术实践
weixin_45563088的博客
04-08 1462
Java多线程编程技术实践 最近笔者面试的时候被面试官问到了有关Java线程池源码方面的问题，没有回答上来，所以准备好好研究一下Java线程池底层源码。当我打开JDK源码的时候，我整个人就愣住了，像极了刘姥姥进大观园，Java线程池源码中的一些涉及到多线程相关的API，我竟然已经完全忘记了这些方法的作用，于是便准备总结一篇Java多线程编程技术相关的内容，用以对自己所学知识的总结。 本文会总结常见的Java多线程基础练习和面试题，包括《Java多线程编程核心技术》、《Java并发编程的艺术》上的Code，以
jvm原理（27）Java字节码方法表与属性表深度剖析
wzq6578702的专栏
08-04 3348
上一节说到成员变量，这一节说一下方法表 图一： 图二： 图三： 行号00000120 开始就是方法表的开始，刚开始2个字节是方法的数量：00 03 是三个方法（无参构造器、变量a的get和set方法） 方法表： 类型 名称 数量 u2 access_flags 1 u2 name_index 1 u2 desc...
Java中.class文件的结构
生而为人我很抱歉
06-16 1359
原文地址：http://blog.sina.com.cn/s/blog_67fcf49e0101hxfp.html 学习Java的朋友应该都知道Java从刚开始的时候就打着平台无关性的旗号，说“一次编写，到处运行”，其实说到无关性，Java平台还有另外一个无关 性那就是语言无关性，要实现语言无关性，那么Java体系中的class的文件结构或者说是字节码就显得相当重要了，其实Java从刚开始的
classfile解析的内容
qq_48241564的博客
01-09 993
目录 一、前言 二、Classfile文件结构解析 1、无符号数 2、表 3、魔术(magic) 3.1、每一个class文件的头4个字节，被称为魔数 magicNumber 3.2、总结魔术的用处： 4、Class文件的版本号（minor_version、major_version） 4.1、minor_version(次版本号) 4.2、major_version(主版本号) 5、常量池(CONSTANT_POOL_COUNT、CONSTANT_POOL) 5.1、con..
Java Class文件属性详解：源文件与数据描述
本文主要关注class文件中的`attributes_count`和`attributes`部分，这些属性分布在不同的位置，并为各类数据提供描述性信息。 `attributes_count`是一个位于`methods`区域下方的整数值，用两个字节表示，记录了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值