【转载】主流对象复制框架使用与比较

在 Java 生态中，有很多第三方框架可以进行对象复制，分别是Apache的BeanUtils和PropertyUtils、Spring的BeanUtils、Cglib的BeanCopier等，下面我们一起来了解一下吧！

一、摘要

对象复制，在实际开发中也是经常需要使用到的，想必最傻瓜式的就是创建一个对象，然后一个一个属性进行set/get，但是如果面对一个对象有100多个属性的情况，显然这种方法效率底、而且容易出错！

当然也有办法，使用 Java 提供的克隆方法，也可以实现对象拷贝，但是 Java 提供的对象拷贝，只能进行浅克隆，如果要进行深度克隆，可以使用序列化流实现对象深度复制。

虽然上述方法，可以解决对象的复制，假如我们有两个类，属性都基本一样，现在的你想要实现属性参数值复制，应该怎么解决呢？

其实解决思路很简单，就是找到两个类的名称、类型是否一致，如果一致，就将要复制的对象内容拷贝到另一个对象的属性上。

当然，在 Java 生态中已经有很多成熟的第三方框架实现了这一功能，在这里，介绍一下 java 的 Bean 复制框架，分别有Apache的BeanUtils和PropertyUtils、Spring的BeanUtils、Cglib的BeanCopier等。

也不多说了，直接撸代码！

二、方法介绍

下面我们来创建两个类FromBean、ToBean，两个类除了名称不一样，属性都一样，如下：

public class FromBean {    
    private String id;    
    private String name;    
    private Integer age;    
    private Date createTime;    
    private BigDecimal money;    
    //... 省略 setter 和 getter
}

public class ToBean {    
    private String id;    
    private String name;    
    private Integer age;    
    private Date createTime;    
    private BigDecimal money;    
    //... 省略 setter 和 getter
}

为了后面更好的比较各个框架的性能，这里使用策略模式，来实现各个方法，先新建一个对象复制接口，如下：

public interface BeanCopyService {    
    /**     
    * 使用的工具包名称    
    * @return     
    */    
    String methodName();    
    /**     
    * 执行复制     
    * @param fromBean     
    * @return     
    */    
    ToBean copyProperty(FromBean fromBean) throws Exception;
}

新建一个对象复制策略类，如下：

public class BeanCopyStragegy {    
    /**     
    * 进行复制     
    * @param beanCopyService     
    * @param fromBean     
    */    
    public void execute(BeanCopyService beanCopyService, FromBean fromBean) throws Exception {        
        System.out.println("=========================");        
        System.out.println("使用的工具包：" + beanCopyService.methodName());        
        ToBean toBean = beanCopyService.copyProperty(fromBean);         
        System.out.println("复制后的对象：" + JSON.toJSONString(toBean));    
    }
}

最后，创建一个测试类，如下：

