Gson使用存根序列化循环引用

Question

我正在尝试实现一些简单的Json序列化功能，但是我很难应付Gson的巨大复杂性。

因此，基本上，我有一堆Entity类，它们通过大量循环引用相互引用。 要将这个结构序列化为JSON，我想跟踪已经序列化的对象。 所有的Entity类都实现了一个名为Identified的接口，该接口具有一个提供全局唯一ID的方法String getId() 。 因此，在序列化一个根元素的过程中，我想将所有遇到的id存储在Set并根据该set决定是完全序列化对象还是将该对象序列化为存根

"something": { "__stub": "true", "id": "..." }

在我看来，这应该不是一件容易的事，但我无法将某些东西放在一起。 使用自定义JsonSerializer我无法以默认方式序列化一个对象（该序列不会作为存根序列化）。 使用TypeAdapterFactory ，我无法访问实际的对象。

因此，任何有关如何实现这一目标的帮助都将非常好！

最好的祝福

Answer 1

我不确定是否可以轻松实现。 据我所知，Gson促进了不变性，并且似乎缺乏自定义序列化上下文支持（至少我不知道是否有可能在任何可能的地方使用自定义JsonSerializationContext ）。 因此，可能的解决方法之一可能是：

IIdentifiable.java

一个简单的接口，用于请求对象的自定义ID。

interface IIdentifiable<ID> {

    ID getId();

}

Entity.java

可以通过两种方式保存另一个实体引用的简单实体：

• 对“下一个”实体的直接依赖；
• 对其他参考文献的参考文献集合。

final class Entity
        implements IIdentifiable<String> {

    @SerializedName(ID_PROPERTY_NAME)
    private final String id;

    private final Collection<Entity> entities = new ArrayList<>();
    private Entity next;

    private Entity(final String id) {
        this.id = id;
    }

    static Entity entity(final String id) {
        return new Entity(id);
    }

    @Override
    public String getId() {
        return id;
    }

    Entity setAll(final Entity... entities) {
        this.entities.clear();
        this.entities.addAll(asList(entities));
        return this;
    }

    Entity setNext(final Entity next) {
        this.next = next;
        return this;
    }

}

IdentitySerializingTypeAdapterFactory.java

除了使它成为类型适配器工厂之外，我没有找到任何更简单的方法，而且不幸的是，此实现是完全有状态的 ， 无法重用 。

final class IdentitySerializingTypeAdapterFactory
        implements TypeAdapterFactory {

    private final Collection<Object> traversedEntityIds = new HashSet<>();

    private IdentitySerializingTypeAdapterFactory() {
    }

    static TypeAdapterFactory identitySerializingTypeAdapterFactory() {
        return new IdentitySerializingTypeAdapterFactory();
    }

    @Override
    public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken) {
        final boolean isIdentifiable = IIdentifiable.class.isAssignableFrom(typeToken.getRawType());
        final TypeAdapter<T> delegateAdapter = gson.getDelegateAdapter(this, typeToken);
        if ( isIdentifiable ) {
            return new TypeAdapter<T>() {
                @Override
                public void write(final JsonWriter out, final T value)
                        throws IOException {
                    final IIdentifiable<?> identifiable = (IIdentifiable<?>) value;
                    final Object id = identifiable.getId();
                    if ( !traversedEntityIds.contains(id) ) {
                        delegateAdapter.write(out, value);
                        traversedEntityIds.add(id);
                    } else {
                        out.beginObject();
                        out.name(REF_ID_PROPERTY_NAME);
                        writeSimpleValue(out, id);
                        out.endObject();
                    }
                }

                @Override
                public T read(final JsonReader in) {
                    throw new UnsupportedOperationException();
                }
            };
        }
        return delegateAdapter;
    }

}

类型适配器首先尝试检查给定的实体是否已经遍历。 如果是，那么它正在编写一个与您的对象相似的特殊对象（当然，可以通过策略模式来重写行为，但是让它更简单）。 如果否，则获取默认类型的适配器，然后将给定的实体委派给该适配器，如果后一种类型的适配器成功，则将其注册为遍历的实体。

