基于注解-实现不同对象间，不同属性名之间的属性值复制

最新推荐文章于 2023-09-14 22:19:36 发布
最新推荐文章于 2023-09-14 22:19:36 发布
阅读量1.2k 收藏 4
点赞数 1
分类专栏： Java 文章标签： java 反射 注解 注释 @Retention
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42028069/article/details/107291600
版权

不同对象间，不同属性名之间的属性值复制

场景:
注意: 不涉及任何业务逻辑
在系统间接口调用，存在各种对象的转换, 这里指的是将 A 类中的 a 的值，赋值给 B 类中的 b . 然后自己系统的数据库存的是 B。
最恐怖的是, 如果进行数据下载的时候, 我们还要把 B 原封不动转换成 A .供其他系统调用.
如下图:
一个完整的 Student 类 ，由3个不同的类的字段值拼凑得到。
然后进行数据下载的时候, 还是把 Student中某些指定的属性，转换成映射的对象.
在这里插入图片描述

字段少的话可能是这样

这里只是模拟一下


        SubjectInfo subjectInfo = new SubjectInfo("语文","80.36");
        UserInfo userInfo = new UserInfo("英旭","30","2020-07-08 12:25:12",subjectInfo);
        EmailInfo email =new EmailInfo("inxu","@163.com",20);

        Student student = new Student();
        student.setName(userInfo.getUname());
        student.setSubName(userInfo.getSubjectInfo().getName());
        student.setEmail(email.getAddr());

问题: 如果字段多了呢？？

眼要写瞎了. 我太难了 o(╥﹏╥)o

基于注解实现

自定义注解

/**
 * @program: springBootStudy
 * @Date: 2020/7/10 20:54
 * @Author: Inxu
 * @Description:
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface AimField {
    /*目标对象的属性名*/
    String value();
    /*目标对象的属性类型 基本类型 */
    Class type();

} 
/**
 * @program: springBootStudy
 * @Date: 2020/7/10 20:49
 * @Author: Inxu
 * @Description:
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.FIELD})
public @interface AimObject {
    Class value() ;
}

/**
 * @program: springBootStudy
 * @Date: 2020/7/11 13:36
 * @Author: Inxu
 * @Description:
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface AimOther {
    /*目标对象的属性名*/
    String value();
    /*目标对象的属性类型 基本类型 */
    Class type();
    /*映射的指定类*/
    Class clazz();
}
通过反射 获取注解信息 ，然后给映射的对象赋值

完整代码如下:

/**
 * @program: springBootStudy
 * @Date: 2020/7/10 20:59
 * @Author: Inxu
 * @Description: 对象属性复制类
 */
public class BeanCopyUtil {
    private static final SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    private static final String DATE="Date";
    private static final String LOCAL_DATE_TIME="LocalDateTime";

    /**
     * 对象属性赋值方法
     * 将 S 中的属性值，按照属性名的对应关系, 复制到 T 中
     * @param s  源对象数据
     * @param t  目标对象 类的实例
     * @param <S> 泛型
     * @param <T> 泛型
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws ParseException
     * @throws NoSuchObjectException
     */
    public static <S,T> T copy(S s,T t) throws IllegalAccessException,
            InstantiationException, ParseException,
            NoSuchObjectException, NoSuchMethodException,
            NoSuchFieldException, InvocationTargetException {

        Class<?> clazz = s.getClass();
        AimObject type_AimObject = clazz.getAnnotation(AimObject.class);
        Class type_Class = type_AimObject.value();
        if( !type_Class.isAssignableFrom(t.getClass())){
            throw  new NoSuchObjectException("注解的映射类与目标类不匹配.");
        }
        // 获取要映射的类的实例
        Object newInstance =null;
        if(null ==t){
            newInstance = type_Class.newInstance();
        }else {
            newInstance=t;
        }
        // 1 : 反射得到 源对象的属性列表
        Field[] s_Fields = clazz.getDeclaredFields();
        for (Field sField : s_Fields) {
            sField.setAccessible(true);
            // 2: 获取源对象中， 属性上需要映射的类
            AimObject field_AimObject = sField.getAnnotation(AimObject.class);
            if(null != field_AimObject){
                // 如果源对象中的 对象属性 的映射类 和源对象映射的类一致, 继续延用当前的 对象(newInstance)
                if(field_AimObject.value().isAssignableFrom(type_Class)){
                    copy(sField.get(s),newInstance);
                }else {
                    continue;
                }
               field_AimObject=null;
            }
            // 3: 获取源对象中属性的映射
            AimField aimField = sField.getAnnotation(AimField.class);
            if(null == aimField && null == field_AimObject){
                continue;
            }
            // Class field_orm_other_obj = aimField.clazz();
            // 获取目标类的属性名
            String target_Field = aimField.value();
            // 获取目标类的 属性类型
            Class target_Field_Type = aimField.type();
            // 获取源对象 的 属性值 , 最终把它赋值给目标类的属性 target_Field
            Object o = sField.get(s);
            if(null == o) {
                continue;
            }
            /*获取源对象属性的类型*/
            Class<?> s_field_Type = sField.getType();
            // 赋值
            setTargetFieldValueByNameAndValue(newInstance,target_Field,target_Field_Type,o,s_field_Type);
        }
        return t;
    }

