Android Gson 自定义TypeAdapter的创建与注册流程深度剖析(13)-CSDN博客

本文链接：https://blog.csdn.net/qq_28540861/article/details/148052906

Android Gson 自定义TypeAdapter的创建与注册流程深度剖析

一、Gson序列化与反序列化核心机制概述

1.1 序列化与反序列化的基本概念

在Android开发中，Gson是一个广泛使用的JSON处理库，它能够将Java对象序列化为JSON字符串，也能将JSON字符串反序列化为Java对象。这个过程的核心在于TypeAdapter机制。

序列化（Serialization）是指将Java对象转换为JSON格式的过程。反序列化（Deserialization）则是将JSON格式的数据转换回Java对象的过程。Gson通过TypeAdapter来处理这两个过程，TypeAdapter是一个抽象类，定义了序列化和反序列化的核心方法。

1.2 Gson的基本工作流程

Gson的工作流程可以简化为以下几个步骤：

当调用toJson()方法时，Gson会根据对象类型查找对应的TypeAdapter。
找到合适的TypeAdapter后，调用其write()方法将对象序列化为JSON。
当调用fromJson()方法时，Gson会根据目标类型查找对应的TypeAdapter。
调用TypeAdapter的read()方法将JSON反序列化为Java对象。

这个过程中，TypeAdapter的查找和注册是关键环节，特别是自定义TypeAdapter的注册机制，是实现个性化JSON处理的基础。

1.3 TypeAdapter在Gson中的核心地位

TypeAdapter是Gson库的核心组件之一，它是一个抽象类，定义了序列化和反序列化的方法：

public abstract class TypeAdapter<T> {
    // 序列化方法：将T类型的对象写入JsonWriter
    public abstract void write(JsonWriter out, T value) throws IOException;
    
    // 反序列化方法：从JsonReader读取数据并转换为T类型的对象
    public abstract T read(JsonReader in) throws IOException;
    
    // 其他辅助方法...
}

Gson通过TypeAdapter实现了对不同类型的序列化和反序列化处理。对于基本类型、集合、数组等，Gson提供了内置的TypeAdapter实现。而对于自定义类型或特殊处理需求，开发者可以创建并注册自己的TypeAdapter。

二、自定义TypeAdapter的创建原理

2.1 TypeAdapter抽象类分析

TypeAdapter是一个抽象类，它定义了两个核心抽象方法：write()和read()。这两个方法分别负责对象的序列化和反序列化。

public abstract class TypeAdapter<T> {
    // 将对象序列化为JSON
    public abstract void write(JsonWriter out, T value) throws IOException;
    
    // 从JSON反序列化为对象
    public abstract T read(JsonReader in) throws IOException;
    
    // 其他方法...
    
    // 将对象转换为JSON字符串
    public final String toJson(T value) throws JsonIOException {
        StringWriter stringWriter = new StringWriter();
        JsonWriter jsonWriter = newJsonWriter(stringWriter);
        try {
            write(jsonWriter, value);
            return stringWriter.toString();
        } catch (IOException e) {
            throw new JsonIOException(e);
        }
    }
    
    // 从JSON字符串转换为对象
    public final T fromJson(String json) throws JsonIOException {
        StringReader stringReader = new StringReader(json);
        return fromJson(stringReader);
    }
    
    // 创建JsonWriter实例
    protected JsonWriter newJsonWriter(Writer writer) {
        return new JsonWriter(writer);
    }
    
    // 创建JsonReader实例
    protected JsonReader newJsonReader(Reader reader) {
        return new JsonReader(reader);
    }
}

2.2 自定义TypeAdapter的实现方式

创建自定义TypeAdapter有两种主要方式：

直接继承TypeAdapter抽象类，实现write()和read()方法。
继承TypeAdapter的子类，如JsonSerializer和JsonDeserializer。

下面分别介绍这两种实现方式。

2.2.1 直接继承TypeAdapter

直接继承TypeAdapter是最基本的方式，需要实现write()和read()方法。

