你還在用BeanUtils進行對象屬性拷貝？

一、背景

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;
    }
}

二、對象拷貝之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支持兩種方式:

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 屬性名稱、類型都相同

• 目標對象屬性類

@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
     */
    @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

五、總結及源碼