反射数据转化工具类

/**
 * 反射数据转化工具类
 */
public class ReflectConvertUtil {


    /**
     * 两个有字段相同（字段属性和字段名称）的两个实体类对象，
     * 将相同属性的源类的对象值赋值给目标类对象
     *
     * @param clazz       源类
     * @param obj         源对象
     * @param targetClazz 目标（被赋值）类
     * @param targetObj   目标（被赋值）对象
     */
    public static void convertPojoValue(Class<?> clazz, Object obj, Class<?> targetClazz, Object targetObj) {
        Field[] fields = clazz.getDeclaredFields();
        Field[] targetFields = targetClazz.getDeclaredFields();
        for (Field targetField : targetFields) {
            for (Field field : fields) {
                if (targetField.getType().isAssignableFrom(field.getType()) && StringUtils.equals(targetField.getName(), field.getName())) {
                    Object value = getValue(field.getName(), obj);
                    setValue(targetField.getName(), targetField.getType(), value, targetObj);
                }
            }
        }
    }


    /**
     * 两个有字段相同（字段属性和字段名称）的两个实体类对象，创建出一个目标类对象，
     * 并将相同属性的源类的对象值赋值给目标类对象
     *
     * @param clazz       源类
     * @param obj         源对象
     * @param targetClazz 目标（被赋值）类
     * @param <T>
     * @return
     */
    public static <T> T convertPojoValue(Class<?> clazz, Object obj, Class<T> targetClazz) {
        T targetObj = null;
        try {
            if (null == obj) {
                return targetClazz.newInstance();
            }
            targetObj = targetClazz.newInstance();
            //转化
            convertPojoValue(clazz, obj, targetClazz, targetObj);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return targetObj;
    }


    /**
     * 两个有字段相同（字段属性和字段名称）的两个实体类对象（集合），创建出一个目标类对象，
     * 并将相同属性的源类的对象值赋值给目标类对象（集合）
     *
     * @param clazz
     * @param list
     * @param targetClazz
     * @param <T>
     * @return
     */
    public static <T> List<T> convertListValue(Class<?> clazz, List list, Class<T> targetClazz) {
        List<T> targetList = new ArrayList<T>();
        try {
            for (Object obj : list) {
                T targetObj = convertPojoValue(clazz, obj, targetClazz);
                targetList.add(targetObj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return targetList;
    }


    /**
     * 两个有字段相同（字段属性和字段名称）的两个实体类对象（page），创建出一个目标类对象，
     * 并将相同属性的源类的对象值赋值给目标类对象（page）
     *
     * @param clazz
     * @param page
     * @param targetClazz
     * @param <T>
     * @return
     */
    public static <T> Page<T> convertPageValue(Class<?> clazz, Page page, Class<T> targetClazz) {
        List<Object> targetList = new ArrayList<>(page.getResult().size());
        try {
            for (Object obj : page.getResult()) {
                T targetObj = convertPojoValue(clazz, obj, targetClazz);
                targetList.add(targetObj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        page.getResult().clear();
        page.getResult().addAll(targetList);
        return page;
    }


    /**
     * 给指定的对象的属性赋值
     *
     * @param fieldName
     * @param value
     * @param t
     * @param <T>
     */
    public static <T> void setValue(String fieldName, Class fieldClass, Object value, T t) {
        String setMethodName = "set"
                + fieldName.substring(0, 1).toUpperCase()
                + fieldName.substring(1);
        try {
            Method setMethod = t.getClass().getMethod(setMethodName, new Class[]{fieldClass});
            setMethod.invoke(t, new Object[]{value});
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 获取指定对象的属性的值
     *
     * @param fieldName
     * @param t
     * @param <T>
     * @return
     */
    public static <T> Object getValue(String fieldName, T t) {
        String getMethodName = "get"
                + fieldName.substring(0, 1).toUpperCase()
                + fieldName.substring(1);
        try {
            Method getMethod = t.getClass().getMethod(getMethodName, new Class[]{});
            Object value = getMethod.invoke(t, new Object[]{});
            return value;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


}