Java里的json工具类（fastjson、Jackson（即ObjectMapper）、Gson）的使用

你的名字 2023-07-05 10:04 16阅读 0赞

# Java里的json工具类（fastjson、Jackson（即ObjectMapper）、Gson）的使用 #

# 说明 #

本文探讨 JSON 的工具类：Fastjson、Jackson（ObjectMapper）、Gson

*  Fastjson：这是阿里巴巴的json工具类
 *  Jackson：这是spring框架自带的（就是那个ObjectMapper类）
 *  Gson：是谷歌的工具类

本文给出了通用的JsonUtil类，分别用这三种实现。分别是`FastJsonUtil.java`、`JacksonUtil.java`、`GsonUtil.java`

要使用这3种json工具，分别需要引入（要用哪个引入哪个）

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.62</version>
    </dependency>

<dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.8.6</version>
    </dependency>

在使用上，常用的特性的差异有

*  null值的字段要不要展示出来
 *  时间类型，格式化成json字符串，展示成时间戳的long形式还是yyyy-MM-dd HH:mm:ss
 *  是否要出现$ref的引用（格式化的时候）
 *  格式化出错的时候抛不抛异常
 *  是否提供pretty格式?
 *  json字符串出现了新字段，在转成对应的类，这个类没有这个字段，要不要抛出异常

### 附录 ###

##### FastJsonUtil #####

