程序博客网 > 韩顺平满汉楼数据库

JackSon学习笔记(一)

来源：互联网 发布：韩顺平满汉楼数据库 编辑：程序博客网 时间：2024/05/20 20:55

概述

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
[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. package com.jackson.json.databinding;  
  2.   
  3. public class Province {  
  4.     public String name;  
  5.     public int population;  
  6.     public String[] city;     
  7. }  
package com.jackson.json.databinding;public class Province {    public String name;    public int population;    public String[] city;   }
Country.java
[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. package com.jackson.json.databinding;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Arrays;  
  5. import java.util.Date;  
  6. import java.util.HashMap;  
  7. import java.util.List;  
  8. import java.util.Map;  
  9.   
  10. public class Country {  
  11.     // 注意：被序列化的bean的private属性字段需要创建getter方法或者属性字段应该为public  
  12.     private String country_id;  
  13.     private Date birthDate;  
  14.     private List<String> nation = new ArrayList<String>();  
  15.     private String[] lakes;  
  16.     private List<Province> provinces = new ArrayList<Province>();  
  17.     private Map<String, Integer> traffic = new HashMap<String, Integer>();  
  18.   
  19.     public Country() {  
  20.         // TODO Auto-generated constructor stub  
  21.     }  
  22.   
  23.     public Country(String countryId) {  
  24.         this.country_id = countryId;  
  25.     }  
  26.   
  27.     public String getCountry_id() {  
  28.         return country_id;  
  29.     }  
  30.   
  31.     public void setCountry_id(String country_id) {  
  32.         this.country_id = country_id;  
  33.     }  
  34.   
  35.     public Date getBirthDate() {  
  36.         return birthDate;  
  37.     }  
  38.   
  39.     public void setBirthDate(Date birthDate) {  
  40.         this.birthDate = birthDate;  
  41.     }  
  42.   
  43.     public List<String> getNation() {  
  44.         return nation;  
  45.     }  
  46.   
  47.     public void setNation(List<String> nation) {  
  48.         this.nation = nation;  
  49.     }  
  50.   
  51.     public String[] getLakes() {  
  52.         return lakes;  
  53.     }  
  54.   
  55.     public void setLakes(String[] lakes) {  
  56.         this.lakes = lakes;  
  57.     }  
  58.   
  59.     public Integer get(String key) {  
  60.         return traffic.get(key);  
  61.     }  
  62.   
  63.     public Map<String, Integer> getTraffic() {  
  64.         return traffic;  
  65.     }  
  66.   
  67.     public void setTraffic(Map<String, Integer> traffic) {  
  68.         this.traffic = traffic;  
  69.     }  
  70.   
  71.     public void addTraffic(String key, Integer value) {  
  72.         traffic.put(key, value);  
  73.     }  
  74.   
  75.     public List<Province> getProvinces() {  
  76.         return provinces;  
  77.     }  
  78.   
  79.     public void setProvinces(List<Province> provinces) {  
  80.         this.provinces = provinces;  
  81.     }  
  82.   
  83.     @Override  
  84.     public String toString() {  
  85.         return “Country [country_id=” + country_id + “, birthDate=” + birthDate  
  86.                 + ”, nation=” + nation + “, lakes=” + Arrays.toString(lakes)  
  87.                 + ”, province=” + provinces + “, traffic=” + traffic + “]”;  
  88.     }  
  89.   
  90. }  
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
[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. package com.jackson.json.databinding;  
  2.   
  3. import java.io.File;  
  4. import java.text.SimpleDateFormat;  
  5. import java.util.ArrayList;  
  6. import java.util.List;  
  7.   
  8. import com.fasterxml.jackson.annotation.JsonInclude.Include;  
  9. import com.fasterxml.jackson.databind.ObjectMapper;  
  10. import com.fasterxml.jackson.databind.SerializationFeature;  
  11.   
  12. public class JavaBeanSerializeToJson {  
  13.   
  14.     public static void convert() throws Exception {  
  15.         // 使用ObjectMapper来转化对象为Json  
  16.         ObjectMapper mapper = new ObjectMapper();  
  17.         // 添加功能，让时间格式更具有可读性  
  18.         SimpleDateFormat dateFormat = new SimpleDateFormat(“yyyy-MM-dd”);  
  19.         mapper.setDateFormat(dateFormat);  
  20.   
  21.         Country country = new Country(“China”);  
  22.         country.setBirthDate(dateFormat.parse(”1949-10-01”));  
  23.         country.setLakes(new String[] { “Qinghai Lake”, “Poyang Lake”,  
  24.                 ”Dongting Lake”, “Taihu Lake” });  
  25.   
  26.         List<String> nation = new ArrayList<String>();  
  27.         nation.add(”Han”);  
  28.         nation.add(”Meng”);  
  29.         nation.add(”Hui”);  
  30.         nation.add(”WeiWuEr”);  
  31.         nation.add(”Zang”);  
  32.         country.setNation(nation);  
  33.   
  34.         Province province = new Province();  
  35.         province.name = ”Shanxi”;  
  36.         province.population = 37751200;  
  37.         Province province2 = new Province();  
  38.         province2.name = ”ZheJiang”;  
  39.         province2.population = 55080000;  
  40.         List<Province> provinces = new ArrayList<Province>();  
  41.         provinces.add(province);  
  42.         provinces.add(province2);  
  43.         country.setProvinces(provinces);  
  44.           
  45.         country.addTraffic(”Train(KM)”, 112000);  
  46.         country.addTraffic(”HighWay(KM)”, 4240000);  
  47.         // 为了使JSON视觉上的可读性，增加一行如下代码，注意，在生产中不需要这样，因为这样会增大Json的内容  
  48.         mapper.configure(SerializationFeature.INDENT_OUTPUT, true);  
  49.         // 配置mapper忽略空属性  
  50.         mapper.setSerializationInclusion(Include.NON_EMPTY);  
  51.         // 默认情况，Jackson使用Java属性字段名称作为 Json的属性名称,也可以使用Jackson annotations(注解)改变Json属性名称  
  52.         mapper.writeValue(new File(“country.json”), country);  
  53.     }  
  54.   
  55.     public static void main(String[] args) throws Exception {  
  56.         convert();  
  57.     }  
  58.   
  59. }  
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，内容如下：
[html] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. {  
  2.   “country_id” : “China”,  
  3.   “birthDate” : “1949-10-01”,  
  4.   “nation” : [ “Han”, “Meng”, “Hui”, “WeiWuEr”, “Zang” ],  
  5.   “lakes” : [ “Qinghai Lake”, “Poyang Lake”, “Dongting Lake”, “Taihu Lake” ],  
  6.   “provinces” : [ {  
  7.     “name” : “Shanxi”,  
  8.     “population” : 37751200  
  9.   }, {  
  10.     “name” : “ZheJiang”,  
  11.     “population” : 55080000  
  12.   } ],  
  13.   “traffic” : {  
  14.     “HighWay(KM)” : 4240000,  
  15.     “Train(KM)” : 112000  
  16.   }  
  17. }  
{  "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对象：
[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. package com.jackson.json.databinding;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException;  
  5. import java.text.SimpleDateFormat;  
  6. import java.util.Iterator;  
  7. import java.util.List;  
  8.   
  9. import com.fasterxml.jackson.core.JsonParseException;  
  10. import com.fasterxml.jackson.databind.DeserializationFeature;  
  11. import com.fasterxml.jackson.databind.JsonMappingException;  
  12. import com.fasterxml.jackson.databind.ObjectMapper;  
  13.   
  14. /** 
  15.  * 将Json字符串反序列化为Java对象 
  16.  */  
  17. public class JsonDeserializeToJava {  
  18.       
  19.     public static void main(String[] args) throws Exception {  
  20.         //ObjectMapper类用序列化与反序列化映射器  
  21.         ObjectMapper mapper = new ObjectMapper();  
  22.         File json = new File(“country.json”);  
  23.         //当反序列化json时，未知属性会引起的反序列化被打断，这里我们禁用未知属性打断反序列化功能，  
  24.         //因为，例如json里有10个属性，而我们的bean中只定义了2个属性，其它8个属性将被忽略  
  25.         mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);  
  26.           
  27.         //从json映射到java对象，得到country对象后就可以遍历查找,下面遍历部分内容，能说明问题就可以了  
  28.         Country country = mapper.readValue(json, Country.class);  
  29.         System.out.println(”country_id:”+country.getCountry_id());  
  30.         //设置时间格式，便于阅读  
  31.         SimpleDateFormat dateformat = new SimpleDateFormat(“yyyy-MM-dd”);  
  32.         String birthDate = dateformat.format(country.getBirthDate());  
  33.         System.out.println(”birthDate:”+birthDate);  
  34.           
  35.         List<Province> provinces = country.getProvinces();  
  36.         for (Province province : provinces) {  
  37.             System.out.println(”province:”+province.name + “\n” + “population:”+province.population);  
  38.         }  
  39.     }  
  40. }  
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);        }    }}
程序运行结果：
[html] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. country_id:China  
  2. birthDate:1949-10-01  
  3. province:Shanxi  
  4. population:37751200  
  5. province:ZheJiang  
  6. population:55080000  
