类字段反射使用工具类

• 获取类field对应的值
• 判断字段名称是否存在
• 按字段对对象列表进行排序(内存分页排序场景)

public class ReflexUtils {

    /**
     * 获取字段对应值
     * @param obj
     * @param fieldName
     * @param <T>
     * @return
     */
    public static <T> Object getByFieldName(T obj, String fieldName) {
        try {
            //拼接get方法
            String getMethodName = "get".concat(fieldName.substring(0, 1).toUpperCase()).concat(fieldName.substring(1));
            Method method = obj.getClass().getMethod(getMethodName);
            return method.invoke(obj);
        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
            //log.error("error: ", e);
        }
        return null;
    }

    /**
     * 判断字段是否存在
     * @param fieldName
     * @param clazz
     * @return
     */
    public static boolean hasField(String fieldName, Class<?> clazz) {
        if (!fieldName.isEmpty() && clazz != null) {
            Class<?> cl = clazz;
            List<Field> fields = new ArrayList<>();
            while (cl != Object.class) {
                fields.addAll(Arrays.asList(cl.getDeclaredFields()));
                cl = cl.getSuperclass();
            }

            for (Field field : fields) {
                if (field.getName().equalsIgnoreCase(fieldName)) {
                    return true;
                }
            }

        }
        return false;
    }

    /**
     * 按字段对list进行排序
     * @param list
     * @param orderField
     * @param orderValue
     * @param <T>
     */
    public static<T> void sortedByOrderField(List<T> list, String orderField, String orderValue) {
        Collections.sort(list, (a, b) -> {
            Object aValue = getByFieldName(a, orderField);
            Object bValue = getByFieldName(b, orderField);
            if (aValue == null || bValue == null) {
                int sign = "desc".equalsIgnoreCase(orderValue) ? -1 : 1;

                if (aValue != null) {
                    return sign;
                }
                if (bValue != null) {
                    return -sign;
                }
                return 0;
            }
            String aStr = aValue.toString();
            String bStr = bValue.toString();
            //默认按该字段的字符串排序
            if (aValue instanceof String) {
                if ("desc".equalsIgnoreCase(orderValue)) {
                    return bStr.compareTo(aStr);
                } else {
                    return aStr.compareTo(bStr);
                }
            } else if (aValue instanceof BigDecimal || aValue instanceof Double) {
                if ("desc".equalsIgnoreCase(orderValue)) {
                    return new BigDecimal(bStr).compareTo(new BigDecimal(aStr));
                } else {
                    return new BigDecimal(aStr).compareTo(new BigDecimal(bStr));
                }
        
            }  
            //这里不能这样写,会报告异常# Comparison method violates its general contract!
            //else if (aValue instanceof Integer) {
             //   if ("desc".equalsIgnoreCase(orderValue)) {
            //        return Integer.parseInt(bStr) - Integer.parseInt(aStr) ;
            //    } else {
            //        return Integer.parseInt(aStr) - Integer.parseInt(bStr) ;
            //    }
            //}  else if (aValue instanceof Long) {
            //    if ("desc".equalsIgnoreCase(orderValue)) {
            //        return Long.parseLong(bStr) - Long.parseLong(aStr) > 0L ? 1 : -1;
            //    } else {
            //        return Long.parseLong(aStr) - Long.parseLong(bStr) > 0L ? 1 : -1;
            //    }
            //    //
            //} 
            
            else if (aValue instanceof Integer) {
                if ("desc".equalsIgnoreCase(orderValue)) {
                    return Integer.compare(Integer.parseInt(bStr), Integer.parseInt(aStr));
                } else {
                    return Integer.compare(Integer.parseInt(aStr), Integer.parseInt(bStr));
                }
            }  else if (aValue instanceof Long) {
                if ("desc".equalsIgnoreCase(orderValue)) {
                    return Long.compare(Integer.parseInt(bStr), Integer.parseInt(aStr));
                } else {
                    return Long.compare(Integer.parseInt(aStr), Integer.parseInt(bStr));
                }
            }

            else {
                //其它类型转字符串后排序
                if ("desc".equalsIgnoreCase(orderValue)) {
                    return bStr.compareTo(aStr);
                } else {
                    return aStr.compareTo(bStr);
                }
            }
        });
    }
    
}