Unendliche Rekursion mit Jackson JSON und Hibernate JPA-Problem

Wenn ich versuche, ein JPA-Objekt mit einer bidirektionalen Zuordnung in JSON zu konvertieren, bekomme ich immer wieder

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

Alles, was ich gefunden habe, ist dieser Thread, der im Grunde mit der Empfehlung endet, bidirektionale Assoziationen zu vermeiden. Hat jemand eine Idee für eine Problemumgehung für diesen Frühlingsfehler?

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

Code Ausschnitte:

Geschäftsobjekt 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 ...

Geschäftsobjekt 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;

Regler:

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

Sie können verwenden @JsonIgnore, um den Zyklus zu unterbrechen.

JsonIgnoreProperties [Update 2017]:

Sie können jetzt JsonIgnoreProperties verwenden , um die Serialisierung von Eigenschaften (während der Serialisierung) zu unterdrücken oder die Verarbeitung der gelesenen JSON-Eigenschaften (während der Deserialisierung) zu ignorieren . Wenn dies nicht das ist, wonach Sie suchen, lesen Sie bitte weiter unten.

(Danke an As Zammel AlaaEddine für den Hinweis).

JsonManagedReference und JsonBackReference

Seit Jackson 1.6 können Sie zwei Annotationen verwenden, um das Problem der unendlichen Rekursion zu lösen, ohne die Getter / Setter während der Serialisierung zu ignorieren: @JsonManagedReferenceund@JsonBackReference .

Erläuterung

Damit Jackson gut funktioniert, sollte eine der beiden Seiten der Beziehung nicht serialisiert werden, um die Infite-Schleife zu vermeiden, die Ihren Stackoverflow-Fehler verursacht.

Also nimmt Jackson den vorwärts gerichteten Teil der Referenz (Ihre Set<BodyStat> bodyStatsin der Trainee-Klasse) und konvertiert sie in ein json-ähnliches Speicherformat. Dies ist der sogenannte Marshalling- Prozess. Dann sucht Jackson nach dem hinteren Teil der Referenz (dh Trainee traineein der BodyStat-Klasse) und lässt sie unverändert, ohne sie zu serialisieren. Dieser Teil der Beziehung wird während der Deserialisierung ( Unmarshalling ) der Vorwärtsreferenz neu konstruiert .

Sie können Ihren Code folgendermaßen ändern (ich überspringe die nutzlosen Teile):

Geschäftsobjekt 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;

Geschäftsobjekt 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;

Jetzt sollte alles richtig funktionieren.

Wenn Sie weitere Informationen wünschen, habe ich einen Artikel über Probleme mit Json und Jackson Stackoverflow in Keenformatics , meinem Blog, geschrieben.

BEARBEITEN:

Eine weitere nützliche Anmerkung, die Sie überprüfen können, ist @JsonIdentityInfo : Wenn Sie sie verwenden, wird jedes Mal , wenn Jackson Ihr Objekt serialisiert, eine ID (oder ein anderes Attribut Ihrer Wahl) hinzugefügt, sodass es nicht jedes Mal vollständig "gescannt" wird. Dies kann nützlich sein, wenn Sie eine Kettenschleife zwischen mehr miteinander verbundenen Objekten haben (zum Beispiel: Order -> OrderLine -> User -> Order und noch einmal).

In diesem Fall müssen Sie vorsichtig sein, da Sie die Attribute Ihres Objekts möglicherweise mehrmals lesen müssen (z. B. in einer Produktliste mit mehr Produkten, die denselben Verkäufer haben), und diese Anmerkung verhindert dies. Ich schlage vor, immer einen Blick auf die Firebug-Protokolle zu werfen, um die Json-Antwort zu überprüfen und festzustellen, was in Ihrem Code vor sich geht.

Quellen:

• Keenformatics - So lösen Sie JSON unendliche Rekursion Stackoverflow (mein Blog)
• Jackson Referenzen
• Persönliche Erfahrung

Die neue Anmerkung @JsonIgnoreProperties behebt viele Probleme mit den anderen Optionen.

@Entity

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

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

Schau es dir hier an. Es funktioniert genau wie in der Dokumentation:
http://springquay.blogspot.com/2016/01/new-approach-to-solve-json-recursive.html

Mit Jackson 2.0+ können Sie auch verwenden @JsonIdentityInfo. Dies funktionierte für meine Winterschlafklassen viel besser als @JsonBackReferenceund @JsonManagedReference, was Probleme für mich hatte und das Problem nicht löste. Fügen Sie einfach etwas hinzu wie:

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

und es sollte funktionieren.

