Gson使用
实例化Gson对象
-
通过构造函数获取
Gson gson = new Gson();
-
通过
GsonBuilder获取，可以进行多项配置Gson gson = new GsonBuilder().create();
生成Json字符串
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("name","hyf");
jsonObject.addProperty("age",21);
jsonObject.addProperty("Boolean",true);
JsonElement
JsonObject jsonObject = new JsonObject();
Json.addProperty("String", "leavesC");
jsonObject.addProperty("Number", 23);
jsonObject.addProperty("Number", 22.9);
jsonObject.addProperty("Boolean", true);
jsonObject.addProperty("Char", 'c');
JsonObject jsonElement = new JsonObject();
jsonElement.addProperty("Boolean", false);
jsonElement.addProperty("Double", 25.9);
jsonElement.addProperty("Char", 'c');
jsonObject.add("JsonElement", jsonElement);
Json和数组/List转换
1. json转字符串数组
Gson gson = new Gson();
String jsonArray = "[\"3\",\"4\",\"5\"]";
String[] strings = gson.fromJson(jsonArray,String[].class);
2. 字符串数组转json
String jsonArray = gson.toJson(jsonArray,new TypeToken<String>(){}.getType());
3. json转List
String jsonArray = "[....]" //此处jsonArray与(1)中相同
List<String> stringList = gson.fromJson(jsonArray,new TypeToken<List<String>>(){}.getType());
4. List转Json
String jsonArray = gson.toJson(stringList,new TypeToken<List<String>>(){}.getType());
序列化和反序列化
1. 序列化
User user = new User("hyf",22,true); //假设有一个userBean里面有name,age,gender
Gson gson = new Gson();
String json = gson.toJson(user);
//out: {"name":"hyf","age":22,"gender":true}
2. 反序列化
User user = gson.fromJson(json,User.class);
//此处的json为上面序列化输出的json字符串
属性重命名
修改User类，为name声明SerializedName。其中value设置属性名，而alternate则设置多个备选属性名
public class User{
@SerializedName(value = "userName",alternate={"user_name","Name"})
private String name;
private int age;
private boolean gender;
}
字段过滤
1. 基于@Expose注解
Expose注解的注解值声明情况有四种
@Expose(serialize=true,deserialize=true)//序列化和反序列化都生效
@Expose(serialize=false,deserialize=false)
//序列化和反序列化都不生效
@Expose(serialize=true,deserialize=false)
//序列化生效，反序列化不生效
@Expose(serialize=false,deserialize=true)
//序列化不生效，反序列化生效
2. 基于版本
Gson提供了@Since和@Until两个注解基于版本对字段进行过滤，它们都包含一个Double值，用于设置版本号。
- @Since 从...开始
- @Until 到...为止
- 它们要配合
GsonBuilder配合使用
当版本（GsonBuilder设置的版本）大于或等于Since值或小于Until时，字段会进行序列化和反序列操作，而没有声明注解的字段都会加入序列化和反序列操作。
例子：修改User类
public class User {
@Since(1.4)
private String a;
@Since(1.6)
private String b;
@Since(1.8)
private String c;
@Until(1.6)
private String d;
@Until(2.0)
private String e;
public User(String a, String b, String c, String d, String e) {
this.a = a;
this.b = b;
this.c = c;
this.d = d;
this.e = e;
}
@Override
public String toString() {
return "User{" +
"a='" + a + '\'' +
", b='" + b + '\'' +
", c='" + c + '\'' +
", d='" + d + '\'' +
", e='" + e + '\'' +
'}';
}
}
Gson gson = new GsonBuilder().setVersion(1.6).create();
User user = new User("A", "B", "C", "D", "E");
System.out.println();
System.out.println(gson.toJson(user));
String json = "{\"a\":\"A\",\"b\":\"B\",\"c\":\"C\",\"d\":\"D\",\"e\":\"E\"}";
user = gson.fromJson(json, User.class);
System.out.println();
System.out.println(user.toString());
结果输出：只会序列化和反序列化a,b,c
序列化：{"a":"A","b":"B","e":"E"}
反序列化：User{a='A',b='B',c='null',d='null',e='E'}
3.基于访问修饰符
通过GsonBuilder对象的excludeFieldsWithModifiers方法来指定不进行序列化和反序列话操作的访问修饰符字段
public class ModifierSample {
public String publicField = "public";
protected String protectedField = "protected";
private String privateField = "private";
String defaultField = "default";
final String finalField = "final";
static String staticField = "static";
}
public static void main(String[] args) {
Gson gson = new GsonBuilder().excludeFieldsWithModifiers(Modifier.PRIVATE, Modifier.STATIC).create();
ModifierSample modifierSample = new ModifierSample();
System.out.println(gson.toJson(modifierSample));
}
输出：private和static的字段将不会被序列化和反序列化
4.基于策略
通过GsonBuilder的setExclusionStrategies(ExclusionStrategy... strategies)来直接排除指定字段名或者指定字段类型不进行序列化和反序列化
Gson gson = new GsonBuilder().setExclusionStrategies（new ExclusionStrategy(){
@Override
public boolean shouldSkipField(FieldAttributes fieldAttributes) {
//排除指定字段名（这里指定字段名为）
return fieldAttributes.getName().equals("intField");
}
@Override
public boolean shouldSkipClass(Class<?> aClass) {
//排除指定字段类型(这里指定dobule类)
return aClass.getName().equals(double.class.getName());
}）.create();
setExclusionStrategies 方法在序列化和反序列化时都会生效，如果只是想指定其中一种情况下的排除策略或分别指定排除策略，可以改为使用以下两个方法
addSerializationExclusionStrategy(ExclusionStrategy strategy);
- addDeserializationExclusionStrategy(ExclusionStrategy strategy);
个性化设置
1. 序列化时输出null
Gson gson = new GsonBuilder()
.serializeNulls();
.create();
序列化User类： 假设user类（null,24,true）
输出：{"name":null,"age":24,"gender":true}
2.格式化输出Json
Gson默认序列化的json字符串不够直观，可以使用GsonBuilder的setPrettyPrinting进行格式化输出
Gson gson = new GsonBuilder()
.serializeNulls()
.setPrettyPrinting()
.create();
输出：
{
"name":null,
"age":24,
"gender":true
}
3.格式化时间
Gson gson = new GsonBuilder()
.setDateFormat("yyyy-MM-dd HH:mm:ss:SSS")
.create();
TypeAdapter
TypeAdapter是一个泛型抽象类，用于接管某种类型的序列化和反序列过程，包含两个抽象方法，分别用于自定义序列化和反序列化的过程。
例子：对应还是使用User类（包含name,age,gender）
定义一个类继承TypeAdapter
public class UserTypeAdapter extends TypeAdapter<User>{
@Override
public void write(JsonWriter jsonWriter, User user) throws IOException {
//流式序列化成对象开始
jsonWriter.beginObject();
//将Json的Key值都指定为大写字母开头
jsonWriter.name("Name").value(user.getName());
jsonWriter.name("Age").value(user.getAge());
jsonWriter.name("Gender").value(user.isSex());
//流式序列化结束
jsonWriter.endObject();
}
@Override
public User read(JsonReader jsonReader) throws IOException {
User user = new User();
//流式反序列化开始
jsonReader.beginObject();
while (jsonReader.hasNext()) {
switch (jsonReader.nextName()) {
//首字母大小写均合法
case "name":
case "Name":
user.setName(jsonReader.nextString());
break;
case "age":
user.setAge(jsonReader.nextInt());
break;
case "gender":
user.setGender(jsonReader.nextBoolean());
break;
}
}
//流式反序列化结束
jsonReader.endObject();
return user;
}
}
使用：
Gson gson = new GsonBuilder()
.registerTypeAdapter(User.class,new UserTypeAdapter())
.create();
User user = new User("hyf",22,true);
String json = gson.toJson(user);
user = gson.fromJson(json,User.class);
输出序列化后的json和反序列化后的user
{"Name":"hyf","Age":22,"Gender":true}
User{name="hyf",age=22,gender=true}
TypeAdapter同时接管了序列化和反序列化操作
- JsonSerializer 只接管序列化过程的接口
- JsonDeserializer 只接管反序列化过程的接口
TypeAdapterFactory
TypeAdapterFactory 是用于创建 TypeAdapter 的工厂类，通过参数 TypeToken 来查找确定对应的 TypeAdapter , 如果没有就返回 null 并由 Gson 默认的处理方法来进行序列化和反序列化，否则就由客户预定义的 TypeAdapter 来进行处理。
Gson gson = new GsonBuilder()
.registerTypeAdapterFactory(new TypeAdapterFactory() {
@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
//如果 Gson 需要与 User 类相关的 TypeAdapter ，则返回我们自己定义的 TypeAdapter 对象
if (typeToken.getType().getTypeName().equals(User.class.getTypeName())) {
return (TypeAdapter<T>) new UserTypeAdapter();
}
//找不到则返回null
return null;
}
})
.create();
