对象拷贝之Apache BeanUtils、Spring的BeanUtils、Mapstruct、BeanCopier、PropertieyUtils对比（深拷贝）

大多时候时候使用的是Apache或Spring``BeanUtils，今天，我们来看一下一个更高效的属性拷贝方式：BeanCopier。

https://github.com/cglib/cglib

https://github.com/cglib/cglib/blob/master/cglib/src/main/java/net/sf/cglib/beans/BeanCopier.java

首先梳理出来现在有哪些对象拷贝的方式：

Apache的BeanUtils：BeanUtils是Apache commens组件里面的成员，由Apache提供的一套开源api，用于简化对javaBean的操作，能够对基本类型自动转换。
Spring的BeanUtils：BeanUtils是Spring框架提供的对Java反射和自省API的包装。其主要目的是利用反射机制对JavaBean的属性进行处理。
Mapstruct：

MapStruct是一个Java 注释处理器，用于为Java Bean类生成类型安全和高性能的映射器。它使您不必手工编写映射代码，这是一个繁琐且容易出错的任务。该生成器具有合理的默认值和许多内置的类型转换，但是在配置或实现特殊行为时，它会自动退出。
与运行时工作的映射框架相比，MapStruct具有以下优点：

通过使用普通方法调用而不是反射来快速执行

编译时类型安全。只能映射彼此映射的对象和属性，因此不会将订单实体意外映射到客户DTO等。

自包含代码 -没有运行时依赖项

如果发生以下情况，则在构建时清除错误报告：
映射不完整（并非所有目标属性都被映射）

映射不正确（找不到正确的映射方法或类型转换）

易于调试的映射代码（或手动编辑，例如在生成器中有错误的情况下）
github mapstruct/mapstruct

4、BeanCopier：BeanCopier是Cglib包中的一个类，用于对象的复制。目标对象必须先实例化而且对象必须要有setter方法。

其实有很多种方法进行属性拷贝的,例如dozer等等下面看下测试性能吧:以:万级进行测试,我觉得Cglib太给力了.可以在遇到属性拷贝瓶颈时考虑.当然他们各有优点哈,功能也不尽相同.还需要多使用体会. 输出结果：手动Copy >Mapstuct>= cglibCopy > springBeanUtils > apachePropertyUtils > apacheBeanUtils 可以理解为: 手工复制 > cglib > 反射 > Dozer。

类型Framework	数据量	测试性能(10000调用次)time
Pure get/set		10ms
Cglib Beancopier		14ms
MapStruct		10ms
Easy mapper		46ms
Spring BeanUtils		96ms
Apache BeanUtils		249ms
Apache PropertieyUtils		130ms
Dozer		770ms

测试结果评估：

数据量	Apache	Spring	MapStruct	BeanCopier
100w	391ms	250ms	45ms	57ms
10w	82ms	34ms	8ms	10ms
1w	30ms	19ms	2ms	7ms
1k	15ms	6ms	1ms	5ms
100	5ms	3ms	1ms	4ms
10	2ms	1ms	1ms	4ms

根据测试结果，我们可以得出在速度方面，MapStruct是最好的，执行速度是 Apache BeanUtils 的10倍、Spring BeanUtils 的 4-5倍、和 BeanCopier 的速度差不多。
由此可以看出，在大数据量级的情况下，MapStruct 和 BeanCopier 都有着较高的性能优势，其中 MapStruct 尤为优秀。如果你仅是在日常处理少量的对象时，选取哪个其实变得并不重要，但数据量大时建议还是使用MapStruct 或 BeanCopier 的方式，提高接口性能

一、背景

1.1 对象拷贝概念

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

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

浅拷贝与深拷贝差异

分类	浅拷贝	深拷贝
区别	创建一个新对象，然后将当前对象的非静态字段复制到该新对象，如果字段是值类型的，那么对该字段执行复制；如果该字段是引用类型的话，则复制引用但不复制引用的对象。因此，原始对象及其副本引用同一个对象。	创建一个新对象，然后将当前对象的非静态字段复制到该新对象，无论该字段是值类型的还是引用类型，都复制独立的一份。当你修改其中一个对象的任何内容时，都不会影响另一个对象的内容。

1.2 示例前准备

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

@Data
public 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;}
}
复制代码

一、对象拷贝之MapStruct（强烈推荐）

