Spring学习笔记（一）【BeanUtils.copyProperties方法】

已于 2024-03-13 22:05:57 修改
阅读量1.2w 收藏 25
点赞数 5
分类专栏： Spring 文章标签： spring 学习 java
于 2023-01-29 17:06:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wei_Naijia/article/details/128791555
版权

Spring下的BeanUtils.copyProperties方法是深拷贝还是浅拷贝？

一、浅拷贝深拷贝的理解

简单地说，拷贝就是将一个类中的属性拷贝到另一个中，对于BeanUtils.copyProperties来说，必须保证属性名和类型是相同的，因为它是根据get和set方法来赋值的

1.1、浅拷贝

浅拷贝对于基本数据类型就是直接进行值传递，在内存的另一个空间内存放，修改这个值不会影响到拷贝源的值
浅拷贝对于引用数据类型就是进行的是地址传递，并没有对该对象重新开辟一个内存空间进行存放，所以对于引用数据类型的浅拷贝就相当于两个引用指向了同一个内存地址

浅拷贝可以理解为如果是引用类型，那么目标对象拷贝的只是源对象的地址，无论目标对象还是源对象改变，他们都会一起改变

1.2、深拷贝

深拷贝就是将目标对象的属性全部复制一份给源对象，复制完之后他们就是隔开的，没有任何关系，无论操作源对象还是目标对象都对另一个没有影响

无论是浅拷贝还是深拷贝，对于基本类型和String来说都是没有影响的，有影响的只有引用类型数据

在这里插入图片描述

二、测试浅拷贝与深拷贝

  • 浅拷贝
package com.vinjcent;

public class Main {

    public static void main(String[] args) {
        // 主人(正)
        Master main = new Master("男");
        // 宠物
        Pet p = new Pet("小狗", 5);

        main.setPet(p);

        // 浅拷贝一个"主"对象(副)
        Master vice = main.clone();

        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("拷贝后对象的指针是否都指向同一个堆内存: " + (main == vice));
        System.out.println();

        // 修改副对象中的性别属性
        vice.setGender("女");
        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("修改拷贝对象中的String类型的属性gender后是否相同: " + main.getGender().equals(vice.getGender()));
        System.out.println();


        // 修改副对象中引用对象中的年龄属性
        vice.getPet().setAge(10);
        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("修改拷贝对象中的引用类型Pet后，是否在同一个堆内存当中: " + (main.getPet() == vice.getPet()));
        System.out.println();
        System.out.println("可以发现，它是对'主'对象的拷贝，它不会拷贝'主'对象深层次的可变对象，只做第一层的拷贝");
    }
}

// 宠物对象
class Pet {
    private String name;
    private int age;

    public Pet(String name, int age) {
        this.name = name;
        this.age = age;
    }

	// ...省略set、get方法

    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

// 主人对象
class Master implements Cloneable {
    private String gender;

    private Pet pet;

    public Master(String gender) {
        this.gender = gender;
    }

	// ...省略set、get方法

    // 浅拷贝
    @Override
    public Master clone() {
        try {
            // TODO: copy mutable state here, so the clone can't change the internals of the original
            return (Master) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }

    @Override
    public String toString() {
        return "Master{" +
                "gender='" + gender + '\'' +
                ", pet=" + pet +
                '}';
    }
}
  • 输出结果

在这里插入图片描述

在这里插入图片描述

  • 深拷贝
package com.vinjcent;

public class Main {

    public static void main(String[] args) {
        // 主人(正)
        Master main = new Master("男");
        // 宠物
        Pet p = new Pet("小狗", 5);

        main.setPet(p);

        // 深拷贝一个"主"对象(副)
        Master vice = main.clone();

        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("拷贝后对象的指针是否都指向同一个堆内存: " + (main == vice));
        System.out.println();

        // 修改副对象中的性别属性
        vice.setGender("女");
        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("修改拷贝对象中的String类型的属性gender后是否相同: " + main.getGender().equals(vice.getGender()));
        System.out.println();


        // 修改副对象中引用对象中的年龄属性
        vice.getPet().setAge(10);
        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("修改拷贝对象中的引用类型Pet后，是否在同一个堆内存当中: " + (main.getPet() == vice.getPet()));
        System.out.println();
        System.out.println("可以发现，它是对'主'对象的完全拷贝，无论是引用对象还是数组，都会拷贝一个新的对象，并且与源对象的引用完全隔离");
    }
}

// 宠物对象
class Pet implements Cloneable {
    private String name;
    private int age;