country_id:ChinabirthDate:1949-10-01province:Shanxipopulation:37751200province:ZheJiangpopulation:55080000

2.Tree Model处理Json

(1)tree model生成json:

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. package com.jackson.json.treemodel;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileWriter;  
  5.   
  6. import com.fasterxml.jackson.core.JsonFactory;  
  7. import com.fasterxml.jackson.core.JsonGenerator;  
  8. import com.fasterxml.jackson.databind.ObjectMapper;  
  9. import com.fasterxml.jackson.databind.SerializationFeature;  
  10. import com.fasterxml.jackson.databind.node.ArrayNode;  
  11. import com.fasterxml.jackson.databind.node.JsonNodeFactory;  
  12. import com.fasterxml.jackson.databind.node.ObjectNode;  
  13.   
  14. public class SerializationExampleTreeModel {  
  15.       
  16.     public static void main(String[] args) throws Exception {  
  17.         //创建一个节点工厂,为我们提供所有节点  
  18.         JsonNodeFactory factory = new JsonNodeFactory(false);  
  19.         //创建一个json factory来写tree modle为json  
  20.         JsonFactory jsonFactory = new JsonFactory();  
  21.         //创建一个json生成器  
  22.         JsonGenerator generator = jsonFactory.createGenerator(new FileWriter(new File(“country2.json”)));  
  23.         //注意，默认情况下对象映射器不会指定根节点，下面设根节点为country  
  24.         ObjectMapper mapper = new ObjectMapper();  
  25.         ObjectNode country = factory.objectNode();  
  26.           
  27.         country.put(”country_id”, “China”);  
  28.         country.put(”birthDate”, “1949-10-01”);  
  29.           
  30.         //在Java中，List和Array转化为json后对应的格式符号都是”obj:[]”  
  31.         ArrayNode nation = factory.arrayNode();  
  32.         nation.add(”Han”).add(“Meng”).add(“Hui”).add(“WeiWuEr”).add(“Zang”);  
  33.         country.set(”nation”, nation);  
  34.           
  35.         ArrayNode lakes = factory.arrayNode();  
  36.         lakes.add(”QingHai Lake”).add(“Poyang Lake”).add(“Dongting Lake”).add(“Taihu Lake”);  
  37.         country.set(”lakes”, lakes);  
  38.           
  39.         ArrayNode provinces = factory.arrayNode();  
  40.         ObjectNode province = factory.objectNode();  
  41.         ObjectNode province2 = factory.objectNode();  
  42.         province.put(”name”,“Shanxi”);  
  43.         province.put(”population”, 37751200);  
  44.         province2.put(”name”,“ZheJiang”);  
  45.         province2.put(”population”, 55080000);  
  46.         provinces.add(province).add(province2);  
  47.         country.set(”provinces”, provinces);  
  48.           
  49.         ObjectNode traffic = factory.objectNode();  
  50.         traffic.put(”HighWay(KM)”, 4240000);  
  51.         traffic.put(”Train(KM)”, 112000);  
  52.         country.set(”traffic”, traffic);  
  53.           
  54.         mapper.configure(SerializationFeature.INDENT_OUTPUT, true);  
  55.         mapper.writeTree(generator, country);  
  56.     }  
  57.   
  58. }  
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,内容如下：

