你还在用BeanUtils进行对象属性拷贝？

一、背景

1.1 对象拷贝概念

Java中，数据类型分为值类型（基本数据类型）和引用类型，值类型包括int、double、byte、boolean、char等简单数据类型，引用类型包括类、接口、数组等复杂类型。

对象拷贝分为浅拷贝(浅克隆)与深拷贝(深克隆)。

  • 浅拷贝与深拷贝差异

1.2 示例前准备

  • 源对象属性类UserDO.class(以下示例，源对象都用这个)
@Datapublic class UserDO {

    private int id;    private String userName;    /**     * 以下两个字段用户模拟自定义转换     */    private LocalDateTime gmtBroth;    private BigDecimal balance;

    public UserDO(Integer id, String userName, LocalDateTime gmtBroth, BigDecimal balance) {        this.id = id;        this.userName = userName;        this.gmtBroth = gmtBroth;        this.balance = balance;    }}
  • 造数据工具类DataUtil.class
public class DataUtil {

    /**     * 模拟查询出一条数据     * @return     */    public static UserDO createData() {        return new UserDO(1, "Van", LocalDateTime.now(),new BigDecimal(100L));    }

    /**     * 模拟查询出多条数据     * @param num 数量     * @return     */    public static List<UserDO> createDataList(int num) {        List<UserDO> userDOS = new ArrayList<>();        for (int i = 0; i < num; i++) {            UserDO userDO = new UserDO(i+1, "Van", LocalDateTime.now(),new BigDecimal(100L));            userDOS.add(userDO);        }        return userDOS;    }}

二、对象拷贝之BeanUtils

Apache和Spring均有BeanUtils工具类， Apache的BeanUtils稳定性与效率都不行;Spring的BeanUtils比较稳定，不会因为量大了，耗时明显增加，故一般都使用Spring的BeanUtils。

2.1 源码解读

Spring中的BeanUtils，其中实现的方式很简单，就是对两个对象中相同名字的属性进行简单get/set，仅检查属性的可访问性。

BeanUtils 源码

可以看到, 成员变量赋值是基于目标对象的成员列表, 并且会跳过ignore的以及在源对象中不存在的, 所以这个方法是安全的, 不会因为两个对象之间的结构差异导致错误, 但是必须保证同名的两个成员变量类型相同。

2.2 示例

@Slf4jpublic class BeanUtilsDemo {

    public static void main(String[] args) {        long start = System.currentTimeMillis();        UserDO userDO = DataUtil.createData();        log.info("拷贝前,userDO:{}", userDO);        UserDTO userDTO = new UserDTO();        BeanUtils.copyProperties(userDO,userDTO);        log.info("拷贝后,userDO:{}", userDO);    }}
  • 结果
18:12:11.734 [main] INFO cn.van.parameter.bean.copy.demo.BeanUtilsDemo - 拷贝前,userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T18:12:11.730, balance=100)18:12:11.917 [main] INFO cn.van.parameter.bean.copy.demo.BeanUtilsDemo - 拷贝后,userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T18:12:11.730, balance=100)

三、对象拷贝之BeanCopier

BeanCopier是用于在两个bean之间进行属性拷贝的。BeanCopier支持两种方式:

  1. 一种是不使用Converter的方式，仅对两个bean间属性名和类型完全相同的变量进行拷贝;
  2. 另一种则引入Converter，可以对某些特定属性值进行特殊操作。

3.1 基本使用

  • 依赖
<dependency>    <groupId>cglib</groupId>    <artifactId>cglib-nodep</artifactId>    <version>3.3.0</version></dependency>

**注意：**该依赖非必须，因为Spring中已经集成了cglib,博主使用的就是org.springframework.cglib.beans.BeanCopier。

3.1.1 属性名称、类型都相同

  • 目标对象属性类
@Datapublic class UserDTO {    private int id;    private String userName;}
  • 测试方法