    public Pet(String name, int age) {
        this.name = name;
        this.age = age;
    }

	// ...省略set、get方法

    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    // 浅拷贝
    @Override
    public Pet clone() {
        try {
            // TODO: copy mutable state here, so the clone can't change the internals of the original
            return (Pet) super.clone();	// 不同点
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

// 主人对象
class Master implements Cloneable {
    private String gender;

    private Pet pet;

    public Master(String gender) {
        this.gender = gender;
    }

	// ...省略set、get方法

    // 深拷贝
    @Override
    public Master clone() {
        try {
            // TODO: copy mutable state here, so the clone can't change the internals of the original
            Master master = (Master) super.clone();
            master.pet = pet.clone();		// 不同点
            return master;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }

    @Override
    public String toString() {
        return "Master{" +
                "gender='" + gender + '\'' +
                ", pet=" + pet +
                '}';
    }
}
  • 输出结果

在这里插入图片描述

在这里插入图片描述

三、使用序列化实现深拷贝

什么是序列化？ 把对象转换为字节序列的过程称为对象的序列化

什么是反序列化？把字节序列恢复为对象的过程称为对象的反序列化

为什么需要序列化？方便传输、存储，计算机数据传输是以字节为单位的，能处理所有类型的数据

通过序列化实现的拷贝不仅可以复制对象本身，而且可以复制其引用的成员对象，因此通过序列化将对象写到一个流中，再从流里将其读出来，可以实现深拷贝

【注】实现序列化的对象其类必须实现Serializable接口

  • 代码演示
package com.vinjcent;

import java.io.*;

public class Main {

    public static void main(String[] args) {
        // 主人(正)
        Master main = new Master("男");
        // 宠物
        Pet p = new Pet("小狗", 5);

        main.setPet(p);

        // 深拷贝一个"主"对象(副)
        Master vice = main.clone();

        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("拷贝后对象的指针是否都指向同一个堆内存: " + (main == vice));
        System.out.println();

        // 修改副对象中的性别属性
        vice.setGender("女");
        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("修改拷贝对象中的String类型的属性gender后是否相同: " + main.getGender().equals(vice.getGender()));
        System.out.println();


        // 修改副对象中引用对象中的年龄属性
        vice.getPet().setAge(10);
        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("修改拷贝对象中的引用类型Pet后，是否在同一个堆内存当中: " + (main.getPet() == vice.getPet()));
        System.out.println();
        System.out.println("可以发现，它是对'主'对象的序列化实现完全拷贝，无论是引用对象还是数组，都会拷贝一个新的对象，并且与源对象的引用完全隔离");

    }
}

// 宠物对象
class Pet implements Serializable {
    private String name;
    private int age;

    public Pet(String name, int age) {
        this.name = name;
        this.age = age;
    }

	// ...省略set、get方法

    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

// 主人对象
class Master implements Serializable {
    private String gender;

    private Pet pet;

    public Master(String gender) {
        this.gender = gender;
    }

	// ...省略set、get方法

    public Master clone() {
        ObjectOutputStream oos;
        ObjectInputStream ois;
        Master master = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
            oos = new ObjectOutputStream(baos);
            oos.writeObject(this);
            // 将流序列化成对象
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ois = new ObjectInputStream(bais);
            master = (Master) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return master;
    }

    @Override
    public String toString() {
        return "Master{" +
                "gender='" + gender + '\'' +
                ", pet=" + pet +
                '}';
    }
}
  • 输出结果

在这里插入图片描述

四、Spring下的BeanUtils.copyProperties()方法进行浅拷贝和深拷贝

对于BeanUtils.copyProperties来说，你必须保证属性名和类型是相同的，因为它是根据get和set方法来赋值的

但，BeanUtils只是浅拷贝

4.1 测试BeanUtils.copyProperties()浅拷贝

  • 代码演示
package com.vinjcent;

import org.springframework.beans.BeanUtils;

public class Main {

    public static void main(String[] args) {
        // 主人(正)
        Master main = new Master("男");
        // 宠物
        Pet p = new Pet("小狗", 5);

        main.setPet(p);

        // 浅拷贝一个"主"对象(副)
        Master vice = new Master();
        BeanUtils.copyProperties(main, vice);   // 修改地方


        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("拷贝后对象的指针是否都指向同一个堆内存: " + (main == vice));
        System.out.println();

        // 修改副对象中的性别属性
        vice.setGender("女");
        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("修改拷贝对象中的String类型的属性gender后是否相同: " + main.getGender().equals(vice.getGender()));
        System.out.println();


        // 修改副对象中引用对象中的年龄属性
        vice.getPet().setAge(10);
        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("修改拷贝对象中的引用类型Pet后，是否在同一个堆内存当中: " + (main.getPet() == vice.getPet()));
        System.out.println();
    }
}

// 宠物对象
class Pet {
    private String name;
    private int age;

    public Pet(String name, int age) {
        this.name = name;
        this.age = age;
    }

	// ...省略set、get方法

    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

// 主人对象
class Master {
    private String gender;

    private Pet pet;

    public Master(String gender) {
        this.gender = gender;
    }

    public Master() {}

	// ...省略set、get方法

    @Override
    public String toString() {
        return "Master{" +
                "gender='" + gender + '\'' +
                ", pet=" + pet +
                '}';
    }
}
  • 输出结果

在这里插入图片描述

4.2 测试BeanUtils.copyProperties()深拷贝

从上面提到，我们可以通过序列化的形式来实现bean的深拷贝，可在BeanUtils.copyProperties()方法中如何实现呢？

答：我们可以借助java8的一些stream新特性

  • 代码演示
package com.vinjcent;

import org.springframework.beans.BeanUtils;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {

        // 要是用stream流,一般会使用到集合,先构造一个master集合
        List<Master> main = Arrays.asList(new Master("男"), new Master("女"));
        main = main.stream().map(m -> {
            m.setPet(new Pet("源pet", 5));
            return m;
        }).collect(Collectors.toList());

        // 使用stream流实现bean的深拷贝
        List<Master> vice = main
                .stream()
                .map(m -> {
                    Master temp = new Master();
                    BeanUtils.copyProperties(m, temp);
                    return temp;
                }).collect(Collectors.toList());


        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("拷贝后对象的指针是否都指向同一个堆内存: " + (main == vice));
        System.out.println();

        // 修改副对象中第一个元素的性别属性
        vice.get(0).setGender("女");
        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("在拷贝对象中，修改第一个元素的String类型的属性gender后是否相同: " + main.get(0).getGender().equals(vice.get(0).getGender()));
        System.out.println();


        // 修改副对象中第一个元素的引用对象中的年龄、名称属性
        vice.get(0).getPet().setAge(10);
        vice.get(0).getPet().setName("小猫");
        System.out.println("主对象: " + main);
        System.out.println("副对象: " + vice);
        System.out.println("在拷贝对象中，修改第一个元素的引用类型Pet后，是否在同一个堆内存当中: " + (main.get(0).getPet() == vice.get(0).getPet()));
        System.out.println();
        System.out.println("可以发现，它是对'主'对象的拷贝，它不会拷贝'主'对象深层次的可变对象，只做第一层的拷贝");
    }
}

// 宠物对象
class Pet {
    private String name;
    private int age;

    public Pet(String name, int age) {
        this.name = name;
        this.age = age;
    }

	// ...省略set、get方法

    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

// 主人对象
class Master {
    private String gender;

    private Pet pet;

    public Master(String gender) {
        this.gender = gender;
    }

    public Master() {
    }

	// ...省略set、get方法

    @Override
    public String toString() {
        return "Master{" +
                "gender='" + gender + '\'' +
                ", pet=" + pet +
                '}';
    }
}
  • 输出结果

在这里插入图片描述

结论：由此可知，org.springframework.beans.BeanUtils工具类中的copyProperties()方法无法实现深拷贝，只能实现浅拷贝

Naijia_OvO
关注
专栏目录
BeanMapper：比BeanUtils.copyProperties更快
08-24
一个BeanUtils.copyProperties的小型快速替代。 起因 由于BeanUtils（Spring或Apache Commons）的copyProperties实现是利用反射实现的，它在大量调用时具有比较严重的性能问题。 BeanMapper通过javassist类库实现在...
【Spring】Apache的BeanUtils与SpringBean的BeanUtils对比
九师兄
07-04 107
在Java中，除了 基本数据类型之外，还存在 类的实例对象这个引用数据类型，而一般使用 “=”号做赋值操作的时候，对于基本数据类型，实际上是拷贝的它的值，但是对于对象而言，其实赋值的只是这个对象的引用，将原对象的引用传递过去，他们实际还是指向的同一个对象。而浅拷贝和深拷贝就是在这个基础上做的区分，如果在拷贝这个对象的时候，只对基本数据类型进行了拷贝，而对引用数据类型只是进行引用的传递，而没有真实的创建一个新的对象，则认为是浅拷贝。
Spring中BeanUtils的copyProperties使用总结
qq_27397913的博客
10-11 418
准备 单独使用spring的BeanUtils的话，需要准备如下 spring-bean包和spring-core包 代码 Person类：要被赋值的类 public class Person{ private Telephone telephone; public Telephone getTelephone() { return telephone; ...
Java BeanUtils.copyProperties() 详解及应用
最新发布
m0_73467713的博客
08-17 2863
方法用于将一个 Java 对象的属性复制到另一个对象。它在处理数据传输对象（DTO）、视图对象（VO）和实体对象（Entity）之间的数据传递时非常有用。source：源对象，属性值从这个对象中提取。target：目标对象，将属性值复制到这个对象中。是一个强大的工具，可以简化对象属性的拷贝操作。它在 Java 开发中扮演着重要的角色，尤其是在对象转换、数据封装和自动化测试等场景中。虽然它提供了很大的便利，但在性能要求较高的情况下，可能需要评估其他解决方案。
BeanUtils.copyProperties方法详解
是木子啦~
10-09 2789
方法是 Apache Commons BeanUtils 库提供的一个实用方法，用于将一个 Java 对象的属性值复制到另一个 Java 对象中。它的作用是简化对象之间属性复制的过程，避免手动编写大量的赋值代码。该方法会将源对象的属性值复制到目标对象中，属性名相同的属性会被复制。下面是一个示例，演示了如何使用。的属性值复制到了目标对象。
BeanUtils.copyProperties() 详解
wjw_de_java的博客
02-07 7万+
BeanUtils.copyProperties会进行类型转换； BeanUtils.copyProperties方法简单来说就是将两个字段相同的对象进行属性值的复制。 这两个类在不同的包下面，而这两个类的copyProperties()方法里面传递的参数赋值是相反的。 一、 org.springframework.beans.BeanUtils a拷贝到b a,b为对象 BeanUtils.copyProperties(a, b); 二、org.apache.commons.beanutils.Bean
BeanUtils.copyProperties的用法(超详细，建议收藏)
wwwwwww31311的博客
05-25 5万+
用法 org.springframework.beans.BeanUtils，它提供了对java反射和自省API的包装。它里面还有很多工具类，这里我们介绍一下copyProperties。 我们如果有两个具有很多相同属性的JavaBean对象a和b，想把a中的属性赋值到b，比如接口中将接收到的前端请求参数封装为reqVo,dan @Data public class User { private String id; private String name; private Stri
BeanUtils.copyProperties
qq_40813329的博客
05-07 1万+
简介 这里说的是spring的BeanUtils.copyProperties BeanUtils 提供对 Java 反射和自省 API 的包装，其主要目的是利用反射机制对 JavaBean 的属性进行处理 public static void copyProperties(Object source, Object target) throws BeansException { copyProperties(source, target, (Class)null, (String[])null);
BeanUtils.copyProperties基本用法与小坑
whiteBearClimb的博客
07-15 1万+
（1）实际应用 BeanUtils.copyProperties(赋值目标对象，模板源对象); 我们都知道当有两个对象AB，属性名称一样的情况下，如果需要把A的全部属性给B，传统写法是： B.setXX(A.getXX()); 如果只有几个特别的参数需要赋值过去这样写没问题，如果AB有100个参数需要粘过去，那么代码就太冗余太长了，BeanUtils.copyProperties就是为了解决这个问题的，现在假设有AB两个对象： static class DemoA { private String
BeanUtils工具类中的copyProperties方法使用
qgnczmnmn的博客
10-30 8万+
文章目录1、两个包下的BeanUtils.copyProperties对比2、BeanUtils.copyProperties的深浅拷贝问题2.1、浅拷贝和深拷贝2.2、BeanUtils.copyProperties深浅拷贝问题 1、两个包下的BeanUtils.copyProperties对比 BeanUtils是开发中常用到的工具类，而获取这一工具类主要是通过导入org.springframework.beans.BeanUtils或者org.apache.commons.beanutils.Bean
java Beanutils.copyProperties( )用法详解
08-19
Java Beanutils.copyProperties() 方法是 Java 中一个非常有用的工具，主要用于将一个 JavaBean 的属性复制到另一个 JavaBean 中。今天，我们将详细介绍 Java Beanutils.copyProperties() 的用法和原理。 在 Java ...
如何使用BeanUtils.copyProperties进行对象之间的属性赋值
08-19
`BeanUtils.copyProperties`是Spring框架中的一个静态方法，位于`org.springframework.beans.BeanUtils`类中。它的主要功能是将源对象（source）的所有可读属性值复制到目标对象（target）。如果源对象和目标对象有...
Beanutils.copyProperties( )使用遇到的问题
wangjianweiaaa的博客
05-11 3820
Beanutils.copyProperties( )使用遇到的问题 BeanUtils.copyProperties VS PropertyUtils.copyProperties 两者最大的区别是： BeanUtils.copyProperties会进行类型转换，而PropertyUtils.copyProperties不会。 既然进行了类型转换，那BeanUtils.copyProperties的速度比不上PropertyUtils.copyProperties。 因此，PropertyUtils
BeanUtils.copyProperties的使用(深拷贝，浅拷贝)
热门推荐
enthan809882的博客
03-18 13万+
这里说的是spring的BeanUtils.copyProperties。 场景 开发中经常遇到，把父类的属性拷贝到子类中。通常有2种方法： 1、一个一个set 2、用BeanUtils.copyProperties 很显然BeanUtils更加方便，也美观很多。 那么任何情况都能使用BeanUtils么，当然不是。要先了解他。 是深拷贝，还是浅拷贝? 是浅拷贝。 浅拷贝： 只是调用子对象的set...
java对象拷贝之BeanUtils.copyProperties() 用法
Mr_linjw的专栏
12-09 8万+
一、简介： BeanUtils提供对Java反射和自省API的包装。其主要目的是利用反射机制对JavaBean的属性进行处理。我们知道，一个JavaBean通常包含了大量的属性，很多情况下，对JavaBean的处理导致大量get/set代码堆积，增加了代码长度和阅读代码的难度。 二、用法： 如果你有两个具有很多相同属性的JavaBean，一个很常见的情况...
BeanUtils
h294590501的专栏
06-19 1万+
BeanUtilsBeanUtils是Apache Commons组件的成员之一， 主要用于简化JavaBean封装数据的操作。 ​ ​ 简化反射封装参数的步骤，给对象封装参数。 好处： BeanUtils给对象封装参数的时候会进行类型自动转换。JavaBean//JavaBean就是一个类，但该类需要满足以下三个条件： ​ 1. 类//必须使用public修饰。 ​ 2. 提供无参数的构造器。 ...
beanutils.copyproperties 深拷贝
08-18
Spring下的BeanUtils.copyProperties方法实现的是浅拷贝而不是深拷贝。浅拷贝是指将一个对象的引用赋值给另一个对象，两个对象指向同一块内存空间，修改其中一个对象的属性会影响到另外一个对象。而深拷贝是指创建一个新的对象，将原对象的属性值复制到新对象中，新对象和原对象指向不同的内存空间，修改其中一个对象的属性不会影响到另外一个对象。 如果想在BeanUtils.copyProperties方法中实现深拷贝，可以通过序列化和反序列化来实现。先将原对象进行序列化，然后再反序列化为一个新的对象，这样就实现了深拷贝。但是需要注意的是，这种方式要求被拷贝的对象及其属性必须实现Serializable接口。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Spring学习笔记（一）【BeanUtils.copyProperties方法】](https://blog.csdn.net/Wei_Naijia/article/details/128791555)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Naijia_OvO

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

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

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

打赏作者

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

抵扣说明：

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

余额充值