美文网首页diboot
利用反射和注解,拷贝类型相同,属性名不同的对象

利用反射和注解,拷贝类型相同,属性名不同的对象

作者: 一个鸡蛋壳儿 | 来源:发表于2019-06-14 13:49 被阅读0次

    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);
        }
    }
    

    运行结果:

    image.png

    5、总结

    • BeanUtils.copyBean()方法支持拷贝超类的属性,属性需要有getter和setter方法,否则抛异常(只影响无get/set方法的属性)
    • PropertyDescriptor属性描述器,可以很方便的获取读取和写入方法,减少getMethod通过字符串拼接获取方法的成本
    • class.getFields()只能获取公开的属性,getDeclaredFields可以获取任意,但只包含本类中,父类需要使用class.getSuperclass()递归向上寻找

    Diboot - 简单高效的轻代码开发框架

    相关文章

      网友评论

        本文标题:利用反射和注解,拷贝类型相同,属性名不同的对象

        本文链接:https://www.haomeiwen.com/subject/ldasfctx.html