public class MyTypeAdapter extends TypeAdapter<MyClass> {
    // 序列化方法
    @Override
    public void write(JsonWriter out, MyClass value) throws IOException {
        if (value == null) {
            out.nullValue(); // 处理null值
            return;
        }
        
        // 开始写入JSON对象
        out.beginObject();
        
        // 写入各个字段
        out.name("field1").value(value.getField1());
        out.name("field2").value(value.getField2());
        
        // 结束JSON对象
        out.endObject();
    }
    
    // 反序列化方法
    @Override
    public MyClass read(JsonReader in) throws IOException {
        // 创建对象实例
        MyClass result = new MyClass();
        
        // 开始读取JSON对象
        in.beginObject();
        
        while (in.hasNext()) {
            // 读取字段名
            String name = in.nextName();
            
            // 根据字段名处理不同的字段
            switch (name) {
                case "field1":
                    result.setField1(in.nextString());
                    break;
                case "field2":
                    result.setField2(in.nextInt());
                    break;
                default:
                    in.skipValue(); // 忽略未知字段
                    break;
            }
        }
        
        // 结束读取JSON对象
        in.endObject();
        
        return result;
    }
}

2.2.2 使用JsonSerializer和JsonDeserializer

另一种方式是使用JsonSerializer和JsonDeserializer接口，这两个接口分别对应序列化和反序列化的功能。

// 自定义序列化器
public class MyClassSerializer implements JsonSerializer<MyClass> {
    @Override
    public JsonElement serialize(MyClass src, Type typeOfSrc, JsonSerializationContext context) {
        // 创建JSON对象
        JsonObject jsonObject = new JsonObject();
        
        // 设置各个字段
        jsonObject.addProperty("field1", src.getField1());
        jsonObject.addProperty("field2", src.getField2());
        
        return jsonObject;
    }
}

// 自定义反序列化器
public class MyClassDeserializer implements JsonDeserializer<MyClass> {
    @Override
    public MyClass deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
            throws JsonParseException {
        // 获取JSON对象
        JsonObject jsonObject = json.getAsJsonObject();
        
        // 创建MyClass实例
        MyClass result = new MyClass();
        
        // 从JSON对象中获取字段值
        result.setField1(jsonObject.get("field1").getAsString());
        result.setField2(jsonObject.get("field2").getAsInt());
        
        return result;
    }
}

2.3 处理复杂类型和泛型

当处理复杂类型或泛型时，需要特别注意类型信息的保留和传递。Gson提供了TypeToken类来处理泛型类型信息。

// 处理泛型集合的TypeAdapter
public class ListTypeAdapter<T> extends TypeAdapter<List<T>> {
    private final TypeAdapter<T> elementTypeAdapter;
    
    public ListTypeAdapter(Gson gson, Type elementType) {
        // 获取元素类型的TypeAdapter
        this.elementTypeAdapter = gson.getAdapter(TypeToken.get(elementType));
    }
    
    @Override
    public void write(JsonWriter out, List<T> value) throws IOException {
        if (value == null) {
            out.nullValue();
            return;
        }
        
        // 开始写入JSON数组
        out.beginArray();
        
        // 遍历列表，序列化每个元素
        for (T element : value) {
            elementTypeAdapter.write(out, element);
        }
        
        // 结束JSON数组
        out.endArray();
    }
    
    @Override
    public List<T> read(JsonReader in) throws IOException {
        if (in.peek() == JsonToken.NULL) {
            in.nextNull();
            return null;
        }
        
        // 创建列表
        List<T> list = new ArrayList<>();
        
        // 开始读取JSON数组
        in.beginArray();
        
        // 读取每个元素
        while (in.hasNext()) {
            T element = elementTypeAdapter.read(in);
            list.add(element);
        }
        
        // 结束读取JSON数组
        in.endArray();
        
        return list;
    }
}

三、自定义TypeAdapter的注册流程

3.1 GsonBuilder的注册方法

Gson提供了多种方式来注册自定义TypeAdapter，主要通过GsonBuilder类的方法来实现。

