类型转换工具类

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.util.CollectionUtils;

import java.lang.reflect.Field;
import java.util.*;

@Slf4j
public class PojoTransformUtil {


    /**
     * 复制list数组
     * @param list
     * @param targetClass
     * @param <T>
     * @return
     */
    public static <T> List<T> copyList(List<?> list, Class<T> targetClass) {
        List<T> targetList = new ArrayList<>();
        if(CollectionUtils.isEmpty(list)) {
            return targetList;
        }
        for(Object obj : list) {
            T target = copyObject(obj, targetClass);

            if(target != null) {
                targetList.add(target);
            }
        }
        return targetList;
    }

    /**
     * 复制对象
     * @param obj
     * @param targetClass
     * @param <T>
     * @return
     */
    public static <T> T copyObject(Object obj, Class<T> targetClass) {
        if(obj == null) {
            return null;
        }

        T target = null;
        try {
            target = targetClass.newInstance();
        }  catch (IllegalAccessException e) {
            log.error("[POJO] --- 相互转换过程出现无法实例化对象：source=" + obj.getClass().getName() + ", Target=" + targetClass.getName());
        } catch (InstantiationException e) {
            log.error("[POJO] --- 相互转换过程出现非法访问：source=" + obj.getClass().getName() + ", Target=" + targetClass.getName());
        }
        if(target != null) {
            BeanUtils.copyProperties(obj, target);
        }
        return target;
    }

    /**
     * 复制list数组
     * @param list
     * @param targetClass
     * @param <T>
     * @return
     */
    public static <T> List<Object> transferListToObj(List<?> list, Class<T> targetClass) {
        List<Object> resultObjList = new ArrayList<>(list.size());
        if(CollectionUtils.isEmpty(list)) {
            return resultObjList;
        }
        for(Object obj : list) {
            T target = copyObject(obj, targetClass);

            if(target != null) {
                resultObjList.add(JsonMapperUtil.toJson(target));
            }
        }
        return resultObjList;
    }

    /**
     * 对象转map
     *
     * @param obj
     * @return
     */
    public static Map<String, Object> objToMap(Object obj, boolean isNeedSuper) {
        Map<String, Object> map = new HashMap<>();
        // 获取f对象对应类中的所有属性域
        Field[] fields = obj.getClass().getDeclaredFields();
        if (isNeedSuper){
            Field[] fieldSupers = obj.getClass().getSuperclass().getDeclaredFields();
            fields = (Field[]) ArrayUtils.addAll(fields, fieldSupers);
        }
        for (int i = 0, len = fields.length; i < len; i++) {
            String varName = fields[i].getName();
            try {
                // 获取原来的访问控制权限
                boolean accessFlag = fields[i].isAccessible();
                // 修改访问控制权限
                fields[i].setAccessible(true);
                // 获取在对象f中属性fields[i]对应的对象中的变量
                Object o = fields[i].get(obj);
                if (o != null) {
                    map.put(varName, o);
                }
                // 恢复访问控制权限
                fields[i].setAccessible(accessFlag);
            } catch (IllegalArgumentException e) {
                log.error("[PojoTransformUtil] --- objToMap, IllegalArgumentException", e);
            } catch (IllegalAccessException e) {
                log.error("[PojoTransformUtil] --- objToMap, IllegalAccessException", e);
            }
        }
        return map;
    }

    /**
     * 把一个字符串转换成bean对象
     * @param str
     * @param <T>
     * @return
     */
    public static <T> T stringToBean(String str, Class<T> clazz) {
            if(str == null || str.length() <= 0 || clazz == null) {
                return null;
            }
            if(clazz == int.class || clazz == Integer.class) {
                return (T)Integer.valueOf(str);
            }else if(clazz == String.class) {
                return (T)str;
            }else if(clazz == long.class || clazz == Long.class) {
                return  (T)Long.valueOf(str);
            }else {
                return JSON.toJavaObject(JSON.parseObject(str), clazz);
            }
    }
}