Bean Copy也就这么点事了！

最新推荐文章于 2024-04-22 19:57:59 发布
最新推荐文章于 2024-04-22 19:57:59 发布
阅读量1.7k 收藏 6
点赞数 6
分类专栏： Java 基础 文章标签： java 后端 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18515155/article/details/111414852
版权
Java 同时被 2 个专栏收录
34 篇文章 3 订阅
订阅专栏
基础
22 篇文章 0 订阅
订阅专栏

文章目录

什么是深拷贝和浅拷贝

先来看一张图：
在这里插入图片描述
我们都知道对象的引用分配在栈上，对象的内存分配在堆上。
如上图所示，对象objB是对象objA的一个拷贝，objB只是在栈上重新分配了一个引用，但是实际指向的内存和objA是同一个，这就是浅拷贝；相反，如果objB除了在栈上分配了新的引用，并且在堆上也分配了新的内存空间，这就是深拷贝。

浅拷贝就是复制对象的引用，修改复制的对象会影响原来的对象；深拷贝就是新建一个和原对象“一模一样”的对象，但是他们在堆上占用不同的内存。

题外话：和深拷贝（Deep Copy）、浅拷贝（Shallow Copy），有相似概念的还有深堆（Deep Heap）、浅堆（Shallow Heap），感兴趣的同学可以自己查找资料。

浅拷贝

在这里插入图片描述

  1. 对于数据类型是基本数据类型的成员变量，浅拷贝会直接将该属性值复制一份给新的对象。因为是两份不同的数据，所以对其中一个对象的该成员变量值进行修改，不会影响另一个对象拷贝得到的数据。
  2. 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
  3. String类型非常特殊，首先，String类型属于引用数据类型，不属于基本数据类型，但是String类型的数据是存放在常量池中的，也就是无法修改的！也就是说，当修改String类型成员变量后，并不是修改了这个数据的值，而是把这个数据的引用指向了一个新的字符串常量。

实现方式

使用拷贝构造方法
public static void main (String[] args) {
	Address addr = new Address("北京")
	User userA = new User(10,addr);
	System.out.println(userA.getAge());
	//浅拷贝
	User userC = new User(userA);
	userC.setAge(30);
	System.out.println(userA.getAge());
	System.out.println(userC.getAge());
	System.out.println(userA.getAddr() == userCopy.getAddr());
}

@Getter
@Setter
public class User {
	private int age;
	private Address addr;
	public User(int age,Address addr) {
		this.age = age;
		this.addr = addr;
	}
	//复制构造方法，模拟浅拷贝
	public User(User source) {
        this.age = source.age;
        this.addr = source.addr;
    }
}
public class Address {
	private String addr;
	public Address(String addr) {
		this.addr = addr;
	}
}

输出结果：

10
10
20
false
使用Cloneable
  1. 实现Cloneable接口；
  2. 重写Object类的clone()方法；

Address.java

/**
 * @author xujian
 * @date 2020-12-20 14:52
 **/
public class Address {
    private String addr;

    public Address(String addr) {
        this.addr = addr;
    }

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "Address{" +
                "addr='" + addr + '\'' +
                '}';
    }
}

User.java

/**
 * @author xujian
 * @date 2020-12-20 14:52
 **/
public class User implements Cloneable{
    private int age;
    private Address addr;

    public User(int age, Address addr) {
        this.age = age;
        this.addr = addr;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Address getAddr() {
        return addr;
    }

    public void setAddr(Address addr) {
        this.addr = addr;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", addr=" + addr +
                '}';
    }
}

测试

/**
 * @author xujian
 * @date 2020-12-20 15:08
 **/
public class Demo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address addr = new Address("北京市");
        User userA = new User(10,addr);
        User userCopy = (User) userA.clone();
        System.out.println(userA);
        System.out.println(userCopy);
        //判断userA和userCopy是否是同一个对象
        System.out.println(userA == userCopy);
        userCopy.setAge(20);
        addr.setAddr("西安市");
        System.out.println(userA);
        System.out.println(userCopy);
        //判断userA的成员变量addr和userCopy的成员变量addr是否是同一个对象
        System.out.println(userA.getAddr() == userCopy.getAddr());
    }
}

输出

User{age=10, addr=Address{addr='北京市'}}
User{age=10, addr=Address{addr='北京市'}}
false
User{age=10, addr=Address{addr='西安市'}}
User{age=20, addr=Address{addr='西安市'}}
true
  1. 基本类型的成员变量原始对象和拷贝对象互不影响；
  2. 可以看到clone()方法拷贝的userCopy对象和原对象的内容是一样的。然而他们并不是同一个对象；
  3. 原始对象和拷贝的象他们的引用类型成员变量Address::addr是同一个对象;
  4. Object::clone()本身是个浅拷贝实现;

