Android中使用Gson
Gson是一个Java库，可用于将Java对象转换为它们的JSON表示。它还可以用于将JSON字符串转换为等效的Java对象。Gson可以处理任意Java对象，包括您没有源代码的已有对象。
一、简单使用
1. 导入
在Android的build.gradle中添加依赖：
dependencies {
implementation 'com.google.code.gson:gson:2.10.1'
}
2. Gson序列化
下面以一个简单例子展示对象序列化：
Item item = new Item();
item.id = 101;
item.name = "Apple";
Gson gson = new Gson();
String json = gson.toJson(item);
Log.d(TAG, json);
打印的json字符串值为：
{"id": 101,"name": "Apple"}
序列化就是如此简单，json字段名就是类的属性名，如果要修改序列化字段名，需要在类型属性上添加注解@SerializedName：
public class Item {
@SerializedName("ID")
int id;
String name;
@NonNull
@Override
public String toString() {
return "Item{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
那么json的字符串值将变为：
{"ID": 101,"name": "Apple"}
3. Gson对象解析
将上面的json直接解析为Item对象：
Item it = gson.fromJson(json, Item.class);
Log.d(TAG, it.toString());
打印结果如下：
Item{id=101, name='Apple'}
可见Gson的使用是非常简单的，掌握上述方法已经可以处理大部分JSON序列化问题了。
二、混淆
Gson的对象解析利用到了java反射机制，如果开启了混淆是否影响序列化和反序列化，接下来做一个简单的实验。
在build.gradle中打开混淆开关：
buildTypes {
debug {
minifyEnabled true
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
再次运行上面的代码，将得到如下类似打印：
{"ID":101,"b":"Apple"}
由于在id字段上添加了注解序列化名称，因此ID名称并没有因混淆被影响；而name字段由于混淆名称变为了b，所以JSON字段名称也变成了b。
所以要避免混淆对系列化的影响，一是可以在需要化字段上添加注解@SerializedName，二是防止整个类被混淆，如可在类上添加注解@Keep，或者在混淆文件中添加
-keepclasseswithmembernames class com.ihuntto.hellogson.Item {*;}
三、序列化部分类属性
上面给出的例子是对类的属性进行全部JSON序列化，如果要进行部分序列化，该怎么办？这里有多种方式可选择。
1. 使用transient修饰符
在不需要序列化字段前面添加transient：
transient String nickName = "Pie";
2. 指定Modifier字段
如不序列化private和protected字段：
Gson gson = new GsonBuilder().excludeFieldsWithModifiers(Modifier.PRIVATE, Modifier.PROTECTED).create();
当然还用其他Modifier可以选择：
package java.lang.reflect;
public class Modifier {
public static final int ABSTRACT = 1024;
public static final int FINAL = 16;
public static final int INTERFACE = 512;
public static final int NATIVE = 256;
public static final int PRIVATE = 2;
public static final int PROTECTED = 4;
public static final int PUBLIC = 1;
public static final int STATIC = 8;
public static final int STRICT = 2048;
public static final int SYNCHRONIZED = 32;
public static final int TRANSIENT = 128;
public static final int VOLATILE = 64;
...
}
3. 使用注解@Expose
在需要进行序列化的字段上添加@Expose注解：
public class Item {
@Expose
@SerializedName("ID")
int id;
@Expose
String name;
transient String nickName = "Pie";
String otherStuff;
...
}
使用GsonBuilder创建Gson，以排除不包含@Expose注解的字段：
Item item = new Item();
item.id = 101;
item.name = "Apple";
item.otherStuff = "Red";
Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();
String json = gson.toJson(item);
Log.d(TAG, json);
序列化的json字符串打印为：
{"ID":101,"name":"Apple"}
可见nickName和otherStuff字段都没有被序列化。
也可以指定字段只支持序列化或反序列化：
@Expose(serialize = true, deserialize = false)
4. 自定义排除策略
如果上面还不能满足部分字段序列化需求，还可以自定义排除策略：
public class MyExclusionStrategy implements ExclusionStrategy {
@Override
public boolean shouldSkipField(FieldAttributes field) {
return field.getName().startsWith("_");
}
@Override
public boolean shouldSkipClass(Class<?> clazz) {
return clazz.isAnonymousClass();
}
}
排除以下划线开头的字段，以及匿名内部类不进行序列化，还可以根据FieldAttributes和Class<?>支持的判断添加排除策略。
综合上述4种方法，首先不推荐使用@Expose注解，因为任何库中类的字段不支持你添加@Expose注解的，也就是你不能序列化任何库中的类对象；其次不推荐使用Modifier进行排除序列化字段，一是代码规范基本建议不使用public字段，二是protected和private可以用来区别子类的可见性，但不是区分序列化的标志，如果实在是要使用，建议使用其他Modifier来区分；比较建议使用transient，因为java语言已经明确其修饰字段不进行序列化。
四、反序列化含子类的列表
如果在ArrayList<IShape>的列表中添加了IShape的子类，那么这个列表还能正常序列化和反序列化吗？
interface IShape {
void draw();
}
public class Circle implements IShape {
private static final String TAG = Circle.class.getSimpleName();
float x;
float y;
float radius;
public Circle() {
}
public Circle(float x, float y, float radius) {
this.x = x;
this.y = y;
this.radius = radius;
}
@Override
public void draw() {
Log.d(TAG, "draw " + toString());
}
@NonNull
@Override
public String toString() {
return "Circle{" +
"x=" + x +
", y=" + y +
", radius=" + radius +
'}';
}
}
public class Rectangle implements IShape {
private static final String TAG = Rectangle.class.getSimpleName();
float x;
float y;
float width;
float height;
public Rectangle() {
}
public Rectangle(float x, float y, float width, float height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
@Override
public void draw() {
Log.d(TAG, "draw " + toString());
}
@NonNull
@Override
public String toString() {
return "Rectangle{" +
"x=" + x +
", y=" + y +
", width=" + width +
", height=" + height +
'}';
}
}
public class ShapeHolder {
List<IShape> shapes = new ArrayList<>();
}
IShape circle = new Circle(0, 0, 10);
IShape rectangle = new Rectangle(0, 0, 20, 10);
ShapeHolder holder = new ShapeHolder();
holder.shapes.add(circle);
holder.shapes.add(rectangle);
Gson gson = new Gson();
String json = gson.toJson(holder);
Log.d(TAG, json);
上述代码可以正常序列化：
{"shapes":[{"radius":10.0,"x":0.0,"y":0.0},{"height":10.0,"width":20.0,"x":0.0,"y":0.0}]}
但是将json字符串进行反序列化时：
ShapeHolder shapeHolder = gson.fromJson(json, ShapeHolder.class);
将得到如下异常：
com.google.gson.JsonIOException: Interfaces can't be instantiated! Register an InstanceCreator or a TypeAdapter for this type. Interface name: com.ihuntto.hellogson.IShape
异常提示注册一个InstanceCreator或者TypeAdapter，那么尝试为gson添加一个TypeAdapter，首先在Circle和Rectangle中添加type字段以区分不同的序列化类：
public class Circle implements IShape {
...
String type = "circle";
...
}
public class Rectangle implements IShape {
...
String type = "rectangle";
...
}
public class IShapeDeserializer implements JsonDeserializer<IShape> {
private final Gson mGson = new Gson();
private final HashMap<String, Class<? extends IShape>> mTypeMap = new HashMap<>();
public IShapeDeserializer() {
mTypeMap.put("circle", Circle.class);
mTypeMap.put("rectangle", Rectangle.class);
}
@Override
public IShape deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
Class<? extends IShape> clazz = mTypeMap.get(json.getAsJsonObject().get("type").getAsString());
return mGson.fromJson(json, clazz);
}
}
现在进行序列化与反序列化：
IShape circle = new Circle(0, 0, 10);
IShape rectangle = new Rectangle(0, 0, 20, 10);
ShapeHolder holder = new ShapeHolder();
holder.shapes.add(circle);
holder.shapes.add(rectangle);
Gson gson = new GsonBuilder().registerTypeAdapter(IShape.class, new IShapeDeserializer()).create();
String json = gson.toJson(holder);
Log.d(TAG, json);
ShapeHolder shapeHolder = gson.fromJson(json, ShapeHolder.class);
for (IShape shape : shapeHolder.shapes) {
shape.draw();
}
运行上述代码将得到如下打印：
2023-12-17 12:37:22.000 31010-31010/com.ihuntto.hellogson D/MainActivity: {"shapes":[{"radius":10.0,"type":"circle","x":0.0,"y":0.0},{"height":10.0,"type":"rectangle","width":20.0,"x":0.0,"y":0.0}]}
2023-12-17 12:37:22.006 31010-31010/com.ihuntto.hellogson D/Circle: draw Circle{x=0.0, y=0.0, radius=10.0}
2023-12-17 12:37:22.006 31010-31010/com.ihuntto.hellogson D/Rectangle: draw Rectangle{x=0.0, y=0.0, width=20.0, height=10.0}
如果我定义了一个ShapeCompounds：
public class ShapeCompounds implements IShape {
private static final String TAG = ShapeCompounds.class.getSimpleName();
String type = "shape-compounds";
List<IShape> shapes = new ArrayList<>();
@Override
public void draw() {
Log.d(TAG, "draw " + toString());
}
@NonNull
@Override
public String toString() {
return "ShapeCompounds{" +
"type='" + type + '\'' +
", shapes=" + shapes +
'}';
}
}
并且在IShapeDeserializer进行注册：
public class IShapeDeserializer implements JsonDeserializer<IShape> {
...
public IShapeDeserializer() {
...
mTypeMap.put("shape-compounds", ShapeCompounds.class);
}
...
}
那么下面这段代码还能运行正常吗？
IShape circle = new Circle(0, 0, 10);
IShape rectangle = new Rectangle(0, 0, 20, 10);
ShapeCompounds compounds = new ShapeCompounds();
compounds.shapes.add(circle);
compounds.shapes.add(rectangle);
ShapeHolder holder = new ShapeHolder();
holder.shapes.add(circle);
holder.shapes.add(rectangle);
holder.shapes.add(compounds);
Gson gson = new GsonBuilder().registerTypeAdapter(IShape.class, new IShapeDeserializer()).create();
String json = gson.toJson(holder);
Log.d(TAG, json);
ShapeHolder shapeHolder = gson.fromJson(json, ShapeHolder.class);
for (IShape shape : shapeHolder.shapes) {
shape.draw();
}
很不辛，上述代码可以序列化成功，但反序列化失败，如果在IShapeDeserializer的deserialize方法出加上打印可以知道原因是无法反序列化ShapeCompounds，因为序列化ShapeCompounds的Gson为普通Gson，并没有注册TypeAdapter，因此同样需要为IShapeDeserializer注册TypeAdapter：
public class IShapeDeserializer implements JsonDeserializer<IShape> {
private static Gson sInstance;
private final HashMap<String, Class<? extends IShape>> mTypeMap = new HashMap<>();
private IShapeDeserializer() {
mTypeMap.put("circle", Circle.class);
mTypeMap.put("rectangle", Rectangle.class);
mTypeMap.put("shape-compounds", ShapeCompounds.class);
}
@Override
public IShape deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
Class<? extends IShape> clazz = mTypeMap.get(json.getAsJsonObject().get("type").getAsString());
return sInstance.fromJson(json, clazz);
}
public static Gson crate() {
if (sInstance == null) {
sInstance = new GsonBuilder().registerTypeAdapter(IShape.class, new IShapeDeserializer()).create();
}
return sInstance;
}
}
将测试代码中的gson对象创建方法替换为：
Gson gson = IShapeDeserializer.crate();
运行测试代码就可以得到正常打印了：
2023-12-17 12:54:41.038 31506-31506/com.ihuntto.hellogson D/MainActivity: {"shapes":[{"radius":10.0,"type":"circle","x":0.0,"y":0.0},{"height":10.0,"type":"rectangle","width":20.0,"x":0.0,"y":0.0},{"shapes":[{"radius":10.0,"type":"circle","x":0.0,"y":0.0},{"height":10.0,"type":"rectangle","width":20.0,"x":0.0,"y":0.0}],"type":"shape-compounds"}]}
2023-12-17 12:54:41.044 31506-31506/com.ihuntto.hellogson D/Circle: draw Circle{x=0.0, y=0.0, radius=10.0}
2023-12-17 12:54:41.044 31506-31506/com.ihuntto.hellogson D/Rectangle: draw Rectangle{x=0.0, y=0.0, width=20.0, height=10.0}
2023-12-17 12:54:41.045 31506-31506/com.ihuntto.hellogson D/ShapeCompounds: draw ShapeCompounds{type='shape-compounds', shapes=[Circle{x=0.0, y=0.0, radius=10.0}, Rectangle{x=0.0, y=0.0, width=20.0, height=10.0}]}
这里仅总结我在使用Gson过程中遇到的问题及解决的方法，后续遇到新的问题再进行更新。
