（Apache BeanUtils、PropertyUtils,Spring BeanUtils,Cglib BeanCopier）Bean复制的几种框架性能比较

原文：http://www.open-open.com/lib/view/open1404998048200.html


 进行了三次测试，最后的结果如下：

10次测验 第一次 第二次 第三次 平均值 每次平均值
BeanUtil.copyProperties 54 57 50 53.66667 5.366666667
PropertyUtils.copyProperties 4 4 4 4 0.4
org.springframework.beans.BeanUtils.copyProperties 12 10 11 11 1.1
BeanCopier.create 0 0 0 0 0

 

10000次测验 第一次 第二次 第三次 平均值 每次平均值
BeanUtil.copyProperties 241 222 226 229.6667 0.022966667
PropertyUtils.copyProperties 92 90 92 91.33333 0.009133333
org.springframework.beans.BeanUtils.copyProperties 29 30 32 30.33333 0.003033333
BeanCopier.create 1 1 1 1 0.1

 

10000次反转测验 第一次 第二次 第三次 平均值 每次平均值
BeanUtil.copyProperties 178 174 178 176.6667 0.017666667
PropertyUtils.copyProperties 91 87 89 89 0.0089
org.springframework.beans.BeanUtils.copyProperties 21 21 21 21 0.0021
BeanCopier.create 0 1 1 0.666667 6.66667E-05

 

      不过需要注意的是，Cglib在测试的时候，先进行了实例的缓存，这个也是他性能较好的原因之一。如果把缓存去掉的话，性能就会出现了一些的差异，但是整体的性能还是很好，不过奇怪的是10000次反而比10次少，而且后面的反转1万次反而耗时最少，进行多次测试效果也是如此。    从整体的表现来看，Cglib的BeanCopier的性能是最好的无论是数量较大的1万次的测试，还是数量较少10次，几乎都是趋近与零损耗，Spring是在次数增多的情况下，性能较好，在数据较少的时候，性能比PropertyUtils的性能差一些。PropertyUtils的性能相对稳定，表现是呈现线性增长的趋势。而Apache的BeanUtil的性能最差，无论是单次Copy还是大数量的多次Copy性能都不是很好。

  10次 10000次 10000次反转
BeanCopier.create 41 28 10

      性能测试就到这里，数据也展示如上，后续会继续编写剩余两篇文章，这一片关注性能，后面的一篇是就每种方式的使用上的差异进行详解，最后一篇想进行探讨是什么早就了这四种方式的性能差异。

比较的是四种复制的方式，分别为Apache的BeanUtils和PropertyUtils,Spring的BeanUtils,Cglib的 BeanCopier。做法是在Eclipse新建了一个Project，专门用于专门测试几种代码的性能。具体的代码如下：
       一个FromBean和一个ToBean，两个的代码基本上一样，除了类名称不一样，所以只是贴出来了一份。
  1. public class FromBean {
  2.     private String name;
  3.     private int age;
  4.     private String address;
  5.     private String idno;
  6.     private double money;
  7.  
  8.     public double getMoney() {
  9.         return money;
  10.     }
  11.  
  12.     public void setMoney(double money) {
  13.         this.money = money;
  14.     }
  15.  
  16.     public String getName() {
  17.         return name;
  18.     }
  19.  
  20.     public void setName(String name) {
  21.         this.name = name;
  22.     }
  23.  
  24.     public int getAge() {
  25.         return age;
  26.     }
  27.  
  28.     public void setAge(int age) {
  29.         this.age = age;
  30.     }
  31.  
  32.     public String getAddress() {
  33.         return address;
  34.     }
  35.  
  36.     public void setAddress(String address) {
  37.         this.address = address;
  38.     }
  39.  
  40.     public String getIdno() {
  41.         return idno;
  42.     }
  43.  
  44.     public void setIdno(String idno) {
  45.         this.idno = idno;
  46.     }
  47.  
  48. }
一个用于测试的BenchmarkTest类，为了减少重复代码，写了一个策略模式 

  1. public class BenchmarkTest {
  2.     private int count;
  3.  
  4.     public BenchmarkTest(int count) {
  5.         this.count = count;
  6.         System.out.println("性能测试" + this.count + "==================");
  7.     }
  8.  
  9.     public void benchmark(IMethodCallBack m, FromBean frombean) {
  10.         try {
  11.             long begin = new java.util.Date().getTime();
  12.             ToBean tobean = null;
  13.             System.out.println(m.getMethodName() + "开始进行测试");
  14.             for (int i = 0; i < count; i++) {
  15.  
  16.                 tobean = m.callMethod(frombean);
  17.  
  18.             }
  19.             long end = new java.util.Date().getTime();
  20.             System.out.println(m.getMethodName() + "耗时" + (end - begin));
  21.             System.out.println(tobean.getAddress());
  22.             System.out.println(tobean.getAge());
  23.             System.out.println(tobean.getIdno());
  24.             System.out.println(tobean.getMoney());
  25.             System.out.println(tobean.getName());
  26.             System.out.println("                                      ");
  27.         } catch (Exception e) {
  28.             e.printStackTrace();
  29.         }
  30.     }
  31. }
