利用Java反射机制实现对象相同字段的复制操作

 /**
 * Copy the property values of the given source bean into the given target bean.
 * <p>Note: The source and target classes do not have to match or even be derived
 * from each other, as long as the properties match. Any bean properties that the
 * source bean exposes but the target bean does not will silently be ignored.
 * @param source the source bean：也就是说要从这个对象里面复制值出去
 * @param target the target bean：出去就是复制到这里面来
 * @param editable the class (or interface) to restrict property setting to：这个类对象是target的父类或其实现的接口，用于控制属性复制的范围
 * @param ignoreProperties array of property names to ignore：需要忽略的字段
 * @throws BeansException if the copying failed
 * @see BeanWrapper
 */
 private static void copyProperties(Object source, Object target, Class<?> editable, String... ignoreProperties)
 throws BeansException {

 //这里在校验要复制的对象是不可以为null的，这两个方法可是会报错的！！
 Assert.notNull(source, "Source must not be null");
 Assert.notNull(target, "Target must not be null");
 //这里和下面的代码就有意思了
 Class<?> actualEditable = target.getClass();//获取目标对象的动态类型
 //下面判断的意图在于控制属性复制的范围
 if (editable != null) {
 //必须是target对象的父类或者其实现的接口类型，相当于instanceof运算符
 if (!editable.isInstance(target)) {
 throw new IllegalArgumentException("Target class [" + target.getClass().getName() +
  "] not assignable to Editable class [" + editable.getName() + "]");
 }
 actualEditable = editable;
 }
 //不得不说，下面这段代码乖巧的像绵羊，待我们来分析分析它是如何如何乖巧的
 PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);//获取属性描述，描述是什么？描述就是对属性的方法信息的封装，好乖。
 List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);

 //重头戏开始了！开始进行复制了
 for (PropertyDescriptor targetPd : targetPds) {
 //先判断有没有写方法，没有写方法我也就没有必要读属性出来了，这个懒偷的真好！
 Method writeMethod = targetPd.getWriteMethod();
 //首先，没有写方法的字段我不写，乖巧撒？就是说你不让我改我就不改，让我忽略我就忽略！
 if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {
 PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
 //如果没办法从原对象里面读出属性也没有必要继续了
 if (sourcePd != null) {
  Method readMethod = sourcePd.getReadMethod();
  //这里就更乖巧了！写方法不让我写我也不写！！！
  if (readMethod != null &&
  ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
  try {
  //这里就算了，来都来了，就乖乖地进行值复制吧，别搞东搞西的了
  if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
  readMethod.setAccessible(true);
  }
  Object value = readMethod.invoke(source);
  if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
  writeMethod.setAccessible(true);
  }
  writeMethod.invoke(target, value);
  }
  catch (Throwable ex) {
  throw new FatalBeanException(
   "Could not copy property '" + targetPd.getName() + "' from source to target", ex);
  }
  }
 }
 }
 }
 }

 /*
  ******************************************************
  * 基础的用于支持反射解析的解析结果缓存，使用软引用实现
  ******************************************************
  */
 private static final Map<Class<?>,SoftReference<Map<String,Field>>> resolvedClassCache = new ConcurrentHashMap<>();
 
 /**
  * 同步解析字节码对象，将解析的结果放入到缓存 1、解析后的字段对象全部 accessAble
  * 1、返回的集合不支持修改，要修改请记得自己重新建一个复制的副本
  * @param sourceClass：需要解析的字节码对象
  */
 @SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
 public static Map<String,Field> resolveClassFieldMap(final Class<?> sourceClass){

  SoftReference<Map<String,Field>> softReference = resolvedClassCache.get(sourceClass);

  //判断是否已经被初始化
  if(softReference == null || softReference.get() == null){

   //对同一个字节码对象的解析是同步的，但是不同字节码对象的解析是并发的，因为字节码对象只有一个
   synchronized(sourceClass){

    softReference = resolvedClassCache.get(sourceClass);

    if(softReference == null || softReference.get() == null){

    //采用：<字段名称,字段对象> 来记录解析结果
     Map<String,Field> fieldMap = new HashMap<>();

     /*
     Returns an array of Field objects reflecting all the fields declared by the class or interface represented by this
     Class object. This includes public, protected, default access, and private fields, but excludes inherited fields
     */
     Field[] declaredFields = sourceClass.getDeclaredFields();

     if(declaredFields != null && declaredFields.length > 0){

      for(Field field : declaredFields){

       /*
       Set the accessible flag for this object to the indicated boolean value.
       */
       field.setAccessible(true);
   //字段名称和字段对象
       fieldMap.put(field.getName(),field);
      }
     }

     //设置为不变Map，这个肯定是不能够改的啊！所以取的时候需要重新构建一个map
     fieldMap = Collections.unmodifiableMap(fieldMap);

     softReference = new SoftReference<>(fieldMap);

     /*
     更新缓存，将解析后的数据加入到缓存里面去
      */
     resolvedClassCache.put(sourceClass,softReference);

     return fieldMap;
    }
   }
  }

  /*
  运行到这里来的时候要么早就存在，要么就是已经被其他的线程给初始化了
   */
  return softReference.get();
 }

 /**
  * 进行属性的基本复制操作
  * @param source：源对象
  * @param sourceFieldMap：原对象解析结果
  * @param target：目标对象
  * @param targetFieldMap：目标对象解析结果
  */
 public static void copyObjectProperties(Object source,Map<String,Field> sourceFieldMap,Object target,Map<String,Field> targetFieldMap){

  //进行属性值复制
  sourceFieldMap.forEach(
    (fieldName,sourceField) -> {

     //查看目标对象是否存在这个字段
     Field targetField = targetFieldMap.get(fieldName);

     if(targetField != null){

      try{
       //对目标字段进行赋值操作
       targetField.set(target,sourceField.get(source));
      }catch(IllegalAccessException e){
       e.printStackTrace();
      }
     }
    }
  );
 }