public final class GsonBuilder {
    // 注册TypeAdapter
    public <T> GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {
        // 检查typeAdapter是否为TypeAdapter或JsonSerializer/JsonDeserializer
        if (typeAdapter instanceof TypeAdapter<?>) {
            // 注册TypeAdapter
            typeTokenFactories.add(TypeToken.get(type), (TypeAdapter<?>) typeAdapter);
        } else if (typeAdapter instanceof JsonSerializer<?> || typeAdapter instanceof JsonDeserializer<?>) {
            // 注册JsonSerializer/JsonDeserializer
            TypeToken<?> typeToken = TypeToken.get(type);
            if (typeAdapter instanceof JsonSerializer<?>) {
                serializers.add(typeToken, (JsonSerializer<?>) typeAdapter);
            }
            if (typeAdapter instanceof JsonDeserializer<?>) {
                deserializers.add(typeToken, (JsonDeserializer<?>) typeAdapter);
            }
        } else {
            throw new IllegalArgumentException("Expected a TypeAdapter, JsonSerializer or JsonDeserializer");
        }
        return this;
    }
    
    // 注册TypeAdapterFactory
    public GsonBuilder registerTypeAdapterFactory(TypeAdapterFactory factory) {
        factories.add(factory);
        return this;
    }
    
    // 注册类型层次的TypeAdapter
    public <T> GsonBuilder registerTypeHierarchyAdapter(Class<? super T> baseType, Object typeAdapter) {
        if (typeAdapter instanceof TypeAdapter<?>) {
            hierarchyFactories.add(baseType, (TypeAdapter<?>) typeAdapter);
        } else if (typeAdapter instanceof JsonSerializer<?> || typeAdapter instanceof JsonDeserializer<?>) {
            if (typeAdapter instanceof JsonSerializer<?>) {
                hierarchySerializers.add(baseType, (JsonSerializer<?>) typeAdapter);
            }
            if (typeAdapter instanceof JsonDeserializer<?>) {
                hierarchyDeserializers.add(baseType, (JsonDeserializer<?>) typeAdapter);
            }
        } else {
            throw new IllegalArgumentException("Expected a TypeAdapter, JsonSerializer or JsonDeserializer");
        }
        return this;
    }
    
    // 创建Gson实例
    public Gson create() {
        // 构建TypeAdapter工厂链
        List<TypeAdapterFactory> factories = buildFactories();
        
        // 创建并返回Gson实例
        return new Gson(
            factories,
            instanceCreators,
            serializeNulls,
            complexMapKeySerialization,
            generateNonExecutableJson,
            excludeFieldsWithModifiers,
            requireExpose,
            version,
            datePattern,
            dateStyle,
            timeStyle,
            serializeSpecialFloatingPointValues,
            longSerializationPolicy,
            fieldNamingStrategy
        );
    }
    
    // 构建TypeAdapter工厂链
    private List<TypeAdapterFactory> buildFactories() {
        // 创建工厂列表
        List<TypeAdapterFactory> factories = new ArrayList<>();
        
        // 添加用户注册的工厂
        factories.addAll(this.factories);
        
        // 添加内置工厂
        factories.add(TypeAdapters.JSON_ELEMENT_FACTORY);
        factories.add(ObjectTypeAdapter.FACTORY);
        
        // 添加反射工厂
        factories.add(new ReflectiveTypeAdapterFactory(
            constructorConstructor,
            fieldNamingStrategy,
            excluder,
            jsonAdapterFactory
        ));
        
        return factories;
    }
}

3.2 注册流程的实现原理

注册自定义TypeAdapter的核心是在GsonBuilder中添加TypeAdapter或TypeAdapterFactory。当调用create()方法时，GsonBuilder会构建一个TypeAdapter工厂链，这个链决定了Gson在序列化和反序列化时查找TypeAdapter的顺序。

注册流程的关键步骤包括：

用户通过GsonBuilder的registerTypeAdapter()、registerTypeAdapterFactory()等方法注册自定义TypeAdapter或TypeAdapterFactory。
这些注册信息被保存在GsonBuilder的内部数据结构中。
当调用create()方法时，GsonBuilder会构建一个有序的工厂链，包括用户注册的工厂和Gson内置的工厂。
这个工厂链被传递给Gson实例，在序列化和反序列化时按顺序查找合适的TypeAdapter。

3.3 注册方式的比较与选择

Gson提供了三种主要的注册方式：

