一个工具类让你彻底解决bean深拷贝

最新推荐文章于 2024-07-04 00:45:00 发布
最新推荐文章于 2024-07-04 00:45:00 发布
阅读量1.4k 收藏 2
点赞数
文章标签： java 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu2374633583/article/details/131300090
版权
本文介绍了深拷贝和浅拷贝的概念与区别，并提供了一个基于Hutool和Lombok的深拷贝工具类，包括单对象拷贝、列表对象拷贝以及对象与Map之间的转换。此外，文章还通过示例展示了如何使用该工具类进行对象间的拷贝操作。
摘要由CSDN通过智能技术生成

深拷贝是我们在代码开发当中经常需要使用到的，但是市面上的对象拷贝方法，比如spring自带的，或者其他工具类带的对象拷贝，大部分都是浅拷贝，根本无法满足咱们的业务需求，我们就只能对里面的引用对象进行专门的赋值动作，比较麻烦。

今天我会为大家分享我在工作当中经常使用到的深拷贝工具类，并会为大家一一分析讲解，当前类已经在生产中实践过，没有什么问题，大家可以基于自己的实际情况进行使用。希望大家多多关注点赞支持，后续继续为大家分享有用的知识点！！

1. 深拷贝和浅拷贝的概念

深拷贝和浅拷贝是指在赋值一个对象时，拷贝的深度不同。

在进行深拷贝时，会拷贝所有的属性，并且如果这些属性是对象，也会对这些对象进行深拷贝，直到最底层的基本数据类型为止。这意味着，对于深拷贝后的对象，即使原对象的属性值发生了变化，深拷贝后的对象的属性值也不会受到影响。

在这里插入图片描述
在这里插入图片描述

2. 深拷贝和浅拷贝的区别

  • 浅拷贝仅仅复制对象的引用，而不是对象本身，新旧对象共享同一块内存。
  • 深拷贝会拷贝所有的属性，并且如果这些属性是对象，也会对这些对象进行深拷贝，直到最底层的基本数据类型为止。新对象和原对象没有任何关联，修改新对象不影响原对象。

3. 赋值和拷贝的区别

区别1：赋值是指赋值者与被赋值者指向的是同一地址，只是标签不同，当a的内容被修改之后，b也发生改变；而拷贝是指把原来的值复制了一份存在另一个地址，当原地址的内容被改变之后，拷贝的内容不变。
区别2：赋值侧重于更新，构造侧重于构造。 等号不等于赋值，他可能是拷贝构造。

4. 工具类