[html] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. {“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}}  
{"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的类型变化

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. package com.jackson.json.treemodel;  
  2.   
  3. import java.io.File;  
  4. import java.util.Iterator;  
  5.   
  6. import com.fasterxml.jackson.databind.JsonNode;  
  7. import com.fasterxml.jackson.databind.ObjectMapper;  
  8.   
  9. public class DeserializationExampleTreeModel1 {  
  10.   
  11.     public static void main(String[] args) throws Exception {  
  12.         ObjectMapper mapper = new ObjectMapper();  
  13.         // Jackson提供一个树节点被称为”JsonNode”,ObjectMapper提供方法来读json作为树的JsonNode根节点  
  14.         JsonNode node = mapper.readTree(new File(“country2.json”));  
  15.         // 看看根节点的类型  
  16.         System.out.println(”node JsonNodeType:”+node.getNodeType());  
  17.         // 是不是一个容器  
  18.         System.out.println(”node is container Node ? ”+node.isContainerNode());  
  19.         // 得到所有node节点的子节点名称  
  20.         System.out.println(”———得到所有node节点的子节点名称————————-“);  
  21.         Iterator<String> fieldNames = node.fieldNames();  
  22.         while (fieldNames.hasNext()) {  
  23.             String fieldName = fieldNames.next();  
  24.             System.out.print(fieldName+” ”);  
  25.         }  
  26.         System.out.println(”\n—————————————————–”);  
  27.         // as.Text的作用是有值返回值，无值返回空字符串  
  28.         JsonNode country_id = node.get(”country_id”);  
  29.         System.out.println(”country_id:”+country_id.asText() + “ JsonNodeType:”+country_id.getNodeType());  
  30.           
  31.         JsonNode birthDate = node.get(”birthDate”);  
  32.         System.out.println(”birthDate:”+birthDate.asText()+“ JsonNodeType:”+birthDate.getNodeType());  
  33.           
  34.         JsonNode nation = node.get(”nation”);  
  35.         System.out.println(”nation:”+ nation+ “ JsonNodeType:”+nation.getNodeType());  
  36.           
  37.         JsonNode lakes = node.get(”lakes”);  
  38.         System.out.println(”lakes:”+lakes+“ JsonNodeType:”+lakes.getNodeType());  
  39.   
  40.         JsonNode provinces = node.get(”provinces”);  
  41.         System.out.println(”provinces JsonNodeType:”+provinces.getNodeType());  
  42.   
  43.         boolean flag = true;  
  44.         for (JsonNode provinceElements : provinces) {  
  45.             //为了避免provinceElements多次打印，用flag控制打印，能体现provinceElements的JsonNodeType就可以了  
  46.             if(flag){  
  47.                 System.out.println(”provinceElements JsonNodeType:”+provinceElements.getNodeType());  
  48.                 System.out.println(”provinceElements is container node? ”+provinceElements.isContainerNode());  
  49.                 flag = false;  
  50.             }  
  51.             Iterator<String> provinceElementFields = provinceElements.fieldNames();  
  52.             while (provinceElementFields.hasNext()) {  
  53.                 String fieldName = (String) provinceElementFields.next();  
  54.                 String province;  
  55.                 if (“population”.equals(fieldName)) {  
  56.                     province = fieldName + ”:” + provinceElements.get(fieldName).asInt();  
  57.                 }else{  
  58.                     province = fieldName + ”:” + provinceElements.get(fieldName).asText();  
  59.                 }  
  60.                 System.out.println(province);  
  61.             }  
  62.         }  
  63.     }  
  64. }  
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);            }        }    }}

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

