一、入门
Jackson中有个ObjectMapper类很是实用，用于Java对象与JSON的互换。
1.JAVA对象转JSON[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
|
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonDemo {
public static void main(String[] args) throws ParseException, IOException {
User user = new User();
user.setName("小民");
user.setEmail("xiaomin@sina.com");
user.setAge(20);
SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd");
user.setBirthday(dateformat.parse("1996-10-01"));
/**
* ObjectMapper是JSON操作的核心，Jackson的所有JSON操作都是在ObjectMapper中实现。
* ObjectMapper有多个JSON序列化的方法，可以把JSON字符串保存File、OutputStream等不同的介质中。
* writeValue(File arg0, Object arg1)把arg1转成json序列，并保存到arg0文件中。
* writeValue(OutputStream arg0, Object arg1)把arg1转成json序列，并保存到arg0输出流中。
* writeValueAsBytes(Object arg0)把arg0转成json序列，并把结果输出成字节数组。
* writeValueAsString(Object arg0)把arg0转成json序列，并把结果输出成字符串。
*/
ObjectMapper mapper = new ObjectMapper();
//User类转JSON
//输出结果：{"name":"小民","age":20,"birthday":844099200000,"email":"xiaomin@sina.com"}
String json = mapper.writeValueAsString(user);
System.out.println(json);
//Java集合转JSON
//输出结果：[{"name":"小民","age":20,"birthday":844099200000,"email":"xiaomin@sina.com"}]
List<User> users = new ArrayList<User>();
users.add(user);
String jsonlist = mapper.writeValueAsString(users);
System.out.println(jsonlist);
}
}
|
2.JSON转Java类[JSON反序列化]
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
import java.io.IOException;
import java.text.ParseException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonDemo {
public static void main(String[] args) throws ParseException, IOException {
String json = "{\"name\":\"小民\",\"age\":20,\"birthday\":844099200000,\"email\":\"xiaomin@sina.com\"}";
/**
* ObjectMapper支持从byte[]、File、InputStream、字符串等数据的JSON反序列化。
*/
ObjectMapper mapper = new ObjectMapper();
User user = mapper.readValue(json, User.class);
System.out.println(user);
}
}
|
二、Jackson支持3种使用方式:
1、Data Binding：最方便使用.
(1)Full Data Binding：
|
1
2
3
4
5
6
7
|
private static final String MODEL_BINDING = "{\"name\":\"name1\",\"type\":1}";
public void fullDataBinding() throws Exception{
ObjectMapper mapper = new ObjectMapper();
Model user = mapper.readValue(MODEL_BINDING, Model.class);//readValue到一个实体类中.
System.out.println(user.getName());
System.out.println(user.getType());
}
|
Model类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
private static class Model{
private String name;
private int type;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
}
|
(2)Raw Data Binding：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/**
Concrete Java types that Jackson will use for simple data binding are:
JSON Type Java Type
object LinkedHashMap<String,Object>
array ArrayList<Object>
string String
number(no fraction) Integer, Long or BigInteger (smallest applicable)
number(fraction) Double(configurable to use BigDecimal)
true|false Boolean
null null
*/
public void rawDataBinding() throws Exception{
ObjectMapper mapper = new ObjectMapper();
HashMap map = mapper.readValue(MODEL_BINDING,HashMap.class);//readValue到一个原始数据类型.
System.out.println(map.get("name"));
System.out.println(map.get("type"));
}
|
(3)generic Data Binding：
|
1
2
3
4
5
6
7
8
|
private static final String GENERIC_BINDING = "{\"key1\":{\"name\":\"name2\",\"type\":2},\"key2\":{\"name\":\"name3\",\"type\":3}}";
public void genericDataBinding() throws Exception{
ObjectMapper mapper = new ObjectMapper();
HashMap<String,Model> modelMap = mapper.readValue(GENERIC_BINDING,new TypeReference<HashMap<String,Model>>(){});//readValue到一个范型数据中.
Model model = modelMap.get("key2");
System.out.println(model.getName());
System.out.println(model.getType());
}
|
2、Tree Model：最灵活。
|
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
|
private static final String TREE_MODEL_BINDING = "{\"treekey1\":\"treevalue1\",\"treekey2\":\"treevalue2\",\"children\":[{\"childkey1\":\"childkey1\"}]}";
public void treeModelBinding() throws Exception{
ObjectMapper mapper = new ObjectMapper();
JsonNode rootNode = mapper.readTree(TREE_MODEL_BINDING);
//path与get作用相同,但是当找不到该节点的时候,返回missing node而不是Null.
String treekey2value = rootNode.path("treekey2").getTextValue();//
System.out.println("treekey2value:" + treekey2value);
JsonNode childrenNode = rootNode.path("children");
String childkey1Value = childrenNode.get(0).path("childkey1").getTextValue();
System.out.println("childkey1Value:"+childkey1Value);
//创建根节点
ObjectNode root = mapper.createObjectNode();
//创建子节点1
ObjectNode node1 = mapper.createObjectNode();
node1.put("nodekey1",1);
node1.put("nodekey2",2);
//绑定子节点1
root.put("child",node1);
//数组节点
ArrayNode arrayNode = mapper.createArrayNode();
arrayNode.add(node1);
arrayNode.add(1);
//绑定数组节点
root.put("arraynode", arrayNode);
//JSON读到树节点
JsonNode valueToTreeNode = mapper.valueToTree(TREE_MODEL_BINDING);
//绑定JSON节点
root.put("valuetotreenode",valueToTreeNode);
//JSON绑定到JSON节点对象
JsonNode bindJsonNode = mapper.readValue(GENERIC_BINDING, JsonNode.class);//绑定JSON到JSON节点对象.
//绑定JSON节点
root.put("bindJsonNode",bindJsonNode);
System.out.println(mapper.writeValueAsString(root));
}
|
3、Streaming API：最佳性能。
对于性能要求高的程序,推荐使用流API,否则使用其他方法
不管是创建JsonGenerator还是JsonParser,都是使用JsonFactory。
|
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
|
package com.jingshou.jackson;
import java.io.File;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
public class JacksonTest6 {
public static void main(String[] args) throws IOException {
JsonFactory jfactory = new JsonFactory();
/*** write to file ***/
JsonGenerator jGenerator = jfactory.createGenerator(new File(
"c:\\user.json"), JsonEncoding.UTF8);
jGenerator.writeStartObject(); // {
jGenerator.writeStringField("name", "mkyong"); // "name" : "mkyong"
jGenerator.writeNumberField("age", 29); // "age" : 29
jGenerator.writeFieldName("messages"); // "messages" :
jGenerator.writeStartArray(); // [
jGenerator.writeString("msg 1"); // "msg 1"
jGenerator.writeString("msg 2"); // "msg 2"
jGenerator.writeString("msg 3"); // "msg 3"
jGenerator.writeEndArray(); // ]
jGenerator.writeEndObject(); // }
jGenerator.close();
/*** read from file ***/
JsonParser jParser = jfactory.createParser(new File("c:\\user.json"));
// loop until token equal to "}"
while (jParser.nextToken() != JsonToken.END_OBJECT) {
String fieldname = jParser.getCurrentName();
if ("name".equals(fieldname)) {
// current token is "name",
// move to next, which is "name"'s value
jParser.nextToken();
System.out.println(jParser.getText()); // display mkyong
}
if ("age".equals(fieldname)) {
// current token is "age",
// move to next, which is "name"'s value
jParser.nextToken();
System.out.println(jParser.getIntValue()); // display 29
}
if ("messages".equals(fieldname)) {
jParser.nextToken(); // current token is "[", move next
// messages is array, loop until token equal to "]"
while (jParser.nextToken() != JsonToken.END_ARRAY) {
// display msg1, msg2, msg3
System.out.println(jParser.getText());
}
}
}
jParser.close();
}
}
|