Infinite Recursion with Jackson JSON and Hibernate JPA issue

JsonIgnoreProperties[Aktualizacja 2017]:

Możesz teraz użyć JsonIgnoreProperties aby wyłączyć serializację właściwości (podczas serializacji) lub zignorować przetwarzanie odczytywanych właściwości JSON (podczas deserializacji). Jeśli to nie jest to, czego szukasz, Czytaj dalej poniżej.

(podziękowania dla As Zammel AlaaEddine za zwrócenie na to uwagi).

JsonManagedReference i JsonBackReference

Od Jacksona 1.6 możesz użyć dwóch adnotacje w celu rozwiązania problemu nieskończonej rekurencji bez ignorowania getterów/setterów podczas serializacji: @JsonManagedReference oraz @JsonBackReference.

Wyjaśnienie

Aby Jackson działał dobrze, jedna z dwóch stron relacji nie powinna być serializowana, aby uniknąć pętli infite, która powoduje błąd stackoverflow.

Więc, Jackson bierze część odniesienia do przodu (twoja Set<BodyStat> bodyStats w klasie stażysty) i konwertuje ją w pamięci podobnej do json format; jest to tak zwany proces . Następnie Jackson szuka tylnej części referencji (tj. Trainee trainee w klasie BodyStat) i pozostawia ją taką, jaka jest, nie serializując jej. Ta część relacji zostanie ponownie skonstruowana podczas deserializacji (unmarshalling) forward reference.

Możesz zmienić swój kod w następujący sposób (pomijam bezużyteczne części):

Obiekt Biznesowy 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;

Obiekt Biznesowy 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;

Jeśli chcesz więcej informacji, napisałem artykuł o JSON i Jackson Stackoverflow problemy na Keenformatics , mój blog.

EDIT:

Kolejna przydatna adnotacja, którą możesz sprawdzić, to @JsonIdentityInfo : używając jej, za każdym razem, gdy Jackson serializuje Twój obiekt, doda do niego ID (lub inny atrybut twojego wyboru), tak aby nie całkowicie "skanował" go ponownie za każdym razem. To może być przydatny, gdy masz pętlę łańcucha między bardziej powiązanymi obiektami (na przykład: Order -> OrderLine -> User -> Order i jeszcze raz).

W tym przypadku musisz być ostrożny, ponieważ może być konieczne przeczytanie atrybutów obiektu więcej niż jeden raz (na przykład na liście produktów z większą liczbą produktów, które mają tego samego sprzedawcę), a ta adnotacja uniemożliwia ci to. Proponuję zawsze zajrzeć do dzienników firebug, aby sprawdzić odpowiedź Json i zobaczyć, co się dzieje w Twoim kod.

Źródła:

• Keenformatics - jak rozwiązać JSON Infinite recursion Stackoverflow (mój blog)
• Jackson Referencje
• osobiste doświadczenie

Nowa adnotacja @JsonIgnoreProperties rozwiązuje wiele problemów z innymi opcjami.

@Entity

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

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

Również, używając Jackson 2.0+ możesz użyć @JsonIdentityInfo. To działało znacznie lepiej dla moich klas hibernate niż @JsonBackReference i @JsonManagedReference, które miały dla mnie problemy i nie rozwiązały problemu. Wystarczy dodać coś w stylu:

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

Ponadto, Jackson 1.6 ma wsparcie dla obsługi dwukierunkowych odniesień ... co wydaje się to, czego szukasz (ten wpis na blogu również wspomina o funkcji)

A od lipca 2011 roku istnieje również "jackson-module-hibernate ", które może pomóc w niektórych aspektach radzenia sobie z obiektami Hibernate, chociaż niekoniecznie ten konkretny (który wymaga adnotacji).

Teraz Jackson wspiera unikanie cykli bez ignorowania pól:

Jackson-serializacja Bytów o relacjach dwukierunkowych (unikanie cykli)

To działało idealnie dla mnie. Dodaj adnotację @JsonIgnore na klasie potomnej, w której wspomnisz odniesienie do klasy rodzica.

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

Jest teraz moduł Jacksona (dla Jacksona 2) specjalnie zaprojektowany do obsługi leniwych problemów z inicjalizacją hibernacji podczas serializacji.

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

Wystarczy dodać zależność (zauważ, że istnieją różne zależności Dla Hibernate 3 i Hibernate 4):

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

A następnie zarejestrować moduł podczas inicjalizacji obiektu Jacksona:

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

Dokumentacja obecnie nie jest świetna. Zobacz też Kod Hibernate4Module {[6] } dla dostępnych opcji.

W moim przypadku wystarczyło zmienić relację z:

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

Do:

@OneToMany
private List<Town> towns;

Inna relacja pozostała taka, jaka była:

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

Dla mnie najlepszym rozwiązaniem jest użycie @JsonView i stworzenie specyficznych filtrów dla każdego scenariusza. Możesz również użyć @JsonManagedReference i @JsonBackReference, Jednak jest to rozwiązanie na twardo tylko w jednej sytuacji, w której właściciel zawsze odwołuje się do strony właściciela, a nigdy nie jest odwrotnie. Jeśli masz inny scenariusz serializacji, w którym musisz zmienić adnotację atrybutu w inny sposób, nie będziesz w stanie tego zrobić.

