概述

Jackson框架是基于Java平台的一套数据处理工具,被称为“最好的Java Json解析器”。 
Jackson框架包含了3个核心库:streaming,databind,annotations.Jackson还包含了其它数据处理类库,此外不作说明。
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开头

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

准备工作

本文所有程序都基于JDK1.7,依赖jackon的三个核心类库:
jackson-core-2.5.3.jar
jackson-annotations-2.5.3.jar
jackson-databind-2.5.3.jar

Jackson处理Json

Jackson提供了三种可选的Json处理方法:流式API(Streaming API) 、树模型(Tree Model)、数据绑定(Data Binding)。从使用角度来看,比较一下这三种处理Json的方式的特性:

Streaming API:是效率最高的处理方式(开销低、读写速度快,但程序编写复杂度高)
Tree Model:是最灵活的处理方式
Data Binding:是最常用的处理方式

下面我们通过例子程序分别使用DataBinding,TreeModel,Streaming的方式来创建和解析Json字符串

1.DataBinding处理Json

Jackson支持Java对象与Json之间的相互转化。java对象序列化为json字符串,json字符串也可以反序列化为相同的java对象。
 
(1)java对象转化成json:
Province.java
package com.jackson.json.databinding;  

public class Province {
public String name;
public int population;
public String[] city;
}

Country.java

package com.jackson.json.databinding;  

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map; public class Country {
// 注意:被序列化的bean的private属性字段需要创建getter方法或者属性字段应该为public
private String country_id;
private Date birthDate;
private List<String> nation = new ArrayList<String>();
private String[] lakes;
private List<Province> provinces = new ArrayList<Province>();
private Map<String, Integer> traffic = new HashMap<String, Integer>(); public Country() {
// TODO Auto-generated constructor stub
} public Country(String countryId) {
this.country_id = countryId;
} public String getCountry_id() {
return country_id;
} public void setCountry_id(String country_id) {
this.country_id = country_id;
} public Date getBirthDate() {
return birthDate;
} public void setBirthDate(Date birthDate) {
this.birthDate = birthDate;
} public List<String> getNation() {
return nation;
} public void setNation(List<String> nation) {
this.nation = nation;
} public String[] getLakes() {
return lakes;
} public void setLakes(String[] lakes) {
this.lakes = lakes;
} public Integer get(String key) {
return traffic.get(key);
} public Map<String, Integer> getTraffic() {
return traffic;
} public void setTraffic(Map<String, Integer> traffic) {
this.traffic = traffic;
} public void addTraffic(String key, Integer value) {
traffic.put(key, value);
} public List<Province> getProvinces() {
return provinces;
} public void setProvinces(List<Province> provinces) {
this.provinces = provinces;
} @Override
public String toString() {
return "Country [country_id=" + country_id + ", birthDate=" + birthDate
+ ", nation=" + nation + ", lakes=" + Arrays.toString(lakes)
+ ", province=" + provinces + ", traffic=" + traffic + "]";
} }

JavaBeanSerializeToJson.java

package com.jackson.json.databinding;  

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List; import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature; public class JavaBeanSerializeToJson { public static void convert() throws Exception {
// 使用ObjectMapper来转化对象为Json
ObjectMapper mapper = new ObjectMapper();
// 添加功能,让时间格式更具有可读性
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
mapper.setDateFormat(dateFormat); Country country = new Country("China");
country.setBirthDate(dateFormat.parse("1949-10-01"));
country.setLakes(new String[] { "Qinghai Lake", "Poyang Lake",
"Dongting Lake", "Taihu Lake" }); List<String> nation = new ArrayList<String>();
nation.add("Han");
nation.add("Meng");
nation.add("Hui");
nation.add("WeiWuEr");
nation.add("Zang");
country.setNation(nation); Province province = new Province();
province.name = "Shanxi";
province.population = 37751200;
Province province2 = new Province();
province2.name = "ZheJiang";
province2.population = 55080000;
List<Province> provinces = new ArrayList<Province>();
provinces.add(province);
provinces.add(province2);
country.setProvinces(provinces); country.addTraffic("Train(KM)", 112000);
country.addTraffic("HighWay(KM)", 4240000);
// 为了使JSON视觉上的可读性,增加一行如下代码,注意,在生产中不需要这样,因为这样会增大Json的内容
mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
// 配置mapper忽略空属性
mapper.setSerializationInclusion(Include.NON_EMPTY);
// 默认情况,Jackson使用Java属性字段名称作为 Json的属性名称,也可以使用Jackson annotations(注解)改变Json属性名称
mapper.writeValue(new File("country.json"), country);
} public static void main(String[] args) throws Exception {
convert();
} }

