Infinite Recursion with Jackson JSON and Hibernate JPA issue
Asked Answered
H

29

556

When trying to convert a JPA object that has a bi-directional association into JSON, I keep getting

org.codehaus.jackson.map.JsonMappingException: Infinite recursion (StackOverflowError)

All I found is this thread which basically concludes with recommending to avoid bi-directional associations. Does anyone have an idea for a workaround for this spring bug?

------ EDIT 2010-07-24 16:26:22 -------

Codesnippets:

Business Object 1:

@Entity
@Table(name = "ta_trainee", uniqueConstraints = {@UniqueConstraint(columnNames = {"id"})})
public class Trainee extends BusinessObject {

    @Id
    @GeneratedValue(strategy = GenerationType.TABLE)
    @Column(name = "id", nullable = false)
    private Integer id;

    @Column(name = "name", nullable = true)
    private String name;

    @Column(name = "surname", nullable = true)
    private String surname;

    @OneToMany(mappedBy = "trainee", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @Column(nullable = true)
    private Set<BodyStat> bodyStats;

    @OneToMany(mappedBy = "trainee", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @Column(nullable = true)
    private Set<Training> trainings;

    @OneToMany(mappedBy = "trainee", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @Column(nullable = true)
    private Set<ExerciseType> exerciseTypes;

    public Trainee() {
        super();
    }

    //... getters/setters ...
}

Business Object 2:

import javax.persistence.*;
import java.util.Date;

@Entity
@Table(name = "ta_bodystat", uniqueConstraints = {@UniqueConstraint(columnNames = {"id"})})
public class BodyStat extends BusinessObject {

    @Id
    @GeneratedValue(strategy = GenerationType.TABLE)
    @Column(name = "id", nullable = false)
    private Integer id;

    @Column(name = "height", nullable = true)
    private Float height;

    @Column(name = "measuretime", nullable = false)
    @Temporal(TemporalType.TIMESTAMP)
    private Date measureTime;

    @ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @JoinColumn(name="trainee_fk")
    private Trainee trainee;
}

Controller:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletResponse;
import javax.validation.ConstraintViolation;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

@Controller
@RequestMapping(value = "/trainees")
public class TraineesController {

    final Logger logger = LoggerFactory.getLogger(TraineesController.class);

    private Map<Long, Trainee> trainees = new ConcurrentHashMap<Long, Trainee>();

    @Autowired
    private ITraineeDAO traineeDAO;
     
    /**
     * Return json repres. of all trainees
     */
    @RequestMapping(value = "/getAllTrainees", method = RequestMethod.GET)
    @ResponseBody        
    public Collection getAllTrainees() {
        Collection allTrainees = this.traineeDAO.getAll();

        this.logger.debug("A total of " + allTrainees.size() + "  trainees was read from db");

        return allTrainees;
    }    
}

JPA-implementation of the trainee DAO:

@Repository
@Transactional
public class TraineeDAO implements ITraineeDAO {

    @PersistenceContext
    private EntityManager em;

    @Transactional
    public Trainee save(Trainee trainee) {
        em.persist(trainee);
        return trainee;
    }

    @Transactional(readOnly = true)
    public Collection getAll() {
        return (Collection) em.createQuery("SELECT t FROM Trainee t").getResultList();
    }
}

persistence.xml

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
             version="1.0">
    <persistence-unit name="RDBMS" transaction-type="RESOURCE_LOCAL">
        <exclude-unlisted-classes>false</exclude-unlisted-classes>
        <properties>
            <property name="hibernate.hbm2ddl.auto" value="validate"/>
            <property name="hibernate.archive.autodetection" value="class"/>
            <property name="dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect"/>
            <!-- <property name="dialect" value="org.hibernate.dialect.HSQLDialect"/>         -->
        </properties>
    </persistence-unit>
</persistence>
Hygrograph answered 24/7, 2010 at 14:0 Comment(5)
Add @Transient to Trainee.bodyStats.Chantay
As of 2017, @JsonIgnoreProperties is the cleanest solution. Check out Zammel AlaaEddine's answer for more details.Sac
How is this spring's fault??Kutaisi
https://mcmap.net/q/74531/-could-not-write-json-infinite-recursion-stackoverflowerror-nested-exception-spring-bootWasp
Maybe it will be helpful: baeldung.com/…Congregation
S
361

You may use @JsonIgnore to break the cycle (reference).

You need to import org.codehaus.jackson.annotate.JsonIgnore (legacy versions) or com.fasterxml.jackson.annotation.JsonIgnore (current versions).

Sympathetic answered 25/7, 2010 at 14:53 Comment(10)
I had the same problem and @JsonIgnore solved it. I had the method annotated with @XmlTransient which should have done the same (and worked when using Jettison). You thought you can use jaxb annotation with Jackson so why isn't this working?Whensoever
@Ben: Actually I don't know. Perhaps its support was not enabled: wiki.fasterxml.com/JacksonJAXBAnnotationsSympathetic
Since Jackson 1.6 there's a better solution: you can use two new annotations to solve infinite recursion problem without ignoring the getters/setters during serialization. See my answer below for details.Ritornello
@Sympathetic Thanks for perfect answer. Btw, I came with another solution: you can simply avoid creating getter for this value, so Spring won't be able to access it while creating JSON (but I don't think that it suits every case, so your answer is better)Elysha
All the above solutions seem need to change the domain objects by adding annotations. If I'm serialize third party classes which I have no way to modify them. How can I avoid this issue?Flavone
this solution doesn't work in some situations. In relational database with jpa, if you put @JsonIgnore you will null in "foreign key" when you update the entity...Fricke
I've also added an example bellow using @JsonView to solve the problem. For me it's the best solution among all discussed here.Humanitarian
Thanks for great solution. However I found that @JsonManagedReference, @JsonBackReference does not gives you the data associated with @OneToMany and @ManyToOne scenario, also when using @JsonIgnoreProperties does skip associated entity data. How to solve this?Messapian
@Sympathetic If I put @ jsonIgnore annotation in the child. I could not get parent object from child .when I try to take the child. why the parent object is not coming, it is ignored by @ jsonignore. tell me the way to get from child to parent and parent to child.Heliotaxis
I put this annotation on all of my OneToMany relations, and it works greatAlevin
R
810

JsonIgnoreProperties [2017 Update]:

You can now use JsonIgnoreProperties to suppress serialization of properties (during serialization), or ignore processing of JSON properties read (during deserialization). If this is not what you're looking for, please keep reading below.

(Thanks to As Zammel AlaaEddine for pointing this out).


JsonManagedReference and JsonBackReference

Since Jackson 1.6 you can use two annotations to solve the infinite recursion problem without ignoring the getters/setters during serialization: @JsonManagedReference and @JsonBackReference.

Explanation

For Jackson to work well, one of the two sides of the relationship should not be serialized, in order to avoid the infite loop that causes your stackoverflow error.

So, Jackson takes the forward part of the reference (your Set<BodyStat> bodyStats in Trainee class), and converts it in a json-like storage format; this is the so-called marshalling process. Then, Jackson looks for the back part of the reference (i.e. Trainee trainee in BodyStat class) and leaves it as it is, not serializing it. This part of the relationship will be re-constructed during the deserialization (unmarshalling) of the forward reference.

You can change your code like this (I skip the useless parts):

Business Object 1:

@Entity
@Table(name = "ta_trainee", uniqueConstraints = {@UniqueConstraint(columnNames = {"id"})})
public class Trainee extends BusinessObject {

    @OneToMany(mappedBy = "trainee", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @Column(nullable = true)
    @JsonManagedReference
    private Set<BodyStat> bodyStats;

Business Object 2:

@Entity
@Table(name = "ta_bodystat", uniqueConstraints = {@UniqueConstraint(columnNames = {"id"})})
public class BodyStat extends BusinessObject {

    @ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @JoinColumn(name="trainee_fk")
    @JsonBackReference
    private Trainee trainee;

Now it all should work properly.

If you want more informations, I wrote an article about Json and Jackson Stackoverflow issues on Keenformatics, my blog.

EDIT:

Another useful annotation you could check is @JsonIdentityInfo: using it, everytime Jackson serializes your object, it will add an ID (or another attribute of your choose) to it, so that it won't entirely "scan" it again everytime. This can be useful when you've got a chain loop between more interrelated objects (for example: Order -> OrderLine -> User -> Order and over again).

In this case you've got to be careful, since you could need to read your object's attributes more than once (for example in a products list with more products that share the same seller), and this annotation prevents you to do so. I suggest to always take a look at firebug logs to check the Json response and see what's going on in your code.

Sources:

Ritornello answered 17/8, 2013 at 12:40 Comment(21)
Thanks for clear answer. This is a more convenient solution than putting @JsonIgnore on back reference.Bono
This is definitely the right way to do it. If you do it like this on the server side because you use Jackson there, it doesnt matter what json mapper you use on the client side and you don not have to set the child to parent link manual. It just works. Thanks KurtNuclease
Nice, detailed explanation and definitely better and more descriptive approach than @JsonIgnore.Savell
Thanks! The @JsonIdentityInfo worked for cyclical references that involved multiple entities in many overlapping loops.Tica
Any idea about the problem with this? #31826122Illtimed
This is quite true BUT in my case I had to move the annotations JsonManagedReference and JsonBackReference at getters methods, at field level it didn't workCynic
I can't get this to work for the life of me. I think I have a pretty similar setup, but I've obviously got something wrong since I cannot get anything but infinite recurision errors:Copley
If the annotations are in the Entitites Class it doesn't work with Spring Data Rest. The annotations need to stay in the Projection classes, otherwise the problem remains.Grey
I have tried @JsonIdentityInfo(generator=ObjectIdGenerators.IntSequenceGenerator.class, property="@id") and it's just add @id with increasing number but doesn't remove recursion. And If I use annotations JsonManaged and JsonBack than I haven't this fields in JSON output at all.Wilbert
I have mixed @OneToMany and @ManyToOne and @JsonManagedReference position, so now it's work. @JsonManagedReference should be on @ManyToOne side and @JsonBackReference on @OneToMany side.Wilbert
Used '@JsonManagedReference' and '@JsonBackReference' , two annotations that saved me.. Thank you so much .Guipure
@Kurt Will these annotations work in bi-directional way? i.e., Trainee have BodyStat & BodyStat have Trainee?Hateful
@Kurt: Thanks man. This works for me. I was not able to understand why I was getting recursive unlimited results and browser and IDE both getting hanged.Ziguard
Does @JsonManageReference and @jsonBackReference work on @ManyToMany relationships? .... I have tried above solution but still getting infinite recursionSerow
If you still didn't quite get the jist of using @JsonIgnoreProperties on Hibernate entities, place the annotation at the top of the class and pass in the names of the fields you wish to ignore. Normally this would be the fields that are annotated with @ManyToOneAppenzell
You can not use Collection, Map, Array or enumeration as @JsonBackReference: fasterxml.github.io/jackson-annotations/javadoc/2.2.0/com/….Coinsurance
@All - Only issue with this solution is that dates are coming like "createdDate": { "epochSecond": 1565115275, "nano": 767000000 }, "lastUpdateDate": { "epochSecond": 1565115275, "nano": 767000000 },Messapian
What if I want to get "trainee_fk" in Json Response of "ta_bodystat" table response? Does Anyone Know?Hackbut
If I put @ jsonIgnore annotation in the child. I could not get parent object from child .when I try to take the child. why the parent object is not coming, it is ignored by @ jsonignore. tell me the way to get from child to parent and parent to child.Heliotaxis
@kurt what if I got this error on creating Json from DTOs not Entitys and i have got no annotation related to relation ships???could you please help me?Denunciate
Adding this won't show me the at least one time result. It completely doesn't show the resultExcite
S
361

You may use @JsonIgnore to break the cycle (reference).

You need to import org.codehaus.jackson.annotate.JsonIgnore (legacy versions) or com.fasterxml.jackson.annotation.JsonIgnore (current versions).

Sympathetic answered 25/7, 2010 at 14:53 Comment(10)
I had the same problem and @JsonIgnore solved it. I had the method annotated with @XmlTransient which should have done the same (and worked when using Jettison). You thought you can use jaxb annotation with Jackson so why isn't this working?Whensoever
@Ben: Actually I don't know. Perhaps its support was not enabled: wiki.fasterxml.com/JacksonJAXBAnnotationsSympathetic
Since Jackson 1.6 there's a better solution: you can use two new annotations to solve infinite recursion problem without ignoring the getters/setters during serialization. See my answer below for details.Ritornello
@Sympathetic Thanks for perfect answer. Btw, I came with another solution: you can simply avoid creating getter for this value, so Spring won't be able to access it while creating JSON (but I don't think that it suits every case, so your answer is better)Elysha
All the above solutions seem need to change the domain objects by adding annotations. If I'm serialize third party classes which I have no way to modify them. How can I avoid this issue?Flavone
this solution doesn't work in some situations. In relational database with jpa, if you put @JsonIgnore you will null in "foreign key" when you update the entity...Fricke
I've also added an example bellow using @JsonView to solve the problem. For me it's the best solution among all discussed here.Humanitarian
Thanks for great solution. However I found that @JsonManagedReference, @JsonBackReference does not gives you the data associated with @OneToMany and @ManyToOne scenario, also when using @JsonIgnoreProperties does skip associated entity data. How to solve this?Messapian
@Sympathetic If I put @ jsonIgnore annotation in the child. I could not get parent object from child .when I try to take the child. why the parent object is not coming, it is ignored by @ jsonignore. tell me the way to get from child to parent and parent to child.Heliotaxis
I put this annotation on all of my OneToMany relations, and it works greatAlevin
S
135

The new annotation @JsonIgnoreProperties resolves many of the issues with the other options.

@Entity

public class Material{
   ...    
   @JsonIgnoreProperties("costMaterials")
   private List<Supplier> costSuppliers = new ArrayList<>();
   ...
}

@Entity
public class Supplier{
   ...
   @JsonIgnoreProperties("costSuppliers")
   private List<Material> costMaterials = new ArrayList<>();
   ....
}

Check it out here. It works just like in the documentation:
http://springquay.blogspot.com/2016/01/new-approach-to-solve-json-recursive.html

Sapling answered 19/9, 2016 at 12:31 Comment(5)
@tero - With this approach as well we dont get data associated with the entity.Messapian
@PAA HEY PAA i think that is associated whith the entity! why you say that ?Sapling
@Sapling how do you manage the infinite recursion when you have more than 2 classes? For instance: Class A -> Class B -> Class C -> Class A. I tried with JsonIgnoreProperties without luckCopperas
@Copperas this is another problem to solve, i suggest to open a new demand for that.Sapling
+1 for the code sample, as a Jackson newbie the use of @JsonIgnoreProperties wasn't entirely clear by reading the JavaDocTadio
P
55

Also, using Jackson 2.0+ you can use @JsonIdentityInfo. This worked much better for my hibernate classes than @JsonBackReference and @JsonManagedReference, which had problems for me and did not solve the issue. Just add something like:

@Entity
@Table(name = "ta_trainee", uniqueConstraints = {@UniqueConstraint(columnNames = {"id"})})
@JsonIdentityInfo(generator=ObjectIdGenerators.IntSequenceGenerator.class, property="@traineeId")
public class Trainee extends BusinessObject {

@Entity
@Table(name = "ta_bodystat", uniqueConstraints = {@UniqueConstraint(columnNames = {"id"})})
@JsonIdentityInfo(generator=ObjectIdGenerators.IntSequenceGenerator.class, property="@bodyStatId")
public class BodyStat extends BusinessObject {

and it should work.

Practicable answered 2/12, 2013 at 21:55 Comment(4)
Can you please explain "This worked much better"? Is there a problem with managed reference?Bono
@UtkuÖzdemir I added details about @JsonIdentityInfo in my answer above.Ritornello
this is the best solution we found so far, because when we used " @JsonManagedReference" the get method successfully returned the values without any stackoverflow error. But, when we tried to save data using the post, it returned an error of 415 (unsupported media error)Glazing
I have added @JsonIdentityInfo annotation to my entities but it's not solves the recursion problem. Only @JsonBackReference and @JsonManagedReference solves, but they are remove mapped properties from JSON.Wilbert
B
19

Also, Jackson 1.6 has support for handling bi-directional references... which seems like what you are looking for (this blog entry also mentions the feature)

And as of July 2011, there is also "jackson-module-hibernate" which might help in some aspects of dealing with Hibernate objects, although not necessarily this particular one (which does require annotations).

Britishism answered 8/11, 2010 at 18:35 Comment(1)
Links are dead, do you mind updating them or editing your answer.Toast
C
14

This worked perfectly fine for me. Add the annotation @JsonIgnore on the child class where you mention the reference to the parent class.

@ManyToOne
@JoinColumn(name = "ID", nullable = false, updatable = false)
@JsonIgnore
private Member member;
Casar answered 9/6, 2015 at 21:2 Comment(3)
I think @JsonIgnore ignores this attribute from being retrieved to client side. What if i need this attribute with its child(if it has child)?Mincemeat
yeah, I have the same question. But Nobody is answering me.Heliotaxis
@KumaresanPerumal try this https://mcmap.net/q/74532/-difference-between-jsonignore-and-jsonbackreference-jsonmanagedreferenceWilliamsen
T
12

Now Jackson supports avoiding cycles without ignoring the fields:

Jackson - serialization of entities with birectional relationships (avoiding cycles)

Tequilater answered 10/4, 2012 at 3:46 Comment(0)
A
11

Working fine for me Resolve Json Infinite Recursion problem when working with Jackson

This is what I have done in oneToMany and ManyToOne Mapping

@ManyToOne
@JoinColumn(name="Key")
@JsonBackReference
private LgcyIsp Key;


@OneToMany(mappedBy="LgcyIsp ")
@JsonManagedReference
private List<Safety> safety;
Asphyxia answered 28/5, 2018 at 5:16 Comment(2)
I have used hibernate mapping in spring boot applicationAsphyxia
Hi Author, Thanks for the nice tutorials and great posts. However I found that @JsonManagedReference, @JsonBackReference does not gives you the data associated with @OneToMany and @ManyToOne scenario, also when using @JsonIgnoreProperties does skip associated entity data. How to solve this?Messapian
H
8

For me the best solution is to use @JsonView and create specific filters for each scenario. You could also use @JsonManagedReference and @JsonBackReference, however it is a hardcoded solution to only one situation, where the owner always references the owning side, and never the opposite. If you have another serialization scenario where you need to re-annotate the attribute differently, you will not be able to.

Problem

Lets use two classes, Company and Employee where you have a cyclic dependency between them:

public class Company {

    private Employee employee;

    public Company(Employee employee) {
        this.employee = employee;
    }

    public Employee getEmployee() {
        return employee;
    }
}

public class Employee {

    private Company company;

    public Company getCompany() {
        return company;
    }

    public void setCompany(Company company) {
        this.company = company;
    }
}

And the test class that tries to serialize using ObjectMapper (Spring Boot):

@SpringBootTest
@RunWith(SpringRunner.class)
@Transactional
public class CompanyTest {

    @Autowired
    public ObjectMapper mapper;

    @Test
    public void shouldSaveCompany() throws JsonProcessingException {
        Employee employee = new Employee();
        Company company = new Company(employee);
        employee.setCompany(company);

        String jsonCompany = mapper.writeValueAsString(company);
        System.out.println(jsonCompany);
        assertTrue(true);
    }
}

If you run this code, you'll get the:

org.codehaus.jackson.map.JsonMappingException: Infinite recursion (StackOverflowError)

Solution Using `@JsonView`

@JsonView enables you to use filters and choose what fields should be included while serializing the objects. A filter is just a class reference used as a identifier. So let's first create the filters:

public class Filter {

    public static interface EmployeeData {};

    public static interface CompanyData extends EmployeeData {};

} 

Remember, the filters are dummy classes, just used for specifying the fields with the @JsonView annotation, so you can create as many as you want and need. Let's see it in action, but first we need to annotate our Company class:

public class Company {

    @JsonView(Filter.CompanyData.class)
    private Employee employee;

    public Company(Employee employee) {
        this.employee = employee;
    }

    public Employee getEmployee() {
        return employee;
    }
}

and change the Test in order for the serializer to use the View:

@SpringBootTest
@RunWith(SpringRunner.class)
@Transactional
public class CompanyTest {

    @Autowired
    public ObjectMapper mapper;

    @Test
    public void shouldSaveCompany() throws JsonProcessingException {
        Employee employee = new Employee();
        Company company = new Company(employee);
        employee.setCompany(company);

        ObjectWriter writter = mapper.writerWithView(Filter.CompanyData.class);
        String jsonCompany = writter.writeValueAsString(company);

        System.out.println(jsonCompany);
        assertTrue(true);
    }
}

Now if you run this code, the Infinite Recursion problem is solved, because you have explicitly said that you just want to serialize the attributes that were annotated with @JsonView(Filter.CompanyData.class).

When it reaches the back reference for company in the Employee, it checks that it's not annotated and ignore the serialization. You also have a powerful and flexible solution to choose which data you want to send through your REST APIs.

With Spring you can annotate your REST Controllers methods with the desired @JsonView filter and the serialization is applied transparently to the returning object.

Here are the imports used in case you need to check:

import static org.junit.Assert.assertTrue;

import javax.transaction.Transactional;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;

import com.fasterxml.jackson.annotation.JsonView;
Humanitarian answered 18/7, 2017 at 21:47 Comment(1)
This is a nice article explaining many alternative solutions to solve recursions: baeldung.com/…Sair
M
8

@JsonIgnoreProperties is the answer.

Use something like this ::

@OneToMany(mappedBy = "course",fetch=FetchType.EAGER)
@JsonIgnoreProperties("course")
private Set<Student> students;
Monumentalize answered 2/5, 2018 at 0:45 Comment(2)
Use this confidently as I have seen Jhipster uses this in its generated codeMonumentalize
Thanks for the answer. However I found that @JsonManagedReference, @JsonBackReference does not gives you the data associated with @OneToMany and @ManyToOne scenario, also when using @JsonIgnoreProperties does skip associated entity data. How to solve this?Messapian
J
7

There's now a Jackson module (for Jackson 2) specifically designed to handle Hibernate lazy initialization problems when serializing.

https://github.com/FasterXML/jackson-datatype-hibernate

Just add the dependency (note there are different dependencies for Hibernate 3 and Hibernate 4):

<dependency>
  <groupId>com.fasterxml.jackson.datatype</groupId>
  <artifactId>jackson-datatype-hibernate4</artifactId>
  <version>2.4.0</version>
</dependency>

and then register the module when intializing Jackson's ObjectMapper:

ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new Hibernate4Module());

Documentation currently isn't great. See the Hibernate4Module code for available options.

Japeth answered 14/12, 2014 at 4:50 Comment(1)
What problem does is solve then, because it looks interesting. I have the same issue as the OP and all the tricks including above haven't worked.Kyte
B
6

You Should use @JsonBackReference with @ManyToOne entity and @JsonManagedReference with @onetomany containing entity classes.

@OneToMany(
            mappedBy = "queue_group",fetch = FetchType.LAZY,
            cascade = CascadeType.ALL
        )
    @JsonManagedReference
    private Set<Queue> queues;



@ManyToOne(cascade=CascadeType.ALL)
        @JoinColumn(name = "qid")
       // @JsonIgnore
        @JsonBackReference
        private Queue_group queue_group;
Bullough answered 13/8, 2019 at 9:35 Comment(3)
If I put @ jsonIgnore annotation in the child. I could not get parent object from child .when I try to take the child. why the parent object is not coming, it is ignored by @ jsonignore. tell me the way to get from child to parent and parent to child.Heliotaxis
No need of Using @JsonIgnore just use the above annotations and For getting objets of parent and child By using Getters and setters. and Jsonignore is also doing the same but it will create infinite recursion. If You share your code then i can check why You are not getting objects. Because for me both are coming.Bullough
I meant to say. when taking a parent. The parent should come with child object. when taking child object. The child should come with a parent. It is not working in this scenario. could you please help me?Heliotaxis
R
6

VERY IMPORTANT: If you are using LOMBOK, make shure to exclude attributes of collections like Set, List, etc...

Like this:

@EqualsAndHashCode(exclude = {"attributeOfTypeList", "attributeOfTypeSet"})
Rottweiler answered 14/8, 2020 at 16:2 Comment(0)
D
5

In my case it was enough to change relation from:

@OneToMany(mappedBy = "county")
private List<Town> towns;

to:

@OneToMany
private List<Town> towns;

another relation stayed as it was:

@ManyToOne
@JoinColumn(name = "county_id")
private County county;
Dezhnev answered 29/8, 2014 at 17:31 Comment(2)
I think its better to use Kurt's solution. Because the JoinColumn solution can end in unreferenced data dead bodies.Nuclease
This is actually the only thing that helped me. No other solutions from the top worked. I am still not sure why...Diagnostician
K
5

I also met the same problem. I used @JsonIdentityInfo's ObjectIdGenerators.PropertyGenerator.class generator type.

That's my solution:

@Entity
@Table(name = "ta_trainee", uniqueConstraints = {@UniqueConstraint(columnNames = {"id"})})
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
public class Trainee extends BusinessObject {
...
Koerlin answered 14/3, 2018 at 14:39 Comment(0)
L
4

Be sure you use com.fasterxml.jackson everywhere. I spent much time to find it out.

<properties>
  <fasterxml.jackson.version>2.9.2</fasterxml.jackson.version>
</properties>

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>${fasterxml.jackson.version}</version>
</dependency>

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>${fasterxml.jackson.version}</version>
</dependency>

Then use @JsonManagedReference and @JsonBackReference.

Finally, you can serialize your model to JSON:

import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(model);
Langley answered 1/9, 2016 at 11:41 Comment(0)
C
4

You can use @JsonIgnore, but this will ignore the json data which can be accessed because of the Foreign Key relationship. Therefore if you reqiure the foreign key data (most of the time we require), then @JsonIgnore will not help you. In such situation please follow the below solution.

you are getting Infinite recursion, because of the BodyStat class again referring the Trainee object

BodyStat

@ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
@JoinColumn(name="trainee_fk")
private Trainee trainee;

Trainee

@OneToMany(mappedBy = "trainee", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
@Column(nullable = true)
private Set<BodyStat> bodyStats;

Therefore, you have to comment/omit the above part in Trainee

Campanulate answered 27/3, 2018 at 14:28 Comment(1)
In my case, its not working. Could you please take a look: github.com/JavaHelper/issue-jackson-boot ?Messapian
C
3

I have the same problem after doing more analysis i came to know that, we can get mapped entity also by just keeping @JsonBackReference at OneToMany annotation

@Entity
@Table(name = "ta_trainee", uniqueConstraints = {@UniqueConstraint(columnNames = {"id"})})
public class Trainee extends BusinessObject {

@Id
@GeneratedValue(strategy = GenerationType.TABLE)
@Column(name = "id", nullable = false)
private Integer id;

@Column(name = "name", nullable = true)
private String name;

@Column(name = "surname", nullable = true)
private String surname;

@OneToMany(mappedBy = "trainee", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
@Column(nullable = true)
@JsonBackReference
private Set<BodyStat> bodyStats;
Corinacorine answered 23/7, 2020 at 2:24 Comment(0)
O
2

you can use DTO pattern create class TraineeDTO without any anotation hiberbnate and you can use jackson mapper to convert Trainee to TraineeDTO and bingo the error message disapeare :)

Orchardist answered 20/8, 2015 at 15:0 Comment(1)
Can you show an example?Curiel
S
2

If you cannot ignore the property, try modifying the visibility of the field. In our case, we had old code still submitting entities with the relationship, so in my case, this was the fix:

    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    private Trainee trainee;
Sibylsibylla answered 26/3, 2019 at 2:35 Comment(1)
If I put @ jsonIgnore annotation in the child. I could not get parent object from child .when I try to take the child. why the parent object is not coming, it is ignored by @ jsonignore. tell me the way to get from child to parent and parent to child.Heliotaxis
B
2

For some reason, in my case, it wasn't working with Set. I had to change it to List and use @JsonIgnore and @ToString.Exclude to get it working.

Replace Set with List:

//before
@OneToMany(mappedBy="client")
private Set<address> addressess;

//after
@OneToMany(mappedBy="client")
private List<address> addressess;

And add @JsonIgnore and @ToString.Exclude annotations:

@ManyToOne
@JoinColumn(name="client_id", nullable = false)
@JsonIgnore
@ToString.Exclude
private Client client;
Biceps answered 17/7, 2020 at 14:15 Comment(1)
What is the dependency to be used for @ToString?Elviraelvis
K
2

If you use @JsonManagedReference, @JsonBackReference or @JsonIgnore annotation it ignore some fields and solve Infinite Recursion with Jackson JSON.

But if you use @JsonIdentityInfo which also avoid the Infinite Recursion and you can get all the fields values, so I suggest that you use @JsonIdentityInfo annotation.

@JsonIdentityInfo(generator= ObjectIdGenerators.UUIDGenerator.class, property="@id")

Refer this article https://www.toptal.com/javascript/bidirectional-relationship-in-json to get good understanding about @JsonIdentityInfo annotation.

Kenneth answered 24/2, 2021 at 18:40 Comment(0)
D
2

This post: https://www.baeldung.com/jackson-bidirectional-relationships-and-infinite-recursion has a full explanation.

If you are using Jackson with older versions, you can try @jsonmanagedreference + @jsonbackreference. If your Jackson is above 2 (1.9 also doesn't work as I know), try @JsonIdentityInfo instead.

Dunning answered 25/7, 2021 at 18:17 Comment(0)
A
1

As someone using Spring Data and Lombok, this is how I solved it for myself.

@Entity
@Data
public class Foo extends BaseEntity {

    @OneToMany(fetch = FetchType.EAGER)
    @JoinColumn(name = "foo_id")
    @JsonIgnoreProperties("parent_foo")
    @EqualsAndHashCode.Exclude
    private Set<Bar> linkedBars;
}

@Entity
@Data
public class Bar extends BaseEntity {

    @Column(name = "foo_id")
    private Long parentFooId;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "foo_id", insertable = false, updatable = false)
    @JsonIgnoreProperties({"linkedBars"})
    private Foo parentFoo;
}

The JsonIgnoreProperties annotation stops infinite recursion as many answers have discussed above.

@EqualsAndHashCode.Exclude prevents the StackOverflowError caused by hashCode and equals being called recursively.

Using Set over List resolves the MultipleBagFetchException which occurs when you add multiple collection fields. You can also use @Fetch(value = FetchMode.SUBSELECT) to avoid the cartesian product, but I haven't tried it personally since my use case didn't need it.

The explicit definition of parentFooId in Bar is to allow mapping Foo entities with Bars.

Appendectomy answered 6/1, 2023 at 9:24 Comment(0)
C
0

I had this problem, but I didn't want to use annotation in my entities, so I solved by creating a constructor for my class, this constructor must not have a reference back to the entities who references this entity. Let's say this scenario.

public class A{
   private int id;
   private String code;
   private String name;
   private List<B> bs;
}

public class B{
   private int id;
   private String code;
   private String name;
   private A a;
}

If you try to send to the view the class B or A with @ResponseBody it may cause an infinite loop. You can write a constructor in your class and create a query with your entityManager like this.

"select new A(id, code, name) from A"

This is the class with the constructor.

public class A{
   private int id;
   private String code;
   private String name;
   private List<B> bs;

   public A(){
   }

   public A(int id, String code, String name){
      this.id = id;
      this.code = code;
      this.name = name;
   }

}

However, there are some constrictions about this solution, as you can see, in the constructor I did not make a reference to List bs this is because Hibernate does not allow it, at least in version 3.6.10.Final, so when I need to show both entities in a view I do the following.

public A getAById(int id); //THE A id

public List<B> getBsByAId(int idA); //the A id.

The other problem with this solution, is that if you add or remove a property you must update your constructor and all your queries.

Countermand answered 30/11, 2015 at 20:20 Comment(0)
B
0

In case you are using Spring Data Rest, issue can be resolved by creating Repositories for every Entity involved in cyclical references.

Blinking answered 20/4, 2016 at 20:54 Comment(0)
R
0

I'm a late comer and it's such a long thread already. But I spent a couple of hours trying to figure this out too, and would like to give my case as another example.

I tried both JsonIgnore, JsonIgnoreProperties and BackReference solutions, but strangely enough it was like they weren't picked up.

I used Lombok and thought that maybe it interferes, since it creates constructors and overrides toString (saw toString in stackoverflowerror stack).

Finally it wasn't Lombok's fault - I used automatic NetBeans generation of JPA entities from database tables, without giving it much thought - well, and one of the annotations that were added to the generated classes was @XmlRootElement. Once I removed it everything started working. Oh well.

Rajasthani answered 12/5, 2020 at 14:52 Comment(0)
C
0

The point is to place the @JsonIgnore in the setter method as follow. in my case.

Township.java

@Access(AccessType.PROPERTY)
@OneToMany(fetch = FetchType.LAZY)
@JoinColumn(name="townshipId", nullable=false ,insertable=false, updatable=false)
public List<Village> getVillages() {
    return villages;
}

@JsonIgnore
@Access(AccessType.PROPERTY)
public void setVillages(List<Village> villages) {
    this.villages = villages;
}

Village.java

@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "townshipId", insertable=false, updatable=false)
Township township;

@Column(name = "townshipId", nullable=false)
Long townshipId;
Cecum answered 8/6, 2020 at 11:0 Comment(0)
F
0

I have faced same issue, add jsonbackref and jsonmanagedref and please make sure @override equals and hashCode methods , this definitely fix this issue.

Farceuse answered 2/12, 2020 at 2:8 Comment(0)

© 2022 - 2024 — McMap. All rights reserved.