Problem

Lets use two classes, Company and Employee where you have a cyclic dependency między nimi:

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

I klasy testowej, która próbuje serializować za pomocą ObjectMapper (Wiosenne Buty):

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

Jeśli uruchomisz ten kod, otrzymasz:

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

Rozwiązanie Za Pomocą '@JsonView '

@JsonView umożliwia korzystanie z filtrów i wybieranie pól, które mają być dołączone podczas serializacji obiektów. Filtr jest tylko odniesieniem do klasy używanym jako identyfikator. Więc najpierw stwórzmy filtry:

public class Filter {

    public static interface EmployeeData {};

    public static interface CompanyData extends EmployeeData {};

} 

Pamiętaj, że filtry są klasami atrapy, tylko służy do określania pól za pomocą adnotacji @JsonView, dzięki czemu możesz utworzyć tyle, ile chcesz i potrzebujesz. Zobaczmy to w akcji, ale najpierw musimy dodać adnotację do naszej klasy Company:

public class Company {

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

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

    public Employee getEmployee() {
        return employee;
    }
}

I zmienić Test, aby serializer mógł korzystać z widoku:

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

Teraz, jeśli uruchomisz ten kod, problem rekurencji nieskończonej zostanie rozwiązany, ponieważ wyraźnie powiedziałeś, że chcesz po prostu serializować atrybuty, które zostały przypisane @JsonView(Filter.CompanyData.class).

Gdy dotrze do back reference dla firmy w Employee, sprawdza, czy nie jest adnotowana i ignoruje serializację. Masz również wydajne i elastyczne rozwiązanie do wyboru danych, które chcesz wysłać za pośrednictwem interfejsów API REST.

Za pomocą Springa można adnotować metody kontrolerów REST za pomocą pożądanego filtra @JsonView, a serializacja jest transparentnie zastosowana do zwracanego obiektu.

Oto import używany w przypadku, gdy trzeba sprawdzić:

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;

Upewnij się, że używasz com.fasterxml.jackson wszędzie. Spędziłem dużo czasu, żeby się tego dowiedzieć.

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

Następnie użyj @JsonManagedReference i @JsonBackReference.

Wreszcie możesz serializować swój model do JSON:

import com.fasterxml.jackson.databind.ObjectMapper;

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

Możesz użyć wzoru DTO Utwórz klasę Trainedto bez anotacji hiberbnate i możesz użyć jackson mapper do konwersji Trainee do Trainedto i bingo komunikat o błędzie disapeare :)

Też spotkałem się z tym samym problemem. Użyłem generatora @JsonIdentityInfo typu ObjectIdGenerators.PropertyGenerator.class.

To moje rozwiązanie:

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

Możesz użyć @JsonIgnore , ale to zignoruje dane json, które mogą być dostępne ze względu na zależność klucza obcego. Dlatego, jeśli zmienisz dane klucza obcego (przez większość czasu wymaganego), to @JsonIgnore nie pomoże ci. W takiej sytuacji postępuj zgodnie z poniższym rozwiązaniem.

Otrzymujesz nieskończoną rekurencję, ponieważ BodyStat klasa ponownie odwołuje się do obiektu

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;

Dlatego musisz skomentować / pominąć powyższą część w

@Jsonignoreprzypisy to jest odpowiedź.

Użyj czegoś takiego::

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

Miałem ten problem, ale nie chciałem używać adnotacji w moich encjach, więc rozwiązałem tworząc konstruktor dla mojej klasy, ten konstruktor nie może mieć odniesienia do encji, które odwołują się do tej encji. Powiedzmy, że ten scenariusz.

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

Jeśli spróbujesz wysłać do widoku klasę B lub A z @ResponseBody może to spowodować nieskończoną pętlę. Możesz napisać konstruktor w swojej klasie i utworzyć zapytanie za pomocą entityManager w ten sposób.

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

To jest klasa z konstruktor.

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

}

Są jednak pewne ograniczenia dotyczące tego rozwiązania, jak widać, w konstruktorze nie zrobiłem odniesienia do listy bs dzieje się tak dlatego, że Hibernate na to nie pozwala, przynajmniej w wersji 3.6.10.Final , więc kiedy muszę pokazać oba byty w widoku, wykonuję następujące czynności.

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

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

Inny problem z tym rozwiązaniem polega na tym, że jeśli dodasz lub usuniesz właściwość, musisz zaktualizować swój konstruktor i wszystkie zapytania.

W przypadku, gdy używasz Spring Data Rest, problem można rozwiązać, tworząc repozytoria dla każdego podmiotu zaangażowanego w cykliczne odwołania.

Working fine for me Rozwiąż problem JSON Infinite Recursion podczas pracy z Jacksonem

Oto co zrobiłem w Onetomanii i mapowaniu ManyToOne

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


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