#头条创作挑战赛#

为什么要了解JavaBean深拷贝的机制

目前大家都在常用已经封装好的工具类，很少去深入了解多种实现方式；

此处提出一种简单的实现原理，也是巩固Java中关于反射的用法和知识；

目的：可以拷贝所有子类以及List中的范型（反射实现）

Java中深拷贝、浅拷贝、赋值的区别

在日常开发中，拷贝一直分为深拷贝和浅拷贝，随着我们开发能力的提升，我们应该逐步关注一些常见但是没有真正理解的东西！

本篇的目的就是简单说明并且留有余地，让我们可以了解的同时也可以有时间充分思考。

我们的问题：

1、深拷贝和浅拷贝，他们究竟是什么意思？

2、为什么要这样区分？

3、赋值和浅拷贝是一样的吗？

概念：

浅拷贝 ：只复制指向某个对象的指针，而不复制对象本身，相当于是新建了一个对象，该对象复制了原对象的指针，新旧对象还是共用一个内存块。
深拷贝：是新建一个一模一样的对象，该对象与原对象不共享内存，修改新对象也不会影响原对象。
赋值：当我们把一个对象赋值给一个变量的时候，赋值的其实是该对象的栈内存地址而不是堆内存数据

概念是不是有一些抽象？看下面表格快速了解。

来用一张表格，快速区分

简单说明一下引用数据类型

引用数据类型：

引用数据类型建立在基本数据类型的基础上，包括数组、类和接口。引用数据类型是由用户自定义，用来限制其他数据的类型。

OK，到这里基本已经了解好了，下面该动手了！

如何自己通过反射实现一个JavaBean的深拷贝工具类

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author N_Xiang
 * @describe JavaBean工具类
 * @time 2021/11/10 11:21 下午
 */
public class KtBeanUtils {
    private static Map<String,Method> cachMap = new ConcurrentHashMap<>();
    /**
     * 仅仅拷贝本身
     * @param source
     * @param target
     */
    public static void copy(Object source ,Object target){
        toJavaBean(source,target,false);
    }
    /**
     * 仅仅拷贝本身
     * @param source
     * @param target
     * @param type 类型 true拷贝父类 false正常拷贝
     */
    public static void copy(Object source ,Object target,Boolean type){
        toJavaBean(source,target,type);
    }
    /**
     * Bean拷贝
     * @param source 元数据
     * @param target 目标数据
     * @param type 类型 true拷贝父类 false正常拷贝
     */
    private static void toJavaBean(Object source ,Object target,Boolean type){
				//Map<String, String> map = KtAliasPars.ParsAlias(source);
        Class<?> cTarget = target.getClass();
        Class<?> cSource = source.getClass();
				//获得某个类的所有声明的字段
        Field[] fields = cTarget.getDeclaredFields();
        for (Field field : fields) {
            String fieldName = field.getName();
						// 获得属性的首字母并转换为大写
            String firstLetter = fieldName.substring(0, 1).toUpperCase().concat(fieldName.substring(1));
            String setMethodName = "set" + firstLetter;
            String getMethodName = "get" + firstLetter;
          
            try {
								//获取源对象的值
                Method cmethod = cachMap.getOrDefault(cSource.getName()+"@"+getMethodName,cSource.getMethod(getMethodName));
                Object cinvoke = cmethod.invoke(source);
                cachMap.put(cSource.getName()+"@"+getMethodName,cmethod);
                if (!isWrapClass(field.getType())){
                    if (field.getType().equals(List.class)){
                        List<Object> o = new ArrayList<>();
                        copyListProperties((List<Object>)cinvoke, o,getT(field));
                        cinvoke = o;
                    }else {
                        Object o = field.getType().newInstance();
                        toJavaBean(cinvoke,o,false);
                        cinvoke = o;
                    }
                }
								//调用方法写入对象
                Method setMethod = cachMap.getOrDefault(cTarget.getName()+"@"+setMethodName,cTarget.getMethod(setMethodName,
                        new Class[] { field.getType() }));
                cachMap.put(cTarget.getName()+"@"+setMethodName,setMethod);
                setMethod.invoke(target, new Object[] { cinvoke });
            } catch (Exception e) {
								// e.printStackTrace();
            }
        }
    }
    private static boolean isWrapClass(Class clz) {
        if (clz.equals(String.class)){
            return true;
        }
        try {
            return ((Class) clz.getField("TYPE").get(null)).isPrimitive();
        } catch (Exception e) {
            return false;
        }
    }
    /**
     * 带回调函数的集合数据的拷贝（可自定义字段拷贝规则）
     * @param sources : 数据源类
     * @param target : 目标类::new(eg: UserVO::new)
     * @return
     */
    public static void copyListProperties(List<Object> sources, List<Object> target,Class<?> targetType) {
        for (Object source : sources) {
            Object o = null;
            try {
                o = targetType.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            toJavaBean(source, o,false);
            target.add(o);
        }
    }
    /**
     * 获取list的范性
     * @param f list
     * @return
     */
    private static Class<?> getT(Field f){
        Type genericType = f.getGenericType();
				// 如果是泛型参数的类型
        if(genericType instanceof ParameterizedType){
            ParameterizedType pt = (ParameterizedType) genericType;
						//得到泛型里的class类型对象
            return (Class<?>)pt.getActualTypeArguments()[0];
        }
        return null;
    }
}

Lintge-每天一个小技巧，了解一些好玩的知识