数据类型转换工具

た入场券 2022-08-31 05:57 289阅读 0赞

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);
        }
    }