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 Wiki:http://wiki.fasterxml.com/JacksonHome
Jackson doc: https://github.com/FasterXML/jackson-docs
Jackson Download Page:http://wiki.fasterxml.com/JacksonDownload
简介
Jackson是一套Java平台的数据处理工具集，具体可以参考官网的说法：
including the flagship streaming JSON parser / generator library, matching data-binding library (POJOs to and from JSON) and additional data format modules to process data encoded in Avro, BSON, CBOR, CSV, Smile, Protobuf, XML or YAML; and even the large set of data format modules to support data types of widely used data types such as Joda, Guava and many, many more.
Jackson有两个主要分支，1.x处于维护状态，只会发布bug修复版本。2.x还在积极地开发当中。这两个版本的Java包名和Maven artifact不一样，所以它们不互相兼容，但是可以和平共存，也就是项目可以同时依赖1.x和2.x而不会发生冲突，本文只会简单介绍2.x版本的用法。
Jackson主要模块
核心模块
核心模块是扩展模块构建的基础，到2.7版本为止，共有3个核心模块：
Streaming : jackson-core jar，定义了底层的streaming API和实现了Json特性。
Annotations: jackson-annotations jar，包含了标准的Jackson注解。本文暂不介绍。
Databind : jackson-databind jar，实现了数据绑定和对象序列化，它依赖于streaming和annotations的包。
Annotations: jackson-annotations jar，包含了标准的Jackson注解。本文暂不介绍。
Databind : jackson-databind jar，实现了数据绑定和对象序列化，它依赖于streaming和annotations的包。
第三方数据类型模块
这些扩展是插件式的Jackson模块，用ObjectMapper.registerModule()注册，并且通过添加serializers和deserializers以便Databind包（ObjectMapper / ObjectReader / ObjectWriter）可以读写这些类型，来增加对各种常用的Java库的数据类型的支持。参考https://github.com/FasterXML/jacksonThird-party datatype modules。
数据格式模块
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
准备工作
Jackson包含了一个核心的jar包和其他两个依赖于核心jar包的jar包，三者的依赖关系是从上到下的，如下：
Jackson Core
Jackson Annotations
Jackson Databind
Jackson Annotations
Jackson Databind
可以从https://github.com/FasterXML下载Jackson的jar包，或者采用maven来管理。如果是maven的方式，需要加入如下的依赖：
com.fasterxml.jackson.core
jackson-core
2.7.4
com.fasterxml.jackson.core
jackson-annotations
2.7.4
com.fasterxml.jackson.core
jackson-databind
2.7.4
处理Json
本文用JDK7.0的版本。Jackson提供了三种可选的Json处理方法：数据绑定(Data Binding)，流式API(Streaming API) 、树模型(Tree Model)。Data Binding
我们主要使用ObjectMapper来操作Json，默认情况下会使用BeanSerializer来序列化POJO。如果是解析，那么如下的例子里的TestJson必须要有setters，且setters必须是public修饰的，否则属性的值将会为null。如果是生成，那么必须有getters，且getters必须是public修饰的。如果属性不是private修饰，那么可以不用有getters和setters。这参考访问修饰符。
Json解析
public class Demo {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
// 当反序列化json时，未知属性会引起的反序列化被打断，这里我们禁用未知属性打断反序列化功能，
// 因为，例如json里有10个属性，而我们的bean中只定义了2个属性，其它8个属性将被忽略
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
//从json映射到java对象，得到country对象后就可以遍历查找,下面遍历部分内容，能说明问题就可以了
TestJson testJson = mapper.readValue("{\"a\":\"1\",\"b\":\"2\",\"c\":\"test\",\"d\":\"true\",\"e\":\"e\"}", TestJson.class);
System.out.println("a:" + testJson.getA());
System.out.println("b:" + testJson.getB());
System.out.println("c:" + testJson.getC());
System.out.println("d:" + testJson.getD());
}
}
class TestJson {
private Integer a;
private Integer b;
private String c;
private Boolean d;
public Integer getA() {
return a;
}
public void setA(Integer a) {
this.a = a;
}
public Integer getB() {
return b;
}
public void setB(Integer b) {
this.b = b;
}
public String getC() {
return c;
}
public void setC(String c) {
this.c = c;
}
public Boolean getD() {
return d;
}
public void setD(Boolean d) {
this.d = d;
}
}输出：
a:1
b:2
c:test
d:true
解析的时候如果碰到集合类，那么可以使用TypeReference类。
public static T json2Obj(String jsonStr, TypeReference typeReference, String dateFormat)
throws Exception {
ObjectMapper objectMapper = getObjectMapper();
if (dateFormat != null && !dateFormat.trim().equals("")) {
objectMapper.setDateFormat(new SimpleDateFormat(dateFormat));
}
return objectMapper.readValue(jsonStr, typeReference);
} Json生成
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.cfg.MapperConfig;
import com.fasterxml.jackson.databind.introspect.AnnotatedField;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
public class SerializationExample {
public static void main(String[] args) throws IOException, ParseException {
ObjectMapper mapper = new ObjectMapper();
Album album = new Album("Kind Of Blue");
album.setLinks(new String[]{"link1", "link2"});
List songs = new ArrayList();
songs.add("So What");
songs.add("Flamenco Sketches");
songs.add("Freddie Freeloader");
album.setSongs(songs);
Artist artist = new Artist();
artist.name = "Miles Davis";
SimpleDateFormat format = new SimpleDateFormat("dd-MM-yyyy");
artist.birthDate = format.parse("26-05-1926");
album.setArtist(artist);
album.addMusician("Miles Davis", "Trumpet, Band leader");
album.addMusician("Julian Adderley", "Alto Saxophone");
album.addMusician("Paul Chambers", "double bass");
//让Json可以缩进，可读性更好，一般用在测试和开发阶段。
mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
//让map的key按自然顺序排列
mapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true);
//日期输出格式
SimpleDateFormat outputFormat = new SimpleDateFormat("yyyy-MM-dd");
mapper.setDateFormat(outputFormat);
//默认情况下java类属性名就是输出的json字段名，但是可以采用注解的方式修改。如果你不想让java类和json绑定
// 或者无法修改java类，这里采用如下另外一种方式。你需要重写如下两个方法，这个取决属性是public或者getter是public
mapper.setPropertyNamingStrategy(new PropertyNamingStrategy() {
/**
* @param config Configuration in used: either SerializationConfig or DeserializationConfig, depending on whether method is called during serialization or deserialization
* @param field Field used to access property
* @param defaultName Default name that would be used for property in absence of custom strategy
* @return
*/
@Override
public String nameForField(MapperConfig config, AnnotatedField field, String defaultName) {
if (field.getFullName().equals("Artist#name"))
return "Artist-Name";
return super.nameForField(config, field, defaultName);
}
/**
* @param config Configuration in used: either SerializationConfig or DeserializationConfig, depending on whether method is called during serialization or deserialization
* @param method Method used to access property.
* @param defaultName Default name that would be used for property in absence of custom strategy
* @return
*/
@Override
public String nameForGetterMethod(MapperConfig config, AnnotatedMethod method, String defaultName) {
if (method.getAnnotated().getDeclaringClass().equals(Album.class) && defaultName.equals("title"))
return "Album-Title";
return super.nameForGetterMethod(config, method, defaultName);
}
});
//如果属性没有值，那么Json是会处理的，int类型为0，String类型为null，数组为[]，设置这个特性可以忽略空值属性
mapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
mapper.writeValue(System.out, album);
}
}
class Album {
private String title;
private String[] links;
private List songs = new ArrayList();
private Artist artist;
private Map musicians = new HashMap();
public Album(String title) {
this.title = title;
}
public String getTitle() {
return title;
}
public void setLinks(String[] links) {
this.links = links;
}
public String[] getLinks() {
return links;
}
public void setSongs(List songs) {
this.songs = songs;
}
public List getSongs() {
return songs;
}
public void setArtist(Artist artist) {
this.artist = artist;
}
public Artist getArtist() {
return artist;
}
public Map
getMusicians() {
return Collections.unmodifiableMap(musicians);
}
public void addMusician(String key, String value) {
musicians.put(key, value);
}
}
class Artist {
public String name;
public Date birthDate;
public int age;
public String homeTown;
public List awardsWon = new ArrayList();
} 输出：
{
"Album-Title" : "Kind Of Blue",
"links" : [ "link1", "link2" ],
"songs" : [ "So What", "Flamenco Sketches", "Freddie Freeloader" ],
"artist" : {
"Artist-Name" : "Miles Davis",
"birthDate" : "1926-05-26",
"age" : 0
},
"musicians" : {
"Julian Adderley" : "Alto Saxophone",
"Miles Davis" : "Trumpet, Band leader",
"Paul Chambers" : "double bass"
}
}Streaming API
Jackson提供了一套底层API来解析Json字符串，这个API为每个Json对象提供了符号。例如， '{' 是解析器提供的第一个对象（writeStartObject()），键值对是解析器提供的另一个单独对象（writeString(key,value)）。这些API很强大，但是需要大量的代码。大多数情况下，Tree Model和Data Binding可以代替Streaming API。
Json解析
public static void main(String[] args) throws IOException {
// 从JsonFactory获得一个JsonParser实例
JsonFactory factory = new JsonFactory();
//createParser有很多种重载，具体可以看API
JsonParser parser = factory.createParser("{\"title\":\"Free Music Archive - Albums\",\"message\":\"test\",\"errors\":[\"invalid or disabled api_key\"],\"dataset\":[{\"id\":\"1\"},{\"id\":\"2\"}]}");
// 解析符号直到字符串结尾
while (!parser.isClosed()) {
// 如果有必要的话，这个方法会沿着流前进直到足以确下一个JsonToken的类型
JsonToken token = parser.nextToken();
// 如果是最后一个JsonToken，那么就结束了
if (token == null)
break;
//如果JsonToken是JsonToken.FIELD_NAME类型并且当前的name是dataset
if (JsonToken.FIELD_NAME.equals(token) && "dataset".equals(parser.getCurrentName())) {
// 开始解析dateset，第一个JsonToken必须是JsonToken.START_ARRAY"["
token = parser.nextToken();
if (!JsonToken.START_ARRAY.equals(token)) {
break;
}
// 数组的每个元素都是对象，因此下一个JsonToken是JsonToken.START_OBJECT"{"
token = parser.nextToken();
if (!JsonToken.START_OBJECT.equals(token)) {
break;
}
// 输出id字段的值
while (true) {
token = parser.nextToken();
if (token == null)
break;
if (JsonToken.FIELD_NAME.equals(token) && "id".equals(parser.getCurrentName())) {
token = parser.nextToken();
System.out.println(parser.getText());
}
}
}
}
}
Json生成
public static void main(String[] args) throws IOException {
JsonFactory factory = new JsonFactory();
JsonGenerator generator = factory.createGenerator(new BufferedOutputStream(System.out));
generator.writeStartObject();//{
generator.writeFieldName("title");
generator.writeString("Free Music Archive - Albums");
generator.writeFieldName("dataset");
generator.writeStartArray();//[
generator.writeStartObject();//{
generator.writeStringField("album_title", "A.B.A.Y.A.M");
generator.writeEndObject();//}
generator.writeEndArray();//]
generator.writeEndObject();//}
//输出{"title":"Free Music Archive - Albums","dataset":[{"album_title":"A.B.A.Y.A.M"}]}
generator.close();
}Tree Mode
如果你不想为你的Json结构写一个class的话，Tree Mode是一个很好的选择。
JSON生成
public static void main(String[] args) throws IOException {
//创建一个提供所有节点的JsonNodeFactory,false表示不创建DecimalNode
JsonNodeFactory factory = new JsonNodeFactory(false);
// 创建JsonFactory，使用Streaming API的方式输出到控制台
JsonFactory jsonFactory = new JsonFactory();
JsonGenerator generator = jsonFactory.createGenerator(System.out);
ObjectMapper mapper = new ObjectMapper();
//创建节点和数据,一个ObjectNode代表一个节点对象
ObjectNode node1 = factory.objectNode();
ObjectNode node2 = factory.objectNode();
node1.put("A", "a");
node1.put("B", "b");
node2.set("C", node1);
// 根节点
ObjectNode root = factory.objectNode();
root.put("root", "root");
root.set("children", node2);
mapper.writeTree(generator, root);
//输出{"root":"root","children":{"C":{"A":"a","B":"b"}}}
}
Json解析
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
// 读取json，将整个json作为根节点
JsonNode node = mapper.readTree("{\"root\":\"root\",\"children\":{\"C\":{\"A\":\"a\",\"B\":\"b\"}}}");
// 看看根节点的类型
System.out.println("node JsonNodeType:" + node.getNodeType());//OBJECT
// 是不是一个ContainerNode（array and object nodes）
System.out.println("node is containerNode ? " + node.isContainerNode());//true
// 得到所有node节点的直接子节点名称
Iterator fieldNames = node.fieldNames();
while (fieldNames.hasNext()) {
String fieldName = fieldNames.next();
System.out.println(fieldName + " ");//root children
}
System.out.println(node.get("root").isContainerNode());//false
} 总结
这只是基本的用法，其他的如果有用到，再继续添加进来。