google Gson学习笔记及与json-lib的比较

因为gson网上的帮助文档打开时比较慢,所以把帮助文档摘录如此,方便查看:

1. 基本类型转化

public static void main(String[] args) {   
        Gson gson = new Gson();   
        System.out.println(gson.toJson(1)); // ==> prints 1   
        System.out.println(gson.toJson("abcd"));// ==> prints "abcd"   
        System.out.println(gson.toJson(new Long(10)));// ==> prints 10   
        int[] values = { 1 };   
        System.out.println(gson.toJson(values));// ==> prints [1]   
        System.out.println("============");   
  
        int one = gson.fromJson("1", int.class);   
        Integer one1 = gson.fromJson("1", Integer.class);   
        Long one2 = gson.fromJson("1", Long.class);   
        String str = gson.fromJson("\"abc\"", String.class);   
        String anotherStr = gson.fromJson("[\"abc\"]", String.class);   
        int[] ints = gson.fromJson("[1,2,3,4,5]", int[].class);   
        Boolean b = gson.fromJson("false", Boolean.class);   
        System.out.println(b == false); //==> prints true   
    }  

2.对象转化

public class BagOfPrimitives {   
  
    private int           value1    = 1;   
    private String        value2    = "abc";   
//是用于声明变量在序列化的时候不被存储   
    private transient int   value3  = 3;   
  
    BagOfPrimitives() {   
        // no-args constructor   
    }   
  
    public static void main(String[] args) {   
        BagOfPrimitives obj = new BagOfPrimitives();   
        Gson gson = new Gson();   
        String json = gson.toJson(obj);     
        System.out.println(json); //==> json is {"value1":1,"value2":"abc"}   
           
        BagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class);    
        System.out.println(obj2.value1);   
        System.out.println(obj2.value2);   
        System.out.println(obj2.value3);//==>3   
           
        String json1 = "{'value1':1,'value2':'abc','value3':4}";   
        BagOfPrimitives obj3 = gson.fromJson(json1, BagOfPrimitives.class);    
        System.out.println(obj3.value1);   
        System.out.println(obj3.value2);   
        System.out.println(obj3.value3); //==>3   
    }   
}  

Note that you can not serialize objects with circular references since that will result in infinite recursion. 

如果要是用json lib的话,上面的代码可以写成如下所示:

String json1 = "{'value1':1,'value2':'abc','value3':4}";   
JSONObject jsonObj = JSONObject.fromObject( json1 );    
BagOfPrimitives obj3 = (BagOfPrimitives) JSONObject.toBean( jsonObj, BagOfPrimitives.class ); 

Finer Points with Objects

It is perfectly fine (and recommended) to use private fields

There is no need to use any annotations to indicate a field is to be included for serialization and deserialization. All fields in the current class (and from all super classes) are included by default.

If a field is marked transient, (by default) it is ignored and not included in the JSON serialization or deserialization.

This implementation handles nulls correctly
While serialization, a null field is skipped from the output
While deserialization, a missing entry in JSON results in setting the corresponding field in the object to null

If a field is synthetic , it is ignored and not included in JSON serialization or deserialization

Fields corresponding to the outer classes in  inner classes, anonymous classes, and local classes are ignored and not included in serialization or deserialization
Nested Classes (including Inner Classes)

Gson can serialize static nested classes quite easily.


Gson can also deserialize static nested classes. However, Gson can not automatically deserialize the pure inner classes since their no-args constructor also need a reference to the containing Object which is not available at the time of deserialization. You can address this problem by either making the inner class static or by providing a custom InstanceCreator for it. Here is an example:

public class A {   
  public String a;   
  
  class B {   
  
    public String b;   
  
    public B() {   
      // No args constructor for B   
    }   
  }   
}  

NOTE : The above class B can not (by default) be serialized with Gson.

G s o n   c a n   n o t   d e serialize {"b":"abc"} into an instance of B since the class B is an inner class. if it was defined as static class B then Gson would have been able to deserialize the string. Another solution is to write a custom instance creator for 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();   
  }   
}  

The above is possible, but not recommended.



数组例子:

Gson gson = new Gson();   
int[] ints = {1, 2, 3, 4, 5};   
String[] strings = {"abc", "def", "ghi"};   
  
(Serialization)   
gson.toJson(ints);     ==> prints [1,2,3,4,5]   
gson.toJson(strings);  ==> prints ["abc", "def", "ghi"]   
  
(Deserialization)   
int[] ints2 = gson.fromJson("[1,2,3,4,5]", int[].class);   
==> ints2 will be same as ints  

We also support multi-dimensional arrays, with arbitrarily complex element types

综合实例1:

public class ExampleBean {   
    private String  name;   
    private String  id;   
    private int    age;   
    private boolean isOk;   
       
