Comment résoudre une référence circulaire lors de la sérialisation d'un objet qui a un membre de classe avec le même type de cet objet

Je pense qu'utiliser ExclusionStrategy n'est pas la bonne approche pour résoudre ce problème.

Je suggérerais plutôt d'utiliser JsonSerializer et JsonDeserializer personnalisé pour votre classe StructId .
(Peut être une approche utilisant TypeAdapter serait encore mieux, mais je n'avais pas assez d'expérience Gson pour que cela fonctionne.)

Vous créeriez donc votre instance Gson par:

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

La classe StructIdSerializer ci-dessous est responsable de la conversion d'un StructId en JSON. Il convertit ses propriétés Name , Type et ChildId en JSON. Notez qu'il ne convertit pas la propriété ParentId en JSON, car cela produirait une récursion infinie.

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;
    }
}

La classe StructIdDeserializer ci-dessous est responsable de la conversion de JSON en un StructId . Il convertit les propriétés JSON Name , Type et ChildId aux champs Java correspondants dans StructId . Notez que le champ Java ParentId est reconstruit à partir de la structure d'imbrication JSON, car il n'est pas directement contenu en tant que propriété 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;
    }
}

J'ai testé le code ci-dessus avec cet exemple d'entrée JSON

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

en le désérialisant avec
StructId root = gson.fromJson (nouveau FileReader ("example.json"), StructId.class); ,
puis en sérialisant cela avec
System.out.println (gson.toJson (racine));
et a obtenu à nouveau le JSON d'origine.

Juste pour montrer une façon de faire la sérialisation (donc je ne gère pas la désérialisation) avec TypeAdapter et ExclusionStrategy . Ce n'est peut-être pas la plus belle implémentation, mais elle est quand même assez générique.

Cette solution utilise le fait que votre structure est une sorte de liste chaînée bidirectionnelle et compte tenu de tout nœud de cette liste, nous devons simplement séparer la sérialisation des parents et des enfants afin que ceux-ci soient sérialisés dans une seule direction pour éviter les références circulaires.

Nous avons d'abord besoin de ExclusionStrategy configurable comme:

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

Désolé de vous avoir induit en erreur, sur la base de ce message:

Existe-t-il une solution à propos de la "référence circulaire" de Gson?

"Il n'y a pas de solution automatisée pour les références circulaires dans Gson. La seule bibliothèque de production JSON que je connaisse qui gère automatiquement les références circulaires est XStream (avec le backend Jettison). "

Mais c'est le cas où vous ne le faites pas n'utilise pas Jackson! Si vous utilisez déjà Jackson pour créer vos contrôleurs d'API REST, pourquoi ne pas l'utiliser pour effectuer la sérialisation. Pas besoin de composants externes comme: Gson ou XStream.

La solution avec Jackson:

Sérialisation:

//@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();

Dé-sérialisation :

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());
    }

Et le plus important, vous devez utiliser l'annotation @JsonIdentityInfo:

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