[html] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. node JsonNodeType:OBJECT  
  2. node is container Node ? true  
  3. ———得到所有node节点的子节点名称————————-  
  4. country_id birthDate nation lakes provinces traffic   
  5. —————————————————–  
  6. country_id:China JsonNodeType:STRING  
  7. birthDate:1949-10-01 JsonNodeType:STRING  
  8. nation:[“Han”,”Meng”,”Hui”,”WeiWuEr”,”Zang”] JsonNodeType:ARRAY  
  9. lakes:[“QingHai Lake”,”Poyang Lake”,”Dongting Lake”,”Taihu Lake”] JsonNodeType:ARRAY  
  10. provinces JsonNodeType:ARRAY  
  11. provinceElements JsonNodeType:OBJECT  
  12. provinceElements is container node? true  
  13. name:Shanxi  
  14. population:37751200  
  15. name:ZheJiang  
  16. population:55080000  
node JsonNodeType:OBJECTnode is container Node ? true---------得到所有node节点的子节点名称-------------------------
country_id birthDate nation lakes provinces traffic -----------------------------------------------------country_id:China JsonNodeType:STRINGbirthDate:1949-10-01 JsonNodeType:STRINGnation:["Han","Meng","Hui","WeiWuEr","Zang"] JsonNodeType:ARRAYlakes:["QingHai Lake","Poyang Lake","Dongting Lake","Taihu Lake"] JsonNodeType:ARRAYprovinces JsonNodeType:ARRAYprovinceElements JsonNodeType:OBJECTprovinceElements is container node? truename:Shanxipopulation:37751200name:ZheJiangpopulation:55080000


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

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

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. package com.jackson.json.treemodel;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException;  
  5. import java.util.Iterator;  
  6.   
  7. import com.fasterxml.jackson.core.JsonProcessingException;  
  8. import com.fasterxml.jackson.databind.JsonNode;  
  9. import com.fasterxml.jackson.databind.ObjectMapper;  
  10.   
  11. public class DeserializationExampleTreeModle2 {  
  12.       
  13.     public static void main(String[] args) throws JsonProcessingException, IOException{  
  14.         ObjectMapper mapper = new ObjectMapper();  
  15.         JsonNode node = mapper.readTree(new File(“country2.json”));  
  16.         //path方法获取JsonNode时，当对象不存在时，返回MISSING类型的JsonNode  
  17.         JsonNode missingNode = node.path(”test”);  
  18.         if(missingNode.isMissingNode()){  
  19.             System.out.println(”JsonNodeType : ” + missingNode.getNodeType());  
  20.         }  
  21.   
  22.         System.out.println(”country_id:”+node.path(“country_id”).asText());  
  23.           
  24.         JsonNode provinces = node.path(”provinces”);  
  25.         for (JsonNode provinceElements : provinces) {  
  26.             Iterator<String> provincesFields = provinceElements.fieldNames();  
  27.             while (provincesFields.hasNext()) {  
  28.                 String fieldName = (String) provincesFields.next();  
  29.                 String province;  
  30.                 if(“name”.equals(fieldName)){  
  31.                     province = fieldName +”:”+ provinceElements.path(fieldName).asText();  
  32.                 }else{  
  33.                     province = fieldName +”:”+ provinceElements.path(fieldName).asInt();  
  34.                 }  
  35.                 System.out.println(province);  
  36.             }  
  37.         }  
  38.     }  
  39.   
  40. }  
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);            }        }    }}
程序运行打印结果：
[html] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. JsonNodeType : MISSING  
  2. country_id:China  
  3. name:Shanxi  
  4. population:37751200  
  5. name:ZheJiang  
  6. population:55080000  