Außerdem unterstützt Jackson 1.6 den Umgang mit bidirektionalen Referenzen ... was genau das ist, wonach Sie suchen (in diesem Blogeintrag wird auch die Funktion erwähnt).

Und ab Juli 2011 gibt es auch " jackson-module-hibernate ", das bei einigen Aspekten des Umgangs mit Hibernate-Objekten hilfreich sein kann, obwohl dies nicht unbedingt der Fall ist (für den Anmerkungen erforderlich sind).

Jetzt unterstützt Jackson das Vermeiden von Zyklen, ohne die Felder zu ignorieren:

Jackson - Serialisierung von Entitäten mit birektionalen Beziehungen (Vermeidung von Zyklen)

Das hat bei mir sehr gut funktioniert. Fügen Sie der untergeordneten Klasse, in der Sie den Verweis auf die übergeordnete Klasse erwähnen, die Anmerkung @JsonIgnore hinzu.

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

Es gibt jetzt ein Jackson-Modul (für Jackson 2), das speziell für Probleme mit der verzögerten Initialisierung im Ruhezustand bei der Serialisierung entwickelt wurde.

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

Fügen Sie einfach die Abhängigkeit hinzu (beachten Sie, dass es für Hibernate 3 und Hibernate 4 unterschiedliche Abhängigkeiten gibt):

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

und registrieren Sie dann das Modul, wenn Sie Jacksons ObjectMapper initialisieren:

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

Die Dokumentation ist derzeit nicht großartig. Die verfügbaren Optionen finden Sie im Hibernate4Module-Code .

Funktioniert gut für mich Beheben Sie das Problem mit Json Infinite Recursion, wenn Sie mit Jackson arbeiten

Dies habe ich in oneToMany und ManyToOne Mapping getan

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


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

Für mich ist die beste Lösung @JsonView, für jedes Szenario spezifische Filter zu verwenden und zu erstellen. Sie könnten auch @JsonManagedReferenceund verwenden@JsonBackReference es ist jedoch eine fest codierte Lösung für nur eine Situation, in der der Eigentümer immer auf die Besitzerseite verweist und niemals auf das Gegenteil. Wenn Sie ein anderes Serialisierungsszenario haben, in dem Sie das Attribut anders neu kommentieren müssen, können Sie dies nicht.

Problem

Hier können zwei Klassen verwenden, Companyund Employeewo Sie eine zyklische Abhängigkeit zwischen ihnen:

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

Und die Testklasse, die versucht, mit ObjectMapper( Spring Boot ) zu serialisieren :

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

Wenn Sie diesen Code ausführen, erhalten Sie Folgendes:

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

Lösung mit `@ JsonView`

@JsonViewMit dieser Option können Sie Filter verwenden und auswählen, welche Felder beim Serialisieren der Objekte enthalten sein sollen. Ein Filter ist nur eine Klassenreferenz, die als Bezeichner verwendet wird. Erstellen wir also zuerst die Filter:

public class Filter {

    public static interface EmployeeData {};

    public static interface CompanyData extends EmployeeData {};

} 

Denken Sie daran, dass die Filter Dummy-Klassen sind, die nur zum Angeben der Felder mit der @JsonViewAnmerkung verwendet werden, sodass Sie so viele erstellen können, wie Sie möchten und benötigen. Lassen Sie es uns in Aktion sehen, aber zuerst müssen wir unsere CompanyKlasse kommentieren :

public class Company {

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

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

    public Employee getEmployee() {
        return employee;
    }
}

und ändern Sie den Test, damit der Serializer die Ansicht verwenden kann:

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

Wenn Sie diesen Code ausführen, ist das Problem der unendlichen Rekursion gelöst, da Sie ausdrücklich gesagt haben, dass Sie nur die Attribute serialisieren möchten, mit denen Anmerkungen versehen wurden @JsonView(Filter.CompanyData.class) .

Wenn es die Rückreferenz für das Unternehmen in der erreicht Employee, prüft es, ob es nicht mit Anmerkungen versehen ist, und ignoriert die Serialisierung. Sie haben auch eine leistungsstarke und flexible Lösung, mit der Sie auswählen können, welche Daten Sie über Ihre REST-APIs senden möchten.

Mit Spring können Sie Ihre REST-Controller-Methoden mit dem gewünschten @JsonViewFilter versehen und die Serialisierung wird transparent auf das zurückkehrende Objekt angewendet.

Hier sind die Importe, die für den Fall verwendet werden, dass Sie überprüfen müssen:

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 ist die Antwort.

Verwenden Sie so etwas ::

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

In meinem Fall hat es gereicht, die Beziehung zu ändern von:

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

