Java Class文件中包含以下信息：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
ClassFile {
u4 magic;
//模数
u2 minor_version;
//次版本号
u2 major_version;
//主版本号
u2 constant_pool_count;
//常量池大小
cp_info constant_pool[constant_pool_count-
1
];
//常量池
u2 access_flags;
//类和接口层次的访问标志（通过|运算得到）
u2 this_class;
//类索引（指向常量池中的类常量）
u2 super_class;
//父类索引（指向常量池中的类常量）
u2 interfaces_count;
//接口索引计数器
u2 interfaces[interfaces_count];
//接口索引集合
u2 fields_count;
//字段数量计数器
field_info fields[fields_count];
//字段表集合
u2 methods_count;
//方法数量计数器
method_info methods[methods_count];
//方法表集合
u2 attributes_count;
//属性个数
attribute_info attributes[attributes_count];
//属性表
}
|
1. 通过实例来看
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
public
interface
InterA {
void
interA();
}
public
interface
InterB {
String interB(
int
i);
}
public
interface
InterC {
void
interC();
}
public
class
Base
implements
InterA {
private
int
baseInt;
protected
String baseString;
public
int
getBaseInt() {
return
baseInt;
}
public
void
setBaseInt(
int
baseInt) {
this
.baseInt = baseInt;
}
@Override
public
void
interA() {
System.out.println(
"the interA in Base"
);
}
}
public
class
Sub
extends
Base
implements
InterB, InterC {
private
int
subInt;
private
static
String subString;
private
static
Object subObject;
public
int
getSubInt() {
return
subInt;
}
public
void
setSubInt(
int
subInt) {
this
.subInt = subInt;
}
public
static
String getSubString() {
return
subString;
}
public
static
void
setSubString(String subString) {
Sub.subString = subString;
}
public
static
Object getSubObject() {
return
subObject;
}
public
static
void
setSubObject(Object subObject) {
Sub.subObject = subObject;
}
@Override
public
void
interC() {
System.out.println(
"the interC in Sub"
);
}
@Override
public
String interB(
int
i) {
return
"the interB in Sub"
;
}
}
|
我们使用WinHex查看Sub类的.class文件：
2. 魔数
作用：确定该文件是否是虚拟机可接受的class文件。java的魔数统一为 0xCAFEBABE (来源于一款咖啡)。
区域：文件第0~3字节。
3. 版本号
作用：表示class文件的版本，由minorversion和majorversion组成。
区域：文件第4~7字节。
如
51代表，jdk为1.7.0
需要注意的是java版本号是从45开始的，大版本发布，主版本号+1.高版本的jdk能向下兼容以前版本的class文件，但不兼容以后版本的class文件。
4. 常量池
常量池的大小是不固定的，根据你的类中的常量的多少而定，所以在常量池的入口，放置了一个u2类型的表示常量池中常量个数的常量池容量计数器。计数器从1开始，第0位有特殊含义，表示指向常量池的索引值数据不引用任何一个常量池项目。池中的数据项就像数组一样是通过索引访问的。
我们可以清楚的看到，我们常量池中有63-1=62个常量。这些常量是什么呢？
要存放字面量Literal和符号引用Symbolic References。
字面量可能是文本字符串，或final的常量值。
符号引用包括以下：
- 类或接口全限定名 Full Qualified Name
- 字段名称和描述符 Descriptor
- 方法名称和描述符
我们使用反编译工具查看一下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
E:\program\JVM\bin\com\gissky\clazz>javap -v Sub.
class
Classfile /E:/program/JVM/bin/com/gissky/clazz/Sub.
class
Last modified
2015
-
2
-
22
; size
1363
bytes
MD5 checksum 2dc77c79e4790422407eb7092085883c
Compiled from
"Sub.java"
public
class
com.gissky.clazz.Sub
extends
com.gissky.clazz.Base
implements
com.gissky.clazz.InterB,com.gissky.clazz.InterC
SourceFile:
"Sub.java"
minor version:
0
major version:
51
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#
1
= Class #
2
// com/gissky/clazz/Sub →类和接口的全限定名
#
2
= Utf8 com/gissky/clazz/Sub
#
3
= Class #
4
// com/gissky/clazz/Base
#
4
= Utf8 com/gissky/clazz/Base
#
5
= Class #
6
// com/gissky/clazz/InterB
#
6
= Utf8 com/gissky/clazz/InterB
#
7
= Class #
8
// com/gissky/clazz/InterC
#
8
= Utf8 com/gissky/clazz/InterC
#
9
= Utf8 subInt
#
10
= Utf8 I
#
11
= Utf8 subString
#
12
= Utf8 Ljava/lang/String;
#
13
= Utf8 subObject
#
14
= Utf8 Ljava/lang/Object;
#
15
= Utf8 <init>
#
16
= Utf8 ()V
#
17
= Utf8 Code
#
18
= Methodref #
3
.#
19
// com/gissky/clazz/Base."<init>":()V
#
19
= NameAndType #
15
:#
16
// "<init>":()V
#
20
= Utf8 LineNumberTable
#
21
= Utf8 LocalVariableTable
#
22
= Utf8
this
#
23
= Utf8 Lcom/gissky/clazz/Sub;
#
24
= Utf8 getSubInt
#
25
= Utf8 ()I
#
26
= Fieldref #
1
.#
27
// com/gissky/clazz/Sub.subInt:I → 类中字段的符号引用
#
27
= NameAndType #
9
:#
10
// subInt:I → 类中字段的部分符号引用之名称和类型
#
28
= Utf8 setSubInt
#
29
= Utf8 (I)V
#
30
= Utf8 getSubString
#
31
= Utf8 ()Ljava/lang/String;
#
32
= Fieldref #
1
.#
33
// com/gissky/clazz/Sub.subString:Ljava/lang/String;
#
33
= NameAndType #
11
:#
12
// subString:Ljava/lang/String;
#
34
= Utf8 setSubString
#
35
= Utf8 (Ljava/lang/String;)V
#
36
= Utf8 getSubObject
#
37
= Utf8 ()Ljava/lang/Object;
#
38
= Fieldref #
1
.#
39
// com/gissky/clazz/Sub.subObject:Ljava/lang/Object;
#
39
= NameAndType #
13
:#
14
// subObject:Ljava/lang/Object;
#
40
= Utf8 setSubObject
#
41
= Utf8 (Ljava/lang/Object;)V
#
42
= Utf8 interC
#
43
= Fieldref #
44
.#
46
// java/lang/System.out:Ljava/io/PrintStream;
#
44
= Class #
45
// java/lang/System
#
45
= Utf8 java/lang/System
#
46
= NameAndType #
47
:#
48
// out:Ljava/io/PrintStream;
#
47
= Utf8 out
#
48
= Utf8 Ljava/io/PrintStream;
#
49
= String #
50
// the interC in Sub
#
50
= Utf8 the interC in Sub
#
51
= Methodref #
52
.#
54
// java/io/PrintStream.println:(Ljava/lang/String;)V
#
52
= Class #
53
// java/io/PrintStream
#
53
= Utf8 java/io/PrintStream
#
54
= NameAndType #
55
:#
35
// println:(Ljava/lang/String;)V
#
55
= Utf8 println
#
56
= Utf8 interB
#
57
= Utf8 (I)Ljava/lang/String;
#
58
= String #
59
// the interB in Sub →方法中用到的String常量
#
59
= Utf8 the interB in Sub
#
60
= Utf8 i
#
61
= Utf8 SourceFile
#
62
= Utf8 Sub.java
|
常量池中的项目类型如下：
- CONSTANT_Utf8_info tag标志位为1, UTF-8编码的字符串
- CONSTANT_Integer_info tag标志位为3， 整形字面量
- CONSTANT_Float_info tag标志位为4， 浮点型字面量
- CONSTANT_Long_info tag标志位为5， 长整形字面量
- CONSTANT_Double_info tag标志位为6， 双精度字面量
- CONSTANT_Class_info tag标志位为7， 类或接口的符号引用
- CONSTANT_String_info tag标志位为8，字符串类型的字面量
- CONSTANT_Fieldref_info tag标志位为9, 字段的符号引用
- CONSTANT_Methodref_info tag标志位为10，类中方法的符号引用
- CONSTANT_InterfaceMethodref_info tag标志位为11, 接口中方法的符号引用
- CONSTANT_NameAndType_info tag 标志位为12，字段和方法的名称以及类型的符号引用
5. 类或接口访问标志
表示类或者接口方面的访问信息，比如Class表示的是类还是接口，是否为public、static、final等。，下面我们就来看看TestClass的访问标示。Class的访问标志值为0×0021：
根据前面说的各种访问标示的标志位，我们可以知道：0×0021=0×0001|0×0020 也即ACC_PUBLIC 和 ACC_SUPER为真，其中ACC_PUBLIC大家好理解，ACC_SUPER是jdk1.2之后编译的类都会带有的标志。
6. 类索引、父类索引与接口索引集合
Class文件中由这3项数据来确定类的继承关系。
类索引和父类索引都是指向常量池中的常量索引：
紧接着后面是一个接口的计数器和接口描述符：
7. 字段表集合
作用：描述接口或者类中声明的类变量以及实例变量，不包括方法中的局部变量。
紧接着接口索引集合之后的2字节是字段计数器：
表示我们类中有3个字段，这里便是subInt、subString、subObject 3个字段。紧接其后的是字段表，字段表结构为：
|
1
2
3
4
5
6
7
8
|
field_info
{
u2 access_flags;
u2 name_index;
u2 descriptor_index;
u2 attributes_count;
attribute_info attributes[attributes_count];
}
|
access_flags项的值是用于定义字段被访问权限和基础属性的掩码标志。取值范围如下表：
描述符标识字符含义：
V 表示特殊类型void。
对于数组类型，每一个维度将使用一个前置的”["字符来描述，如一个定义的"java.lang.String[][]“类型的二维数组，将被记录为:”[[Ljava/lang/String;",一个整型数组"int[]“将被记录为”[I"
父类中的字段不会出现在子类的字段表中。
8. 方法表集合
字段表集合结束后便是方法表集合。
作用：描述该类中的方法。
和字段表一样，使用一个u2类型的方法计数器，记录该类中方法的个数。
表示我们的类中有9个方法。
方法表的结构如下图所示
其中name_index和descriptor_index表示的是方法的名称和描述符，他们分别是指向常量池的索引。这里需要结解释一下方法的描述符，方法的描述符的结构为：（参数列表）返回值，比如public int instanceMethod(int param)的描述符为：（I）I，表示带有一个int类型参数且返回值也为int类型的方法，方法java.lang.String.toString()的描述符为"()Ljava/lang/String;"，int IndexOf(char[] source,int sourceOffset,int sourceCount,char[] target int targetOffset,int targetCount,int fromIndex) 表示为([CII[CII)I。接下来就是属性数量以及属性表了，方法表和字段表虽然都有 属性数量和属性表，但是他们里面所包含的属性是不同。
如果父类方法在子类中没有被重写（@Override），方法表中就不会出现来自父类的方法信息。
9. 属性表集合
上面的方法表中我们就看到<init>方法有一个Code的属性。在本节我们将阐述这些属性：
Code属性：
该属性里主要存放由javac编译器处理后得到的字节码指令。
其中attribute_name_index指向常量池中值为Code的常量，attribute_length的长度表示Code属性表的长度（这里 需要注意的时候长度不包括attribute_name_index和attribute_length的6个字节的长度）。
max_stack表示最大栈深度，虚拟机在运行时根据这个值来分配栈帧中操作数的深度，而max_locals代表了局部变量表所需的存储空间。
max_locals的单位为slot，slot是虚拟机为局部变量分配内存的最小单元，在运行时，对于不超过32位类型的数据类型，比如 byte,char,int等占用1个slot，而double和Long这种64位的数据类型则需要分配2个slot，另外max_locals的值并不是所有局部变量所需要的内存数量之和，因为slot是可以重用的，当局部变量超过了它的作用域以后，局部变量所占用的slot就会被重用。方法参数、显示异常处理器的参数、方法体中定义的局部变量都要使用局部变量表来存放。
code_length代表了字节码指令的数量，而code表示的是字节码指令，从上图可以知道code的类型为u1,一个u1类型的取值为0x00-0xFF,对应的十进制为0-255，目前虚拟机规范已经定义了200多条指令。
exception_table_length以及exception_table分别代表方法对应的异常信息。
attributes_count和attribute_info分别表示了Code属性中的属性数量和属性表，从这里可以看出Class的文件结构中，属性表是很灵活的，它可以存在于Class文件，方法表，字段表以及Code属性中。
修改一下Sub中的InterB方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
@Override
public
int
interB(
int
i){
int
x=
0
;
try
{
x+=i;
return
x;
}
catch
(Exception e){
x=-
1
;
return
x;
}
finally
{
x=
3
;
}
}
|
大家不妨先猜一下这个函数的结果是什么？假如在try块中发生异常，结构又是什么？我相信对Java语言熟悉的朋友，肯定知道答案。<a href="http://images.cnitblog.com/blog/692756/201502/222239118613000.gif" 0="rel=" lightbox[15161]”"="" title="”em1″" class="external" rel="nofollow" target="_blank" style="border: 0px; margin: 0px; padding: 0px; text-decoration: none; color: rgb(0, 153, 204);">
使用反编译工具查看：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
public
int
interB(
int
);
flags: ACC_PUBLIC
Code:
stack=
2
, locals=
6
, args_size=
2
0
: iconst_0
1
: istore_2
2
: iload_2
3
: iload_1
4
: iadd
5
: istore_2
6
: iload_2
7
: istore
5
9
: iconst_3
10
: istore_2
11
: iload
5
13
: ireturn
14
: astore_3
15
: iconst_m1
16
: istore_2
17
: iload_2
18
: istore
5
20
: iconst_3
21
: istore_2
22
: iload
5
24
: ireturn
25
: astore
4
27
: iconst_3
28
: istore_2
29
: aload
4
31
: athrow
Exception table:
from to target type
2
9
14
Class java/lang/Exception
2
9
25
any
14
20
25
any
LineNumberTable:
line
35
:
0
line
37
:
2
line
38
:
6
line
43
:
9
line
38
:
11
line
39
:
14
line
40
:
15
line
41
:
17
line
43
:
20
line
41
:
22
line
42
:
25
line
43
:
27
line
44
:
29
LocalVariableTable:
Start Length Slot Name Signature
0
32
0
this
Lcom/gissky/clazz/Sub;
0
32
1
i I
2
30
2
x I
15
10
3
e Ljava/lang/Exception;
StackMapTable: number_of_entries =
2
frame_type =
255
/* full_frame */
offset_delta = 14
locals = [ class com/gissky/clazz/Sub, int, int ]
stack = [ class java/lang/Exception ]
frame_type = 74 /* same_locals_1_stack_item */
stack = [
class
java/lang/Throwable ]
}
|
从 args_size=2这条反编译代码，我们可以知道，在public int interB(int i)这个方法中有6个局部变量，2个参数，可是我们的函数中明明只有一个参数么……这是因为编译器会为每一个实例函数包括构造器添加一个参数this，在JVM调用该方法的时候会该形参传递一个实参—方法所在对象的自身。
Exception table:
from to target type
2 9 14 Class java/lang/Exception
2 9 25 any
14 20 25 any
上表表头表示，当字节码在form行到to行（不包括to行）出现类型为type的异常，则转到第target行继续处理。
从方法的异常表中，我们可以看到这个函数有3条执行路径：
这里我们插入阐述一下LineNumberTable表的含义：它表示Java源码行号与字节码行号之间的对应关系。
知道了该方法执行的3条路径，我们也就知道刚才我们的那个问题有3个答案：没有异常是为x+i；try块中出现Exception类型的错误时，返回-1；出现Exception以外的任何异常方法非正常结束，没有返回值。
LocalVariableTable:
Start Length Slot Name Signature
0 32 0 this Lcom/gissky/clazz/Sub;
0 32 1 i I
2 30 2 x I
15 10 3 e Ljava/lang/Exception;
LocalVariableTable表示局部变量表，描述方法中局部变量。
如果你对返回的答案能理解的话，那么我相信你也肯定知道，我们函数中只有4个参数，但max_locals却等于6。不懂的话仔细看一下Code中字节码的执行过程变可以理解了。
一个方法在执行时需要多大的局部变量空间在编译时期就知道了，方法执行期间不会改变局部变量表的大小。
Signature 属性：
该属性是在JDK1.5新增的。该属性可用于类、属性表和方法表结构的属性表中。使用泛型签名如果包含了类型变量（Type Variables）或参数化类型（Parameterized Types），则Signature 属性会为它记录泛型签名信息。当我们要泛型类中拿到泛型的实际类型的时候非常有用。
实例：
在使用Hibernate时，我习惯将为Dao层封装一个泛型基类，来放置一些通用的方法，而Hibernate有很多方法都要传递一个POJO的类型，然后进行查询，如load方法。我们构建这样的一个基类：
public abstract class BaseDaoImpl<T, PK extends Serializable> extends HibernateDaoSupport implements BaseDao<T, PK>
那么load中要使用的POJO类型便是T的实际类型。怎么来那倒这个属性呢？这里边要使用到Signature属性了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public
abstract
class
BaseDaoImpl<T, PK
extends
Serializable>
extends
HibernateDaoSupport
implements
BaseDao<T, PK> {
private
Class<T> entityClass;
@SuppressWarnings
(
"unchecked"
)
public
BaseDaoImpl() {
//class OrgDao extends BaseDaoImpl<Organization, String> implements OrgDao {}
Class c =
this
.getClass();
//返回的是使用new创建的泛型类对应的对象的class对象。
Type type = c.getGenericSuperclass();
//取得该对象的泛型类
//取得泛型对应的真正的class，并放到数组中
Type[] types = ((ParameterizedType)type).getActualTypeArguments();
entityClass = (Class<T>) types[
0
];
}
|
这时，getById中就可以直接使用了：
|
1
2
3
|
public
T getById(PK id) {
return
(T) getHibernateTemplate().load(entityClass, id);
}
|
扫一扫
5774
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