registerTypeAdapter()：注册特定类型的TypeAdapter，精确匹配类型。
registerTypeHierarchyAdapter()：注册类型层次的TypeAdapter，适用于指定类型及其所有子类。
registerTypeAdapterFactory()：注册自定义TypeAdapterFactory，最灵活但也最复杂的方式。

选择哪种注册方式取决于具体需求：

如果需要精确控制某个特定类型的序列化和反序列化，使用registerTypeAdapter()。
如果需要处理某个类型及其所有子类，使用registerTypeHierarchyAdapter()。
如果需要实现复杂的TypeAdapter选择逻辑，或者处理泛型类型，使用registerTypeAdapterFactory()。

四、TypeAdapter的查找与使用流程

4.1 Gson的TypeAdapter查找机制

当Gson需要序列化或反序列化某个类型时，会通过TypeAdapterFactory链来查找合适的TypeAdapter。

public final class Gson {
    // 查找TypeAdapter
    public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {
        // 先从缓存中查找
        TypeAdapter<?> cached = typeTokenCache.get(type);
        if (cached != null) {
            return (TypeAdapter<T>) cached;
        }
        
        // 从工厂链中查找
        for (TypeAdapterFactory factory : factories) {
            TypeAdapter<T> candidate = factory.create(this, type);
            if (candidate != null) {
                // 缓存找到的TypeAdapter
                typeTokenCache.put(type, candidate);
                return candidate;
            }
        }
        
        throw new IllegalArgumentException("Gson cannot handle " + type);
    }
}

4.2 TypeAdapterFactory的工作原理

TypeAdapterFactory是一个接口，定义了创建TypeAdapter的方法：

public interface TypeAdapterFactory {
    // 为指定类型创建TypeAdapter
    <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type);
}

Gson内置了多个TypeAdapterFactory，例如：

ReflectiveTypeAdapterFactory：用于反射处理普通Java对象
CollectionTypeAdapterFactory：用于处理集合类型
MapTypeAdapterFactory：用于处理Map类型
EnumTypeAdapterFactory：用于处理枚举类型

当查找TypeAdapter时，Gson会按顺序遍历工厂链，调用每个工厂的create()方法，直到找到一个能处理该类型的工厂。

4.3 自定义TypeAdapterFactory的实现

实现自定义TypeAdapterFactory可以更灵活地控制TypeAdapter的创建过程。

public class MyTypeAdapterFactory implements TypeAdapterFactory {
    @Override
    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
        // 判断是否是我们要处理的类型
        if (type.getRawType() == MyClass.class) {
            // 创建并返回自定义TypeAdapter
            return (TypeAdapter<T>) new MyTypeAdapter();
        }
        
        // 不是我们要处理的类型，返回null
        return null;
    }
}

然后通过GsonBuilder注册这个工厂：

Gson gson = new GsonBuilder()
    .registerTypeAdapterFactory(new MyTypeAdapterFactory())
    .create();

五、高级应用与最佳实践

5.1 处理日期和时间类型

日期和时间类型的处理是JSON序列化中的常见挑战。可以创建自定义TypeAdapter来处理特定的日期格式。

public class DateTypeAdapter extends TypeAdapter<Date> {
    private final SimpleDateFormat dateFormat;
    
    public DateTypeAdapter(String pattern) {
        this.dateFormat = new SimpleDateFormat(pattern, Locale.US);
    }
    
    @Override
    public void write(JsonWriter out, Date value) throws IOException {
        if (value == null) {
            out.nullValue();
            return;
        }
        
        // 将日期格式化为字符串
        String dateString = dateFormat.format(value);
        out.value(dateString);
    }
    
    @Override
    public Date read(JsonReader in) throws IOException {
        if (in.peek() == JsonToken.NULL) {
            in.nextNull();
            return null;
        }
        
        try {
            // 从字符串解析日期
            String dateString = in.nextString();
            return dateFormat.parse(dateString);
        } catch (ParseException e) {
            throw new JsonSyntaxException(e);
        }
    }
}

注册这个TypeAdapter：

Gson gson = new GsonBuilder()
    .registerTypeAdapter(Date.class, new DateTypeAdapter("yyyy-MM-dd"))
    .create();

5.2 处理多态类型

