Android Gson总结

Gson总结

依赖库

implementation 'com.google.code.gson:gson:2.8.6'

基本API介绍

JsonElement有4个子类：
- JsonObject
- JsonArray
- JsonPrimitive
- JsonNull

JsonElement常用方法：
isJsonArray()
getAsJsonArray()
isJsonObject()
getAsJsonObject()
isJsonPrimitive()
getAsJsonPrimitive()
isJsonNull()
getAsJsonNull()

基本用法

生成Json字符串

JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("name", "小明");
jsonObject.addProperty("age", 18);
jsonObject.addProperty("sex", true);

JsonArray jsonArray = new JsonArray();
jsonArray.add("北京市");
jsonArray.add("广州市");
jsonArray.add("上海市");
jsonObject.add("address", jsonArray);

System.out.println(jsonObject.toString());

{"name":"小明","age":18,"sex":true,"address":["北京市","广州市","上海市"]}

序列化和反序列化

public class User {
    
    
    private String name;
    private int age;
    private boolean sex;
    private String[] address;

    public User() {
    
    
    }

    public User(String name, int age, boolean sex, String[] address) {
    
    
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.address = address;
    }

    //省略setter/getter toString()
}

序列化操作

Gson gson = new Gson();
User user = new User("小白", 18, true, new String[]{
    
    "北京市", "上海市", "广州市"});
String json = gson.toJson(user);
System.out.println(json);

{"name":"小白","age":18,"sex":true,"address":["北京市","上海市","广州市"]}

反序列化操作

Gson gson = new Gson();
String json = "{\"name\":\"小白\",\"age\":18,\"sex\":true,\"address\":[\"北京市\",\"上海市\",\"广州市\"]}\n";
User user = gson.fromJson(json, User.class);
System.out.println(user);

User{name='小白', age=18, sex=true, address=[北京市, 上海市, 广州市]}

Json与数组的转换

String json = "[\n" +
    "{\"name\":\"小白\",\"age\":18,\"sex\":true,\"address\":[\"北京市\",\"上海市\",\"广州市\"]},\n" +
    "{\"name\":\"小白2\",\"age\":19,\"sex\":false,\"address\":[\"上海市\",\"广州市\"]},\n" +
    "{\"name\":\"小白3\",\"age\":120,\"sex\":true,\"address\":[\"北京市\",\"广州市\"]}\n" +
    "]";

Gson gson = new Gson();

//Json字符串转数组
System.out.println("Json字符串转数组：");
User[] users = gson.fromJson(json, User[].class);
for (User item : users) {
    
    
    System.out.println(item);
}

//数组转Json字符串
System.out.println("数组转Json字符串：");
String str = gson.toJson(users);
System.out.println(str);

Json字符串转数组：
User{name='小白', age=18, sex=true, address=[北京市, 上海市, 广州市]}
User{name='小白2', age=19, sex=false, address=[上海市, 广州市]}
User{name='小白3', age=120, sex=true, address=[北京市, 广州市]}
数组转Json字符串：
[{"name":"小白","age":18,"sex":true,"address":["北京市","上海市","广州市"]},{"name":"小白2","age":19,"sex":false,"address":["上海市","广州市"]},{"name":"小白3","age":120,"sex":true,"address":["北京市","广州市"]}]

Json与List的转换

String json = "[\n" +
    "{\"name\":\"小白\",\"age\":18,\"sex\":true,\"address\":[\"北京市\",\"上海市\",\"广州市\"]},\n" +
    "{\"name\":\"小白2\",\"age\":19,\"sex\":false,\"address\":[\"上海市\",\"广州市\"]},\n" +
    "{\"name\":\"小白3\",\"age\":120,\"sex\":true,\"address\":[\"北京市\",\"广州市\"]}\n" +
    "]";

Gson gson = new Gson();

//Json字符串转List
System.out.println("Json字符串转List:");
ArrayList<User> userList = gson.fromJson(json, new TypeToken<List<User>>() {
    
    
}.getType());
System.out.println(userList);

//List转Json字符串
System.out.println("List转Json字符串:");
String str = gson.toJson(userList);
System.out.println(str);

Json字符串转List:
[User{name='小白', age=18, sex=true, address=[北京市, 上海市, 广州市]}, User{name='小白2', age=19, sex=false, address=[上海市, 广州市]}, User{name='小白3', age=120, sex=true, address=[北京市, 广州市]}]
List转Json字符串:
[{"name":"小白","age":18,"sex":true,"address":["北京市","上海市","广州市"]},{"name":"小白2","age":19,"sex":false,"address":["上海市","广州市"]},{"name":"小白3","age":120,"sex":true,"address":["北京市","广州市"]}]

