我认为使用ExclusionStrategy不是解决这个问题的正确方法。
我建议使用为StructId类定制的JsonSerializer和JsonDeserializer。
(May使用TypeAdapter的方法会更好，但我没有足够的Gson经验来实现这一点。）
因此，您可以通过以下方式创建Gson示例：

Gson gson = new GsonBuilder()
    .registerTypeAdapter(StructId.class, new StructIdSerializer())
    .registerTypeAdapter(StructId.class, new StructIdDeserializer())
    .setPrettyPrinting()
    .create();

下面的StructIdSerializer类负责将StructId转换为JSON。它将其属性Name，Type和ChildId转换为JSON。请注意，它不会将属性ParentId转换为JSON，因为这样做会产生无限递归。

public class StructIdSerializer implements JsonSerializer<StructId> {

    @Override
    public JsonElement serialize(StructId src, Type typeOfSrc, JsonSerializationContext context) {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("Name", src.Name);
        jsonObject.add("Type", context.serialize(src.Type));
        jsonObject.add("ChildId", context.serialize(src.ChildId));  // recursion!
        return jsonObject;
    }
}

下面的StructIdDeserializer类负责将JSON转换为StructId。它将JSON属性Name、Type和ChildId转换为StructId中相应的Java字段。请注意，ParentId Java字段是从JSON嵌套结构中重新构建的，因为它没有直接作为JSON属性包含。

public class StructIdDeserializer implements JsonDeserializer<StructId> {

    @Override
    public StructId deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
        throws JsonParseException {
        StructId id = new StructId();
        id.Name = json.getAsJsonObject().get("Name").getAsString();
        id.Type = context.deserialize(json.getAsJsonObject().get("Type"), StructType.class);
        JsonElement childJson = json.getAsJsonObject().get("ChildId");
        if (childJson != null) {
            id.ChildId = context.deserialize(childJson, StructId.class);  // recursion!
            id.ChildId.ParentId = id;
        }
        return id;
    }
}

我用这个JSON输入示例测试了上面的代码

{
    "Name": "John",
    "Type": "A",
    "ChildId": {
        "Name": "Jane",
        "Type": "B",
        "ChildId": {
            "Name": "Joe",
            "Type": "A"
        }
    }
}

通过将其与
StructId root = gson.fromJson(new FileReader("example.json"), StructId.class);，
然后通过序列化，
System.out.println(gson.toJson(root));
并再次获得原始JSON。

这里只展示一种使用TypeAdapter和ExclusionStrategy进行序列化的方法（因此我不处理反序列化）。这可能不是最漂亮的实现，但无论如何它是相当通用的。
这个解决方案利用了这样一个事实，即你的结构是某种双向链表，给定该列表中的任何节点，我们只需要将父节点和子节点的序列化分开，这样它们就可以在一个方向上序列化，以避免循环引用。
首先，我们需要可配置的ExclusionStrategy，例如：

public class FieldExclusionStrategy implements ExclusionStrategy {

    private final List<String> skipFields;

    public FieldExclusionStrategy(String... fieldNames) {
        skipFields = Arrays.asList(fieldNames);
    }

    @Override
    public boolean shouldSkipField(FieldAttributes f) {
        return skipFields.contains(f.getName());
    }

    @Override
    public boolean shouldSkipClass(Class<?> clazz) {
        return false;
    }

}

那么TypeAdapter就像这样：

public class LinkedListAdapter extends TypeAdapter<StructId> {

private static final String PARENT_ID = "ParentId";
private static final String CHILD_ID = "ChildId";
private Gson gson;

@Override
public void write(JsonWriter out, StructId value) throws IOException {
    // First serialize everything but StructIds
    // You could also use type based exclusion strategy
    // but for brevity I use just this one  
    gson = new GsonBuilder()
            .addSerializationExclusionStrategy(
                    new FieldExclusionStrategy(CHILD_ID, PARENT_ID))
            .create();
    JsonObject structObject = gson.toJsonTree(value).getAsJsonObject(); 
    JsonObject structParentObject;
    JsonObject structChildObject;

    // If exists go through the ParentId side in one direction.
    if(null!=value.ParentId) {
        gson = new GsonBuilder()
                .addSerializationExclusionStrategy(new FieldExclusionStrategy(CHILD_ID))
                .create();
        structObject.add(PARENT_ID, gson.toJsonTree(value.ParentId));

        if(null!=value.ParentId.ChildId) {
            gson = new GsonBuilder()
                    .addSerializationExclusionStrategy(new FieldExclusionStrategy(PARENT_ID))
                    .create();
            structParentObject = structObject.get(PARENT_ID).getAsJsonObject();
            structParentObject.add(CHILD_ID, gson.toJsonTree(value.ParentId.ChildId).getAsJsonObject());
        }
    }
    // And also if exists go through the ChildId side in one direction.
    if(null!=value.ChildId) {
        gson = new GsonBuilder()
                .addSerializationExclusionStrategy(new FieldExclusionStrategy(PARENT_ID))
                .create();
        structObject.add(CHILD_ID, gson.toJsonTree(value.ChildId));

        if(null!=value.ChildId.ParentId) {
            gson = new GsonBuilder()
                    .addSerializationExclusionStrategy(new FieldExclusionStrategy(CHILD_ID))
                    .create();

            structChildObject = structObject.get(CHILD_ID).getAsJsonObject();
            structChildObject.add(PARENT_ID, gson.toJsonTree(value.ChildId.ParentId).getAsJsonObject());
        }
    }

    // Finally write the combined result out. No need to initialize gson anymore
    // since just writing JsonElement
    gson.toJson(structObject, out);
}

@Override
public StructId read(JsonReader in) throws IOException {
    return null;
}}

测试它：

@Slf4j
public class TestIt extends BaseGsonTest {

@Test
public void test1() {
    StructId grandParent   = new StructId();

    StructId parent   = new StructId();
    grandParent.ChildId = parent;
    parent.ParentId = grandParent;

    StructId child = new StructId();
    parent.ChildId = child;
    child.ParentId = parent;

    Gson gson = new GsonBuilder()
            .setPrettyPrinting()
            .registerTypeAdapter(StructId.class, new LinkedListAdapter())
            .create();

    log.info("\n{}", gson.toJson(parent));
}}

会给你给予这样的东西：

{
  "Name": "name1237598030",
  "Type": {
       "name": "name688766789"
   },
  "ParentId": {
  "Name": "name1169146729",
  "Type": {
     "name": "name2040352617"
  }
 },
"ChildId": {
  "Name": "name302155142",
  "Type": {
     "name": "name24606376"
   }
 }
}

在我的测试材料中，名称默认初始化为"name"+hashCode()

对不起，误导了你们，基于这篇文章：
Is there a solution about Gson "circular reference"?
“Gson中没有循环引用的自动解决方案。我所知道的唯一一个自动处理循环引用的JSON生成库是XStream（带有Jettison后端）。
但前提是你不用Jackson！如果您已经在使用Jackson构建REST API控制器，那么为什么不使用它来进行序列化呢？无需外部组件，如：Gson或XStream。
Jackson的解决方案：
序列化：

ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        jsonDesttinationIdString = ow.writeValueAsString(destinationId);
    } catch (JsonProcessingException ex) {
        throw new SpecificationException(ex.getMessage());
    }