程序运行后生成country.json,内容如下:

{
"country_id" : "China",
"birthDate" : "1949-10-01",
"nation" : [ "Han", "Meng", "Hui", "WeiWuEr", "Zang" ],
"lakes" : [ "Qinghai Lake", "Poyang Lake", "Dongting Lake", "Taihu Lake" ],
"provinces" : [ {
"name" : "Shanxi",
"population" : 37751200
}, {
"name" : "ZheJiang",
"population" : 55080000
} ],
"traffic" : {
"HighWay(KM)" : 4240000,
"Train(KM)" : 112000
}
}

(2)Json字符串反序列化为java对象:

package com.jackson.json.databinding;  

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Iterator;
import java.util.List; import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper; /**
* 将Json字符串反序列化为Java对象
*/
public class JsonDeserializeToJava { public static void main(String[] args) throws Exception {
//ObjectMapper类用序列化与反序列化映射器
ObjectMapper mapper = new ObjectMapper();
File json = new File("country.json");
//当反序列化json时,未知属性会引起的反序列化被打断,这里我们禁用未知属性打断反序列化功能,
//因为,例如json里有10个属性,而我们的bean中只定义了2个属性,其它8个属性将被忽略
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); //从json映射到java对象,得到country对象后就可以遍历查找,下面遍历部分内容,能说明问题就可以了
Country country = mapper.readValue(json, Country.class);
System.out.println("country_id:"+country.getCountry_id());
//设置时间格式,便于阅读
SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd");
String birthDate = dateformat.format(country.getBirthDate());
System.out.println("birthDate:"+birthDate); List<Province> provinces = country.getProvinces();
for (Province province : provinces) {
System.out.println("province:"+province.name + "\n" + "population:"+province.population);
}
}
}

程序运行结果:

country_id:China
birthDate:1949-10-01
province:Shanxi
population:37751200
province:ZheJiang
population:55080000

2.Tree Model处理Json

(1)tree model生成json:

package com.jackson.json.treemodel;  

import java.io.File;
import java.io.FileWriter; import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode; public class SerializationExampleTreeModel { public static void main(String[] args) throws Exception {
//创建一个节点工厂,为我们提供所有节点
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("country_id", "China");
country.put("birthDate", "1949-10-01"); //在Java中,List和Array转化为json后对应的格式符号都是"obj:[]"
ArrayNode nation = factory.arrayNode();
nation.add("Han").add("Meng").add("Hui").add("WeiWuEr").add("Zang");
country.set("nation", nation); ArrayNode lakes = factory.arrayNode();
lakes.add("QingHai Lake").add("Poyang Lake").add("Dongting Lake").add("Taihu Lake");
country.set("lakes", lakes); ArrayNode provinces = factory.arrayNode();
ObjectNode province = factory.objectNode();
ObjectNode province2 = factory.objectNode();
province.put("name","Shanxi");
province.put("population", 37751200);
province2.put("name","ZheJiang");
province2.put("population", 55080000);
provinces.add(province).add(province2);
country.set("provinces", provinces); ObjectNode traffic = factory.objectNode();
traffic.put("HighWay(KM)", 4240000);
traffic.put("Train(KM)", 112000);
country.set("traffic", traffic); mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
mapper.writeTree(generator, country);
} }

程序运行生成country2.json,内容如下:

{"country_id":"China","birthDate":"1949-10-01","nation":["Han","Meng","Hui","WeiWuEr","Zang"],"lakes":["QingHai Lake","Poyang Lake","Dongting Lake","Taihu Lake"],"provinces":[{"name":"Shanxi","population":37751200},{"name":"ZheJiang","population":55080000}],"traffic":{"HighWay(KM)":4240000,"Train(KM)":112000}} 