package com.wyf.test.jsonutil.fastjson;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.fastjson.serializer.SerializeConfig;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** * @author Stone * @version V1.0.0 * @date 2020/2/12 */
    public class FastJsonUtil { 
    
    
        /** * 将对象转为JSON字符串 * * @param obj 被转的对象 * @param dateFormat 日期格式，当传null或空串时，则被格式化为时间戳，否则返回指定的格式。例子：yyyy-MM-dd HH:mm:ss（不合法的日期格式会格式化出错） * @param ignoreNull 是否忽略null字段。true时，且当字段的值是null，则不输出该字段 * @param noRef 是否不转换成ref。例如false，当字段间是相同的引用之时，则将出现$ref之类的符号替代冗余的值 * @param pretty 是否格式化JSON字符串以便有更好的可读性 * @return JSON字符串，出异常时抛出 */
        public static String toJSONString0(Object obj,
                                           String dateFormat,
                                           boolean ignoreNull,
                                           boolean noRef,
                                           boolean pretty) { 
            try { 
                List<SerializerFeature> featureList = new ArrayList<>();
    
                // 当传null时，则返回默认的时间戳，否则则返回指定的格式
                if (dateFormat != null && dateFormat.length() > 0) { 
                    featureList.add(SerializerFeature.WriteDateUseDateFormat);
                }
                if (!ignoreNull) { 
                    // 当字段的值是null时，依然出现这个字段，即不忽略
                    featureList.add(SerializerFeature.WriteMapNullValue);
                }
                if (noRef) { 
                    featureList.add(SerializerFeature.DisableCircularReferenceDetect);
                }
                if (pretty) { 
                    featureList.add(SerializerFeature.PrettyFormat);
                }
    
                // 当List类型的值是null时，返回[]
                // featureList.add(SerializerFeature.WriteNullListAsEmpty);
                // 当String类型的值是null时，返回""
                // featureList.add(SerializerFeature.WriteNullStringAsEmpty);
                // 当Number类型（指Integer、Long等数字类型）的值是null时，返回0
                // featureList.add(SerializerFeature.WriteNullNumberAsZero);
                // 当Boolean类型的值是null时，返回false
                // featureList.add(SerializerFeature.WriteNullBooleanAsFalse);
    
                SerializerFeature[] featureArr = featureList.toArray(new SerializerFeature[featureList.size()]);
                return JSONObject.toJSONString(obj, SerializeConfig.globalInstance, null, dateFormat,
                        JSON.DEFAULT_GENERATE_FEATURE, featureArr);
            } catch (Exception e) { 
                throw new RuntimeException("Convert object to JSON string, error[" + obj + "]", e);
            }
        }
    
        /** * 将对象转为JSON字符串。 * 日期转为特别的格式，不忽略null值的字段，不格式化JSON字符串 * * @param obj 被转换的对象 * @return JSON字符串，发送异常时抛出 */
        public static String toJSONString(Object obj) { 
            return toJSONString0(obj, "yyyy-MM-dd HH:mm:ss", false, true, false);
        }
    
        /** * 将对象转为JSON字符串。不抛出异常，专用于日志打印 * * @param obj 被转换的对象 * @return JSON字符串，出异常时返回null */
        public static String toJSONStringNoThrows(Object obj) { 
            try { 
                return toJSONString0(obj, "yyyy-MM-dd HH:mm:ss", false, true, false);
            } catch (Exception e) { 
                logError(e);
                return null;
            }
        }
    
        /** * 解析JSON字符串成为一个Object，结果可能是JSONArray(多个)或JSONObject(单个) * （该方法可用于对json字符串不知道是对象还是列表的时候之用） * （假设json字符串多了某个字段，可能是新加上去的，显然转换成JSONEntity会有这个字段） * * @param jsonStr 要解析的JSON字符串 * @return 返回JSONEntity，当jsonArrayFlag 为true，表示它是 JSONArray，否则是JSONObject */
        public static JSONEntity parseJSONStr2JSONEntity(String jsonStr) { 
            try { 
                Object value = JSON.parse(jsonStr);
                boolean jsonArrayFlag = false;
                if (value instanceof JSONArray) { 
                    jsonArrayFlag = true;
                }
                return new JSONEntity(jsonArrayFlag, value);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
        /** * 字符串转为JSON对象,注意数组类型会抛异常[{name:\"Stone\"}] * （假设json字符串多了某个字段，可能是新加上去的，显然转换成JSONObject时会有这个字段，因为JSONObject就相当于map） * * @param jsonStr 传入的JSON字串 * @return 返回转换结果。传入的JSON字串必须是对象而非数组，否则会抛出异常 * @author Stone */
        public static JSONObject parseJSONStr2JSONObject(String jsonStr) { 
            try { 
                return (JSONObject) JSONObject.parse(jsonStr);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
        /** * 字符串转为JSON数组,注意对象类型,非数组的会抛异常{name:\"Stone\"} * （假设json字符串多了某个字段，可能是新加上去的，显然转换成JSONArray时，其元素会有这个字段，因为JSONArray的元素JSONObject就相当于map） * * @param jsonStr 传入的JSON字串 * @return 返回转换结果。当传入的JSON字串是非数组形式时，会抛出异常 * @author Stone */
        public static JSONArray parseJSONStr2JSONArray(String jsonStr) { 
            try { 
                return (JSONArray) JSONArray.parse(jsonStr);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
        /** * 字符串转为某个类 * （日期字段不管是时间戳形式还是yyyy-MM-dd HH:mm:ss的形式都能成功转换） * （假设json字符串多了某个字段，可能是新加上去的，T类没有，转换成T对象的时候，不会抛出异常） * * @param jsonStr 传入的JSON字串 * @param clazz 转为什么类型 * @return 返回转换结果。当传入的JSON字串是数组形式时，会抛出异常 * @author Stone */
        public static <T> T parseJSONStr2T(String jsonStr, Class<T> clazz) { 
            try { 
                return JSONObject.parseObject(jsonStr, clazz);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
        /** * 字符串转为某个类的列表 * （日期字段不管是时间戳形式还是yyyy-MM-dd HH:mm:ss的形式都能成功转换） * （假设json字符串多了某个字段，可能是新加上去的，T类没有，转换成T对象的时候，不会抛出异常） * * @param jsonStr 传入的JSON字串 * @param clazz List里装的元素的类型 * @return 返回转换结果。当传入的JSON字串是非数组的形式时会抛出异常 * @author Stone */
        public static <T> List<T> parseJSONStr2TList(String jsonStr, Class<T> clazz) { 
            try { 
                return JSONObject.parseArray(jsonStr, clazz);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
        public static class JSONEntity { 
            public JSONEntity() { 
            }
    
            public JSONEntity(boolean jsonArrayFlag, Object value) { 
                this.jsonArrayFlag = jsonArrayFlag;
                this.value = value;
            }
    
            private boolean jsonArrayFlag;
            private Object value;
    
            public boolean getJsonArrayFlag() { 
                return jsonArrayFlag;
            }
    
            public Object getValue() { 
                return value;
            }
    
            @Override
            public String toString() { 
                return "JSONEntity{" +
                        "jsonArrayFlag=" + jsonArrayFlag +
                        ", value=" + value +
                        '}';
            }
        }
    
        private static void logError(Exception e) { 
            e.printStackTrace();
        }
    }

##### JacksonUtil #####

package com.wyf.test.jsonutil.jackson;
    
    import com.fasterxml.jackson.annotation.JsonInclude;
    import com.fasterxml.jackson.databind.DeserializationFeature;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.SerializationFeature;
    import com.fasterxml.jackson.databind.type.CollectionType;
    
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    /** * @author Stone * @version V1.0.0 * @date 2020/2/12 */
    public class JacksonUtil { 
        /** * 是线程安全的，详细参考文档 */
        private static ObjectMapper objectMapper = new ObjectMapper();
    
        static { 
            // 转换为格式化的json
            // objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
    
            // 如果json字符串中有新增的字段，但实体类中不存在的该字段，不报错。默认true
            objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    
            // 日期格式指定格式（TODO 疑问：SimpleDateFormat 是线程不安全的，都用同一个，不会不安全吗?）
            objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        }
    
        /** * 将对象转为JSON字符串 * * @param obj 被转的对象 * @param dateFormat 日期格式，当传null或空串时，则被格式化为时间戳，否则返回指定的格式。例子：yyyy-MM-dd HH:mm:ss（不合法的日期格式会格式化出错） * @param ignoreNull 是否忽略null字段。true时，且当字段的值是null，则不输出该字段 * @param pretty 是否格式化JSON字符串以便有更好的可读性 * @return JSON字符串，出异常时抛出 */
        public static String toJSONString0(Object obj,
                                           String dateFormat,
                                           boolean ignoreNull,
                                           boolean pretty) { 
            try { 
                // 获取ObjectMapper，这里每次都获取一个新的，因为传入的配置可能每次都不一样
                ObjectMapper objectMapper = getObjectMapper(dateFormat, ignoreNull, pretty, true);
    
                return objectMapper.writeValueAsString(obj);
            } catch (Exception e) { 
                throw new RuntimeException("Convert object to JSON string, error[" + obj + "]", e);
            }
        }
    
        /** * 获取ObjectMapper。其本身是线程安全的，可以作为成员变量，但传入的参数不可能每次都一样，所以不使用成员变量。 * * @param dateFormat 日期格式，传null或空串则不设置 * @param ignoreNull 是否忽略字段值是null的字段 * @param pretty 是否格式化 * @param compatNewProps 是否兼容。当json字符串新增了字段，在转化为某个类，这个类没有该字段，不兼容时将抛出异常。 * @return */
        private static ObjectMapper getObjectMapper(String dateFormat,
                                                    boolean ignoreNull,
                                                    boolean pretty,
                                                    boolean compatNewProps) { 
    
            ObjectMapper objectMapper = new ObjectMapper();
    
            if (dateFormat != null && dateFormat.length() > 0) { 
                objectMapper.setDateFormat(new SimpleDateFormat(dateFormat));
            }
    
            // ObjectMapper 默认不忽略字段值是null的字段
            if (ignoreNull) { 
                objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
            }
            if (pretty) { 
                objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
            }
    
            if (compatNewProps) { 
                objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
            }
    
            // ObjectMapper 默认不会打印出$ref的值。找了一下没找到ObjectMapper对此的配置，于是讲究不提供该配置。
            // 实际上像 Fastjson 默认会输出$ref 几乎是毫无用处的（除了节省文本长度）
            return objectMapper;
        }
    
        /** * 将对象转为JSON字符串。 * 日期转为非时间戳的格式，不忽略null值的字段，不格式化JSON字符串 * * @param obj 被转的对象 * @return JSON字符串，出异常时抛出 */
        public static String toJSONString(Object obj) { 
            return toJSONString0(obj, "yyyy-MM-dd HH:mm:ss", false, false);
        }
    
        /** * 将对象转为JSON字符串。不抛出异常，专用于日志打印 * * @param obj 被转的对象 * @return JSON字符串，出异常时返回null */
        public static String toJSONStringNoThrows(Object obj) { 
            try { 
                return toJSONString0(obj, "yyyy-MM-dd HH:mm:ss", false, false);
            } catch (Exception e) { 
                logError(e);
                return null;
            }
        }
    
        /** * 传入JSON字符串，不管是对象和列表，都能兼容的方法 * TODO ObjectMapper 的API似乎没有Fastjson的那样，可以不事先了要转换的json字符串是对象还是列表统一一个api转。ObjectMapper似乎只能了解清楚后使用对应的api，否则会转换抛出异常 * * @param jsonStr * @return */
        public static JSONEntity parseJSONStr2JSONEntity(String jsonStr) { 
            throw new RuntimeException("Jackson api not support this feature!");
        }
    
        /** * 字符串转为MAP * （假设json字符串多了某个字段，可能是新加上去的，显然转换后会有这个字段） * * @param jsonStr 传入的JSON字串 * //@param dateFormat 解析为map的时候，日期格式是无意义的，因为根本就不知道json字符串的字段要用什么类型去承载 * @return 转换失败则抛出异常 */
        public static Map<String, Object> parseJSONStr2Map(String jsonStr) { 
            try { 
                // 对于json字符串新增的字段，由于返回的是map，不管 compatNewProps 设置成什么值都不会抛出异常
                ObjectMapper objectMapper = getObjectMapper(null, false, false, true);
                return objectMapper.readValue(jsonStr, Map.class);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
        /** * 字符串转为MAP列表 * （假设json字符串多了某个字段，可能是新加上去的，显然转换后会有这个字段） * * @param jsonStr 传入的JSON字串 * //@param dateFormat 解析为map的时候，日期格式是无意义的，因为根本就不知道json字符串的字段要用什么类型去承载 * @return 转换失败则抛出异常 */
        public static List<Map<String, Object>> parseJSONStr2MapList(String jsonStr) { 
            try { 
                // 对于json字符串新增的字段，由于返回的是map，不管 compatNewProps 设置成什么值都不会抛出异常
                ObjectMapper objectMapper = getObjectMapper(null, false, false, true);
                CollectionType listType = objectMapper.getTypeFactory().constructCollectionType(ArrayList.class, Map.class);
                return objectMapper.readValue(jsonStr, listType);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
    
        /** * json 字符串转成某个类 * （假设json字符串多了某个字段，可能是新加上去的，T类没有，转换成T对象的时候，不会抛出异常） * * @param jsonStr 传入的JSON字串 * @param clazz 转为什么类型 * @param dateFormat 日期格式，传null或空串则不设置，不设置时默认格式化时间戳。当无法格式化的时候抛出异常 * @param <T> 类型 * @return 转换失败则抛出异常 */
        public static <T> T parseJSONStr2T(String jsonStr, Class<T> clazz, String dateFormat) { 
            try { 
                ObjectMapper objectMapper = getObjectMapper(dateFormat, false, false, true);
                return objectMapper.readValue(jsonStr, clazz);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
        /** * json 字符串转成某个类的列表 * * @param jsonStr 传入的JSON字串 * @param clazz 转为什么类型 * @param dateFormat 日期格式，传null或空串则不设置，不设置时默认格式化时间戳。当无法格式化的时候抛出异常 * @param <T> 类型 * @return 转换失败则抛出异常 */
        public static <T> List<T> parseJSONStr2TList(String jsonStr, Class<T> clazz, String dateFormat) { 
            try { 
                ObjectMapper objectMapper = getObjectMapper(dateFormat, false, false, true);
                CollectionType listType = objectMapper.getTypeFactory().constructCollectionType(ArrayList.class, clazz);
                return objectMapper.readValue(jsonStr, listType);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
    
        public static class JSONEntity { 
            public JSONEntity() { 
            }
    
            public JSONEntity(boolean jsonArrayFlag, Object value) { 
                this.jsonArrayFlag = jsonArrayFlag;
                this.value = value;
            }
    
            private boolean jsonArrayFlag;
            private Object value;
    
            public boolean getJsonArrayFlag() { 
                return jsonArrayFlag;
            }
    
            public Object getValue() { 
                return value;
            }
    
            @Override
            public String toString() { 
                return "JSONEntity{" +
                        "jsonArrayFlag=" + jsonArrayFlag +
                        ", value=" + value +
                        '}';
            }
        }
    
        private static void logError(Exception e) { 
            e.printStackTrace();
        }
    }

##### GsonUtil #####

package com.wyf.test.jsonutil.gson;
    
    import com.google.gson.*;
    import com.google.gson.reflect.TypeToken;
    import com.wyf.test.jsonutil.jackson.JacksonUtil;
    
    import java.lang.reflect.Type;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    import java.util.Map;
    
    /** * @author Stone * @version V1.0.0 * @date 2020/2/13 */
    public class GsonUtil { 
        /** * 是线程安全的，详细参考文档 */
        private static Gson gson = new Gson();
    
    
        /** * 将对象转为JSON字符串 * * @param obj 被转的对象 * @param dateFormat 日期格式，当传null或空串时，则被格式化为时间戳，否则返回指定的格式。例子：yyyy-MM-dd HH:mm:ss（不合法的日期格式会格式化出错） * @param ignoreNull 是否忽略null字段。true时，且当字段的值是null，则不输出该字段 * @param pretty 是否格式化JSON字符串以便有更好的可读性 * @return JSON字符串，出异常时抛出 */
        public static String toJSONString0(Object obj,
                                           String dateFormat,
                                           boolean ignoreNull,
                                           boolean pretty) { 
            try { 
                return getGson(dateFormat, ignoreNull, pretty).toJson(obj);
            } catch (Exception e) { 
                throw new RuntimeException("Convert object to JSON string, error[" + obj + "]", e);
            }
        }
    
        /** * 获取ObjectMapper。其本身是线程安全的，可以作为成员变量，但传入的参数不可能每次都一样，所以不使用成员变量。 * （获取的Gson，在解析JSON字符串的时候，若字符串新增了目标类未知的字段，不报错，也就是兼容的。 * @param dateFormat 日期格式，传null或空串则不设置 * @param ignoreNull 是否忽略字段值是null的字段 * @param pretty 是否格式化 //* @param compatNewProps 是否兼容。当json字符串新增了字段，在转化为某个类，这个类没有该字段，不兼容时将抛出异常。【找不到Gson中这个开关，默认是兼容的】 * @return */
        private static Gson getGson(String dateFormat,
                                    boolean ignoreNull,
                                    boolean pretty) { 
            GsonBuilder gsonBuilder = new GsonBuilder();
    
            // 默认序列化的格式是 Feb 13, 2020 11:54:55 AM，如果不指定形式，改成序列化成时间戳形式
            if (dateFormat != null && dateFormat.length() > 0) { 
                gsonBuilder.setDateFormat(dateFormat);
            } else { 
                // 转json字符串，日期格式使用时间戳
                gsonBuilder.registerTypeAdapter(Date.class, new JsonSerializer<Date>() { 
                    @Override
                    public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) { 
                        return new JsonPrimitive(src.getTime());
                    }
                });
    
                // json字符串转对象，日期格式使用时间戳的输入
                gsonBuilder.registerTypeAdapter(Date.class, new JsonDeserializer<Date>() { 
                    @Override
                    public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException { 
                        return new Date(json.getAsJsonPrimitive().getAsLong());
                    }
                });
            }
    
            // 默认忽略所有null值字段
            if (!ignoreNull) { 
                gsonBuilder.serializeNulls();
            }
            // 默认不格式化
            if (pretty) { 
                gsonBuilder.setPrettyPrinting();
            }
    
            // Gson 默认不会打印出$ref的值。找了一下没找到Gson对此的配置，于是讲究不提供该配置。
            // 实际上像 Fastjson 默认会输出$ref 几乎是毫无用处的（除了节省文本长度）
            return gsonBuilder.create();
        }
    
        /** * 将对象转为JSON字符串。 * 日期转为非时间戳的格式，不忽略null值的字段，不格式化JSON字符串 * * @param obj 被转的对象 * @return JSON字符串，出异常时抛出 */
        public static String toJSONString(Object obj) { 
            return toJSONString0(obj, "yyyy-MM-dd HH:mm:ss", false, false);
        }
    
        /** * 将对象转为JSON字符串。不抛出异常，专用于日志打印 * * @param obj 被转的对象 * @return JSON字符串，出异常时返回null */
        public static String toJSONStringNoThrows(Object obj) { 
            try { 
                return toJSONString0(obj, "yyyy-MM-dd HH:mm:ss", false, false);
            } catch (Exception e) { 
                logError(e);
                return null;
            }
        }
    
        /** * 传入JSON字符串，不管是对象和列表，都能兼容的方法 * TODO ObjectMapper 的API似乎没有Fastjson的那样，可以不事先了要转换的json字符串是对象还是列表统一一个api转。ObjectMapper似乎只能了解清楚后使用对应的api，否则会转换抛出异常 * * @param jsonStr * @return */
        public static JacksonUtil.JSONEntity parseJSONStr2JSONEntity(String jsonStr) { 
            throw new RuntimeException("Jackson api not support this feature!");
        }
    
        public static <T> T parseJSONStr2T(String jsonStr, Class<T> clazz, String dateFormat) { 
            try { 
                Gson gson = getGson(dateFormat, false, false);
                return gson.fromJson(jsonStr, clazz);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
        /** * json 字符串转成某个类的列表 * * @param jsonStr 传入的JSON字串 * @param clazz 转为什么类型 * @param dateFormat 日期格式，传null或空串则不设置，不设置时默认格式化时间戳。当无法格式化的时候抛出异常 * @param <T> 类型 * @return 转换失败则抛出异常 */
        public static <T> List<T> parseJSONStr2TList(String jsonStr, Class<T> clazz, String dateFormat) { 
            try { 
                Gson gson = getGson(dateFormat, false, false);
                Type listType = TypeToken.getParameterized(ArrayList.class, clazz).getType();
                return gson.fromJson(jsonStr, listType);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
        /** * 字符串转为MAP * （假设json字符串多了某个字段，可能是新加上去的，显然转换后会有这个字段） * * @param jsonStr 传入的JSON字串 * //@param dateFormat 解析为map的时候，日期格式是无意义的，因为根本就不知道json字符串的字段要用什么类型去承载 * @return 转换失败则抛出异常 */
        public static Map<String, Object> parseJSONStr2Map(String jsonStr) { 
            try { 
                // 对于json字符串新增的字段，由于返回的是map，不管 compatNewProps 设置成什么值都不会抛出异常
                Gson gson = getGson(null, false, false);
                return gson.fromJson(jsonStr, Map.class);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
        /** * 字符串转为MAP列表 * （假设json字符串多了某个字段，可能是新加上去的，显然转换后会有这个字段） * * @param jsonStr 传入的JSON字串 * //@param dateFormat 解析为map的时候，日期格式是无意义的，因为根本就不知道json字符串的字段要用什么类型去承载 * @return 转换失败则抛出异常 */
        public static List<Map<String, Object>> parseJSONStr2MapList(String jsonStr) { 
            try { 
                // 对于json字符串新增的字段，由于返回的是map，不管 compatNewProps 设置成什么值都不会抛出异常
                Gson gson = getGson(null, false, false);
                Type listType = TypeToken.getParameterized(ArrayList.class, Map.class).getType();
                return gson.fromJson(jsonStr, listType);
            } catch (Exception e) { 
                throw new RuntimeException("Invalid jsonStr,parse error:" + jsonStr, e);
            }
        }
    
        public static class JSONEntity { 
            public JSONEntity() { 
            }
    
            public JSONEntity(boolean jsonArrayFlag, Object value) { 
                this.jsonArrayFlag = jsonArrayFlag;
                this.value = value;
            }
    
            private boolean jsonArrayFlag;
            private Object value;
    
            public boolean getJsonArrayFlag() { 
                return jsonArrayFlag;
            }
    
            public Object getValue() { 
                return value;
            }
    
            @Override
            public String toString() { 
                return "JSONEntity{" +
                        "jsonArrayFlag=" + jsonArrayFlag +
                        ", value=" + value +
                        '}';
            }
        }
    
        private static void logError(Exception e) { 
            e.printStackTrace();
        }
    }