属性复制工具类
有时可能需要复制一个对象的属性到另一个对象，使用 Spring 的 BeanUtils 工具类可以很容易实现，但是这样复制的属性如果是对象的话，可能会导致不安全的共享，为此，可以通过为每个属性对象实例化对应的对象来达到这一目的
具体代码如下所示：
import com.google.common.collect.Sets;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.time.chrono.ChronoLocalDate;
import java.time.chrono.ChronoLocalDateTime;
import java.util.Set;
public class PropertiesTool {
private final static Logger log = LoggerFactory.getLogger(PropertiesTool.class);
public static void copyProperties(Object src, Object target) {
copyProperties(src, target, true);
}
/**
* 将一个原对象的所有非静态属性（包括父类属性）复制到目标对象，复制属性时，通过属性的类型和名称来
* 判断是否是相同的属性<br />
* 这里的属性复制为深度拷贝，但这并不意味着一定会创建新的实例属性。因为对于不可变的对象，在多个对象
* 之间进行共享是安全的，并且这些不可变对象一般都不会提供直接的实例化构造函数，因此对于不可变类的属性
* 将会直接复制对象引用而不是重新实例化新的实例
*
* @param src 具备相关属性值的实例对象
* @param target 将要填充属性值的实例对象
* @param copyNull 控制开关，是否需要将 null 值拷贝到目标对象
* @apiNote 复制的属性将会覆盖所有的非静态字段，即使这些字段属性被 final 修饰
*/
public static void copyProperties(Object src, Object target, boolean copyNull) {
copyProperties(src, src.getClass(), target, target.getClass(), copyNull);
}
private static void copyProperties(
Object src, Class<?> srcClass,
Object target, Class<?> tarClass,
boolean copyNull
) {
if (src == null || target == null) return;
if (srcClass == null || tarClass == null) return;
Field[] sfs = srcClass.getDeclaredFields();
Set<Field> fieldSet = Sets.newHashSet(tarClass.getDeclaredFields());
for (Field tf : sfs) {
// 目标对象不包含的属性字段需要跳过
if (!fieldSet.contains(tf)) continue;
int modifiers = tf.getModifiers();
// 过滤静态字段
if ((modifiers & Modifier.STATIC) != 0) continue;
try {
tf.setAccessible(true);
Object val = tf.get(src);
// 是否将空值复制到目标对象的对象的处理
if (copyNull && val == null) continue;
Class<?> fc = tf.getType();
if (!isConstType(fc)) {
if (fc.isArray()) {
tf.set(target, cloneArray(val));
continue;
}
// 对于对象类型的深度属性复制，需要相关的对象具有对应的无参构造函数
Object obj = fc.getDeclaredConstructor().newInstance();
copyProperties(val, obj);
tf.set(target, obj);
continue;
}
tf.set(target, val); // 基本类型的特殊处理
} catch (Exception e) {
throw new RuntimeException(e);
}
}
copyProperties(src, srcClass.getSuperclass(), target, tarClass.getSuperclass(), copyNull);
}
private static boolean isConstType(Class<?> clazz) {
if (clazz.isPrimitive()) return true;
// LocalDate 系列不可变对象的处理
if (ChronoLocalDateTime.class.isAssignableFrom(clazz)) return true;
if (ChronoLocalDate.class.isAssignableFrom(clazz)) return true;
// 数值型的类型是不可变的，可以在多个对象之间安全地进行共享
if (Number.class.isAssignableFrom(clazz)) return true;
// String 在这里被视为基本数据类型，因为它是不可变的，可以安全地在多个对象之间共享
return clazz == String.class;
}
private enum Clazz {
BYTE(byte.class),
BOOLEAN(boolean.class),
SHORT(short.class),
CHAR(char.class),
FLOAT(float.class),
INT(int.class),
LONG(long.class),
DOUBLE(double.class);
public final Class<?> clazz;
Clazz(Class<?> clazz) {
this.clazz = clazz;
}
}
/**
* 实现数组对象的深度拷贝，数组中元素类型，应当至少存在一个无参构造函数，
* 即使这个构造函数是私有的同样可以满足要求
*
* @param obj 待拷贝的数组对象
* @return 拷贝之后的数组对象
*/
private static Object cloneArray(Object obj) {
if (!obj.getClass().isArray()) {
throw new IllegalArgumentException("不能将非数组类型的对象转换为对应的 List");
}
Class<?> compClazz = obj.getClass().getComponentType();
if (compClazz.isPrimitive()) {
Clazz type = Clazz.valueOf(Clazz.class, compClazz.getSimpleName().toUpperCase());
Object res = null;
switch (type) {
case BYTE:
res = ((byte[]) obj).clone();
break;
case BOOLEAN:
res = ((boolean[]) obj).clone();
break;
case SHORT:
res = ((short[]) obj).clone();
break;
case CHAR:
res = ((char[]) obj).clone();
break;
case FLOAT:
res = ((float[]) obj).clone();
break;
case INT:
res = ((int[]) obj).clone();
break;
case LONG:
res = ((long[]) obj).clone();
break;
case DOUBLE:
res = ((double[]) obj).clone();
break;
}
return res;
}
int len = Array.getLength(obj);
if (len <= 0) return null;
Class<?> clazz = Array.get(obj, 0).getClass();
Object ans = Array.newInstance(clazz, len);
for (int i = 0; i < len; i++) {
Object val = Array.get(obj, i); // 当前属性中，数组中指定位置的对象
// 基本类型直接复制即可
if (isConstType(clazz)) {
Array.set(ans, i, val);
continue;
}
// 多维数组的处理
if (clazz.isArray()) {
Array.set(ans, i, cloneArray(val));
continue;
}
try {
/*
* 针对数组中元素类型为一般对象，那么首先通过反射的方式实例化该位置的数组元素，
* 然后将该位置的原对象属性复制到这个对象中，从而实现数组对象的深度拷贝
*/
Object o = clazz.getDeclaredConstructor().newInstance();
copyProperties(val, o);
Array.set(ans, i, o);
} catch (Throwable t) {
log.info("类型 {} 不存在相关的无参构造函数，无法完成数组对象的深度拷贝", clazz);
t.printStackTrace();
}
}
return ans;
}
}