    /**
     *  对象属性赋值方法
     *  将 S 属性中的 @AimOther注解 ,根据属性名和指定的类， 复制到 T
     * @param s  源对象
     * @param t  目标对象
     * @param <S> 泛型
     * @param <T> 泛型
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws NoSuchObjectException
     * @throws NoSuchMethodException
     * @throws NoSuchFieldException
     * @throws ParseException
     * @throws InvocationTargetException
     */
    public static <S,T> T copyPartByAimOther(S s ,T t) throws IllegalAccessException,
            InstantiationException, NoSuchObjectException,
            NoSuchMethodException, NoSuchFieldException, ParseException,
            InvocationTargetException {
        if(null == s || null == t){
            throw  new NullPointerException("源对象 或者 目标对象 不能为空.");
        }
        Field[] fields = s.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            AimOther type_Aim_other = field.getAnnotation(AimOther.class);
            if(null == type_Aim_other){
                continue;
            }
            Class type_Class = type_Aim_other.clazz();
            if(!type_Class.isAssignableFrom(t.getClass())){
                continue;
            }
            String target_Field = type_Aim_other.value();
            Class target_Field_Type = type_Aim_other.type();
            Class<?> s_field_Type = field.getType();
            Object o = field.get(s);
            if(null == o) {
                continue;
            }
            setTargetFieldValueByNameAndValue(t,target_Field,target_Field_Type,o,s_field_Type);
        }
        return  t;
    }

    /**
     *
     * @param s
     * @param t
     * @param <S>
     * @param <T>
     * @return
     * @throws IllegalAccessException
     * @throws NoSuchMethodException
     * @throws InvocationTargetException
     * @throws ParseException
     * @throws InstantiationException
     * @throws NoSuchObjectException
     * @throws NoSuchFieldException
     */
    public  static <S,T> T copyPartByAimObjectOnField(S s ,T t) throws IllegalAccessException, NoSuchMethodException, InvocationTargetException, ParseException, InstantiationException, NoSuchObjectException, NoSuchFieldException {
        if(null == s || null == t){
            throw  new NullPointerException("源对象 或者 目标对象 不能为空.");
        }
        Field[] fields = s.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            // 获取源对象中， 属性上需要映射的类
            AimObject field_AimObject = field.getAnnotation(AimObject.class);
            if(null == field_AimObject){
                continue;
            }
            t=copy(field.get(s),t);
        }

        return t;
    }

    /**
     *  为目标类的属性 通过属性名赋值
     * @param t  目标类
     * @param fieldName  目标类的变量名
     * @param target_Field_Type   变量类型
     * @param value    源数据
     * @param s_field_Type  源数据 类型
     * @param <T>  泛型
     * @return
     * @throws NoSuchMethodException
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     * @throws NoSuchFieldException
     */
    public  static <T> void setTargetFieldValueByNameAndValue(T t ,
                                                              String fieldName,
                                                              Class target_Field_Type,
                                                              Object value,
                                                              Class<?> s_field_Type) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, NoSuchFieldException, ParseException {

        Field field = t.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        // 如果与映射属性的类型不一致， 转换成目标属性的类型
        if(!target_Field_Type.isAssignableFrom(s_field_Type)  ){
                // 时间转 String
                if((DATE).equals (s_field_Type.getSimpleName())|| s_field_Type.getSimpleName().equals(LOCAL_DATE_TIME)){
                    value=covertDate2String(s_field_Type.getSimpleName(),value);
                }else {
                    value= convertValueByType(target_Field_Type,value.toString());
                }
            }
        field.set(t,value);
}

    /**
     * 将 值 进行类型转换
     * @param target_Field_Type  目标类变量的类型
     * @param val  值
     * @return
     * @throws ParseException
     */
    public static  Object convertValueByType(Class target_Field_Type ,String val) throws ParseException {
        String typeName = target_Field_Type.getSimpleName();
        Object o =null;
        switch (typeName){
            case "Integer":
                o=Integer.parseInt(val);break;
            case "Long":
                o=Long.parseLong(val);break;
            case "Double":
                o=Double.parseDouble(val);break;
            case "Short":
                o= Short.parseShort(val); break;
            case "Byte":
                o= Byte.parseByte(val);break;
            case "Date":
                o=SIMPLE_DATE_FORMAT.parse(val);
            case "LocalDateTime":
               o= LocalDateTime.parse(val,DATE_TIME_FORMATTER);break;
            default:
                o=val;break;
        }

        return  o;
    }

    public static  Object covertDate2String(String typeName,Object value){
        Object o =null;
        switch (typeName){
            case "Date":
                Date date =(Date)value;
                o=SIMPLE_DATE_FORMAT.format(date);
                break;
            case "LocalDateTime":
                LocalDateTime parse=(LocalDateTime)value;
                o= parse.format(DATE_TIME_FORMATTER);
                break;
            default:
                o=value;break;
        }

        return  o;
    }
}

