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

時間  2019-11-07
標籤 還在 beanutils 進行 對象 屬性 拷貝 简体版
原文   原文鏈接

在作業務的時候，爲了隔離變化，咱們會將DAO查詢出來的DO和對前端提供的DTO隔離開來。大概90%的時候，它們的結構都是相似的；可是咱們很不喜歡寫不少冗長的b.setF1(a.getF1())這樣的代碼，因而咱們須要簡化對象拷貝方式。html

1、背景

1.1 對象拷貝概念

Java中，數據類型分爲值類型（基本數據類型）和引用類型，值類型包括int、double、byte、boolean、char等簡單數據類型，引用類型包括類、接口、數組等複雜類型。前端

對象拷貝分爲淺拷貝(淺克隆)與深拷貝(深克隆)。java

  • 淺拷貝與深拷貝差別
分類 淺拷貝 深拷貝
區別 建立一個新對象，而後將當前對象的非靜態字段複製到該新對象，若是字段是值類型的，那麼對該字段執行復制；若是該字段是引用類型的話，則複製引用但不復制引用的對象。所以，原始對象及其副本引用同一個對象。 建立一個新對象，而後將當前對象的非靜態字段複製到該新對象，不管該字段是值類型的仍是引用類型，都複製獨立的一份。當你修改其中一個對象的任何內容時，都不會影響另外一個對象的內容。

參考文章node

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

2、對象拷貝之BeanUtils

Apache和Spring均有BeanUtils工具類， Apache的BeanUtils穩定性與效率都不行;Spring的BeanUtils比較穩定，不會由於量大了，耗時明顯增長，故通常都使用Spring的BeanUtils。git

2.1 源碼解讀

Spring中的BeanUtils，其中實現的方式很簡單，就是對兩個對象中相同名字的屬性進行簡單get/set，僅檢查屬性的可訪問性。github

BeanUtils 源碼spring

能夠看到, 成員變量賦值是基於目標對象的成員列表, 而且會跳過ignore的以及在源對象中不存在的, 因此這個方法是安全的, 不會由於兩個對象之間的結構差別致使錯誤, 可是必須保證同名的兩個成員變量類型相同。api

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)

3、對象拷貝之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)
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 小節

  1. 一旦使用Converter，BeanCopier只使用Converter定義的規則去拷貝屬性，因此在convert()方法中要考慮全部的屬性。
  2. 但，使用Converter會使對象拷貝速度變慢。

3.3 BeanCopier總結

  1. 當源類和目標類的屬性名稱、類型都相同，拷貝沒問題。
  2. 當源對象和目標對象的屬性名稱相同、類型不一樣,那麼名稱相同而類型不一樣的屬性不會被拷貝。注意，原始類型（int，short，char）和 他們的包裝類型，在這裏都被當成了不一樣類型，所以不會被拷貝。
  3. 源類或目標類的setter比getter少，拷貝沒問題，此時setter多餘，可是不會報錯。
  4. 源類和目標類有相同的屬性（二者的getter都存在），可是目標類的setter不存在，此時會拋出NullPointerException。

4、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

5、總結及源碼

場景 耗時（10000次調用） 原理
BeanUtils 232ms 反射
BeanCopier 116ms 修改字節碼
BeanCopier(加緩存) 6ms 修改字節碼

Github 示例代碼

推薦：BeanCopier 源碼分析

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程