Android中使用Gson根据Type反序列化DataItem子类的优化方案

你可以通过给DataItem类单独注册自定义TypeAdapter的方式，实现仅针对该类的子类反序列化逻辑，无需在Response层面处理，既聚焦又符合单一职责原则。

具体实现步骤 #

1. 定义核心数据类

先明确基础类结构：

// Color基类
public abstract class Color {
    // 基类公共字段
}

// Blue子类
public class Blue extends Color {
    private String blueSpecificProp;
    // getter、setter省略
}

// Red子类
public class Red extends Color {
    private int redSpecificProp;
    // getter、setter省略
}

// 目标处理类DataItem
public class DataItem {
    private String type; // 用于标识Color子类的字段
    private Color data; // 存储子类实例
    // getter、setter省略
}

2. 编写DataItem专属TypeAdapter

自定义适配器仅处理DataItem的反序列化，根据type字段动态选择Color的子类：

public class DataItemTypeAdapter extends TypeAdapter<DataItem> {
    private final Gson gson = new Gson();
    // 提前维护type与子类的映射，避免硬编码if-else
    private static final Map<String, Class<? extends Color>> COLOR_TYPE_MAP = new HashMap<>();
    
    static {
        COLOR_TYPE_MAP.put("blue", Blue.class);
        COLOR_TYPE_MAP.put("red", Red.class);
    }

    @Override
    public void write(JsonWriter out, DataItem value) throws IOException {
        // 序列化逻辑（若无需自定义，直接用Gson默认序列化即可）
        out.beginObject();
        out.name("type").value(value.getType());
        out.name("data");
        Class<? extends Color> colorClass = COLOR_TYPE_MAP.get(value.getType());
        gson.toJson(value.getData(), colorClass != null ? colorClass : Color.class, out);
        out.endObject();
    }

    @Override
    public DataItem read(JsonReader in) throws IOException {
        DataItem item = new DataItem();
        in.beginObject();
        
        while (in.hasNext()) {
            switch (in.nextName()) {
                case "type":
                    item.setType(in.nextString());
                    break;
                case "data":
                    // 根据type映射获取对应子类，反序列化data字段
                    Class<? extends Color> targetClass = COLOR_TYPE_MAP.get(item.getType());
                    if (targetClass != null) {
                        item.setData(gson.fromJson(in, targetClass));
                    } else {
                        // 处理未知类型，可抛异常或返回基类实例
                        item.setData(gson.fromJson(in, Color.class));
                    }
                    break;
                default:
                    in.skipValue(); // 跳过未定义字段
                    break;
            }
        }
        
        in.endObject();
        return item;
    }
}

3. 注册适配器到Gson实例

创建Gson时仅给DataItem类绑定该适配器，确保逻辑仅作用于目标类：

Gson gson = new GsonBuilder()
    .registerTypeAdapter(DataItem.class, new DataItemTypeAdapter())
    .create();

4. 处理嵌套的序列化JSON字符串

对于MyResponse中items（序列化后的DataItem列表JSON）和base.data（序列化后的DataItem JSON），直接用注册好的Gson实例反序列化即可，适配器会自动处理子类逻辑：

public class MyResponse {
    private String items;
    private Base base;

    public static class Base {
        private String data;
        // getter、setter省略
    }

    // 解析items为DataItem列表
    public List<DataItem> getParsedItems() {
        return gson.fromJson(items, new TypeToken<List<DataItem>>() {}.getType());
    }

    // 解析base.data为DataItem
    public DataItem getParsedBaseData() {
        return gson.fromJson(base.getData(), DataItem.class);
    }
    // getter、setter省略
}

优势说明 #

• 聚焦单一类：仅针对DataItem类生效，不会干扰其他类的反序列化逻辑
• 可扩展性强：新增Color子类时，只需在COLOR_TYPE_MAP中添加映射，无需修改适配器核心逻辑
• 职责清晰：把子类选择逻辑封装在适配器中，代码结构更整洁

内容的提问来源于stack exchange，提问作者Sharas