(2) json字符串反序列化为tree mode

DeserializationExampleTreeModel1.java,请注意观察程序中不同的JsonNode的类型变化

package com.jackson.json.treemodel;  

import java.io.File;
import java.util.Iterator; import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper; public class DeserializationExampleTreeModel1 { public static void main(String[] args) throws Exception {
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 is container Node ? "+node.isContainerNode());
// 得到所有node节点的子节点名称
System.out.println("---------得到所有node节点的子节点名称-------------------------");
Iterator<String> fieldNames = node.fieldNames();
while (fieldNames.hasNext()) {
String fieldName = fieldNames.next();
System.out.print(fieldName+" ");
}
System.out.println("\n-----------------------------------------------------");
// as.Text的作用是有值返回值,无值返回空字符串
JsonNode country_id = node.get("country_id");
System.out.println("country_id:"+country_id.asText() + " JsonNodeType:"+country_id.getNodeType()); JsonNode birthDate = node.get("birthDate");
System.out.println("birthDate:"+birthDate.asText()+" JsonNodeType:"+birthDate.getNodeType()); JsonNode nation = node.get("nation");
System.out.println("nation:"+ nation+ " JsonNodeType:"+nation.getNodeType()); JsonNode lakes = node.get("lakes");
System.out.println("lakes:"+lakes+" JsonNodeType:"+lakes.getNodeType()); JsonNode provinces = node.get("provinces");
System.out.println("provinces JsonNodeType:"+provinces.getNodeType()); boolean flag = true;
for (JsonNode provinceElements : provinces) {
//为了避免provinceElements多次打印,用flag控制打印,能体现provinceElements的JsonNodeType就可以了
if(flag){
System.out.println("provinceElements JsonNodeType:"+provinceElements.getNodeType());
System.out.println("provinceElements is container node? "+provinceElements.isContainerNode());
flag = false;
}
Iterator<String> provinceElementFields = provinceElements.fieldNames();
while (provinceElementFields.hasNext()) {
String fieldName = (String) provinceElementFields.next();
String province;
if ("population".equals(fieldName)) {
province = fieldName + ":" + provinceElements.get(fieldName).asInt();
}else{
province = fieldName + ":" + provinceElements.get(fieldName).asText();
}
System.out.println(province);
}
}
}
}

程序运行后打印结果如下:

node JsonNodeType:OBJECT
node is container Node ? true
---------得到所有node节点的子节点名称-------------------------
country_id birthDate nation lakes provinces traffic
-----------------------------------------------------
country_id:China JsonNodeType:STRING
birthDate:1949-10-01 JsonNodeType:STRING
nation:["Han","Meng","Hui","WeiWuEr","Zang"] JsonNodeType:ARRAY
lakes:["QingHai Lake","Poyang Lake","Dongting Lake","Taihu Lake"] JsonNodeType:ARRAY
provinces JsonNodeType:ARRAY
provinceElements JsonNodeType:OBJECT
provinceElements is container node? true
name:Shanxi
population:37751200
name:ZheJiang
population:55080000

在来看一下DeserializationExampleTreeModel2.java,本例中使用JsonNode.path的方法,path方法类似于DeserializationExampleTreeModel1.java中使用的get方法,

但当node不存在时,get方法返回null,而path返回MISSING类型的JsonNode

 
package com.jackson.json.treemodel;  

import java.io.File;
import java.io.IOException;
import java.util.Iterator; import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper; public class DeserializationExampleTreeModle2 { public static void main(String[] args) throws JsonProcessingException, IOException{
ObjectMapper mapper = new ObjectMapper();
JsonNode node = mapper.readTree(new File("country2.json"));
//path方法获取JsonNode时,当对象不存在时,返回MISSING类型的JsonNode
JsonNode missingNode = node.path("test");
if(missingNode.isMissingNode()){
System.out.println("JsonNodeType : " + missingNode.getNodeType());
} System.out.println("country_id:"+node.path("country_id").asText()); JsonNode provinces = node.path("provinces");
for (JsonNode provinceElements : provinces) {
Iterator<String> provincesFields = provinceElements.fieldNames();
while (provincesFields.hasNext()) {
String fieldName = (String) provincesFields.next();
String province;
if("name".equals(fieldName)){
province = fieldName +":"+ provinceElements.path(fieldName).asText();
}else{
province = fieldName +":"+ provinceElements.path(fieldName).asInt();
}
System.out.println(province);
}
}
} }

