目录
1. Spring 中的对象拷贝
其实，在 Spring 中，也有类似的拷贝方法。他就是位于 org.springframework.beans.BeanUtils 工具类中的 copyProperties 方法。下面就简单演示下这个方法的使用效果。
为了方便演示，我们创建两个有部分相同属性的对象 Cat 类和 Dog 类（都有 name 和 age 字段）。
Cat 类如下：
@Data
public class Cat {
private String name;
private Integer age;
private String color;
}
Dog 类如下：
@Data
public class Dog {
private String name;
private Integer age;
private String address;
}测试代码：
import org.springframework.beans.BeanUtils;
public class Test {
public static void main(String[] args) {
// 实例化一个 Cat 对象并赋值属性
Cat cat = new Cat();
cat.setName("tom");
cat.setAge(5);
// 实例化一个 Dog 对象
Dog dog = new Dog();
// 将 cat 对象中的属性值拷贝至 dog 中
BeanUtils.copyProperties(cat, dog);
System.out.println("拷贝后：" + dog);
}
}测试效果：
可以看到，相同的 name 和 age 已经复制过去了。
2. 本工具类中的对象拷贝
上面我们演示了 Spring 下 BeanUtils 工具类中的对象属性拷贝，虽然他也可以成功拷贝对象中的属性，但对于我个人来说，还是有点不适应。
首先，Spring 去拷贝一个对象属性的时候，需要先创建好另外一个对象，然后再进行属性拷贝，这一步对象创建是明显可以放到工具方法中去的。
其次，如果只是本类复制的话，参数只需要传一个源对象的实例就应该够了，而Spring就算拷贝本类，也得传两个参数，即源实例对象和目标实例对象。
另外，Spring 的对象拷贝不支持批量拷贝，比如我们将 List<Cat> 属性拷贝后，生成一个 List<Dog> 中，只能自己循环去拷贝生成每个 Dog，然后添加到 List<Dog> 中。
于是，敝人针对个人习惯，编写了一个适合自己的编码习惯的对象拷贝工具类 BeanUtils（类名还是参照的 Spring），具体使用效果如下。
下面先做效果演示，工具类源码放在文章最后。
2.1 拷贝对象本身（单个）
比如，我们想复制一个对象本身（如 cat），那么直接使用下面这个方法就可以了。
Cat newCat = BeanUtils.copy(cat);
测试代码：
测试效果：
从测试结果我们可以看到，源对象和复制对象的每个字段值已经拷贝过去了，但两个对象的内存 hashCode 并不相同，说明并不是同一个对象，也就说我们是进行深拷贝的，两个对象是互不影响的。
另外，我们这个工具类不但支持类对象本身属性拷贝，连父类属性拷贝也是支持的。
比如，Cat类去继承下面这个 Animal 类：
@Data
public class Animal {
private Integer price;
private Date birth;
}@Data
public class Cat extends Animal {
private String name;
private Integer age;
private String color;
}
我们再试试测试一下：
测试效果：
可以看到，我们的父类属性字段值也确实复制成功了。
2.2 拷贝对象本身（批量）
工具类中不仅支对单个对象拷贝的，对多个对象的拷贝也是支持的。
List<Cat> newCatList = BeanUtils.copyList(catList);
测试代码：
测试效果：
可以看到，批量属性复制也是OK的，拷贝后的集合中每个对象新生成的深拷贝对象。
2.3 拷贝对象属性至其他类（单个）
上面，我们演示了对象本身复制的效果，下面继续演示下拷贝同名字段到其他属性的效果。
Dog dog = BeanUtils.copy(cat, Dog.class);
我们把 Cat 中的同名字段属性拷贝到 Dog 中去，我们让 Dog 也去继承下 Anima 类。
@Data
public class Dog extends Animal {
private String name;
private Integer age;
private String address;
}测试代码：
因为拷贝前后是两个完全不一样的对象了，所以这里就不再打印地址 hashCode 来进行说明是深拷贝了。
测试效果：
可以看到 cat 中的所有相同属性已经拷贝到 dog 中去了。
2.4 拷贝对象属性至其他类（批量）
同理，我们拷贝对象属性至其他类也是支持批量操作的。
List<Dog> dogs = BeanUtils.copyList(cats, Dog.calss);
测试代码：
测试效果：
可以看到，批量复制也是OK的。
至此，整个对象的拷贝的四个常用方法已经都已经支持了。
4. 工具类源码
下面就是整个工具类的源码 BeanUtils ：
package com.zyq.utils.common;
import java.lang.reflect.Field;
import java.util.*;
/**
* @author zyqok
* @since 2022/07/18
*/
@SuppressWarnings("unused")
public class BeanUtils {
/**
* 拷贝数据到新对象（单个）
*
* @param source 源实例对象
* @return 拷贝后的新实例对象
*/
public static <T> T copy(T source) {
if (Objects.isNull(source)) {
return null;
}
Class<?> c = source.getClass();
List<Field> fields = getFields(c);
return newInstance(source, c, fields);
}
/**
* 拷贝数据到新对象（批量）
*
* @param sourceList 源实例对象集合
* @return 拷贝后的新实例对象集合
*/
public static <T> List<T> copyList(List<T> sourceList) {
if (Objects.isNull(sourceList) || sourceList.isEmpty()) {
return Collections.emptyList();
}
Class<?> c = getClass(sourceList);
if (Objects.isNull(c)) {
return Collections.emptyList();
}
List<Field> fields = getFields(c);
List<T> ts = new ArrayList<>();
for (T t : sourceList) {
T s = newInstance(t, c, fields);
if (Objects.nonNull(s)) {
ts.add(s);
}
}
return ts;
}
/**
* 单个深度拷贝
*
* @param source 源实例化对象
* @param target 目标对象类（如：User.class）
* @return 目标实例化对象
*/
public static <T> T copy(Object source, Class<T> target) {
if (Objects.isNull(source) || Objects.isNull(target)) {
return null;
}
List<Field> sourceFields = getFields(source.getClass());
List<Field> targetFields = getFields(target);
T t = null;
try {
t = newInstance(source, target, sourceFields, targetFields);
} catch (Exception e) {
e.printStackTrace();
}
return t;
}
/**
* 批量深度拷贝（如果原集合中有null,则自动忽略）
*
* @param sourceList 源实例化对象集合
* @param target 目标对象类（如：User.class）
* @return 目标实例化对象集合
*/
public static <T, K> List<K> copyList(List<T> sourceList, Class<K> target) {
if (Objects.isNull(sourceList) || sourceList.isEmpty() || Objects.isNull(target)) {
return Collections.emptyList();
}
Class<?> c = getClass(sourceList);
if (Objects.isNull(c)) {
return Collections.emptyList();
}
List<Field> sourceFields = getFields(c);
List<Field> targetFields = getFields(target);
List<K> ks = new ArrayList<>();
for (T t : sourceList) {
if (Objects.nonNull(t)) {
try {
K k = newInstance(t, target, sourceFields, targetFields);
ks.add(k);
} catch (Exception e) {
e.printStackTrace();
}
}
}
return ks;
}
/**
* 获取List集合中的类名
*
* @param list 对象集合
* @return 类名
*/
private static <T> Class<?> getClass(List<T> list) {
for (T t : list) {
if (Objects.nonNull(t)) {
return t.getClass();
}
}
return null;
}
/**
* 实例化同源对象
*
* @param source 源对象
* @param c 源对象类名
* @param fields 源对象属性集合
* @return 同源新对象
*/
@SuppressWarnings("unchecked")
private static <T> T newInstance(T source, Class<?> c, List<Field> fields) {
T t = null;
try {
t = (T) c.newInstance();
for (Field field : fields) {
field.setAccessible(true);
field.set(t, field.get(source));
}
} catch (Exception e) {
e.printStackTrace();
}
return t;
}
/**
* 目标实例化对象
*
* @param source 原对实例化象
* @param target 目标对象类
* @param sourceFields 源对象字段集合
* @param targetFields 目标对象属性字段集合
* @return 目标实例化对象
*/
private static <T> T newInstance(Object source, Class<T> target, List<Field> sourceFields,
List<Field> targetFields) throws Exception {
T t = target.newInstance();
if (targetFields.isEmpty()) {
return t;
}
for (Field field : sourceFields) {
field.setAccessible(true);
Object o = field.get(source);
Field sameField = getSameField(field, targetFields);
if (Objects.nonNull(sameField)) {
sameField.setAccessible(true);
sameField.set(t, o);
}
}
return t;
}
/**
* 获取目标对象中同源对象属性相同的属性（字段名称，字段类型一致则判定为相同）
*
* @param field 源对象属性
* @param fields 目标对象属性集合
* @return 目标对象相同的属性
*/
private static Field getSameField(Field field, List<Field> fields) {
String name = field.getName();
String type = field.getType().getName();
for (Field f : fields) {
if (name.equals(f.getName()) && type.equals(f.getType().getName())) {
return f;
}
}
return null;
}
/**
* 获取一个类中的所有属性（包括父类属性）
*
* @param c 类名
* @return List<Field>
*/
private static List<Field> getFields(Class<?> c) {
List<Field> fieldList = new ArrayList<>();
Field[] fields = c.getDeclaredFields();
if (fields.length > 0) {
fieldList.addAll(Arrays.asList(fields));
}
return getSuperClassFields(c, fieldList);
}
/**
* 递归获取父类属性
*
* @param o 类名
* @param allFields 外层定义的所有属性集合
* @return 父类所有属性
*/
private static List<Field> getSuperClassFields(Class<?> o, List<Field> allFields) {
Class<?> superclass = o.getSuperclass();
if (Objects.isNull(superclass) || Object.class.getName().equals(superclass.getName())) {
return allFields;
}
Field[] fields = superclass.getDeclaredFields();
if (fields.length == 0) {
return allFields;
}
allFields.addAll(Arrays.asList(fields));
return getSuperClassFields(superclass, allFields);
}
}