要注意，我在底层引用了hutool和lombok，所以在使用之前一定要引入这两个依赖。
我在工具类里面提供了如下功能：

  • 单对象基于class创建拷贝
  • 单对象基于对象创建拷贝
  • 列表对象基于class创建拷贝
  • 对象转Map
  • map基于class拷贝到bean
  • map基于对象拷贝到bean
  • map拷贝到map
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class BeanCopyUtils {
 /**
     * 单对象基于class创建拷贝
     *
     * @param source 数据来源实体
     * @param desc   描述对象 转换后的对象
     * @return desc
     */
    public static <T, V> V copy(T source, Class<V> desc) {
        if (ObjectUtil.isNull(source)) {
            return null;
        }
        if (ObjectUtil.isNull(desc)) {
            return null;
        }
        final V target = ReflectUtil.newInstanceIfPossible(desc);
        return copy(source, target);
    }

    /**
     * 单对象基于对象创建拷贝
     *
     * @param source 数据来源实体
     * @param desc   转换后的对象
     * @return desc
     */
    public static <T, V> V copy(T source, V desc) {
        if (ObjectUtil.isNull(source)) {
            return null;
        }
        if (ObjectUtil.isNull(desc)) {
            return null;
        }
        BeanCopier beanCopier = BeanCopierCache.INSTANCE.get(source.getClass(), desc.getClass(), null);
        beanCopier.copy(source, desc, null);
        return desc;
    }

    /**
     * 列表对象基于class创建拷贝
     *
     * @param sourceList 数据来源实体列表
     * @param desc       描述对象 转换后的对象
     * @return desc
     */
    public static <T, V> List<V> copyList(List<T> sourceList, Class<V> desc) {
        if (ObjectUtil.isNull(sourceList)) {
            return null;
        }
        if (CollUtil.isEmpty(sourceList)) {
            return CollUtil.newArrayList();
        }
        return StreamUtils.toList(sourceList, source -> {
            V target = ReflectUtil.newInstanceIfPossible(desc);
            copy(source, target);
            return target;
        });
    }
    /**
     * bean拷贝到map
     *
     * @param bean 数据来源实体
     * @return map对象
     */
    public static <T> Map<String, Object> copyToMap(T bean) {
        if (ObjectUtil.isNull(bean)) {
            return null;
        }
        return BeanMap.create(bean);
    }
 /**
     * map拷贝到bean
     *
     * @param map       数据来源
     * @param beanClass bean类
     * @return bean对象
     */
    public static <T> T mapToBean(Map<String, Object> map, Class<T> beanClass) {
        if (MapUtil.isEmpty(map)) {
            return null;
        }
        if (ObjectUtil.isNull(beanClass)) {
            return null;
        }
        T bean = ReflectUtil.newInstanceIfPossible(beanClass);
        return mapToBean(map, bean);
    }

    /**
     * map拷贝到bean
     *
     * @param map  数据来源
     * @param bean bean对象
     * @return bean对象
     */
    public static <T> T mapToBean(Map<String, Object> map, T bean) {
        if (MapUtil.isEmpty(map)) {
            return null;
        }
        if (ObjectUtil.isNull(bean)) {
            return null;
        }
        BeanMap.create(bean).putAll(map);
        return bean;
    }

    /**
     * map拷贝到map
     *
     * @param map   数据来源
     * @param clazz 返回的对象类型
     * @return map对象
     */
    public static <T, V> Map<String, V> mapToMap(Map<String, T> map, Class<V> clazz) {
        if (MapUtil.isEmpty(map)) {
            return null;
        }
        if (ObjectUtil.isNull(clazz)) {
            return null;
        }
        Map<String, V> copyMap = new LinkedHashMap<>(map.size());
        map.forEach((k, v) -> copyMap.put(k, copy(v, clazz)));
        return copyMap;
    }

    /**
     * BeanCopier属性缓存<br>
     * 缓存用于防止多次反射造成的性能问题
     */
    public enum BeanCopierCache {
        /**
         * BeanCopier属性缓存单例
         */
        INSTANCE;

        private final SimpleCache<String, BeanCopier> cache = new SimpleCache<>();

        /**
         * 获得类与转换器生成的key在{@link BeanCopier}的Map中对应的元素
         *
         * @param srcClass    源Bean的类
         * @param targetClass 目标Bean的类
         * @param converter   转换器
         * @return Map中对应的BeanCopier
         */
        public BeanCopier get(Class<?> srcClass, Class<?> targetClass, Converter converter) {
            final String key = genKey(srcClass, targetClass, converter);
            return cache.get(key, () -> BeanCopier.create(srcClass, targetClass, converter != null));
        }

        /**
         * 获得类与转换器生成的key
         *
         * @param srcClass    源Bean的类
         * @param targetClass 目标Bean的类
         * @param converter   转换器
         * @return 属性名和Map映射的key
         */
        private String genKey(Class<?> srcClass, Class<?> targetClass, Converter converter) {
            final StringBuilder key = StrUtil.builder()
                .append(srcClass.getName()).append('#').append(targetClass.getName());
            if (null != converter) {
                key.append('#').append(converter.getClass().getName());
            }
            return key.toString();
        }
    }
}

5. 举例

5.1 对象之间相互拷贝

public static void main(String[] args) {
        SysUser sysUser1 = new SysUser();
        SysDept sysDept = new SysDept();
        sysDept.setDeptId(111L);
        List<SysRole> roles = new ArrayList<>(){{add(new SysRole(1234L));}};
        sysUser1.setUserId(100L);
        sysUser1.setDept(sysDept);
        sysUser1.setRoles(roles);

        SysUser sysUser2 = new SysUser();
        BeanCopyUtils.copy(sysUser1,sysUser2);
        System.out.println(sysUser2);

    }