public class BeanCopyClient {    
    public static void main(String[] args) throws Exception {        
        //初始化一个源对象bean        
        FromBean fromBean = new FromBean();        
        fromBean.setId("ID0001");        
        fromBean.setName("张三");        
        fromBean.setAge(18);        
        fromBean.setCreateTime(new Date());        
        fromBean.setMoney(new BigDecimal(100));        
        //apache的BeanUtils        
        BeanCopyService apacheBeanUtils = new BeanCopyService() {            
            @Override            
            public String methodName() {                
                return "apache BeanUtils";            
            }            
            @Override            
            public ToBean copyProperty(FromBean fromBean) throws Exception {                
                ToBean toBean = new ToBean();                
                org.apache.commons.beanutils.BeanUtils.copyProperties(toBean,fromBean);                
                return toBean;            
            }        
        };        
        //apache的PropertyUtils        
        BeanCopyService apachePropertyUtils = new BeanCopyService() {            
            @Override            
            public String methodName() {                
                return "apache PropertyUtils";            
            }            
            @Override            
            public ToBean copyProperty(FromBean fromBean) throws Exception {                
                ToBean toBean = new ToBean();                
                org.apache.commons.beanutils.PropertyUtils.copyProperties(toBean,fromBean);                
                return toBean;            
            }        
        };        
        //spring的BeanUtils        
        BeanCopyService springBeanUtils = new BeanCopyService() {            
            @Override            
            public String methodName() {                
                return "spring BeanUtils";            
            }            
            @Override            
            public ToBean copyProperty(FromBean fromBean) throws Exception {                
                ToBean toBean = new ToBean();                
                org.springframework.beans.BeanUtils.copyProperties(fromBean, toBean);                
                return toBean;            
            }        
        };        
        //cglib的BeanCopier        
        BeanCopyService cglibBeanCopier = new BeanCopyService() {            
            @Override            
            public String methodName() {                
                return "cglib BeanCopier";            
            }            
            @Override            
            public ToBean copyProperty(FromBean fromBean) throws Exception {                
                ToBean toBean = new ToBean();                
                net.sf.cglib.beans.BeanCopier.create(FromBean.class, ToBean.class, false).copy(fromBean, toBean, null);                
                return toBean;            
            }        
        };        
        System.out.println("源对象的内容：" + JSON.toJSONString(fromBean));       
        //进行测试       
        BeanCopyStragegy stragegy = new BeanCopyStragegy();       
        stragegy.execute(apacheBeanUtils, fromBean);//apache的BeanUtils       
        stragegy.execute(apachePropertyUtils, fromBean);//apache的PropertyUtils       
        stragegy.execute(springBeanUtils, fromBean);//spring的BeanUtils       
        stragegy.execute(cglibBeanCopier, fromBean);//cglib的BeanCopier    
}}

运行程序，输出结果如下：

其中 apache 提供了2个类来实现对象复制，分别是BeanUtils和PropertyUtils，这两者的区别在于BeanUtils提供类型转换功能，即发现两个JavaBean的同名属性为不同类型时，在支持的数据类型范围内进行转换，而PropertyUtils不支持这个功能！

关于这点，我们将ToBean类中的money类型修改成String，如下：

public class ToBean {    
    private String id;    
    private String name;    
    private Integer age;    
    private Date createTime;    
    private String money;//修改money的类型为String    
    //... 省略 setter 和 getter
}

在运行程序，输入结果如下：

从结果可以看出，apache的BeanUtils依然可以完整复制，但是PropertyUtils报错！

而spring的BeanUtils和cglib的BeanCopier，因为属性对应的类型不一致，直接跳过复制！

既然，四者都可以复制，我们从性能角度来观察一下各个框架复制的效率如下，我们将BeanCopyStragegy类进行改造，如下：

public class BeanCopyStragegy {    
    private Integer count;    
    public BeanCopyStragegy(Integer count) {        
        this.count = count;    
    }    
    /**     
    * 进行复制     
    * @param beanCopyService     
    * @param fromBean     
    */   
    public void execute(BeanCopyService beanCopyService, FromBean fromBean) throws Exception {
        System.out.print("使用的工具包：" + beanCopyService.methodName());        
        long start = System.currentTimeMillis();        
        for (int i = 0; i < count; i++) {            
            ToBean toBean = beanCopyService.copyProperty(fromBean);        
        }        
        System.out.print("循环复制对象"+count+"次，耗时：" + (System.currentTimeMillis() - start) +"\n");    
    }
}

在测试的时候，传入循环次数！

//传入循环次数，进行测试
BeanCopyStragegy stragegy = new BeanCopyStragegy(10);

我们分别传入10、100、1000、10000、100000，最终各个框架耗时结果如下：

可能每台机器测试结果有差异，从结果可以得出如下结论：

• 在低频次下，apache的PropertyUtils效率最高，在高频次下，cglib BeanCopier效率最高；
• apache的BeanUtils，在四个框架中效率最低；
• 在高频次下，spring的BeanUtils的效率仅次于cglib BeanCopier；

三、总结

因为apache的BeanUtils在进行复制的时候，在支持的数据类型范围内进行转换，所有性能会有些损失，对于数据结构严谨的复制，不建议采用！