Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/BeanUtil.java

对比新文件
@@ -0,0 +1,175 @@
package com.vci.ubcs.starter.web.util;


import com.vci.ubcs.starter.web.toolmodel.DateConverter;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.core.Converter;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class BeanUtil {
   private static final ConcurrentMap<String, BeanCopier> beanCopierMap = new ConcurrentHashMap();

   public BeanUtil() {
   }

   public static BeanCopier getBeanCopier(Class<?> source, Class<?> target, boolean useConverter) {
      String beanCopierKey = generateBeanKey(source, target);
      if (beanCopierMap.containsKey(beanCopierKey)) {
         return (BeanCopier)beanCopierMap.get(beanCopierKey);
      } else {
         BeanCopier beanCopier = BeanCopier.create(source, target, useConverter);
         beanCopierMap.putIfAbsent(beanCopierKey, beanCopier);
         return (BeanCopier)beanCopierMap.get(beanCopierKey);
      }
   }

   public static String generateBeanKey(Class<?> source, Class<?> target) {
      return source.getName() + "@" + target.getName();
   }

   public static void convert(Object source, Object target, boolean useConvert) {
      if (source != null && target != null) {
         BeanCopier beanCopier = getBeanCopier(source.getClass(), target.getClass(), useConvert);
         beanCopier.copy(source, target, useConvert ? new DeepCopyConverter(target) : null);
      }

   }

   public static void convert(Object source, Object target) {
      convert(source, target, true);
   }

   public static class DeepCopyConverter implements Converter {
      private Object target;

      public DeepCopyConverter(Object target) {
         this.target = target;
      }

      @Override
      public Object convert(Object value, Class targetClazz, Object methodName) {
         if (value instanceof List) {
            List values = (List)value;
            List retList = new ArrayList(values.size());
            this.copyForCollection(values, retList, methodName);
            return retList;
         } else {
            if (value instanceof Set) {
               Set values = (Set)value;
               Set retSet = new HashSet();
               this.copyForCollection(values, retSet, methodName);
            } else if (value instanceof Vector) {
               Vector values = (Vector)value;
               Vector retVector = new Vector();
               this.copyForCollection(values, retVector, methodName);
            } else if (value instanceof Map) {
               Map values = (Map)value;
               Map retMap = new HashMap();
               Iterator var6 = values.keySet().iterator();

               while(var6.hasNext()) {
                  Object key = var6.next();
                  Object mapValue = values.get(key);
                  String tempFieldName = methodName.toString().replace("set", "");
                  String fieldName = tempFieldName.substring(0, 1).toLowerCase() + tempFieldName.substring(1);
                  Class clazz = ClassUtil.getElementType(this.target.getClass(), fieldName);
                  Object targetAttr = null;

                  try {
                     targetAttr = clazz.newInstance();
                  } catch (Throwable var15) {
                  }

                  BeanUtil.convert(mapValue, targetAttr);
                  retMap.put(key, targetAttr);
               }
            } else if (!ClassUtil.isPrimitive(targetClazz)) {
               Object targetAttr = null;

               try {
                  targetAttr = targetClazz.newInstance();
               } catch (Throwable var14) {
               }

               BeanUtil.convert(value, targetAttr);
               return targetAttr;
            }

            if (value instanceof Boolean && targetClazz.equals(String.class)) {
               return String.valueOf(value);
            } else if (!(value instanceof String) || !targetClazz.equals(Boolean.class) && !targetClazz.equals(Boolean.TYPE)) {
               if (value instanceof Date && targetClazz.equals(String.class)) {
                  return VciDateUtil.date2Str((Date)value, "yyyy-MM-dd HH:mm:ss.SSS");
               } else if (value instanceof String && targetClazz.equals(Date.class)) {
                  DateConverter dateConverter = new DateConverter();
                  dateConverter.setAsText((String)value);
                  return dateConverter.getValue();
               } else {
                  return value;
               }
            } else {
               return "true".equalsIgnoreCase((String)value) ? true : false;
            }
         }
      }

      private void copyForCollection(Collection<?> sourceCollection, Collection targetCollection, Object methodName) {
         Iterator var4 = sourceCollection.iterator();

         while(true) {
            while(var4.hasNext()) {
               Object source = var4.next();
               if (source instanceof Collection) {
                  List<Object> targetValues = new ArrayList();
                  this.copyForCollection((Collection)source, targetValues, methodName);
                  targetCollection.add(targetValues);
               } else {
                  String tempFieldName;
                  String fieldName;
                  Class clazz;
                  Object targetAttr;
                  if (!(source instanceof Map)) {
                     tempFieldName = methodName.toString().replace("set", "");
                     fieldName = tempFieldName.substring(0, 1).toLowerCase() + tempFieldName.substring(1);
                     clazz = ClassUtil.getElementType(this.target.getClass(), fieldName);
                     targetAttr = null;

                     try {
                        targetAttr = clazz.newInstance();
                     } catch (Throwable var13) {
                     }

                     BeanUtil.convert(source, targetAttr);
                     targetCollection.add(targetAttr);
                  } else {
                     tempFieldName = methodName.toString().replace("set", "");
                     fieldName = tempFieldName.substring(0, 1).toLowerCase() + tempFieldName.substring(1);
                     clazz = ClassUtil.getElementType(this.target.getClass(), fieldName);
                     targetAttr = null;

                     try {
                        targetAttr = clazz.newInstance();
                     } catch (Throwable var14) {
                     }

                     Map map = (Map)source;
                     Iterator var11 = map.keySet().iterator();

                     while(var11.hasNext()) {
                        Object key = var11.next();
                        VciBaseUtil.setValueForField(key.toString(), targetAttr, VciBaseUtil.getStringValueFromObject(map.get(key)));
                     }

                     targetCollection.add(targetAttr);
                  }
               }
            }

            return;
         }
      }
   }
}