测试

UserInfo 类
/**
 * @program: springBootStudy
 * @Date: 2020/7/10 21:30
 * @Author: Inxu
 * @Description:
 */
@NoArgsConstructor
@AllArgsConstructor
@Setter
@Getter
@ToString
@AimObject(Student.class)
public class UserInfo {
    @AimField(value = "name",type = String.class)
    private String uname;

    @AimField(value = "age",type = Integer.class)
    private String uage;

    @AimField(value = "dateTime",type = LocalDateTime.class)
    private String udate;

    @AimObject(Student.class)
    private SubjectInfo subjectInfo;
}
SubjectInfo 类

/**
 * @program: springBootStudy
 * @Date: 2020/7/10 23:46
 * @Author: Inxu
 * @Description:
 */
@NoArgsConstructor
@AllArgsConstructor
@Setter
@Getter
@ToString
@AimObject(Student.class)
public class SubjectInfo {
    @AimField(value = "subName",type = String.class)
    private String name;
    @AimField(value = "score",type = Double.class)
    private String score;
}
EmailInfo 类

/**
 * @program: springBootStudy
 * @Date: 2020/7/11 13:17
 * @Author: Inxu
 * @Description:
 */
@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
@ToString
@AimObject(Student.class)
public class EmailInfo {
    @AimField(value = "email",type = String.class)
    private String addr;
    @AimField(value = "emailIP",type = String.class)
    private String ip;
    private Integer times;
}
Student 类

/**
 * @program: springBootStudy
 * @Date: 2020/7/10 21:28
 * @Author: Inxu
 * @Description:
 */
@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
@ToString
@AimObject(UserInfo.class)
public class Student {
    @AimField(value = "uname",type = String.class)
    private String name;
    @AimField(value = "uage",type = String.class)
    private Integer age;
    @AimField(value = "udate",type = String.class)
    private LocalDateTime dateTime;

    @AimOther(value = "name",type = String.class,clazz = SubjectInfo.class)
    private String subName;
    @AimOther(value = "score",type = String.class,clazz = SubjectInfo.class)
    private Double score;

    @AimOther(value = "addr",type = String.class,clazz = EmailInfo.class)
    private String email;
    @AimOther(value = "ip",type = String.class,clazz = EmailInfo.class)
    private String emailIP;

}

效果如下: 基本实现，把终端提交的原数据转换成自身数据库需要的数据格式，然后如果需要的话,在转换成终端需要的数据格式。
在这里插入图片描述

待完善

不支持 集合 ,仅支持对象间基本类型的转换。
可能有BUG。还请谅解, 修改后，望告知 inxu0317@163.com. 谢谢！！！

