FastJSON、Jackson和Gson用法

前端之家收集整理的这篇文章主要介绍了FastJSON、Jackson和Gson用法前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。
一、JSON规范
JSON是一个标准规范,用于数据交互,规范的中文文档如下:
http://www.json.org/json-zh.html
参看规范,来对比JSON类库处理结果。

二、fastjson的一些简要说明
Fastjson是一个Java语言编写的JSON处理器。
1、遵循http://json.org标准,为其官方网站收录的参考实现之一。
2、功能qiang打,支持JDK的各种类型,包括基本的JavaBean、Collection、Map、Date、Enum、泛型。
3、无依赖,不需要例外额外的jar,能够直接跑在JDK上。
4、开源,使用Apache License 2.0协议开源。http://code.alibabatech.com/wiki/display/FastJSON/Home
如果获得Fastjson?
SVN:http://code.alibabatech.com/svn/fastjson/trunk/
WIKI:http://code.alibabatech.com/wiki/display/FastJSON/Home
Issue Tracking:http://code.alibabatech.com/jira/browse/FASTJSON

三、主要的使用入口

Fastjson API入口类是com.alibaba.fastjson.JSON,常用的序列化操作都可以在JSON类上的静态方法直接完成。

  1. public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray
  2. public static final JSONObject parSEObject(String text); // 把JSON文本parse成JSONObject
  3. public static final <T> T parSEObject(String text,Class<T> clazz); // 把JSON文本parse为JavaBean
  4. public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray
  5. public static final <T> List<T> parseArray(String text,Class<T> clazz); //把JSON文本parse成JavaBean集合
  6. public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本
  7. public static final String toJSONString(Object object,boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本
  8. public static final Object toJSON(Object javaObject); JavaBean转换为JSONObject或者JSONArray

测试代码

  1. package dhp.com.test;
  2.  
  3. public class Userinfo {
  4. private String name;
  5. private int age;
  6.  
  7. public Userinfo() {
  8. super();
  9. }
  10.  
  11. public Userinfo(String name,int age) {
  12. super();
  13. this.name = name;
  14. this.age = age;
  15. }
  16.  
  17. public void setName(String name) {
  18. this.name = name;
  19. }
  20.  
  21. public String getName() {
  22. return name;
  23. }
  24.  
  25. public void setAge(int age) {
  26. this.age = age;
  27. }
  28.  
  29. public int getAge() {
  30. return age;
  31. }
  32. }

  1. package dhp.com.test;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import java.util.Date;
  6. import java.util.HashMap;
  7. import java.util.List;
  8. import java.util.Vector;
  9.  
  10. import com.alibaba.fastjson.JSON;
  11. import com.alibaba.fastjson.JSONArray;
  12. import com.alibaba.fastjson.JSONObject;
  13. import com.alibaba.fastjson.serializer.SerializerFeature;
  14.  
  15. /**
  16. * fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器,来自阿里巴巴的工程师开发。
  17. * 主要特点:
  18. * 1.快速FAST(比其它任何基于Java的解析器和生成器更快,包括jackson) 强大
  19. * (支持普通JDK类包括任意Java Bean
  20. * 2.Class、Collection、Map、Date或enum) 零依赖(没有依赖其它任何类库除了JDK)
  21. *
  22. */
  23. public class TestFastJson {
  24. public static void main(String[] args) {
  25. String json = "{\"name\":\"chenggang\",\"age\":24}";
  26. String arrayAyy = "[[\'马云',50],null,[\'马化腾',30]]";
  27. //Entity2json("zhangsan",24);
  28. //list2Json();
  29. //Complexdata();
  30. Deserialization(json);
  31. DateFormate(new Date());
  32. //Json2Eetity(json);
  33. //String2JSONArray(arrayAyy);
  34. }
  35.  
  36. // 实体转为Json
  37. public static void Entity2json(String name,int age) {
  38. Userinfo info = new Userinfo(name,age);
  39. String str_json = JSON.toJSONString(info); //
  40. System.out.println("实体转化为Json" + str_json);
  41. }
  42.  
  43. // list转Json
  44. public static void list2Json() {
  45. List<Userinfo> list = new ArrayList<Userinfo>();
  46. Userinfo userinfo1 = new Userinfo("lisi",15);
  47. Userinfo userinfo2 = new Userinfo("wangwu",16);
  48. list.add(userinfo1);
  49. list.add(userinfo2);
  50. String json = JSON.toJSONString(list,true);
  51. System.out.println("List集合转json格式字符串 :" + json);
  52. }
  53.  
  54. // 字符数组转化为JSon
  55. private static void String2JSONArray(String arrayAyy) {
  56. JSONArray array = JSONArray.parseArray(arrayAyy);
  57. System.out.println("数组:" + array);
  58. System.out.println("数组长度: " + array.size());
  59. Collection nuCon = new Vector();
  60. nuCon.add(null);
  61. array.removeAll(nuCon);
  62. System.out.println("数组:" + array);
  63. System.out.println("数组长度: " + array.size());
  64. }
  65.  
  66. // 复杂数据类型
  67. public static void Complexdata() {
  68. HashMap<String,Object> map = new HashMap<String,Object>();
  69. map.put("username","zhangsan");
  70. map.put("age",24);
  71. map.put("sex","男");
  72.  
  73. // map集合
  74. HashMap<String,Object> temp = new HashMap<String,Object>();
  75. temp.put("name","xiaohong");
  76. temp.put("age","23");
  77. map.put("girlInfo",temp);
  78.  
  79. // list集合
  80. List<String> list = new ArrayList<String>();
  81. list.add("爬山");
  82. list.add("骑车");
  83. list.add("旅游");
  84. map.put("hobby",list);
  85. String jsonString = JSON.toJSONString(map);
  86. System.out.println("复杂数据类型:" + jsonString);
  87. }
  88.  
  89. public static void Deserialization(String json) {
  90. Userinfo userInfo = JSON.parSEObject(json,Userinfo.class);
  91. System.out.println("姓名是:" + userInfo.getName() + ",年龄是:" + userInfo.getAge());
  92. }
  93.  
  94. // 格式话日期
  95. public static void DateFormate(Date date) {
  96. System.out.println("输出毫秒值:" + JSON.toJSONString(date));
  97. System.out.println("默认格式为:" + JSON.toJSONString(date,SerializerFeature.WriteDateUseDateFormat));
  98. System.out.println("自定义日期:"
  99. + JSON.toJSONStringWithDateFormat(date,"yyyy-MM-dd",SerializerFeature.WriteDateUseDateFormat));
  100. }
  101.  
  102. // Json转为实体
  103. private static void Json2Eetity(String json) {
  104. Userinfo userInfo = JSON.parSEObject(json,Userinfo.class);
  105. System.out.println("输出对象的地址:" + userInfo.toString());
  106. System.out.println("输出对象的名字:" + userInfo.getName());
  107. }
  108. }

有关需要带类型的全类型序列化过程,需要调用JSON.toJSONString()方法
需要美化输出时候,需要打开序列化美化开关,在方法中true那个参数。


四、Jackson提供了很多类和方法,而在序列化和反序列化中使用的最多的类则是ObjectMapper这个类,此类中提供了readTree(),readValue(),writeValueAsString()等方法用于转换。

  1. package dhp.com.test2;
  2.  
  3. public class Name {
  4. private String firstName;
  5. private String lastName;
  6.  
  7. public Name() {
  8. }
  9.  
  10. public Name(String firstName,String lastName) {
  11. this.firstName = firstName;
  12. this.lastName = lastName;
  13. }
  14.  
  15. public String getFirstName() {
  16. return firstName;
  17. }
  18.  
  19. public void setFirstName(String firstName) {
  20. this.firstName = firstName;
  21. }
  22.  
  23. public String getLastName() {
  24. return lastName;
  25. }
  26.  
  27. public void setLastName(String lastName) {
  28. this.lastName = lastName;
  29. }
  30.  
  31. public String toString() {
  32. return firstName + " " + lastName;
  33. }
  34. }

  1. package dhp.com.test2;
  2.  
  3. import java.util.Date;
  4.  
  5. public class Student {
  6. private int id;
  7. private Name name;
  8. private String className;
  9. private Date birthDay;
  10.  
  11. public Student() {
  12. }
  13.  
  14. public Student(int id,Name name,String className,Date birthDay) {
  15. super();
  16. this.id = id;
  17. this.name = name;
  18. this.className = className;
  19. this.birthDay = birthDay;
  20. }
  21.  
  22. public int getId() {
  23. return id;
  24. }
  25.  
  26. public void setId(int id) {
  27. this.id = id;
  28. }
  29.  
  30. public Name getName() {
  31. return name;
  32. }
  33.  
  34. public void setName(Name name) {
  35. this.name = name;
  36. }
  37.  
  38. public Date getBirthDay() {
  39. return birthDay;
  40. }
  41.  
  42. public void setBirthDay(Date birthDay) {
  43. this.birthDay = birthDay;
  44. }
  45.  
  46. public String getClassName() {
  47. return className;
  48. }
  49.  
  50. public void setClassName(String className) {
  51. this.className = className;
  52. }
  53.  
  54. @Override
  55. public String toString() {
  56. return "Student [birthDay=" + birthDay + ",id=" + id + ",name=" + name + ",classname=" + className + "]";
  57. }
  58. }

  1. package dhp.com.test2;
  2.  
  3. import java.text.SimpleDateFormat;
  4. import java.util.ArrayList;
  5. import java.util.Date;
  6. import java.util.HashMap;
  7. import java.util.List;
  8. import java.util.Map;
  9. import org.codehaus.jackson.JsonGenerator;
  10. import org.codehaus.jackson.map.DeserializationConfig;
  11. import org.codehaus.jackson.map.ObjectMapper;
  12. import org.codehaus.jackson.map.SerializationConfig;
  13. import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;
  14. import org.codehaus.jackson.type.TypeReference;
  15.  
  16. public class TestJackson {
  17. public static ObjectMapper getDefaultObjectMapper() {
  18. ObjectMapper mapper = new ObjectMapper();
  19. //设置将对象转换成JSON字符串时候:包含的属性不能为空或"";
  20. //Include.Include.ALWAYS 默认
  21. //Include.NON_DEFAULT 属性为默认值不序列化
  22. //Include.NON_EMPTY 属性为 空("") 或者为 NULL 都不序列化
  23. //Include.NON_NULL 属性为NULL 不序列化
  24. mapper.setSerializationInclusion(Inclusion.NON_EMPTY);
  25. //设置将MAP转换为JSON时候只转换值不等于NULL的
  26. mapper.configure(SerializationConfig.Feature.WRITE_NULL_MAP_VALUES,false);
  27. //mapper.configure(JsonGenerator.Feature.ESCAPE_NON_ASCII,true);
  28. mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
  29. //设置有属性不能映射成PO时不报错
  30. mapper.disable(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES);
  31. return mapper;
  32. }
  33. public static void main(String[] args) throws Exception{
  34. //准备数据
  35. Name name1 = new Name("zhang","san");
  36. Name name2 = new Name("li","si");
  37. Name name3 = new Name("wang","wu");
  38. Student student1 = new Student(1,name1,"一班",new Date());
  39. Student student2 = new Student(2,name2,"二班",new Date());
  40. Student student3 = new Student(3,name3,"三班",new Date());
  41. List<Student> studentList = new ArrayList<Student>();
  42. studentList.add(student1);
  43. studentList.add(student2);
  44. studentList.add(student3);
  45. Map<String,Student> studentMap = new HashMap<String,Student>();
  46. studentMap.put("1",student1);
  47. studentMap.put("2",student2);
  48. studentMap.put("3",student3);
  49. Student json2object = null;
  50. List<Student> json2list = null;
  51. Map<String,Student> json2map = null;
  52. ObjectMapper mapper = getDefaultObjectMapper();
  53. /* Object --> JSON */
  54. String object4json = mapper.writeValueAsString(student1);
  55. System.out.println("Object ----> JSON");
  56. System.out.println(object4json);
  57. System.out.println("------------------------------------------------------");
  58. /* List<Object> --> JSON */
  59. String listforjson = mapper.writeValueAsString(studentList);
  60. System.out.println("List<Object> ----> JSON");
  61. System.out.println(listforjson);
  62. System.out.println("------------------------------------------------------");
  63. /* Map<String,Object> ----> JSON */
  64. String map4json = mapper.writeValueAsString(studentMap);
  65. System.out.println("Map<String,Object> ----> JSON");
  66. System.out.println(map4json);
  67. System.out.println("------------------------------------------------------");
  68. /* JSON --> Object */
  69. json2object = mapper.readValue(object4json,Student.class);
  70. System.out.println("JSON ----> Object");
  71. System.out.println(json2object);
  72. System.out.println("------------------------------------------------------");
  73. /* JSON --> List<Object> */
  74. json2list = mapper.readValue(listforjson,new TypeReference<List<Student>>() {});
  75. System.out.println("JSON --> List<Object>");
  76. System.out.println(json2list.toString());
  77. System.out.println("------------------------------------------------------");
  78. /* JSON --> Map<String,Object> */
  79. json2map = mapper.readValue(map4json,new TypeReference<Map<String,Student>>() {});
  80. System.out.println("JSON --> Map<String,Object>");
  81. System.out.println(json2map.toString());
  82. }
  83. }


注意:jackson渐次反序列化
方法更灵活,可以只将用户感兴趣的Json串信息值提取出来。主要利用ObjectMapper提供的readTree和Jackson提供的JsonNode类来实现。

测试例子:

  1. String test="{"results":[{"objectID":357,"geoPoints":[{"x":504604.59802246094,"y":305569.9150390625}]},{"objectID":358,"geoPoints":[{"x":504602.2680053711,"y":305554.43603515625}]}]}";

此Json串比较复杂,包含了嵌套数组的形式,具有通用性。

实现反序列化

  1. JsonNode node= objectMapper.readTree(test); //将Json串以树状结构读入内存
  2. JsonNode contents=node.get("results");//得到results这个节点下的信息
  3. for(int i=0;i<contents.size();i++) //遍历results下的信息,size()函数可以得节点所包含的的信息的个数,类似于数组的长度
  4. {
  5. System.out.println(contents.get(i).get("objectID").getIntValue()); //读取节点下的某个子节点的值
  6. JsonNode geoNumber=contents.get(i).get("geoPoints");
  7. for(int j=0;j<geoNumber.size();j++) //循环遍历子节点下的信息
  8. {
  9. System.out.println(geoNumber.get(j).get("x").getDoubleValue()+" "+geoNumber.get(j).get("y").getDoubleValue());
  10. }
  11. }

在控制台下输出的结果是:
357
504604.59802246094 305569.9150390625
358
504602.2680053711 305554.43603515625
方法类似于XML解析中的DOM方式解析,其好处是结构明细,便于提取想要的信息。当然,其缺点也和此方法一样:耗时费空间。

五、Gson是非常强大的API,它支持Java泛型,支持现成的JSON与Java对象的转换,只要对象的成员名称与JSON中的一致即可。如果针对Java bean和JSON要使用不同的名称,那么可以使用@SerializedName注解来映射JSON和Java类中的变量。

我们来看一个复杂示例,在JSON中含有嵌套对象以及数组,我们要将其映射到Java bean的属性(List、Map、Array类型等)中。

  1. {
  2. "empID": 100,"name": "David","permanent": false,"address": {
  3. "street": "BTM 1st Stage","city": "Bangalore","zipcode": 560100
  4. },"phoneNumbers": [
  5. 123456,987654
  6. ],"role": "Manager","cities": [
  7. "Los Angeles","New York"
  8. ],"properties": {
  9. "age": "28 years","salary": "1000 Rs"
  10. }
  11. }

建立Java bean类,将JSON转换为Java对象。
Employee.java

  1. package com.journaldev.json.model;
  2. import java.util.Arrays;
  3. import java.util.List;
  4. import java.util.Map;
  5. import com.google.gson.annotations.SerializedName;
  6. public class Employee {
  7. @SerializedName("empID")
  8. private int id;
  9. private String name;
  10. private boolean permanent;
  11. private Address address;
  12. private long[] phoneNumbers;
  13. private String role;
  14. private List<String> cities;
  15. private Map<String,String> properties;
  16. public int getId() {
  17. return id;
  18. }
  19. public void setId(int id) {
  20. this.id = id;
  21. }
  22. public String getName() {
  23. return name;
  24. }
  25. public void setName(String name) {
  26. this.name = name;
  27. }
  28. public boolean isPermanent() {
  29. return permanent;
  30. }
  31. public void setPermanent(boolean permanent) {
  32. this.permanent = permanent;
  33. }
  34. public Address getAddress() {
  35. return address;
  36. }
  37. public void setAddress(Address address) {
  38. this.address = address;
  39. }
  40. public long[] getPhoneNumbers() {
  41. return phoneNumbers;
  42. }
  43. public void setPhoneNumbers(long[] phoneNumbers) {
  44. this.phoneNumbers = phoneNumbers;
  45. }
  46. public String getRole() {
  47. return role;
  48. }
  49. public void setRole(String role) {
  50. this.role = role;
  51. }
  52. @Override
  53. public String toString(){
  54. StringBuilder sb = new StringBuilder();
  55. sb.append("***** Employee Details *****n");
  56. sb.append("ID="+getId()+"n");
  57. sb.append("Name="+getName()+"n");
  58. sb.append("Permanent="+isPermanent()+"n");
  59. sb.append("Role="+getRole()+"n");
  60. sb.append("Phone Numbers="+Arrays.toString(getPhoneNumbers())+"n");
  61. sb.append("Address="+getAddress()+"n");
  62. sb.append("Cities="+Arrays.toString(getCities().toArray())+"n");
  63. sb.append("Properties="+getProperties()+"n");
  64. sb.append("*****************************");
  65. return sb.toString();
  66. }
  67. public List<String> getCities() {
  68. return cities;
  69. }
  70. public void setCities(List<String> cities) {
  71. this.cities = cities;
  72. }
  73. public Map<String,String> getProperties() {
  74. return properties;
  75. }
  76. public void setProperties(Map<String,String> properties) {
  77. this.properties = properties;
  78. }
  79. }

Address.java

  1. package com.journaldev.json.model;
  2. public class Address {
  3. private String street;
  4. private String city;
  5. private int zipcode;
  6. public String getStreet() {
  7. return street;
  8. }
  9. public void setStreet(String street) {
  10. this.street = street;
  11. }
  12. public String getCity() {
  13. return city;
  14. }
  15. public void setCity(String city) {
  16. this.city = city;
  17. }
  18. public int getZipcode() {
  19. return zipcode;
  20. }
  21. public void setZipcode(int zipcode) {
  22. this.zipcode = zipcode;
  23. }
  24. @Override
  25. public String toString(){
  26. return getStreet() + ","+getCity()+","+getZipcode();
  27. }
  28. }

下面是Java程序,展示了如何将JSON转换为Java对象,反之亦然。
EmployeeGsonExample.java

  1. package com.journaldev.json.gson;
  2. import java.io.IOException;
  3. import java.nio.file.Files;
  4. import java.nio.file.Paths;
  5. import java.util.ArrayList;
  6. import java.util.HashMap;
  7. import java.util.List;
  8. import java.util.Map;
  9. import com.google.gson.Gson;
  10. import com.google.gson.GsonBuilder;
  11. import com.journaldev.json.model.Address;
  12. import com.journaldev.json.model.Employee;
  13. public class EmployeeGsonExample {
  14. public static void main(String[] args) throws IOException {
  15. Employee emp = createEmployee();
  16. // Get Gson object
  17. Gson gson = new GsonBuilder().setPrettyPrinting().create();
  18. // read JSON file data as String
  19. String fileData = new String(Files.readAllBytes(Paths
  20. .get("employee.txt")));
  21. // parse json string to object
  22. Employee emp1 = gson.fromJson(fileData,Employee.class);
  23. // print object data
  24. System.out.println("nnEmployee Objectnn" + emp1);
  25. // create JSON String from Object
  26. String jsonEmp = gson.toJson(emp);
  27. System.out.print(jsonEmp);
  28. }
  29. public static Employee createEmployee() {
  30. Employee emp = new Employee();
  31. emp.setId(100);
  32. emp.setName("David");
  33. emp.setPermanent(false);
  34. emp.setPhoneNumbers(new long[] { 123456,987654 });
  35. emp.setRole("Manager");
  36. Address add = new Address();
  37. add.setCity("Bangalore");
  38. add.setStreet("BTM 1st Stage");
  39. add.setZipcode(560100);
  40. emp.setAddress(add);
  41. List<String> cities = new ArrayList<String>();
  42. cities.add("Los Angeles");
  43. cities.add("New York");
  44. emp.setCities(cities);
  45. Map<String,String> props = new HashMap<String,String>();
  46. props.put("salary","1000 Rs");
  47. props.put("age","28 years");
  48. emp.setProperties(props);
  49. return emp;
  50. }
  51. }

Gson是主类,它暴露出fromJson()和toJson()方法进行转换工作,对于默认实现,可以直接创建对象,也可以使用GsonBuilder类提供的实用选项进行转换,比如整齐打印,字段命名转换,排除字段,日期格式化,等等。
当运行以上程序时,可以看到以下Java对象的输出

  1. Employee Object
  2. ***** Employee Details *****
  3. ID=100
  4. Name=David
  5. Permanent=false
  6. Role=Manager
  7. Phone Numbers=[123456,987654]
  8. Address=BTM 1st Stage,Bangalore,560100
  9. Cities=[Los Angeles,New York]
  10. Properties={age=28 years,salary=1000 Rs}
  11. *****************************

你可以看到,使用Gson是多么的容易,这就是为什么它在JSON处理方面如此风靡。
以上的JSON处理方式是我们所熟知的对象模型,因为整个JSON被一次性的转换为对象了,在大多数情况下这足够了,然而如果JSON确实非常庞大,我们不想将其全部一次性置入内存,Gson也提供了Streaming API。
我们来看一个例子,它展示了如何使用Streaming API进行JSON到Java对象的转换。
EmployeeGsonReader.java

  1. package com.journaldev.json.gson;
  2. import java.io.FileInputStream;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.InputStreamReader;
  6. import java.util.ArrayList;
  7. import java.util.HashMap;
  8. import java.util.List;
  9. import com.google.gson.stream.JsonReader;
  10. import com.google.gson.stream.JsonToken;
  11. import com.journaldev.json.model.Address;
  12. import com.journaldev.json.model.Employee;
  13. public class EmployeeGsonReader {
  14. public static void main(String[] args) throws IOException {
  15. InputStream is = new FileInputStream("employee.txt");
  16. InputStreamReader isr = new InputStreamReader(is);
  17. //create JsonReader object
  18. JsonReader reader = new JsonReader(isr);
  19. //create objects
  20. Employee emp = new Employee();
  21. Address add = new Address();
  22. emp.setAddress(add);
  23. List<Long> phoneNums = new ArrayList<Long>();
  24. emp.setCities(new ArrayList<String>());
  25. emp.setProperties(new HashMap<String,String>());
  26. String key = null;
  27. boolean insidePropertiesObj=false;
  28. key = parseJSON(reader,emp,phoneNums,key,insidePropertiesObj);
  29. long[] nums = new long[phoneNums.size()];
  30. int index = 0;
  31. for(Long l :phoneNums){
  32. nums[index++] = l;
  33. }
  34. emp.setPhoneNumbers(nums);
  35. reader.close();
  36. //print employee object
  37. System.out.println("Employee Objectnn"+emp);
  38. }
  39. private static String parseJSON(JsonReader reader,Employee emp,List<Long> phoneNums,String key,boolean insidePropertiesObj) throws IOException {
  40. //loop to read all tokens
  41. while(reader.hasNext()){
  42. //get next token
  43. JsonToken token = reader.peek();
  44. switch(token){
  45. case BEGIN_OBJECT:
  46. reader.beginObject();
  47. if("address".equals(key) || "properties".equals(key)){
  48. while(reader.hasNext()){
  49. parseJSON(reader,insidePropertiesObj);
  50. }
  51. reader.endObject();
  52. }
  53. break;
  54. case END_OBJECT:
  55. reader.endObject();
  56. if(insidePropertiesObj) insidePropertiesObj=false;
  57. break;
  58. case BEGIN_ARRAY:
  59. reader.beginArray();
  60. if("phoneNumbers".equals(key) || "cities".equals(key)){
  61. while(reader.hasNext()){
  62. parseJSON(reader,insidePropertiesObj);
  63. }
  64. reader.endArray();
  65. }
  66. break;
  67. case END_ARRAY:
  68. reader.endArray();
  69. break;
  70. case NAME:
  71. key = reader.nextName();
  72. if("properties".equals(key)) insidePropertiesObj=true;
  73. break;
  74. case BOOLEAN:
  75. if("permanent".equals(key)) emp.setPermanent(reader.nextBoolean());
  76. else{
  77. System.out.println("Unknown item found with key="+key);
  78. //skip value to ignore it
  79. reader.skipValue();
  80. }
  81. break;
  82. case NUMBER:
  83. if("empID".equals(key)) emp.setId(reader.nextInt());
  84. else if("phoneNumbers".equals(key)) phoneNums.add(reader.nextLong());
  85. else if("zipcode".equals(key)) emp.getAddress().setZipcode(reader.nextInt());
  86. else {
  87. System.out.println("Unknown item found with key="+key);
  88. //skip value to ignore it
  89. reader.skipValue();
  90. }
  91. break;
  92. case STRING:
  93. setStringValues(emp,reader.nextString(),insidePropertiesObj);
  94. break;
  95. case NULL:
  96. System.out.println("Null value for key"+key);
  97. reader.nextNull();
  98. break;
  99. case END_DOCUMENT:
  100. System.out.println("End of Document Reached");
  101. break;
  102. default:
  103. System.out.println("This part will never execute");
  104. break;
  105. }
  106. }
  107. return key;
  108. }
  109. private static void setStringValues(Employee emp,String value,boolean insidePropertiesObj) {
  110. if("name".equals(key)) emp.setName(value);
  111. else if("role".equals(key)) emp.setRole(value);
  112. else if("cities".equals(key)) emp.getCities().add(value);
  113. else if ("street".equals(key)) emp.getAddress().setStreet(value);
  114. else if("city".equals(key)) emp.getAddress().setCity(value);
  115. else{
  116. //add to emp properties map
  117. if(insidePropertiesObj){
  118. emp.getProperties().put(key,value);
  119. }else{
  120. System.out.println("Unknown data found with key="+key+" value="+value);
  121. }
  122. }
  123. }
  124. }

由于JSON是一个递归语言(译注:JSON本身并不是“语言”,而是一种表示方法),我们也需要针对数组和嵌套对象递归地调用解析方法。JsonToken是JsonReader中next()方法所返回的Java枚举类型,我们可以用其配合条件逻辑或switch case语句进行转换工作。根据以上代码,你应该能够理解这不是一个简单的实现,如果JSON确实非常复杂,那么代码将会变得极难维护,所以要避免使用这种方式,除非没有其他出路。


我们来看一下如何使用Gson Streaming API写出Employee对象。
EmployeeGsonWriter.java

  1. package com.journaldev.json.gson;
  2. import java.io.IOException;
  3. import java.io.OutputStreamWriter;
  4. import java.util.Set;
  5. import com.google.gson.stream.JsonWriter;
  6. import com.journaldev.json.model.Employee;
  7. public class EmployeeGsonWriter {
  8. public static void main(String[] args) throws IOException {
  9. Employee emp = EmployeeGsonExample.createEmployee();
  10. //writing on console,we can initialize with FileOutputStream to write to file
  11. OutputStreamWriter out = new OutputStreamWriter(System.out);
  12. JsonWriter writer = new JsonWriter(out);
  13. //set indentation for pretty print
  14. writer.setIndent("t");
  15. //start writing
  16. writer.beginObject(); //{
  17. writer.name("id").value(emp.getId()); // "id": 123
  18. writer.name("name").value(emp.getName()); // "name": "David"
  19. writer.name("permanent").value(emp.isPermanent()); // "permanent": false
  20. writer.name("address").beginObject(); // "address": {
  21. writer.name("street").value(emp.getAddress().getStreet()); // "street": "BTM 1st Stage"
  22. writer.name("city").value(emp.getAddress().getCity()); // "city": "Bangalore"
  23. writer.name("zipcode").value(emp.getAddress().getZipcode()); // "zipcode": 560100
  24. writer.endObject(); // }
  25. writer.name("phoneNumbers").beginArray(); // "phoneNumbers": [
  26. for(long num : emp.getPhoneNumbers()) writer.value(num); //123456,987654
  27. writer.endArray(); // ]
  28. writer.name("role").value(emp.getRole()); // "role": "Manager"
  29. writer.name("cities").beginArray(); // "cities": [
  30. for(String c : emp.getCities()) writer.value(c); //"Los Angeles","New York"
  31. writer.endArray(); // ]
  32. writer.name("properties").beginObject(); //"properties": {
  33. Set<String> keySet = emp.getProperties().keySet();
  34. for(String key : keySet) writer.name("key").value(emp.getProperties().get(key));//"age": "28 years","salary": "1000 Rs"
  35. writer.endObject(); // }
  36. writer.endObject(); // }
  37. writer.flush();
  38. //close writer
  39. writer.close();
  40. }
  41. }

从Java对象到JSON的转换,与使用streaming API解析相比,相对容易一些,默认情况下JsonWriter会以一种紧凑的格式写入JSON,但也可以设置缩进进行整齐打印。

这就是Gson API演示教程的所有内容,如果你遇到任何问题,请告诉我。以下链接可以下载项目,你可以玩一玩Gson提供的多种选项。 http://www.journaldev.com/?wpdmact=process&did=MzAuaG90bGluaw== 原文链接: Pankaj Kumar 翻译: ImportNew.com - Justin Wu 译文链接: http://www.importnew.com/14509.html

猜你在找的Json相关文章