/** * 属性名称、类型都相同(部分属性不拷贝) */private static void normalCopy() {	// 模拟查询出数据    UserDO userDO = DataUtil.createData();    log.info("拷贝前：userDO:{}", userDO);    // 第一个参数：源对象， 第二个参数：目标对象，第三个参数：是否使用自定义转换器（下面会介绍），下同    BeanCopier b = BeanCopier.create(UserDO.class, UserDTO.class, false);    UserDTO userDTO = new UserDTO();    b.copy(userDO, userDTO, null);    log.info("拷贝后：userDTO:{}", userDTO);}
  • 结果：拷贝成功
18:24:24.080 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝前：userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T18:24:24.077, balance=100)18:24:24.200 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝后：userDTO:UserDTO(id=1, userName=Van)

3.1.2 属性名称相同、类型不同

  • 目标对象属性类
@Datapublic class UserEntity {    private Integer id;    private String userName;}
  • 测试方法
/** * 属性名称相同、类型不同 */private static void sameNameDifferentType() {    // 模拟查询出数据    UserDO userDO = DataUtil.createData();    log.info("拷贝前：userDO:{}", userDO);

    BeanCopier b = BeanCopier.create(UserDO.class, UserEntity.class, false);    UserEntity userEntity = new UserEntity();    b.copy(userDO, userEntity, null);    log.info("拷贝后：userEntity:{}", userEntity);}
  • 结果
19:43:31.645 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝前：userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T19:43:31.642, balance=100)19:43:31.748 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝后：userEntity:UserEntity(id=null, userName=Van)
  • 分析

通过日志可以发现：UserDO的int类型的id无法拷贝到UserEntity的Integer的id。

3.1.3 小节

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

即使源类型是原始类型(int, short和char等)，目标类型是其包装类型(Integer, Short和Character等)，或反之：都不会被拷贝。

3.2 自定义转换器

通过3.1.2可知，当源和目标类的属性类型不同时，不能拷贝该属性，此时我们可以通过实现Converter接口来自定义转换器

3.2.1 准备

  • 目标对象属性类
@Datapublic class UserDomain {    private Integer id;    private String userName;

    /**     * 以下两个字段用户模拟自定义转换     */    private String gmtBroth;    private String balance;}

3.2.2 不使用Converter

  • 测试方法
/** * 类型不同,不使用Converter */public static void noConverterTest() {    // 模拟查询出数据    UserDO userDO = DataUtil.createData();    log.info("拷贝前：userDO:{}", userDO);    BeanCopier copier = BeanCopier.create(UserDO.class, UserDomain.class, false);    UserDomain userDomain = new UserDomain();    copier.copy(userDO, userDomain, null);    log.info("拷贝后：userDomain:{}", userDomain);}
  • 结果
19:49:19.294 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝前：userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T19:49:19.290, balance=100)19:49:19.394 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝后：userDomain:UserDomain(id=null, userName=Van, gmtBroth=null, balance=null)
  • 分析

通过打印日志的前后对比，属性类型不同的字段id,gmtBroth,balance未拷贝。

3.2.3 使用Converter

  • 实现Converter接口来自定义属性转换
public  class UserConverter implements Converter {

