码字不易，请大佬们点点关注，谢谢~
一、循环引用与递归反序列化概述
1.1 循环引用的概念
在Java对象结构中，循环引用是指两个或多个对象之间相互引用，形成一个闭环。例如，对象A引用对象B，而对象B又引用对象A，这就形成了一个简单的循环引用。
public class Parent {
private Child child;
// getter和setter方法
}
public class Child {
private Parent parent;
// getter和setter方法
}
// 创建循环引用
Parent parent = new Parent();
Child child = new Child();
parent.setChild(child);
child.setParent(parent);
1.2 循环引用对JSON序列化和反序列化的挑战
循环引用对JSON处理带来了特殊挑战：
- 无限递归：序列化时，如果不处理循环引用，会导致无限递归，最终引发StackOverflowError。
- 数据冗余：即使避免了无限递归，简单地忽略循环引用可能导致数据丢失或冗余。
- 对象标识丢失：JSON是一种无类型的扁平格式，无法直接表达对象之间的引用关系。
1.3 Gson处理循环引用的基本策略
Gson处理循环引用的核心策略是：
- 序列化时：检测循环引用并通过特定机制避免无限递归。
- 反序列化时：重建对象之间的引用关系，确保正确还原原始对象结构。
下面我们将深入分析Gson如何实现这些策略。
二、Gson序列化过程中的循环引用处理
2.1 序列化流程概述
Gson的序列化流程大致如下：
- 从根对象开始，递归遍历对象的所有字段。
- 对于每个字段，根据其类型选择合适的TypeAdapter进行序列化。
- 将对象转换为JSON格式。
2.2 循环引用检测机制
Gson在序列化过程中通过一个身份引用注册表（IdentityHashMap）来检测循环引用。
// Gson类中的核心序列化方法
public String toJson(Object src, Type typeOfSrc) {
StringWriter writer = new StringWriter();
toJson(src, typeOfSrc, writer);
return writer.toString();
}
public void toJson(Object src, Type typeOfSrc, Appendable writer) throws JsonIOException {
// 创建JsonWriter
JsonWriter jsonWriter = newJsonWriter(Streams.writerForAppendable(writer));
// 序列化对象
toJson(src, typeOfSrc, jsonWriter);
}
public void toJson(Object src, Type typeOfSrc, JsonWriter writer) throws JsonIOException {
// 获取类型适配器
TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfSrc));
// 创建序列化上下文
SerializationContext context = new SerializationContext() {
// 实现序列化上下文接口
@Override
public JsonElement serialize(Object src) {
return toJsonTree(src);
}
@Override
public JsonElement serialize(Object src, Type typeOfSrc) {
return toJsonTree(src, typeOfSrc);
}
};
// 跟踪已序列化的对象，防止循环引用
writer.setSerializeNulls(serializeNulls);
writer.setLenient(lenient);
// 开始序列化
adapter.write(writer, src);
}
2.3 JsonWriter的角色
JsonWriter是Gson中用于生成JSON的核心类，它维护了一个状态栈来跟踪当前序列化的对象路径。
public final class JsonWriter implements Closeable, Flushable {
// 跟踪当前路径的栈
private final List<String> stack = new ArrayList<String>();
// 对象引用跟踪器，用于检测循环引用
private final Map<Object, FutureTypeAdapter<?>> instanceMap = new IdentityHashMap<Object, FutureTypeAdapter<?>>();
// 开始序列化对象
public JsonWriter beginObject() throws IOException {
// 检查状态
beforeValue(true);
// 将对象开始标记压入栈
stack.add("object");
// 写入对象开始符号
out.write('{');
return this;
}
// 结束序列化对象
public JsonWriter endObject() throws IOException {
// 检查状态
if (stack.isEmpty() || !stack.get(stack.size() - 1).equals("object")) {
throw new IllegalStateException("Nesting problem.");
}
// 弹出栈顶元素
stack.remove(stack.size() - 1);
// 写入对象结束符号
out.write('}');
return this;
}
// 其他方法...
}
2.4 处理循环引用的具体实现
当Gson遇到一个对象时，会先检查该对象是否已经在序列化过程中出现过。
// TypeAdapterRuntimeTypeWrapper类的write方法
@Override
public void write(JsonWriter out, Object value) throws IOException {
// 处理null值
if (value == null) {
out.nullValue();
return;
}
// 检查运行时类型
TypeAdapter<?> runtimeTypeAdapter = getRuntimeTypeAdapter(gson, value, type);
// 检查是否已经序列化过该对象
FutureTypeAdapter<Object> futureAdapter = out.getInstanceMap().get(value);
if (futureAdapter != null) {
// 对象已经在序列化过程中，这是一个循环引用
// 根据配置处理循环引用
if (out.getSerializeNulls()) {
out.nullValue();
} else {
// 忽略循环引用
out.skipValue();
}
return;
}
// 标记对象正在序列化
FutureTypeAdapter<Object> deferredAdapter = new FutureTypeAdapter<Object>();
out.getInstanceMap().put(value, deferredAdapter);
try {
// 序列化对象
runtimeTypeAdapter.write(out, value);
// 对象序列化完成后，从注册表中移除
out.getInstanceMap().remove(value);
} catch (Exception e) {
// 发生异常时，也从注册表中移除
out.getInstanceMap().remove(value);
throw e;
}
}
三、Gson反序列化过程中的循环引用重建
3.1 反序列化流程概述
Gson的反序列化流程大致如下：
- 从JSON数据开始，递归解析JSON结构。
- 对于每个JSON元素，根据目标类型选择合适的TypeAdapter进行反序列化。
- 创建Java对象并设置其字段值。
3.2 引用跟踪与对象缓存
在反序列化过程中，Gson使用一个缓存来跟踪已经创建的对象，以便在遇到循环引用时能够正确重建引用关系。
// ReflectiveTypeAdapterFactory类的Adapter内部类
public static final class Adapter<T> extends TypeAdapter<T> {
private final ObjectConstructor<T> constructor;
private final Map<String, BoundField> boundFields;
@Override
public T read(JsonReader in) throws IOException {
// 处理null值
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
// 创建对象实例
T instance = constructor.construct();
try {
// 开始解析JSON对象
in.beginObject();
// 记录已创建的对象，用于处理循环引用
// 注意：这里的具体实现涉及Gson内部的引用跟踪机制
// 实际代码会在解析过程中维护一个对象缓存
while (in.hasNext()) {
// 读取字段名
String name = in.nextName();
// 查找对应的BoundField
BoundField field = boundFields.get(name);
if (field == null || !field.deserialized) {
// 忽略未知字段
in.skipValue();
continue;
}
// 读取字段值
field.read(in, instance);
}
// 结束解析JSON对象
in.endObject();
} catch (IllegalStateException e) {
throw new JsonSyntaxException(e);
} catch (IllegalAccessException e) {
throw new AssertionError(e);
}
return instance;
}
// 其他方法...
}
3.3 处理嵌套对象的循环引用
当反序列化嵌套对象时，Gson会递归处理每个对象，并在遇到循环引用时使用已创建的对象实例。
// 处理嵌套对象的示例
public class Parent {
private Child child;
// getter和setter方法
}
public class Child {
private Parent parent;
// getter和setter方法
}
// 对应的JSON可能是：
// {
// "child": {
// "parent": { ... }
// }
// }
// 在反序列化过程中，Gson会：
// 1. 创建Parent对象
// 2. 创建Child对象
// 3. 设置Child的parent字段为之前创建的Parent对象
// 4. 设置Parent的child字段为当前Child对象
3.4 具体实现细节
Gson在反序列化过程中使用了一个延迟引用机制来处理循环引用。
// 简化的延迟引用实现示例
public class ReferenceHolder<T> {
private T value;
public void setValue(T value) {
this.value = value;
}
public T getValue() {
return value;
}
}
// 在反序列化过程中，当遇到可能的循环引用时：
// 1. 创建一个ReferenceHolder
// 2. 立即将ReferenceHolder与对象关联
// 3. 继续反序列化对象的其他字段
// 4. 当遇到循环引用时，使用已关联的ReferenceHolder
// 例如：
ReferenceHolder<Parent> parentHolder = new ReferenceHolder<>();
// 创建Parent对象并关联到holder
Parent parent = new Parent();
parentHolder.setValue(parent);
// 反序列化Child对象，可能会引用到parent
Child child = deserializeChild(jsonReader, parentHolder);
// 设置Parent的child字段
parent.setChild(child);
四、自定义处理循环引用的策略
4.1 自定义TypeAdapter
开发者可以通过自定义TypeAdapter来实现特定的循环引用处理策略。
public class ParentTypeAdapter extends TypeAdapter<Parent> {
// 用于跟踪已序列化的对象
private final Set<Parent> serializedParents = Collections.newSetFromMap(new IdentityHashMap<Parent, Boolean>());
@Override
public void write(JsonWriter out, Parent value) throws IOException {
if (value == null) {
out.nullValue();
return;
}
// 检查是否已经序列化过该对象
if (serializedParents.contains(value)) {
// 处理循环引用，这里简单地写入null
out.nullValue();
return;
}
// 标记对象正在序列化
serializedParents.add(value);
// 序列化对象
out.beginObject();
out.name("child");
// 递归序列化child字段
TypeAdapter<Child> childAdapter = gson.getAdapter(Child.class);
childAdapter.write(out, value.getChild());
out.endObject();
// 序列化完成后，从标记集合中移除
serializedParents.remove(value);
}
@Override
public Parent read(JsonReader in) throws IOException {
// 反序列化实现...
}
}
4.2 使用@JsonAdapter注解
可以使用@JsonAdapter注解将自定义TypeAdapter应用到类上。
@JsonAdapter(ParentTypeAdapter.class)
public class Parent {
private Child child;
// getter和setter方法
}
4.3 注册全局TypeAdapter
也可以在GsonBuilder中注册全局的TypeAdapter。
Gson gson = new GsonBuilder()
.registerTypeAdapter(Parent.class, new ParentTypeAdapter())
.create();
五、性能考量与优化
5.1 循环引用处理的性能开销
循环引用处理会带来一定的性能开销，主要体现在：
- 对象标识检查（使用IdentityHashMap）。
- 额外的内存使用（维护对象注册表）。
- 递归深度增加（处理嵌套对象）。
5.2 优化建议
- 避免不必要的循环引用：在设计数据模型时，尽量避免或减少循环引用。
- 使用@Expose注解：通过@Expose注解选择性地序列化和反序列化字段。
- 优化TypeAdapter实现：自定义TypeAdapter时，尽量减少不必要的对象检查。
- 批量处理：对于大量对象的处理，考虑使用批量操作减少开销。
六、总结与展望
6.1 Gson处理循环引用的优势
Gson处理循环引用的机制具有以下优势：
- 自动检测：能够自动检测循环引用，避免无限递归。
- 灵活处理：提供多种方式自定义循环引用的处理策略。
- 引用重建：在反序列化时能够正确重建对象间的引用关系。
6.2 未来发展方向
未来，Gson可能在以下方面改进循环引用处理：
- 更高效的引用跟踪：优化对象注册表的实现，减少内存和性能开销。
- 声明式配置：提供更简洁的声明式配置方式来处理循环引用。
- 与其他框架集成：更好地与其他Android框架集成，提供统一的对象图处理机制。
- 异步处理支持：支持异步环境下的循环引用处理。
通过不断改进，Gson将继续为开发者提供高效、灵活的JSON处理解决方案，特别是在处理复杂对象图和循环引用方面。
