1、前言
最近开发遇到一个问题，两个对象进行属性值拷贝。理论上来说可以直接借助 org.springframework.beans.BeanUtils.copyProperties(Object source, Object target) 来进行拷贝，奈何两个对象属性名不同，懵逼脸。
2、问题引入
待拷贝类
/**
* @author : weenie
* @version v1.0
* @Description: 源 User
*/
public class OriginUser {
/**id*/
private Long originId;
/** 名称 */
private String originName;
/** 密码 */
private String password;
/** 出生日期 */
private Date originBirthDay;
/** 是否健康 */
private Boolean originHealth;
/**getter/setter 省略 */
}
目标类
/**
* @author : weenie
* @version v1.0
* @Description: 目标 User
*/
public class TargetUser {
/**id*/
private Long targetId;
/** 名称 */
private String targetName;
/** 密码 */
private String password;
/** 出生日期 */
private Date targetBirthDay;
/** 是否健康 */
private Boolean targetHealth;
/**getter/setter 省略 */
}
拷贝上述两个类产生的对象，spring 为我们提供的工具类就直接歇菜了。最初想到的方案便是 targetUser.setXxx(originUser.getXxx())，这种方式简单粗暴，易写，不易扩展。如果属性过多的时候，写到吐血。
3、问题思考
对象的拷贝，我们可以使用反射进行处理，但是两个不同属性的对象进行拷贝的问题在于，我们如何让两个不同的属性名进行关联。顺着这个思路，我开始考虑设置一个工具类专门存放两个对象的属性对应关系。这个时候问题又出现了，如果有成千上万的对象，建立关系映射又是浩大的工程。
偶然间想到 fastJson 中利用 @JSONField(name=”xxx”) 注解可以给属性设置别名，那么在拷贝不同属性对象时，我们也可以使用这种方案。
4、代码开发
4.1 CopyField 注解
/**
* 该注解应用于类属性上，主要为了设置属性别名，适用于不同属性拷贝
* @author : weenie
* @version v1.0
* @Description: 常用 bean 相关方法
*/
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface CopyField {
/**
* 在即将被拷贝的属性上面，设置目标属性名
* @return
*/
String targetName() default “”;
/**
* 在即将拷贝至改属性上面，设置源属性名
* @return
*/
String originName() default “”;
}
4.2 bean 改造
注解中设置了两个方法，为了缩小篇幅，我会同时使用
待拷贝 bean
public class OriginUser {
/**id*/
@CopyField(targetName = “targetId”)
private Long originId;
/** 名称 */
@CopyField(targetName = “targetName”)
private String originName;
/** 密码 */
private String password;
/** 出生日期 */
private Date originBirthDay;
/** 是否健康 */
private Boolean originHealth;
}
目标 bean
public class TargetUser {
/**id*/
private Long targetId;
/** 名称 */
private String targetName;
/** 密码 */
private String password;
/** 出生日期 */
@CopyField(originName = “originBirthDay”)
private Date targetBirthDay;
/** 是否健康 */
@CopyField(originName = “originHealth”)
private Boolean targetHealth;
}
4.3 BeanUtil 工具类
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
/**
* @author : weenie
* @version v1.0
* @Description: 常用 bean 相关方法
*/
public class BeanUtils {
private static Logger logger = LoggerFactory.getLogger(BeanUtils.class);
/**
* <h3> 拷贝一个对象的属性至另一个对象 </h3>
* <p>
* 支持两个对象之间不同属性名称进行拷贝，使用注解 {@link CopyField}
* </p>
* @param originBean 源对象 使用注解 {@link CopyField#targetName()}
* @param targetBean 目标对象 使用注解 {@link CopyField#originName()}
*/
public static void copyBean(Object originBean, Object targetBean) {
Map<String, Object> originFieldKeyWithValueMap = new HashMap<>(16);
PropertyDescriptor propertyDescriptor = null;
// 生成源 bean 的属性及其值的字典
generateOriginFieldWithValue(propertyDescriptor, originBean, originFieldKeyWithValueMap, originBean.getClass());
// 设置目标 bean 的属性值
settingTargetFieldWithValue(propertyDescriptor, targetBean, originFieldKeyWithValueMap, targetBean.getClass());
}
/**
* 生成需要被拷贝的属性字典 属性 - 属性值 <br/>
* 递归取父类属性值
* @param propertyDescriptor 属性描述器，可以获取 bean 中的属性及方法
* @param originBean 待拷贝的 bean
* @param originFieldKeyWithValueMap 存放待拷贝的属性和属性值
* @param beanClass 待拷贝的 class[可能是超类的 class]
*/
private static void generateOriginFieldWithValue(PropertyDescriptor propertyDescriptor, Object originBean, Map<String, Object> originFieldKeyWithValueMap, Class<?> beanClass) {
/** 如果不存在超类，那么跳出循环 */
if (beanClass.getSuperclass() == null) {
return;
}
Field[] originFieldList = beanClass.getDeclaredFields();
for (Field field : originFieldList) {
try {
/* 获取属性上的注解。如果不存在，使用属性名，如果存在使用注解名 */
CopyField annotation = field.getAnnotation(CopyField.class);
String targetName = “”;
if (annotation != null) {
targetName = annotation.targetName();
} else {
targetName = field.getName();
}
// 初始化
propertyDescriptor = new PropertyDescriptor(field.getName(), beanClass);
// 获取当前属性的 get 方法
Method method = propertyDescriptor.getReadMethod();
// 设置值
Object value = method.invoke(originBean);
// 设置值
originFieldKeyWithValueMap.put(targetName, value);
} catch (IntrospectionException e) {
logger.warn(“【源对象】异常:” + field.getName() + “ 不存在对应的 get 方法，无法参与拷贝！”);
} catch (IllegalAccessException e) {
logger.warn(“【源对象】异常:” + field.getName() + “ 的 get 方法执行失败！”);
} catch (InvocationTargetException e) {
logger.warn(“【源对象】异常:” + field.getName() + “ 的 get 方法执行失败！”);
}
}
// 生成超类 属性 -value
generateOriginFieldWithValue(propertyDescriptor, originBean, originFieldKeyWithValueMap, beanClass.getSuperclass());
}
/**
*
* @param propertyDescriptor 属性描述器，获取当前传入属性的（getter/setter）方法
* @param targetBean 目标容器 bean
* @param originFieldKeyWithValueMap 待拷贝的属性和属性值
* @param beanClass 待设置的 class[可能是超类的 class]
*/
private static void settingTargetFieldWithValue(PropertyDescriptor propertyDescriptor, Object targetBean, Map<String, Object> originFieldKeyWithValueMap, Class<?> beanClass) {
/** 如果不存在超类，那么跳出循环 */
if (beanClass.getSuperclass() == null) {
return;
}
Field[] targetFieldList = beanClass.getDeclaredFields();
for (Field field : targetFieldList) {
try {
/* 获取属性上的注解。如果不存在，使用属性名，如果存在使用注解名 */
CopyField annotation = field.getAnnotation(CopyField.class);
String originName = “”;
if (annotation != null) {
originName = annotation.originName();
} else {
originName = field.getName();
}
// 初始化当前属性的描述器
propertyDescriptor = new PropertyDescriptor(field.getName(), beanClass);
// 获取当前属性的 set 方法
Method method = propertyDescriptor.getWriteMethod();
method.invoke(targetBean, originFieldKeyWithValueMap.get(originName));
} catch (IntrospectionException e) {
logger.warn(“【目标对象】异常:” + field.getName() + “ 不存在对应的 set 方法，无法参与拷贝！”);
} catch (IllegalAccessException e) {
logger.warn(“【目标对象】异常:” + field.getName() + “ 的 set 方法执行失败！”);
} catch (InvocationTargetException e) {
logger.warn(“【目标对象】异常:” + field.getName() + “ 的 set 方法执行失败！”);
}
}
// 设置超类属性
settingTargetFieldWithValue(propertyDescriptor, targetBean, originFieldKeyWithValueMap, beanClass.getSuperclass());
}
}
4.4 测试
/**
* @author : weenie
* @version v1.0
* @Description:
* @Date 2019-03-23 09:48
*/
public class MainTest {
public static void main(String[] args) {
OriginUser originUser = new OriginUser();
originUser.setOriginId(1000L);
originUser.setOriginName(“ 张四 ”);
originUser.setPassword(“123456”);
originUser.setOriginBirthDay(new Date());
originUser.setOriginHealth(true);
TargetUser targetUser = new TargetUser();
// 拷贝
BeanUtils.copyBean(originUser, targetUser);
System.out.println(targetUser);
}
}
运行结果：
5、总结
BeanUtils.copyBean() 方法支持拷贝超类的属性，属性需要有 getter 和 setter 方法，否则抛异常（只影响无 get/set 方法的属性）
PropertyDescriptor 属性描述器，可以很方便的获取读取和写入方法，减少 getMethod 通过字符串拼接获取方法的成本
class.getFields() 只能获取公开的属性，getDeclaredFields 可以获取任意，但只包含本类中，父类需要使用 class.getSuperclass() 递归向上寻找