@@ -24,31 +24,46 @@ public static <T> T deepCopy(T sourceObj) {
24
24
/**
25
25
* 深度拷贝单个对象
26
26
*
27
+ * 如果被拷贝对象里含有多引用情况,拷贝出来的对象会丢失这种关联
28
+ * 比方说sourceObj对象里面有集合listA和listB, 有一对象a同时存在于listA、listB, 众所周知对listA里的a进行修改,B里面的a也会被变化
29
+ * 被此方法深度拷贝出来的listA和listB里的"a"将会是分别独立存在的,对listA的"a"进行修改,B里面的"a"不会被变化
30
+ *
27
31
* @param sourceObj 被拷贝对象
28
- * @param targetObj 拷贝到目标类类型
32
+ * @param targetObjClz 拷贝到目标类类型
29
33
*/
30
- public static <T > T deepCopy (Object sourceObj , Class <T > targetObj ) {
31
- T t ;
34
+ public static <T > T deepCopy (Object sourceObj , Class <T > targetObjClz ) {
35
+
36
+ if (sourceObj instanceof Collection ) {
37
+ return (T ) ListUtils .deepClone ((Collection ) sourceObj );
38
+ } else if (sourceObj instanceof Map ) {
39
+ return (T ) MapUtils .deepClone ((Map ) sourceObj );
40
+ }
41
+
42
+ T target ;
32
43
try {
33
- t = targetObj .newInstance ();
44
+ target = targetObjClz .newInstance ();
34
45
} catch (InstantiationException |IllegalAccessException e ) {
35
46
e .printStackTrace ();
36
47
return null ;
37
48
}
38
- Map <String , Field > sourceObjFieldMapping = getFieldMapping (sourceObj .getClass ());
39
- Map <String , Field > targetObjFieldMapping = getFieldMapping (targetObj );
40
- for (Field targetField : targetObjFieldMapping .values ()) {
41
- Field sourceField = sourceObjFieldMapping .get (targetField .getName ());
49
+
50
+ Map <String , Field > s = getFieldMapping (sourceObj .getClass ());
51
+ Map <String , Field > t = getFieldMapping (targetObjClz );
52
+ for (Field targetField : t .values ()) {
53
+
54
+ // 源对象存在跟目标对象同样名称的字段
55
+ Field sourceField = s .get (targetField .getName ());
56
+
42
57
if (sourceField != null ) {
43
58
try {
44
59
Object value = sourceField .get (sourceObj );
45
- targetField .set (t , getValueByValue (value ));
60
+ targetField .set (target , getValueByValue (value ));
46
61
} catch (IllegalAccessException e ) {
47
62
//
48
63
}
49
64
}
50
65
}
51
- return t ;
66
+ return target ;
52
67
}
53
68
54
69
/**
@@ -60,16 +75,12 @@ private static Object getValueByValue(Object value){
60
75
|| value instanceof Integer
61
76
|| value instanceof Boolean
62
77
|| value instanceof Long
63
- || value instanceof Byte
64
- || value instanceof Character
65
78
|| value instanceof Short
79
+ || value instanceof Double
66
80
|| value instanceof Float
67
- || value instanceof Double ) {
81
+ || value instanceof Character
82
+ || value instanceof Byte ) {
68
83
return value ;
69
- } else if (value instanceof Collection ) {
70
- return ListUtils .deepClone ((Collection ) value );
71
- } else if (value instanceof Map ) {
72
- return MapUtils .deepClone ((Map ) value );
73
84
}
74
85
return deepCopy (value , value .getClass ());
75
86
}
@@ -91,9 +102,11 @@ public static Map<String, Field> getFieldMapping(Class clz) {
91
102
* 递归搜集对象的所有字段
92
103
*/
93
104
public static void collectField (Class clz , List <Field > result ) {
94
- if (!(clz instanceof Object )) {
105
+ // 向上追溯父对象
106
+ if (!(clz .getSuperclass () == Object .class )) {
95
107
collectField (clz .getSuperclass (), result );
96
108
}
109
+ // 到达除Object外的最上层父对象时结束递归,开始收集字段
97
110
for (Field field : clz .getDeclaredFields ()) {
98
111
field .setAccessible (true );
99
112
result .add (field );
0 commit comments