Gson

简介

一个Java库,用于Java对象和JSON对相互转换。

项目地址

https://github.com/google/gson

API

http://www.javadoc.io/doc/com.google.code.gson/gson/2.8.0

User Guide

https://github.com/google/gson/blob/master/UserGuide.md

gradle配置

compile 'com.google.code.gson:gson:2.8.0'

基本用法

序列化json

gson.toJson()

反序列化json

gson.fromJson()

例子1：

// Serialization
Gson gson = new Gson();
gson.toJson(1);            // ==> 1
gson.toJson("abcd");       // ==> "abcd"
gson.toJson(new Long(10)); // ==> 10
int[] values = { 1 };
gson.toJson(values);       // ==> [1]

// Deserialization
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);

例子2：

class BagOfPrimitives {
  private int value1 = 1;
  private String value2 = "abc";
  private transient int value3 = 3;
  BagOfPrimitives() {
    // no-args constructor
  }
}

// Serialization
BagOfPrimitives obj = new BagOfPrimitives();
Gson gson = new Gson();
String json = gson.toJson(obj);  

// ==> json is {"value1":1,"value2":"abc"}

gsonBuilder设置

        GsonBuilder gsonBuilder = new GsonBuilder();
        /**
         * 设置在序列化时忽略null元素
         */
        gsonBuilder.serializeNulls();

        /**
         * 设置不对序列化内部类，内部类
         */
        gsonBuilder.disableInnerClassSerialization();
        /**
         * 设置高于版本号，配合@Since
         */
        gsonBuilder.setVersion(3);
        /**
         *
         */
        gsonBuilder.excludeFieldsWithModifiers(Modifier.STATIC);
        /**
         * 设置格式化打印
         */
        gsonBuilder.setPrettyPrinting();
        /**
         * 禁止html转码
         */
        gsonBuilder.disableHtmlEscaping();

自定义适配器

MyClass.java

public class MyClass {
    private int m_int;
    private String m_string;


    public int getM_int() {
        return m_int;
    }

    public void setM_int(int m_int) {
        this.m_int = m_int;
    }

    public String getM_string() {
        return m_string;
    }

    public void setM_string(String m_string) {
        this.m_string = m_string;
    }
}

使用TypeAdapter序列化和反序列化

public class MyTypeAdapter extends TypeAdapter<MyClass> {

    @Override
    public void write(JsonWriter out, MyClass value) throws IOException {
        if (value == null) {
            out.nullValue();
            return;
        }
        out.beginObject();
        out.name("myclass_int");
        out.value(value.getM_int());
        out.name("myclass_string");
        out.value(value.getM_string());
        out.endObject();
    }

    @Override
    public MyClass read(JsonReader in) throws IOException {
        if (in.peek() == JsonToken.NULL) {
            in.nextNull();
            return null;
        }
        in.beginObject();
        MyClass myClass = new MyClass();
        while (in.peek() != JsonToken.END_OBJECT) {
            String name = in.nextName();
            if(name.equals("myclass_int")){
                int value = in.nextInt();
                myClass.setM_int(value);
            }else if(name.equals("myclass_string")){
                String string = in.nextString();
                myClass.setM_string(string);
            }
        }
        in.endObject();
        return myClass;
    }

}

使用JsonSerializer和JsonDeserializer序列化和反序列化

public class MyJsonSerializerAndJsonDeserializer implements JsonSerializer<MyClass>,JsonDeserializer<MyClass>{

    @Override
    public MyClass deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        /**
         * 反序列化
         */
        MyClass myClass = new MyClass();
        int myclass_int = json.getAsJsonObject().get("myclass_int").getAsJsonPrimitive().getAsInt();
        String myclass_string = json.getAsJsonObject().get("myclass_string").getAsString();
        myClass.setM_int(myclass_int);
        myClass.setM_string(myclass_string);
        return myClass;
    }

    @Override
    public JsonElement serialize(MyClass src, Type typeOfSrc, JsonSerializationContext context) {
        /**
         *序列化
         */
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("myclass_int",src.getM_int());
        jsonObject.addProperty("myclass_string",src.getM_string());
        return jsonObject;
    }
}

使用以上适配器

        GsonBuilder gsonBuilder = new GsonBuilder();
        gsonBuilder.registerTypeAdapter(MyClass.class,new MyTypeAdapter());
        gsonBuilder.registerTypeAdapter(MyClass.class,new MyJsonSerializerAndJsonDeserializer());
        Gson gson = gsonBuilder.create();

        MyClass myClass = new MyClass();
        myClass.setM_int(3);
        myClass.setM_string("我是陆大旭");
        String string = gson.toJson(myClass);

        String string2 = "{\"myclass_int\":3,\"myclass_string\":\"我是陆大旭\"}";
        MyClass myClass1 = gson.fromJson(string2,MyClass.class);

其他知识点

1.不能序列化循环应用的对象，这样会导致无限递归。 比如：

class BagOfPrimitives {

    private BagOfPrimitives bagOfPrimitives = new BagOfPrimitives();

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

//无限递归，报错
gson.toJson(new BagOfPrimitives());

2.FieldNamingPolicy参数 IDENTITY：默认，不改变变量名字 UPPER_CAMEL_CASE：首字母变大

• someFieldName ---> SomeFieldName
• _someFieldName ---> _SomeFieldName

• someFieldName ---> Some Field Name
• _someFieldName ---> _Some Field Name

• someFieldName ---> some_field_name
• _someFieldName ---> _some_field_name
• aStringField ---> a_string_field
• aURL ---> a_u_r_l

• someFieldName ---> some-field-name
• _someFieldName ---> _some-field-name
• aStringField ---> a-string-field
• aURL ---> a-u-r-l