Styjun

I had this problem when I had a Log4J logger as a class property, such as:

private Logger logger = Logger.getLogger(Foo.class);

This can be solved by either making the logger static or simply by moving it into the actual function(s).

If you're using Realm and you get this error, and the object giving the trouble extends RealmObject, don't forget to do realm.copyFromRealm(myObject) to create a copy without all the Realm bindings before passing through to GSON for serialization.

I'd missed doing this for just one amongst a bunch of objects being copied... took me ages to realise as the stack trace doesn't name the object class/type. Thing is, the issue is caused by a circular reference, but it's a circular reference somewhere in the RealmObject base class, not your own subclass, which makes it harder to spot!

As SLaks said StackOverflowError happen if you have circular reference in your object.

To fix it you could use TypeAdapter for your object.

For example, if you need only generate String from your object you could use adapter like this:

class MyTypeAdapter<T> extends TypeAdapter<T> 
 public T read(JsonReader reader) throws IOException 
 return null;
 

 public void write(JsonWriter writer, T obj) throws IOException 
 if (obj == null) 
 writer.nullValue();
 return;
 
 writer.value(obj.toString());
 

and register it like this:

Gson gson = new GsonBuilder()
 .registerTypeAdapter(BomItem.class, new MyTypeAdapter<BomItem>())
 .create();

or like this, if you have interface and want to use adapter for all its subclasses:

Gson gson = new GsonBuilder()
 .registerTypeHierarchyAdapter(BomItemInterface.class, new MyTypeAdapter<BomItemInterface>())
 .create();

My answer is a little bit late, but I think this question doesn't have a good solution yet. I found it originally here.

With Gson you can mark the fields you do want to be included in json with @Expose like this:

@Expose
String myString; // will be serialized as myString

and create the gson object with:

Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();

Circular references you just do not expose. That did the trick for me!

This error is common when you have a logger in your super class. As @Zar suggested before, you can use static for your logger field, but this also works:

protected final transient Logger logger = Logger.getLogger(this.getClass());

P.S. probably it will work and with @Expose annotation check more about this here: https://stackoverflow.com/a/7811253/1766166

I have the same problem. In my case the reason was that constructor of my serialized class take context variable, like this:

public MetaInfo(Context context)

When I delete this argument, error has gone.

public MetaInfo()

Edit: Sorry for my bad, this is my first answer. Thanks for your advises.

I create my own Json Converter

The main solution I used is to create a parents object set for each object reference. If a sub-reference points to existed parent object, it will discard.
Then I combine with an extra solution, limiting the reference time to avoid infinitive loop in bi-directional relationship between entities.

My description is not too good, hope it helps you guys.

This is my first contribution to Java community (solution to your problem). You can check it out ;)
There is a README.md file
https://github.com/trannamtrung1st/TSON

In Android, gson stack overflow turned out to be the declaration of a Handler. Moved it to a class that isn't being deserialized.

Based on Zar's recommendation, I made the the handler static when this happened in another section of code. Making the handler static worked as well.

BomItem refers to BOMModule (Collection<BomModule> modules), and BOMModule refers to BOMItem (Collection<BomItem> items). Gson library doesn't like circular references. Remove this circular dependency from your class. I too had faced same issue in the past with gson lib.

I had this problem occur for me when I put:

Logger logger = Logger.getLogger( this.getClass().getName() );

in my object...which made perfect sense after an hour or so of debugging!

For Android users, you cannot serialize a Bundle due to a self-reference to Bundle causing a StackOverflowError.

To serialize a bundle, register a BundleTypeAdapterFactory.

Avoid unnecessary workarounds, like setting values to null or making fields transient. The right way to do this, is to annotate one of the fields with @Expose and then tell Gson to serialize only the fields with the annotation:

private Collection<BomModule> parentModules;
@Expose
private Collection<BomModule> subModules;

...
Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();

I had a similar issue where the class had an InputStream variable which I didn't really have to persist. Hence changing it to Transient solved the issue.