• Java 对象深拷贝工具类

    目录

    1. 使用场景

    1.1 场景一

    1.2 场景二

    2. Spring 中的对象拷贝

    3. 本工具类中的对象拷贝

    3.1 拷贝对象本身（单个）

    3.2 拷贝对象本身（批量）

    3.3 拷贝对象属性至其他类（单个）

    3.4 拷贝对象属性至其他类（批量）

    4. 工具类源码

    1. 使用场景

    我们在Java编码中，有时候可能会经常遇到对象拷贝的场景。

    1.1 场景一

    当我们更新一个对象的时候，如果要记录对象属性的前后变化，那么在更新对象之前，我们应该首先将对象拷贝暂存起来，且这个时候的拷贝一定是深拷贝（内存地址不同的两个对象），因为Java存在对象引用，将一个对象赋值给另外一个对象，他是浅拷贝的（两个不同变量名，但实际内存地址一样的两个对象）的话，也就是说当我们去更新完成属性值的时候，其实是设置的同一个对象，那么这个时候就会导致更新前后无变化的情况。

    1.2 场景二

    又比如，当我们从数据库中查询出一个实体对象的时候，这个对象往往对应的是和数据库字段 一 一 对应的实体，但这个实体往往又不会满足我们的页面需求。比如我们查询学生课程表的时候，我们数据库往往只是存的一个 id 对应关系，但页面往往是展示的名称，那么这个名称字段我们的表对应的实体类是不应该存在的，这个时候，我们应该创建一个对应的 VO （View Object）类，把额外的需要字段定义在这里面，同时可以去继承原表实体类，这样的一个对象就满足了。到时候，我们把原表实体对应的字段值拷贝到 VO 对象中后，再设置其他表额外的字段，这样就可以返回给前端页面进行展示了。

    综上：所以，对象拷贝还是挺有用途的，但如果我们拷贝对象的时候，去一个一个字段挨着进行取值拷贝的话，难免代码看上去不够优雅。于是，搞一个对象拷贝工具类还是很有必要的。

    2. Spring 中的对象拷贝

    其实，在 Spring 中，也有类似的拷贝方法。他就是位于 org.springframework.beans.BeanUtils 工具类中的 copyProperties 方法。下面就简单演示下这个方法的使用效果。

    为了方便演示，我们创建两个有部分相同属性的对象 Cat 类和 Dog 类（都有 name 和 age 字段）。

    Cat 类如下：

    1. @Data
    2. public class Cat {
    3.  
    4.     private String name;
    5.     private Integer age;
    6.     private String color;
    7.  
    8. }

    Dog 类如下：

    1. @Data
    2. public class Dog {
    3.  
    4.     private String name;
    5.     private Integer age;
    6.     private String address;
    7.  
    8. }

    测试代码：

    1. import org.springframework.beans.BeanUtils;
    2.  
    3. public class Test {
    4.  
    5.     public static void main(String[] args) {
    6.         // 实例化一个 Cat 对象并赋值属性
    7.         Cat cat = new Cat();
    8.         cat.setName("tom");
    9.         cat.setAge(5);
    10.  
    11.         // 实例化一个 Dog 对象
    12.         Dog dog = new Dog();
    13.  
    14.         // 将 cat 对象中的属性值拷贝至 dog 中
    15.         BeanUtils.copyProperties(cat, dog);
    16.         System.out.println("拷贝后：" + dog);
    17.     }
    18.  
    19. }

     测试效果：

    可以看到，相同的 name 和 age 已经复制过去了。

    3. 本工具类中的对象拷贝

    上面我们演示了 Spring 下 BeanUtils 工具类中的对象属性拷贝，虽然他也可以成功拷贝对象中的属性，但对于我个人来说，还是有点不适应。

    首先，Spring 去拷贝一个对象属性的时候，需要先创建好另外一个对象，然后再进行属性拷贝，这一步对象创建是明显可以放到工具方法中去的。

    其次，如果只是本类复制的话，参数只需要传一个源对象的实例就应该够了，而Spring就算拷贝本类，也得传两个参数，即源实例对象和目标实例对象。

    另外，Spring 的对象拷贝不支持批量拷贝，比如我们将 List 属性拷贝后，生成一个 List 中，只能自己循环去拷贝生成每个 Dog，然后添加到 List 中。

    于是，敝人针对个人习惯，编写了一个适合自己的编码习惯的对象拷贝工具类 BeanUtils（类名还是参照的 Spring），具体使用效果如下。

    下面先做效果演示，工具类源码放在文章最后。

    3.1 拷贝对象本身（单个）

    比如，我们想复制一个对象本身（如 cat），那么直接使用下面这个方法就可以了。

    Cat newCat = BeanUtils.copy(cat);

    测试代码：

     测试效果：

    从测试结果我们可以看到，源对象和复制对象的每个字段值已经拷贝过去了，但两个对象的内存 hashCode 并不相同，说明并不是同一个对象，也就说我们是进行深拷贝的，两个对象是互不影响的。

    另外，我们这个工具类不但支持类对象本身属性拷贝，连父类属性拷贝也是支持的。

    比如，Cat类去继承下面这个 Animal 类：

    1. @Data
    2. public class Animal {
    3.  
    4.     private Integer price;
    5.     private Date birth;
    6.  
    7. }
    1. @Data
    2. public class Cat extends Animal {
    3.  
    4.     private String name;
    5.     private Integer age;
    6.     private String color;
    7.  
    8. }

    我们再试试测试一下：

    测试效果：

    可以看到，我们的父类属性字段值也确实复制成功了。

    3.2 拷贝对象本身（批量）

    工具类中不仅支对单个对象拷贝的，对多个对象的拷贝也是支持的。

    List newCatList = BeanUtils.copyList(catList);

    测试代码：

    测试效果：

    可以看到，批量属性复制也是OK的，拷贝后的集合中每个对象新生成的深拷贝对象。

    3.3 拷贝对象属性至其他类（单个）

    上面，我们演示了对象本身复制的效果，下面继续演示下拷贝同名字段到其他属性的效果。

    Dog dog = BeanUtils.copy(cat, Dog.class);

    我们把 Cat 中的同名字段属性拷贝到 Dog 中去，我们让 Dog 也去继承下 Anima 类。

    1. @Data
    2. public class Dog extends Animal {
    3.  
    4.     private String name;
    5.     private Integer age;
    6.     private String address;
    7.  
    8. }

    测试代码：

    因为拷贝前后是两个完全不一样的对象了，所以这里就不再打印地址 hashCode 来进行说明是深拷贝了。

    测试效果：

    可以看到 cat 中的所有相同属性已经拷贝到 dog 中去了。

    3.4 拷贝对象属性至其他类（批量）

    同理，我们拷贝对象属性至其他类也是支持批量操作的。

    List dogs = BeanUtils.copyList(cats, Dog.calss);

    测试代码：

    测试效果：

    可以看到，批量复制也是OK的。

    至此，整个对象的拷贝的四个常用方法已经都已经支持了。

    4. 工具类源码

    下面就是整个工具类的源码 BeanUtils ：

    1. package com.zyq.utils.common;
    2.  
    3. import java.lang.reflect.Field;
    4. import java.util.*;
    5.  
    6. /**
    7.  * @author zyqok
    8.  * @since 2022/07/18
    9.  */
    10. @SuppressWarnings("unused")
    11. public class BeanUtils {
    12.  
    13.     /**
    14.      * 拷贝数据到新对象（单个）
    15.      *
    16.      * @param source 源实例对象
    17.      * @return 拷贝后的新实例对象
    18.      */
    19.     public static  T copy(T source) {
    20.         if (Objects.isNull(source)) {
    21.             return null;
    22.         }
    23.         Class c = source.getClass();
    24.         List fields = getFields(c);
    25.         return newInstance(source, c, fields);
    26.     }
    27.  
    28.     /**
    29.      * 拷贝数据到新对象（批量）
    30.      *
    31.      * @param sourceList 源实例对象集合
    32.      * @return 拷贝后的新实例对象集合
    33.      */
    34.     public static  List copyList(List sourceList) {
    35.         if (Objects.isNull(sourceList) || sourceList.isEmpty()) {
    36.             return Collections.emptyList();
    37.         }
    38.         Class c = getClass(sourceList);
    39.         if (Objects.isNull(c)) {
    40.             return Collections.emptyList();
    41.         }
    42.         List fields = getFields(c);
    43.         List ts = new ArrayList<>();
    44.         for (T t : sourceList) {
    45.             T s = newInstance(t, c, fields);
    46.             if (Objects.nonNull(s)) {
    47.                 ts.add(s);
    48.             }
    49.         }
    50.         return ts;
    51.     }
    52.  
    53.     /**
    54.      * 单个深度拷贝
    55.      *
    56.      * @param source 源实例化对象
    57.      * @param target 目标对象类（如：User.class）
    58.      * @return 目标实例化对象
    59.      */
    60.     public static  T copy(Object source, Class target) {
    61.         if (Objects.isNull(source) || Objects.isNull(target)) {
    62.             return null;
    63.         }
    64.         List sourceFields = getFields(source.getClass());
    65.         List targetFields = getFields(target);
    66.         T t = null;
    67.         try {
    68.             t = newInstance(source, target, sourceFields, targetFields);
    69.         } catch (Exception e) {
    70.             e.printStackTrace();
    71.         }
    72.         return t;
    73.     }
    74.  
    75.     /**
    76.      * 批量深度拷贝（如果原集合中有null,则自动忽略）
    77.      *
    78.      * @param sourceList 源实例化对象集合
    79.      * @param target     目标对象类（如：User.class）
    80.      * @return 目标实例化对象集合
    81.      */
    82.     public static  List copyList(List sourceList, Class target) {
    83.         if (Objects.isNull(sourceList) || sourceList.isEmpty() || Objects.isNull(target)) {
    84.             return Collections.emptyList();
    85.         }
    86.         Class c = getClass(sourceList);
    87.         if (Objects.isNull(c)) {
    88.             return Collections.emptyList();
    89.         }
    90.         List sourceFields = getFields(c);
    91.         List targetFields = getFields(target);
    92.         List ks = new ArrayList<>();
    93.         for (T t : sourceList) {
    94.             if (Objects.nonNull(t)) {
    95.                 try {
    96.                     K k = newInstance(t, target, sourceFields, targetFields);
    97.                     ks.add(k);
    98.                 } catch (Exception e) {
    99.                     e.printStackTrace();
    100.                 }
    101.             }
    102.         }
    103.         return ks;
    104.     }
    105.  
    106.     /**
    107.      * 获取List集合中的类名
    108.      *
    109.      * @param list 对象集合
    110.      * @return 类名
    111.      */
    112.     private static  Class getClass(List list) {
    113.         for (T t : list) {
    114.             if (Objects.nonNull(t)) {
    115.                 return t.getClass();
    116.             }
    117.         }
    118.         return null;
    119.     }
    120.  
    121.     /**
    122.      * 实例化同源对象
    123.      *
    124.      * @param source 源对象
    125.      * @param c      源对象类名
    126.      * @param fields 源对象属性集合
    127.      * @return 同源新对象
    128.      */
    129.     @SuppressWarnings("unchecked")
    130.     private static  T newInstance(T source, Class c, List fields) {
    131.         T t = null;
    132.         try {
    133.             t = (T) c.newInstance();
    134.             for (Field field : fields) {
    135.                 field.setAccessible(true);
    136.                 field.set(t, field.get(source));
    137.             }
    138.         } catch (Exception e) {
    139.             e.printStackTrace();
    140.         }
    141.         return t;
    142.     }
    143.  
    144.     /**
    145.      * 目标实例化对象
    146.      *
    147.      * @param source       原对实例化象
    148.      * @param target       目标对象类
    149.      * @param sourceFields 源对象字段集合
    150.      * @param targetFields 目标对象属性字段集合
    151.      * @return 目标实例化对象
    152.      */
    153.     private static  T newInstance(Object source, Class target, List sourceFields,
    154.                                      List targetFields) throws Exception {
    155.         T t = target.newInstance();
    156.         if (targetFields.isEmpty()) {
    157.             return t;
    158.         }
    159.         for (Field field : sourceFields) {
    160.             field.setAccessible(true);
    161.             Object o = field.get(source);
    162.             Field sameField = getSameField(field, targetFields);
    163.             if (Objects.nonNull(sameField)) {
    164.                 sameField.setAccessible(true);
    165.                 sameField.set(t, o);
    166.             }
    167.         }
    168.         return t;
    169.     }
    170.  
    171.     /**
    172.      * 获取目标对象中同源对象属性相同的属性（字段名称，字段类型一致则判定为相同）
    173.      *
    174.      * @param field  源对象属性
    175.      * @param fields 目标对象属性集合
    176.      * @return 目标对象相同的属性
    177.      */
    178.     private static Field getSameField(Field field, List fields) {
    179.         String name = field.getName();
    180.         String type = field.getType().getName();
    181.         for (Field f : fields) {
    182.             if (name.equals(f.getName()) && type.equals(f.getType().getName())) {
    183.                 return f;
    184.             }
    185.         }
    186.         return null;
    187.     }
    188.  
    189.     /**
    190.      * 获取一个类中的所有属性（包括父类属性）
    191.      *
    192.      * @param c 类名
    193.      * @return List
    194.      */
    195.     private static List getFields(Class c) {
    196.         List fieldList = new ArrayList<>();
    197.         Field[] fields = c.getDeclaredFields();
    198.         if (fields.length > 0) {
    199.             fieldList.addAll(Arrays.asList(fields));
    200.         }
    201.         return getSuperClassFields(c, fieldList);
    202.     }
    203.  
    204.     /**
    205.      * 递归获取父类属性
    206.      *
    207.      * @param o         类名
    208.      * @param allFields 外层定义的所有属性集合
    209.      * @return 父类所有属性
    210.      */
    211.     private static List getSuperClassFields(Class o, List allFields) {
    212.         Class superclass = o.getSuperclass();
    213.         if (Objects.isNull(superclass) || Object.class.getName().equals(superclass.getName())) {
    214.             return allFields;
    215.         }
    216.         Field[] fields = superclass.getDeclaredFields();
    217.         if (fields.length == 0) {
    218.             return allFields;
    219.         }
    220.         allFields.addAll(Arrays.asList(fields));
    221.         return getSuperClassFields(superclass, allFields);
    222.     }
    223.  
    224. }

  • 相关阅读:
    图解神经网络的基本原理,神经网络基本结构说明
    bugxxx
    Dockerfile自定义镜像实操【镜像结构、Dockerfile语法、构建Java项目】
    MFC Windows 程序设计[151]之色彩控件之谜
    一个Vue3数字框区间指令及其衍生的一个知识点
    指针相关面试题目
    C/C++苹果和虫子 2019年9月电子学会青少年软件编程（C/C++）等级考试一级真题答案解析
    1870. 准时到达的列车最小时速-二分法
    景联文科技：数据供应商在新一轮AI热潮中的重要性
    EchoServer回显服务器简单测试
  • 原文地址：https://blog.csdn.net/sunnyzyq/article/details/125856311