数据类型转换工具

public class SafeParserUtil {
    public static final String TRUE_VALUE = "true";
    public static final String FALSE_VALUE = "false";
    public static final String TRUE_INT_VALUE = "1";
    public static final String FALSE_INT_VALUE = "0";

    public SafeParserUtil() {
    }

    public static Integer parseInt(Object value) {
        if (value == null) {
            return null;
        } else {
            String valueStr = value.toString();
            if (StringUtils.isBlank(valueStr)) {
                return null;
            } else {
                if ("true".equals(valueStr)) {
                    valueStr = "1";
                } else if ("false".equals(valueStr)) {
                    valueStr = "0";
                } else if (valueStr.contains(".")) {
                    int index = valueStr.indexOf(".");
                    valueStr = valueStr.substring(0, index);
                }

                return Integer.valueOf(valueStr);
            }
        }
    }

    public static Long parseLong(Object value) {
        if (value == null) {
            return null;
        } else {
            String valueStr = value.toString();
            return StringUtils.isBlank(valueStr) ? null : Long.valueOf(valueStr);
        }
    }

    public static String parseString(Object value) {
        return value == null ? null : value.toString();
    }

    public static Double parseDouble(Object value) {
        if (value == null) {
            return null;
        } else {
            String valueStr = value.toString();
            return StringUtils.isBlank(valueStr) ? null : Double.valueOf(valueStr);
        }
    }

    public static Boolean parseBoolean(Object value) {
        if (value == null) {
            return null;
        } else {
            String valueStr = value.toString();
            return StringUtils.isBlank(valueStr) ? null : Boolean.valueOf(valueStr);
        }
    }

    public static Byte parseByte(Object value) {
        Integer temp = parseInt(value);
        return temp == null ? null : (byte)temp;
    }

    public static Short parseShort(Object value) {
        Integer temp = parseInt(value);
        return temp == null ? null : (short)temp;
    }

    public static Float parseFloat(Object value) {
        if (value == null) {
            return null;
        } else {
            String valueStr = value.toString();
            return StringUtils.isBlank(valueStr) ? null : Float.valueOf(valueStr);
        }
    }
}



/**
 * 数据类型转换工具类.
 */
public class DataTypeConvertUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(DataTypeConvertUtil.class);

    private static Map<String, Method> convertMap = Maps.newHashMap();

    private static Map<String, Class<?>> CONVERT_CLASS_MAP = Maps.newHashMap();

    static {
        try {
            Class cls = SafeParserUtil.class;
            convertMap.put("Int", cls.getMethod("parseInt", Object.class));
            convertMap.put("Long", cls.getMethod("parseLong", Object.class));
            convertMap.put("String", cls.getMethod("parseString", Object.class));
            convertMap.put("Double", cls.getMethod("parseDouble", Object.class));
            convertMap.put("Boolean", cls.getMethod("parseBoolean", Object.class));
            convertMap.put("Byte", cls.getMethod("parseByte", Object.class));
            convertMap.put("Short", cls.getMethod("parseShort", Object.class));
            convertMap.put("Float", cls.getMethod("parseFloat", Object.class));
        } catch (Exception e) {
            LOGGER.error("初始化convertMap失败", e);
        }

        try {
            CONVERT_CLASS_MAP.put("Map", Map.class);
            CONVERT_CLASS_MAP.put("List", List.class);
        } catch (Exception e) {
            LOGGER.error("初始化CONVERT_CLASS_MAP失败", e);
        }
    }

    public static Object convert(Object value, String resultType) throws ActuatorExeException {
        if (value == null) {
            return null;
        }

        Method method = convertMap.get(resultType);
        if (method != null) {
            try {
                return method.invoke(null, value);静态方法可省略对象，直接用null替代，或用clas
            } catch (Exception e) {
                throw new ActuatorExeException(PlatformConstant.CONVERT_ERROR_CODE,
                        "类型转换失败, resultType:%s, value:%s", resultType, value);
            }
        }

        Class<?> clazz = CONVERT_CLASS_MAP.get(resultType);
        if (clazz != null && clazz.isAssignableFrom(value.getClass())) {
            return value;
        }

        throw new ActuatorExeException(PlatformConstant.CONVERT_ERROR_CODE, "不支持指定的类型转换, resultType: " + resultType);
    }
}