json字符串的结构是以 key：value格式呈现的，先初始化一个复杂的json字符串，
在一个json字符串里包含json字符串，在包含jsonArray格式的字符串：
1.初始化一个复杂的json字符串：
JSONObject obj = new JSONObject();
JSONObject header = new JSONObject();
header.put("1","one");
header.put("2","two");
header.put("3","three");
obj.put("Header",header);
JSONObject body = new JSONObject();
JSONArray jsonArray = new JSONArray();
JSONObject array1 = new JSONObject();
JSONObject array2 = new JSONObject();
array1.put("array1","array1");
array1.put("array2","array2");
array2.put("array3","ayyay3");
array2.put("array3","array23");
jsonArray.add(array1);
jsonArray.add(array2);
body.put("jsonArray",jsonArray);
body.put("head",header);
obj.put("body",body);初始化的json格式字符串为：
{
"Header":
{"1":"one","2":"two","3":"three"},
"body":
{
"head":{"1":"one","2":"two","3":"three"},
"jsonArray":[{"array2":"array2","array1":"array1"},
{"array3":"array23"}]
}
}2.将这个obj转换成json格式字符串，再尝试取到这个完整的json字符串里面的json格式的value或者jsonArray格式的value以及普通的字符串value：
/转成json格式字符串
String s = JSONObject.toJSONString(obj);
//先想json格式的字符串转成JSONObject
//如果"body"字段的值对应的还是json格式,使用parseObject()直接获取JSONObject
//如果"body"字段对应的JSONObject格式的值中的"head"字段的值也是JSONObject,依旧能获取JSONObject
JSONObject jsonObject = JSONObject.parseObject(s).
getJSONObject("body").getJSONObject("head");
//如果"body"字段对应的JSONObject格式的值中的"jsonArray"字段的值格式为JSONArray
//通过JSONObject的getJSONArray()方法获取
JSONArray jsonArray2 = JSONObject.parseObject(s).
getJSONObject("body").getJSONArray("jsonArray");
3.JsonUtil一套自定义工具类：
import java.util.List;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.json.JsonMapper;
public class JsonUtil {
private static final JsonMapper MAPPER = new JsonMapper();
private static final JsonMapper MAPPER_NON_NULL = new JsonMapper();
static {
// 配置忽略未知属性
MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
MAPPER_NON_NULL.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
// 设置为不含为null的属性
MAPPER_NON_NULL.setSerializationInclusion(Include.NON_NULL);
}
/**
* 将对象转换成json字符串
*
* @param obj 对象数据
* @return json字符串
*/
public static String objToStr(Object obj) {
try {
return MAPPER.writeValueAsString(obj);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
/**
* 将对象转换成json字符串（不含为null的属性）
*
* @param obj 对象数据
* @return json字符串
*/
public static String objToStrNonNull(Object obj) {
try {
return MAPPER_NON_NULL.writeValueAsString(obj);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
/**
* 将对象转换成byte数组
*
* @param obj 对象数据
* @return byte数组
*/
public static byte[] objToBytes(Object obj) {
try {
return MAPPER.writeValueAsBytes(obj);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
/**
* 将对象转换成byte数组（不含为null的属性）
*
* @param obj 对象数据
* @return byte数组
*/
public static byte[] objToBytesNonNull(Object obj) {
try {
return MAPPER_NON_NULL.writeValueAsBytes(obj);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
/**
* 将json字符串转化为普通对象
*
* @param str json字符串数据
* @param cls 对象类型
* @return 转化的普通对象
*/
public static <T> T strToPojo(String str, Class<T> cls) {
if (StringUtils.isBlank(str)) {
return null;
}
try {
return MAPPER.readValue(str, cls);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
/**
* 将json字符串转化为Map对象
*
* @param str json字符串数据
* @return Map对象
*/
@SuppressWarnings("unchecked")
public static <K, V> Map<K, V> strToMap(String str) {
if (StringUtils.isBlank(str)) {
return null;
}
try {
return MAPPER.readValue(str, Map.class);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
/**
* 将json字符串转换成pojo对象list
*
* @param str json字符串数据
* @param cls 对象泛型类型
* @return List 返回对象集合
*/
public static <T> List<T> strToList(String str, Class<T> cls) {
if (StringUtils.isBlank(str)) {
return null;
}
try {
JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, cls);
return MAPPER.readValue(str, javaType);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
/**
* 将json字符串转换成type指定类型的对象
*
* @param <T> 泛型参数
* @param str json字符串
* @param type 对象类型
* @return 转化的对象
* @author chzhou@iflytek.com
* @since 1.7
* @date 2021/8/14 12:49
*/
public static <T> T strToObj(String str, TypeReference<T> type) {
if (StringUtils.isBlank(str)) {
return null;
}
try {
return MAPPER.readValue(str, type);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
}
4.如何将初始化的复杂结构的json字符串通过Map进行获取
json格式字符串转为Map<T,V>,List<Map<T,V>>常见形式
//注意：Map<K,V>的V最好都用Object，用String的话如果要转成这个位置的值是一个Array格式就会报错
Map<String, Object> map = JsonUtil.strToObj(JsonUtil.objToStr(JsonUtil.objToStr(JSONObject.parseObject(s).get("body"))), new TypeReference<Map<String, Object>>() {
});
//获取"jsonArray"对应的值（Object）并转成json字符串格式
//注意这里一定要转成json格式的字符串！！
//因为上一步json格式的字符串使用strToObj后得到Map
//json格式字符串是 {k:v},而转成Map后变成了{k=v}
//所以从map中拿到数据不是最后的字符串还需要继续转换格式的话
//就需要使用JsonUtil的objToStr方式或者JSONObject.toJSONString()
String str = JSONObject.toJSONString(map.get("jsonArray"));
//JSONArray格式的字符串转成List<Map<T,V>>
//注意：List<Map<K,V>>的V最好都用Object,理由同上,这里由于对应的都是字符串，所以可以用String
List<Map<String, String>> maps = JsonUtil.strToObj(str, new TypeReference<List<Map<String, String>>>() {
});
得到的结果是：
1 转成Map<String,Object> map 后：
{head={1=one, 2=two, 3=three}, jsonArray=[{array2=array2, array1=array1}, {array3=array23}]}
2 获取上面的jsonArray的值：
[{array2=array2, array1=array1}, {array3=array23}]
3 使用 JSONObject.toJSONString(map.get("jsonArray")) 转换之后：
[{"array2":"array2","array1":"array1"},{"array3":"array23"}]
4 使用JsonUtil 的strToObj得到的List<Map<String,Object>（这里可以是List<Map<String,String>）：
[{array2=array2, array1=array1}, {array3=array23}
踩坑1：
接收到的返回值response的body为：
{"code":200,"data":" \"{\"code\":\"400\",\"success\":false}\" "}
原本错误方法：
Map<String,Object> resMap = JsonUtil.strToMap(response);
//data是一个json格式，获取data数据转换为Map格式
Map<String,Object> dataMap = JsonUtil.strToMap(res.get("data"));
//再直接获取
dataMap.get("success")错误点： 返回数据的data所对应的字符串里面有多了一对双引号，返回值为“data”：“ “{}” ”
所以通过map获取到的字符串打印为“{}”，而我需要得到的字符串打印为{}；
所以需要去掉首为的双引号，示例：
JSONObject res = JSONObject.parseObject(response);
int length =res.getString("data").length;
Map<String,Object> data =JsonUtil.strToMap(res.getString("data").subString(1,length-1));完全使用JsonUtil类也可以很方便的得到返回的数据，只需要使用strToMap，然后强转值的类型：
public static void main(String[] args) {
JSONObject jsonObject1 = new JSONObject();
JSONObject jsonObject2 = new JSONObject();
JSONArray jsonArray = new JSONArray();
jsonObject1.put("1","one");
jsonObject2.put("2","two");
jsonArray.add(jsonObject1);
jsonArray.add(jsonObject2);
String str = jsonArray.toJSONString();
JSONObject testobject = new JSONObject();
testobject.put("jsonarray",jsonArray);
testobject.put("json1",jsonObject1);
testobject.put("json2",jsonObject2);
String testString = testobject.toString();
System.out.println(testString);
Map<String, Object> map1 = JsonUtil.strToMap(testString);
Map<String,String> json2 = (Map<String,String>)map1.get("json2");
System.out.println("json2:"+json2);
List<Map<String,Object>> jsonarray = (List<Map<String,Object>>) map1.get("jsonarray");
System.out.println(jsonarray);
for (Map map:jsonarray) {
System.out.println(map);
}
}返回结果：
{"json2":{"2":"two"},"json1":{"1":"one"},"jsonarray":[{"$ref":"$.json1"},{"$ref":"$.json2"}]}
json2:{2=two}
[{$ref=$.json1}, {$ref=$.json2}]
{$ref=$.json1}
{$ref=$.json2}
5466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
