SpringData JPA框架使用时出现JSON循环依赖解决方案

最新推荐文章于 2025-06-18 09:45:00 发布

原创最新推荐文章于 2025-06-18 09:45:00 发布 · 2.2k 阅读

3 ·

CC 4.0 BY-SA版权

JPA 同时被 2 个专栏收录

4 篇文章

订阅专栏

Java Why

4 篇文章

订阅专栏

本文介绍如何使用Jackson的@JsonIgnoreProperties注解解决实体类间的循环引用问题，通过具体示例展示了如何配置以避免无限递归。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

jackson解决问题的方式是循环的那一部分不解析

JsonIgnoreProperties配置不解析的属性
描述不形象，我用两个“栗子"来描述一下
类有多少个怎么关联都不用慌，你从你想要出发的类开始，属性中有对自己引用的就在属性那个类中将自己忽略

eg:第一个“栗子"，只有两个类关联，但互相引用了，多对多和一对一这里都适用
Book类上面放入

@JsonIgnoreProperties(ignoreUnknown = true, value = 
{"hibernateLazyInitializer", "handler", "fieldHandler"})
public class Book{
... ...

Book类中属性上注解，此属性Author中引用了private Set books;

public class Book{
... ...
@JsonIgnoreProperties(ignoreUnknown = true, value = {"books"})
private Set<Author> authors;
... ...

Author类上面放入

@JsonIgnoreProperties(ignoreUnknown = true, value = 
{"hibernateLazyInitializer", "handler", "fieldHandler"})
public class Author{
... ...

Author类中属性上注解，此属性Book中引用了private Set authors;

public class Author{
... ...
@JsonIgnoreProperties(ignoreUnknown = true, value = {"authors"})
private Set<Book> books;
... ...

上面的例子“栗子"过去久远，只对关键需要配置的地方进行了标注
eg:第二个“栗子"，有三个类关联，通过一个中间类关联直接贴代码

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

import javax.persistence.*;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

@Entity
@JsonIgnoreProperties(ignoreUnknown = true, value =
        {"hibernateLazyInitializer", "handler", "fieldHandler"})
public class Book implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @TableGenerator(name = "book_generator", table = "tables_sequence", allocationSize = 1, initialValue = 0)
    @GeneratedValue(strategy = GenerationType.TABLE, generator = "book_generator")
    private int id;
    private String name;

    @OneToMany(mappedBy = "book", cascade = CascadeType.ALL, orphanRemoval = true)
    @JsonIgnoreProperties(ignoreUnknown = true, value = {"book"})
    private Set<BookPublisher> bookPublishers;

    public Book() {
    }

    public Book(String name) {
        this.name = name;
        bookPublishers = new HashSet<>();
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<BookPublisher> getBookPublishers() {
        return bookPublishers;
    }

    public void setBookPublishers(Set<BookPublisher> bookPublishers) {
        this.bookPublishers = bookPublishers;
    }
}

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Set;

@Entity
@JsonIgnoreProperties(ignoreUnknown = true, value =
        {"hibernateLazyInitializer", "handler", "fieldHandler"})
public class Publisher implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @TableGenerator(name = "pub_generator", table = "tables_sequence", allocationSize = 1, initialValue = 0)
    @GeneratedValue(strategy = GenerationType.TABLE, generator = "pub_generator")
    private int id;
    private String name;
    @OneToMany(mappedBy = "publisher")
    @JsonIgnoreProperties(ignoreUnknown = true, value = {"publisher"})
    private Set<BookPublisher> bookPublishers;

    public Publisher() {

    }

    public Publisher(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<BookPublisher> getBookPublishers() {
        return bookPublishers;
    }

    public void setBookPublishers(Set<BookPublisher> bookPublishers) {
        this.bookPublishers = bookPublishers;
    }
}

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;

@Entity
@Table(name = "book_publisher")
@JsonIgnoreProperties(ignoreUnknown = true, value =
        {"hibernateLazyInitializer", "handler", "fieldHandler"})
public class BookPublisher implements Serializable {

    @Id
    @ManyToOne
    @JoinColumn(name = "book_id")
    @JsonIgnoreProperties(ignoreUnknown = true, value = {"bookPublishers"})
    private Book book;

    @Id
    @ManyToOne
    @JoinColumn(name = "publisher_id")
    @JsonIgnoreProperties(ignoreUnknown = true, value = {"bookPublishers"})
    private Publisher publisher;

    @Column(name = "published_date")
    private Date publishedDate;

    public Book getBook() {
        return book;
    }

    public void setBook(Book book) {
        this.book = book;
    }


    public Publisher getPublisher() {
        return publisher;
    }

    public void setPublisher(Publisher publisher) {
        this.publisher = publisher;
    }

    public Date getPublishedDate() {
        return publishedDate;
    }

    public void setPublishedDate(Date publishedDate) {
        this.publishedDate = publishedDate;
    }
}

在这里插入图片描述
总结：
本实体中引入了另外一个实体，但另外一个实体也引用了自己无论是集合还是单个实体。jakson在格式化数据的时候会动态过滤掉此属性中对本身对象的引用。