策略中使用的接口声明
  1. public interface IMethodCallBack {
  2.  
  3.     String getMethodName();
  4.  
  5.     ToBean callMethod(FromBean frombean)  throws Exception;
  6.  
  7. }
使用的测试类 

  1. public class TestMain {
  2.  
  3.     /**
  4.      * @param args
  5.      */
  6.     public static void main(String[] args) {
  7.         FromBean fb = new FromBean();
  8.         fb.setAddress("北京市朝阳区大屯路");
  9.         fb.setAge(20);
  10.         fb.setMoney(30000.111);
  11.         fb.setIdno("110330219879208733");
  12.         fb.setName("测试");
  13.  
  14.         IMethodCallBack beanutilCB = new IMethodCallBack() {
  15.  
  16.             @Override
  17.             public String getMethodName() {
  18.                 return "BeanUtil.copyProperties";
  19.             }
  20.  
  21.             @Override
  22.             public ToBean callMethod(FromBean frombean) throws Exception {
  23.  
  24.                 ToBean toBean = new ToBean();
  25.                 BeanUtils.copyProperties(toBean, frombean);
  26.                 return toBean;
  27.             }
  28.         };
  29.  
  30.         IMethodCallBack propertyCB = new IMethodCallBack() {
  31.  
  32.             @Override
  33.             public String getMethodName() {
  34.                 return "PropertyUtils.copyProperties";
  35.             }
  36.  
  37.             @Override
  38.             public ToBean callMethod(FromBean frombean) throws Exception {
  39.                 ToBean toBean = new ToBean();
  40.                 PropertyUtils.copyProperties(toBean, frombean);
  41.                 return toBean;
  42.             }
  43.         };
  44.  
  45.         IMethodCallBack springCB = new IMethodCallBack() {
  46.  
  47.             @Override
  48.             public String getMethodName() {
  49.                 return "org.springframework.beans.BeanUtils.copyProperties";
  50.             }
  51.  
  52.             @Override
  53.             public ToBean callMethod(FromBean frombean) throws Exception {
  54.                 ToBean toBean = new ToBean();
  55.                 org.springframework.beans.BeanUtils.copyProperties(frombean,
  56.                         toBean);
  57.                 return toBean;
  58.             }
  59.         };
  60.  
  61.         IMethodCallBack cglibCB = new IMethodCallBack() {
  62.             BeanCopier bc = BeanCopier.create(FromBean.class, ToBean.class,
  63.                     false);
  64.  
  65.             @Override
  66.             public String getMethodName() {
  67.                 return "BeanCopier.create";
  68.             }
  69.  
  70.             @Override
  71.             public ToBean callMethod(FromBean frombean) throws Exception {
  72.                 ToBean toBean = new ToBean();
  73.                 bc.copy(frombean, toBean, null);
  74.                 return toBean;
  75.             }
  76.         };
  77.  
  78.         // 数量较少的时候，测试性能
  79.         BenchmarkTest bt = new BenchmarkTest(10);
  80.         bt.benchmark(beanutilCB, fb);
  81.         bt.benchmark(propertyCB, fb);
  82.         bt.benchmark(springCB, fb);
  83.         bt.benchmark(cglibCB, fb);
  84.  
  85.         // 测试一万次性能测试
  86.         BenchmarkTest bt10000 = new BenchmarkTest(10000);
  87.         bt10000.benchmark(beanutilCB, fb);
  88.         bt10000.benchmark(propertyCB, fb);
  89.         bt10000.benchmark(springCB, fb);
  90.         bt10000.benchmark(cglibCB, fb);
  91.  
  92.         // 担心因为顺序问题影响测试结果
  93.         BenchmarkTest bt1000R = new BenchmarkTest(10000);
  94.         bt1000R.benchmark(cglibCB, fb);
  95.         bt1000R.benchmark(springCB, fb);
  96.         bt1000R.benchmark(propertyCB, fb);
  97.         bt1000R.benchmark(beanutilCB, fb);
  98.  
  99.     }
  100.  
  101. }







posted @ 2019-07-10 13:16  No8g攻城狮  阅读(22)  评论(0)  编辑  收藏  举报