对象属性拷贝工具类的性能比较

最新推荐文章于 2023-02-25 23:10:13 发布
转载 最新推荐文章于 2023-02-25 23:10:13 发布 · 219 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/exceptioneye/p/4852962.html

本文对比分析了五种属性拷贝方法（手动拷贝、cglib、Spring BeanUtils、Apache PropertyUtils、Apache BeanUtils）在不同拷贝次数下的性能表现，并讨论了它们的工作原理和注意事项。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 一、对象属性拷贝工具类                                                                                 

    ”天下武功，唯快不破“。在互联网行业中体现的更加淋淋尽致。我们在业务系统会经常遇到业务对象间属性的拷贝，对如外接口一般都使用特定的DTO对象，而不会使用领域模型，以避免两者的变动互相影响。我们不仅要关注“快”，还要注重CPU的稳定即避免CPU使用的大起大落现象。如何高效完成属性的拷贝并降低对CPU的使用率或避免CPU的抖动。

相关博文已经有很多，为什么还要自己在一篇类似的哪？原因有二：一是加深理解二是比较各自优劣。目前对象间属性的拷贝常用的方法大致如下：

  • 手动拷贝(set)
  • 动态代理

       cglib版本：net.sf.cglib.beans.BeanCopier.copy(Object from, Object to, Converter converter)

  • 反射机制

       Spring版本：org.springframework.beans.BeanUtils.copyProperties(Object source, Object target) 

       Apache版本：org.apache.commons.beanutils.PropertyUtils.copyProperties(Object dest, Object orig) 

                          org.apache.commons.beanutils.BeanUtils.copyProperties(Object dest, Object orig)

      DozerMapper

二、实践说明性能优劣                                                                                    

    1、环境

      WIN7 i5，12G内存，

      JVM： 

           java version "1.8.0_51"
           Java(TM) SE Runtime Environment (build 1.8.0_51-b16)
           Java HotSpot(TM) 64-Bit Server VM (build 25.51-b03, mixed mode)

      依赖jar及版本

      

    2、代码结构

      

package test;

/**
 * @author wy
 *
 */
public interface IMethodCallBack {
    public String getMethodName();

    public DestBean callBack(SourceBean sourceBean) throws Exception;
}
View Code
package test;

/**
 * 
 * @author wy
 *
 */
public class CopyProcessor {
    public int count;

    public CopyProcessor(int count) {
        this.count = count;
        System.out.println("性能测试=========" + this.count + "=========");
    }

    public void processor(IMethodCallBack methodCallBack, SourceBean sourceBean) throws Exception {
        long begin = System.currentTimeMillis();
        DestBean destBean = null;
        System.out.println(methodCallBack.getMethodName() + "开始进行测试");
        for (int i = 0; i < count; i++) {
            destBean = methodCallBack.callBack(sourceBean);
        }
        long end = System.currentTimeMillis();
        System.out.println(methodCallBack.getMethodName() + " 耗时 = " + (end - begin) + " 毫秒");

        System.out.println(destBean.getPid());
        System.out.println(destBean.getUserId());
        System.out.println(destBean.getSubTitle());
        System.out.println(destBean.getAlias());
        System.out.println(destBean.getActor());
        System.out.println(destBean.getShortDesc());

        System.out.println("----------------------------------------");
    }

}
View Code
package test;

import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.commons.beanutils.PropertyUtils;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.BeanUtils;

import net.sf.cglib.beans.BeanCopier;

/**
 * 
 * @author wy
 *
 */
public class PerformanceTest {
    public SourceBean sourceBean = null;
    public IMethodCallBack manualCopy = null;
    public IMethodCallBack cglib = null;
    public IMethodCallBack springBeanUtils = null;
    public IMethodCallBack apachePropertyUtils = null;
    public IMethodCallBack apacheBeanUtils = null;

