Java数据转换工具类

发表于

从2020年左右开始就一直在使用的自己写的一个用于Springboot项目中数据类型之间相互转换的一个工具类，可以完全替代MapStruct（当时写工具类的时候还不知道有这么个奇怪又不好用的的东西存在）。之前都是从一个项目复制到另一个项目，然后更新也没有完全同步，所以特此记录。之后的版本更新也会在这里更新，方便复制。

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
package io.tomoto.utils;

import org.springframework.beans.BeanUtils;

import java.lang.reflect.InvocationTargetException;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 数据工具
 *
 * @author Tomoto
 * @version 1.4
 */
public class DataTransformUtil {
    /**
     * 数据复制
     *
     * @param origin     原始数据
     * @param targetType 目标数据类型
     * @param then       后操作
     * @param <O>        原始数据类型
     * @param <T>        目标数据类型
     * @return 目标类型数据
     */
    public static <O, T> T transform(O origin, Class<T> targetType, BiConsumer<O, T> then) {
        if (origin == null) {
            return null;
        }
        try {
            T t = targetType.getDeclaredConstructor().newInstance();
            BeanUtils.copyProperties(origin, t);
            then.accept(origin, t);
            return t;
        } catch (NoSuchMethodException |
                 InstantiationException |
                 IllegalAccessException |
                 InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 数据复制
     *
     * @param origin     原始数据
     * @param targetType 目标数据类型
     * @param <O>        原始数据类型
     * @param <T>        目标数据类型
     * @return 目标类型数据
     */
    public static <O, T> T transform(O origin, Class<T> targetType) {
        return transform(origin, targetType, (o, t) -> {
        });
    }

    /**
     * List 数据复制
     *
     * @param originList 原始数据 List
     * @param targetType 目标数据类型
     * @param then       后操作
     * @param <O>        原始数据类型
     * @param <T>        目标数据类型
     * @return 目标类型数据 List
     */
    public static <O, T> List<T> listTransform(List<O> originList, Class<T> targetType, BiConsumer<O, T> then) {
        return originList.stream().map(o -> transform(o, targetType, then)).collect(Collectors.toList());
    }

    /**
     * List 数据复制
     *
     * @param originList 原始数据 List
     * @param targetType 目标数据类型
     * @param <O>        原始数据类型
     * @param <T>        目标数据类型
     * @return 目标类型数据 List
     */
    public static <O, T> List<T> listTransform(List<O> originList, Class<T> targetType) {
        return listTransform(originList, targetType, (o, t) -> {
        });
    }

    /**
     * List 转 Map
     *
     * @param list      原始数据 List
     * @param keyGetter Key 字段 Getter
     * @param <T>       数据类型
     * @param <K>       Key 数据类型
     * @return 以keyGetter对应field为key，值为原始数据的map
     */
    public static <T, K> Map<K, T> listToMap(List<T> list, Function<T, K> keyGetter) {
        return listToMap(list, keyGetter, Function.identity());
    }

    /**
     * List 转 Map
     *
     * @param list        原始数据 List
     * @param keyGetter   Key 字段 Getter
     * @param valueGetter Value 字段 Getter
     * @param <T>         数据类型
     * @param <K>         Key 数据类型
     * @param <U>         Value 数据类型
     * @return 以keyGetter对应field为key，valueGetter对应值为value的map
     */
    public static <T, K, U> Map<K, U> listToMap(List<T> list, Function<T, K> keyGetter, Function<T, U> valueGetter) {
        return list.stream().collect(Collectors.toMap(keyGetter, valueGetter));
    }
}