Java解析json(二)：jackson
官方参考
Jackson Home Page:https://github.com/FasterXML/jackson
Jackson Wiki:http://wiki.fasterxml.com/JacksonHome
Jackson doc: https://github.com/FasterXML/jackson-docs
Jackson Download Page:http://wiki.fasterxml.com/JacksonDownload
简介
Jackson框架是基于Java平台的一套数据处理工具，被称为“最好的Java Json解析器”。
Jackson有两个主要分支，1.x处于维护状态，只会发布bug修复版本。2.x还在积极地开发当中。这两个版本的Java包名和Maven artifact不一样，所以它们不互相兼容，但是可以和平共存，也就是项目可以同时依赖1.x和2.x而不会发生冲突。
Jackson版本： 1.x (目前版本从1.1~1.9)与2.x。1.x与2.x从包的命名上可以看出来，1.x的类库中，包命名以：org.codehaus.jackson.xxx开头，而2.x类库中包命令：com.fastxml.jackson.xxx开头。
本文以2.x为主…
主要模块
1. 核心模块
核心模块是扩展模块构建的基础，到2.7版本为止，共有3个核心模块（依赖关系从上到下）:
***Streaming*** : jackson-core jar，定义了底层的streaming API和实现了Json特性。
***Annotations*** : jackson-annotations jar，包含了标准的Jackson注解。
***Databind*** : jackson-databind jar，实现了数据绑定和对象序列化，它依赖于streaming和annotations的包。
- 1
- 2
- 3
- 4
- 5
- 6
2. 第三方数据类型模块
这些扩展是插件式的Jackson模块，用ObjectMapper.registerModule()注册，并且通过添加serializers和deserializers以便Databind包（ObjectMapper / ObjectReader / ObjectWriter）可以读写这些类型，来增加对各种常用的Java库的数据类型的支持。参考https://github.com/FasterXML/jacksonThird-party datatype modules。
3. 数据格式模块
Jackson也有处理程序对JAX-RS标准实现者例如Jersey, RESTeasy, CXF等提供了数据格式支持。处理程序实现了MessageBodyReader和MessageBodyWriter，目前支持的数据格式包括JSON, Smile, XML, YAML和CBOR。
数据格式提供了除了Json之外的数据格式支持，它们绝大部分仅仅实现了streaming API abstractions，以便数据绑定组件可以按照原来的方式使用。另一些（几乎不需要）提供了databind标准功能来处理例如schemas。参考https://github.com/FasterXML/jacksonData format modules
准备工作
JDK1.7,依赖jackon的三个核心类库：
- jackson-core-2.5.3.jar
- jackson-annotations-2.5.3.jar
- jackson-databind-2.5.3.jar
maven依赖:
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.7.4</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.7.4</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.7.4</version>
</dependency>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
处理Json
Jackson提供了三种可选的Json处理方法：流式API(Streaming API) 、树模型(Tree Model)、数据绑定(Data Binding)。三种处理Json的方式的特性：
- Streaming API：是效率最高的处理方式(开销低、读写速度快，但程序编写复杂度高)
- Tree Model：是最灵活的处理方式
- Data Binding：是最常用的处理方式
1.Data Binding
主要使用ObjectMapper来操作Json，默认情况下会使用BeanSerializer来序列化POJO。
如果是解析，那么如下的例子里的TestJson必须要有setters，且setters必须是public修饰的，否则属性的值将会为null。
如果是生成，那么必须有getters，且getters必须是public修饰的。
如果属性不是private修饰，那么可以不用有getters和setters。（参考访问修饰符）
要点：
ObjectMapper mapper = new ObjectMapper();
mapper.writeValue(jsonFile, Bean);
mapper.readValue(jsonFile, Bean.class/Collection< Bean >);
(1)生成json
city.java
package com.myjackson.databinding;
//市
public class City {
private Integer id;
private String cityName;
public City(){}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getCityName() {
return cityName;
}
public void setCityName(String cityName) {
this.cityName = cityName;
}
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
province.java
package com.myjackson.databinding;
import java.util.Date;
import java.util.List;
//省
public class Province {
private Integer id;
private String name;
private Date birthDate;
private List<City> cities;
public Province(){}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<City> getCities() {
return cities;
}
public void setCities(List<City> cities) {
this.cities = cities;
}
public Date getBirthDate() {
return birthDate;
}
public void setBirthDate(Date birthDate) {
this.birthDate = birthDate;
}
}- 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
counry.java
package com.myjackson.databinding;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
//国家
public class Country {
private Integer id;
private String countryName;
private Date establishTime;
private List<Province> provinces;
private String[] lakes;
private Map<String, String> forest = new HashMap<String, String>();
public Country(){
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getCountryName() {
return countryName;
}
public void setCountryName(String countryName) {
this.countryName = countryName;
}
public Date getEstablishTime() {
return establishTime;
}
public void setEstablishTime(Date establishTime) {
this.establishTime = establishTime;
}
public List<Province> getProvinces() {
return provinces;
}
public void setProvinces(List<Province> provinces) {
this.provinces = provinces;
}
public String[] getLakes() {
return lakes;
}
public void setLakes(String[] lakes) {
this.lakes = lakes;
}
public Map<String, String> getForest() {
return forest;
}
public void setForest(Map<String, String> forest) {
this.forest = forest;
}
}- 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
测试案例
@Test
public void Bean2JsonStr() throws ParseException, JsonGenerationException, JsonMappingException, IOException{
// 使用ObjectMapper转化对象为Json
ObjectMapper mapper = new ObjectMapper();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
mapper.setDateFormat(dateFormat); //设置日期序列化格式
City city1 = new City();
city1.setId(1);
city1.setCityName("gz");
City city2 = new City();
city2.setId(2);
city2.setCityName("dg");
Province province = new Province();
province.setId(1);
province.setName("GD");
province.setBirthDate(new Date());
List<City> cities = new ArrayList<City>();
cities.add(city1);
cities.add(city2);
province.setCities(cities);
Country country = new Country();
country.setCountryName("China");
country.setId(1);
country.setEstablishTime(dateFormat.parse("1949-10-01"));
country.setLakes(new String[] { "Qinghai Lake", "Poyang Lake","Dongting Lake", "Taihu Lake" });
HashMap<String, String> forest = new HashMap<String, String>();
forest.put("no.1", "dxal");
forest.put("no.2", "xxal");
country.setForest(forest);
List<Province> provinces = new ArrayList<Province>();
provinces.add(province);
country.setProvinces(provinces);
mapper.configure(SerializationFeature.INDENT_OUTPUT, true); // 为了使JSON视觉上的可读性，在生产中不需如此，会增大Json的内容
mapper.setSerializationInclusion(Include.NON_EMPTY); // 配置mapper忽略空属性
mapper.writeValue(new File("country.json"), country); // 默认情况，Jackson使用Java属性字段名称作为 Json的属性名称,也可以使用Jackson annotations(注解)改变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
运行得到country.json：
{
"id" : 1,
"countryName" : "China",
"establishTime" : "1949-10-01",
"provinces" : [ {
"id" : 1,
"name" : "GD",
"birthDate" : "2017-02-04",
"cities" : [ {
"id" : 1,
"cityName" : "gz"
}, {
"id" : 2,
"cityName" : "dg"
} ]
} ],
"lakes" : [ "Qinghai Lake", "Poyang Lake", "Dongting Lake", "Taihu Lake" ],
"forest" : {
"no.1" : "dxal",
"no.2" : "xxal"
}
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
(2)解析json
@Test
public void JsonStr2Bean() throws JsonParseException, JsonMappingException, IOException{
ObjectMapper mapper = new ObjectMapper();
File jsonFile = new File("country.json");
//当反序列化json时，未知属性会引起的反序列化被打断，这里我们禁用未知属性打断反序列化功能，
//因为，例如json里有10个属性，而我们的bean中只定义了2个属性，其它8个属性将被忽略
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
Country country = mapper.readValue(jsonFile, Country.class);
System.out.println(country.getCountryName()+country.getEstablishTime());
List<Province> provinces = country.getProvinces();
for (Province province : provinces) {
System.out.println("province:"+province.getName() + "
" + "birthDate:"+province.getBirthDate());
for (City city: province.getCities()) {
System.out.println(city.getId()+" "+city.getCityName());
}
}
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
输出结果：
ChinaSat Oct 01 08:00:00 CST 1949
province:GD
getBirthDate:Sat Feb 04 08:00:00 CST 2017
1 gz
2 dg- 1
- 2
- 3
- 4
- 5
解析的时候如果碰到集合类，那么可以使用TypeReference类
@Test
public void JsonStr2List() throws IOException{
City city1 = new City();
city1.setId(1);
city1.setCityName("gz");
City city2 = new City();
city2.setId(2);
city2.setCityName("dg");
List<City> cities = new ArrayList<City>();
cities.add(city1);
cities.add(city2);
ObjectMapper mapper = new ObjectMapper();
String listJsonStr = mapper.writeValueAsString(cities);
System.out.println(listJsonStr);
List<City> list = mapper.readValue(listJsonStr, new TypeReference<List<City>>(){} );
for (City city: list) {
System.out.println("id:"+city.getId()+" cityName:"+city.getCityName());
}
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
2.Streaming API
Jackson提供了一套底层API来解析Json字符串，这个API为每个Json对象提供了符号。例如， ‘{’ 是解析器提供的第一个对象（writeStartObject()），键值对是解析器提供的另一个单独对象（writeString(key,value)）。这些API很强大，但是需要大量的代码。大多数情况下，Tree Model和Data Binding可以代替Streaming API。
上面代码如果注释掉 city1.setId(1);这行，结果为：
[{"id":null,"cityName":"gz"},{"id":2,"cityName":"dg"}]
id:null cityName:gz
id:2 cityName:dg- 1
- 2
- 3
但假如想让id为null的不输出，不为null的输出除了 mapper.setSerializationInclusion(Include.NON_EMPTY); // 配置mapper忽略空属性 这种方法外还可以在ObjectMapper中注册一个自定义的序列化JsonSerializer和反序列化
JsonDeSerializer:
CityJsonSerializer.java
package com.myjackson.databinding;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public class CityJsonSerializer extends JsonSerializer<City>{
@Override
public void serialize(City city, JsonGenerator jsonGenerator, SerializerProvider arg2)
throws IOException, JsonProcessingException {
jsonGenerator.writeStartObject();
if ( city.getId()!=null) {
jsonGenerator.writeNumberField("id", city.getId());
}
jsonGenerator.writeStringField("cityName", city.getCityName());
jsonGenerator.writeEndObject();
}
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
CityJsonDeSerializer.java
package com.myjackson.databinding;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
public class CityJsonDeSerializer extends JsonDeserializer<List<City>>{
@Override
public List<City> deserialize(JsonParser parser,DeserializationContext deserializationcontext) throws IOException,
JsonProcessingException {
List<City> list = new ArrayList<City>();
// 开始解析数组，第一个JsonToken必须是JsonToken.START_ARRAY"["
if (!JsonToken.START_ARRAY.equals(parser.getCurrentToken())) {
System.out.println(parser.getCurrentToken());
return null;
}
// 解析符号直到字符串结尾
while (!parser.isClosed()) {
// 如果有必要的话，这个方法会沿着流前进直到足以确下一个JsonToken的类型
JsonToken token = parser.nextToken();
// 如果是最后一个JsonToken，那么就结束了
if (token == null)
break;
// 数组的每个元素都是对象，因此下一个JsonToken是JsonToken.START_OBJECT"{"
if (!JsonToken.START_OBJECT.equals(token)) {
break;
}
City city = null;
// 输出id字段的值
while (true) {
if (JsonToken.START_OBJECT.equals(token)) {
city = new City();
}
token = parser.nextToken();
if (token == null)
break;
if (JsonToken.FIELD_NAME.equals(token) ) {
if("id".equals(parser.getCurrentName())){
token = parser.nextToken();
city.setId(parser.getIntValue());
}else if("cityName".equals(parser.getCurrentName())){
token = parser.nextToken();
city.setCityName(parser.getText());
}
}
if(JsonToken.END_OBJECT.equals(token)){
list.add(city);
}
}
}
return list;
}
}- 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
测试：
@Test
public void StreamJsonStr2List() throws IOException{
City city1 = new City();
//city1.setId(1);
city1.setCityName("gz");
City city2 = new City();
city2.setId(2);
city2.setCityName("dg");
List<City> cities = new ArrayList<City>();
cities.add(city1);
cities.add(city2);
ObjectMapper mapper = new ObjectMapper();
SimpleModule module = new SimpleModule();
module.addSerializer(City.class, new CityJsonSerializer());
mapper.registerModule(module);
String listJsonStr = mapper.writeValueAsString(cities);
System.out.println(listJsonStr);
ObjectMapper mapper2 = new ObjectMapper();
SimpleModule module2 = new SimpleModule();
module2.addDeserializer(List.class, new CityJsonDeSerializer());
mapper2.registerModule(module2);
List<City> list = mapper2.readValue(listJsonStr, new TypeReference<List<City>>(){} );
for (City city: list) {
System.out.println("id:"+city.getId()+" cityName:"+city.getCityName());
}
}- 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
也可以简单一点，使用注解，省去在ObjectMapper 中注册SimpleModule
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
@JsonSerialize(using=CityJsonSerializer.class)
public class City {
...
}- 1
- 2
- 3
- 4
- 5
运行结果:
[{"cityName":"gz"},{"id":2,"cityName":"dg"}]
id:null cityName:gz
id:2 cityName:dg- 1
- 2
- 3
###3.Tree Mode
如果不想为Json结构写一个class的话，Tree Mode是一个很好的选择。
生成json:
@Test
public void TreeMode2Json() throws IOException{
//创建一个节点工厂,为我们提供所有节点
JsonNodeFactory factory = new JsonNodeFactory(false);
//创建一个json factory来写tree modle为json
JsonFactory jsonFactory = new JsonFactory();
//创建一个json生成器
JsonGenerator generator = jsonFactory.createGenerator(new FileWriter(new File("country2.json")));
//注意，默认情况下对象映射器不会指定根节点，下面设根节点为country
ObjectMapper mapper = new ObjectMapper();
ObjectNode country = factory.objectNode();
country.put("id", 1);
country.put("countryName","China");
country.put("establishTime", "1949-10-01");
ArrayNode provinces = factory.arrayNode();
ObjectNode province = factory.objectNode();
ObjectNode city1 = factory.objectNode();
city1.put("id", 1);
city1.put("cityName", "gz");
ObjectNode city2 = factory.objectNode();
city2.put("id", 1);
city2.put("cityName", "dg");
ArrayNode cities = factory.arrayNode();
cities.add(city1).add(city2);
province.put("cities", cities);
provinces.add(province);
country.put("provinces",provinces);
ArrayNode lakes = factory.arrayNode();
lakes.add("QingHai Lake").add("Poyang Lake").add("Dongting Lake").add("Taihu Lake");
country.put("lakes",lakes);
ObjectNode forest = factory.objectNode();
forest.put("no.1","dxal");
forest.put("no.2", "xxal");
country.put("forest", forest);
mapper.setSerializationInclusion(Include.NON_EMPTY); // 配置mapper忽略空属性
mapper.writeTree(generator, country);
}- 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
结果：
{
"id":1,
"countryName":"China",
"establishTime":"1949-10-01",
"provinces":[
{"cities":[
{"id":1,"cityName":"gz"},
{"id":1,"cityName":"dg"}
]
}
],
"lakes":["QingHai Lake","Poyang Lake","Dongting Lake","Taihu Lake"],
"forest":{"no.1":"dxal","no.2":"xxal"}
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
读取json:
@Test
public void TreeModeReadJson() throws IOException{
ObjectMapper mapper = new ObjectMapper();
// Jackson提供一个树节点被称为"JsonNode",ObjectMapper提供方法来读json作为树的JsonNode根节点
JsonNode node = mapper.readTree(new File("country2.json"));
// 看看根节点的类型
System.out.println("node JsonNodeType:"+node.getNodeType());
System.out.println("---------得到所有node节点的子节点名称----------------------");
Iterator<String> fieldNames = node.fieldNames();
while (fieldNames.hasNext()) {
String fieldName = fieldNames.next();
System.out.print(fieldName+" ");
}
System.out.println("
---------------------------------------------------");
JsonNode lakes = node.get("lakes");
System.out.println("lakes:"+lakes+" JsonNodeType:"+lakes.getNodeType());
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
运行结果：
node JsonNodeType:OBJECT
---------得到所有node节点的子节点名称-------------------------
id countryName establishTime provinces lakes forest
-----------------------------------------------------
lakes:["QingHai Lake","Poyang Lake","Dongting Lake","Taihu Lake"] JsonNodeType:ARRAY- 1
- 2
- 3
- 4
- 5
结束
Stream API方式是开销最低、效率最高，但编写代码复杂度也最高，在生成Json时，需要逐步编写符号和字段拼接json,在解析Json时，需要根据token指向也查找json值，生成和解析json都不是很方便，代码可读性也很低。
Databinding处理Json是最常用的json处理方式，生成json时，创建相关的java对象，并根据json内容结构把java对象组装起来，最后调用writeValue方法即可生成json,
解析时，就更简单了，直接把json映射到相关的java对象，然后就可以遍历java对象来获取值了。
TreeModel处理Json，是以树型结构来生成和解析json，生成json时，根据json内容结构，我们创建不同类型的节点对象，组装这些节点生成json。解析json时，它不需要绑定json到java bean，根据json结构，使用path或get方法轻松查找内容。
以上为个人参考网上博客以及一些个人实践，不对之处烦请指正，感激不尽~
参考：
http://blog.csdn.net/gjb724332682/article/details/51586701#
http://blog.csdn.net/java_huashan/article/details/46375857