[关闭]
@DefinedOne 2015-11-12T09:29:46.000000Z 字数 5604 阅读 1144

使用Gson解析JSON数据

json gson 解析 java

创建于2015/10/27，更新于2015/11/04

1. Google的开源项目--Gson

Github网址：https://github.com/google/gson
google/gson: A Java serialization library that can convert Java Objects into JSON and back.
（一个能将Java对象和JSON相互转换的Java序列化程序库。）
程序库的下载网址：http://search.maven.org/#artifactdetails|com.google.code.gson|gson|2.4|jar

2. 最常见的使用方法

2.1 例子一，多种使用方法

JSON格式：

  1. {
  2.     "id":"25871",
  3.     "name":"苹果"
  4. }

需要写这些Java代码解析它：
可以这样写：

  1. public class Food implements Serializable {
  3.     private static final long serialVersionUID = 385746866573166810L;
  5.     public int id;
  6.     public String name;
  7. }

调用Gson类和JsonSyntaxException类，将字符串jsonString解析为Food类的对象。

  1. Food food = null;
  2. try {
  3.     food = new Gson().fromJson(jsonString, Food.class);
  4. } catch(JsonSyntaxException e) {
  5.    // ... 处理e
  6. }

调用Gson类，将Food对象转换为JSON字符串。

  1. String json = new Gson().toJson(food);

或者这样写：

  1. public class Food implements Serializable {
  3.     private static final long serialVersionUID = 878065946505174667L;
  5.     public String id;
  6.     public String name;
  7. }

