zoukankan      html  css  js  c++  java

  • jackson java对象和json对象的互相转换

    概述

    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
     
    1. package com.jackson.json.databinding;  
    2.   
    3. public class Province {  
    4.     public String name;  
    5.     public int population;  
    6.     public String[] city;     
    7. }  
    Country.java
    [java] view plain copy
     
    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. }  
    JavaBeanSerializeToJson.java
    [java] view plain copy
     
    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. }  
    程序运行后生成country.json，内容如下：
    [html] view plain copy
     
    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. }  
     
    (2)Json字符串反序列化为java对象：
    [java] view plain copy
     
    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 + " " + "population:"+province.population);  
    38.         }  
    39.     }  
    40. }  
    程序运行结果：
    [html] view plain copy
     
    1. country_id:China  
    2. birthDate:1949-10-01  
    3. province:Shanxi  
    4. population:37751200  
    5. province:ZheJiang  
    6. population:55080000  
     

    2.Tree Model处理Json

    (1)tree model生成json:

    [java] view plain copy
     
    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. }  

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

    [html] view plain copy
     
    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}}  

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

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

    [java] view plain copy
     
    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(" -----------------------------------------------------");  
    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. }  

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

    [html] view plain copy
     
    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  

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

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

    [java] view plain copy
     
    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. }  

    程序运行打印结果：

    [html] view plain copy
     
    1. JsonNodeType : MISSING  
    2. country_id:China  
    3. name:Shanxi  
    4. population:37751200  
    5. name:ZheJiang  
    6. population:55080000  

    3.Stream处理Json

    (1)stream生成json
    [java] view plain copy
     
    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. }  
    程序运行后生成country3.json文件内容：
    [html] view plain copy
     
    1. {"country_id":"China","provinces":[{"name":"Shanxi","population":33750000}]}  
     
    (2)stream解析json:
    现在adgcountry3.json，我们用Streaming API的方式来解析上面的Json,并查找json中population的值。
    [java] view plain copy
     
    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. }  
    程序运行后，在控制台打印结果如下：
    [html] view plain copy
     
    1. 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方法轻松查找内容。
  • 相关阅读:
    ld -l选项注意事项
    linux下创建用户(转)
    delete void *
    __attribute__机制介绍（转）
    正常断开连接情况下，判断非阻塞模式socket连接是否断开
    std::thread “terminate called without an active exception”
    Android 开发手记二 C可执行程序编译实例(转帖)
    c++11 on Android
    由一段小程序看算法复杂度
    Linux守护进程的编程实现(转)
  • 原文地址：https://www.cnblogs.com/UUUz/p/8750873.html
Copyright © 2011-2022 走看看