反射應用，將類中的屬性 所有轉換成String類型的

萌新今天上手app了.. 有點小激動，可是app大佬們要求返回的全部參數都是String 類型的，就寫了一個奇葩的工具類，自測了一下還能夠用，一聽老大說出了BUG責任自負，果斷扔了。。不過正好練練反射，還蠻好的~

/**
 * 反射處理Bean 獲取對象的屬性值
 *
 * @author hao.wei
 * @date 2018/7/12
 */
public class ReflexObjectUtil {
    private static List<Object> packagingClass = new ArrayList<>();
    static {
        packagingClass.add(Byte.class);
        packagingClass.add(Short.class);
        packagingClass.add(Integer.class);
        packagingClass.add(Long.class);
        packagingClass.add(Float.class);
        packagingClass.add(Double.class);
        packagingClass.add(Character.class);
        packagingClass.add(Boolean.class);
        packagingClass.add(String.class);
    }
    /**
     * 將指定對象的屬性 所有轉換成 目標對象的String類型
     *
     * @param sourceObj 來源對象
     * @param desObj 目標對象
     * @return
     */
    public static Object sourceObjFieldToDesObjFieldStr(Object sourceObj, Object desObj) {
        // 獲取來源類對象
        Class sourceObjClass = sourceObj.getClass();
        /* 來源類中的全部屬性集合 */
        Field[] sourceObjClassDeclaredFields = sourceObjClass.getDeclaredFields();

        // 獲取目標類對象
        Class desObjClass = desObj.getClass();
        /* 目標類中的全部屬性集合 */
        Field[] desObjClassDeclaredFields = desObjClass.getDeclaredFields();

        for (int i = 0; i < sourceObjClassDeclaredFields.length; i++) {
            Field sourceObjClassDeclaredField = sourceObjClassDeclaredFields[i];
            // 設置屬性可訪問
            sourceObjClassDeclaredField.setAccessible(true);
            // 獲取來源類的屬性值
            Object sourceVal = null;
            try {
                sourceVal = sourceObjClassDeclaredField.get(sourceObj);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            if (null !=sourceVal) {
                for (int j = 0; j < desObjClassDeclaredFields.length; j++) {
                    try {
                        Field desObjClassDeclaredField = desObjClassDeclaredFields[j];
                        // 設置屬性可訪問
                        desObjClassDeclaredField.setAccessible(true);
                        // 屬性名相同
                        if (desObjClassDeclaredField.getName().equals(sourceObjClassDeclaredField.getName())) {
                            // 獲取來源類屬性的對象類型
                            Class<?> type = sourceObjClassDeclaredField.getType();
                            // 若是是基本類型/包裝類型/BigDecimal 直接轉換爲 String
                            if (type.isPrimitive() || packagingClass.contains(type)|| type.equals(BigDecimal.class)) {
                                sourceVal = String.valueOf(sourceVal);
                            } else if (type.equals(Date.class)) {
                                Date date = (Date) sourceVal;
                                sourceVal = ThreadSafeDateUtil.format(date, "yyyy-MM-dd HH:mm:ss");
                            }
                            // 設置目標類的屬性值
                            desObjClassDeclaredField.set(desObj, sourceVal);
                        }
                    } catch (IllegalArgumentException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        return desObj;
    }

    /**
     * 單個對象的某個鍵的值
     *
     * @param obj 對象
     * @param key 鍵
     * @return Object 鍵在對象中所對應得值 沒有查到時返回空字符串
     */
    public static Object getValueByKey(Object obj, String key) {
        // 獲得類對象
        Class userCla = (Class) obj.getClass();
        /* 獲得類中的全部屬性集合 */
        Field[] fs = userCla.getDeclaredFields();
        for (int i = 0; i < fs.length; i++) {
            Field f = fs[i];
            f.setAccessible(true); // 設置些屬性是能夠訪問的
            try {

                if (f.getName().endsWith(key)) {
                    System.out.println("單個對象的某個鍵的值==反射==" + f.get(obj));
                    return f.get(obj);
                }
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        // 沒有查到時返回空字符串
        return "";
    }

    /**
     * 多個（列表）對象的全部鍵值
     *
     * @param object
     * @return
     */
    public static List<Map<String, Object>> getKeysAndValues(List<Object> object) {
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        for (Object obj : object) {
            Class userCla;
            // 獲得類對象
            userCla = (Class) obj.getClass();
            /* 獲得類中的全部屬性集合 */
            Field[] fs = userCla.getDeclaredFields();
            Map<String, Object> listChild = new HashMap<String, Object>();
            for (int i = 0; i < fs.length; i++) {
                Field f = fs[i];
                f.setAccessible(true); // 設置些屬性是能夠訪問的
                Object val = new Object();
                try {
                    val = f.get(obj);
                    // 獲得此屬性的值
                    listChild.put(f.getName(), val);// 設置鍵值
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
            list.add(listChild);// 將map加入到list集合中
        }
        System.out.println("多個（列表）對象的全部鍵值====" + list.toString());
        return list;
    }

    /**
     * 多個（列表）對象的某個鍵的值
     *
     * @param object
     * @param key
     * @return
     */
    public static List<Object> getValuesByKey(List<Object> object, String key) {
        List<Object> list = new ArrayList<Object>();
        for (Object obj : object) {
            // 獲得類對象
            Class userCla = (Class) obj.getClass();
            /* 獲得類中的全部屬性集合 */
            Field[] fs = userCla.getDeclaredFields();
            for (int i = 0; i < fs.length; i++) {
                Field f = fs[i];
                f.setAccessible(true); // 設置些屬性是能夠訪問的
                try {
                    if (f.getName().endsWith(key)) {
                        list.add(f.get(obj));
                    }
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("多個（列表）對象的某個鍵的值列表====" + list.toString());
        return list;
    }
}