Jackson JSON ve Hibernate JPA sorunu ile Sonsuz Özyineleme

Çift yönlü bir ilişkisi olan bir JPA nesnesini JSON'a dönüştürmeye çalışırken,

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

Tüm bulduğum temelde iki yönlü ilişkilerden kaçınmayı öneren bu konu . Herkes bu bahar hata için bir geçici çözüm için bir fikri var mı?

------ DÜZENLEME 2010-07-24 16:26:22 -------

Kod parçacıkları:

İş Nesnesi 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 ...

İş Nesnesi 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;

Denetleyici:

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

Kursiyer DAO'nun JPA uygulaması:

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

@JsonIgnoreDöngüyü kırmak için kullanabilirsiniz .

JsonIgnoreProperties [2017 Güncellemesi]:

Artık kullanabilirsiniz JsonIgnoreProperties için (seri hale getirme sırasında) özelliklerinin bastırmak serileştirme veya (seri kaldırma sırasında) okumak JSON özelliklerinin işleme görmezden . Aradığınız şey bu değilse, lütfen aşağıda okumaya devam edin.

(Bunu işaret ettiği için As Zammel AlaaEddine'e teşekkürler).

JsonManagedReference ve JsonBackReference

Jackson 1.6'dan beri, serileştirme sırasında alıcıları / ayarlayıcıları göz ardı etmeden sonsuz özyineleme sorununu çözmek için iki ek açıklama kullanabilirsiniz: @JsonManagedReferenceve @JsonBackReference.

açıklama

Jackson'ın iyi çalışması için, yığın akışı hatasına neden olan sonsuz döngüden kaçınmak için ilişkinin iki tarafından biri serileştirilmemelidir.

Böylece, Jackson referansın ( Set<BodyStat> bodyStatsTrainee sınıfında) ileri kısmını alır ve json benzeri bir depolama biçimine dönüştürür; bu sözde marşaling sürecidir. Daha sonra, Jackson referansın arka kısmını arar (yani Trainee traineeBodyStat sınıfında) ve diziselleştirmeden olduğu gibi bırakır. İlişkinin bu kısmı , ileri başvurunun serileştirilmesi ( uyumsuzlaştırılması ) sırasında yeniden yapılandırılacaktır .

Kodunuzu bu şekilde değiştirebilirsiniz (yararsız kısımları atlarım):

İş Nesnesi 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;

İş Nesnesi 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;

Şimdi her şey düzgün çalışmalı.

Daha fazla bilgi istiyorsanız , blogum Keenformatics hakkında Json ve Jackson Stackoverflow sorunları hakkında bir makale yazdım .

DÜZENLE:

Kontrol edebileceğiniz bir diğer yararlı ek açıklama @JsonIdentityInfo : bunu kullanarak, Jackson nesnenizi her serileştirdiğinde, ona bir kimlik (veya seçtiğiniz başka bir özellik) ekleyecektir, böylece her seferinde tamamen "taramayacak". Bu, daha fazla ilişkili nesneler arasında bir zincir döngünüz olduğunda yararlı olabilir (örneğin: Order -> OrderLine -> Kullanıcı -> Order ve tekrar).

Bu durumda dikkatli olmalısınız, çünkü nesnenizin özelliklerini bir kereden fazla okumanız gerekebilir (örneğin aynı satıcıyı paylaşan daha fazla ürün içeren bir ürün listesinde) ve bu ek açıklama bunu yapmanızı engeller. Json yanıtını kontrol etmek ve kodunuzda neler olduğunu görmek için her zaman firebug günlüklerine göz atmanızı öneririm.

Kaynaklar:

• Keenformatics - JSON sonsuz özyineleme Stackoverflow Nasıl Çözülür (benim blog)
• Jackson Referansları
• Kişisel deneyim

Yeni @JsonIgnoreProperties ek açıklaması diğer seçeneklerle ilgili sorunların çoğunu çözer.

@Entity

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

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

Buradan kontrol edin. Tıpkı belgelerde olduğu gibi çalışır:
http://springquay.blogspot.com/2016/01/new-approach-to-solve-json-recursive.html

Ayrıca, Jackson 2.0+ kullanarak @JsonIdentityInfo . Bu benim hazırda daha sınıflar için çok daha iyi çalıştı @JsonBackReferenceve @JsonManagedReferencebenim için sorunlar vardı ve sorunu çözmedi. Bunun gibi bir şey ekleyin:

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

ve işe yaramalı.

Ayrıca, Jackson 1.6, aradığınıza benzeyen iki yönlü referansları işleme desteğine sahiptir ( bu blog girişi de özellikten bahseder)

Ve Temmuz 2011 itibariyle, bu özel bir şey olmasa da (ek açıklama gerektiren) Hibernate nesneleriyle uğraşmanın bazı yönlerinde yardımcı olabilecek " jackson-module-hibernate " de vardır.

Artık Jackson, alanları görmezden gelmeden döngülerden kaçınmayı destekliyor:

Jackson - Birectional ilişkilere sahip varlıkların serileştirilmesi (döngüden kaçınma)

Bu benim için gayet iyi çalıştı. Üst sınıfa başvuruda belirttiğiniz alt sınıfa @JsonIgnore ek açıklamasını ekleyin.

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

Şimdi serileştirirken Hazırda Bekleme tembel başlatma sorunlarını ele almak için özel olarak tasarlanmış bir Jackson modülü (Jackson 2 için) var.

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

Sadece bağımlılığı ekleyin (Hazırda Bekletme 3 ve Hazırda Bekletme 4 için farklı bağımlılıklar olduğunu unutmayın):

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

ve Jackson'ın ObjectMapper'ını başlatırken modülü kaydedin:

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

Belgeler şu anda harika değil. Kullanılabilir seçenekler için Hibernate4Module koduna bakın .

Benim için iyi çalışıyor Jackson ile çalışırken Json Infinite Recursion sorununu çözün

OneToMany ve ManyToOne Mapping'de yaptığım şey bu

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


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

Benim için en iyi çözüm, @JsonViewher senaryo için özel filtreler kullanmak ve oluşturmaktır. Ayrıca kullanabilirsiniz @JsonManagedReferenceve @JsonBackReferenceancak bu, sahibin her zaman sahip olan tarafa atıfta bulunduğu ve asla tersi olmayan tek bir duruma sabit kodlanmış bir çözümdür. Özelliğe farklı bir şekilde yeniden açıklama eklemeniz gereken başka bir serileştirme senaryosunuz varsa, bunu yapamazsınız.

Sorun

İki sınıf kullanalım Companyve Employeearalarında döngüsel bağımlılığın olduğu yerler:

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

Ve ObjectMapper( Spring Boot ) kullanarak serileştirmeye çalışan test sınıfı :

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

Bu kodu çalıştırırsanız şunları elde edersiniz:

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

`@ JsonView` Kullanarak Çözüm

@JsonViewfiltreleri kullanmanızı ve nesneleri serileştirirken hangi alanların ekleneceğini seçmenizi sağlar. Filtre, tanımlayıcı olarak kullanılan bir sınıf başvurusudur. Önce filtreleri oluşturalım:

public class Filter {

    public static interface EmployeeData {};

    public static interface CompanyData extends EmployeeData {};

} 

Unutmayın, filtreler, @JsonViewek açıklama içeren alanları belirtmek için kullanılan kukla sınıflardır, böylece istediğiniz ve ihtiyacınız olanı oluşturabilirsiniz. Eylemde görelim, ama önce Companysınıfımıza açıklama eklememiz gerekiyor :

public class Company {

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

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

    public Employee getEmployee() {
        return employee;
    }
}

ve serileştiricinin Görünümü kullanması için Testi değiştirin:

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

Şimdi bu kodu çalıştırırsanız, Sonsuz Özyineleme sorunu çözülür, çünkü yalnızca ek açıklama eklenmiş nitelikleri serileştirmek istediğinizi açık bir şekilde söylediniz. @JsonView(Filter.CompanyData.class) .

İçindeki şirket için geri referansa ulaştığında, Employeeaçıklamalı olmadığını kontrol eder ve serileştirmeyi yok sayar. Ayrıca REST API'leriniz aracılığıyla hangi verileri göndermek istediğinizi seçmek için güçlü ve esnek bir çözümünüz de vardır.

Spring ile REST Kontrolörleri yöntemlerinizi istediğiniz @JsonViewfiltreyle açıklayabilirsiniz ve serileştirme dönen nesneye şeffaf olarak uygulanır.

Kontrol etmeniz gerektiğinde kullanılan ithalatlar şunlardır:

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;

Cevap @JsonIgnoreProperties .

Bunun gibi bir şey kullanın ::

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

Benim durumumda ilişki değiştirmek için yeterliydi:

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

için:

@OneToMany
private List<Town> towns;

başka bir ilişki olduğu gibi kaldı:

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

Her yerde com.fasterxml.jackson kullandığınızdan emin olun . Bunu bulmak için çok zaman harcadım.

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

Sonra @JsonManagedReferenceve kullanın @JsonBackReference.

Son olarak, modelinizi JSON'a serileştirebilirsiniz:

import com.fasterxml.jackson.databind.ObjectMapper;

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

@JsonIgnore kullanabilirsiniz , ancak bu, Yabancı Anahtar ilişkisi nedeniyle erişilebilen json verilerini yok sayar . Bu nedenle, yabancı anahtar verilerini (çoğu zaman ihtiyaç duyduğumuz) reqiure ederseniz, @JsonIgnore size yardımcı olmaz. Bu durumda lütfen aşağıdaki çözümü takip edin.

tekrar Stajyer nesnesine atıfta bulunan BodyStat sınıfı nedeniyle Sonsuz özyineleme alıyorsunuz

Bodystat

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

Stajyer

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

Bu nedenle, yorumuna sahip / kısmen yukarıda ihmal Stajyer

Ben de aynı problemle karşılaştım. Kullandığım @JsonIdentityInfo'nin ObjectIdGenerators.PropertyGenerator.classjeneratör türü.

Bu benim çözümüm:

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

@ManyToOne varlık ile @JsonBackReference ve @onetomany içeren varlık sınıflarıyla @JsonManagedReference kullanmalısınız.

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

herhangi bir açıklama hiberbnate olmadan DTO desen oluşturmak sınıf TraineeDTO kullanabilirsiniz ve Trainee TraineeDTO dönüştürmek ve hata mesajı hayal kırıklığı bingo jackson mapper kullanabilirsiniz :)

