本文提供相关源码，请放心食用，详见网页侧边栏或底部，有疑问请评论或 Issue

一、前言

实际开发中，经常会遇到对象拷贝的需求，本文就结合日常开发过程中，使用到的浅拷贝技术，进行性能比较，看看谁更强。

重要： 下面将会花大量篇幅，列出各种类型浅拷贝的代码，你可以直接拖到文章末尾，看性能对比结果。然后再根据你中意的对象回过头来看它的代码，避免疲劳。

首先创建一个用于拷贝的 Bean，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.RandomUtils;

import java.util.Date;

@Data
@Builder
public class User {
    private long id;

    private int age;

    private String name;

    private boolean isMale;

    private School school;

    private Date createDate;

    public static User mock() {
        return User.builder()
                .id(RandomUtils.nextLong())
                .age(RandomUtils.nextInt())
                .name(RandomStringUtils.randomAlphanumeric(5))
                .isMale(RandomUtils.nextBoolean())
                .school(new School(RandomStringUtils.randomAlphanumeric(5), RandomUtils.nextInt()))
                .createDate(new Date())
                .build();
    }
}

@AllArgsConstructor
class School {
    private String name;

    private int code;
}

然后编写一个模板类，给各个浅拷贝方法提供预热和耗时统计功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public abstract class BaseCopyTest {
    public List<User> prepareData(int size) {
        List<User> list = new ArrayList<>(size);
        IntStream.range(0, size).forEach(e -> list.add(User.mock()));
        return list;
    }

    public User prepareOne() {
        return User.mock();
    }

    public void testCopy(List<User> data) {
        warnUp();

        long startTime = System.currentTimeMillis();

        copyLogic(data);

        System.out.println(name() + ": " + (System.currentTimeMillis() - startTime) + "ms");
    }

    abstract void warnUp();

    abstract void copyLogic(List<User> data);

    abstract String name();
}

二、工具类

首先介绍下工具类这边，代表“工具类”参赛的选手有：

  • Apache BeanUtils——廉颇老矣
  • Spring BeanUtils——夕阳红
  • Spring BeanCopier——三十而立
  • Spring BeanCopier + Reflectasm——身强力壮

2.1 Apache BeanUtils

Apache BeanUtils 算是一个比较古老的工具类，其自身是存在性能问题的，阿里巴巴开发手册中也明确禁止使用该工具，本次对比仍然把它加进来把。

想要用它需要导入依赖包：

