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();
}
}
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/135286.html
