spring\spring boot拷贝实体的工具类---BeanObjectCopyUtils

/** @deprecated */
@Deprecated
public static <T> T instantiate(Class<T> clazz) throws BeanInstantiationException {
    Assert.notNull(clazz, "Class must not be null");
    if (clazz.isInterface()) {
        throw new BeanInstantiationException(clazz, "Specified class is an interface");
    } else {
        try {
            return clazz.newInstance();
        } catch (InstantiationException var2) {
            throw new BeanInstantiationException(clazz, "Is it an abstract class?", var2);
        } catch (IllegalAccessException var3) {
            throw new BeanInstantiationException(clazz, "Is the constructor accessible?", var3);
        }
    }
}

public static void copyProperties(Object source, Object target) throws BeansException {
    copyProperties(source, target, (Class)null, (String[])null);
}

private static void copyProperties(Object source, Object target, @Nullable Class<?> editable, @Nullable String... ignoreProperties) throws BeansException {
    Assert.notNull(source, "Source must not be null");
    Assert.notNull(target, "Target must not be null");
    Class<?> actualEditable = target.getClass();
    if (editable != null) {
        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;
    PropertyDescriptor[] var7 = targetPds;
    int var8 = targetPds.length;

    for(int var9 = 0; var9 < var8; ++var9) {
        PropertyDescriptor targetPd = var7[var9];
        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 var15) {
                        throw new FatalBeanException("Could not copy property '" + targetPd.getName() + "' from source to target", var15);
                    }
                }
            }
        }
    }

}

import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;


/**
 * 对象拷贝工具
 * @author DELL
 * @version 1.0
 */
public class BeanObjectCopyUtils{

   private static  Logger LOGGER = LoggerFactory.getLogger( BeanObjectCopyUtils.class );


   /**
    * 拷贝对象
    * @param desObj 目标对象
    * @param origObj 源对象
    * @return  desObj 目标对象
    */
   public static <T,E> T copyObject(T desObj, E origObj){
      if(origObj!=null && desObj!=null){
         try {
            BeanUtils.copyProperties(origObj, desObj);
         }
         catch (Exception e) {
            LOGGER.error("object copy error",e);
            throw new RuntimeException("object copy error",e);
         }
      }
      return desObj;
   }


   /**
    * 拷贝List对象到另一个list对象
    * @param desClass  源List对象
    * @param sourceList 目标List对象
    * @return  List
    */
   @SuppressWarnings({ "rawtypes", "unchecked" })
   public static <T> List<T> copyListObjToListObj(Class<T> desClass, List sourceList){
      List desList=new ArrayList();
      if(sourceList!=null){
         for(int i=0; i<sourceList.size(); i++){
            try {
               Object  sourceObj = sourceList.get(i);
               Object  desObj = desClass.newInstance();
               BeanUtils.copyProperties(sourceObj, desObj);
               desList.add(desObj);
            }
            catch (Exception e) {
               LOGGER.error("list copy error",e);
               throw new RuntimeException("list copy error",e);
            }

         }
      }
      return desList;
   }

VoucherPostBaseBo vouchPostRecordBO = BeanObjectCopyUtils.copyObject(new VoucherPostBaseBo(), vouchPostRecordVO);

List<VoucherPostBaseBo> vouchPostRecordBO = BeanObjectCopyUtils.copyListObjToListObj(VoucherPostBaseBo.class, vouchPostRecordVO);