java反射效率到底如何,花了点时间,做了一个简单的测试.供大家参考.
测试背景:
1. 测试简单Bean(int,Integer,String)的set方法
2. loop 1亿次
3. 测试代码尽可能避免对象的创建,复发方法的调用,仅仅测试set方法的耗时
测试结果:
场景 | 本机测试结果(XP,双核,2G) | 服务器测试结果(Linux,XEN虚拟机,8核,5.5G) |
方法直接调用 | 235MS | 190MS |
JDK Method调用 | 29188MS | 4633MS |
JDK Method调用(稍作优化) | 5672MS | 4262MS |
Cglib FastMethod调用 | 5390MS | 2787MS |
得出一个感性的结果:
1.JDK反射效率是直接调用的一个数量级,差不多20倍
2.一个set方法的反射调用时间 = 4633ms / 1亿 / 3次 = 0.0154us
3.Cglib的fastmethod还是有优势的
最后,附上测试代码:
1
/**
2
* <pre>
3
* 本机测试结果(XP,双核,2G):
4
* 直接调用(LOOP=1亿): 235MS
5
* 反射调用(LOOP=1亿): 29188MS
6
* 反射调用(优化)(LOOP=1亿): 5672MS
7
* 放射调用(CGLIB)(LOOP=1亿):5390MS
8
*
9
* 服务器测试结果(linux xen虚拟机,5.5G内存;8核CPU):
10
* 直接调用(LOOP=1亿): 190MS
11
* 反射调用(LOOP=1亿): 4633MS
12
* 反射调用(优化)(LOOP=1亿): 4262MS
13
* 放射调用(CGLIB)(LOOP=1亿):2787MS
14
* </pre>
15
*
16
*
@author
Stone.J 2010-9-15 上午10:07:27
17
*/
18
public
class
ReflectionTest {
19
20
private
static
final
int
DEFAULT_INT
=
1
;
21
private
static
final
Integer DEFAULT_INTEGER
=
1
;
22
private
static
final
String DEFAULT_STRING
=
"
name
"
;
23
private
static
final
Object[] DEFAULT_INTS
=
{
1
};
24
private
static
final
Object[] DEFAULT_INTEGERS
=
new
Integer[] {
1
};
25
private
static
final
Object[] DEFAULT_STRINGS
=
new
String[] {
"
name
"
};
26
27
private
static
final
Bean BEAN
=
new
Bean();
28
29
private
static
final
CachedMethod CACHED_METHOD
=
new
CachedMethod();
30
private
static
final
OptimizationCachedMethod OPTIMIZATION_CACHED_METHOD
=
new
OptimizationCachedMethod();
31
private
static
final
CglibCachedMethod CGLIB_CACHED_METHOD
=
new
CglibCachedMethod();
32
33
private
static
final
long
LOOP
=
1
*
10000
*
10000
;
34
35
//
测试main
36
public
static
void
main(String[] args) {
37
if
(args.length
!=
1
) {
38
System.out.println(
"
args error.
"
);
39
System.exit(
1
);
40
}
41
int
tc
=
Integer.valueOf(args[
0
]);
42
43
long
start
=
System.currentTimeMillis();
44
for
(
long
i
=
0
; i
<
LOOP; i
++
) {
45
switch
(tc) {
46
case
1
:
47
//
直接调用
48
test();
49
break
;
50
case
2
:
51
//
反射调用
52
testReflection();
53
break
;
54
case
3
:
55
//
优化后反射调用
56
testOptimizationReflection();
57
break
;
58
case
4
:
59
//
cglib反射调用
60
testCglibReflection();
61
break
;
62
default
:
63
System.out.println(
"
tc error. must be [1-4]
"
);
64
break
;
65
}
66
}
67
long
dur
=
System.currentTimeMillis()
-
start;
68
System.out.println(dur);
69
}
70
71
//
直接调用测试
72
public
static
void
test() {
73
BEAN.setId(DEFAULT_INT);
74
BEAN.setCode(DEFAULT_INTEGER);
75
BEAN.setName(DEFAULT_STRING);
76
}
77
78
//
反射调用测试
79
public
static
void
testReflection() {
80
try
{
81
CACHED_METHOD.setId.invoke(BEAN, DEFAULT_INTS);
82
CACHED_METHOD.setCode.invoke(BEAN, DEFAULT_INTEGERS);
83
CACHED_METHOD.setName.invoke(BEAN, DEFAULT_STRINGS);
84
}
catch
(Exception e) {
85
e.printStackTrace();
86
}
87
}
88
89
//
优化后反射调用测试
90
public
static
void
testOptimizationReflection() {
91
try
{
92
OPTIMIZATION_CACHED_METHOD.setId.invoke(BEAN, DEFAULT_INTS);
93
OPTIMIZATION_CACHED_METHOD.setCode.invoke(BEAN, DEFAULT_INTEGERS);
94
OPTIMIZATION_CACHED_METHOD.setName.invoke(BEAN, DEFAULT_STRINGS);
95
}
catch
(Exception e) {
96
e.printStackTrace();
97
}
98
}
99
100
//
cglib反射调用测试
101
public
static
void
testCglibReflection() {
102
try
{
103
CGLIB_CACHED_METHOD.cglibSetId.invoke(BEAN, DEFAULT_INTS);
104
CGLIB_CACHED_METHOD.cglibSetCode.invoke(BEAN, DEFAULT_INTEGERS);
105
CGLIB_CACHED_METHOD.cglibSetName.invoke(BEAN, DEFAULT_STRINGS);
106
}
catch
(Exception e) {
107
e.printStackTrace();
108
}
109
}
110
111
/**
112
* <pre>
113
* 测试的bean
114
* 简单的int Integer String类型
115
* </pre>
116
*
117
*
@author
Stone.J 2010-9-15 上午10:40:40
118
*/
119
public
static
class
Bean {
120
121
private
int
id;
122
private
Integer code;
123
private
String name;
124
125
public
int
getId() {
126
return
id;
127
}
128
129
public
void
setId(
int
id) {
130
this
.id
=
id;
131
}
132
133
public
Integer getCode() {
134
return
code;
135
}
136
137
public
void
setCode(Integer code) {
138
this
.code
=
code;
139
}
140
141
public
String getName() {
142
return
name;
143
}
144
145
public
void
setName(String name) {
146
this
.name
=
name;
147
}
148
149
}
150
151
/**
152
* 反射测试需要:Cached Method
153
*
154
*
@author
Stone.J 2010-9-15 上午10:41:04
155
*/
156
public
static
class
CachedMethod {
157
158
public
Method setId;
159
public
Method setCode;
160
public
Method setName;
161
162
{
163
try
{
164
setId
=
Bean.
class
.getDeclaredMethod(
"
setId
"
,
int
.
class
);
165
setCode
=
Bean.
class
.getDeclaredMethod(
"
setCode
"
, Integer.
class
);
166
setName
=
Bean.
class
.getDeclaredMethod(
"
setName
"
, String.
class
);
167
}
catch
(Exception e) {
168
e.printStackTrace();
169
}
170
}
171
172
}
173
174
/**
175
* 反射测试需要:优化后的Cached Method
176
*
177
*
@author
Stone.J 2010-9-15 上午10:41:21
178
*/
179
public
static
class
OptimizationCachedMethod
extends
CachedMethod {
180
181
{
182
/**
所谓的优化
*/
183
setId.setAccessible(
true
);
184
setCode.setAccessible(
true
);
185
setName.setAccessible(
true
);
186
}
187
188
}
189
190
/**
191
* 反射测试需要,使用cglib的fast method
192
*
193
*
@author
Stone.J 2010-9-15 上午10:51:53
194
*/
195
public
static
class
CglibCachedMethod
extends
CachedMethod {
196
197
public
FastMethod cglibSetId;
198
public
FastMethod cglibSetCode;
199
public
FastMethod cglibSetName;
200
201
private
FastClass cglibBeanClass
=
FastClass.create(Bean.
class
);
202
203
{
204
cglibSetId
=
cglibBeanClass.getMethod(setId);
205
cglibSetCode
=
cglibBeanClass.getMethod(setCode);
206
cglibSetName
=
cglibBeanClass.getMethod(setName);
207
}
208
209
}
210
211
}