更多高级使用参照手册。

https://github.com/mapstruct

https://mapstruct.org/

   <!-- mapstruct start--><dependency><groupId>org.mapstruct</groupId><artifactId>mapstruct-jdk8</artifactId><version>1.3.0.Final</version></dependency><dependency><groupId>org.mapstruct</groupId><artifactId>mapstruct-processor</artifactId><version>1.3.0.Final</version><scope>provided</scope></dependency><!-- mapstruct end-->

转换：


import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;/*** * FileName: UserConvertUtils** @author: Van* Date:     2019-11-08 20:56* Description: ${DESCRIPTION}* Version： V1.0*/
@Mapper
public interface UserConvertUtils {UserConvertUtils INSTANCE = Mappers.getMapper(UserConvertUtils.class);/*** 普通的映射** @param userDO UserDO数据持久层类* @return 数据传输类*/UserDTO doToDTO(UserDO userDO);/*** 类型转换的映射** @param userDO UserDO数据持久层类* @return 数据传输类*/@Mappings({@Mapping(target = "gmtBroth", source = "gmtBroth", dateFormat = "yyyy-MM-dd HH:mm:ss"),@Mapping(target = "balances", source = "balance"),})UserDTO doToDtoWithConvert(UserDO userDO);/*** 多对一映射* @param userDO* @param userInfoDO* @return*/UserDTO doAndInfoToDto(UserDO userDO, UserInfoDO userInfoDO);
}

使用：

/*** * FileName: UserConvertUtilsDemo** @author: Van* Date:     2019-11-08 18:05* Description: ${DESCRIPTION}* Version： V1.0*/
@Slf4j
public class MapStructTest {/*** 一般拷贝*/@Testpublic void normalCopy() {// 模拟查询出数据UserDO userDO = DataUtil.createData();log.info("拷贝前：userDO:{}", userDO);UserDTO userDTO = UserConvertUtils.INSTANCE.doToDTO(userDO);log.info("拷贝后：userDTO:{}", userDTO);}/*** 包含类型转换的拷贝*/@Testpublic void doToDtoWithConvert() {// 模拟查询出数据UserDO userDO = DataUtil.createData();log.info("拷贝前：userDO:{}", userDO);UserDTO userDTO = UserConvertUtils.INSTANCE.doToDtoWithConvert(userDO);log.info("拷贝后：userDTO:{}", userDTO);}/*** 包含类型转换的拷贝*/@Testpublic void doAndInfoToDto() {// 模拟查询出数据UserDO userDO = DataUtil.createData();log.info("拷贝前：userDO:{}", userDO);UserDTO userDTO = UserConvertUtils.INSTANCE.doAndInfoToDto(userDO, new UserInfoDO(1));log.info("拷贝后：userDTO:{}", userDTO);}}

二、对象拷贝之BeanUtils

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

2.1 源码解读

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

BeanUtils 源码

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

2.2 示例

@Slf4j
public 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支持两种方式:

一种是不使用Converter的方式，仅对两个bean间属性名和类型完全相同的变量进行拷贝;
另一种则引入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 属性名称、类型都相同

目标对象属性类

@Data
public 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 属性名称相同、类型不同

目标对象属性类

@Data
public 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 准备

目标对象属性类

@Data
public 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*/@Overridepublic 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)
19:51:12.096 [main] INFO cn.van.parameter.bean.copy.demo.BeanCopierDemo - 拷贝后：userDomain:UserDomain(id=1, userName=Van, gmtBroth=2019-11-02 19:51:11, balance=100)
复制代码

3.2.4 小节

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

3.3 `BeanCopier`总结

当源类和目标类的属性名称、类型都相同，拷贝没问题。
当源对象和目标对象的属性名称相同、类型不同,那么名称相同而类型不同的属性不会被拷贝。注意，原始类型（int，short，char）和他们的包装类型，在这里都被当成了不同类型，因此不会被拷贝。
源类或目标类的setter比getter少，拷贝没问题，此时setter多余，但是不会报错。
源类和目标类有相同的属性（两者的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
复制代码

五、总结及源码

场景	耗时（10000次调用）	原理
BeanUtils	232ms	反射
BeanCopier	116ms	修改字节码
BeanCopier(加缓存)	6ms	修改字节码

Github 示例代码