package edu.cqupt.demonstration.common.util;

import java.lang.ref.SoftReference;
import java.lang.reflect.Field;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 反射的工具集，主要用于对对象的复制操作
 */
public class ReflectUtil {

 /*
  ******************************************************
  * 基础的用于支持反射解析的解析结果缓存，使用软引用实现
  ******************************************************
  */
 private static final Map<Class<?>,SoftReference<Map<String,Field>>> resolvedClassCache = new ConcurrentHashMap<>();

 /*
  ****************************************
  * 获取一个对象指定条件字段名称的工具方法
  ****************************************
  */

 /**
  * 获取一个对象里面字段为null的字段名称集合
  */
 public static String[] getNullValueFieldNames(Object source){

  //非空校验：NullPointerException
  Objects.requireNonNull(source);

  Class<?> sourceClass = source.getClass();

  //从缓存里面获取，如果缓存里面没有就会进行第一次反射解析
  Map<String,Field> classFieldMap = getClassFieldMapWithCache(sourceClass);

  List<String> nullValueFieldNames = new ArrayList<>();

  classFieldMap.forEach(
    (fieldName,field) -> {

     try{
      //挑选出值为null的字段名称
      if(field.get(source) == null){
       nullValueFieldNames.add(fieldName);
      }
     }catch(IllegalAccessException e){
      e.printStackTrace();
     }
    }
  );

  return nullValueFieldNames.toArray(new String[]{});
 }

 /**
  * 获取一个对象里面字段不为null的字段名称集合
  */
 public static String[] getNonNullValueFieldNames(Object source){

   //非空校验
  Objects.requireNonNull(source);

  //获取空值字段名称
  String[] nullValueFieldNames = getNullValueFieldNames(source);

  Map<String,Field> classFieldMap = getClassFieldMapWithCache(source.getClass());

  //获取全部的字段名称，因为原数据没办法修改，所以需要重新建立一个集合来进行判断
  Set<String> allFieldNames = new HashSet<>(classFieldMap.keySet());

  //移除掉值为null的字段名称
  allFieldNames.removeAll(Arrays.asList(nullValueFieldNames));

  return allFieldNames.toArray(new String[]{});
 }

