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 }