Jackson和JSON Pointer查询解析任何JSON节点
JSON Pointer是字符串表达式,用于标识JSON文档特定节点。RFC 6901规范有定义,用于查询复杂Json文档结构。
1.示例Json文档
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
{
"firstName" : "John" ,
"lastName" : "Doe" ,
"address" : {
"street" : "21 2nd Street" ,
"city" : "New York" ,
"postalCode" : "10021-3100" ,
"coordinates" : {
"latitude" : 40.7250387 ,
"longitude" : - 73.9932568
}
},
"phone" : [
"139" ,
"137"
],
"grade" : [
{
"name" : "math" ,
"score" : 99
},
{
"name" : "english" ,
"score" : 97
}
]
}
|
该文档包括复杂的嵌套,其中嵌套类型有对象,数组,数组对象。下面使用JSON Pointer进行解析。
2. 解析文档
使用Jackson的核心对象ObjectMapper,首先解析json字符串未JsonNode。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
String json = "{\n" +
" \"firstName\": \"John\",\n" +
" \"lastName\": \"Doe\",\n" +
" \"address\": {\n" +
" \"street\": \"21 2nd Street\",\n" +
" \"city\": \"New York\",\n" +
" \"postalCode\": \"10021-3100\",\n" +
" \"coordinates\": {\n" +
" \"latitude\": 40.7250387,\n" +
" \"longitude\": -73.9932568\n" +
" }\n" +
" },\n" +
" \"phone\":[\"139\",\"137\"],\n" +
" \"grade\":[\n" +
" {\"name\":\"math\",\"score\":99},\n" +
" {\"name\":\"english\",\"score\":97}\n" +
" ]\n" +
" }" ;
ObjectMapper mapper = new ObjectMapper();
JsonNode node = mapper.readTree(json);
|
2.1 获取属性
1
2
|
JsonNode firstName = node.at( "/firstName" );
print( "firstName" ,firstName.toString());
|
必须以/开头,表示当前起始节点。
输出结果:
firstName:"John"
2.2 获取对象属性
1
2
|
JsonNode coordinatesNode = node.at( "/address/coordinates" );
print( "coordinatesNode" ,coordinatesNode.toString());
|
输出结果:
coordinatesNode:{"latitude":40.7250387,"longitude":-73.9932568}
2.3 获取数组属性
1
2
|
JsonNode phoneNode = node.at( "/phone" );
print( "phoneNode" , phoneNode.toString());
|
输出结果:
phoneNode:["139","137"]
2.4 获取数组属性元素
1
2
|
JsonNode phone1Node = node.at( "/phone/0" );
print( "phone1Node" ,phone1Node.toString());
|
输出结果:
phone1Node:"139"
2.4 获取数组对象属性
1
2
3
4
|
JsonNode nameNode = node.at( "/grade/0/name" );
print( "name" ,nameNode.toString());
JsonNode scoreNode = node.at( "/grade/0/score" );
print( "score" ,scoreNode.toString());
|
输出结果:
name:"math"
score:99
Jackson 通用解析JSON方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
package com.util;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.type.TypeFactory;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* json 解析类,通用于全项目
* <p/>
* Created by 刘一波 on 15/7/24.
* E-Mail:zhanlanstar@163.com
*/
@Slf4j
public class JsonUtils {
private static ObjectMapper objectMapper = new ObjectMapper();
static {
objectMapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
objectMapper.configure(SerializationFeature.INDENT_OUTPUT, true );
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false );
objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false );
SimpleDateFormat sdf = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
objectMapper.setDateFormat(sdf);
}
/**
* 提供给elasticsearch使用,把bean转换成list map 集合类型,否则不能存入索引
*
* @param o
* @return
*/
public static Object beanToJsonObject(Object o) {
return jsonStrToList(objectToJsonStr(o), Map. class );
}
public static String objectToJsonStr(Object o) {
try {
return objectMapper.writeValueAsString(o);
} catch (IOException e) {
log.error( "object can not objectTranslate to json" , e);
}
return null ;
}
public static <T> T jsonStrToObject(String json, Class<T> cls) {
try {
return objectMapper.readValue(json, cls);
} catch (IOException e) {
log.error( "json cant be objectTranslate to object" , e);
return null ;
}
}
public static <T> T jsonDataToObject(String jsonStr, Class<T> cls) {
if (!StringUtils.isEmpty(jsonStr)) {
T data = JsonUtils.jsonStrToObject(jsonStr, cls);
return data;
} else {
return null ;
}
}
public static <T> List<T> jsonStrToList(String jsonStr, Class<?> clazz) {
List<T> list = Lists.newArrayList();
try {
// 指定容器结构和类型(这里是ArrayList和clazz)
TypeFactory t = TypeFactory.defaultInstance();
list = objectMapper.readValue(jsonStr,
t.constructCollectionType(ArrayList. class , clazz));
} catch (IOException e) {
log.error( "反序列化序列化attributes,从Json到List报错" , e);
}
return list;
}
public static Map jsonStrToMap(String attributes) {
try {
return objectMapper.readValue(attributes, HashMap. class );
} catch (IOException e) {
log.error( "反序列化序列化attributes,从Json到HashMap报错" , e);
}
return new HashMap();
}
}
|
以上为个人经验,希望能给大家一个参考,也希望大家多多支持服务器之家。
原文链接:https://blog.csdn.net/neweastsun/article/details/106530134