Ricorsione infinita con Jackson JSON e Hibernate JPA

Quando provo a convertire un oggetto JPA che ha un'associazione bidirezionale in JSON, continuo a ottenere

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

Tutto quello che ho trovato è questa discussione che sostanzialmente si conclude con la raccomandazione di evitare le associazioni bidirezionali. Qualcuno ha un'idea per una soluzione alternativa per questo bug di primavera?

------ MODIFICA 24/07/2010 16:26:22 -------

Frammenti di codice:

Oggetto aziendale 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 ...

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

Implementazione dell'APP del tirocinante 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>

È possibile utilizzare @JsonIgnoreper interrompere il ciclo.

JsonIgnoreProperties [aggiornamento 2017]:

Ora è possibile utilizzare JsonIgnoreProperties per eliminare la serializzazione delle proprietà (durante la serializzazione) o ignorare l'elaborazione delle proprietà JSON lette (durante la deserializzazione) . Se questo non è quello che stai cercando, continua a leggere di seguito.

(Grazie a As Zammel AlaaEddine per averlo segnalato).

JsonManagedReference e JsonBackReference

Da Jackson 1.6 è possibile utilizzare due annotazioni per risolvere il problema della ricorsione infinita senza ignorare i getter / setter durante la serializzazione: @JsonManagedReferencee @JsonBackReference.

Spiegazione

Perché Jackson funzioni bene, uno dei due lati della relazione non dovrebbe essere serializzato, al fine di evitare il ciclo di infite che causa l'errore dello stackoverflow.

Quindi, Jackson prende la parte anteriore del riferimento (il tuo Set<BodyStat> bodyStatsin classe Trainee) e lo converte in un formato di archiviazione simile a json; questo è il cosiddetto processo di marshalling . Quindi, Jackson cerca la parte posteriore del riferimento (cioè Trainee traineenella classe BodyStat) e la lascia così com'è, non serializzandola. Questa parte della relazione verrà ricostruita durante la deserializzazione ( unmarshalling ) del riferimento in avanti.

Puoi modificare il tuo codice in questo modo (salto le parti inutili):

Oggetto aziendale 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;

Oggetto aziendale 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;

Ora dovrebbe funzionare tutto correttamente.

Se vuoi maggiori informazioni, ho scritto un articolo sui problemi di Stackoverflow di Json e Jackson su Keenformatics , il mio blog.

MODIFICARE:

Un'altra utile annotazione che potresti controllare è @JsonIdentityInfo : usandola, ogni volta che Jackson serializza il tuo oggetto, aggiungerà un ID (o un altro attributo di tua scelta), in modo che non lo "scansionerà" di nuovo ogni volta. Questo può essere utile quando hai un anello a catena tra più oggetti correlati (ad esempio: Ordine -> OrdineLinea -> Utente -> Ordine e ancora).

In questo caso devi stare attento, poiché potresti dover leggere più volte gli attributi del tuo oggetto (ad esempio in un elenco di prodotti con più prodotti che condividono lo stesso venditore) e questa annotazione ti impedisce di farlo. Suggerisco di dare sempre un'occhiata ai log di firebug per verificare la risposta di Json e vedere cosa sta succedendo nel tuo codice.

fonti:

• Keenformatics - How To Solve JSON ricorsione infinita Stackoverflow (il mio blog)
• Riferimenti di Jackson
• Esperienza personale

La nuova annotazione @JsonIgnoreProperties risolve molti problemi con le altre opzioni.

@Entity

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

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

Controllalo qui. Funziona proprio come nella documentazione:
http://springquay.blogspot.com/2016/01/new-approach-to-solve-json-recursive.html

Inoltre, utilizzando Jackson 2.0+ è possibile utilizzare @JsonIdentityInfo. Questo ha funzionato molto meglio per le mie lezioni in letargo rispetto a @JsonBackReferencee @JsonManagedReference, che ha avuto problemi per me e non ha risolto il problema. Aggiungi qualcosa come:

