泛型与反射封装数据

代码主要用作分页后对分页子数据封装以及Po类转Dto类的封装操作，目的是简化代码提高开发效率：

/**
 * 功能描述: 分页组装工具
 * @return: Pager<T>
 * @auther: 
 * @date: 2019-04-25 
 */
public static<T,S> Pager<T> getPage(Pager<S> poPager, List<T> list){
    if (null == poPager){
        return new Pager<>();
    }
    //poPager作为数据库查询出来的分页数据，需要将数据里的条件去分页子数据使用
    Pager<T> resDtoPager = new Pager<>();
    resDtoPager.setList(list);
    resDtoPager.setCurrentPage(poPager.getCurrentPage());
    resDtoPager.setTotalPage(poPager.getTotalPage());
    resDtoPager.setPageSize(poPager.getPageSize());
    resDtoPager.setTotalCount(poPager.getTotalCount());
    return resDtoPager;
}
/**
 * 功能描述: 对象转换工具，主要是将PO类转DTO类
 * @return: T
 * @auther: 
 * @date: 2019-04-25 
 */
public static<T,S> T getObject(S conversionObj, T receiveObj){
    if (null == conversionObj){
        return receiveObj;
    }
    //获取对象的所有字段集合
    List<Field> conversionField = getFields(conversionObj);
    List<Field> receiveField = getFields(receiveObj);
    conversionField.forEach(conObj ->{
        receiveField.forEach(obj ->{
            if (!"serialVersionUID".equals(conObj.getName())){
                if(conObj.getName().equalsIgnoreCase(obj.getName())){
                    try {
                        //设置private属性可访问
                        conObj.setAccessible(true);
                        obj.setAccessible(true);
                        String type = conObj.getType().toString();
                        Object objs = QueryParamUtils.castType(type,conObj.get(conversionObj));
                        //属性set对象+value
                        obj.set(receiveObj,objs);
                    } catch (IllegalAccessException e) {
                        throw new AppException("Object conversion failed:",e);
                    }
                }
            }
        });
    });
    return receiveObj;
}
/**
 * 功能描述: 拿到对象的所有字段并转化为集合
 * @return: List<Field> 
 * @auther: 
 * @date: 2019-04-25
 */
public static List<Field> getFields(Object obj) {
    //获得子类所有属性
    Field[] sonField = obj.getClass().getDeclaredFields();
    //获得子类继承父类的所有属性,关于父级别如果嵌套层数太多这里可能需要处理，未验证。
    Field[] fatherField = obj.getClass().getSuperclass().getDeclaredFields();
    List<Field> fieldList = Arrays.asList(sonField);
    /**
     * 这个fieldList不是java.util.List，而是一个内部类java.util.Arrays.ArrayList,
     * 且继承AbstractList,但是未实现add和remove方法，只能调用父级别add(int index,E element)
     * 所有需要实例化新集合list
     */
    List<Field> newFieldList = new ArrayList<>(fieldList);
    newFieldList.addAll(Arrays.asList(fatherField));
    return newFieldList;
}

/** 
 * 功能描述: 查询字段类型的转换 查询字段默认转进来的值都是字符串，需要根据PO类型作转换
 * @return: Object 
 * @auther: 
 * @date: 2019-04-25
 */
public static Object castType(String fieldNameType, Object val) {
    if (val == null) {
        return null;
    }
    Object ret;
    String[] str;
    String valStr = String.valueOf(val);
    String simpleTypeName = StringUtils.substringAfterLast("." + fieldNameType, ".").toLowerCase();
    switch (simpleTypeName) {
        /**需要转换的基本类型**/
        case "double":
            ret = Double.parseDouble(valStr);
            break;
        case "float":
            ret = Float.parseFloat(valStr);
            break;
        case "short":
            ret = Short.parseShort(valStr);
            break;
        case "integer":
            ret = Integer.parseInt(valStr);
            break;
        case "int":
            ret = Integer.parseInt(valStr);
            break;
        case "long":
            ret = Long.parseLong(valStr);
            break;
        /**基本类型的数组**/
        case "double[]":
            str = valStr.split(",");
            Double[] doubles = new Double[str.length];
            for (int i = 0; i < str.length; i++) {
                doubles[i] = Double.parseDouble(str[i]);
            }
            ret = doubles;
            break;
        case "float[]":
            str = valStr.split(",");
            Float[] floats = new Float[str.length];
            for (int i = 0; i < str.length; i++) {
                floats[i] = Float.parseFloat(str[i]);
            }
            ret = floats;
            break;
        case "short[]":
            str = valStr.split(",");
            Short[] shorts = new Short[str.length];
            for (int i = 0; i < str.length; i++) {
                shorts[i] = Short.parseShort(str[i]);
            }
            ret = shorts;
            break;
        case "integer[]":
            str = valStr.split(",");
            Integer[] integers = new Integer[str.length];
            for (int i = 0; i < str.length; i++) {
                integers[i] = Integer.parseInt(str[i]);
            }
            ret = integers;
            break;
        case "int[]":
            str = valStr.split(",");
            Integer[] ints = new Integer[str.length];
            for (int i = 0; i < str.length; i++) {
                ints[i] = Integer.parseInt(str[i]);
            }
            ret = ints;
            break;
        case "long[]":
            ret = Long.parseLong(valStr);
            break;
        /** 枚举 暂没实现（生成的po代码，暂时没有枚举型的） **/
        case "bigdecimal":
            ret = new BigDecimal(valStr);
            break;
        case "biginteger":
            ret = new BigInteger(valStr);
            break;
        /**日期时间**/
        case "localdate":
            ret = LocalDate.parse(valStr);
            break;
        case "localtime":
            ret = LocalTime.parse(valStr);
            break;
        case "localdatetime":
            ret = LocalDateTime.parse(valStr);
            break;
        default:
            ret = val;
            break;
    }
    return ret;
}

 

关于获取对象所有属性上面的方法不太好，当时写的比较急没怎么考虑，如下方式比较不错，但是上面让我了解了一个坑所以留下提醒
private static List<Field> getFields(Class clazz){
    List<Field> fieldList = Lists.newArrayList();
    while (clazz != null){
        fieldList.addAll(Arrays.asList(clazz.getDeclaredFields()));
        clazz = clazz.getSuperclass();
    }
    return fieldList;
}

整体下来觉得很好用，简化项目中很多重复代码，但是类型转换还有一些没放入进去。

---

文章是个人成果，转载请注明出处！！！