    @Before
    public void init() {
        // 初始化数据
        sourceBean = new SourceBean();
        sourceBean.setPid(Long.valueOf(1001));
        sourceBean.setUserId(Long.valueOf(123));
        sourceBean.setSubTitle("人再囧途之港囧");
        sourceBean.setAlias("港囧");
        Map<String, String> map = new LinkedHashMap<String, String>();
        map.put("主演1", "徐峥");
        map.put("主演2", "包贝尔");
        map.put("主演3", "赵薇");
        sourceBean.setActor(map);
        sourceBean.setShortDesc("徐来和小舅子抱着各自不同目的来到香港，展开了一段阴差阳错、啼笑皆非的旅程，最终两人获得友谊并懂得了人生真谛。");

        // 手动设置属性
        manualCopy = new IMethodCallBack() {

            @Override
            public String getMethodName() {
                return "manual copy";
            }

            @Override
            public DestBean callBack(SourceBean sourceBean) throws Exception {
                DestBean destBean = new DestBean();
                destBean.setActor(sourceBean.getActor());
                destBean.setPid(sourceBean.getPid());
                destBean.setUserId(sourceBean.getUserId().intValue());
                destBean.setShortDesc(sourceBean.getShortDesc());
                destBean.setSubTitle(sourceBean.getSubTitle());
                destBean.setAlias(sourceBean.getAlias());

                return destBean;
            }

        };

        // Cglib
        cglib = new IMethodCallBack() {
            BeanCopier beanCopier = BeanCopier.create(SourceBean.class, DestBean.class, false);

            @Override
            public String getMethodName() {
                return "net.sf.cglib.beans.BeanCopier.create";
            }

            @Override
            public DestBean callBack(SourceBean sourceBean) throws Exception {
                DestBean destBean = new DestBean();
                beanCopier.copy(sourceBean, destBean, null);
                return destBean;
            }

        };

        // Spring BeanUtils
        springBeanUtils = new IMethodCallBack() {

            @Override
            public String getMethodName() {
                return "org.springframework.beans.BeanUtils.copyProperties";
            }

            @Override
            public DestBean callBack(SourceBean sourceBean) throws Exception {
                DestBean destBean = new DestBean();
                BeanUtils.copyProperties(sourceBean, destBean);
                return destBean;
            }

        };

        // Apache PropertyUtils
        apachePropertyUtils = new IMethodCallBack() {

            @Override
            public String getMethodName() {
                return "org.apache.commons.beanutils.PropertyUtils.copyProperties";
            }

            @Override
            public DestBean callBack(SourceBean sourceBean) throws Exception {
                DestBean destBean = new DestBean();
                PropertyUtils.copyProperties(destBean, sourceBean);
                return destBean;
            }

        };

        // Apache BeanUtils
        apacheBeanUtils = new IMethodCallBack() {

            @Override
            public String getMethodName() {
                return "org.apache.commons.beanutils.BeanUtils.copyProperties";
            }

            @Override
            public DestBean callBack(SourceBean sourceBean) throws Exception {
                DestBean destBean = new DestBean();
                org.apache.commons.beanutils.BeanUtils.copyProperties(destBean, sourceBean);
                return destBean;
            }

        };
    }

    // 测试一百次性能测试
    @Test
    public void perform100() throws Exception {
        CopyProcessor processor100 = new CopyProcessor(100);
        processor100.processor(manualCopy, sourceBean);
        processor100.processor(cglib, sourceBean);
        processor100.processor(springBeanUtils, sourceBean);
        processor100.processor(apachePropertyUtils, sourceBean);
        processor100.processor(apacheBeanUtils, sourceBean);

        CopyProcessor processor100R = new CopyProcessor(100);
        processor100R.processor(apacheBeanUtils, sourceBean);
        processor100R.processor(apachePropertyUtils, sourceBean);
        processor100R.processor(springBeanUtils, sourceBean);
        processor100R.processor(cglib, sourceBean);
        processor100R.processor(manualCopy, sourceBean);
    }