其余的部分

剩下的就是这里。

SystemNames.java

final class SystemNames {

    private SystemNames() {
    }

    private static final String SYSTEM_PREFIX = "__$";

    static final String ID_PROPERTY_NAME = SYSTEM_PREFIX + "id";
    static final String REF_ID_PROPERTY_NAME = SYSTEM_PREFIX + "refId";

}

GsonJsonWriters.java

final class GsonJsonWriters {

    private GsonJsonWriters() {
    }

    static void writeSimpleValue(final JsonWriter writer, final Object value)
            throws IOException {
        if ( value == null ) {
            writer.nullValue();
        } else if ( value instanceof Double ) {
            writer.value((double) value);
        } else if ( value instanceof Long ) {
            writer.value((long) value);
        } else if ( value instanceof String ) {
            writer.value((String) value);
        } else if ( value instanceof Boolean ) {
            writer.value((Boolean) value);
        } else if ( value instanceof Number ) {
            writer.value((Number) value);
        } else {
            throw new IllegalArgumentException("Cannot handle values of type " + value);
        }
    }

}

测试

在下面的测试中，有三个由FOO ， BAR和BAZ字符串标识符标识的实体。 它们都具有如下循环依赖：

• FOO > BAR ， BAR > BAZ ， BAZ > FOO使用next属性；
• FOO > [BAR, BAZ] ， BAR > [FOO, BAZ] ， BAZ > [FOO, BAR]使用entities属性。

由于类型适配器工厂是有状态的，因此甚至GsonBuilder必须从头开始创建，因此GsonBuilder使用之间不会出现“损坏”状态。 简而言之，一旦使用了Gson实例，就必须将其丢弃，因此下面的测试中有GsonBuilder供应商。

public final class Q41213747Test {

    private static final Entity foo = entity("FOO");
    private static final Entity bar = entity("BAR");
    private static final Entity baz = entity("BAZ");

    static {
        foo.setAll(bar, baz).setNext(bar);
        bar.setAll(foo, baz).setNext(baz);
        baz.setAll(foo, bar).setNext(foo);
    }

    @Test
    public void testSerializeSameJson() {
        final String json1 = newSerializingGson().toJson(foo);
        final String json2 = newSerializingGson().toJson(foo);
        assertThat("Must be the same between the calls because the GSON instances are stateful", json1, is(json2));
    }

    @Test
    public void testSerializeNotSameJson() {
        final Gson gson = newSerializingGson();
        final String json1 = gson.toJson(foo);
        final String json2 = gson.toJson(foo);
        assertThat("Must not be the same between the calls because the GSON instance is stateful", json1, is(not(json2)));
    }

    @Test
    public void testOutput() {
        out.println(newSerializingGson().toJson(foo));
    }

    private static Gson newSerializingGson() {
        return newSerializingGson(GsonBuilder::new);
    }

    private static Gson newSerializingGson(final Supplier<GsonBuilder> defaultGsonBuilderSupplier) {
        return defaultGsonBuilderSupplier.get()
                .registerTypeAdapterFactory(identitySerializingTypeAdapterFactory())
                .create();
    }

}

{
    "__$id": "FOO",
    "entities": [
        {
            "__$id": "BAR",
            "entities": [
                {
                    "__$refId": "FOO"
                },
                {
                    "__$id": "BAZ",
                    "entities": [
                        {
                            "__$refId": "FOO"
                        },
                        {
                            "__$refId": "BAR"
                        }
                    ],
                    "next": {
                        "__$refId": "FOO"
                    }
                }
            ],
            "next": {
                "__$refId": "BAZ"
            }
        },
        {
            "__$refId": "BAZ"
        }
    ],
    "next": {
        "__$refId": "BAR"
    }
}

这些东西的反序列化看起来真的很复杂。 至少使用GSON工具。

---

您是否考虑重新考虑JSON模型以避免在JSON输出中产生循环依赖关系？ 也许将您的对象分解为单个映射，例如Map<ID, Object>并使引用成为瞬态或@Expose -annotated可能更容易使用？ 这也将简化反序列化。