 /*
  ***************************************************************
  * 复制一个对象的相关工具方法，注意事项如下：
  * 1、只能复制字段名称相同且数据类型兼容的字段数据
  * 2、只能复制这个对象实际类（运行时动态类型）里面声明的各种字段
  ***************************************************************
  */

 /**
  * 将一个对象里面字段相同、类型兼容的数据复制到另外一个对象去
  * 1、只复制类的运行时类型的声明的全部访问权限的字段
  * @param source：从这个对象复制
  * @param target：复制到这个对象来
  */
 public static void copyPropertiesSimple(Object source,Object target){

  copyObjectProperties(
    source,new HashMap<>(getClassFieldMapWithCache(source.getClass())),
    target,new HashMap<>(getClassFieldMapWithCache(target.getClass())));
 }

 /**
  * 除实现 copyPropertiesSimple 的功能外，会忽略掉原对象的指定字段的复制
  * @param ignoreFieldNames：需要忽略的原对象字段名称集合
  */
 public static void copyPropertiesWithIgnoreSourceFields(Object source,Object target,String ...ignoreFieldNames){

  Map<String,Field> sourceFieldMap = new HashMap<>(getClassFieldMapWithCache(source.getClass()));

  filterByFieldName(sourceFieldMap,ignoreFieldNames);

  copyObjectProperties(source,sourceFieldMap,target,new HashMap<>(getClassFieldMapWithCache(target.getClass())));
 }

 /**
  * 除实现 copyPropertiesSimple 的功能外，会忽略掉原对象字段值为null的字段
  */
 public static void copyPropertiesWithNonNullSourceFields(Object source,Object target){

  Map<String,Field> sourceFieldMap = new HashMap<>(getClassFieldMapWithCache(source.getClass()));

  filterByFieldValue(source,sourceFieldMap,true);

  copyObjectProperties(source,sourceFieldMap,target,new HashMap<>(getClassFieldMapWithCache(target.getClass())));
 }

 /**
  * 除实现 copyPropertiesSimple 的功能外，会忽略掉目标对象的指定字段的复制
  * @param ignoreFieldNames：需要忽略的原对象字段名称集合
  */
 public static void copyPropertiesWithIgnoreTargetFields(Object source,Object target,String ...ignoreFieldNames){

  Map<String,Field> targetFieldMap = new HashMap<>(getClassFieldMapWithCache(target.getClass()));

  filterByFieldName(targetFieldMap,ignoreFieldNames);

  copyObjectProperties(source,new HashMap<>(getClassFieldMapWithCache(source.getClass())),target,targetFieldMap);
 }

 /**
  * 除实现 copyPropertiesSimple 的功能外，如果目标对象的属性值不为null将不进行覆盖
  */
 public static void copyPropertiesWithTargetFieldNonOverwrite(Object source,Object target){

  Map<String,Field> targetFieldMap = new HashMap<>(getClassFieldMapWithCache(target.getClass()));

  filterByFieldValue(target,targetFieldMap,false);
  copyObjectProperties(source,new HashMap<>(getClassFieldMapWithCache(source.getClass())),target,targetFieldMap);
 }

 /**
  * 进行复制的完全定制复制
  * @param source：源对象
  * @param target：目标对象
  * @param ignoreSourceFieldNames：需要忽略的原对象字段名称集合
  * @param ignoreTargetFieldNames：要忽略的目标对象字段集合
  * @param isSourceFieldValueNullAble：是否在源对象的字段为null的时候仍然进行赋值
  * @param isTargetFiledValueOverwrite：是否在目标对象的值不为null的时候仍然进行赋值
  */
 public static void copyPropertiesWithConditions(Object source,Object target
   ,String[] ignoreSourceFieldNames,String[] ignoreTargetFieldNames
   ,boolean isSourceFieldValueNullAble,boolean isTargetFiledValueOverwrite){

  Map<String,Field> sourceFieldMap = new HashMap<>(getClassFieldMapWithCache(source.getClass()));
  Map<String,Field> targetFieldMap = new HashMap<>(getClassFieldMapWithCache(target.getClass()));

  if(!isSourceFieldValueNullAble){

   filterByFieldValue(source,sourceFieldMap,true);
  }

  if(!isTargetFiledValueOverwrite){
   filterByFieldValue(target,targetFieldMap,false);
  }

  filterByFieldName(sourceFieldMap,ignoreSourceFieldNames);
  filterByFieldName(targetFieldMap,ignoreTargetFieldNames);
  copyObjectProperties(source,sourceFieldMap,target,targetFieldMap);
 }