    // 测试一千性能测试
    @Test
    public void perform1000() throws Exception {
        CopyProcessor processor1000 = new CopyProcessor(1000);
        processor1000.processor(manualCopy, sourceBean);
        processor1000.processor(cglib, sourceBean);
        processor1000.processor(springBeanUtils, sourceBean);
        processor1000.processor(apachePropertyUtils, sourceBean);
        processor1000.processor(apacheBeanUtils, sourceBean);

        CopyProcessor processor1000R = new CopyProcessor(1000);
        processor1000R.processor(apacheBeanUtils, sourceBean);
        processor1000R.processor(apachePropertyUtils, sourceBean);
        processor1000R.processor(springBeanUtils, sourceBean);
        processor1000R.processor(cglib, sourceBean);
        processor1000R.processor(manualCopy, sourceBean);
    }

    // 测试一万次性能测试
    @Test
    public void perform10000() throws Exception {
        CopyProcessor processor10000 = new CopyProcessor(10000);
        processor10000.processor(manualCopy, sourceBean);
        processor10000.processor(cglib, sourceBean);
        processor10000.processor(springBeanUtils, sourceBean);
        processor10000.processor(apachePropertyUtils, sourceBean);
        processor10000.processor(apacheBeanUtils, sourceBean);

        CopyProcessor processor10000R = new CopyProcessor(10000);
        processor10000R.processor(apacheBeanUtils, sourceBean);
        processor10000R.processor(apachePropertyUtils, sourceBean);
        processor10000R.processor(springBeanUtils, sourceBean);
        processor10000R.processor(cglib, sourceBean);
        processor10000R.processor(manualCopy, sourceBean);
    }

    // 测试十万次性能测试
    @Test
    public void perform100000() throws Exception {
        CopyProcessor processor100000 = new CopyProcessor(100000);
        processor100000.processor(manualCopy, sourceBean);
        processor100000.processor(cglib, sourceBean);
        processor100000.processor(springBeanUtils, sourceBean);
        processor100000.processor(apachePropertyUtils, sourceBean);
        processor100000.processor(apacheBeanUtils, sourceBean);

        processor100000.processor(apacheBeanUtils, sourceBean);
        processor100000.processor(apachePropertyUtils, sourceBean);
        processor100000.processor(springBeanUtils, sourceBean);
        processor100000.processor(cglib, sourceBean);
        processor100000.processor(manualCopy, sourceBean);
    }

    // 测试一百万次性能测试
    @Test
    public void perform1000000() throws Exception {
        CopyProcessor processor1000000 = new CopyProcessor(1000000);
        processor1000000.processor(manualCopy, sourceBean);
        processor1000000.processor(cglib, sourceBean);
        processor1000000.processor(springBeanUtils, sourceBean);
        processor1000000.processor(apachePropertyUtils, sourceBean);
        processor1000000.processor(apacheBeanUtils, sourceBean);

        CopyProcessor processor1000000R = new CopyProcessor(1000000);
        processor1000000R.processor(apacheBeanUtils, sourceBean);
        processor1000000R.processor(apachePropertyUtils, sourceBean);
        processor1000000R.processor(springBeanUtils, sourceBean);
        processor1000000R.processor(cglib, sourceBean);
        processor1000000R.processor(manualCopy, sourceBean);
    }
}
View Code

　

    3、结果比较   

一百次性能测试第一次(毫秒)第二次(毫秒)第三次(毫秒)每次平均值(毫秒)
manualCopy0110.0066666666666667
cglib1220.0166666666666667
springBeanUtils1771811921.833333333333333
apachePropertyUtils1792071921.926666666666667
apacheBeanUtils9694890.93

 

一千次性能测试第一次(毫秒)第二次(毫秒)第三次(毫秒)每次平均值(毫秒)
manualCopy1120.0013333333333333
cglib1311120.012
springBeanUtils2722612860.273
apachePropertyUtils4504314440.4416666666666667
apacheBeanUtils3493533600.354

 

一万次性能测试第一次(毫秒)第二次(毫秒)第三次(毫秒)每次平均值(毫秒)
manualCopy 2 3 4 0.0003
cglib 16 18 17 0.0016
springBeanUtils 526 554 532 0.0537333333333333
apachePropertyUtils 1888 1848 1832 0.1856
apacheBeanUtils 2210 2150 2162 0.2174

 