Inxu
关注
专栏目录
两个对象属性值的拷贝和文件的拷贝
07-28
实现了两个对象之间属性值的拷贝，只要具有相同的属性名就可以拷贝，还有两个file对象的拷贝，实现文件的复制功能
复制两个对象字段类型一样,属性(字段名)不一样
单人影的博客
07-25 4294
两个字段不一样的对象复制 思路:自定义注解获取目标实体类和源实体类的对应关系.通过反射获取值和赋值. 自定义注解 /** * 对象拷贝注解(自定义注解) */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) public @interface CopyField { /** * ...
java 注解 对象_基于注解进行对象拷贝（一）
weixin_32158567的博客
02-21 549
背景作为一名CRUD boy，非常厌烦了Ctrl+C & Ctrl+V的方式进行开发。尤其是在Web类项目开发中，我们经常会遇到PO(Persistent Object, 持久化对象)，DTO(Data Transfer Object, 数据传输对象)，VO(View Object, 视图对象)对象之间的转换，毕竟后端总不能把数据库原始数据直接丢给前端进行处理(估计会被????)，返回一个合适的...
如何实现两个对象之间的属性拷贝
IT小辉同学
07-22 647
如果要放弃，请先想好如何开始！
实现不同属性名称的对象拷贝
Ludy
08-16 905
实现不同属性名称的属性拷贝 import com.ebtrust.constant.FinanceDictConsts; import org.springframework.beans.BeanUtils; import org.springframework.beans.BeanWrapper; import org.springframework.beans.BeansException; import org.springframework.beans.FatalBeanException; imp
java不同对象及集合的多次复制
04-24
- 在某些场景下，我们可能需要将源对象的属性值复制到具有不同类型的对象中，这时可以使用ModelMapper的`configure()`方法设置映射规则。 总的来说，Java中的对象复制可以通过多种方式实现，包括基本的复制方法和...
swift-ObjectBoxSwift-超快速和简单持久化你的Swift对象
08-15
通过设置`@ToOne`或`@ToMany`属性，可以轻松管理对象之间的关联。 ### 2. **安装与集成** 要将ObjectBox添加到Swift项目中，可以使用CocoaPods或Swift Package Manager。在Podfile或Package.swift中添加相应依赖，...
spring-mvc.docx
06-16
面向对象编程（OOP）是一种编程范式，基于对象的概念。每个对象都是数据和可以作用于这些数据的方法的封装。 1. **封装**：将数据和操作这些数据的方法组合在一起。 2. **继承**：允许创建现有类的新版本，继承已有...
mapstruct.zip
06-03
MapStruct基于注解驱动的代码生成机制，它通过读取源对象和目标对象上的注解，自动生成映射器接口的实现类。这种自动化的映射方式避免了手动编写繁琐的映射代码，同时也减少了出错的可能性。MapStruct默认提供了基本...
.NET 高性能对象映射器
最新发布
11-19
- 对象映射器的主要任务是将一个对象的属性值复制到另一个对象的相应属性上，通常跨越不同的对象模型。 - 这种映射过程可以减少代码重复，使得数据转换更简洁，尤其在处理复杂数据结构时。 2. **Dozer的功能特性*...
比较同对象属性不一样的字段数据（可过滤） 复制粘贴可用
weixin_43636160的博客
04-19 145
System.out.println(“两个对象不同，不同字段如下：”);System.out.println(“两个对象相同”);// 【年龄】由 『18』 变为 『20』
将对象的属性值复制到另一个对象中
qq_41853447的博客
12-19 4071
将对象的属性值复制到另一个对象中 /*** * 将第一个对象的属性值复制到第二个对象中 * @param <T> 第一个对象 * @param <R> 第二个对象 */ class HandleObject<T,R>{ //保存指定不同的字段名称和数据类型 private List<Attribute> attributes...
C# 快速高效率复制对象另一种方式 表达式树
weixin_34261739的博客
04-06 375
1、需求 在代码中经常会遇到需要把对象复制一遍，或者把属性名相同的值复制一遍。 比如： public class Student { public int Id { get; set; } public string Name { get; set; } public int Age { get; set; } } ...
使用自定义注解：实现两个对象间，不同属性名之间的属性值复制
Gongyl的博客
11-04 1738
直接上代码：自定义注解、对象准备（源对象、目标对象） 自定义注解 import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; im...
已解决：java两个不同对象不同属性之间的赋值复制（fastjson处理）
zhanghengchao123的博客
12-24 5224
项目开发中 有时会有需要两个不同对象赋值，两个对象的属性名称也不一样，传统的 BeanUtils.copyProperties();这个方法已经不满足需求了， 目前用fastjson处理。
注解实现两个类不同字段名称值复制
u011579004的专栏
01-21 1662
List&lt;Emp&gt; empLists=list;//数据集合 ConvertEntity&lt;Emp, Employee&gt; entity=new ConvertEntity&lt;Emp, Employee&gt;(Emp.class, empLists, null, new Emp(), Employee.class, new Employee()); List&lt;...
复制两个不同类的对象的属性
getCool
01-22 289
Apache的开源包BeanUtils用来复制两个对象的属性，要使用这个Apache的开源包，要先去官网下载commons-beanutils-1.X.jar包，http://www.apache.org/ 然后点击Apache Projects下面的链接Commons，可以找到链接BeanUtils，点击进入后就可以看到下载了。 ——BeanUtils.copyProperties()与Prop...
Bean拷贝组件（注解驱动）方案设计与落地
m0_59588838的博客
09-14 344
数据流转在各层之间的过程，应当是改头换面的，字段属性数量，属性名称（一般不变，但也有重构时出现变化的情况），类型名称（普遍变化例如BO、VO、DTO）。对于转换的业务对象，原始的做法时直接实例采用Getter与Setter方法进行逐一填充。这太低效了，那我们就先了解最简单的拷贝工具。
Spring系列：对象属性拷贝方式总结
风尘博客
04-23 8656
当`get/set`太繁琐时；当`BeanUtils`无法拷贝集合时；当。。。可能，你需要好好看看这篇文章，文末附完整示例代码。
mybatisplus将对象转换为其他对象复制属性
06-28
如果属性名不同，则需要使用@Mapping注解指定源对象属性名和目标对象属性名之间的映射关系。 除了使用BeanUtils.copyProperties()方法之外，MybatisPlus还提供了一个ObjectUtils.copyProperties()方法，该方法会把...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值