Android 开发必备之json解析Gson篇

概述

在了解gson前，你需要了解json。
什么是 JSON ？

• JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation）
• JSON 是轻量级的文本数据交换格式
• JSON 独立于语言 *
• JSON 具有自我描述性，更易理解
• JSON 使用 JavaScript 语法来描述数据对象，但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON库支持许多不同的编程语言。

如下就是一个json实例

{
"employees": [
{ "firstName":"Bill" , "lastName":"Gates" },
{ "firstName":"George" , "lastName":"Bush" },
{ "firstName":"Thomas" , "lastName":"Carter" }
]
}

Gson是一个Java库，可用于将Java对象转换为JSON表示形式。它也可以用于将JSON字符串转换为等效的Java对象。
Gson可以使用在任意Java对象，包括您没有源代码的预先存在的对象

Gson最初是为了在Google中使用，目前在许多项目中使用。它现在被一些公共项目和公司使用

使用Gson

Gson使用具体事例源码请到http://blog.youkuaiyun.com/qq_30034925/article/details/70162546

使用的主要类是Gson，您可以通过调用new Gson()创建。还有一个类GsonBuilder可用于创建具有各种设置（如版本控制等）的Gson实例

调用Json操作时，Gson实例不会保持任何状态，也就是说，例如你调用了gson.tojson（）后，gson并不会被赋予一个值。因此，您可以自由地重复使用相同的对象进行多个Json序列化和反序列化操作

原始实例

//序列化
Gson gson = new Gson();
//tojson把一个对象转化为json
gson.toJson(1);            // ==> 1
gson.toJson("abcd");       // ==> "abcd"
gson.toJson(new Long(10)); // ==> 10
int[] values = { 1 };
gson.toJson(values);       // ==> [1]

// 反序列化 把一个json转化为一个对象
int one = gson.fromJson("1", int.class);
Integer one = gson.fromJson("1", Integer.class);
Long one = gson.fromJson("1", Long.class);
Boolean false = gson.fromJson("false", Boolean.class);
String str = gson.fromJson("\"abc\"", String.class);
String[] anotherStr = gson.fromJson("[\"abc\"]", String[].class);

对象示例

这个应该是我们开发所需要用到的最多的一个了

public class GsonTest {
    public static void main(String[] args) {
        // Serialization
        BagOfPrimitives obj = new BagOfPrimitives();
        Gson gson = new Gson();
        String json = gson.toJson(obj);
        System.out.println(json);
    }
}

class BagOfPrimitives {
    private int value1 = 1;
    private String value2 = "jianguotang";
    private transient int value3 = 3;

    BagOfPrimitives() {
        // no-args constructor
    }
}

运行结果

嵌套类（包括内部类）
Gson可以很容易地序列化静态嵌套类。Gson也可以反序列化静态嵌套类。然而，Gson不能自动反序列化纯粹的内在类
例如

public class A { 
  public String a; 

  class B { 

    public String b; 

    public B() {
      // No args constructor for B
    }
  } 
}

上面的类B不能（默认情况下）用Gson序列化。因为B类是一个内部类，所以Gson不能将{“b”：“abc”}反序列化为B的实例。如果将它定义为静态类B，则Gson将能够反序列化字符串。另一个解决方案是为B编写一个自定义实例创建者。
如下：

public class InstanceCreatorForB implements InstanceCreator<A.B> {
  private final A a;
  public InstanceCreatorForB(A a)  {
    this.a = a;
  }
  public A.B createInstance(Type type) {
    return a.new B();
  }
}

以上是可行的，但是谷歌不推荐我们这样做。

Array 例子：

public class GsonTest {
    public static void main(String[] args) {
        // 序列化
        Gson gson = new Gson();
        int[] ints = {1, 2, 3, 4, 5};
        String[] strings = {"abc", "def", "ghi"};
        // 序列化
        gson.toJson(ints);     // ==> [1,2,3,4,5]
        gson.toJson(strings);  // ==> ["abc", "def", "ghi"]
        // 反序列话
        int[] ints2 = gson.fromJson("[1,2,3,4,5]", int[].class); 
        // ==> ints2和ints将会一样   
        String[] strings2 = gson.fromJson(gson.toJson(strings), String[].class);
        System.out.println(gson.toJson(ints));
        System.out.println(gson.toJson(strings));
        for(int i = 0;i<5;i++){
         System.out.print(ints[i]+" ");
        }
    }
}

运行结果

当然Gson还支持多维数组，具有任意复杂的元素类型。

当您调用Json（obj）时，Gson调用obj.getClass（）获取字段序列化信息。同样，您通常可以在fromJson（json，MyClass.class）方法中传递MyClass.class对象如果对象是非泛型类型，则此操作正常。但是，如果对象是通用类型，那么由于Java类型擦除，通用类型信息会丢失。
这是一个例子，说明一点：

public class GsonTest {
    public static void main(String[] args) {

        Gson gson = new Gson();
        Foo<String> foo = new Foo<String>();

        gson.toJson(foo); // 不能正确序列化foo.value
        gson.fromJson("jianguotang", foo.getClass()); // 无法将foo.value反序列化为String
    }

}
class Foo<T> {
    T value;
}

运行结果

您可以通过为通用类型指定正确的参数化类型来解决此问题。您可以使用TypeToken类来执行此操作。

Type fooType = new TypeToken<Foo<String>>() {}.getType();
gson.toJson(foo, fooType);
gson.fromJson(json, fooType);

使用任意类型的对象序列化和反序列化集合有时您正在处理包含混合类型的JSON数组。例如：
[‘hello’，5，{name：’GREETINGS’，source：’guest’}]

包含这个的等效集合是：

Collection collection = new ArrayList();
collection.add("hello");
collection.add(5);
collection.add(new Event("GREETINGS", "guest"));

Event类的定义如下：

class Event {
  private String name;
  private String source;
  private Event(String name, String source) {
    this.name = name;
    this.source = source;
  }
}

您可以使用Gson序列化集合，而不做任何具体的操作：toJson（collection）将生成所需的结果。

空对象支持
以下是配置Gson实例以输出null的Gson gson = new GsonBuilder().serializeNulls().create();
Gson序列化null时，它将向JsonElement结构添加一个JsonNull元素。因此，该对象可以用于自定义序列化/反序列化

public class Foo {
  private final String s;
  private final int i;

  public Foo() {
    this(null, 5);
  }

  public Foo(String s, int i) {
    this.s = s;
    this.i = i;
  }
}

Gson gson = new GsonBuilder().serializeNulls().create();
Foo foo = new Foo();
String json = gson.toJson(foo);
System.out.println(json);

json = gson.toJson(null);
System.out.println(json);
输出为：

{"s":null,"i":5}
null

版本控制支持
例如

public class VersionedClass {
  @Since(1.1) private final String newerField;
  @Since(1.0) private final String newField;
  private final String field;

  public VersionedClass() {
    this.newerField = "newer";
    this.newField = "new";
    this.field = "old";
  }
}

VersionedClass versionedObject = new VersionedClass();
Gson gson = new GsonBuilder().setVersion(1.0).create();
String jsonOutput = gson.toJson(someObject);
System.out.println(jsonOutput);
System.out.println();

gson = new Gson();
jsonOutput = gson.toJson(someObject);
System.out.println(jsonOutput);

输出为：

{"newField":"new","field":"old"}

{"newerField":"newer","newField":"new","field":"old"}