或者这样写：

  1. public class Food  implements Serializable {
  3.     private static final long serialVersionUID = -2440906703930967942L;
  5.     private int id;
  6.     private String name;
  8.     public int getId() {
  9.         return id;
  10.     }
  11.     public void setId(int id) {
  12.         this.id = id;
  13.     }
  14.     public String getName() {
  15.         return name;
  16.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  20. }

2.2 例子二，解析嵌套类

JSON格式：

  1. {
  2.     "id":"25871",
  3.     "name":"苹果",
  4.     "taste":{ // 味道的评价
  6.         "sour":"3", // 酸味
  7.         "sweet":"8",  // 甜味
  8.         "peppery":"0" // 辣味
  9.     }
  10. }

需要写这些Java代码解析它：
可以这样写：

  1. *Food.java*
  3. public class Food {
  5.     public String id;
  6.     public String name;
  7.     public TasteEvaluation taste;
  9.     public static class TasteEvaluation { // 味道的评价
  11.         public int sour; // 酸味
  12.         public int sweet;  // 甜味
  13.         public int peppery; // 辣味
  14.     }
  15. }

或者这样写：

  1. *Food.java文件*
  3. public class Food {
  5.     public String id;
  6.     public String name;
  7.     public TasteEvaluation taste;
  8. }
  1. *TasteEvaluation.java文件*
  3. public class TasteEvaluation { // 味道的评价
  5.     public int sour; // 酸味
  6.     public int sweet;  // 甜味
  7.     public int peppery; // 辣味
  8. }

2.3 例子三--解析数组

JSON格式：

  1. {
  2.     "type":"fruit", // 食物类型为水果
  3.     "content":[
  4.         {"id":"25871","name":"苹果"},
  5.         {"id":"4646","name":"梨"},
  6.         {"id":"1657","name":"香蕉"},
  7.         {"id":"6874","name":"西瓜"}
  8.     ]
  9. }

需要写这些Java代码解析它：

  1. import java.util.List;
  3. public class FoodDictionary {
  5.     public String type;
  6.     public List<Food> content;
  7. }

2.4 解析继承的子类

Gson是否能解析继承了某个类的JavaBean类？

  1. *Response.java*
  3. public class Response {
  5.     public int code;
  6.     public int message;
  7. }
  1. *ResponseFoodDictionary.java*
  3. public class ResponseFoodDictionary extends Response {
  5.     public FoodDictionary foodDictionary; // 继承之后添加了这个字段
  6. }

2.5 缺少字段的JavaBean

在2.2节中的JSON数据的格式：

  1. {
  2.     "id":"25871",
  3.     "name":"苹果",
  4.     "taste":{ // 味道的评价
  6.         "sour":"3", // 酸味
  7.         "sweet":"8",  // 甜味
  8.         "peppery":"0" // 辣味
  9.     }
  10. }

相对2.1节的，多了taste这个字段。
2.1节的Food类：

  1. public class Food {
  3.     public int id;
  4.     public String name;
  5. }

这个Food类中没有taste这个变量，但是用它解析这个JSON时，程序能够正常运行。但是，显然，这样就不能将taste字段的数据保存在Food类中。

2.6 多余字段的JavaBean

在2.1节中的JSON数据的格式：

  1. {
  2.     "id":"25871",
  3.     "name":"苹果",
  4. }

2.2节的Food类：

  1. public class Food {
  3.     public String id;
  4.     public String name;
  5.     public TasteEvaluation taste;
  6. }

这个Food类比较这个JSON多余了taste变量，但是用它解析这个JSON时，程序能够正常运行。但是，显然，这样就没有给taste变量赋值，于是taste变量的值为初始值，即null。

2.7 带有泛型参数的JavaBean类

Gson能否处理带有泛型参数的JavaBean类型？
例如，Response类型具有一个泛型参数T：

  1. public class Response<T> implements Serializable {
  3.     private static final long serialVersionUID = -8476732816742376064L;
  5.     public T data;
  6. }

能够解析不论T为那种JavaBean类型，Gson都能解析。
例如，Json数据：

  1. {"data":{"id":"25871","name":"苹果"}}

需要写这些Java代码解析它：

  1. Response<Food> response = new Gson().fromJson(json, new TypeToken<Response<Food>>() {}.getType());

这里为什么不使用Response<Food>.class，而使用new TypeToken<Response<Food>>() {}.getType()呢？请继续阅读。

2.8 使用Gson和Volley框架封装网络请求的工具

【 待完善 】

  1. package com.gis.pror.networkconnection;
  3. import com.android.volley.AuthFailureError;
  4. import com.android.volley.NetworkResponse;
  5. import com.android.volley.ParseError;
  6. import com.android.volley.Request;
  7. import com.android.volley.Response;
  8. import com.android.volley.Response.ErrorListener;
  9. import com.android.volley.toolbox.HttpHeaderParser;
  10. import com.google.gson.Gson;
  11. import com.google.gson.JsonSyntaxException;
  13. import java.io.UnsupportedEncodingException;
  14. import java.util.Map;
  16. /**
  17.  *
  18.  * @author 翻译者:王永阁，更新者:dengnengcai
  19.  *
  20.  * @date 2015/11/12.
  21.  *
  22.  * 信息来自：
  23.  * http://blog.csdn.net/wangyongge85/article/details/48522233
  24.  */
  25. public class GsonRequest<T> extends Request<T> {
  27.     private final Class<T> mClazz;
  28.     private final Response.Listener<T> mListener;
  29.     private final Map<String, String> mHeaders;
  30.     private final Gson mGson = new Gson();
  32.     /**
  33.      * GET请求方式，并且返回JSON解析对象
  34.      */
  35.     public GsonRequest(String url, Class<T> clazz, Response.Listener<T> listener, ErrorListener errorListener) {
  36.         this(url, clazz, listener, errorListener, null);
  37.     }
  39.     /**
  40.      * GET请求方式，并且返回JSON解析对象
  41.      */
  42.     public GsonRequest(String url, Class<T> clazz, Response.Listener<T> listener,
  43.                        ErrorListener errorListener, Map<String, String> headers) {
  44.         super(Method.GET, url, errorListener);
  45.         this.mClazz = clazz;
  46.         this.mHeaders = headers;
  47.         this.mListener = listener;
  48.     }
  50.     /**
  51.      * 方法回调
  52.      */
  53.     @Override
  54.     protected void deliverResponse(T response) {
  55.         mListener.onResponse(response);
  56.     }
  58.     @Override
  59.     protected Response<T> parseNetworkResponse(NetworkResponse response) {
  60.         try {
  61.             String json = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
  62.             return Response.success(mGson.fromJson(json, mClazz), HttpHeaderParser.parseCacheHeaders(
  63.                     response));
  64.         } catch (UnsupportedEncodingException e) {
  65.             return Response.error(new ParseError(e));
  66.         } catch (JsonSyntaxException e) {
  67.             return Response.error(new ParseError(e));
  68.         }
  69.     }
  71.     @Override
  72.     public Map<String, String> getHeaders() throws AuthFailureError {
  73.         return mHeaders != null ? mHeaders : super.getHeaders();
  74.     }
  75. }

信息来自：
http://blog.csdn.net/wangyongge85/article/details/48522233

4 Gson不能解析的

4.1 没有继承Serializable接口的JavaBean类

？具体细节待测试。

copy https://zybuluo.com/DefinedOne/note/204558

* end *

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注