Özelliği yok sayamıyorsanız, alanın görünürlüğünü değiştirmeyi deneyin. Bizim durumumuzda, eski kod hala ilişki ile varlık gönderme vardı, bu yüzden benim durumumda, bu düzeltme oldu:

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

Bu sorunu yaşadım, ancak varlıklarımda ek açıklama kullanmak istemedim, bu yüzden sınıfım için bir kurucu oluşturarak çözdüm, bu kurucunun bu varlığa referans veren varlıklara bir referansı olmamalıdır. Diyelim ki bu senaryo.

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

Eğer görünüme sınıfını göndermeye çalışırsanız Bya Aile @ResponseBodybuna sonsuz bir döngüye neden olabilir. Sınıfınıza bir kurucu yazabilir ve bunun entityManagergibi bir sorgu oluşturabilirsiniz .

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

Bu, kurucu ile sınıftır.

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

}

Ancak bu çözüm hakkında bazı daralmalar ben bir başvuru yapmadığını yapıcı içinde, gördüğünüz gibi, orada List bs hazırda buna izin vermez çünkü bu en azından içinde olduğu versiyon 3.6.10.Final ihtiyacım nedenle zaman her iki objeyi bir görünümde göstermek için aşağıdakileri yapıyorum.

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

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

Bu çözümle ilgili diğer sorun, bir özellik ekler veya kaldırırsanız kurucunuzu ve tüm sorgularınızı güncellemenizdir.

Spring Data Rest kullanıyorsanız, döngüsel referanslarda yer alan her bir Varlık için Depolar oluşturularak sorun çözülebilir.

Ben geç geliyorum ve zaten çok uzun bir iplik. Ama bunu anlamaya çalışmak için birkaç saat geçirdim ve davamı başka bir örnek olarak vermek istiyorum.

Hem JsonIgnore, JsonIgnoreProperties hem de BackReference çözümlerini denedim, ama garip bir şekilde alınmamış gibi oldu.

Lombok'u kullandım ve belki de müdahale ettiğini düşündüm, çünkü yapıcılar oluşturuyor ve String'i geçersiz kılıyor (stackoverflowerror yığınında gördüm).

Sonunda Lombok'un hatası değildi - çok düşünmeden, veritabanı tablolarından otomatik NetBeans nesli JPA varlıklarını kullandım - ve oluşturulan sınıflara eklenen ek açıklamalardan biri @XmlRootElement idi. Kaldırdığımda her şey çalışmaya başladı. Oh iyi.

Amaç @JsonIgnore ayarlayıcı yöntemine aşağıdaki gibi yerleştirmektir. benim durumumda.

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;