I have two entities: Order and Item in a OneToMany relationship. Item belongs an Order, and the Order has a set of Items.
class Order{
#OneToMany(fetch = FetchType.EAGER, mappedBy = "id_order")
Set<Item> items;
}
class Item{
#ManyToOne(targetEntity = Order.class, fetch = FetchType.LAZY)
#JoinColumn(name = "id_order")
Order id_order;
}
I use gson to serialize Orders and send them to another machine, but a loop is being created during serialization, due to both orders and items having a reference to each other.
My goal is that when an Item is loaded, the field id_order should either be null or contain only the id, to avoid propagation. Does hibernate support this feature? Or can I exclude the field during serialization?
I already tried FetchType.LAZY on Item and catching Item inside an onLoad() Interceptor and setting its id_order to null. But it didn't work. I am trying to avoid writing a custom adapter or manually parsing all Items inside all Orders at every query.
I believe it has not much with Hibernate, but more with GSON. You should define serialization/deserialization rule.
Easiest way is to use #Expose annotation, to include/exclude given property from serialization/deserialization:
#Expose(serialize = false, deserialize = false)
Another way is to define custom adapters for givem class. WIth Adapter you can completely override the way GSON serialize or deserialize object.
For example:
public class YourAdapter implements JsonDeserializer<Order>, JsonSerializer<Order> {
#Override
public Orderde serialize(JsonElement jsonElement, Type type, JsonDeserializationContext jsonDeserializationContext) throws JsonParseException {
// your logic
}
#Override
public JsonElement serialize(Ordersrc, Type typeOfSrc, JsonSerializationContext context) {
// your logic
}
}
Finally initialize instance of your Gson parser:
Gson gson = new GsonBuilder()
.registerTypeAdapter(Order.class, new YourAdapter())
.build();
If you want to avoid writting whole serialization, you could exclude your field by using #Expose, and then write adapter with pure instance of GSON in it, serialize/deserialize using that pure one and manually add that one field.
Another way of dealing with serialization/deserialization problem is to use ExclusionStrategy described here: https://google-gson.googlecode.com/svn/trunk/gson/docs/javadocs/com/google/gson/ExclusionStrategy.html
I know this doesnt answer the question derectly but might help others, GSON has an option to exclude based on a vairiables modifier.
Gson gson = new GsonBuilder().excludeFieldsWithModifiers(Modifier.PRIVATE).create();
I have custom Entity that i want to put as Json to my view page
But when i serialize it in map using ObjectMapper from Jackson i receive String created from toString() method
#Test
public void test() throws JsonProcessingException {
Map<ProductEntity, Integer> map = new HashMap<ProductEntity, Integer>();
ProductEntity prod = new ProductEntity();
prod.setIdProduct(1);
map.put(prod, 1);
ObjectMapper mapper = new ObjectMapper();
System.out.println(mapper.writeValueAsString(map));
}
Received: {"com.onlineshop.entity.ProductEntity#2":1}
where "com.onlineshop.entity.ProductEntity#2" is a String, not an object.
So how can i make it to be an Object?
I need exactly Map, not another type of Collection
You either need to annotate your ProductEntity object so Jackson knows how to serialize it or use a Mix In annotation if you are not able to modify the ProductEntity class. IIRC there are also global Jackson options you can set that tell it how to handle POJOs.
Since you didn't specify which version of Jackson you're using I can't link to the correct documents but there is a ton of information available on the Jackson sites on how to use annotations and mix ins.
Thanks to all for your answers.
I solved it by creating new DTO which contains :
private ProductEntity
private Integer
fields.
First time on here but long time reader... Been spinning my wheels on this and having a tough time finding a way to complete something using Jackson and Wink to desearlize a set of Objects that are sent over. For some reason the HashSet in this can't be cast properly. Here is an example: I have an Object Foo which is an entity in the DAO. I can serealize and deseralize a singel Foo object, which contains Sets and List and etc, no problem. Here is my
Foo object:
[{"uuid":"1","version":1,"salutation":null,"firstName":"Random1","lastName":"Dude1"},
{"uuid":"2","version":1,"salutation":null,"firstName":"Random2","lastName":"Dude2"}]
What I have been trying to do is this in a Rest service using Wink and Jackson. Example below:
#Resource
BarManager barManager
#PUT
#Path("{id}")
#Produces(MediaType.APPLICATION_JSON)
#Consumes(MediaType.APPLICATION_JSON)
public Bar addFoosForBar(#PathParam("id") String id, Set<Foo> foos) {
Bar bar = barManager.getById(id);
bar.addFoos(foos);
return barManager.update(bar);
}
This is example code and barManager.getById(id) is a find resource(#Resource annotated) the retrieves Bar objects. The "addFoos" methods adds a set of Foo to Bar or in this case adding foos to the lookuped bar. In this code foos in the rest service come back and I can inspect the foos and it looks exactly like the json object but I get an exception “java.lang.ClassCastException: java.util.LinkedHashMap cannot be cast to com.model.Foo” when I try to use foos as a set, i.e. try to iterate through etc.
My question is can Jackson deserialize a set of Objects that are Entities or do you have to define a separate Object type that is a set of Entities just specifically as a map for Jackson to use? To sum it up, how does Jackson take into account HashSets of defined objects for deserialization? Having trouble lighting a fuse on a direction to take on this one because it should be straight forward that I just want to deserialize the set and be able to manipulate it in the rest service as POJO.
Here is what I did to be able to deserlize sets of known entities in Jackson. used ObjectMapper and defined on each rest services as below example:
#Resource
BarManager barManager
ObjectMapper mapper = new ObjectMapper();
#PUT
#Path("{id}")
#Produces(MediaType.APPLICATION_JSON)
#Consumes(MediaType.APPLICATION_JSON)
public Bar addFoosForBar(#PathParam("id") String id, String foos) {
HashSet<foos> foosSet = null;
JavaType javaType = mapper.getTypeFactory().constructParametricType(HashSet.class, Foo.class);
try {
fooSet = mapper.readValue(foos, javaType);
} catch (IOException e) {
e.printStackTrace();
}
Bar bar = barManager.getById(id);
bar.addFoos(foos);
return barManager.update(bar);
}
Not the greatest work but will do the trick on making sets, lists, and whatever on a known defined class with a constructor for Jackson. Hope this helps someone.
My object graph consists of Hibernate entities. Now most of the objects don't exist in the new database. However some do. So my object is like this:
Class MyObject{
Set<B> bset;
Set<C> cset;
}
The items in bset need to be instantiated and persisted after deserialization. However, the items in cset already exist in the new database, so I don't want new instances created. What is the best way to tell Jackson I know how to find references to these? Right now I am thinking about using a custom serializer / deserializer for cset, which will serialize it by creating an object with the database ID, and then will deserialize it by pulling the appropriate objects out of the database.
This is kind of complicated and I am hoping there is a simpler solution. Any suggestions?
Figured it out. There are three things I needed:
A JsonCreator to take the entityManager, and the id to return an object
#JsonCreator
#IgnoredMethod
public static UiElement findById(#JacksonInject EntityManager entityManager, #JsonProperty("id") int id) {
return entityManager.find(UiElement.class, id);
}
A JsonValue getter to return an object with only the id
#JsonValue
#Transient
public Map<String,Integer> getJsonObject(){
HashMap<String,Integer> map = new HashMap<String,Integer>();
map.put("id", getId());
return map;
}
The entity manager needed to be injected into the ObjectMapper
//entitymanager for creating any static data based entities
InjectableValues injects = new InjectableValues.Std().addValue(EntityManager.class, entityManager);
mapper.setInjectableValues(injects);
I would like to generate a JSON String from my object:
Gson gson = new Gson();
String json = gson.toJson(item);
Everytime I try to do this, I get this error:
14:46:40,236 ERROR [[BomItemToJSON]] Servlet.service() for servlet BomItemToJSON threw exception
java.lang.StackOverflowError
at com.google.gson.stream.JsonWriter.string(JsonWriter.java:473)
at com.google.gson.stream.JsonWriter.writeDeferredName(JsonWriter.java:347)
at com.google.gson.stream.JsonWriter.value(JsonWriter.java:440)
at com.google.gson.internal.bind.TypeAdapters$7.write(TypeAdapters.java:235)
at com.google.gson.internal.bind.TypeAdapters$7.write(TypeAdapters.java:220)
at com.google.gson.internal.bind.TypeAdapterRuntimeTypeWrapper.write(TypeAdapterRuntimeTypeWrapper.java:68)
at com.google.gson.internal.bind.ReflectiveTypeAdapterFactory$1.write(ReflectiveTypeAdapterFactory.java:89)
at com.google.gson.internal.bind.ReflectiveTypeAdapterFactory$Adapter.write(ReflectiveTypeAdapterFactory.java:200)
at com.google.gson.internal.bind.TypeAdapterRuntimeTypeWrapper.write(TypeAdapterRuntimeTypeWrapper.java:68)
at com.google.gson.internal.bind.CollectionTypeAdapterFactory$Adapter.write(CollectionTypeAdapterFactory.java:96)
at com.google.gson.internal.bind.CollectionTypeAdapterFactory$Adapter.write(CollectionTypeAdapterFactory.java:60)
at com.google.gson.Gson$FutureTypeAdapter.write(Gson.java:843)
These are the attributes of my BomItem class:
private int itemId;
private Collection<BomModule> modules;
private boolean deprecated;
private String partNumber;
private String description; //LOB
private int quantity;
private String unitPriceDollar;
private String unitPriceEuro;
private String discount;
private String totalDollar;
private String totalEuro;
private String itemClass;
private String itemType;
private String vendor;
private Calendar listPriceDate;
private String unitWeight;
private String unitAveragePower;
private String unitMaxHeatDissipation;
private String unitRackSpace;
Attributes of my referenced BomModule class:
private int moduleId;
private String moduleName;
private boolean isRootModule;
private Collection<BomModule> parentModules;
private Collection<BomModule> subModules;
private Collection<BomItem> items;
private int quantity;
Any idea what causes this error? How can I fix it?
That problem is that you have a circular reference.
In the BomModule class you are referencing to:
private Collection<BomModule> parentModules;
private Collection<BomModule> subModules;
That self reference to BomModule, obviously, not liked by GSON at all.
A workaround is just set the modules to null to avoid the recursive looping. This way I can avoid the StackOverFlow-Exception.
item.setModules(null);
Or mark the fields you don't want to show up in the serialized json by using the transient keyword, eg:
private transient Collection<BomModule> parentModules;
private transient Collection<BomModule> subModules;
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
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.
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!
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.
After some time fighting with this issue, I believe i have a solution.
Problem is in unresolved bidirectional connections, and how to represent connections when they are being serialized.
The way to fix that behavior is to "tell" gson how to serialize objects. For that purpose we use Adapters.
By using Adapters we can tell gson how to serialize every property from your Entity class as well as which properties to serialize.
Let Foo and Bar be two entities where Foo has OneToMany relation to Bar and Bar has ManyToOne relation to Foo. We define Bar adapter so when gson serializes Bar, by defining how to serialize Foo from perspective of Bar cyclic referencing will not be possible.
public class BarAdapter implements JsonSerializer<Bar> {
#Override
public JsonElement serialize(Bar bar, Type typeOfSrc, JsonSerializationContext context) {
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("id", bar.getId());
jsonObject.addProperty("name", bar.getName());
jsonObject.addProperty("foo_id", bar.getFoo().getId());
return jsonObject;
}
}
Here foo_id is used to represent Foo entity which would be serialized and which would cause our cyclic referencing problem. Now when we use adapter Foo will not be serialized again from Bar only its id will be taken and put in JSON.
Now we have Bar adapter and we can use it to serialize Foo. Here is idea:
public String getSomething() {
//getRelevantFoos() is some method that fetches foos from database, and puts them in list
List<Foo> fooList = getRelevantFoos();
GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.registerTypeAdapter(Bar.class, new BarAdapter());
Gson gson = gsonBuilder.create();
String jsonResponse = gson.toJson(fooList);
return jsonResponse;
}
One more thing to clarify, foo_id is not mandatory and it can be skipped. Purpose of adapter in this example is to serialize Bar and by putting foo_id we showed that Bar can trigger ManyToOne without causing Foo to trigger OneToMany again...
Answer is based on personal experience, therefore feel free to comment, to prove me wrong, to fix mistakes, or to expand answer. Anyhow I hope someone will find this answer useful.