运行结果：

SysUser(userId=100, deptId=null, userName=null, nickName=null, userType=null, email=null, phonenumber=null, sex=null, avatar=null, password=null, status=null, delFlag=null, loginIp=null, loginDate=null, remark=null, dept=SysDept(deptId=111, deptName=null, orderNum=null, leader=null, phone=null, email=null, status=null, delFlag=null, ancestors=null), roles=[SysRole(roleId=1234, roleName=null, roleKey=null, roleSort=null, dataScope=null, menuCheckStrictly=null, deptCheckStrictly=null, status=null, delFlag=null, remark=null, flag=false, menuIds=null, deptIds=null)], roleIds=null, postIds=null, roleId=null)

可以清楚地看到角色集合ID，部门对象ID，用户ID都被拷贝进去了。

5.2 对象拷贝到Map

public static void main(String[] args) {
        SysUser sysUser1 = new SysUser();
        SysDept sysDept = new SysDept();
        sysDept.setDeptId(111L);
        List<SysRole> roles = new ArrayList<>(){{add(new SysRole(1234L));}};
        sysUser1.setUserId(100L);
        sysUser1.setDept(sysDept);
        sysUser1.setRoles(roles);

        Map<String, Object> stringObjectMap = BeanCopyUtils.copyToMap(sysUser1);
        System.out.println(stringObjectMap);

    }

运行结果

{roles=[SysRole(roleId=1234, roleName=null, roleKey=null, roleSort=null, dataScope=null, menuCheckStrictly=null, deptCheckStrictly=null, status=null, delFlag=null, remark=null, flag=false, menuIds=null, deptIds=null)], phonenumber=null, admin=false, loginDate=null, remark=null, delFlag=null, password=null, updateBy=null, postIds=null, loginIp=null, email=null, nickName=null, roleId=null, sex=null, deptId=null, updateTime=null, avatar=null, dept=SysDept(deptId=111, deptName=null, orderNum=null, leader=null, phone=null, email=null, status=null, delFlag=null, ancestors=null), params={}, userName=null, userId=100, createBy=null, roleIds=null, createTime=null, userType=null, searchValue=null, status=null}

5.3 集合之间的相互拷贝

    public static void main(String[] args) {

        List<SysRole> roles = new ArrayList<>(){{
            add(new SysRole(1234L));
            add(new SysRole(123111L));

        }};
        List<SysRole> sysRoles = BeanCopyUtils.copyList(roles, SysRole.class);
        System.out.println(sysRoles);
    }

运行结果

[SysRole(roleId=1234, roleName=null, roleKey=null, roleSort=null, dataScope=null, menuCheckStrictly=null, deptCheckStrictly=null, status=null, delFlag=null, remark=null, flag=false, menuIds=null, deptIds=null), SysRole(roleId=123111, roleName=null, roleKey=null, roleSort=null, dataScope=null, menuCheckStrictly=null, deptCheckStrictly=null, status=null, delFlag=null, remark=null, flag=false, menuIds=null, deptIds=null)]

今天深拷贝就给大家分享到这里，希望大家多多点赞支持，也希望我的分享能给大家的工作和学习带来帮助！！！