泛型支持

public class Base<T> {
    
    
    private int code;
    private String message;
    private T data;  
}

String json = "{\n" +
"    \"code\":1,\n" +
"    \"message\":\"success\",\n" +
"    \"data\":{\n" +
"        \"name\":\"小花\",\n" +
"        \"age\":\"38\",\n" +
"        \"sex\":true\n" +
"    }\n" +
"}";
Gson gson = new Gson();
Base<User> userBase = gson.fromJson(json, new TypeToken<Base<User>>() {
    
    
}.getType());
System.out.println(userBase);

Base{code=1, message='success', data=User{name='小花', age=38, sex=true}}

注解

@SerializedName 属性重命名

public class User {
    
    
    @SerializedName("Name")
    private String name;
    @SerializedName("Age")
    private int age;
    @SerializedName("Sex")
    private boolean sex;
    @SerializedName("Address")
    private String[] address;
}

Gson gson = new Gson();
String json = "{\"Name\":\"小白\",\"Age\":18,\"Sex\":true,\"Address\":[\"北京市\",\"上海市\",\"广州市\"]}\n";
User user = gson.fromJson(json, User.class);
System.out.println(user);

User{name='小白', age=18, sex=true, address=[北京市, 上海市, 广州市]}

@Expose 序列化策略

@Expose(serialize = true, deserialize = true)   //序列化和反序列化都生效
@Expose(serialize = false, deserialize = true)  //序列化时不生效，反序列化时生效
@Expose(serialize = true, deserialize = false)  //序列化时生效，反序列化时不生效
@Expose(serialize = false, deserialize = false) //序列化和反序列化都不生效，和不写注解一样

过滤

Gson提供excludeFieldsWithModifiers()方法过滤指定数据

public class User {
    
    
    public String name;
    int age;
    protected boolean sex;
    private String[] address;
}

User user = new User("小白", 18, true, new String[]{
    
    "北京市", "上海市", "广州市"});
Gson gson = new GsonBuilder().excludeFieldsWithModifiers(Modifier.PUBLIC, Modifier.PROTECTED).create();
String json = gson.toJson(user);
System.out.println(json);

{"age":18,"address":["北京市","上海市","广州市"]}

输出null

Gson在进行序列化操作时，如果某个属性值为null，则序列化时不操作该字段，否则使用serializeNulls()进行配置。

User user = new User(null, 18, true, null);
Gson gson = new Gson();
String json = gson.toJson(user);
System.out.println(json);

{"age":18,"sex":true}

serializeNulls()

User user = new User(null, 18, true, null);
Gson gson = new GsonBuilder().serializeNulls().create();
String json = gson.toJson(user);
System.out.println(json);

{"name":null,"age":18,"sex":true,"address":null}

格式日期时间

public class User {
    
    
    private String name;
    private int age;
    private Date date;
}

序列化

Gson gson = new GsonBuilder()
    .setPrettyPrinting() //格式化输出json
    .setDateFormat("yyyy-MM-dd HH:mm:ss") //格式化日期
    .create();

User user = new User("小黑", 18, new Date());
String json = gson.toJson(user);
System.out.println(json);

{
  "name": "小黑",
  "age": 18,
  "date": "2021-02-25 17:38:10"
}

反序列化

String json = "{\n" +
    "  \"name\": \"小黑\",\n" +
    "  \"age\": 18,\n" +
    "  \"date\": \"2021-02-25 17:38:10\"\n" +
    "}";
User user = gson.fromJson(json, User.class);
System.out.println(user);

User{name='小黑', age=18, date=Thu Feb 25 17:38:10 CST 2021}

TypeAdapter

TypeAdapter是一个抽象类，用于处理序列化和反序列化过程。

public class User {
    
    
    private String name;
    private int age;
    private boolean sex;

    public User() {
    
    
    }

    public User(String name, int age, boolean sex) {
    
    
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    //省略getter/setter toString()
}

自定义TypeAdapter

public class UserTypeAdapter extends TypeAdapter<User> {
    
    

    //定义序列化操作
    @Override
    public void write(JsonWriter out, User user) throws IOException {
    
    
        out.beginObject();
        out.name("Name").value(user.getName());
        out.name("Age").value(user.getAge());
        out.name("Sex").value(user.isSex());
        out.endObject();
    }

