对象拷贝那些事

对象拷贝那些事

拷贝方法

该文章对以下几种拷贝方式进行使用场景和性能对比进行说明。
- clone
- set
- spring beanutils
- cglib beanCopier
- stream
- orika

深拷贝 or 浅拷贝

• 深拷贝：指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。
• 浅拷贝：指拷贝的对象根据原对象属性值拷贝一份，包括值，和内存地址，一个引用对象中值改变会影响其他对象

clone

1: 如何使用clone
实现cloneable 接口，重写clone 方法

 public class UserA implements Cloneable{
    private Long uid;
    private String name;
    private Date brithday;
    private Address address;
    @Override
    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
 }

注意点：这样写的clone 是浅拷贝，当我们修改拷贝对象的address 值，原对象的address 会修改。

测试代码：

    UserA userA=new UserA();
    userA.setUid(1L);
    userA.setName("cs");
    userA.setBrithday(new Date());
    Address address=new Address();
    address.setAddress("hangzhou");
    userA.setAddress(address);

    UserA userA1=(UserA)userA.clone();
    userA1.getAddress().setAddress("quzhou");
    System.out.println("userA:"+userA.toString());
    System.out.println("userA1:"+userA1.toString());

结果：

    userA:UserA{uid=1, name='cs', brithday=Sun Jul 15 10:36:28 CST 2018, address=Address{address='quzhou'}}
    userA1:UserA{uid=1, name='cs', brithday=Sun Jul 15 10:36:28 CST 2018, address=Address{address='quzhou'}}

如何实现整个深拷贝？
1:Address 也实现Cloneable 类，并重写clone方法

public class Address implements Cloneable{
    private String address;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

2: 重新改造UserA 中的clone 方法

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj= super.clone();
        Address address=((UserA)obj).getAddress();
        if(Objects.nonNull(address)) {
            ((UserA) obj).setAddress((Address) address.clone());
        }
        return obj;
    }

结果：

    userA:UserA{uid=1, name='cs', brithday=Sun Jul 15 10:36:28 CST 2018, address=Address{address='hangzhou'}}
    userA1:UserA{uid=1, name='cs', brithday=Sun Jul 15 10:36:28 CST 2018, address=Address{address='quzhou'}}

clone总结：
① 如果有一个非原生成员，如自定义对象的成员，那么就需要：
该成员实现Cloneable接口并覆盖clone()方法，不要忘记提升为public可见。
同时，修改被复制类的clone()方法，增加成员的克隆逻辑。
② 如果被复制对象不是直接继承Object，中间还有其它继承层次，每一层super类都需要实现Cloneable接口并覆盖clone()方法。

缺点：1：该clone 只能clone 赋值给该对象
2: 只能适用于简单对象，复杂对象，太麻烦

set

该方法是我们比较常用的，通过getset 方法进行设置

    @Test
    public void testSet(){
        UserA userA=new UserA();
        userA.setUid(1L);
        userA.setName("cs");
        userA.setBrithday(new Date());

        UserA userA1=new UserA();
        userA1.setUid(userA.getUid());
        userA1.setName(userA.getName());
        userA1.setBrithday(userA.getBrithday());

        userA1.setName("css");
        System.out.println("userA:"+userA.toString());
        System.out.println("userA1:"+userA1.toString());
    }

和clone 类似如果要实现深拷贝效果就要手赋值每一个对象，address 中的属性也要分别赋值

缺点：当属性多时，手写费时费力

spring beanutils

介绍

spring 提供的对象拷贝类，使用反射实现，获得目标对象属性值，根据属性去获得source readmethod 方法，如果为私有就设置 成public，然后根据属性获得target writeMethod,如果为私有就设置成public,最后writeMethod.invoke(target, value);和apache common beanutil 不同的是这个能处理date

如何使用 beanutils？

    public void testBeanUtil() {
        UserA userA=new UserA();
        userA.setUid(1L);
        userA.setName("cs");
        userA.setBrithday(new Date());
        Address address=new Address();
        address.setAddress("hangzhou");
        userA.setAddress(address);

        UserA userA1=new UserA();
        BeanUtils.copyProperties(userA,userA1);
        userA1.getAddress().setAddress("quzhou");
        System.out.println("userA:"+userA.toString());
        System.out.println("userA1:"+userA1.toString());
    }

结果：

    userA:UserA{uid=1, name='cs', brithday=Sun Jul 15 12:18:32 CST 2018, address=Address{address='quzhou'}}
    userA1:UserA{uid=1, name='cs', brithday=Sun Jul 15 12:18:32 CST 2018, address=Address{address='quzhou'}}