    /**     * 时间转换的格式     */    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    /**     * 自定义属性转换     * @param value 源对象属性类     * @param target 目标对象里属性对应set方法名,eg.setId     * @param context 目标对象属性类     * @return     */    @Override    public Object convert(Object value, Class target, Object context) {        if (value instanceof Integer) {            return value;        } else if (value instanceof LocalDateTime) {            LocalDateTime date = (LocalDateTime) value;            return dtf.format(date);        } else if (value instanceof BigDecimal) {            BigDecimal bd = (BigDecimal) value;            return bd.toPlainString();        }        // 更多类型转换请自定义        return value;    }}
  • 测试方法
/** * 类型不同,使用Converter */public static void converterTest() {    // 模拟查询出数据    UserDO userDO = DataUtil.createData();    log.info("拷贝前：userDO:{}", userDO);    BeanCopier copier = BeanCopier.create(UserDO.class, UserDomain.class, true);    UserConverter converter = new UserConverter();    UserDomain userDomain = new UserDomain();    copier.copy(userDO, userDomain, converter);    log.info("拷贝后：userDomain:{}", userDomain);}
  • 结果：全部拷贝
19:51:11.989 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝前：userDO:UserDO(id=1, userName=Van, gmtBroth=2019-11-02T19:51:11.985, balance=100)

3.2.4 小节

  1. 一旦使用Converter，BeanCopier只使用Converter定义的规则去拷贝属性，所以在convert()方法中要考虑所有的属性。
  2. 但，使用Converter会使对象拷贝速度变慢。

3.3 BeanCopier总结

  1. 当源类和目标类的属性名称、类型都相同，拷贝没问题。
  2. 当源对象和目标对象的属性名称相同、类型不同,那么名称相同而类型不同的属性不会被拷贝。注意，原始类型（int，short，char）和 他们的包装类型，在这里都被当成了不同类型，因此不会被拷贝。
  3. 源类或目标类的setter比getter少，拷贝没问题，此时setter多余，但是不会报错。
  4. 源类和目标类有相同的属性（两者的getter都存在），但是目标类的setter不存在，此时会抛出NullPointerException。

四、BeanUtils与BeanCopier速度对比

废话不多说，我这里直接演示两种工具10000条数据拷贝的耗时对比

4.1 BeanUtils

  • 测试代码
private static void beanUtil() {    List<UserDO> list = DataUtil.createDataList(10000);    long start = System.currentTimeMillis();    List<UserDTO> dtoList = new ArrayList<>();    list.forEach(userDO -> {        UserDTO userDTO = new UserDTO();        BeanUtils.copyProperties(userDO,userDTO);        dtoList.add(userDTO);    });    log.info("BeanUtils cotTime: {}ms", System.currentTimeMillis() - start);}
  • 结果(耗时：232ms)
20:14:24.380 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopyComparedDemo - BeanUtils cotTime: 232ms

4.2 BeanCopier

  • 测试代码
private static void beanCopier() {    // 工具类生成10w条数据    List<UserDO> doList = DataUtil.createDataList(10000);    long start = System.currentTimeMillis();    List<UserDTO> dtoList = new ArrayList<>();    doList.forEach(userDO -> {        BeanCopier b = BeanCopier.create(UserDO.class, UserDTO.class, false);        UserDTO userDTO = new UserDTO();        b.copy(userDO, userDTO, null);        dtoList.add(userDTO);    });    log.info("BeanCopier costTime: {}ms", System.currentTimeMillis() - start);}
  • 结果(耗时：116ms)
20:15:24.380 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopyComparedDemo - BeanCopier costTime: 116ms

4.3 缓存BeanCopier实例提升性能

BeanCopier拷贝速度快，性能瓶颈出现在创建BeanCopier实例的过程中。 所以，把创建过的BeanCopier实例放到缓存中，下次可以直接获取，提升性能。

  • 测试代码
private static void beanCopierWithCache() {

    List<UserDO> userDOList = DataUtil.createDataList(10000);    long start = System.currentTimeMillis();    List<UserDTO> userDTOS = new ArrayList<>();    userDOList.forEach(userDO -> {        UserDTO userDTO = new UserDTO();        copy(userDO, userDTO);        userDTOS.add(userDTO);    });    log.info("BeanCopier 加缓存后 costTime: {}ms", System.currentTimeMillis() - start);

}

public static void copy(Object srcObj, Object destObj) {    String key = genKey(srcObj.getClass(), destObj.getClass());    BeanCopier copier = null;    if (!BEAN_COPIERS.containsKey(key)) {        copier = BeanCopier.create(srcObj.getClass(), destObj.getClass(), false);        BEAN_COPIERS.put(key, copier);    } else {        copier = BEAN_COPIERS.get(key);    }    copier.copy(srcObj, destObj, null);

}private static String genKey(Class<?> srcClazz, Class<?> destClazz) {    return srcClazz.getName() + destClazz.getName();}
  • 结果(耗时：6ms)
20:32:31.405 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopyComparedDemo - BeanCopier 加缓存后 costTime: 6ms

五、总结及源码

原文地址：https://www.cnblogs.com/CQqfjy/p/12425007.html

时间： 2024-10-04 01:33:05

你还在用BeanUtils进行对象属性拷贝？的相关文章

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

一.对象属性拷贝工具类 ”天下武功,唯快不破“.在互联网行业中体现的更加淋淋尽致.我们在业务系统会经常遇到业务对象间属性的拷贝,对如外接口一般都使用特定的DTO对象,而不会使用领域模型,以避免两者的变动互相影响.我们不仅要关注“快”,还要注重CPU的稳定即避免CPU使用的大起大落现象.如何高效完成属性的拷贝并降低对CPU的使用率或避免CPU的抖动. 相关博文已经有很多,为什么还要自己在一篇类似的哪?原因有二:一是加深理解二是比较各自优劣.目前对象间属性的拷贝常用的方法大致如下: 手动拷贝(set

BeanUtils对象属性copy的性能对比以及源码分析

1. 对象属性拷贝的常见方式及其性能 在日常编码中,经常会遇到DO.DTO对象之间的转换,如果对象本身的属性比较少的时候,那么我们采用硬编码手工setter也还ok,但如果对象的属性比较多的情况下,手工setter就显得又low又效率又低.这个时候我们就考虑采用一些工具类来进行对象属性的拷贝了. 我们常用的对象属性拷贝的方式有: Hard Code net.sf.cglib.beans.BeanCopier#copy org.springframework.beans.BeanUtils.cop

使用序列化实现对象的拷贝

java提高篇(五)-----使用序列化实现对象的拷贝 分类:            [JAVA开发]-----Java提高篇2013-10-22 19:153668人阅读评论(5)收藏举报 javajava提高篇 摘自:http://blog.csdn.net/chenssy/article/details/12952063 目录(?)[+] 一浅拷贝问题 二利用序列化实现对象的拷贝       我们知道在Java中存在这个接口Cloneable,实现该接口的类都会具备被拷贝的能力,同时拷贝是

使用序列化实现对象的拷贝(转)

   我们知道在Java中存在这个接口Cloneable,实现该接口的类都会具备被拷贝的能力,同时拷贝是在内存中进行,在性能方面比我们直接通过new生成对象来的快,特别是在大对象的生成上,使得性能的提升非常明显.然而我们知道拷贝分为深拷贝和浅拷贝之分,但是浅拷贝存在对象属性拷贝不彻底问题.关于深拷贝.浅拷贝的请参考这里:渐析java的浅拷贝和深拷贝        一.浅拷贝问题       我们先看如下代码: [java] view plaincopyprint? public class Pe

java提高篇(六)-----使用序列化实现对象的拷贝

我们知道在Java中存在这个接口Cloneable,实现该接口的类都会具备被拷贝的能力,同时拷贝是在内存中进行,在性能方面比我们直接通过new生成对象来的快,特别是在大对象的生成上,使得性能的提升非常明显.然而我们知道拷贝分为深拷贝和浅拷贝之分,但是浅拷贝存在对象属性拷贝不彻底问题.关于深拷贝.浅拷贝的请参考这里:渐析java的浅拷贝和深拷贝 一.浅拷贝问题 我们先看如下代码: public class Person implements Cloneable{ /** 姓名 **/ privat

利用BeanUtils在对象间复制属性

commons-beanutils是jakarta commons子项目中的一个软件包,其主要目的是利用反射机制对JavaBean的属性进行处理.我们知道,一个JavaBean通常包含了大量的属性,很多情况下,对JavaBean的处理导致大量get/set代码堆积,增加了代码长度和阅读代码的难度(什么,你的薪水按代码行数计算?那千万别让老板看到此帖哦) BeanUtils是这个包里比较常用的一个工具类,这里只介绍它的copyProperties()方法.该方法定义如下: public stati

javascript 对象属性的添加，删除，json对象和字符串转换方法等

1:动态添加 对象属性 var obj = new Object(); console.log (obj.username); obj.username = "haha"; console.log (obj.username); //undefined //haha 用"[]"表示.写成 obj["username"] = "haha"; var obj = new Object(); console.log (obj.use

js 中对象--属性相关操作

查询属性: 可以用 对象.属性 来查询属性和属性方法               或者                    对象[“属性”]  来查询属性和属性方法 演示代码: 1 <script> 2 var obj ={ 3 username:"ziksang", 4 age:22, 5 addr:"北京", 6 say:function(){ 7 return "我的名字叫 "+this.username //解析this,此

对象属性复制几种方式

对象属性复制的三种方法: 1.Apache提供的BeanUtil.copyProperties和PropertyUtil.copyProperties两种方式 BeanUtils.copyProperties("转换后的类", "要转换的类"); PropertyUtils.copyProperties("转换后的类", "要转换的类"); 口诀:后付钱(后付前:后面的复制给前面) 2.spring提供的BeanUtil.co