这对我来说非常有效。 在提到父类引用的子类上添加注释@JsonIgnore。

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

在我的情况下，这足以改变关系:

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

to:

@OneToMany
private List<Town> towns;

另一种关系保持不变:

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

对我来说，最好的解决方案是使用@JsonView，并为每个场景创建特定的过滤器。你也可以使用@JsonManagedReference和@JsonBackReference，但是这是一种硬编码的解决方案，只针对一种情况，即所有者总是引用拥有方，而不是相反。如果您有另一个序列化场景，需要以不同的方式重新注释属性，则不能这样做。

问题

让我们使用两个类，Company和Employee，它们之间有循环依赖关系:

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

以及尝试使用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);
    }
}

如果你运行这段代码，你会得到:

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

使用“@JsonView”的解决方案

@JsonView允许您在序列化对象时使用过滤器并选择应该包括哪些字段。筛选器只是用作标识符的类引用。让我们先创建过滤器:

public class Filter {

    public static interface EmployeeData {};

    public static interface CompanyData extends EmployeeData {};

} 

请记住，过滤器是虚拟类，仅用于使用@JsonView注释指定字段，因此您可以根据需要创建任意数量的字段。让我们来看看它的实际操作，但首先我们需要注释我们的Company类:

public class Company {

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

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

    public Employee getEmployee() {
        return employee;
    }
}

并更改Test以便序列化器使用视图:

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

现在，如果运行这段代码，无限递归问题就解决了，因为您已经显式地说过，您只想序列化用@JsonView(Filter.CompanyData.class)注释的属性。

当它到达Employee中company的后向引用时，它检查它是否没有注释并忽略序列化。您还有一个强大而灵活的解决方案来选择希望通过REST api发送哪些数据。

使用Spring，您可以使用所需的@JsonView过滤器注释REST Controllers方法，序列化将透明地应用到返回的对象。

下面是用于检查的导入:

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;

此外，使用Jackson 2.0+，您可以使用@JsonIdentityInfo。对于我的hibernate类来说，这比@JsonBackReference和@JsonManagedReference要好得多，后者对我来说有问题，但没有解决问题。只需添加如下内容:

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

它应该会起作用。

JsonIgnoreProperties[2017年更新]:

您现在可以使用JsonIgnoreProperties来抑制属性的序列化(在序列化期间)，或者忽略JSON属性读取的处理(在反序列化期间)。如果这不是你想要的，请继续阅读下面的内容。

(感谢As Zammel AlaaEddine指出这一点)。

JsonManagedReference和JsonBackReference

从Jackson 1.6开始，您可以使用@JsonManagedReference和@JsonBackReference这两个注释来解决无限递归问题，而不必在序列化期间忽略getter /setter。

解释

为了使Jackson能够正常工作，关系的两个方面之一不应该被序列化，以避免导致stackoverflow错误的无限循环。

因此，Jackson取引用的前部分(您的Set<BodyStat> bodyStats in练习生类)，并将其转换为类似json的存储格式;这就是所谓的编组过程。然后，Jackson查找引用的后面部分(即BodyStat类中的练习生练习生)，并保持原样，不序列化它。关系的这一部分将在前向引用的反序列化(解组)期间重新构造。

你可以像这样修改你的代码(我跳过无用的部分):

业务对象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;

业务对象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;

现在一切都应该正常工作了。

如果你想了解更多信息，我在我的博客Keenformatics上写了一篇关于Json和Jackson Stackoverflow问题的文章。

编辑:

你可以检查的另一个有用的注释是@JsonIdentityInfo:使用它，每次Jackson序列化你的对象时，它都会添加一个ID(或你选择的其他属性)，这样它就不会每次都完全“扫描”它。当您在更多相关的对象之间有一个链循环时(例如:Order -> OrderLine -> User -> Order and over again)，这可能是有用的。

在这种情况下，您必须小心，因为您可能需要多次读取对象的属性(例如，在具有多个共享同一卖家的产品列表中)，而该注释阻止了您这样做。我建议经常查看firebug日志，检查Json响应，看看代码中发生了什么。

来源:

Keenformatics如何解决JSON无限递归Stackoverflow(我的博客) 杰克逊的引用 个人经验

我来晚了，而且已经有这么长一段了。但我也花了几个小时试图弄清楚这一点，我想把我的情况作为另一个例子。

我尝试了JsonIgnore, JsonIgnoreProperties和BackReference解决方案，但奇怪的是，它们好像没有被选中。

我使用Lombok，并认为它可能会干扰，因为它创建构造函数并覆盖toString(在stackoverflowerror堆栈中看到toString)。

最后，这不是Lombok的错——我使用了从数据库表自动生成JPA实体的NetBeans，没有考虑太多——而且，添加到生成的类中的注释之一是@XmlRootElement。一旦我把它取出来，一切都开始工作了。哦。