深clone - 嵌套对象（失败案例：ModelMapper & Cloner）

淩亂°似流年 2024-03-26 21:08 23阅读 0赞

#### 深clone - 嵌套对象（失败案例：ModelMapper & Cloner） ####

*  前言
 *  一、工具类 BeanHelp
 *  二、测试实体类
 *  三、测试类
 *  想搞个批量clone对象的方法

--------------------

## 前言 ##

想实现嵌套对象的深clone。  
现有三方插件里，除了hutool，fastJson，jackJson以外  
这里继续用ModelMapper & Cloner来尝试实现深度Clone

## 一、工具类 BeanHelp ##

import com.rits.cloning.Cloner;
    import org.modelmapper.ModelMapper;
    import org.modelmapper.convention.MatchingStrategies;
    
    import java.lang.reflect.Field;
    import java.time.LocalDate;
    import java.time.LocalDateTime;
    import java.util.Date;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    public class BeanHelp {
        
    
        private static final ModelMapper modelMapper = new ModelMapper();
        private static final Cloner cloner = new Cloner();
        private static final Map<String, Field> FN_MAP;
    
        static {
        
            modelMapper.getConfiguration().setFieldMatchingEnabled(true).setFullTypeMatchingRequired(true).setMatchingStrategy(MatchingStrategies.STRICT).setPropertyCondition((ctx) -> {
        
                return null != ctx.getSource();
            }).setProvider((request) -> {
        
                return null != request.getSource() && requireClone(request.getSource().getClass()) ? cloner.deepClone(request.getSource()) : null;
            });
            FN_MAP = new ConcurrentHashMap();
        }
    
        public static <Source, Target> Target castTo(Source source, Class<Target> destType) {
        
            if (null != source && null != destType) {
        
                try {
        
                    Target target = destType.newInstance();
                    copy(source, target);
                    return target;
                } catch (Exception var3) {
        
                    throw new RuntimeException("error to copy source as " + destType.getName(), var3);
                }
            } else {
        
                return null;
            }
        }
    
        public static void copy(Object source, Object target) {
        
            if (null != source && null != target) {
        
                modelMapper.map(source, target);
            }
        }
    
    
        private static boolean requireClone(Class<?> type) {
        
            return !isPrimitiveType(type);
        }
        public static boolean isPrimitiveType(Class<?> clz) {
        
            return clz.isPrimitive() || isSubTypeOf(clz, Number.class, Boolean.class, Character.class, String.class, Date.class, LocalDate.class, LocalDateTime.class);
        }
    
        private static boolean isSubTypeOf(Class<?> targetClz, Class<?>... parentClz) {
        
            Class[] var2 = parentClz;
            int var3 = parentClz.length;
    
            for(int var4 = 0; var4 < var3; ++var4) {
        
                Class<?> c = var2[var4];
                if (c.isAssignableFrom(targetClz)) {
        
                    return true;
                }
            }
    
            return false;
        }
    }

## 二、测试实体类 ##

import lombok.Data;
    import java.util.List;
    @Data
    class Example {
        
        public Example() {
        
        }
    
        public Example(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        private String name;
        private int age;
    
        private List<Example> children;
    }

import lombok.Data;
    
    import java.util.List;
    
    @Data
    class Target {
        
        public Target() {
        
        }
    
        public Target(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        private String name;
    
        private int age;
    
        private List<Target> children;
    
    
    }

## 三、测试类 ##

代码如下（示例）：

import com.google.common.collect.Lists;
    
    public class BeansHelperDemo {
        
        public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        
    
            Example example = new Example("张三", 28);
            Example children1 = new Example("张三儿子", 3);
            Example children2 = new Example("张三女子", 1);
            example.setChildren(Lists.newArrayList(children1, children2));
    
    
            Target target = BeanHelp.castTo(example, Target.class);
            System.out.println(target.toString());
            target.getChildren().forEach(children -> System.out.println(children.toString()));
    
        }
    }

Target(name=张三, age=28, children=[Example(name=张三儿子, age=3, children=null), Example(name=张三女子, age=1, children=null)])

`这里可以看到：`  
`张三的类型变成了Targe`  
`张三儿子、张三女二的类型还是Example`

`此时：target.getChildren().forEach(children -> System.out.println(children.toString())); 会报错:java.lang.ClassCastException: com.example.demo.beansHelper.Example cannot be cast to com.example.demo.beansHelper.Target`

## 想搞个批量clone对象的方法 ##