技术闲聊DD
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java deep clone util_JAVA对象任意深度克隆clone工具类分享 | 学步园
weixin_39804523的博客
02-13 465
JAVA对象任意深度克隆clone工具类分享package com.zuidaima.n_app.util;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Mo...
深度拷贝及封装深度拷贝工具类
京城下了一场大雪的博客
01-23 287
什么是深度拷贝 需求复制一个People类，不考虑new一个 如果这么做的话发生的是引用传递，也就是将指向p1所指向内存空间的地址传递给了p2，也就是p1与p2指向同一个内存，所以改变p2的值p1也会改变，这就是浅度拷贝 根据如果将一个对象序列化成字节序列，再根据字节序列反序列化成一个对象就可以复制一个对象，并且改变其中一个其余的不会发生改变 首先一个类想要进行序列化必须有可序列化特性修饰，并且引入命名空间 实现深度拷贝 测试 改成泛型做成工具类 ...
【Spring】Apache的BeanUtils与SpringBean的BeanUtils对比
最新发布
九师兄
07-04 63
在Java中，除了 基本数据类型之外，还存在 类的实例对象这个引用数据类型，而一般使用 “=”号做赋值操作的时候，对于基本数据类型，实际上是拷贝的它的值，但是对于对象而言，其实赋值的只是这个对象的引用，将原对象的引用传递过去，他们实际还是指向的同一个对象。而浅拷贝和深拷贝就是在这个基础上做的区分，如果在拷贝这个对象的时候，只对基本数据类型进行了拷贝，而对引用数据类型只是进行引用的传递，而没有真实的创建一个新的对象，则认为是浅拷贝。
原型模式之 深度拷贝 工具类
chuncui2576的博客
06-12 137
看了 一些 原型模式，原来就是 深度拷贝，浅拷贝的。 工作了这么久，说实话，我还没有真实使用过 拷贝的方法的。。。 特别是浅拷贝 更加不敢乱用了，万一引用什么的搞混了就麻烦了。而且 浅拷贝还得 实现 cloable 什么的。 我们的 对象bean 一般都是 实现 序列化而已。 更加用不上了。...
Java复制和深复制
木冰的专栏
04-20 238
import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable;...
序列化深拷贝工具类
爪哇人的博客
07-26 344
使用序列化进行深层拷贝的工具类
深拷贝工具类
无名小卒菜的博客
12-29 353
Description: 使用这个方法，你可以实现深度克隆任何具有序列化接口的对象。// 将对象写入到字节数组输出流中。// 从字节数组输入流中读取对象。
12.实现一个拷贝文件的工具类要使用字节流还是字符串.avi
03-07
12.实现一个拷贝文件的工具类要使用字节流还是字符串.avi
Springboot实现多线程注入bean的工具类操作
09-07
为了解决这个问题，我们可以创建一个工具类，如`ApplicationContextProvider`，用于在多线程场景中获取所需的bean。 `ApplicationContextProvider`实现了`ApplicationContextAware`接口，这个接口是Spring提供的一...
java代码-使用java解决bean&map工具类的源代码
03-20
java代码-使用java解决bean&map工具类的源代码 ——学习参考资料：仅用于个人学习使用！
Bean转换的Java工具类
10-25
Bean转换的Java工具类
java 深度拷贝 复制 深度复制.zip
03-21
java反射机制创建对象实现：java 深度拷贝 -超完美，只使反射机制，不使用其它封装好的深度拷贝的工具类
beancopy:java bean深度克隆的简单实现
05-09
beancopy ###java bean深度克隆的简单实现 Bean中必须有对应的getter, setter方法. 可以复制包含 "8种基本类型, String, java.util.Date, enum, Set, List 以及多层嵌套" 的Bean.
Spring自动扫描无法扫描jar包中bean的解决方法
08-30
在Spring框架中，自动扫描（Auto-Component Discovery）是一个便捷的功能，它允许开发者无需显式配置每个Bean，而是通过指定包名让Spring自动发现并管理Bean。然而，当Bean定义在独立的jar包中，有时Spring可能无法...
深拷贝实现工具类
weixin_45024993的博客
12-28 140
深拷贝实现工具类
深拷贝和浅拷贝工具整理
qq_22795957的博客
06-30 846
前几天写代码的时候，需要拷贝对象，就使用了的拷贝对象，后面又修改了新对象的属性，就导致原对象也被修改了，仔细一研究才发现这个工具只是进行了浅拷贝。索性整理一下现在比较常用的一些深拷贝和浅拷贝工具。......
对象拷贝工具类（深拷贝）
dc_user的博客
10-25 942
public class CloneUtil { private CloneUtil() { throw new AssertionError(); } public static <T extends Serializable> T clone(T object) throws IOException, Class...
java bean深拷贝工具
Mr.Debug的博客
10-24 1683
java 深拷贝工具
深拷贝工具
Stephen
12-23 348
public class ObjectUtil { public ObjectUtil() { } public static Object deepCopy(Object orig) throws IOException, ClassNotFoundException { ByteArrayOutputStream bos = new ByteArra...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

技术闲聊DD

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值