注意：spring beanutils 是浅拷贝，如果要是想实现深拷贝效果，就要手动对每个引用属性进行copy

缺点：随着属性增多，耗时增加明显，相互拷贝的对象需要属性名称和set 方法相同

cglib beanCopier

介绍

cglib 通过代理的方式实现拷贝，性能优于反射，扫描原来的get方法赋值给set 方法

如何使用 beanCopier？
1: 依赖

 <dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.2.4</version>
</dependency>

如果项目中引用了 spring-boot-starter-test 则不需要单独引
2：使用

    UserA userA=new UserA();
    userA.setUid(1L);
    userA.setName("cs");
    userA.setBrithday(new Date());
    Address address=new Address();
    address.setAddress("hangzhou");
    userA.setAddress(address);
    UserA userA1=new UserA();
    BeanCopier.create(UserA.class, UserA.class, false).copy(userA, userA1, null);
    userA1.getAddress().setAddress("quzhou");
    System.out.println("userA:"+userA.toString());
    System.out.println("userA1:"+userA1.toString());

结果：

    userA:UserA{uid=1, name='cs', brithday=Sun Jul 15 10:36:28 CST 2018, address=Address{address='quzhou'}}
    userA1:UserA{uid=1, name='cs', brithday=Sun Jul 15 10:36:28 CST 2018, address=Address{address='quzhou'}}

注意：cglib 是浅拷贝，并且使用时应该对BeanCopier 进行缓存
优点：高性能,简洁

stream

如何使用？

 /**
     * This method makes a "deep clone" of any Java object it is given.
     */
    public static Object deepClone(Object object) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        }
        catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

注意：该方法是通过字节流输入输出进行深拷贝
缺点: 性能差

orika

介绍

官方介绍 ：simpler, lighter and faster Java bean mapping
针对复杂的嵌套属性和深度结构化的对象有很好的处理方式，它将自动收集类的元数据来生成映射对象，这些映射对象可以一起使用，以递归地将数据从一个对象图复制到另一个对象图中。Orika试图提供许多方便的功能，同时保持相对简单和开放的状态——让你有可能扩展和调整它，以满足你的需要。
如何使用？
1:引用依赖

    <dependency>
          <groupId>ma.glasnost.orika</groupId>
          <artifactId>orika-core</artifactId>
          <version>1.5.2</version>
    </dependency>

2：使用

MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
MapperFacade mapper=mapperFactory.getMapperFacade();
List<UserC> userAList4=mapper.mapAsList(userAList, TypeFactory.valueOf(UserA.class),TypeFactory.valueOf(UserC.class));

3: 一些使用

指定不同名称属性直接相互转换
 mapperFactory.classMap(BasicPerson.class, BasicPersonDto.class)
    .field("name", "fullName")
    .field("age", "currentAge")
    .register();

指定不同名称属性单项转换
mapperFactory.classMap(BasicPerson.class, BasicPersonDto.class)
    .fieldAToB("name", "fullName")
    ...
    .register();

排除name 属性进行转换
 mapperFactory.classMap(BasicPerson.class, BasicPersonDto.class)
    .exclude("name")
    ...
    .register();

更多使用请参考 文章

注意：orika 是深拷贝，性能比stream 好10-20倍左右，orika 最耗时的是创建MapperFactory，和获得MapperFacade ，MapperFacade 是线程安全的，我们可以使用单例保存起来

性能测试：使用JMH微基准框架进行测试由于JVM会对热点代码进行优化：方法反射调用次数超过阈值时会生成一个专用的MethodAccessor实现类，生成其中的调用（）方法的字节码进行执行。！[ 这里写图片描述]

使用场景：

性能(极致,好)，属性数量(多,少)，层级（浅，深），属性名称（一致，不一致），代码简洁
0：同类型对象拷贝，需要性能极致，浅拷贝或(对象相对简单，层级不深的)，推荐使用clone>beancopier>set>orika>beanUtil>deepcopy
1：不同类型对象拷贝，需要性能极致，并且属性数量多，层级浅，属性名称一致，需要代码简洁 推荐使用beancopier
2：不同类型对象拷贝或同类型对象，需要性能极致，并且属性数量少，层级浅，属性名称不一致 推荐set
3: 不同类型对象拷贝或同类型对象，需要性能好，并且属性数量少或多，层级深，属性名称不限，需要相互转换，推荐orika