⚠️注意

  1. 使用clone()方法时必须实现Cloneable接口，否则会报错CloneNotSupportedException，其实Cloneable接口没有定义任何方法，它和Serializable接口一样，都是起到一个标识作用;
  2. clone()是一个native方法，所以在浅拷贝上其效率还是很好的;
  3. clone()三原则：
    ① 对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象；
    ② 对任何的对象x，都有x.clone().getClass()==x.getClass()//克隆对象与原对象的类型一样；
    ③ 如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立；
使用Setter方法

通过对象内部提供的Setter方法简单且直接的进行对象的拷贝：

public static User copyBySetter(User source){
        User user = new User();
        user.setAge(source.getAge());
        user.setAddr(source.getAddr());
        return user;
    }

深拷贝

在这里插入图片描述

  1. 不仅要复制对象的所有基本数据类型的成员变量值，还要为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，一直递归下去直到没有引用类型的成员变量。也就是说，对象进行深拷贝要对整个对象图进行拷贝；
  2. 深拷贝对引用数据类型的成员变量的对象图中所有的对象都开辟了内存空间；而浅拷贝只是传递地址指向，新的对象并没有对引用数据类型创建内存空间；

实现方式

使用Cloneable

在上面使用Cloneable实现浅拷贝的基础上，对clone方法进行改造：
City.java

/**
 * @author xujian
 * @date 2020-12-26 12:30
 **/
public class City implements Cloneable, Serializable{
    private String name;

    public City() {

    }