zu:

@OneToMany
private List<Town> towns;

eine andere Beziehung blieb wie sie war:

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

Stellen Sie sicher, dass Sie überall com.fasterxml.jackson verwenden . Ich habe viel Zeit damit verbracht, es herauszufinden.

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

Dann benutze @JsonManagedReferenceund @JsonBackReference.

Schließlich können Sie Ihr Modell in JSON serialisieren:

import com.fasterxml.jackson.databind.ObjectMapper;

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

Sie können @JsonIgnore verwenden , dies ignoriert jedoch die JSON-Daten, auf die aufgrund der Fremdschlüsselbeziehung zugegriffen werden kann. Wenn Sie daher die Fremdschlüsseldaten benötigen (die meiste Zeit, die wir benötigen), dann @JsonIgnore hilft Ihnen nicht weiter. In einer solchen Situation folgen Sie bitte der folgenden Lösung.

Sie erhalten eine unendliche Rekursion, da die BodyStat- Klasse erneut auf das Trainee- Objekt verweist

BodyStat

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

Auszubildender

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

Daher müssen Sie den obigen Teil in Trainee kommentieren / weglassen

Ich habe auch das gleiche Problem getroffen. Ich habe @JsonIdentityInfoden ObjectIdGenerators.PropertyGenerator.classGeneratortyp verwendet.

Das ist meine Lösung:

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

Sie sollten @JsonBackReference mit der Entität @ManyToOne und @JsonManagedReference mit der Entität @onetomany verwenden, die Entitätsklassen enthält.

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

Sie können die DTO-Mustererstellungsklasse TraineeDTO ohne Anotation Hiberbnate verwenden und Sie können Jackson Mapper verwenden, um Trainee in TraineeDTO zu konvertieren und die Fehlermeldung verschwinden zu lassen :)

Wenn Sie die Eigenschaft nicht ignorieren können, ändern Sie die Sichtbarkeit des Felds. In unserem Fall hatten wir noch alten Code, der Entitäten mit der Beziehung übermittelte. In meinem Fall war dies also die Lösung:

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

Ich hatte dieses Problem, wollte aber keine Annotation in meinen Entitäten verwenden. Daher habe ich einen Konstruktor für meine Klasse erstellt. Dieser Konstruktor darf keinen Verweis auf die Entitäten haben, die auf diese Entität verweisen. Sagen wir dieses Szenario.

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

Wenn Sie versuchen , die Klasse zu der Ansicht zu senden Boder Amit @ResponseBodykann es zu einer Endlosschleife führen. Sie können einen Konstruktor in Ihre Klasse schreiben und eine Abfrage mit entityManagerdieser erstellen .

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

Dies ist die Klasse mit dem 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;
   }

}

Wie Sie sehen, gibt es jedoch einige Einschränkungen bei dieser Lösung. Im Konstruktor habe ich keinen Verweis auf List bs erstellt. Dies liegt daran, dass Hibernate dies nicht zulässt, zumindest in Version 3.6.10.Final , also wenn ich es brauche Um beide Entitäten in einer Ansicht anzuzeigen, gehe ich wie folgt vor.

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

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

Das andere Problem bei dieser Lösung besteht darin, dass Sie beim Hinzufügen oder Entfernen einer Eigenschaft Ihren Konstruktor und alle Ihre Abfragen aktualisieren müssen.

Wenn Sie Spring Data Rest verwenden, kann das Problem behoben werden, indem Repositorys für jede Entität erstellt werden, die an zyklischen Referenzen beteiligt ist.

Ich bin spät dran und es ist schon so ein langer Faden. Aber ich habe ein paar Stunden damit verbracht, dies auch herauszufinden, und möchte meinen Fall als weiteres Beispiel nennen.

Ich habe sowohl JsonIgnore- als auch JsonIgnoreProperties- und BackReference-Lösungen ausprobiert, aber seltsamerweise war es so, als würden sie nicht abgeholt.

Ich habe Lombok verwendet und dachte, dass es möglicherweise stört, da es Konstruktoren erstellt und toString überschreibt (saw toString im Stackoverflowerror-Stack).

Schließlich war es nicht Lomboks Schuld - ich habe die automatische NetBeans-Generierung von JPA-Entitäten aus Datenbanktabellen verwendet, ohne viel darüber nachzudenken - und eine der Anmerkungen, die den generierten Klassen hinzugefügt wurden, war @XmlRootElement. Sobald ich es entfernt hatte, fing alles an zu funktionieren. Naja.

Der Punkt ist, den @JsonIgnore wie folgt in die Setter-Methode zu platzieren. in meinem Fall.

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;