程序运行打印结果:

JsonNodeType : MISSING
country_id:China
name:Shanxi
population:37751200
name:ZheJiang
population:55080000

3.Stream处理Json

(1)stream生成json
 
package com.jackson.json.streaming;  

import java.io.File;
import java.io.FileWriter;
import java.io.Exception; import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator; public class StreamGeneratorJson { public static void main(String[] args) throws Exception {
JsonFactory factory = new JsonFactory();
//从JsonFactory创建一个JsonGenerator生成器的实例
JsonGenerator generator = factory.createGenerator(new FileWriter(new File("country3.json"))); generator.writeStartObject();
generator.writeFieldName("country_id");
generator.writeString("China");
generator.writeFieldName("provinces");
generator.writeStartArray();
generator.writeStartObject();
generator.writeStringField("name", "Shanxi");
generator.writeNumberField("population", 33750000);
generator.writeEndObject();
generator.writeEndArray();
generator.writeEndObject(); generator.close();
} }

程序运行后生成country3.json文件内容:

{"country_id":"China","provinces":[{"name":"Shanxi","population":33750000}]}  

(2)stream解析json:
现在adgcountry3.json,我们用Streaming API的方式来解析上面的Json,并查找json中population的值。

 
package com.jackson.json.streaming;  

import java.io.File;
import java.io.IOException; import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken; /*Jackson API提供了token对每个Json对象,例如,Json开始符号“{”是token指向的第一个解析的对象,
key:value键值对是另一个单独的对象。这个API很强大,但也需要编写大量代码。不推荐使用,平时更多的是使用DataBinding和TreeModel来处理json
*/
public class StreamParserJson {
public static void main(String[] args) throws JsonParseException,
IOException {
JsonFactory factory = new JsonFactory();
// 从JsonFactory创建JsonParser解析器的实例
JsonParser parser = factory.createParser(new File("country3.json")); while (!parser.isClosed()) {
// 得到一个token,第一次遍历时,token指向json文件中第一个符号"{"
JsonToken token = parser.nextToken();
if (token == null) {
break;
}
// 我们只查找 country3.json中的"population"字段的值,能体现解析的流程就可以了
// 当key是provinces时,我们进入provinces,查找population
if (JsonToken.FIELD_NAME.equals(token)
&& "provinces".equals(parser.getCurrentName())) {
token = parser.nextToken();
if (!JsonToken.START_ARRAY.equals(token)) {
break;
}
// 此时,token指向的应该是"{"
token = parser.nextToken();
if (!JsonToken.START_OBJECT.equals(token)) {
break;
}
while (true) {
token = parser.nextToken();
if (token == null) {
break;
}
if (JsonToken.FIELD_NAME.equals(token)
&& "population".equals(parser.getCurrentName())) {
token = parser.nextToken();
System.out.println(parser.getCurrentName() + " : "
+ parser.getIntValue());
}
}
}
}
} }

程序运行后,在控制台打印结果如下:

population : 33750000 

总结

上面的例子中,分别用3种方式处理Json,我的体会大致如下:
 
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/java_huashan/article/details/46375857
 
学习参考:http://www.cnblogs.com/lee0oo0/articles/2652528.html
 
 
 
 
 

