Bdtjtk

I'm facing this issue when using Gson to serialize an object which has a class member with the same type:

https://github.com/google/gson/issues/1447

The object:

public class StructId implements Serializable {

private static final long serialVersionUID = 1L;



public String Name;

public StructType Type;

public StructId ParentId;

public StructId ChildId;

And since StructId contains ParentId/ChildId with the same type I was getting infinite loop when trying to serialize it, so what I did is:

private Gson gson = new GsonBuilder()

.setExclusionStrategies(new ExclusionStrategy() {



        public boolean shouldSkipClass(Class<?> clazz) {

            return false; //(clazz == StructId.class);

        }



        /**

          * Custom field exclusion goes here

          */

        public boolean shouldSkipField(FieldAttributes f) {

            //Ignore inner StructIds to solve circular serialization

            return ( f.getName().equals("ParentId") || f.getName().equals("ChildId") ); 

        }



     })

    /**

      * Use serializeNulls method if you want To serialize null values 

      * By default, Gson does not serialize null values

      */

    .serializeNulls()

    .create();

But this is not good enough cause I need the data inside Parent/Child and ignoring them while serializing is not a solution.
How is it possible to solve it?

Related to the answer marked as Solution:

I have such a struct:
- Struct1
-- Table
--- Variable1

The object before serialization is:

And Json that is generated is:

As you can see, the ParentId of Table is "Struct1" but the ChildId of "Struct1" is empty and it should be "Table"

B.R.

I think using ExclusionStrategy is not the right approach to solve this problem.

I would rather suggest to use JsonSerializer and JsonDeserializer
customized for your StructId class.

(May be an approach using TypeAdapter would be even better,
but I didn't have enough Gson experience do get this working.)

So you would create your Gson instance by:

Gson gson = new GsonBuilder()

    .registerTypeAdapter(StructId.class, new StructIdSerializer())

    .registerTypeAdapter(StructId.class, new StructIdDeserializer())

    .setPrettyPrinting()

    .create();

The StructIdSerializer class below is responsible for converting a StructId to JSON.
It converts its properties Name, Type and ChildId to JSON.
Note that it does not convert the property ParentId to JSON,
because doing that would produce infinite recursion.

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;

    }

}

The StructIdDeserializer class below is responsible for converting JSON to a StructId.
It converts the JSON properties Name, Type and ChildId
to corresponding Java fields in StructId.
Note that the ParentId Java field is reconstructed from the JSON nesting structure,
because it is not directly contained as a JSON property.

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;

    }

}

I tested the code above with this JSON input example

{

    "Name": "John",

    "Type": "A",

    "ChildId": {

        "Name": "Jane",

        "Type": "B",

        "ChildId": {

            "Name": "Joe",

            "Type": "A"

        }

    }

}

by deserializing it with
StructId root = gson.fromJson(new FileReader("example.json"), StructId.class);,

then by serializing that with
System.out.println(gson.toJson(root));

and got the original JSON again.

Just to show one way to make serialization (so I do not handle de-serialization) with TypeAdapter and ExclusionStrategy. This might not be the most beautiful implementation but it is quite generic anyway.

This solution makes use of the fact that your struct is some kind of a bi-directional linked list and given any node in that list we just need to separate the serialization of parents and children so that those are serialized just in one direction to avoid circular references.

First we need configurable ExclusionStrategy like:

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;

    }



}

Then the TypeAdapter would be like:

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;

}}

Testing it:

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

}}

Would give you something like:

{

  "Name": "name1237598030",

  "Type": {

       "name": "name688766789"

   },

  "ParentId": {

  "Name": "name1169146729",

  "Type": {

     "name": "name2040352617"

  }

 },

"ChildId": {

  "Name": "name302155142",

  "Type": {

     "name": "name24606376"

   }

 }

}

Names in my test material are just by default initialized with "name"+hashCode()

Sorry for misleading you guys, based on this post :

Is there a solution about Gson "circular reference"?

"there is no automated solution for circular references in Gson. The only JSON-producing library I know of that handles circular references automatically is XStream (with Jettison backend)."

But that is case you don't use Jackson! If you are using Jackson already for building your REST API controllers so why not to use it for making the serialization. No need for external compopnents like: Gson or XStream.

The solution with Jackson:

Serialization:

ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();

    try {

        jsonDesttinationIdString = ow.writeValueAsString(destinationId);

    } catch (JsonProcessingException ex) {

        throw new SpecificationException(ex.getMessage());

    }

De-serialization:

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

    }

And most important, you must use the @JsonIdentityInfo annotation:

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