当处理多态类型时，需要在JSON中保留类型信息，以便在反序列化时能够正确还原对象类型。

// 基类
public abstract class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}

// 子类
public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, String breed) {
        super(name);
        this.breed = breed;
    }
    
    public String getBreed() {
        return breed;
    }
}

// 子类
public class Cat extends Animal {
    private boolean longHaired;
    
    public Cat(String name, boolean longHaired) {
        super(name);
        this.longHaired = longHaired;
    }
    
    public boolean isLongHaired() {
        return longHaired;
    }
}

// 多态类型适配器
public class AnimalTypeAdapter extends TypeAdapter<Animal> {
    private static final String TYPE_FIELD = "type";
    private static final String DATA_FIELD = "data";
    
    @Override
    public void write(JsonWriter out, Animal value) throws IOException {
        if (value == null) {
            out.nullValue();
            return;
        }
        
        out.beginObject();
        
        // 写入类型信息
        if (value instanceof Dog) {
            out.name(TYPE_FIELD).value("dog");
        } else if (value instanceof Cat) {
            out.name(TYPE_FIELD).value("cat");
        }
        
        // 写入对象数据
        out.name(DATA_FIELD);
        Gson gson = new Gson();
        gson.toJson(value, value.getClass(), out);
        
        out.endObject();
    }
    
    @Override
    public Animal read(JsonReader in) throws IOException {
        if (in.peek() == JsonToken.NULL) {
            in.nextNull();
            return null;
        }
        
        Gson gson = new Gson();
        Class<? extends Animal> type = null;
        
        in.beginObject();
        
        while (in.hasNext()) {
            String name = in.nextName();
            
            if (name.equals(TYPE_FIELD)) {
                String typeValue = in.nextString();
                if ("dog".equals(typeValue)) {
                    type = Dog.class;
                } else if ("cat".equals(typeValue)) {
                    type = Cat.class;
                }
            } else if (name.equals(DATA_FIELD)) {
                if (type != null) {
                    return gson.fromJson(in, type);
                } else {
                    in.skipValue();
                }
            } else {
                in.skipValue();
            }
        }
        
        in.endObject();
        
        return null;
    }
}

5.3 处理嵌套对象和集合

处理嵌套对象和集合时，需要确保每个层级都有合适的TypeAdapter。

// 嵌套对象示例
public class User {
    private String name;
    private Address address;
    private List<String> hobbies;
    
    // 构造函数、getter和setter方法...
}

public class Address {
    private String street;
    private String city;
    private String country;
    
    // 构造函数、getter和setter方法...
}

// User的TypeAdapter
public class UserTypeAdapter extends TypeAdapter<User> {
    @Override
    public void write(JsonWriter out, User value) throws IOException {
        if (value == null) {
            out.nullValue();
            return;
        }
        
        out.beginObject();
        out.name("name").value(value.getName());
        
        // 处理嵌套的Address对象
        out.name("address");
        Gson gson = new Gson();
        gson.toJson(value.getAddress(), Address.class, out);
        
        // 处理hobbies集合
        out.name("hobbies");
        out.beginArray();
        for (String hobby : value.getHobbies()) {
            out.value(hobby);
        }
        out.endArray();
        
        out.endObject();
    }
    
    @Override
    public User read(JsonReader in) throws IOException {
        if (in.peek() == JsonToken.NULL) {
            in.nextNull();
            return null;
        }
        
        User user = new User();
        
        in.beginObject();
        
        while (in.hasNext()) {
            String name = in.nextName();
            
            switch (name) {
                case "name":
                    user.setName(in.nextString());
                    break;
                case "address":
                    // 反序列化嵌套的Address对象
                    Gson gson = new Gson();
                    Address address = gson.fromJson(in, Address.class);
                    user.setAddress(address);
                    break;
                case "hobbies":
                    // 反序列化hobbies集合
                    List<String> hobbies = new ArrayList<>();
                    in.beginArray();
                    while (in.hasNext()) {
                        hobbies.add(in.nextString());
                    }
                    in.endArray();
                    user.setHobbies(hobbies);
                    break;
                default:
                    in.skipValue();
                    break;
            }
        }
        
        in.endObject();
        
        return user;
    }
}