反序列化：

ObjectMapper mapper = new ObjectMapper();
    try {
        destinationStructId = destinationId.isEmpty() ? null : mapper.readValue(URLDecoder.decode(destinationId, ENCODING), StructId.class);
    } catch (IOException e) {
        throw new SpecificationException(e.getMessage());
    }

最重要的是，您必须使用@JsonIdentityInfo注解：

//@JsonIdentityInfo(
//        generator = ObjectIdGenerators.PropertyGenerator.class, 
//        property = "Name")
@JsonIdentityInfo(
      generator = ObjectIdGenerators.UUIDGenerator.class, 
      property = "id")
public class StructId implements Serializable {
    private static final long serialVersionUID = 1L;

    @JsonProperty("id") // I added this field to have a unique identfier
    private UUID id = UUID.randomUUID();

如果你能接受二进制格式而不是json，你可以尝试https://github.com/alipay/fury。Json是一种文本格式，不能表示循环引用，必须通过@JsonIgnore注解来裁剪循环字段。但是json中的对象会丢失循环引用，被忽略的数据将为null。
使用fury进行循环引用序列化示例：

Fury fury = Fury.builder().withRefTracking(true).build();
byte[] data = fury.serializeJavaObject(structId);
StructId newStructId = fury.deserializeJavaObject(data, StructId.class);

类似的框架如kryo/fst也可以用于此。