    public ExampleBean(String name, String id, int age, boolean isOk) {   
        super();   
        this.name = name;   
        this.id = id;   
        this.age = age;   
        this.isOk = isOk;   
    }   
  
    public ExampleBean() {   
    }   
//setter和getter方法   
}  

测试:

public static void main(String[] args) {   
        Gson gson = new Gson();   
        List<ExampleBean> list = new ArrayList<ExampleBean>();   
        for (int i = 0; i < 5; i++) {   
            String name = "xxlong" + i;   
            int age = 20 + i;   
            ExampleBean bean = new ExampleBean(name, i + "", age);   
            list.add(bean);   
        }   
        Type listType = new TypeToken<List<ExampleBean>>() {   
        }.getType();   
        //将list转化成json字符串   
        String json = gson.toJson(list);   
        System.out.println(json);   
        //将json字符串还原成list   
        List<ExampleBean> list2 = gson.fromJson(json, listType);   
    }  

输出如下:[{"name":"xxlong0","id":"0","age":20,"isOk":false},{"name":"xxlong1","id":"1","age":21,"isOk":false},{"name":"xxlong2","id":"2","age":22,"isOk":false},{"name":"xxlong3","id":"3","age":23,"isOk":false},{"name":"xxlong4","id":"4","age":24,"isOk":false}]



综合实例2:

需求:想将字符串{'tableName' :'ys_index_y','year': '2008','params':'[z_expense,z_expense_profit,z_main_margin]','isOperAll':'false','copyToYear':''}还原成对象OpeerConditions,OpeerConditions对象代码如下所示

public class OperConditions {   
  
    private String   tableName;   
    private String   year;   
    private String[]    params;   
    private boolean  isOperALl;   
    private String   copyToYear;   
  
    public OperConditions() {   
    }   
  
    public OperConditions(String tableName, String year, String[] params,   
                    boolean isOperALl, String copyToYear) {   
        super();   
        this.tableName = tableName;   
        this.year = year;   
        this.params = params;   
        this.setOperALl(isOperALl);   
        this.copyToYear = copyToYear;   
    }   
//getter和setter方法   
}  

因为OperConditions中有属性params,它是一个数组,所以无论是用json lib还是gson都不能直接将上面的字符串还原成OperCondtions对象,可以直接将params分离出来，单独处理，我这里选用此种方法来处理：

json-lib代码如下：

public static void main(String[] args) {   
           
        String json = "{'tableName' :'ys_index_y','year': '2008','isOperAll':'false','copyToYear':''}";   
        JSONObject jsonObj = JSONObject.fromObject( json );    
        OperConditions conditions = (OperConditions) JSONObject.toBean( jsonObj, OperConditions.class );   
        System.out.println(conditions.isOperALl() == false); //==>输出为true   
           
        String json1 = "['z_expense','z_expense_profit','z_main_margin']";   
        JSONArray jsonArray = JSONArray.fromObject(json1);   
        //List<String> list = jsonArray.toList(jsonArray); //这个方法也可以   
        List<String> list = jsonArray.toList(jsonArray,String.class);   
        conditions.setParams(list.toArray(new String[0]));   
        System.out.println(conditions.getParams()[0]); //==>输出为z_expense   
    }  

因为JSONArray的toArray()方法返回的是一个Object[]数组，所以先将它转化成list，再转化到String数组。

当然由JSONArray转化成list时也可以使用subList方法，如下所示：

List<String> list = jsonArray.subList(0, jsonArray.size());

 
或者可以直接使用JSONArray的iterator() 方法迭代它本身直接得到需要的String数组。



如果使用Gson来完成这一需求，个人感觉更简单，代码如下所示：

public static void main(String[] args) {   
  
        String json = "{'tableName' :'ys_index_y','year': '2008','isOperAll':'false','copyToYear':''}";   
        Gson gson = new Gson();   
        OperConditions conditions = gson.fromJson(json, OperConditions.class);   
        System.out.println(conditions.isOperALl() == false); // ==>输出为true   
  
        String json1 = "['z_expense','z_expense_profit','z_main_margin']";   
        String[] params = gson.fromJson(json1,String[].class);   
        conditions.setParams(params);   
        System.out.println(conditions.getParams()[0]); // ==>输出为z_expense   
    }  

Gson可以直接转化成String[]数组，同时转化OperConditions时也比json-lib简单。

还有一点是非常值得注意的，就是你的bean中有boolean属性值时，强烈建议你别像我这个例子中一样命名为以is开头的属性名，这可能给你带来意想不到的错误，关于这一点的详细解说请参看我的文章json lib 学习笔记

【转载地址】
http://ryxxlong.iteye.com/blog/736783