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工具,分别需要引入(要用哪个引入哪个)
<!-- Fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.62</version>
</dependency>
<!-- Jackson,ObjectMapper -->
<!-- Spring 框架自带所需要的Jar,如非spring框架,引入 -->
<!--<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.10.2</version>
</dependency>-->
<!-- Gson -->
<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();
}
}