1
2
3
4
5
 <dependency>
     <groupId>commons-beanutils</groupId>
     <artifactId>commons-beanutils</artifactId>
     <version>1.9.4</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class ApacheBeanUtilsTest extends BaseCopyTest {

    @Override
    void warnUp() {
        User source = prepareOne();
        try {
            User target = new User();
            System.out.println(source);
            BeanUtils.copyProperties(target, source);
            System.out.println(target);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    void copyLogic(List<User> data) {
        for(User source : data) {
            try {
                BeanUtils.copyProperties(new User(), source);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    String name() {
        return "Apache BeanUtils";
    }
}

2.2 Spring BeanUtils

Spring BeanUtils 和 Apache Utils API 很像，但是在效率上比 Apache 效率更高，目前使用的人也不少。引入 spring-beans 依赖包后即可使用。

Spring BeanUtils 的 copyProperties() 方法，第一个是源对象，第二个是目标对象。和 Apache BeanUtils 正好相反，要注意避免踩坑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class SpringBeanUtilsTest extends BaseCopyTest {

    @Override
    void warnUp() {
        User source = prepareOne();
        User target = new User();
        System.out.println(source);
        BeanUtils.copyProperties(source, target);
        System.out.println(target);
    }

    @Override
    void copyLogic(List<User> data) {
        for(User source : data) {
            BeanUtils.copyProperties(source, new User());
        }
    }

    @Override
    String name() {
        return "Spring BeanUtils";
    }
}

2.3 Spring BeanCopier

Spring 还为我们提供了一种基于 Cglib 的浅拷贝方式 BeanCopier，引入 spring-core 依赖包后即可使用，它被认为是取代 BeanUtils 的存在。

让我们编写一个工具类来使用 BeanCopier，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class BeanCopierUtils {
    private static final Map<String, BeanCopier> CACHE = new ConcurrentHashMap<>();

    public static void copyProperties(Object source, Object target) {
        BeanCopier copier = getBeanCopier(source.getClass(), target.getClass());
        copier.copy(source, target, null);
    }

    private static BeanCopier getBeanCopier(Class<?> sourceClazz, Class<?> targetClazz) {
        String key = generatorKey(sourceClazz, targetClazz);
        BeanCopier copier;
        if(CACHE.containsKey(key)) {
            copier = CACHE.get(key);
        } else {
            copier = BeanCopier.create(sourceClazz, targetClazz, false);
            CACHE.put(key, copier);
        }
        return copier;
    }

    private static String generatorKey(Class<?> sourceClazz, Class<?> targetClazz) {
        return sourceClazz + "_" + targetClazz;
    }
}

对应的，编写下它的测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class BeanCopierUtilsTest extends BaseCopyTest {

    @Override
    void warnUp() {
        User source = prepareOne();
        User target = new User();
        System.out.println(source);
        BeanCopierUtils.copyProperties(source, target);
        System.out.println(target);
    }

    @Override
    void copyLogic(List<User> data) {
        for(User source : data) {
            BeanCopierUtils.copyProperties(source, new User());
        }
    }

    @Override
    String name() {
        return "Spring BeanCopier";
    }
}

2.4 Spring BeanCopier + Reflectasm

在大量对象拷贝过程中，new 操作往往是耗时的，Spring BeanCopier 并没有解决 new 这个动作。Reflectasm 是一个高性能的反射工具包，可以利用它来解决 new 步骤的耗时。使用 Reflectasm 需要引入依赖：

1
2
3
4
5
<dependency>
    <groupId>com.esotericsoftware</groupId>
    <artifactId>reflectasm</artifactId>
    <version>1.11.9</version>
</dependency>

改造 BeanCopierUtils 类代码后如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
public class BeanCopierReflectasmUtils {
    private static final Map<String, BeanCopier> BEAN_COPIER_MAP = new ConcurrentHashMap<>();

    private static final Map<String, ConstructorAccess> CONSTRUCTOR_ACCESS_CACHE = new ConcurrentHashMap<>();

    private static final int MAX_CACHE_SIZE = 512;

    public static void copyProperties(Object source, Object target) {
        BeanCopier copier = getBeanCopier(source.getClass(), target.getClass());
        copier.copy(source, target, null);
    }

    public static <T> T copyProperties(T source, Class<T> targetClass) {
        if (source == null) {
            return null;
        }

        T target;
        try {
            ConstructorAccess<T> constructorAccess = getConstructorAccess(targetClass);
            target = constructorAccess.newInstance();
        } catch (RuntimeException e) {
            try {
                target = targetClass.newInstance();
            } catch (InstantiationException | IllegalAccessException e1) {
                throw new RuntimeException(String.format("Create new instance of %s failed: %s", targetClass, e.getMessage()));
            }
        }
        copyProperties(source, target);
        return target;
    }

    public static <T> List<T> copyProperties(List<?> sourceList, Class<T> targetClass) {
        if (CollectionUtils.isEmpty(sourceList)) {
            return Collections.emptyList();
        }

        ConstructorAccess<T> constructorAccess = getConstructorAccess(targetClass);
        List<T> resultList = new ArrayList<>(sourceList.size());
        for (Object source : sourceList) {
            T target;
            try {
                target = constructorAccess.newInstance();
            } catch (RuntimeException e) {
                try {
                    target = targetClass.newInstance();
                } catch (InstantiationException | IllegalAccessException e1) {
                    throw new RuntimeException(String.format("Create new instance of %s failed: %s", targetClass, e.getMessage()));
                }
            }

            copyProperties(source, target);
            resultList.add(target);
        }
        return resultList;
    }

    private static <T> ConstructorAccess<T> getConstructorAccess(Class<T> targetClass) {
        ConstructorAccess<T> constructorAccess = CONSTRUCTOR_ACCESS_CACHE.get(targetClass.getName());
        if(constructorAccess != null) {
            return constructorAccess;
        }
        try {
            constructorAccess = ConstructorAccess.get(targetClass);
            if (CONSTRUCTOR_ACCESS_CACHE.size() > MAX_CACHE_SIZE) {
                CONSTRUCTOR_ACCESS_CACHE.clear();
            }
            CONSTRUCTOR_ACCESS_CACHE.put(targetClass.getName(),constructorAccess);
        } catch (Exception e) {
            throw new RuntimeException(String.format("Create new instance of %s failed: %s", targetClass, e.getMessage()));
        }
        return constructorAccess;
    }

    private static BeanCopier getBeanCopier(Class<?> sourceClazz, Class<?> targetClazz) {
        String key = generatorKey(sourceClazz, targetClazz);
        BeanCopier copier;
        if(BEAN_COPIER_MAP.containsKey(key)) {
            copier = BEAN_COPIER_MAP.get(key);
        } else {
            copier = BeanCopier.create(sourceClazz, targetClazz, false);
            BEAN_COPIER_MAP.put(key, copier);
        }
        return copier;
    }

    private static String generatorKey(Class<?> sourceClazz, Class<?> targetClazz) {
        return sourceClazz + "_" + targetClazz;
    }
}

如上所示，拷贝方法通过 class 进行反射创建对象，并对 ConstructorAccess 进行缓存，提高效率。编写下它对应的测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class BeanCopierReflectasmUtilsTest extends BaseCopyTest {

    @Override
    void warnUp() {
        User source = prepareOne();
        try {
            System.out.println(source);
            System.out.println(BeanCopierReflectasmUtils.copyProperties(source, User.class));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    void copyLogic(List<User> data) {
        for(User source : data) {
            User target = BeanCopierReflectasmUtils.copyProperties(source, User.class);
        }
    }

    @Override
    String name() {
        return "Spring BeanCopier Reflectasm";
    }
}

三、原生类

回过头来介绍下代表 Java “原生类”参赛的选手：

  • new——祖师爷
  • clone——瘦死的骆驼比马大

3.1 new

咱们 java 面向对象编程学习的第一个关键字，非 new 莫属了。虽然浅拷贝用 new 未免太过于傻瓜，但还是把它请出来，看看它的性能咋样。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class NewTest extends BaseCopyTest {

    @Override
    void warnUp() {
        User source = prepareOne();
        try {
            User target = new User();
            System.out.println(source);
            target.setId(source.getId());
            target.setAge(source.getAge());
            target.setName(source.getName());
            target.setMale(source.isMale());
            target.setSchool(source.getSchool());
            target.setCreateDate(source.getCreateDate());
            System.out.println(target);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    void copyLogic(List<User> data) {
        for(User source : data) {
            User target = new User();
            target.setId(source.getId());
            target.setAge(source.getAge());
            target.setName(source.getName());
            target.setMale(source.isMale());
            target.setSchool(source.getSchool());
            target.setCreateDate(source.getCreateDate());
        }
    }

    @Override
    String name() {
        return "Java New";
    }
}

3.2 clone

clone 也是 Java 原生提供的拷贝方法，并且据说性能还不错，我司项目里面就还有许多用 clone 的实现。咱们也拉出来比划比划：

使用 clone 咱们得先让对象实现 Cloneable 接口，修改 User：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User implements Cloneable {
    private long id;

    private int age;

    private String name;

    private boolean isMale;

    private School school;

    private Date createDate;

    public static User mock() {
        return User.builder()
                .id(RandomUtils.nextLong())
                .age(RandomUtils.nextInt())
                .name(RandomStringUtils.randomAlphanumeric(5))
                .isMale(RandomUtils.nextBoolean())
                .school(new School(RandomStringUtils.randomAlphanumeric(5), RandomUtils.nextInt()))
                .createDate(new Date())
                .build();
    }

    @Override
    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

@AllArgsConstructor
class School {
    private String name;

    private int code;
}

再来编写它的测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class CloneTest extends BaseCopyTest {

    @Override
    void warnUp() {
        User source = prepareOne();
        System.out.println(source);
        System.out.println(source.clone());
    }

    @Override
    void copyLogic(List<User> data) {
        for(User source : data) {
            Object target = source.clone();
        }
    }

    @Override
    String name() {
        return "Java Clone";
    }
}

四、Lombok

最后咱们咱来介绍下 Lombok 的浅拷贝，代表 Lombok 出场的有两位选手：

  • toBuilder——后起之秀
  • newBuilder——迅雷不及掩耳之势

4.1 toBuilder

想要开启 Lombok 的 toBuilder 功能，需要将 User 类上方的 @Builder 修改为 @Builder(toBuilder = true) 即可，编写它的测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class ToBuilderTest extends BaseCopyTest {

    @Override
    void warnUp() {
        User source = prepareOne();
        System.out.println(source);
        System.out.println(source.toBuilder().build());
    }

    @Override
    void copyLogic(List<User> data) {
        for(User source : data) {
            User target = source.toBuilder().build();
        }
    }

    @Override
    String name() {
        return "Lombok toBuilder";
    }
}

4.2 newBuilder

再来介绍下 Lombok 的 newBuilder，它有点类似于 new，有点傻瓜，但也把它列出来，看看性能咋样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class NewBuilderTest extends BaseCopyTest {

    @Override
    void warnUp() {
        User source = prepareOne();
        System.out.println(source);
        System.out.println(this.copy(source));
    }

    @Override
    void copyLogic(List<User> data) {
        for(User source : data) {
            User target = this.copy(source);
        }
    }

    private User copy(User source) {
        return User.builder()
                .id(source.getId())
                .age(source.getAge())
                .name(source.getName())
                .isMale(source.isMale())
                .school(source.getSchool())
                .createDate(source.getCreateDate())
                .build();
    }

    @Override
    String name() {
        return "Lombok newBuilder";
    }
}

五、测试

经过漫长的选手出场介绍，咱们终于可以进行性能对比了。首先介绍下本机器配置信息：

  • Win10 专业版 1909
  • AMD Ryzen 5 3600 6-Core
  • 16GB RAM

测试均采用单线程测试，压测不同数据量情况下各种方式的耗时结果，测试结果如下（单位ms）。

类别 1K 1W 10W 100W 500W 1000W
Apache BeanUtils 27 134 1331 12902 28231 128566
Spring BeanUtils 4 21 217 1949 2004 19755
Spring BeanCopier 1 6 60 546 528 5114
Spring BeanCopier Reflectasm 2 8 72 569 563 5325
Java New 0 3 21 47 44 192
Java Clone 0 2 15 92 95 834
Lombok toBuilder 0 1 10 40 42 263
Lombok newBuilder 0 1 8 40 43 273

Java 对象浅拷贝

排除掉 BeanUtils 后，结果如下：

Java 对象浅拷贝

最后简单总结下：

  1. 禁止使用 Apache BeanUtils，性能差到离谱
  2. 不推荐使用 Spring BeanUtils，可以使用 Spring BeanCopier 替代
  3. Spring BeanCopier Reflectasm 和 Spring BeanCopier 相比提升不了性能，但是写起来更简便（不需要显式 new 对象）
  4. Java 原生的 new 和 clone 性能很高，可以使用 clone
  5. Lombok 的 toBuilder 速度也很快，并且写起来很方便，推荐使用