JackSon学习笔记(一)的更多相关文章

  1. Jackson学习笔记-对象序列化

    一.用ObjectMapper.readValue(jsonString, Student.class) , ObjectMapper.writeValueAsString(student) impo ...

  2. jackson 学习笔记

    Jackson以优异的解析性能赢得了好评,今天就看看Jackson的一些简单的用法. Jackson使用之前先要下载,这里一共有三个jar包,想要获得完美的Jackson体验,这三个jar包都不可或缺 ...

  3. Jackson学习笔记(三)&lt;转&gt;

    概述 使用jackson annotations简化和增强的json解析与生成. Jackson-2.x通用annotations列表:https://github.com/FasterXML/jac ...

  4. Jackson学习笔记

    老版本的Jackson使用的包名为org.codehaus.jackson,而新版本使用的是com.fasterxml.jackson. Jackson主要包含了3个模块: jackson-core ...

  5. spring学习笔记---Jackson的使用和定制

      前言: JAVA总是把实体对象(数据库/Nosql等)转换为POJO对象再处理, 虽然有各类框架予以强力支持. 但实体对象和POJO, 由于"饮食习惯", "民族特色 ...

  6. springmvc学习笔记--REST API的异常处理

    前言: 最近使用springmvc写了不少rest api, 觉得真是一个好框架. 之前描述的几篇关于rest api的文章, 其实还是不够完善. 比如当遇到参数缺失, 类型不匹配的情况时, 直接抛出 ...

  7. springmvc学习笔记---面向移动端支持REST API

    前言: springmvc对注解的支持非常灵活和飘逸, 也得web编程少了以往很大一坨配置项. 另一方面移动互联网的到来, 使得REST API变得流行, 甚至成为主流. 因此我们来关注下spring ...

  8. &lt;老友记&gt;学习笔记

    这是六个人的故事,从不服输而又有强烈控制欲的monica,未经世事的千金大小姐rachel,正直又专情的ross,幽默风趣的chandle,古怪迷人的phoebe,花心天真的joey——六个好友之间的 ...

  9. MySQL学习笔记一

    MySQL 学习笔记 一 一.数据库简单介绍 1. 按照数据库的发展时间顺序,主要出现了以下类型数据库系统: Ø 网状型数据库 Ø 层次型数据库 Ø 关系型数据库 Ø 面向对象数据库 上面4中数据库系 ...

随机推荐

  1. 【环境配置】Linux环境下下载、配置java环境、安装eclipse、建立eclipse快捷方式详解

    一.首先是下载Java JDK 到目前为止的最新版本为(jdk1.8.0_60),有两种方式进行下载: 1.使用shell来进行下载,可使用如下命令直接进行下载: wget --no-check-ce ...

  2. hdu 1251:统计难题(字典树,经典题)

    统计难题 Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 131070/65535 K (Java/Others)Total Submi ...

  3. java Spring 在WEB应用中的实例化

    .前面讲解的都是通过直接读取配置文件,进行的实例化ApplicationContext AbstractApplicationContext app = new ClassPathXmlApplica ...

  4. Asp.Net中JSON的序列化和反序列化-----JavaScriptSerializer ,加上自己工作心得

    在工作中和手机通信用到web服务和javascriptSerializer,返回json数据,供手机端调用,一开始返回的数据是一大堆,比如 [{"word_picture9":&q ...

  5. hibernate懒加载和json序列化冲突

    因为懒加载这个对象属性只是一个代理对象,如果json直接当作一个存在的属性去序列化就会出现错误,所以就只能这样了,当然还有其他办法吧 或者在class上加上 @JsonIgnoreProperties ...

  6. jQuery中getJSON跨域原理详解

    详见:http://blog.yemou.net/article/query/info/tytfjhfascvhzxcytp28 jQuery中getJSON跨域原理详解 前几天我再开发一个叫 河蟹工 ...

  7. java异常常见面试问题

    java异常常见面试问题 一.java异常的理解 异常主要是处理编译期不能捕获的错误.出现问题时能继续顺利执行下去,而不导致程序终止,确保程序的健壮性. 处理过程:产生异常状态时,如果当前的conte ...

  8. Cocos2D:塔防游戏制作之旅(八)

    如果所有东西通过检查,则创建一个新炮塔,将它放置在基座上,然后添加到towers数组中. 注意:在方法最后的bridge语法需要做一些解释.你下载的初始项目已经为一 些文件打开ARC,但不是Cocos ...

  9. 转 MYSQL SELECT ... FOR UPDATE and SELECT ... LOCK IN SHARE MODE Locking Reads

    原文: http://dev.mysql.com/doc/refman/5.0/en/innodb-locking-reads.html In some circumstances, a consis ...

  10. fedora23没有/var/log/messages &amp;如何禁用后台自动更新软件?

    警告!! Linux是一个非常敏感的操作系统,若删除文件错误,很容易造成系统崩溃. fedora23没有/var/log/messages 不是没有messages这个文件,而是 从 fc core ...