Bean复制的几种框架性能比较(BeanUtils、PropertyUtils、BeanCopier)

开发 后端
阅读代码的诸多好处就不说了,我就直奔主题,通过预读代码,发现了几种实现两个不同类型的Bean之间实现值复制的几种方式,上网查询后发现性能上会有差异,于是就萌生自己深入了解几种实现的想法。

 作为一个新员工,一个首要的工作就是阅读别人的代码,阅读代码的诸多好处就不说了,我就直奔主题,通过预读代码,发现了几种实现两个不同类型的Bean之间实现值复制的几种方式,上网查询后发现性能上会有差异,于是就萌生自己深入了解几种实现的想法。第一步就是先本着实事求是的原则去探求一下大家总结出来的性能差异是否正确。

比较的是四种复制的方式,分别为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.     public double getMoney() {  
  8.         return money;  
  9.     }   
  10.     public void setMoney(double money) {  
  11.         this.money = money;  
  12.     }  
  13.     public String getName() {  
  14.         return name;  
  15.     }   
  16.     public void setName(String name) {  
  17.         this.name = name;  
  18.     }  
  19.     public int getAge() {  
  20.         return age;  
  21.     }   
  22.     public void setAge(int age) {  
  23.         this.age = age;  
  24.     }   
  25.     public String getAddress() {  
  26.         return address;  
  27.     }  
  28.     public void setAddress(String address) {  
  29.         this.address = address;  
  30.     }  
  31.     public String getIdno() { 
  32.          return idno;  
  33.     } 
  34.     public void setIdno(String idno) {  
  35.         this.idno = idno;  
  36.     }   

一个用于测试的BenchmarkTest类,为了减少重复代码,写了一个策略模式 

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

策略中使用的接口声明 

  1. public interface IMethodCallBack {  
  2.     String getMethodName();  
  3.     ToBean callMethod(FromBean frombean)  throws Exception;  

使用的测试类 

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

进行了三次测试,最后的结果如下:

不过需要注意的是,Cglib在测试的时候,先进行了实例的缓存,这个也是他性能较好的原因之一。如果把缓存去掉的话,性能就会出现了一些的差异,但是整体的性能还是很好,不过奇怪的是10000次反而比10次少,而且后面的反转1万次反而耗时最少,进行多次测试效果也是如此。

从整体的表现来看,Cglib的BeanCopier的性能是最好的无论是数量较大的1万次的测试,还是数量较少10次,几乎都是趋近与零损耗,Spring是在次数增多的情况下,性能较好,在数据较少的时候,性能比PropertyUtils的性能差一些。

PropertyUtils的性能相对稳定,表现是呈现线性增长的趋势。而Apache的BeanUtil的性能最差,无论是单次Copy还是大数量的多次Copy性能都不是很好。

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

 

责任编辑:庞桂玉 来源: Java知音
相关推荐

2021-05-31 10:16:04

代码Java工具

2011-04-15 10:26:38

JavaMVC

2021-01-13 05:25:49

框架代码性能

2013-12-16 10:20:48

MySQL数据库

2009-05-25 08:39:08

iPhone苹果移动OS

2012-12-03 10:26:51

Scala

2009-07-01 18:12:18

JSP的优势性能比较

2020-10-23 07:43:37

Log配置性能

2011-05-18 14:52:04

XML

2023-11-20 10:34:09

语言

2015-02-05 09:25:51

HTTPSSPDYHTTP2

2011-07-06 14:18:40

Percona SerMySQL

2010-03-10 16:35:23

Python编程语言

2020-07-27 08:24:42

编程语言C语言Java

2009-12-16 14:10:12

路由技术性能比较

2023-11-19 21:17:58

GoRust

2009-12-04 19:28:25

FreeBSD 8.0Ubuntu 9.10性能比较

2010-12-27 16:01:45

jQuery选择器

2017-12-14 10:16:01

CaddySSLDockerNginx

2014-08-20 09:49:50

虚拟机Linux Conta
点赞
收藏

51CTO技术栈公众号