@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 {

e dovrebbe funzionare.

Inoltre, Jackson 1.6 ha il supporto per la gestione di riferimenti bidirezionali ... che sembra quello che stai cercando ( questo articolo del blog menziona anche la funzione)

E a partire da luglio 2011, esiste anche " jackson-module-hibernate " che potrebbe aiutare in alcuni aspetti della gestione degli oggetti di Hibernate, sebbene non necessariamente questo particolare (che richiede annotazioni).

Ora Jackson supporta evitando cicli senza ignorare i campi:

Jackson - serializzazione di entità con relazioni birectional (evitando cicli)

Questo ha funzionato perfettamente per me. Aggiungi l'annotazione @JsonIgnore sulla classe figlio in cui menzioni il riferimento alla classe padre.

@ManyToOne
@JoinColumn(name = "ID", nullable = false, updatable = false)
@JsonIgnore
private Member member;

Ora c'è un modulo Jackson (per Jackson 2) appositamente progettato per gestire i problemi di inizializzazione lenta di Hibernate durante la serializzazione.

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

Basta aggiungere la dipendenza (si noti che esistono diverse dipendenze per Hibernate 3 e Hibernate 4):

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

e quindi registra il modulo durante l'inizializzazione dell'ObjectMapper di Jackson:

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

La documentazione al momento non è eccezionale. Vedi il codice Hibernate4Module per le opzioni disponibili.

Funzionando bene per me Risolvi il problema della ricorsione infinita Json quando lavori con Jackson

Questo è ciò che ho fatto in oneToMany e ManyToOne Mapping

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


@OneToMany(mappedBy="LgcyIsp ")
@JsonManagedReference
private List<Safety> safety;

Per me la soluzione migliore è utilizzare @JsonViewe creare filtri specifici per ogni scenario. Puoi anche usare @JsonManagedReferencee @JsonBackReference, tuttavia, è una soluzione hardcoded per una sola situazione, in cui il proprietario fa sempre riferimento al lato proprietario e mai il contrario. Se si dispone di un altro scenario di serializzazione in cui è necessario annotare nuovamente l'attributo in modo diverso, non sarà possibile.

Problema

Consente di utilizzare due classi Companye in Employeecui esiste una dipendenza ciclica tra di loro:

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

E la classe di test che tenta di serializzare utilizzando 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);
    }
}

Se esegui questo codice, otterrai:

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

Soluzione usando `@ JsonView`

@JsonViewconsente di utilizzare i filtri e scegliere quali campi devono essere inclusi durante la serializzazione degli oggetti. Un filtro è solo un riferimento di classe utilizzato come identificatore. Quindi prima creiamo i filtri:

public class Filter {

    public static interface EmployeeData {};

    public static interface CompanyData extends EmployeeData {};

} 

Ricorda, i filtri sono classi fittizie, utilizzate solo per specificare i campi con l' @JsonViewannotazione, in modo da poterne creare quanti ne desideri e di cui hai bisogno. Vediamolo in azione, ma prima dobbiamo annotare la nostra Companyclasse:

public class Company {

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

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

    public Employee getEmployee() {
        return employee;
    }
}

e modificare il test affinché il serializzatore utilizzi la vista:

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

Ora, se si esegue questo codice, il problema della ricorsione infinita viene risolto, poiché è stato esplicitamente affermato che si desidera solo serializzare gli attributi con cui sono stati annotati @JsonView(Filter.CompanyData.class).

Quando raggiunge il riferimento posteriore per la società in Employee, verifica che non sia annotato e ignora la serializzazione. Hai anche una soluzione potente e flessibile per scegliere quali dati vuoi inviare tramite le tue API REST.

Con Spring è possibile annotare i metodi dei controller REST con il @JsonViewfiltro desiderato e la serializzazione viene applicata in modo trasparente all'oggetto restituito.

Ecco le importazioni utilizzate nel caso sia necessario verificare:

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;

@JsonIgnoreProperties è la risposta.

Usa qualcosa del genere ::

