Jackson入门教程

最新推荐文章于 2024-06-13 15:05:55 发布

VoidMe

最新推荐文章于 2024-06-13 15:05:55 发布

阅读量2.3k

点赞数 1

分类专栏： java

java 专栏收录该内容

120 篇文章 0 订阅

订阅专栏

转载自：http://blog.csdn.net/gjb724332682/article/details/51586701

简介

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的包。

第三方数据类型模块

这些扩展是插件式的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

可以从https://github.com/FasterXML下载Jackson的jar包，或者采用maven来管理。如果是maven的方式，需要加入如下的依赖：

[html]view plaincopy 
    
print?
 <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>  

处理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解析

[java]view plaincopy 
    
print?
 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;  
     }  
 }  

[java]view plaincopy 
    
print?
 输出：  
 a:1  
 b:2  
 c:test  
 d:true  

解析的时候如果碰到集合类，那么可以使用TypeReference<T>类。

[java]view plaincopy 
     
print?
 public static <T> T json2Obj(String jsonStr, TypeReference<T> 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生成

[java]view plaincopy 
    
print?
 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<String> songs = new ArrayList<String>();  
         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<String> songs = new ArrayList<String>();  
     private Artist artist;  
     private Map<String, String> musicians = new HashMap<String, String>();  
   
   
     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<String> songs) {  
         this.songs = songs;  
     }  
   
   
     public List<String> getSongs() {  
         return songs;  
     }  
   
   
     public void setArtist(Artist artist) {  
         this.artist = artist;  
     }  
   
   
     public Artist getArtist() {  
         return artist;  
     }  
   
   
     public Map<String, String>  
   
   
     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<String> awardsWon = new ArrayList<String>();  
 }  

[java]view plaincopy 
    
print?
 输出：  
 {  
   "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解析

[java]view plaincopy 
    
print?
 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生成

[java]view plaincopy 
     
print?
 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生成

[java]view plaincopy 
    
print?
 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解析

[java]view plaincopy 
    
print?
 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<String> fieldNames = node.fieldNames();  
         while (fieldNames.hasNext()) {  
             String fieldName = fieldNames.next();  
             System.out.println(fieldName + " ");//root children  
         }  
         System.out.println(node.get("root").isContainerNode());//false  
     }  

总结

这只是基本的用法，其他的如果有用到，再继续添加进来。

VoidMe

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Jackson入门教程

转载自：http://blog.csdn.net/gjb724332682/article/details/51586701相关地址Jackson Home Page:https://github.com/FasterXML/jacksonJackson Wiki:http://wiki.fasterxml.com/JacksonHomeJackson doc: https
复制链接

扫一扫