JsonNodeType : MISSINGcountry_id:Chinaname:Shanxipopulation:37751200name:ZheJiangpopulation:55080000

3.Stream处理Json

(1)stream生成json

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. package com.jackson.json.streaming;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileWriter;  
  5. import java.io.Exception;  
  6.   
  7. import com.fasterxml.jackson.core.JsonFactory;  
  8. import com.fasterxml.jackson.core.JsonGenerator;  
  9.   
  10. public class StreamGeneratorJson {  
  11.       
  12.     public static void main(String[] args) throws Exception {  
  13.         JsonFactory factory = new JsonFactory();  
  14.         //从JsonFactory创建一个JsonGenerator生成器的实例  
  15.         JsonGenerator generator = factory.createGenerator(new FileWriter(new File(“country3.json”)));  
  16.           
  17.         generator.writeStartObject();  
  18.         generator.writeFieldName(”country_id”);  
  19.         generator.writeString(”China”);  
  20.         generator.writeFieldName(”provinces”);  
  21.         generator.writeStartArray();  
  22.         generator.writeStartObject();  
  23.         generator.writeStringField(”name”, “Shanxi”);  
  24.         generator.writeNumberField(”population”, 33750000);  
  25.         generator.writeEndObject();  
  26.         generator.writeEndArray();  
  27.         generator.writeEndObject();  
  28.           
  29.         generator.close();  
  30.     }  
  31.   
  32. }  
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文件内容：
[html] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. {“country_id”:”China”,”provinces”:[{“name”:”Shanxi”,”population”:33750000}]}  
{"country_id":"China","provinces":[{"name":"Shanxi","population":33750000}]}

