码字不易，请大佬们点点关注，谢谢~
一、Gson类的架构定位与设计哲学
1.1 作为框架入口的核心职责
Gson类是Google Gson框架的核心入口点，承担着协调JSON序列化与反序列化流程的核心职责。作为用户与框架交互的主要接口，Gson类封装了复杂的类型适配器管理、配置解析和反射操作，为开发者提供了简洁统一的API。其设计遵循了以下核心原则：
1.1.1 配置与执行分离
Gson类通过工厂模式与GsonBuilder配合，实现了配置过程与执行过程的分离。这种设计允许用户通过GsonBuilder定制各种序列化和反序列化策略，而Gson类则专注于执行这些策略：
// GsonBuilder负责配置参数
Gson gson = new GsonBuilder()
.setPrettyPrinting() // 配置JSON美化输出
.excludeFieldsWithoutExposeAnnotation() // 配置只处理带@Expose注解的字段
.registerTypeAdapter(Date.class, new DateTypeAdapter()) // 注册自定义类型适配器
.create(); // 创建不可变的Gson实例
// Gson实例负责执行序列化/反序列化
String json = gson.toJson(myObject);
MyType obj = gson.fromJson(json, MyType.class);
1.1.2 不可变性与线程安全
Gson实例一旦创建即为不可变对象，所有配置参数在创建时确定，之后无法修改。这种设计使得Gson实例可以安全地在多线程环境中共享：
// Gson类的构造函数使用参数对象初始化，创建后不可变
public final class Gson {
private final List<TypeAdapterFactory> factories;
private final FieldNamingStrategy fieldNamingStrategy;
private final LongSerializationPolicy longSerializationPolicy;
// 其他不可变配置字段...
Gson(
List<TypeAdapterFactory> factories,
FieldNamingStrategy fieldNamingStrategy,
LongSerializationPolicy longSerializationPolicy,
// 其他参数...
) {
this.factories = factories;
this.fieldNamingStrategy = fieldNamingStrategy;
this.longSerializationPolicy = longSerializationPolicy;
// 初始化其他字段...
}
// 所有配置相关方法均由GsonBuilder提供
}
1.2 核心组件的协同关系
Gson类作为框架核心，与以下关键组件协同工作：
1.2.1 TypeAdapter体系
TypeAdapter是Gson处理序列化和反序列化的核心接口，Gson类通过TypeAdapterFactory注册表来查找和创建特定类型的适配器：
public final class Gson {
// 存储所有已注册的TypeAdapterFactory
private final List<TypeAdapterFactory> factories;
// 根据类型获取对应的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) {
// 找到匹配的工厂后，缓存适配器并返回
typeTokenCache.put(type, candidate);
return candidate;
}
}
throw new IllegalArgumentException("Gson cannot handle " + type);
}
}
1.2.2 JsonReader与JsonWriter
JsonReader和JsonWriter是Gson处理JSON读写的底层组件，Gson类通过它们实现与JSON文本的交互：
public final class Gson {
// 将对象序列化为JSON并写入指定的JsonWriter
public void toJson(Object src, Type typeOfSrc, JsonWriter writer) throws JsonIOException {
// 获取类型适配器
TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfSrc));
// 调用适配器的write方法进行序列化
((TypeAdapter<Object>) adapter).write(writer, src);
}
// 从JsonReader读取JSON并反序列化为对象
public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {
// 获取类型适配器
TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfT));
// 调用适配器的read方法进行反序列化
return (T) adapter.read(reader);
}
}
1.2.3 反射与类型处理
Gson通过反射机制处理Java对象的字段，并使用TypeToken解决Java泛型类型擦除问题：
public final class Gson {
// 使用反射创建对象实例
private final ConstructorConstructor constructorConstructor;
// 处理带泛型的类型
public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException {
// 创建TypeToken保存泛型信息
TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(typeOfT);
// 使用保存的泛型信息获取适配器
TypeAdapter<T> adapter = getAdapter(typeToken);
// 执行反序列化
return adapter.fromJson(json);
}
}
二、Gson类的初始化与配置体系
2.1 GsonBuilder的配置机制
GsonBuilder是创建Gson实例的唯一方式，通过流式API提供了丰富的配置选项：
public final class GsonBuilder {
// 配置参数
private boolean serializeNulls = false;
private boolean prettyPrinting = false;
private boolean lenient = false;
private boolean generateNonExecutableJson = false;
private boolean escapeHtmlChars = true;
private LongSerializationPolicy longSerializationPolicy = LongSerializationPolicy.DEFAULT;
private FieldNamingStrategy fieldNamingPolicy = FieldNamingPolicy.IDENTITY;
private final List<ExclusionStrategy> exclusionStrategies = new ArrayList<>();
private final List<TypeAdapterFactory> factories = new ArrayList<>();
private final Map<Type, InstanceCreator<?>> instanceCreators = new LinkedHashMap<>();
// 其他配置参数...
// 设置是否序列化null值
public GsonBuilder serializeNulls() {
this.serializeNulls = true;
return this;
}
// 设置是否美化输出JSON
public GsonBuilder setPrettyPrinting() {
this.prettyPrinting = true;
return this;
}
// 设置JSON解析是否宽松模式
public GsonBuilder setLenient() {
this.lenient = true;
return this;
}
// 注册自定义类型适配器
public <T> GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {
// 验证typeAdapter是否为JsonSerializer或JsonDeserializer的实例
if (typeAdapter instanceof JsonSerializer || typeAdapter instanceof JsonDeserializer) {
// 创建适配器工厂并添加到工厂列表
factories.add(TypeAdapters.newFactory(TypeToken.get(type), typeAdapter));
} else if (typeAdapter instanceof TypeAdapter) {
// 直接添加TypeAdapter工厂
factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter<?>) 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,
generateNonExecutableJson,
escapeHtmlChars,
prettyPrinting,
lenient,
fieldNamingPolicy,
longSerializationPolicy,
exclusionStrategies,
// 其他配置参数...
);
}
// 构建完整的工厂列表，包括内置工厂和用户注册的工厂
private List<TypeAdapterFactory> buildFactories() {
List<TypeAdapterFactory> factories = new ArrayList<>();
// 1. 添加用户注册的序列化器/反序列化器工厂（最高优先级）
factories.addAll(this.factories);
// 2. 添加内置的核心工厂
factories.add(TypeAdapters.JSON_ELEMENT_FACTORY);
factories.add(ObjectTypeAdapter.FACTORY);
// 3. 添加集合类型工厂
factories.add(new CollectionTypeAdapterFactory(constructorConstructor));
factories.add(new MapTypeAdapterFactory(constructorConstructor, complexMapKeySerialization));
// 4. 添加反射类型工厂（处理普通Java对象）
factories.add(new ReflectiveTypeAdapterFactory(
constructorConstructor,
fieldNamingPolicy,
exclusionStrategies,
jsonAdapterFactory));
// 5. 添加其他内置工厂...
return Collections.unmodifiableList(factories);
}
}
2.2 配置参数的优先级体系
Gson的配置参数具有明确的优先级顺序，这确保了用户自定义配置能够覆盖默认行为：
- 用户注册的TypeAdapter：通过
GsonBuilder.registerTypeAdapter()注册的适配器具有最高优先级 - 用户配置的策略：如字段命名策略、排除策略等
- Gson内置的默认适配器：处理基本类型、集合、映射等常见类型
- 反射机制：作为最后的手段，处理没有自定义适配器的类型
2.3 类型适配器工厂的注册与排序
GsonBuilder在创建Gson实例时，会将所有注册的TypeAdapterFactory按特定顺序排列：
// GsonBuilder的buildFactories方法片段
private List<TypeAdapterFactory> buildFactories() {
List<TypeAdapterFactory> factories = new ArrayList<>();
// 1. 添加用户注册的工厂（按注册顺序，先注册的优先级高）
factories.addAll(this.factories);
// 2. 添加内置工厂（固定顺序）
factories.add(TypeAdapters.JSON_ELEMENT_FACTORY);
factories.add(ObjectTypeAdapter.FACTORY);
factories.add(new CollectionTypeAdapterFactory(constructorConstructor));
factories.add(new MapTypeAdapterFactory(constructorConstructor, complexMapKeySerialization));
factories.add(new ReflectiveTypeAdapterFactory(
constructorConstructor,
fieldNamingPolicy,
exclusionStrategies,
jsonAdapterFactory));
return Collections.unmodifiableList(factories);
}
这种排序确保了用户自定义的适配器能够优先被应用，而内置适配器则作为后备选项处理未被特殊处理的类型。
三、序列化流程的实现细节
3.1 序列化的入口方法
Gson类提供了多个重载的toJson()方法，最终都会调用到核心的序列化方法：
public final class Gson {
// 最核心的序列化方法，将对象序列化为JSON并写入JsonWriter
public void toJson(Object src, Type typeOfSrc, JsonWriter writer) throws JsonIOException {
// 获取对象的类型适配器
TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfSrc));
// 设置JsonWriter的宽松模式
boolean oldLenient = writer.isLenient();
writer.setLenient(true);
try {
// 调用适配器的write方法执行序列化
((TypeAdapter<Object>) adapter).write(writer, src);
} catch (IOException e) {
throw new JsonIOException(e);
} finally {
// 恢复JsonWriter的原始宽松模式设置
writer.setLenient(oldLenient);
}
}
// 常用的序列化方法，将对象转换为JSON字符串
public String toJson(Object src) {
if (src == null) {
return toJson(JsonNull.INSTANCE);
}
// 获取对象的实际类型
Type typeOfSrc = src.getClass();
return toJson(src, typeOfSrc);
}
// 将对象按照指定类型转换为JSON字符串
public String toJson(Object src, Type typeOfSrc) {
StringWriter writer = new StringWriter();
toJson(src, typeOfSrc, writer);
return writer.toString();
}
// 将对象按照指定类型序列化为JSON并写入Appendable
public void toJson(Object src, Type typeOfSrc, Appendable writer) throws JsonIOException {
try {
// 创建JsonWriter包装Appendable
JsonWriter jsonWriter = newJsonWriter(Streams.writerForAppendable(writer));
toJson(src, typeOfSrc, jsonWriter);
} catch (IOException e) {
throw new JsonIOException(e);
}
}
}
3.2 类型适配器的查找过程
Gson通过getAdapter()方法查找处理特定类型的TypeAdapter，这是一个关键流程：
public final class Gson {
// 类型适配器缓存，提高性能
private final ConcurrentMap<TypeToken<?>, TypeAdapter<?>> typeTokenCache = new ConcurrentHashMap<>();
// 根据TypeToken获取对应的TypeAdapter
public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {
// 首先从缓存中查找适配器
TypeAdapter<?> cached = typeTokenCache.get(type);
if (cached != null) {
return (TypeAdapter<T>) cached;
}
// 缓存未命中时，处理可能的递归调用（防止循环引用）
Map<TypeToken<?>, TypeAdapter<?>> threadCalls = calls.get();
boolean requiresThreadLocalCleanup = false;
if (threadCalls == null) {
threadCalls = new HashMap<>();
calls.set(threadCalls);
requiresThreadLocalCleanup = true;
}
// 检查是否正在处理当前类型（防止循环引用导致的栈溢出）
TypeAdapter<?> candidate = threadCalls.get(type);
if (candidate != null) {
return (TypeAdapter<T>) candidate;
}
try {
// 标记正在处理当前类型
threadCalls.put(type, null);
// 遍历工厂列表，查找能够处理该类型的工厂
for (TypeAdapterFactory factory : factories) {
TypeAdapter<T> candidateAdapter = factory.create(this, type);
if (candidateAdapter != null) {
// 找到匹配的工厂后，缓存适配器并返回
typeTokenCache.put(type, candidateAdapter);
return candidateAdapter;
}
}
// 没有找到合适的工厂，抛出异常
throw new IllegalArgumentException("Gson cannot handle " + type);
} finally {
// 移除正在处理的标记
threadCalls.remove(type);
// 清理线程本地存储
if (requiresThreadLocalCleanup) {
calls.remove();
}
}
}
}
3.3 对象序列化的反射实现
对于普通Java对象，Gson使用ReflectiveTypeAdapter进行序列化，这是最常见的场景：
public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {
// 反射类型适配器的实现
static final class Adapter<T> extends TypeAdapter<T> {
private final ObjectConstructor<T> constructor;
private final Map<String, BoundField> boundFields;
Adapter(ObjectConstructor<T> constructor, Map<String, BoundField> boundFields) {
this.constructor = constructor;
this.boundFields = boundFields;
}
@Override
public T read(JsonReader in) throws IOException {
// 反序列化实现...
}
@Override
public void write(JsonWriter out, T value) throws IOException {
if (value == null) {
out.nullValue();
return;
}
// 开始写入JSON对象
out.beginObject();
try {
// 遍历所有绑定的字段
for (BoundField boundField : boundFields.values()) {
// 检查字段是否应该被序列化
if (boundField.writeField(value)) {
// 写入字段名
out.name(boundField.name);
// 写入字段值
boundField.write(out, value);
}
}
} catch (IllegalAccessException e) {
throw new AssertionError(e);
}
// 结束写入JSON对象
out.endObject();
}
}
// 绑定字段类，封装了字段的序列化和反序列化逻辑
abstract static class BoundField {
final String name;
final boolean serialized;
final boolean deserialized;
protected BoundField(String name, boolean serialized, boolean deserialized) {
this.name = name;
this.serialized = serialized;
this.deserialized = deserialized;
}
// 检查字段是否应该被序列化
abstract boolean writeField(Object value) throws IOException, IllegalAccessException;
// 写入字段值
abstract void write(JsonWriter writer, Object value) throws IOException, IllegalAccessException;
// 读取字段值
abstract void read(JsonReader reader, Object value) throws IOException, IllegalAccessException;
}
}
3.4 集合与映射的序列化
对于集合和映射类型，Gson使用专门的TypeAdapter进行处理：
// 集合类型适配器工厂
public final class CollectionTypeAdapterFactory implements TypeAdapterFactory {
private final ConstructorConstructor constructorConstructor;
public CollectionTypeAdapterFactory(ConstructorConstructor constructorConstructor) {
this.constructorConstructor = constructorConstructor;
}
@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
Type type = typeToken.getType();
// 检查是否为集合类型
Class<? super T> rawType = typeToken.getRawType();
if (!Collection.class.isAssignableFrom(rawType)) {
return null;
}
// 获取集合元素的类型
Type elementType = $Gson$Types.getCollectionElementType(type, rawType);
TypeAdapter<?> elementTypeAdapter = gson.getAdapter(TypeToken.get(elementType));
// 创建集合的实例构造器
ObjectConstructor<T> constructor = constructorConstructor.get(typeToken);
// 创建集合类型适配器
@SuppressWarnings({"unchecked", "rawtypes"})
TypeAdapter<T> result = new Adapter(gson, elementType, elementTypeAdapter, constructor);
return result;
}
// 集合类型适配器实现
private static final class Adapter<E> extends TypeAdapter<Collection<E>> {
private final TypeAdapter<E> elementTypeAdapter;
private final ObjectConstructor<? extends Collection<E>> constructor;
Adapter(Gson context, Type elementType,
TypeAdapter<E> elementTypeAdapter,
ObjectConstructor<? extends Collection<E>> constructor) {
this.elementTypeAdapter =
new TypeAdapterRuntimeTypeWrapper<>(context, elementTypeAdapter, elementType);
this.constructor = constructor;
}
@Override
public Collection<E> read(JsonReader in) throws IOException {
// 反序列化实现...
}
@Override
public void write(JsonWriter out, Collection<E> collection) throws IOException {
if (collection == null) {
out.nullValue();
return;
}
// 开始写入JSON数组
out.beginArray();
// 遍历集合并序列化每个元素
for (E element : collection) {
elementTypeAdapter.write(out, element);
}
// 结束写入JSON数组
out.endArray();
}
}
}
// 映射类型适配器工厂
public final class MapTypeAdapterFactory implements TypeAdapterFactory {
private final ConstructorConstructor constructorConstructor;
private final boolean complexMapKeySerialization;
public MapTypeAdapterFactory(ConstructorConstructor constructorConstructor,
boolean complexMapKeySerialization) {
this.constructorConstructor = constructorConstructor;
this.complexMapKeySerialization = complexMapKeySerialization;
}
@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
Type type = typeToken.getType();
// 检查是否为映射类型
Class<? super T> rawType = typeToken.getRawType();
if (!Map.class.isAssignableFrom(rawType)) {
return null;
}
// 获取映射键和值的类型
Type[] keyAndValueTypes = $Gson$Types.getMapKeyAndValueTypes(type, rawType);
TypeAdapter<?> keyAdapter = getKeyAdapter(gson, keyAndValueTypes[0]);
TypeAdapter<?> valueAdapter = gson.getAdapter(TypeToken.get(keyAndValueTypes[1]));
// 创建映射的实例构造器
ObjectConstructor<T> constructor = constructorConstructor.get(typeToken);
// 创建映射类型适配器
@SuppressWarnings({"unchecked", "rawtypes"})
TypeAdapter<T> result = new Adapter(gson, keyAndValueTypes[0], keyAdapter,
keyAndValueTypes[1], valueAdapter, constructor);
return result;
}
// 获取键的适配器，处理特殊情况
private TypeAdapter<?> getKeyAdapter(Gson context, Type keyType) {
// 对于基本类型的键，使用特殊处理
if (keyType == boolean.class || keyType == Boolean.class) {
return TypeAdapters.BOOLEAN_AS_STRING;
}
if (keyType == char.class || keyType == Character.class) {
return TypeAdapters.STRING;
}
if (keyType == Number.class) {
return TypeAdapters.STRING;
}
// 对于其他类型的键，使用默认适配器
TypeAdapter<?> adapter = context.getAdapter(TypeToken.get(keyType));
if (!(adapter instanceof StringTypeAdapter)) {
adapter = new StringAdapter(adapter);
}
return adapter;
}
// 映射类型适配器实现
private static final class Adapter<K, V> extends TypeAdapter<Map<K, V>> {
private final TypeAdapter<K> keyTypeAdapter;
private final TypeAdapter<V> valueTypeAdapter;
private final ObjectConstructor<? extends Map<K, V>> constructor;
Adapter(Gson context, Type keyType, TypeAdapter<K> keyTypeAdapter,
Type valueType, TypeAdapter<V> valueTypeAdapter,
ObjectConstructor<? extends Map<K, V>> constructor) {
this.keyTypeAdapter = new TypeAdapterRuntimeTypeWrapper<>(context, keyTypeAdapter, keyType);
this.valueTypeAdapter = new TypeAdapterRuntimeTypeWrapper<>(context, valueTypeAdapter, valueType);
this.constructor = constructor;
}
@Override
public Map<K, V> read(JsonReader in) throws IOException {
// 反序列化实现...
}
@Override
public void write(JsonWriter out, Map<K, V> map) throws IOException {
if (map == null) {
out.nullValue();
return;
}
// 开始写入JSON对象
out.beginObject();
// 遍历映射并序列化每个键值对
for (Map.Entry<K, V> entry : map.entrySet()) {
// 序列化键
String key = keyTypeAdapter.toJsonTree(entry.getKey()).getAsString();
// 写入键
out.name(key);
// 序列化并写入值
valueTypeAdapter.write(out, entry.getValue());
}
// 结束写入JSON对象
out.endObject();
}
}
}
四、反序列化流程的实现细节
4.1 反序列化的入口方法
Gson类提供了多个重载的fromJson()方法，最终都会调用到核心的反序列化方法：
public final class Gson {
// 最核心的反序列化方法，从JsonReader读取JSON并反序列化为对象
public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {
boolean isEmpty = true;
boolean oldLenient = reader.isLenient();
reader.setLenient(true);
try {
// 检查JSON是否有内容
reader.peek();
isEmpty = false;
// 获取类型适配器
TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfT));
// 调用适配器的read方法执行反序列化
T result = (T) adapter.read(reader);
// 确保JSON被完全消耗
assertFullConsumption(reader, typeOfT);
return result;
} catch (EOFException e) {
// 处理空JSON的情况
if (isEmpty) {
return null;
}
throw new JsonSyntaxException(e);
} catch (IllegalStateException e) {
throw new JsonSyntaxException(e);
} catch (IOException e) {
throw new JsonIOException(e);
} catch (AssertionError e) {
throw new JsonIOException(e);
} finally {
// 恢复JsonReader的原始宽松模式设置
reader.setLenient(oldLenient);
}
}
// 常用的反序列化方法，从JSON字符串反序列化为对象
public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException {
if (json == null) {
return null;
}
// 创建StringReader读取JSON字符串
StringReader reader = new StringReader(json);
// 调用核心反序列化方法
return fromJson(reader, typeOfT);
}
// 从Reader反序列化为对象
public <T> T fromJson(Reader json, Type typeOfT) throws JsonIOException, JsonSyntaxException {
// 创建JsonReader包装Reader
JsonReader jsonReader = newJsonReader(json);
// 调用核心反序列化方法
return fromJson(jsonReader, typeOfT);
}
// 从JSON字符串反序列化为对象（使用Class指定类型）
public <T> T fromJson(String json, Class<T> classOfT) throws JsonSyntaxException {
if (json == null) {
return null;
}
// 创建StringReader读取JSON字符串
StringReader reader = new StringReader(json);
// 调用核心反序列化方法
return fromJson(reader, classOfT);
}
}
4.2 类型适配器的查找与反序列化
反序列化过程中的类型适配器查找逻辑与序列化相同，但具体的反序列化操作由适配器的read()方法实现：
public final class Gson {
// 从JsonReader读取JSON并反序列化为对象
public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {
// ... 前置代码 ...
// 获取类型适配器（与序列化共享同一缓存和查找逻辑）
TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfT));
// 调用适配器的read方法执行反序列化
T result = (T) adapter.read(reader);
// ... 后置代码 ...
}
}
4.3 对象反序列化的反射实现
对于普通Java对象，Gson使用ReflectiveTypeAdapter进行反序列化：
public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {
// 反射类型适配器的实现
static final class Adapter<T> extends TypeAdapter<T> {
private final ObjectConstructor<T> constructor;
private final Map<String, BoundField> boundFields;
Adapter(ObjectConstructor<T> constructor, Map<String, BoundField> boundFields) {
this.constructor = constructor;
this.boundFields = boundFields;
}
@Override
public T read(JsonReader in) throws IOException {
// 处理JSON为null的情况
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
// 创建对象实例
T instance = constructor.construct();
try {
// 开始解析JSON对象
in.beginObject();
// 遍历JSON对象的所有属性
while (in.hasNext()) {
// 读取属性名
String name = in.nextName();
// 查找匹配的绑定字段
BoundField field = boundFields.get(name);
if (field == null || !field.deserialized) {
// 没有找到匹配的字段或字段不需要反序列化，跳过
in.skipValue();
} else {
// 读取字段值
field.read(in, instance);
}
}
} catch (IllegalStateException e) {
throw new JsonSyntaxException(e);
} catch (IllegalAccessException e) {
throw new AssertionError(e);
}
// 结束解析JSON对象
in.endObject();
return instance;
}
@Override
public void write(JsonWriter out, T value) throws IOException {
// 序列化实现...
}
}
// 绑定字段类，封装了字段的序列化和反序列化逻辑
abstract static class BoundField {
final String name;
final boolean serialized;
final boolean deserialized;
final boolean isPrimitive;
protected BoundField(String name, boolean serialized, boolean deserialized, boolean isPrimitive) {
this.name = name;
this.serialized = serialized;
this.deserialized = deserialized;
this.isPrimitive = isPrimitive;
}
// 检查字段是否应该被序列化
abstract boolean writeField(Object value) throws IOException, IllegalAccessException;
// 写入字段值
abstract void write(JsonWriter writer, Object value) throws IOException, IllegalAccessException;
// 读取字段值
abstract void read(JsonReader reader, Object value) throws IOException, IllegalAccessException;
}
}
4.4 集合与映射的反序列化
对于集合和映射类型，Gson使用专门的TypeAdapter进行反序列化：
// 集合类型适配器工厂
public final class CollectionTypeAdapterFactory implements TypeAdapterFactory {
// ... 工厂代码 ...
// 集合类型适配器实现
private static final class Adapter<E> extends TypeAdapter<Collection<E>> {
private final TypeAdapter<E> elementTypeAdapter;
private final ObjectConstructor<? extends Collection<E>> constructor;
@Override
public Collection<E> read(JsonReader in) throws IOException {
// 处理JSON为null的情况
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
// 创建集合实例
Collection<E> collection = constructor.construct();
// 开始解析JSON数组
in.beginArray();
// 遍历JSON数组的每个元素
while (in.hasNext()) {
// 反序列化元素并添加到集合中
E instance = elementTypeAdapter.read(in);
collection.add(instance);
}
// 结束解析JSON数组
in.endArray();
return collection;
}
@Override
public void write(JsonWriter out, Collection<E> collection) throws IOException {
// 序列化实现...
}
}
}
// 映射类型适配器工厂
public final class MapTypeAdapterFactory implements TypeAdapterFactory {
// ... 工厂代码 ...
// 映射类型适配器实现
private static final class Adapter<K, V> extends TypeAdapter<Map<K, V>> {
private final TypeAdapter<K> keyTypeAdapter;
private final TypeAdapter<V> valueTypeAdapter;
private final ObjectConstructor<? extends Map<K, V>> constructor;
@Override
public Map<K, V> read(JsonReader in) throws IOException {
// 处理JSON为null的情况
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
// 创建映射实例
Map<K, V> map = constructor.construct();
// 开始解析JSON对象
in.beginObject();
// 遍历JSON对象的所有属性
while (in.hasNext()) {
// 读取属性名（键）
String keyStr = in.nextName();
// 反序列化键
K key = keyTypeAdapter.fromJsonTree(new JsonPrimitive(keyStr));
// 反序列化值
V value = valueTypeAdapter.read(in);
// 将键值对添加到映射中
map.put(key, value);
}
// 结束解析JSON对象
in.endObject();
return map;
}
@Override
public void write(JsonWriter out, Map<K, V> map) throws IOException {
// 序列化实现...
}
}
}
五、配置选项的实现与应用
5.1 字段命名策略的实现
Gson提供了多种字段命名策略，通过FieldNamingStrategy接口实现：
// 字段命名策略接口
public interface FieldNamingStrategy {
// 将Java字段名转换为JSON属性名
public String translateName(Field f);
}
// 内置的字段命名策略实现
public enum FieldNamingPolicy implements FieldNamingStrategy {
// 使用字段的原始名称
IDENTITY {
@Override
public String translateName(Field f) {
return f.getName();
}
},
// 将字段名转换为小写，并用下划线分隔
LOWER_CASE_WITH_UNDERSCORES {
@Override
public String translateName(Field f) {
return separateCamelCase(f.getName(), "_").toLowerCase();
}
},
// 将字段名转换为小写，并用连字符分隔
LOWER_CASE_WITH_DASHES {
@Override
public String translateName(Field f) {
return separateCamelCase(f.getName(), "-").toLowerCase();
}
},
// 将字段名转换为大写，并用下划线分隔
UPPER_CASE_WITH_UNDERSCORES {
@Override
public String translateName(Field f) {
return separateCamelCase(f.getName(), "_").toUpperCase();
}
},
// 将字段名的首字母大写
UPPER_CAMEL_CASE {
@Override
public String translateName(Field f) {
return modifyString(0, f.getName(), Character::toUpperCase);
}
},
// 将字段名的首字母大写，并添加前缀
UPPER_CAMEL_CASE_WITH_SPACES {
@Override
public String translateName(Field f) {
return separateCamelCase(f.getName(), " ");
}
};
// 辅助方法：将驼峰命名转换为分隔符命名
private static String separateCamelCase(String name, String separator) {
StringBuilder translation = new StringBuilder();
for (int i = 0; i < name.length(); i++) {
char character = name.charAt(i);
if (Character.isUpperCase(character) && translation.length() != 0) {
translation.append(separator);
}
translation.append(character);
}
return translation.toString();
}
// 辅助方法：修改字符串特定位置的字符
private static String modifyString(int offset, String string, Function<Character, Character> modifier) {
StringBuilder result = new StringBuilder(string);
result.setCharAt(offset, modifier.apply(result.charAt(offset)));
return result.toString();
}
}
5.2 排除策略的实现
Gson通过ExclusionStrategy接口实现字段和类的排除：
// 排除策略接口
public interface ExclusionStrategy {
// 是否
Gson通过ExclusionStrategy接口实现字段和类的排除：
// 排除策略接口
public interface ExclusionStrategy {
// 是否排除指定的类
boolean shouldSkipClass(Class<?> clazz);
// 是否排除指定的字段
boolean shouldSkipField(FieldAttributes f);
}
// 字段属性接口，封装了字段的元数据
public interface FieldAttributes {
// 获取字段名
String getName();
// 获取字段的声明类型
Class<?> getDeclaringClass();
// 获取字段的类型
Class<?> getType();
// 获取字段的泛型类型
Type getGenericType();
// 检查字段是否有指定的注解
boolean hasModifier(int modifier);
// 获取字段上的指定注解
<T extends Annotation> T getAnnotation(Class<T> annotation);
// 检查字段是否有任何注解
boolean hasAnnotations();
}
// 内置的排除策略实现
class ModifierBasedExclusionStrategy implements ExclusionStrategy {
private final int modifiers;
public ModifierBasedExclusionStrategy(int modifiers) {
this.modifiers = modifiers;
}
@Override
public boolean shouldSkipField(FieldAttributes f) {
// 检查字段是否有指定的修饰符
return (f.getModifiers() & modifiers) != 0;
}
@Override
public boolean shouldSkipClass(Class<?> clazz) {
return false;
}
}
// 处理@Expose注解的排除策略
class ExposeAnnotationExclusionStrategy implements ExclusionStrategy {
@Override
public boolean shouldSkipField(FieldAttributes f) {
Expose expose = f.getAnnotation(Expose.class);
return expose == null || (!expose.serialize() && !expose.deserialize());
}
@Override
public boolean shouldSkipClass(Class<?> clazz) {
return false;
}
}
// 处理@Since和@Until注解的版本排除策略
class VersionExclusionStrategy implements ExclusionStrategy {
private final double version;
public VersionExclusionStrategy(double version) {
this.version = version;
}
@Override
public boolean shouldSkipField(FieldAttributes f) {
Since since = f.getAnnotation(Since.class);
if (since != null && since.value() > version) {
return true;
}
Until until = f.getAnnotation(Until.class);
return until != null && until.value() <= version;
}
@Override
public boolean shouldSkipClass(Class<?> clazz) {
Since since = clazz.getAnnotation(Since.class);
if (since != null && since.value() > version) {
return true;
}
Until until = clazz.getAnnotation(Until.class);
return until != null && until.value() <= version;
}
}
5.3 自定义序列化与反序列化器的注册
Gson允许通过registerTypeAdapter()和registerTypeHierarchyAdapter()方法注册自定义的序列化器和反序列化器：
public final class GsonBuilder {
// 注册针对特定类型的适配器
public GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {
// 验证typeAdapter是否为合法类型
if (typeAdapter instanceof TypeAdapter) {
factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter<?>) typeAdapter));
} else if (typeAdapter instanceof JsonSerializer || typeAdapter instanceof JsonDeserializer) {
TypeToken<?> typeToken = TypeToken.get(type);
factories.add(TypeAdapters.newFactoryWithMatchRawType(
typeToken,
typeAdapter,
matchRawType));
} else {
throw new IllegalArgumentException("Expected a TypeAdapter, JsonSerializer or JsonDeserializer");
}
return this;
}
// 注册针对类型层次结构的适配器
public GsonBuilder registerTypeHierarchyAdapter(Class<?> baseType, Object typeAdapter) {
if (typeAdapter instanceof TypeAdapter) {
factories.add(TypeAdapters.newTypeHierarchyFactory(baseType, (TypeAdapter<?>) typeAdapter));
} else if (typeAdapter instanceof JsonSerializer || typeAdapter instanceof JsonDeserializer) {
factories.add(TypeAdapters.newJsonSerializerDeserializer(
baseType,
(JsonSerializer<?>) typeAdapter,
(JsonDeserializer<?>) typeAdapter));
} else {
throw new IllegalArgumentException("Expected a TypeAdapter, JsonSerializer or JsonDeserializer");
}
return this;
}
}
5.4 处理泛型类型的TypeToken机制
由于Java的类型擦除，在运行时无法直接获取泛型的具体类型参数。Gson通过TypeToken类解决这个问题：
// TypeToken类：保存泛型类型信息
public abstract class TypeToken<T> {
final Type type;
final Class<? super T> rawType;
final int hashCode;
// 受保护的构造函数，强制子类通过匿名内部类实现
protected TypeToken() {
this.type = getSuperclassTypeParameter(getClass());
this.rawType = (Class<? super T>) $Gson$Types.getRawType(type);
this.hashCode = type.hashCode();
}
// 私有构造函数，用于直接创建TypeToken
private TypeToken(Type type) {
this.type = $Gson$Types.canonicalize(type);
this.rawType = (Class<? super T>) $Gson$Types.getRawType(this.type);
this.hashCode = this.type.hashCode();
}
// 获取泛型类型信息
public final Type getType() {
return type;
}
// 获取原始类型
public final Class<? super T> getRawType() {
return rawType;
}
// 静态工厂方法，创建TypeToken实例
public static TypeToken<?> get(Type type) {
return new TypeToken<Object>(type) {};
}
// 获取类的泛型父类的类型参数
static Type getSuperclassTypeParameter(Class<?> subclass) {
Type superclass = subclass.getGenericSuperclass();
if (superclass instanceof Class) {
throw new RuntimeException("Missing type parameter.");
}
ParameterizedType parameterized = (ParameterizedType) superclass;
return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);
}
// 其他方法...
}
5.5 处理日期格式的配置
Gson提供了多种方式配置日期格式：
public final class GsonBuilder {
// 使用特定的日期格式
public GsonBuilder setDateFormat(String pattern) {
this.datePattern = pattern;
this.dateStyle = null;
this.timeStyle = null;
return this;
}
// 使用特定的日期风格
public GsonBuilder setDateFormat(int style) {
this.dateStyle = style;
this.timeStyle = style;
this.datePattern = null;
return this;
}
// 使用特定的日期和时间风格
public GsonBuilder setDateFormat(int dateStyle, int timeStyle) {
this.dateStyle = dateStyle;
this.timeStyle = timeStyle;
this.datePattern = null;
return this;
}
// 注册自定义的日期适配器
public GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {
if (type == Date.class) {
// 处理日期类型的适配器注册
if (typeAdapter instanceof TypeAdapter) {
factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter<?>) typeAdapter));
} else if (typeAdapter instanceof JsonSerializer || typeAdapter instanceof JsonDeserializer) {
// 处理JsonSerializer和JsonDeserializer
// ...
}
}
return this;
}
}
// 内置的日期适配器
class DateTypeAdapter extends TypeAdapter<Date> {
private final DateFormat enUsFormat;
private final DateFormat localFormat;
private final DateFormat iso8601Format;
public DateTypeAdapter() {
this.enUsFormat = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.US);
this.localFormat = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT);
this.iso8601Format = buildIso8601Format();
}
private static DateFormat buildIso8601Format() {
DateFormat iso8601Format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US);
iso8601Format.setTimeZone(TimeZone.getTimeZone("UTC"));
return iso8601Format;
}
@Override
public Date read(JsonReader in) throws IOException {
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
return deserializeToDate(in.nextString());
}
private Date deserializeToDate(String json) {
synchronized (enUsFormat) {
try {
// 尝试使用ISO 8601格式解析
return iso8601Format.parse(json);
} catch (ParseException e) {
try {
// 尝试使用本地格式解析
return localFormat.parse(json);
} catch (ParseException e2) {
try {
// 尝试使用US格式解析
return enUsFormat.parse(json);
} catch (ParseException e3) {
throw new JsonSyntaxException(json, e3);
}
}
}
}
}
@Override
public void write(JsonWriter out, Date value) throws IOException {
if (value == null) {
out.nullValue();
return;
}
synchronized (enUsFormat) {
// 使用ISO 8601格式序列化
String dateFormatAsString = iso8601Format.format(value);
out.value(dateFormatAsString);
}
}
}
六、线程安全与性能优化
6.1 Gson实例的线程安全性
Gson实例是不可变的，因此可以安全地在多线程环境中共享：
public final class Gson {
// 所有配置参数在构造时初始化，之后不可变
private final List<TypeAdapterFactory> factories;
private final FieldNamingStrategy fieldNamingStrategy;
private final LongSerializationPolicy longSerializationPolicy;
// 其他配置字段...
public Gson(
List<TypeAdapterFactory> factories,
FieldNamingStrategy fieldNamingStrategy,
LongSerializationPolicy longSerializationPolicy,
// 其他参数...
) {
// 初始化配置字段
this.factories = factories;
this.fieldNamingStrategy = fieldNamingStrategy;
this.longSerializationPolicy = longSerializationPolicy;
// 初始化其他字段...
}
// 所有公共方法都是无状态的，不修改Gson实例的内部状态
public String toJson(Object src) {
// 序列化实现...
}
public <T> T fromJson(String json, Class<T> classOfT) {
// 反序列化实现...
}
}
6.2 类型适配器的缓存机制
Gson使用ConcurrentHashMap缓存已创建的TypeAdapter，提高性能：
public final class Gson {
// 类型适配器缓存
private final ConcurrentMap<TypeToken<?>, TypeAdapter<?>> typeTokenCache = new ConcurrentHashMap<>();
// 获取类型适配器，先检查缓存
public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {
// 从缓存中查找适配器
TypeAdapter<?> cached = typeTokenCache.get(type);
if (cached != null) {
return (TypeAdapter<T>) cached;
}
// 缓存未命中时，创建新的适配器并缓存
TypeAdapter<T> newAdapter = createAdapter(type);
TypeAdapter<?> previous = typeTokenCache.putIfAbsent(type, newAdapter);
return previous != null ? (TypeAdapter<T>) previous : newAdapter;
}
// 创建新的类型适配器
private <T> TypeAdapter<T> createAdapter(TypeToken<T> type) {
// 遍历工厂列表，查找能够处理该类型的工厂
for (TypeAdapterFactory factory : factories) {
TypeAdapter<T> candidate = factory.create(this, type);
if (candidate != null) {
return candidate;
}
}
// 没有找到合适的工厂，抛出异常
throw new IllegalArgumentException("Gson cannot handle " + type);
}
}
6.3 反射性能优化
Gson通过多种方式优化反射性能：
// 构造函数工厂，用于创建对象实例
public final class ConstructorConstructor {
private final Map<Type, InstanceCreator<?>> instanceCreators;
public ConstructorConstructor(Map<Type, InstanceCreator<?>> instanceCreators) {
this.instanceCreators = instanceCreators;
}
// 获取创建指定类型实例的工厂
public <T> ObjectConstructor<T> get(TypeToken<T> typeToken) {
final Type type = typeToken.getType();
final Class<? super T> rawType = typeToken.getRawType();
// 1. 检查是否有注册的InstanceCreator
final InstanceCreator<T> typeCreator = (InstanceCreator<T>) instanceCreators.get(type);
if (typeCreator != null) {
return () -> typeCreator.createInstance(type);
}
// 2. 检查是否有注册的原始类型的InstanceCreator
final InstanceCreator<T> rawTypeCreator = (InstanceCreator<T>) instanceCreators.get(rawType);
if (rawTypeCreator != null) {
return () -> rawTypeCreator.createInstance(type);
}
// 3. 使用反射创建无参构造函数的实例
ObjectConstructor<T> defaultConstructor = newDefaultConstructor(rawType);
if (defaultConstructor != null) {
return defaultConstructor;
}
// 4. 使用反射创建有参构造函数的实例
ObjectConstructor<T> defaultImplementation = newDefaultImplementationConstructor(type, rawType);
if (defaultImplementation != null) {
return defaultImplementation;
}
// 5. 使用Unsafe创建实例（性能最优，但需要特殊权限）
return newUnsafeAllocator(type, rawType);
}
// 使用反射创建无参构造函数的实例
private <T> ObjectConstructor<T> newDefaultConstructor(Class<? super T> rawType) {
try {
// 获取无参构造函数
final Constructor<? super T> constructor = rawType.getDeclaredConstructor();
// 检查构造函数的可访问性
if (!constructor.isAccessible()) {
constructor.setAccessible(true);
}
// 返回构造函数工厂
return () -> {
try {
return (T) constructor.newInstance();
} catch (InstantiationException e) {
throw new RuntimeException("Failed to invoke " + constructor + " with no args", e);
} catch (InvocationTargetException e) {
throw new RuntimeException("Failed to invoke " + constructor + " with no args", e.getTargetException());
} catch (IllegalAccessException e) {
throw new AssertionError(e);
}
};
} catch (NoSuchMethodException e) {
return null;
}
}
// 使用Unsafe创建实例
private <T> ObjectConstructor<T> newUnsafeAllocator(final Type type, final Class<? super T> rawType) {
return () -> {
try {
// 使用Unsafe.allocateInstance创建实例，不调用构造函数
return (T) unsafe.allocateInstance(rawType);
} catch (InstantiationException e) {
throw new RuntimeException("Unable to create instance of " + type, e);
}
};
}
}
6.4 流式API的性能优势
Gson的流式API（JsonReader和JsonWriter）相比DOM API（JsonObject和JsonArray）具有更好的性能：
// 使用流式API解析JSON
public void parseJsonStream(String json) throws IOException {
JsonReader reader = new JsonReader(new StringReader(json));
// 开始解析
reader.beginObject();
while (reader.hasNext()) {
String name = reader.nextName();
if (name.equals("name")) {
String value = reader.nextString();
// 处理name字段
} else if (name.equals("age")) {
int value = reader.nextInt();
// 处理age字段
} else {
reader.skipValue(); // 跳过不关心的字段
}
}
// 结束解析
reader.endObject();
reader.close();
}
// 使用流式API生成JSON
public String generateJsonStream() throws IOException {
StringWriter stringWriter = new StringWriter();
JsonWriter writer = new JsonWriter(stringWriter);
// 开始生成JSON对象
writer.beginObject();
// 添加name字段
writer.name("name").value("John Doe");
// 添加age字段
writer.name("age").value(30);
// 添加hobbies数组
writer.name("hobbies").beginArray();
writer.value("reading");
writer.value("swimming");
writer.value("coding");
writer.endArray();
// 结束生成JSON对象
writer.endObject();
writer.close();
return stringWriter.toString();
}
七、与其他框架的集成与扩展
7.1 与Retrofit的集成
Gson与Retrofit的集成通过GsonConverterFactory实现：
// GsonConverterFactory类
public final class GsonConverterFactory extends Converter.Factory {
private final Gson gson;
private GsonConverterFactory(Gson gson) {
this.gson = gson;
}
// 创建GsonConverterFactory实例
public static GsonConverterFactory create() {
return create(new Gson());
}
public static GsonConverterFactory create(Gson gson) {
return new GsonConverterFactory(gson);
}
// 创建响应体转换器
@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonResponseBodyConverter<>(gson, adapter);
}
// 创建请求体转换器
@Override
public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonRequestBodyConverter<>(gson, adapter);
}
}
// 响应体转换器
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
private final Gson gson;
private final TypeAdapter<T> adapter;
GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
this.gson = gson;
this.adapter = adapter;
}
@Override
public T convert(ResponseBody value) throws IOException {
JsonReader jsonReader = gson.newJsonReader(value.charStream());
try {
return adapter.read(jsonReader);
} finally {
value.close();
}
}
}
// 请求体转换器
final class GsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
private final MediaType MEDIA_TYPE = MediaType.get("application/json; charset=UTF-8");
private final Charset UTF_8 = Charset.forName("UTF-8");
private final Gson gson;
private final TypeAdapter<T> adapter;
GsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) {
this.gson = gson;
this.adapter = adapter;
}
@Override
public RequestBody convert(T value) throws IOException {
Buffer buffer = new Buffer();
Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
JsonWriter jsonWriter = gson.newJsonWriter(writer);
adapter.write(jsonWriter, value);
jsonWriter.close();
return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
}
}
7.2 与Room数据库的集成
Gson可用于Room数据库中处理复杂数据类型的序列化和反序列化：
// 自定义TypeConverter类
public class Converters {
private static Gson gson = new Gson();
// 将List<String>转换为JSON字符串
@TypeConverter
public static String fromStringList(List<String> list) {
return gson.toJson(list);
}
// 将JSON字符串转换为List<String>
@TypeConverter
public static List<String> toStringList(String json) {
Type type = new TypeToken<List<String>>() {}.getType();
return gson.fromJson(json, type);
}
// 将自定义对象转换为JSON字符串
@TypeConverter
public static String fromUser(User user) {
return gson.toJson(user);
}
// 将JSON字符串转换为自定义对象
@TypeConverter
public static User toUser(String json) {
return gson.fromJson(json, User.class);
}
}
// 在Room数据库中注册TypeConverter
@Database(entities = {Note.class}, version = 1)
@TypeConverters(Converters.class)
public abstract class AppDatabase extends RoomDatabase {
public abstract NoteDao noteDao();
}
7.3 自定义TypeAdapterFactory的实现
通过实现自定义的TypeAdapterFactory，可以实现更灵活的类型适配：
// 自定义TypeAdapterFactory
public class CustomTypeAdapterFactory implements TypeAdapterFactory {
@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
// 处理特定类型
if (type.getRawType() == Date.class) {
return (TypeAdapter<T>) new CustomDateTypeAdapter();
}
// 处理集合类型
if (Collection.class.isAssignableFrom(type.getRawType())) {
Type elementType = $Gson$Types.getCollectionElementType(type.getType(), type.getRawType());
TypeAdapter<?> elementAdapter = gson.getAdapter(TypeToken.get(elementType));
return (TypeAdapter<T>) new CustomCollectionTypeAdapter(gson, elementType, elementAdapter);
}
// 其他类型使用默认适配器
return null;
}
}
// 自定义Date类型适配器
class CustomDateTypeAdapter extends TypeAdapter<Date> {
private final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
@Override
public Date read(JsonReader in) throws IOException {
String dateStr = in.nextString();
try {
return dateFormat.parse(dateStr);
} catch (ParseException e) {
throw new JsonSyntaxException(e);
}
}
@Override
public void write(JsonWriter out, Date date) throws IOException {
if (date == null) {
out.nullValue();
return;
}
out.value(dateFormat.format(date));
}
}
// 自定义集合类型适配器
class CustomCollectionTypeAdapter<E> extends TypeAdapter<Collection<E>> {
private final TypeAdapter<E> elementAdapter;
public CustomCollectionTypeAdapter(Gson gson, Type elementType, TypeAdapter<E> elementAdapter) {
this.elementAdapter = elementAdapter;
}
@Override
public Collection<E> read(JsonReader in) throws IOException {
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
Collection<E> collection = new ArrayList<>();
in.beginArray();
while (in.hasNext()) {
E element = elementAdapter.read(in);
collection.add(element);
}
in.endArray();
return collection;
}
@Override
public void write(JsonWriter out, Collection<E> collection) throws IOException {
if (collection == null) {
out.nullValue();
return;
}
out.beginArray();
for (E element : collection) {
elementAdapter.write(out, element);
}
out.endArray();
}
}
八、常见问题与最佳实践
8.1 处理循环引用
当对象图中存在循环引用时，直接序列化会导致栈溢出异常。Gson提供了两种解决方案：
// 方法一：使用@Expose注解排除循环引用字段
public class Parent {
private String name;
@Expose(serialize = false, deserialize = false)
private Child child;
// getter和setter方法
}
public class Child {
private String name;
@Expose(serialize = false, deserialize = false)
private Parent parent;
// getter和setter方法
}
// 方法二：自定义TypeAdapter处理循环引用
public class ParentTypeAdapter extends TypeAdapter<Parent> {
private final Map<Parent, Boolean> serialized = new IdentityHashMap<>();
@Override
public void write(JsonWriter out, Parent parent) throws IOException {
if (parent == null) {
out.nullValue();
return;
}
// 检查是否已序列化，避免循环引用
if (serialized.containsKey(parent)) {
out.beginObject();
out.name("id").value(System.identityHashCode(parent));
out.endObject();
return;
}
// 标记为已序列化
serialized.put(parent, true);
out.beginObject();
out.name("name").value(parent.getName());
// 递归序列化child，但不处理其parent字段
out.name("child");
new ChildTypeAdapter(serialized).write(out, parent.getChild());
out.endObject();
}
@Override
public Parent read(JsonReader in) throws IOException {
// 反序列化实现...
}
}
public class ChildTypeAdapter extends TypeAdapter<Child> {
private final Map<Parent, Boolean> serialized;
public ChildTypeAdapter(Map<Parent, Boolean> serialized) {
this.serialized = serialized;
}
@Override
public void write(JsonWriter out, Child child) throws IOException {
if (child == null) {
out.nullValue();
return;
}
out.beginObject();
out.name("name").value(child.getName());
// 不序列化parent字段，避免循环引用
// out.name("parent");
// parentTypeAdapter.write(out, child.getParent());
out.endObject();
}
@Override
public Child read(JsonReader in) throws IOException {
// 反序列化实现...
}
}
8.2 处理泛型类型
由于Java的类型擦除，在反序列化泛型类型时需要使用TypeToken：
// 错误的方式（无法正确反序列化泛型类型）
List<String> list = gson.fromJson(json, List.class); // 会丢失泛型信息
// 正确的方式（使用TypeToken保留泛型信息）
TypeToken<List<String>> typeToken = new TypeToken<List<String>>() {};
List<String> list = gson.fromJson(json, typeToken.getType());
// 处理复杂泛型类型
TypeToken<Map<String, List<Integer>>> typeToken = new TypeToken<Map<String, List<Integer>>>() {};
Map<String, List<Integer>> map = gson.fromJson(json, typeToken.getType());
// 在方法中使用TypeToken
public <T> T fromJson(String json, TypeToken<T> typeToken) {
return gson.fromJson(json, typeToken.getType());
}
// 使用示例
List<String> list = fromJson(json, new TypeToken<List<String>>() {});
8.3 处理多态类型
当需要序列化和反序列化多态类型时，需要额外的类型信息：
// 基类
public abstract class Shape {
private String type;
public Shape(String type) {
this.type = type;
}
public String getType() {
return type;
}
// 抽象方法
public abstract double area();
}
// 子类
public class Circle extends Shape {
private double radius;
public Circle(double radius) {
super("circle");
this.radius = radius;
}
@Override
public double area() {
return Math.PI * radius * radius;
}
public double getRadius() {
return radius;
}
}
public class Rectangle extends Shape {
private double width;
private double height;
public Rectangle(double width, double height) {
super("rectangle");
this.width = width;
this.height = height;
}
@Override
public double area() {
return width * height;
}
public double getWidth() {
return width;
}
public double getHeight() {
return height;
}
}
// 自定义TypeAdapter处理多态类型
public class ShapeTypeAdapter extends TypeAdapter<Shape> {
private static final String TYPE_FIELD = "type";
@Override
public void write(JsonWriter out, Shape shape) throws IOException {
if (shape == null) {
out.nullValue();
return;
}
out.beginObject();
out.name(TYPE_FIELD).value(shape.getType());
if (shape instanceof Circle) {
Circle circle = (Circle) shape;
out.name("radius").value(circle.getRadius());
} else if (shape instanceof Rectangle) {
Rectangle rectangle = (Rectangle) shape;
out.name("width").value(rectangle.getWidth());
out.name("height").value(rectangle.getHeight());
}
out.endObject();
}
@Override
public Shape read(JsonReader in) throws IOException {
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
String type = null;
double radius = 0;
double width = 0;
double height = 0;
in.beginObject();
while (in.hasNext()) {
String name = in.nextName();
switch (name) {
case TYPE_FIELD:
type = in.nextString();
break;
case "radius":
radius = in.nextDouble();
break;
case "width":
width = in.nextDouble();
break;
case "height":
height = in.nextDouble();
break;
default:
in.skipValue();
}
}
in.endObject();
if ("circle".equals(type)) {
return new Circle(radius);
} else if ("rectangle".equals(type)) {
return new Rectangle(width, height);
} else {
throw new JsonSyntaxException("Unknown shape type: " + type);
}
}
}
// 注册自定义TypeAdapter
Gson gson = new GsonBuilder()
.registerTypeAdapter(Shape.class, new ShapeTypeAdapter())
.create();
// 使用示例
Shape circle = new Circle(5.0);
String json = gson.toJson(circle);
Shape shape = gson.fromJson(json, Shape.class);
System.out.println("Area: " + shape.area());
8.4 性能优化最佳实践
以下是使用Gson时的性能优化建议：
- 复用Gson实例：Gson实例创建开销较大，应在应用中共享单例实例
public class GsonUtils {
private static final Gson GSON = new GsonBuilder()
.setPrettyPrinting()
.create();
public static Gson getInstance() {
return GSON;
}
}
- 使用自定义TypeAdapter：对于频繁序列化/反序列化的类型，使用自定义TypeAdapter避免反射开销
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.endObject();
}
@Override
public User read(JsonReader in) throws IOException {
String name = null;
int age = 0;
in.beginObject();
while (in.hasNext()) {
String jsonName = in.nextName();
switch (jsonName) {
case "name":
name = in.nextString();
break;
case "age":
age = in.nextInt();
break;
default:
in.skipValue();
}
}
in.endObject();
return new User(name, age);
}
}
- 避免序列化不必要的字段：使用
@Expose注解或自定义排除策略
public class User {
private String name;
private int age;
@Expose(serialize = false)
private String password;
// getter和setter方法
}
// 配置Gson只处理带@Expose注解的字段
Gson gson = new GsonBuilder()
.excludeFieldsWithoutExposeAnnotation()
.create();
- 使用流式API处理大型JSON：对于大型JSON数据，使用JsonReader和JsonWriter的流式API避免内存溢出
// 读取大型JSON文件
try (JsonReader reader = new JsonReader(new FileReader("large_data.json"))) {
reader.beginArray();
while (reader.hasNext()) {
// 逐行处理JSON元素
processElement(reader);
}
reader.endArray();
} catch (IOException e) {
e.printStackTrace();
}
- 启用JIT优化：在Android环境中，确保应用已启用JIT编译以提高反射性能
android {
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
}
九、总结与展望
9.1 Gson的优势与局限
9.1.1 主要优势
- 简单易用：提供简洁的API，降低了JSON处理的复杂度
- 强大的类型支持：能够处理复杂的Java对象图，包括泛型、集合和多态
- 高度可定制：通过自定义TypeAdapter和TypeAdapterFactory，可以灵活处理各种特殊情况
- 广泛的集成：与Retrofit、Room等主流Android框架无缝集成
- 性能优化：通过缓存机制和多种优化策略，提供了良好的性能表现
- 社区活跃：作为Google的开源项目，得到了持续的维护和广泛的社区支持
9.1.2 主要局限
- 反射开销：对于大量数据的序列化和反序列化，反射机制会带来一定的性能开销
- 泛型类型擦除：由于Java的类型擦除，处理复杂泛型类型时需要额外的TypeToken机制
- 学习曲线：对于复杂的自定义序列化和反序列化需求，需要深入理解Gson的内部机制
- 不支持非标准JSON：严格遵循JSON规范，对于一些非标准JSON格式的支持有限
- 内存占用：在处理大型JSON数据时，DOM方式可能导致较高的内存占用
9.2 未来发展趋势
9.2.1 性能优化方向
- 减少反射依赖：通过代码生成技术（如Annotation Processor）减少运行时反射的使用
- 支持GraalVM：优化在GraalVM等原生编译环境下的性能表现
- 流式处理增强：进一步优化流式API的性能，提供更高效的大型JSON处理能力
9.2.2 功能增强方向
- Kotlin协程支持：提供对Kotlin协程的原生支持，简化异步JSON处理
- 更丰富的注解支持：引入更多注解，提供更灵活的序列化和反序列化控制
- 多格式支持：扩展支持其他数据格式，如Protocol Buffers、CBOR等
- 模块化设计：采用模块化设计，允许用户只引入需要的功能模块
9.2.3 生态融合方向
- 与Android Jetpack深度集成：与Data Binding、ViewModel等