@OneToMany(mappedBy = "course",fetch=FetchType.EAGER)
@JsonIgnoreProperties("course")
private Set<Student> students;

Nel mio caso è stato sufficiente cambiare la relazione da:

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

per:

@OneToMany
private List<Town> towns;

un'altra relazione rimase com'era:

@ManyToOne
@JoinColumn(name = "county_id")
private County county;

Assicurati di usare com.fasterxml.jackson ovunque. Ho trascorso molto tempo a scoprirlo.

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

Quindi utilizzare @JsonManagedReferencee @JsonBackReference.

Infine, puoi serializzare il tuo modello su JSON:

import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(model);

È possibile utilizzare @JsonIgnore , ma questo ignorerà i dati json a cui è possibile accedere a causa della relazione Chiave esterna. Pertanto, se richiedi i dati della chiave esterna (il più delle volte che richiediamo), @JsonIgnore non ti aiuterà. In tale situazione, seguire la soluzione seguente.

stai ricevendo una ricorsione infinita, a causa della classe BodyStat che fa nuovamente riferimento all'oggetto Trainee

Bodystat

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

apprendista

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

Pertanto, devi commentare / omettere la parte sopra in Tirocinante

Ho anche incontrato lo stesso problema. Ho usato @JsonIdentityInfoil ObjectIdGenerators.PropertyGenerator.classtipo di generatore.

Questa è la mia soluzione:

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

È necessario utilizzare @JsonBackReference con l'entità @ManyToOne e @JsonManagedReference con @onetomany contenente le classi di entità.

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

puoi usare il modello DTO per creare la classe TraineeDTO senza alcuna hiberbnate di anotazione e puoi usare jackson mapper per convertire il tirocinante in TraineeDTO e bingo il messaggio di errore non essere più :)

Se non puoi ignorare la proprietà, prova a modificare la visibilità del campo. Nel nostro caso, avevamo ancora il vecchio codice che inviava entità con la relazione, quindi nel mio caso, questa era la soluzione:

    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    private Trainee trainee;

Ho avuto questo problema, ma non volevo usare l'annotazione nelle mie entità, quindi ho risolto creando un costruttore per la mia classe, questo costruttore non deve avere un riferimento alle entità che fanno riferimento a questa entità. Diciamo questo 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;
}

Se si tenta di inviare alla vista la classe Bo Acon @ResponseBodyessa può causare un ciclo infinito. Puoi scrivere un costruttore nella tua classe e creare una query con la tua entityManagercome questa.

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

Questa è la classe con il costruttore.

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

}

Tuttavia, ci sono alcune costrizioni su questa soluzione, come puoi vedere, nel costruttore non ho fatto un riferimento all'Elenco bs, perché Hibernate non lo consente, almeno nella versione 3.6.10 . Finale , quindi quando ho bisogno per mostrare entrambe le entità in una vista, faccio quanto segue.

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

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

L'altro problema con questa soluzione è che se aggiungi o rimuovi una proprietà devi aggiornare il costruttore e tutte le tue query.

Nel caso in cui si utilizzi Spring Data Rest, il problema può essere risolto creando Repository per ogni Entità coinvolta in riferimenti ciclici.

Sono in ritardo ed è già un filo così lungo. Ma ho trascorso un paio d'ore a cercare di capire anche questo, e vorrei dare il mio caso come altro esempio.

Ho provato entrambe le soluzioni JsonIgnore, JsonIgnoreProperties e BackReference, ma stranamente è stato come se non fossero stati raccolti.

Ho usato Lombok e ho pensato che forse interferisce, dal momento che crea costruttori e sostituisce String (visto to String in stackoverflowerror stack).

Alla fine non è stata colpa di Lombok - ho usato la generazione automatica NetBeans di entità JPA dalle tabelle del database, senza pensarci troppo - bene, e una delle annotazioni aggiunte alle classi generate era @XmlRootElement. Una volta rimosso, tutto ha iniziato a funzionare. Oh bene.

Il punto è posizionare @JsonIgnore nel metodo setter come segue. nel mio caso.

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;