 /*
  ******************************
  * 内部工具方法或者内部兼容方法
  ******************************
  */

 /**
  * 同步解析字节码对象，将解析的结果放入到缓存 1、解析后的字段对象全部 accessAble
  * 1、返回的集合不支持修改，要修改请记得自己重新建一个复制的副本
  * @param sourceClass：需要解析的字节码对象
  */
 @SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
 public static Map<String,Field> resolveClassFieldMap(final Class<?> sourceClass){

  SoftReference<Map<String,Field>> softReference = resolvedClassCache.get(sourceClass);

  //判断是否已经被初始化
  if(softReference == null || softReference.get() == null){

   //对同一个字节码对象的解析是同步的，但是不同字节码对象的解析是并发的
   synchronized(sourceClass){

    softReference = resolvedClassCache.get(sourceClass);
    if(softReference == null || softReference.get() == null){

     Map<String,Field> fieldMap = new HashMap<>();
     /*
     Returns an array of Field objects reflecting all the fields declared by the class or interface represented by this
     Class object. This includes public, protected, default access, and private fields, but excludes inherited fields
     */
     Field[] declaredFields = sourceClass.getDeclaredFields();
     if(declaredFields != null && declaredFields.length > 0){
      for(Field field : declaredFields){
       /*
       Set the accessible flag for this object to the indicated boolean value.
       */
       field.setAccessible(true);
       fieldMap.put(field.getName(),field);
      }
     }

     //设置为不变Map
     fieldMap = Collections.unmodifiableMap(fieldMap);

     softReference = new SoftReference<>(fieldMap);

     /*
     更新缓存，将解析后的数据加入到缓存里面去
      */
     resolvedClassCache.put(sourceClass,softReference);

     return fieldMap;
    }
   }
  }
  /*
  运行到这里来的时候要么早就存在，要么就是已经被其他的线程给初始化了
   */
  return softReference.get();
 }

 /**
  * 确保正确的从缓存里面获取解析后的数据
  * 1、返回的集合不支持修改，要修改请记得自己重新建一个复制的副本
  * @param sourceClass：需要解析的字节码对象
  */
 public static Map<String,Field> getClassFieldMapWithCache(Class<?> sourceClass){

  //查看缓存里面有没有已经解析完毕的现成的数据
  SoftReference<Map<String,Field>> softReference = resolvedClassCache.get(sourceClass);

  //确保classFieldMap的正确初始化和缓存
  if(softReference == null || softReference.get() == null){

   //解析字节码对象
   return resolveClassFieldMap(sourceClass);
  }else {

   //从缓存里面正确的取出数据
   return softReference.get();
  }
 }

 /**
  * 将一个可变参数集合转换为List集合，当为空的时候返回空集合
  */
 public static <T> List<T> resolveArrayToList(T ...args){

  List<T> result = new ArrayList<>();
  if(args != null && args.length > 0){
   result = Arrays.asList(args);
  }
  return result;
 }

 /**
  * 进行属性的基本复制操作
  * @param source：源对象
  * @param sourceFieldMap：原对象解析结果
  * @param target：目标对象
  * @param targetFieldMap：目标对象解析结果
  */
 public static void copyObjectProperties(Object source,Map<String,Field> sourceFieldMap,Object target,Map<String,Field> targetFieldMap){

  //进行属性值复制
  sourceFieldMap.forEach(
    (fieldName,sourceField) -> {

     //查看目标对象是否存在这个字段
     Field targetField = targetFieldMap.get(fieldName);

     if(targetField != null){

      try{
       //对目标字段进行赋值操作
       targetField.set(target,sourceField.get(source));
      }catch(IllegalAccessException e){
       e.printStackTrace();
      }
     }
    }
  );
 }

