java反射效率

java反射效率

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  }