`

cglib相关性能测试对比

 
阅读更多

转载：http://www.iteye.com/topic/801577

很多同学提出，因中文文档缺乏，导致对文章中的介绍看的不是很明白，更多的只是想了解具体的使用即可。所以趁势写了这篇博文，主要是将cglib中的几个工具类和常用的Reflect ,BeanUtils做一个对比，顺便也介绍一下cglib的相关用法，一举两得，望大家多多支持。

 

正题：

1.  首先定义一份Pojo Bean ，后续的测试主要围绕这个进行。

 

 

Java代码  收藏代码
  1. public static class CopyBean {  
  2.   
  3.         private int        intValue;  
  4.         private boolean    boolValue;  
  5.         private float      floatValue;  
  6.         private double     doubleValue;  
  7.         private long       longValue;  
  8.         private char       charValue;  
  9.         private byte       byteValue;  
  10.         private short      shortValue;  
  11.         private Integer    integerValue;  
  12.         private Boolean    boolObjValue;  
  13.         private Float      floatObjValue;  
  14.         private Double     doubleObjValue;  
  15.         private Long       longObjValue;  
  16.         private Short      shortObjValue;  
  17.         private Byte       byteObjValue;  
  18.         private BigInteger bigIntegerValue;  
  19.         private BigDecimal bigDecimalValue;  
  20.         private String     stringValue;  
  21. ......// 一堆的setter/getter方法  
  22. }  

 

 说明： 该copyBean基本包含了java的所有原型对象，基本对象，和常用的BigDecimal,BigInteger，总共17个属性。

 

2.  定义测试模板 (模板模式)

 

   定义一个TestCallback接口。

 

Java代码  收藏代码
  1. interface TestCallback {  
  2.   
  3.     String getName();  
  4.   
  5.     CglibPerformanceTest.CopyBean call(CglibPerformanceTest.CopyBean source);  
  6. }  

 

 

   定义测试的模板方法 

   private static final DecimalFormat integerFormat = new DecimalFormat("#,###");

Java代码  收藏代码
  1. public static void testTemplate(TestCallback callback, CopyBean source, int count) {  
  2.         int warmup = 10;  
  3.         // 先进行预热，加载一些类，避免影响测试  
  4.         for (int i = 0; i < warmup; i++) {  
  5.             callback.call(source);  
  6.         }  
  7.         restoreJvm(); // 进行GC回收  
  8.         // 进行测试  
  9.         long start = System.nanoTime();  
  10.         for (int i = 0; i < count; i++) {  
  11.             callback.call(source);  
  12.         }  
  13.         long nscost = (System.nanoTime() - start);  
  14.         System.out.println(callback.getName() + " total cost=" + integerFormat.format(nscost) + "ns , each cost="  
  15.                            + nscost / count  + "ns");  
  16.         restoreJvm();// 进行GC回收  
  17.   
  18.     }  

 

 

 说明：

 

  • 为了测试更加精确，避免因为在一次的循环中进行处理，jvm内存,GC,Class装载对测试的影响，有一个warmup的过程，先执行少量的测试方法，这里是执行10次
  • 避免jvm内存GC对测试id影响，这里有restoreJvm强制进行一次jvm GC

   restoreJvm相关方法：

   private static void restoreJvm() {
Java代码  收藏代码
  1.     int maxRestoreJvmLoops = 10;  
  2.     long memUsedPrev = memoryUsed();  
  3.     for (int i = 0; i < maxRestoreJvmLoops; i++) {  
  4.         System.runFinalization();  
  5.         System.gc();  
  6.   
  7.         long memUsedNow = memoryUsed();  
  8.         //  如果多次GC后内存稳定了，就退出   
  9.         if ((ManagementFactory.getMemoryMXBean().getObjectPendingFinalizationCount() == 0)  
  10.             && (memUsedNow >= memUsedPrev)) {  
  11.             break;  
  12.         } else {  
  13.             memUsedPrev = memUsedNow;  
  14.         }  
  15.     }  
  16. }  
  17.   
  18. private static long memoryUsed() {  
  19.     Runtime rt = Runtime.getRuntime();  
  20.     return rt.totalMemory() - rt.freeMemory();  
  21. }  

 

3.  准备原始的CopyBean数据

 

Java代码  收藏代码
  1. private static CopyBean getBean() {  
  2.         CopyBean bean = new CopyBean();  
  3.         bean.setIntValue(1);  
  4.         bean.setBoolValue(false);  
  5.         bean.setFloatValue(1.0f);  
  6.         bean.setDoubleValue(1.0d);  
  7.         bean.setLongValue(1l);  
  8.         bean.setCharValue('a');  
  9.         bean.setShortValue((short) 1);  
  10.         bean.setByteValue((byte) 1);  
  11.         bean.setIntegerValue(new Integer("1"));  
  12.         bean.setBoolObjValue(new Boolean("false"));  
  13.         bean.setFloatObjValue(new Float("1.0"));  
  14.         bean.setDoubleObjValue(new Double("1.0"));  
  15.         bean.setLongObjValue(new Long("1"));  
  16.         bean.setShortObjValue(new Short("1"));  
  17.         bean.setByteObjValue(new Byte("1"));  
  18.         bean.setBigIntegerValue(new BigInteger("1"));  
  19.         bean.setBigDecimalValue(new BigDecimal("1"));  
  20.         bean.setStringValue("1");  
  21.         return bean;  
  22.     }  

 

 

4. 执行相关测试

测试环境说明：

 

  • 操作系统 Linux ccbu-156-49 2.6.18-131.el5.customxen #1 SMP Tue Sep 15 15:46:11 CST 2009 x86_64 x86_64 x86_64 GNU/Linux
  • 虚拟8cpu , 5G内存
  • jdk  1.6.0_18
  • jvm 参数 
  • Jvm参数代码  收藏代码
    1. -server -Xmx2g -Xms2g -Xmn512m -XX:PermSize=196m -Xss256k -XX:+UseConcMarkSweepGC -XX:+CMSParallelRemarkEnabled -XX:+UseCMSCompactAtFullCollection -XX:LargePageSizeInBytes=128m -XX:+UseFastAccessorMethods -XX:+UseCMSInitiatingOccupancyOnly -XX:CMSInitiatingOccupancyFraction=70  
     

第一测试主要是一个对象的全部属性进行拷贝

  • BeanCopier  (cglib)
  • PropertyUtils (apache-common)
  • BeanUtils (apache-common)
 
1.  BeanCopier  (cglib)

 

  • Java代码  收藏代码
    1. // beanCopier测试  
    2.      final BeanCopier beanCopier = BeanCopier.create(CopyBean.class, CopyBean.class, false);  
    3.         final CopyBean beanCopierTarget = new CopyBean();//new一次，避免new对象产生的代价影响测试结果  
    4.         testTemplate(new TestCallback() {  
    5.   
    6.             public String getName() {  
    7.                 return "BeanCopier";  
    8.             }  
    9.   
    10.             public CopyBean call(CopyBean source) {  
    11.                 beanCopier.copy(source, beanCopierTarget, null);  
    12.                 return beanCopierTarget;  
    13.             }  
    14.         }, bean, testCount);  
2. PropertyUtils (apache-common)
  • Java代码  收藏代码
    1. <span style="background-color: rgba(0, 0, 0, 0);">// PropertyUtils测试  
    2.         final CopyBean propertyUtilsTarget = new CopyBean();  
    3.         testTemplate(new TestCallback() {  
    4.   
    5.             public String getName() {  
    6.                 return "PropertyUtils";  
    7.             }  
    8.   
    9.             public CopyBean call(CopyBean source) {  
    10.                 try {  
    11.                     PropertyUtils.copyProperties(propertyUtilsTarget, source);  
    12.                 } catch (Exception e) {  
    13.                     e.printStackTrace();  
    14.                 }  
    15.                 return propertyUtilsTarget;  
    16.             }  
    17.   
    18.         }, bean, testCount);</span>  
3. BeanUtils (apache-common)
    • Java代码  收藏代码
      1. <span style="background-color: rgba(0, 0, 0, 0);">// BeanUtils测试  
      2.         final CopyBean beanUtilsTarget = new CopyBean();  
      3.         testTemplate(new TestCallback() {  
      4.   
      5.             public String getName() {  
      6.                 return "BeanUtils";  
      7.             }  
      8.   
      9.             public CopyBean call(CopyBean source) {  
      10.                 try {  
      11.                     BeanUtils.copyProperties(beanUtilsTarget, source);  
      12.                 } catch (Exception e) {  
      13.                     e.printStackTrace();  
      14.                 }  
      15.                 return beanUtilsTarget;  
      16.             }  
      17.   
      18.         }, bean, testCount);</span>  

 

测试结果： 

 

测试次数：testCount = 1000 * 1000 = 100万次

  • BeanCopier total cost=36,626,000ns , each cost=36ns
  • PropertyUtils total cost=18,173,767,000ns , each cost=18173ns
  • BeanUtils total cost=31,236,079,000ns , each cost=31236ns
从这个结果可以看出， BeanCopier是PropertyUtils的504倍， PropertyUtils是BeanUtils的1.71倍， BeanCopier是PropertyUtils的861.84倍，差了近3个数量级。
 

第二测试主要是一个对象的单个属性进行拷贝 

  • BulkBean (cglib)
  • BeanMap (cglib)
  • FastClass/FastMethod  (cglib)
  • 未处理的jdk reflect (jdk)
  • 处理的jdk reflect (jdk)
1. BulkBean 
Java代码  收藏代码
  1. // 测试BulkBean  
  2.         final BulkBean bulkBean = BulkBean.create(bean.getClass(), new String[] { getMethodName },  
  3.                                                   new String[] { setMethodName }, new Class[] { Integer.class });  
  4.         final CopyBean bulkBeanTarget = new CopyBean();  
  5.         testTemplate(new TestCallback() {  
  6.   
  7.             @Override  
  8.             public String getName() {  
  9.                 return "BulkBean";  
  10.             }  
  11.   
  12.             @Override  
  13.             public CopyBean call(CopyBean source) {  
  14.                 Object[] result = bulkBean.getPropertyValues(source); // 先调用getter  
  15.                 bulkBean.setPropertyValues(bulkBeanTarget, result); // 再调用setter  
  16.                 return bulkBeanTarget;  
  17.             }  
  18.   
  19.         }, bean, testCount);  
 
2. BeanMap
 
Java代码  收藏代码
  1. // 测试BeanMap  
  2.         final BeanMap sourceMap = BeanMap.create(bean); // 预先创建对象  
  3.         final BeanMap targetMap = BeanMap.create(new CopyBean());  
  4.         final CopyBean beanMapTarget = new CopyBean();  
  5.         testTemplate(new TestCallback() {  
  6.   
  7.             @Override  
  8.             public String getName() {  
  9.                 return "BeanMap";  
  10.             }  
  11.   
  12.             @Override  
  13.             public CopyBean call(CopyBean source) {  
  14.                 targetMap.setBean(beanMapTarget); // 将目标对象设置于beanMap  
  15.                 Object obj = sourceMap.get(fieldName);  
  16.                 targetMap.put(fieldName, obj);  
  17.                 return beanMapTarget;  
  18.             }  
  19.   
  20.         }, bean, testCount);  
 
 3. FastClass/FastMethod
Java代码  收藏代码
  1. // 测试FastClass  
  2.         final FastClass fastClass = FastClass.create(bean.getClass());  
  3.         final FastMethod setFastMetod = fastClass.getMethod(setMethodName, new Class[] { Integer.class });  
  4.         final FastMethod getFastMetod = fastClass.getMethod(getMethodName, new Class[] {});  
  5.         final CopyBean fastClassTarget = new CopyBean();  
  6.         testTemplate(new TestCallback() {  
  7.   
  8.             @Override  
  9.             public String getName() {  
  10.                 return "FastClass";  
  11.             }  
  12.   
  13.             @Override  
  14.             public CopyBean call(CopyBean source) {  
  15.   
  16.                 try {  
  17.                     Object field = getFastMetod.invoke(source, new Object[] {});// 调用get方法  
  18.                     setFastMetod.invoke(fastClassTarget, new Object[] { field });// 调用set方法赋值  
  19.                 } catch (Exception e) {  
  20.                     e.printStackTrace();  
  21.                 }  
  22.   
  23.                 return fastClassTarget;  
  24.             }  
  25.   
  26.         }, bean, testCount);  
 
4.  未处理的jdk reflect
Java代码  收藏代码
  1. try {  
  2.             // 进行method对象cache，真实应用中一般都会cache method对象  
  3.             final Method getMethod = bean.getClass().getMethod(getMethodName, new Class[] {});  
  4.             final Method setMethod = bean.getClass().getMethod(setMethodName, new Class[] { Integer.class });  
  5.             // 测试未优化过的Reflect  
  6.             final CopyBean reflect1Target = new CopyBean();  
  7.             testTemplate(new TestCallback() {  
  8.   
  9.                 @Override  
  10.                 public String getName() {  
  11.                     return "未优化过的Reflect";  
  12.                 }  
  13.   
  14.                 @Override  
  15.                 public CopyBean call(CopyBean source) {  
  16.                     try {  
  17.                         Object field = getMethod.invoke(source, new Object[] {});  
  18.                         setMethod.invoke(reflect1Target, new Object[] { field });  
  19.                     } catch (Exception e) {  
  20.                         e.printStackTrace();  
  21.                     }  
  22.                     return reflect1Target;  
  23.                 }  
  24.   
  25.             }, bean, testCount);  
  26.   
  27.         } catch (Exception e1) {  
  28.             e1.printStackTrace();  
  29.         }  
  30.   
  31.     }  
 
 
5. 处理过的jdk reflect
Java代码  收藏代码
  1. try {  
  2.             // 进行method对象cache，真实应用中一般都会cache method对象  
  3.             final Method getMethod = bean.getClass().getMethod(getMethodName, new Class[] {});  
  4.             final Method setMethod = bean.getClass().getMethod(setMethodName, new Class[] { Integer.class });  
  5.             // 测试优化过的Reflect  
  6.             getMethod.setAccessible(true);// 设置不进行access权限检查  
  7.             setMethod.setAccessible(true);// 设置不进行access权限检查  
  8.             final CopyBean reflect2Target = new CopyBean();  
  9.             testTemplate(new TestCallback() {  
  10.   
  11.                 @Override  
  12.                 public String getName() {  
  13.                     return "优化过的Reflect";  
  14.                 }  
  15.   
  16.                 @Override  
  17.                 public CopyBean call(CopyBean source) {  
  18.                     try {  
  19.                         Object field = getMethod.invoke(source, new Object[] {});  
  20.                         setMethod.invoke(reflect2Target, new Object[] { field });  
  21.                     } catch (Exception e) {  
  22.                         e.printStackTrace();  
  23.                     }  
  24.                     return reflect2Target;  
  25.                 }  
  26.   
  27.             }, bean, testCount);  
  28.         } catch (Exception e1) {  
  29.             e1.printStackTrace();  
  30.         }  
 

 

 

测试结果：  

 

测试次数：testCount = 1000 * 1000 * 100 = 1亿次

  • BulkBean total cost=2,125,759,000ns , each cost=21ns
  • BeanMap total cost=2,730,912,000ns , each cost=27ns
  • FastClass total cost=2,576,470,000ns , each cost=25ns
  • 未处理过的Reflect total cost=2,882,755,000ns , each cost=28ns
  • 处理过的Reflect total cost=2,792,828,000ns , each cost=27ns
测试结果，性能相差不多，差距不大，这也可以说明jdk对reflect调用的优化已经做的很棒了。
分享到：
| cglib源码学习交流
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    CGLIB简介 CGLIB简介 CGLIB简介 CGLIB简介

    CGLIB简介CGLIB简介CGLIB简介CGLIB简介CGLIB简介

    cglib动态代理相关包

    cglib动态代理相关jar包，亲测可用cglib动态代理相关jar包，亲测可用cglib动态代理相关jar包，亲测可用

    cglib.jar下载

    通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。 二、CGLIB原理 CGLIB原理：动态生成一个要代理类的子类，子类重写要代理的类的所有不是final的方法。...

    cglib的依赖包

    cglib

    cglib_cglib.zip

    cglib.zip

    开发工具 cglib-3.2.4

    开发工具 cglib-3.2.4开发工具 cglib-3.2.4开发工具 cglib-3.2.4开发工具 cglib-3.2.4开发工具 cglib-3.2.4开发工具 cglib-3.2.4开发工具 cglib-3.2.4开发工具 cglib-3.2.4开发工具 cglib-3.2.4开发工具 cglib-3.2.4...

    cglib-3.1-API文档-中文版.zip

    赠送jar包：cglib-3.1.jar； 赠送原API文档：cglib-3.1-javadoc.jar； 赠送源代码：cglib-3.1-sources.jar； 赠送Maven依赖信息文件：cglib-3.1.pom； 包含翻译后的API文档：cglib-3.1-javadoc-API文档-中文(简体)版...

    cglib包及依赖汉cglib3.1和asm4.2

    cglib包及依赖汉cglib3.1和asm4.2,主要作用是用户代理，代理为控制要访问的目标对象提供了一种途径。当访问对象时，它引入了一个间接的层。JDK自从1.3版本开始，就引入了动态代理，并且经常被用来动态地创建代理。...

    cglib相关jar包.zip

    cglib代理模式所需要的jar吧，包括cglib3.1.jar和字节码asm4.0.jar；并且经过代码测试，直接可用

    cglib_cglib3.2_remain3gr_cglibjar包_cglib.jar_

    cglib 的jar包，用于做动态代理的，但是版本太高不知道会不会有影响

    cglib-3.2.0.jar

    CGLIB是一个强大的高性能的代码生成包。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。最流行的OR Mapping工具hibernate也使用CGLIB来代理单端single-ended(多对一...

    CGLIB-DOC说明

    CGLIB-DOC,CGLIB说明文件.

    基于Cglib简单实现Spring体系(Ioc+Aop+Mvc)

    基于Cglib简单实现Spring体系(Ioc+Aop+Mvc)基于Cglib简单实现Spring体系(Ioc+Aop+Mvc)基于Cglib简单实现Spring体系(Ioc+Aop+Mvc)基于Cglib简单实现Spring体系(Ioc+Aop+Mvc)基于Cglib简单实现Spring体系(Ioc+Aop+Mvc)...

    cglib必需的包

    在cglib需要的包，含有asm.jar asm_commons.jar asm-util.jar cglib-nodep.jar

    CGLib3.2.5依赖包及源码

    cglib-3.2.5.jar、cglib-nodep-3.2.5.jar、cglib-RELEASE_3_2_5.tar.gz（源码）、cglib-RELEASE_3_2_5.zip（源码）

    Cglib的jar文件 Cglib.zip

    Cglib的jar文件，包含：asm.jar、asm-commons.jar、asm-tree.jar、cglib-2.2.jar 四个jar包

    CGLib详细教程

    CGLib详细教程 CGLib详细教程 CGLib详细教程

    cglib-2.2.2源码

    cglib-2.2.2源码

    CGLIB入门实例.doc

    Hibernate底层技术简介 CGLIB

    CGLIB需要的asm-2.2.3.jar和cglib-nodep-2.2.jar

    里面包含完整的cglib-nodep-2.2.jar和asm-2.2.3.jar，放心下载

Magicbox
Global site tag (gtag.js) - Google Analytics