    public City(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

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

Address.java

/**
 * @author xujian
 * @date 2020-12-20 14:52
 **/
public class Address implements Cloneable, Serializable{
    private String addr;
    private City city;

    public Address() {

    }

    public Address(String addr) {
        this.addr = addr;
    }

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public void setCity(City city) {
        this.city = city;
    }

    public City getCity() {
        return city;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Address address = (Address) super.clone();
        City city = (City) address.getCity().clone();
        address.setCity(city);
        return address;
    }

    @Override
    public String toString() {
        return "Address{" +
                "addr='" + addr + '\'' +
                ", city=" + city +
                '}';
    }
}

User.java

/**
 * @author xujian
 * @date 2020-12-20 14:52
 **/
public class User implements Cloneable, Serializable{
    private int age;
    private Address addr;

    public User() {

    }
    public User(int age, Address addr) {
        this.age = age;
        this.addr = addr;
    }

    public User(User source) {
        this.age = source.age;
        this.addr = source.addr;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Address getAddr() {
        return addr;
    }

    public void setAddr(Address addr) {
        this.addr = addr;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        User user = (User) super.clone();
        Address address = (Address) user.getAddr().clone();
        user.setAddr(address);
        return user;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", addr=" + addr +
                '}';
    }
}

public static void main(String[] args) throws CloneNotSupportedException {
        User source = new User();
        source.setAge(70);
        Address address = new Address();
        address.setAddr("陕西省");
        City city = new City("渭南市");
        address.setCity(city);
        source.setAddr(address);

        User copyUser = (User) source.clone();
        System.out.println(source);
        System.out.println(copyUser);
        System.out.println(source == copyUser);
    }

输出结果如下：

User{age=70, addr=Address{addr='陕西省', city=City{name='渭南市'}}}
User{age=70, addr=Address{addr='陕西省', city=City{name='渭南市'}}}
false

这种方式在clone()方法的浅拷贝基础上，根据引用类型成员变量使用层层调用，来实现深拷贝，也是有点繁琐的。

序列化方式

这种方式在我们日常开发工作中非常常见，避免了手动实现深拷贝中“递归”的操作，所以看上去会比上面的方式简单一点。

Json序列化/反序列化

可以想一想，SpringMVC中的Controller在传递对象参数和返回对象数据时的序列化和反序列化。
在这里插入图片描述

从Json字符串反序列化来的对象都是一个新的对象。

依旧是上面的例子：

public static void main(String[] args) throws CloneNotSupportedException {
        User source = new User();
        source.setAge(70);
        Address address = new Address();
        address.setAddr("陕西省");
        City city = new City("渭南市");
        address.setCity(city);
        source.setAddr(address);

		//序列化成json字符串
        String userJsonStr = JSON.toJSONString(source);
        //反序列化成对象
        User copyUser = JSON.parseObject(userJsonStr,User.class);

        System.out.println(source);
        System.out.println(copyUser);
        System.out.println(source == copyUser);
    }

输出结果：

User{age=70, addr=Address{addr='陕西省', city=City{name='渭南市'}}}
User{age=70, addr=Address{addr='陕西省', city=City{name='渭南市'}}}
false

可见反序列化生成的对象是一个新的对象。

JDK序列化/反序列化

同样还有JDK自带的序列化方式。
依旧是上面的例子：

public static void main(String[] args) throws Exception {
        User source = new User();
        source.setAge(70);
        Address address = new Address();
        address.setAddr("陕西省");
        City city = new City("渭南市");
        address.setCity(city);
        source.setAddr(address);
        
        User copyUser = jdkDeepCopy(source);

        System.out.println(source);
        System.out.println(copyUser);
        System.out.println(source == copyUser);
    }
    /**
     * jdk序列化/反序列化
     * @param source
     * @return
     * @throws Exception
     */
    public static User jdkDeepCopy(User source) throws Exception {
        //将对象写到流里
        ByteArrayOutputStream bo=new ByteArrayOutputStream();
        ObjectOutputStream oo=new ObjectOutputStream(bo);
        oo.writeObject(source);
        //从流里读出来
        ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
        ObjectInputStream oi=new ObjectInputStream(bi);
        return (User) oi.readObject();
    }

输出结果：

User{age=70, addr=Address{addr='陕西省', city=City{name='渭南市'}}}
User{age=70, addr=Address{addr='陕西省', city=City{name='渭南市'}}}
false
手动使用Setter层层设置属性

还是基于上面的例子，增加一个手动使用Setter进行copy的方法：

public static void main(String[] args) {
        User source = new User();
        source.setAge(70);
        Address address = new Address();
        address.setAddr("陕西省");
        City city = new City("渭南市");
        address.setCity(city);
        source.setAddr(address);

        User copyUser = getDeepCopyInstance(source);
        System.out.println(source);
        System.out.println(copyUser);
        System.out.println(source == copyUser);
    }

    /**
     * 得到指定对象的一个深拷贝对象
     * @return
     */
    public static User getDeepCopyInstance(User source) {
        User copyUser = new User();
        copyUser.setAge(source.getAge());
        Address address = new Address();
        address.setAddr(source.getAddr().getAddr());
        City city = new City();
        city.setName(source.getAddr().getCity().getName());
        address.setCity(city);
        copyUser.setAddr(address);
        return copyUser;
    }

输出结果：

User{age=70, addr=Address{addr='陕西省', city=City{name='渭南市'}}}
User{age=70, addr=Address{addr='陕西省', city=City{name='渭南市'}}}
false

这个方法虽然可以达到效果，但是编码繁琐，并且不够通用，试想引用链很长的时候编码工作量得多恐怖。

其他方式还可以借助反射直接进行属性赋值，内省机制（依赖于反射）通过调用Setter方法，构造函数等通过层层递归来进行对象的深拷贝。

Bean拷贝工具

Apache的BeanUtils

位于org.apache.commons.beanutils包下。通过上面提到的内省机制调用Setter方法实现。默认实现浅拷贝，想要实现深拷贝，则需要提供自定义的Converter。
使用示例：

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)

稳定性与效率都不行，不推荐使用。

Apache的PropertyUtils

位于org.apache.commons.beanutils包下。
PropertyUtils的copyProperties()方法几乎与BeanUtils.copyProperties()相同，主要的区别在于BeanUtils.copyProperties()提供类型转换功能，即发现两个JavaBean的同名属性为不同类型时，在支持的数据类型范围内进行转换，PropertyUtils不支持这个功能，所以说BeanUtils使用更普遍一点，犯错的风险更低一点，默认实现浅拷贝。

Apache的SerializationUtils

位于org.apache.commons.lang3包下。
SerializationUtils.clone(T)，T对象需要实现 Serializable 接口，基于JDK序列化实现了深克隆。

深拷贝可以使用。

Spring的BeanUtils

位于org.springframework.beans包下。
其copyProperties方法实现原理和Apache BeanUtils.copyProperties原理类似，默认实现浅拷贝，区别在于对PropertyDescriptor（内省机制相关）的处理结果做了缓存来提升性能。

Spring的BeanCopier

位于org.springframework.cglib.beans包下，默认实现浅拷贝。
BeanCopier支持两种方式:

  1. 不使用Converter的方式，仅对两个bean间属性名和类型完全相同的变量进行拷贝;
  2. 引入Converter，可以对某些特定属性值进行特殊操作，但性能会大大降低。

通过操作字节码生成类，来实现原本需要通过反射或者一堆代码才能实现的逻辑，内部还是通过直接调用Setter方法来实现。

使用了字节码操作取代反射，使用缓存以及通过Setter方法设置属性值使其性能非常优秀，推荐使用。

Tips：
实际使用时，可以把创建过的BeanCopier实例放到缓存中，下次可以直接获取，提升性能。

MapStruct

默认实现浅拷贝，通过注解编译时自动生成拷贝的代码，基于直接调用Setter方法实现。

性能还不错，主要是使用方便，加上注解就可以用了。

总结

  1. 浅拷贝：是对原对象的属性值进行精准复制，那么对如果原对象的属性值是基本类型那就是值的引用，所以浅拷贝后修改基本类型不会修改到原对象的，如果原对象属性值是引用类型，那么就是对引用类型属性值的栈内存的复制，所以修改引用类型属性值的时候回修改到原对象。
  2. 深拷贝：在浅拷贝的基础上，对引用类型开辟新的堆内存进行层层拷贝。
  3. 上文中提到的深堆，浅堆，内省机制有兴趣的可以自行了解。

上文示例代码请参考：浅拷贝、深拷贝。

观众老爷求点赞

墨、鱼
关注
  • 6
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
BeanCopy:BeanCopy是一个bean映射器。-开源
05-27
这是一个轻量级的，基于注释的beanmapper，可以在反射下进行工作。 采摘樱桃：将IgnoreCopy添加到目标Bean。 因此，您还可以从那里确定应该复制哪些字段。
Java浅拷贝与深拷贝
Jak的博客
09-21 440
一、浅拷贝介绍 对于引用数据类型，浅拷贝的hashcode值是相同的 。 浅拷贝是使用默认的clone()方法来实现 sheep = (Sheep) super.clone(); 二、深拷贝介绍 复制对象的所有基本数据类型的成员变量值。 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象(包括对象的引用类型)进行拷贝。 深拷贝实现方式1：重写clone方法来实现深拷贝 深拷贝实现方式2：通
BeanCopy 常用工具类
chy1984的博客
09-30 1844
以上介绍的几种bean copy方式都是浅拷贝，通常处于性能考虑，也是使用浅拷贝，除非特殊情况。根类 Object 的 clone() 方法是 native 方法，速度快、性能高。拷贝都是新建目标类实例，浅拷贝、深拷贝的区别在于引用类型的成员字段的复制方式不同。反序列化是深拷贝的，这也是实现深拷贝最常见的方式。手动get、set，性能最高，但写起来麻烦。基于反射实现，性能极差，避免使用。
Spring BeanCopier：一键复制JavaBean属性的利器
最新发布
m0_51176516的博客
04-22 526
BeanCopier是Spring框架提供的一个辅助类，用于在不同JavaBean之间进行高效的属性复制。它通过生成动态的字节码来实现属性的复制，从而避免了使用反射机制所带来的性能损失。BeanCopier主要用于在具有相同或相似属性名称和类型的JavaBean之间复制数据。
常用Bean拷贝工具一览
m0_51478572的博客
09-15 1957
对象拷贝，是我们在开发过程中，绕不开的过程，既存在于Po、Dto、Do、Vo各个表现层数据的转换，也存在于系统交互如序列化、反序列化
BeanCopy几种实现的比较
热门推荐
guanfengliang的专栏
02-27 1万+
  Bean复制的几种框架性能比较 Apache BeanUtils、PropertyUtils,Spring BeanUtils,Cglib BeanCopier）        一个FromBean和一个ToBean，两个的代码基本上一样，除了类名称不一样，所以只是贴出来了一份。   public class FromBean {     private String name; ...
BeanUtils工具类实现Bean拷贝详解
这里是Mae。
02-07 7851
BeanUtils工具类实现Bean拷贝使用详解。 真正学会Bean拷贝！
beancopy:java bean深度克隆的简单实现
05-09
beancopy ###java bean深度克隆的简单实现 Bean中必须有对应的getter, setter方法. 可以复制包含 "8种基本类型, String, java.util.Date, enum, Set, List 以及多层嵌套" 的Bean.
Copiers:友好的Bean复制工具
04-27
Copiers 是一个优雅的 Bean 拷贝工具，可通过友好的 Fluent API 帮助用户完成拷贝对象的操作。 依赖 <!-- java8 or higher --> <groupId>com.github.drtrang</groupId> <artifactId>copiers <version>...
BeanMapper：比BeanUtils.copyProperties更快
02-17
BeanMapper 一个BeanUtils.copyProperties的小型快速替代。 起因 由于BeanUtils（Spring或Apache Commons）的copyProperties实现是利用反射实现的，它在大量调用时具有比较严重的性能问题。... BeanMapper.copy用时98毫
Simple-Bean-Utility:bean 反射的简单实用程序，如 *setter 、 *getter 、 *populate 、 *copy 、*reset 、 *newInstance
06-02
Simple-Bean-Utility是一个专门为处理Java Bean而设计的库，它提供了一系列便捷的方法，简化了对Bean对象的操作，如setter、getter、populate、copy、reset和newInstance等。下面将详细探讨这些功能及其在实际应用中...
Bean拷贝
m0_57082679的博客
06-08 1419
因为基础的BeanUtils在使用时拷贝非常不方便，还需要我们自己去创建新的User拷贝，对List集合的拷贝还需要我们自己去遍历，这里我们封装工具类来实现这些功能。VO是后端将前端查询的字段数据封装成VO返给前端，使用Bean拷贝可以实现：将前端查询实体对象转为VO对象。DTO是封装前端传回来的字段，使用Bean拷贝可以实现：将前端传入Dto对象转为实体类对象。注意：两个对象中对应字段名和类型应完全相同，否则无法拷贝。将source中的字段添加到target中。第一个是参数对象，第二个是目标对象。
四种bean拷贝工具对比
qq_37436172的博客
07-20 1923
在日常编码中，经常会遇到DO、DTO对象之间的转换，如果对象本身的属性比较少的时候，那么我们采用硬编码手工setter也还ok，但如果对象的属性比较多的情况下，手工setter就显得又low又效率又低。这个时候我们就考虑采用一些工具类来进行对象属性的拷贝了。从测试结果中很明显可以看出采用HardCode方式进行对象属性Copy性能最佳；采用net.sf.cglib.beans.BeanCopier#copy方式进行对象属性copy性能最稳定；...
6种常用Bean拷贝工具一览
Java知音
12-07 2367
在我们日常的工作中，经常需要做对象的拷贝或转化，例如在传递参数时，把入参的DTO转化为PO存入数据库，在返回前端时把PO再转化为VO。如果再分的细一点，可能还会有DO(Domain Obj...
常见Bean拷贝框架使用姿势及性能对比
weixin_44882412的博客
05-25 1399
再实际的项目中，正好遇到了这个问题，不仅慢，还发现会有锁竞争，这特么就尼普了。上面的测试中，存在一个不同的变量，即不是用相同的source对象来测试不同的工具转换情况，但是这个不同并不会太影响不同框架的性能对比，基本上从上面的运行结果来看。MapStruct 性能更强悍了，缺点也比较明显，需要声明bean的转换接口，自动代码生成的方式来实现拷贝，性能媲美直接的get/set。当然我们现在一般用的Spring5+了，这段代码也早就做了改造了，新版的如下，不再存在上面的这个并发问题了。
BeanCopy坑到MapStruct技巧
m0_71777195的博客
06-20 589
Bean Copy 和 MapStruct 都是 Java 中用于对象之间复制属性的工具，它们可以大大简化代码的编写和维护。MapStruct 的性能更高，因为它在编译时生成代码，而 Bean Copy 需要使用反射机制获取对象的属性信息。但是MapStruct 的学习成本相对较高，因为需要了解注解的使用方法以及如何配置和生成代码。
bean拷贝
博观而约取 厚积而薄发
03-30 1886
平时常用的工具： Apache BeanUtils Spring BeanUtils Cglib BeanCopier MapStruct 性能对比： MapStruct ≈ Cglib BeanCopier > Spring BeanUtils > Apache BeanUtils 拷贝场景： 同名同类型字段拷贝 不同类型的属性拷贝，比如基本类型与其包装类型等 不同字段名属性拷贝，当然字段名应该尽量保持一致，但是实际业务中，由于不同开发人员，或者笔误拼错单词，这些原因都可能导
bean 属性COPY
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
04-27 617
bean 属性COPY LD is tigger forever，CG are not brothers forever， throw the pot and shine. Ride a donkey to find a horse, stay with good people, and stay away from poor people. talk is cheap, show others the code,Keep progress，make a better result. ...
Bean copy实战
weixin_38068301的博客
01-23 914
一次Bean copy引起的问题分析
java bean copy
05-17
Java Bean Copy 可以通过手动编写代码实现，也可以使用一些开源框架来实现，例如 Apache Commons BeanUtils、Spring Framework 的 BeanUtils、Dozer 等。 下面是使用 Apache Commons BeanUtils 实现 Java Bean Copy...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值