(2)stream解析json:
现在adgcountry3.json，我们用Streaming API的方式来解析上面的Json,并查找json中population的值。
[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. package com.jackson.json.streaming;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException;  
  5.   
  6. import com.fasterxml.jackson.core.JsonFactory;  
  7. import com.fasterxml.jackson.core.JsonParseException;  
  8. import com.fasterxml.jackson.core.JsonParser;  
  9. import com.fasterxml.jackson.core.JsonToken;  
  10.   
  11. /*Jackson API提供了token对每个Json对象，例如，Json开始符号“{”是token指向的第一个解析的对象， 
  12.  key:value键值对是另一个单独的对象。这个API很强大，但也需要编写大量代码。不推荐使用，平时更多的是使用DataBinding和TreeModel来处理json 
  13.  */  
  14. public class StreamParserJson {  
  15.     public static void main(String[] args) throws JsonParseException,  
  16.             IOException {  
  17.         JsonFactory factory = new JsonFactory();  
  18.         // 从JsonFactory创建JsonParser解析器的实例  
  19.         JsonParser parser = factory.createParser(new File(“country3.json”));  
  20.   
  21.         while (!parser.isClosed()) {  
  22.             // 得到一个token,第一次遍历时，token指向json文件中第一个符号”{“  
  23.             JsonToken token = parser.nextToken();  
  24.             if (token == null) {  
  25.                 break;  
  26.             }  
  27.             // 我们只查找 country3.json中的”population”字段的值，能体现解析的流程就可以了  
  28.             // 当key是provinces时，我们进入provinces,查找population  
  29.             if (JsonToken.FIELD_NAME.equals(token)  
  30.                     && ”provinces”.equals(parser.getCurrentName())) {  
  31.                 token = parser.nextToken();  
  32.                 if (!JsonToken.START_ARRAY.equals(token)) {  
  33.                     break;  
  34.                 }  
  35.                 // 此时，token指向的应该是”{“  
  36.                 token = parser.nextToken();  
  37.                 if (!JsonToken.START_OBJECT.equals(token)) {  
  38.                     break;  
  39.                 }  
  40.                 while (true) {  
  41.                     token = parser.nextToken();  
  42.                     if (token == null) {  
  43.                         break;  
  44.                     }  
  45.                     if (JsonToken.FIELD_NAME.equals(token)  
  46.                             && ”population”.equals(parser.getCurrentName())) {  
  47.                         token = parser.nextToken();  
  48.                         System.out.println(parser.getCurrentName() + ” : ”  
  49.                                 + parser.getIntValue());  
  50.                     }  
  51.                 }  
  52.             }  
  53.         }  
  54.     }  
  55.   
  56. }  
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());                    }                }            }        }    }}
程序运行后，在控制台打印结果如下：
[html] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. population : 33750000  
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://www.cnblogs.com/lee0oo0/articles/2652528.html
0 0
韩顺平满汉楼数据库 韩顺平满汉楼数据库
原创粉丝点击
热门IT博客
最快速的排序算法最快速的排序算法
安卓编程安卓编程
菏泽网络推广
新丰县网络问政乙
mysql主键 增加
北京seo公司 华网天下
吉宝置业 知乎
通过大数据分析
单片机触摸按键
签名设计免费版软件
新浪期货软件下载
linux下telnet命令
火车头采集数据导出
便携加湿器推荐知乎
烘干机 知乎
淘宝桑濑鱼碳素线真
淘宝一伍一拾
欧盟个人数据保护指令
gm预测软件下载
炸鸡叔 绝命毒师 知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 波兰精馏伏特加 酩馏青稞酒价格表 精馏实验报告 血管馏 酩馏酒750装价格 干馏是物理变化还是化学变化 四马分肥 半马一小时40分什么水平 四马分肥名词解释 库兹马41分 四马分肥是指 马姓女孩起名100分 四马分肥包括哪四个方面 一个马 女生齐耳三七分短发 女生齐耳短发 齐姓女孩名字100分 齐刘海留中分 齐刘海怎么变中分 齐刘海怎么分三角区图解 切 鬼切 切接 空切 安吉利卡科切娃 疯狂切菜 切玉红龙咆哮 白切鸡 桑切斯梅开二度 白切鸡做法 真实割奶切阴 切辣椒手辣怎么办 切格瓦拉 切辣椒手辣 公主切 切辣椒后手很辣怎么办 桑切斯两分钟梅开二度 红龙咆哮切玉 宫颈锥切术 切勿头向东脚向西 公主切发型

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里