十万次性能测试第一次(毫秒)第二次(毫秒)第三次(毫秒)每次平均值(毫秒)
manualCopy 26 24 26 0.00025333
cglib 48 51 48 0.00049
springBeanUtils 1949 1956 1881 0.0192866666666667
apachePropertyUtils 14741 15478 15065 0.1509466666666667
apacheBeanUtils 19506 19800 19753 0.1968633333333333

        输出结果： manualCopy > cglibCopy > springBeanUtils > apachePropertyUtils > apacheBeanUtils 可以理解为: 手工复制 > cglib > 反射。

        对于最求速度的属性拷贝，建议使用手动设置拷贝，虽然代码会变得臃肿不堪。

    4、原理说明

反射类型：

都使用静态类调用，最终转化虚拟机中两个单例的工具对象。

public BeanUtilsBean()

{

  this(new ConvertUtilsBean(), new PropertyUtilsBean());

}

ConvertUtilsBean可以通过ConvertUtils全局自定义注册。

ConvertUtils.register(new DateConvert(), java.util.Date.class);

PropertyUtilsBean的copyProperties方法实现了拷贝的算法。

1、  动态bean：orig instanceof DynaBean：Object value = ((DynaBean)orig).get(name);然后把value复制到动态bean类

2、  Map类型：orig instanceof Map：key值逐个拷贝

3、  其他普通类：：从beanInfo【每一个对象都有一个缓存的bean信息，包含属性字段等】取出name，然后把sourceClass和targetClass逐个拷贝

 

Cglib类型：BeanCopier

copier = BeanCopier.create(source.getClass(), target.getClass(), false);

copier.copy(source, target, null);

Create对象过程：产生sourceClass-》TargetClass的拷贝代理类，放入jvm中，所以创建的代理类的时候比较耗时。最好保证这个对象的单例模式，可以参照最后一部分的优化方案。

创建过程：源代码见jdk：net.sf.cglib.beans.BeanCopier.Generator.generateClass(ClassVisitor)

1、  获取sourceClass的所有public get 方法-》PropertyDescriptor[] getters

2、  获取TargetClass 的所有 public set 方法-》PropertyDescriptor[] setters

3、  遍历setters的每一个属性，执行4和5

4、  按setters的name生成sourceClass的所有setter方法-》PropertyDescriptor getter【不符合javabean规范的类将会可能出现空指针异常】

5、  PropertyDescriptor[] setters-》PropertyDescriptor setter

6、  将setter和getter名字和类型 配对，生成代理类的拷贝方法。

Copy属性过程：调用生成的代理类，代理类的代码和手工操作的代码很类似，效率非常高。

     Apache BeanUtils.copyProperties会进行类型转换，而Apache PropertyUtils.copyProperties不会。 既然进行了类型转换，那BeanUtils.copyProperties的速度比不上PropertyUtils.copyProperties。我们从上面的实践中得到了验证。

 

三、注意事项                                                                                                

注意事项是否支持扩展useConvete功能相同属性名，且类型不匹配时候的处理Set和Get方法不匹配的处理 对于空字段的处理 
manualCopy ---- ---- ---- ---- 
cglib支持

只拷贝名称和类型都相同的属性，

名称相同而类型不同的属性不会被拷贝

OK

包装类型未设置值字段，默认设置null
基本数据类型未设置值字段，

默认设置0或0.0

 
springBeanUtils支持

能正常拷贝并进行初级转换，Long和Integer互转

OK  
apachePropertyUtils不支持异常 java.lang.IllegalArgumentException: argument type mismatchOK  
apacheBeanUtils支持能正常拷贝并进行初级转换，Long和Integer互转OK  

 

对于未设置值的field字段，无论是基本数据类型还是包装类型、集合的值都是各自的默认值。

 

四、总结                                                                                                                                                                                                                       

   1、追求高效率的属性拷贝请使用手工设置属性(set)

   2、在使用工具进行属性拷贝时，要注意程序的健壮性即日期Date、各种类型的变量的初始值。

 

