java一个对象赋值给另一个对象，支持平铺类和层级类间的互转

场景：将一个层级类对象(领域驱动model对象)转换为平铺类对象(view)

src对象，（红框为子对象）

target对象（平铺对象）

代码思路，先递归反射遍历出所有字段，存到一个map里，再递归赋值给target对象

缺陷：不同子对象间的同名字段会被覆盖成一个值

代码

private static void getSrcALLFieldMap(Object obj,Map<String,Object> collectMap){
        Class srcClazz = obj.getClass();
        Field[] srcFields = srcClazz.getDeclaredFields();
        Stream.of(srcFields).forEach(field -> {
            field.setAccessible(true);
            try {
                if(field.getType().toString().contains("aacoin.account")  && !field.getType().isEnum()){
                    Object subObj = field.get(obj);
                    if(subObj!=null)
                        getSrcALLFieldMap(subObj,collectMap);
                }else{
                    collectMap.put(field.getName(),field.get(obj));
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        });
    }
    private static void setTargetAllField(Object obj, Map<String,Object> srcMap){
        Class srcClazz = obj.getClass();
        Field[] srcFields = srcClazz.getDeclaredFields();
        Stream.of(srcFields).forEach(field -> {
            field.setAccessible(true);
            try {
                if(field.getType().toString().contains("aacoin.trade.otc") && !field.getType().isEnum()){
                    Object subObj = field.get(obj);
                    if(subObj == null) {
                        Constructor cons = field.getType().getDeclaredConstructor(null);
                        cons.setAccessible(true);
                        subObj = cons.newInstance(null);
                        field.set(obj, subObj);
                    }
                    setTargetAllField(subObj, srcMap);
                }else{
                    //collectMap.put(field,obj);
                    Object currentField = srcMap.get(field.getName());
                    if( currentField !=null && field.getType() == currentField.getClass()){
                        field.set(obj,currentField);
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        });
    }

    public static <T> T convert(Object src,Class<T> tClass){

        Constructor<T> cons = null;
        try {
            cons = tClass.getDeclaredConstructor(null);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        cons.setAccessible(true);
        T result = null;
        try {
            result = cons.newInstance(null);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        convert(src,result);
        return result;
    }

    public static <T> T convert(Object src,T result) {

        Map<String,Object> srcMap = new HashMap();
        getSrcALLFieldMap(src,srcMap);

        setTargetAllField(result,srcMap);
        return result;
    }

调用：

adverVO =convert(advert,AdvertVO.class);

写的比较随意，直接吞掉了异常，需自行处理，将异常统一规范抛出

原文地址：https://www.cnblogs.com/cmos/p/9104384.html