 /**
  * 忽略掉对象里面的某些字段
  */
 public static void filterByFieldName(Map<String,Field> fieldMap,String ... ignoreFieldNames){

  //需要忽略的对象字段
  List<String> ignoreNames = ReflectUtil.<String>resolveArrayToList(ignoreFieldNames);

  //移除忽略的对象字段
  fieldMap.keySet().removeAll(ignoreNames);
 }

 /**
  * 忽略掉非空的字段或者空的字段
  */
 public static void filterByFieldValue(Object object,Map<String,Field> fieldMap,boolean filterNullAble){

  Iterator<String> iterator = fieldMap.keySet().iterator();
  if(filterNullAble){
   while(iterator.hasNext()){
    try{
     //移除值为null的字段
     if(fieldMap.get(iterator.next()).get(object) == null){
      iterator.remove();
     }
    }catch(IllegalAccessException e){
     e.printStackTrace();
    }
   }
  }else {

   while(iterator.hasNext()){

    try{
     //移除字段不为null的字段
     if(fieldMap.get(iterator.next()).get(object) != null){
      iterator.remove();
     }
    }catch(IllegalAccessException e){
     e.printStackTrace();
    }
   }
  }
 }
}

/**
	 * 将两个JavaBean里相同的字段自动填充
	 * @param dto 参数对象
	 * @param obj 待填充的对象
	 */
	public static void autoFillEqFields(Object dto, Object obj) {
		try {
			Field[] pfields = dto.getClass().getDeclaredFields();
 
			Field[] ofields = obj.getClass().getDeclaredFields();
 
			for (Field of : ofields) {
				if (of.getName().equals("serialVersionUID")) {
					continue;
				}
				for (Field pf : pfields) {
					if (of.getName().equals(pf.getName())) {
						PropertyDescriptor rpd = new PropertyDescriptor(pf.getName(), dto.getClass());
						Method getMethod = rpd.getReadMethod();// 获得读方法
 
						PropertyDescriptor wpd = new PropertyDescriptor(pf.getName(), obj.getClass());
						Method setMethod = wpd.getWriteMethod();// 获得写方法
 
						setMethod.invoke(obj, getMethod.invoke(dto));
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
 
	/**
	 * 将两个JavaBean里相同的字段自动填充,按指定的字段填充
	 * @param dto
	 * @param obj
	 * @param String[] fields
	 */
	public static void autoFillEqFields(Object dto, Object obj, String[] fields) {
		try {
			Field[] ofields = obj.getClass().getDeclaredFields();
 
			for (Field of : ofields) {
				if (of.getName().equals("serialVersionUID")) {
					continue;
				}
				for (String field : fields) {
					if (of.getName().equals(field)) {
						PropertyDescriptor rpd = new PropertyDescriptor(field, dto.getClass());
						Method getMethod = rpd.getReadMethod();// 获得读方法
 
						PropertyDescriptor wpd = new PropertyDescriptor(field, obj.getClass());
						Method setMethod = wpd.getWriteMethod();// 获得写方法
 
						setMethod.invoke(obj, getMethod.invoke(dto));
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

/**
 * 将两个JavaBean里相同的字段自动填充
 * @param obj 原JavaBean对象
 * @param toObj 将要填充的对象
 */
 public static void autoFillEqFields(Object obj, Object toObj) {
 try {
 Map<String, Method> getMaps = new HashMap<>();
 Method[] sourceMethods = obj.getClass().getMethods();
 for (Method m : sourceMethods) {
 if (m.getName().startsWith("get")) {
  getMaps.put(m.getName(), m);
 }
 }
 
 Method[] targetMethods = toObj.getClass().getMethods();
 for (Method m : targetMethods) {
 if (!m.getName().startsWith("set")) {
  continue;
 }
 String key = "g" + m.getName().substring(1);
 Method getm = getMaps.get(key);
 if (null == getm) {
  continue;
 }
 // 写入方法写入
 m.invoke(toObj, getm.invoke(obj));
 }
 } catch (Exception e) {
 e.printStackTrace();
 }
 }