    //定义反序列化操作
    @Override
    public User read(JsonReader in) throws IOException {
    
    
        User user = new User();
        in.beginObject();
        while (in.hasNext()) {
    
    
            switch (in.nextName()) {
    
    
                case "name":
                case "Name":
                    user.setName(in.nextString());
                    break;
                case "age":
                case "Age":
                    user.setAge(in.nextInt());
                    break;
                case "sex":
                case "Sex":
                    user.setSex(in.nextBoolean());
                    break;
            }
        }
        in.endObject();
        return user;
    }
}

序列化

Gson gson = new GsonBuilder().registerTypeAdapter(User.class, new UserTypeAdapter()).create();
User user = new User("小红", 28, true);
String json = gson.toJson(user);
System.out.println(json);

{"Name":"小红","Age":28,"Sex":true}

反序列化

String json = "{\"Name\":\"小红\",\"Age\":28,\"Sex\":true}";
User user = gson.fromJson(json, User.class);
System.out.println(user);

User{name='小红', age=28, sex=true}

JsonSerializer & JsonDeserializer

TypeAdapter 将序列化和反序列操作都接管了过来，可以通过JsonSerializer和JsonDeserializer只处理其中一个。

序列化

Gson gson = new GsonBuilder()
    .registerTypeAdapter(User.class, new JsonSerializer<User>() {
    
    
        @Override
        public JsonElement serialize(User user, Type typeOfSrc, JsonSerializationContext context) {
    
    
            JsonObject jsonObject = new JsonObject();
            jsonObject.addProperty("name", user.getName());
            jsonObject.addProperty("age", user.getAge());
            jsonObject.addProperty("sex", user.isSex());
            return jsonObject;
        }
    })
    .registerTypeAdapter(User.class, new JsonDeserializer<User>() {
    
    
        @Override
        public User deserialize(JsonElement jsonElement, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
    
    
            User user = new User();
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            if (jsonObject.has("name")) {
    
    
                user.setName(jsonObject.get("name").getAsString());
            }
            if (jsonObject.has("age")) {
    
    
                user.setAge(jsonObject.get("age").getAsInt());
            }
            if (jsonObject.has("sex")) {
    
    
                user.setSex(jsonObject.get("sex").getAsBoolean());
            }
            return user;
        }
    })
    .create();

User user = new User("小花", 38, false);
String json = gson.toJson(user);
System.out.println(json);

{"name":"小花","age":38,"sex":false}

反序列化

String json = "{\"name\":\"小花\",\"age\":38,\"sex\":true}";
User user = gson.fromJson(json, User.class);
System.out.println(user);

User{name='小花', age=38, sex=true}

@JsonAdapter

public class UserTypeAdapter implements JsonSerializer<User>, JsonDeserializer<User> {
    
    

    @Override
    public JsonElement serialize(User user, Type typeOfSrc, JsonSerializationContext context) {
    
    
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("name", user.getName());
        jsonObject.addProperty("age", user.getAge());
        jsonObject.addProperty("sex", user.isSex());
        return jsonObject;
    }

    @Override
    public User deserialize(JsonElement jsonElement, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
    
    
        User user = new User();
        JsonObject jsonObject = jsonElement.getAsJsonObject();
        if (jsonObject.has("name")) {
    
    
            user.setName(jsonObject.get("name").getAsString());
        }
        if (jsonObject.has("age")) {
    
    
            user.setAge(jsonObject.get("age").getAsInt());
        }
        if (jsonObject.has("sex")) {
    
    
            user.setSex(jsonObject.get("sex").getAsBoolean());
        }
        return user;
    }
}

@JsonAdapter(UserTypeAdapter.class)
public class User {
    
    
    private String name;
    private int age;
    private boolean sex;
}

String json = "{\"name\":\"小花\",\"age\":38,\"sex\":true}";
Gson gson = new Gson();
User user = gson.fromJson(json, User.class);
System.out.println(user);

TypeAdapterFactory

String json = "{\"name\":\"小花\",\"age\":38,\"sex\":true}";
Gson gson = new GsonBuilder().registerTypeAdapterFactory(new TypeAdapterFactory() {
    
    
    @Override
    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
    
    
        if (typeToken.getRawType().equals(User.class)) {
    
    
            return (TypeAdapter<T>) new UserTypeAdapter();
        }
        return null;
    }
}).create();
User user = gson.fromJson(json, User.class);
System.out.println(user);