参考：http://grefr.iteye.com/blog/1880008

 

由于本人经验有限，文章中难免会有错误，请浏览文章的您指正或有不同的观点共同探讨！ 

 

转载于:https://www.cnblogs.com/exceptioneye/p/4852962.html

封装BeanCopier工具，支持单个对象以及列表拷贝，超高性能简单实用
学而时习之
10-17 3868
说明 前几天写了一个关于Spring BeanUtils的封装类代码片段六：BeanUtils.copyProperties扩展复制列表，然后又发现了一款性能更好的工具BeanCopier，这款工具性能比较好，但是易用性稍差，故而封装一下，分享出来。由于使用上和上面????那个基本一致，故不作过多介绍。至于性能提升多少，小伙伴们可以参考各类对象属性拷贝工具性能测试对比（BeanCopier、BeanUt...
BeanUtil属性拷贝工具类
04-05
BeanUtil属性拷贝工具类，支持基本的javabean属性拷贝，通过java反射和泛型编程实现了list属性拷贝
对象属性值的复制工具类
09-03
对象属性值的复制工具类 1.全复制 2.部分复制 3.部分不复制
几种常见的属性拷贝工具类性能对比（Spring BeanUtils 、Apache BeanUtils等）
weixin_43581193的博客
08-18 1978
1、背景 在日常开发中，我们经常需要给对象进行赋值，通常会调用其set/get方法，有些时候，如果我们要转换的两个对象之间属性大致相同，就会考虑使用属性拷贝工具进行。 例如我们经常在代码中会对一个数据结构封装成DO、SDO、DTO、VO等，而这些Bean中的大部分属性都是一样的，所以使用属性拷贝类工具可以帮助我们节省大量的set和get操作。 市面上有很多类似的工具类，比较常用的有： Spring BeanUtils Cglib BeanCopier Apache BeanUtils Apache Pro
复制属性的工具类
howroad的博客
06-08 938
在开发中进行遇到值对象和实体间的数据复制. 其中最常用的为Apache BeanUtilsBean的copyProperties. 本次测试发现该工具可兼容大部分数据格式,但在Java.sql.Date和java.util.Date复制时,原数据如为空将发送报错. 通过注册BeanUtilsBean的转换器,简单封装copyProperties方法. 完成效果: 调用封装后的工具类方法复制...
对象拷贝性能对比分析
乂星人
04-05 1131
对象拷贝可分为浅拷贝和深拷贝，在开发过程中深拷贝不是随处可见，大部分是引用的赋值，也即是内存地址的引用。如果简单的类似Student studen1 = student0这样便认为复制了一份，这就大错特错了，有些时候你会莫名的发现studen1没有任何操作里面的属性却发生变化了，不用说一定是student0在某个时候被修改了，因为这两个对象引用的是一个地址的内容。开发过程中，因为嵌套过深，对象中转...
对象属性复制工具类
易先生
06-26 601
具有相同属性名称的对象之间的属性值复制，具体代码如下public class BeanUtil { /** * 利用反射实现对象之间相同属性复制 * * @param source 要复制的 * @param target 复制给 */ public static void copyProperties(Object source, O
BeanConvertor工具类Java开发Bean转换拷贝工具类
09-18
适合人群：有一定Java开发经验，了解对象属性拷贝和反射机制的研发人员，尤其适用于需要处理复杂对象转换的中级Java开发者。 能学到什么：通过本资源，读者将学习到以下内容： 如何使用Java反射机制进行对象属性...
ShengMapper：快速高效.NET对象属性拷贝工具
根据所提供的信息，我们可以对标题...在开发实践中有广泛的应用，尤其适合那些需要高效处理大量对象属性拷贝任务的场景。因此，掌握此类工具的使用，对.NET开发人员来说，是提高工作效率和软件质量的重要手段之一。
java相关的bean深拷贝工具
最新发布
04-26
2. 使用Apache Commons BeanUtils：Apache Commons库提供了一套方便的工具类，可以实现复杂的bean属性拷贝。通过使用BeanUtils类的copyProperties方法，可以对bean进行深拷贝操作，但需要注意的是，这种方法依赖于...
Java BeanConvertor工具类实现高效属性拷贝
资源摘要信息:"BeanConvertor工具类Java开发Bean转换拷贝工具类" Bean转换拷贝工具类在Java开发中是一个非常实用的功能，尤其是在需要处理对象属性映射和数据转换的场景中。本资源所介绍的BeanConvertor工具类，...
对象属性拷贝工具类
xiangwang2016的博客
02-23 388
相同的：都是浅拷贝，都提供了copyProperties()方法，只要属性名相同就可以从源bean中拷贝值到目标bean中不同点：BeanUtils.copyProperties提供类型转换功能,BeanUtils会调用默认的转换器（Converter）进行类型转换，所以在拷贝时能对八个基本类型间进行转换，不能转换时抛出错误 PropertyUtils.copyProperties不提供类...
属性拷贝工具类封装
jgdabc的博客
02-25 455
集合类型的拷贝也是一样的了，先把集合对象处理为流，对其中的每个对象都执行到拷贝，然后拷贝完后收集起来返回一个拷贝完成后的新的集合。其实原理和上面一样就是利用的反射。一共分为单个对象类拷贝，和集合类型拷贝。属性拷贝主要就是用于封装一些必要的数据。这是一个工具类封装的一个现成的方法，内部实现的原理就是利用反射实现对象的拷贝。下面这里是一个拷贝方法，参数是源对类和要拷贝的对象的字节码 .class。来看我们普通的反射如何实现对象的拷贝。先来看简单的反射如何实现对象拷贝。简单的记录，方便cv。
一个Bean属性拷贝的工具类
白强
02-05 233
  package com.fpi.spring.qaepb.cps.util; import java.beans.IntrospectionException; import java.beans.PropertyDescriptor; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutp...
开发必备：主流对象复制框架使用与比较
Java极客技术
03-02 934
在 Java 生态中，有很多第三方框架可以进行对象复制，分别是Apache的BeanUtils和PropertyUtils、Spring的BeanUtils、Cglib的BeanCopi...
对象属性拷贝工具类大全==>Bean的属性拷贝从此不用愁
dejianqiu6073的博客
04-17 221
大家在做java开发时，肯定会遇到api层参数对象传递给服务层，或者把service层的对象传递给dao层，他们之间又不是同一个类型对象，但字段又是一样，如果还是用普通的get、set方式来处理话，比较繁琐，.... 那么你来跟我学....."天下武功，唯快不破"===>要的就是快....1.使用get/set不用说了,字段一多脑壳大....2.BeanCopier 使用了cgli...
Java常用属性拷贝工具类使用总结
香农三定律的博客
03-28 1580
Java常用属性拷贝工具类使用总结引言字段与属性使用说明原理剖析 引言 对项目中经常使用的属性拷贝工具类进行总结： org.apache.commons.beanutils.BeanUtils org.apache.commons.beanutils.PropertyUtils org.springframework.beans.BeanUtils 字段与属性 public class UserTest{ private String userName; private String p
阿里巴巴为什么禁止使用Apache Beanutils进行属性复制？
磊哥聊Java
09-10 296
作者 l Hollis来源 l Hollis（ID：hollischuang）在日常开发中，我们经常需要给对象进行赋值，通常会调用其set/get方法，有些时候，如果我们要转换的两个对象...
Java常用17个工具类方法，提升开发效率的“轮子”，避免重复造轮子
代码时光
06-29 5087
首先出场的是java.util包下的Collections类，该类主要用于操作集合或者返回集合，我个人非常喜欢用它。在工作中经常有对集合排序的需求。看看使用Collections工具是如何实现升序和降序的： 执行结果： 1.2 获取最大或最小值 有时候需要找出集合中的最大值或者最小值，这时可以使用Collections的max和min方法。例如： 执行结果： 1.3 转换线程安全集合 我们都知道，java中的很多集合，比如：ArrayList、LinkedList、HashMap、HashSet等，都是线程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值