对象之间的转换，只转换属性名称和类型匹配的field，并且要求有setter getter
    *注：不能用使用Lombok的 @Accessors(chain = true) 注解
    包含功能：

    1. 单个转换（可以是两个不同class的类，只要属性、名称匹配，就可以转换）
    2. 集合转换
    3. copy 不为 null的属性
    4. 获得类的属性名和值 的Map
    5. 获得类和父类的属性名和值 的Map
    6. Map 转 Object
    1. package com.hq.pfexample.util;
    4. import org.springframework.beans.BeanUtils;
    5. import org.springframework.beans.BeanWrapper;
    6. import org.springframework.beans.BeanWrapperImpl;
    7. import org.springframework.cglib.beans.BeanCopier;
    8. import org.springframework.util.CollectionUtils;
    10. import java.beans.BeanInfo;
    11. import java.beans.Introspector;
    12. import java.beans.PropertyDescriptor;
    13. import java.lang.reflect.Field;
    14. import java.lang.reflect.Method;
    15. import java.util.*;
    16. import java.util.concurrent.ConcurrentHashMap;
    18. /**
    19.  * @author zhangzuhao
    20.  * @Description: 对象之间的转换，只转换属性名称和类型匹配的field，并且要求有setter getter
    21.  * @date 2020/9/25 9:41
    22.  */
    23. public class BeanMapperUtil {
    26.     /**
    27.      * 缓存coper
    28.      */
    29.     public static Map<String, BeanCopier> beanCopierMap = new ConcurrentHashMap<>();
    31.     /**
    32.      * @param source
    33.      * @param target
    34.      * @return
    35.      */
    36.     private static String generateKey(Class<?> source, Class<?> target) {
    37.         return source.toString() + target.toString();
    38.     }
    40.     /**
    41.      * 单个转换
    42.      *
    43.      * @param source
    44.      * @param destinationClass
    45.      * @param <T>
    46.      * @return
    47.      */
    48.     public static <T> T map(Object source, Class<T> destinationClass) {
    49.         if (source == null) {
    50.             return null;
    51.         }
    52.         try {
    53.             T instance = destinationClass.newInstance();
    54.             copyProperties(source, instance);
    55.             return instance;
    56.         } catch (Throwable e) {
    57.             return null;
    58.         }
    59.     }
    61.     /**
    62.      * 集合转换
    63.      *
    64.      * @param sourceList
    65.      * @param destinationClass
    66.      * @param <T>
    67.      * @return
    68.      */
    69.     public static <T> List<T> mapList(Collection sourceList, Class<T> destinationClass) {
    70.         List<T> destinationList = new ArrayList<>();
    71.         if (CollectionUtils.isEmpty(sourceList)) {
    72.             return destinationList;
    73.         }
    74.         for (Object sourceObject : sourceList) {
    75.             T cur = map(sourceObject, destinationClass);
    76.             destinationList.add(cur);
    77.         }
    78.         return destinationList;
    79.     }
    81.     /**
    82.      * @param source
    83.      * @param target
    84.      */
    85.     public static void copyProperties(Object source, Object target) {
    86.         String beanKey = generateKey(source.getClass(), target.getClass());
    87.         BeanCopier copier;
    88.         if (!beanCopierMap.containsKey(beanKey)) {
    89.             copier = BeanCopier.create(source.getClass(), target.getClass(), false);
    90.             beanCopierMap.put(beanKey, copier);
    91.         } else {
    92.             copier = beanCopierMap.get(beanKey);
    93.         }
    94.         copier.copy(source, target, null);
    95.     }
    97.     /**
    98.      * copy 不为 null的 .
    99.      *
    100.      * @param source
    101.      * @param target
    102.      */
    103.     public static void copyNotNullProperties(Object source, Object target) {
    104.         BeanUtils.copyProperties(source, target, getNullPropertyNames(source));
    105.     }
    107.     public static String[] getNullPropertyNames(Object source) {
    108.         final BeanWrapper src = new BeanWrapperImpl(source);
    109.         PropertyDescriptor[] pds = src.getPropertyDescriptors();
    111.         Set<String> emptyNames = new HashSet<String>();
    112.         for (PropertyDescriptor pd : pds) {
    113.             Object srcValue = src.getPropertyValue(pd.getName());
    114.             if (srcValue == null) emptyNames.add(pd.getName());
    115.         }
    116.         String[] result = new String[emptyNames.size()];
    117.         return emptyNames.toArray(result);
    118.     }
    121.     /**
    122.      * 获取利用反射获取类里面的值和名称
    123.      *
    124.      * @param obj
    125.      * @return
    126.      */
    127.     public static HashMap<String, Object> objectToMap(Object obj) {
    128.         HashMap<String, Object> map = new HashMap<>();
    129.         Class<?> clazz = obj.getClass();
    130.         if (classToMap(obj, map, clazz)) return map;
    131.         return new HashMap<>();
    132.     }
    134.     public static HashMap<String, Object> objectAndSuperClassToMap(Object obj) {
    135.         HashMap<String, Object> map = new HashMap<>();
    136.         Class<?> clazz = obj.getClass();
    137.         Class superclass = obj.getClass().getSuperclass();
    138.         if (classToMap(obj, map, clazz) && classToMap(obj, map, superclass)) {
    139.             return map;
    140.         }
    141.         return new HashMap<>();
    142.     }
    144.     private static boolean classToMap(Object obj, HashMap<String, Object> map, Class<?> clazz) {
    145.         for (Field field : clazz.getDeclaredFields()) {
    146.             field.setAccessible(true);
    147.             String fieldName = field.getName();
    148.             Object value;
    149.             try {
    150.                 value = field.get(obj);
    151.             } catch (IllegalAccessException e) {
    152.                 return false;
    153.             }
    154.             map.put(fieldName, value);
    155.         }
    156.         return true;
    157.     }
    160.     public static <T> T mapToObject(Map<String, Object> map, Class<?> beanClass) {
    161.         if (map == null)
    162.             return null;
    163.         Object obj = null;
    164.         try {
    165.             obj = beanClass.newInstance();
    166.             BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
    167.             PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
    168.             for (PropertyDescriptor property : propertyDescriptors) {
    169.                 Method setter = property.getWriteMethod();
    170.                 if (setter != null) {
    171.                     setter.invoke(obj, map.get(property.getName()));
    172.                 }
    173.             }
    174.         } catch (Exception e) {
    175.             e.printStackTrace();
    176.         }
    177.         return (T) obj;
    178.     }
    179. }