Mysql 数据库映射

我创建了一个MySql数据库，其中包含两个表（书籍、成员）。一个成员可以有多本书，而某本书只能有一个成员。我想创建一个springboot项目，它将是一个restapi，在数据库上执行CRUD操作。对于数据库操作，我使用SpringDataJPA

接下来，我创建了两个名为books和members的类

    @Entity
    @Table(name = "members")
    public class Members {
        @Id
        @Column(name = "id")
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private int id;

        @Column(name = "last_name")
        private String lastName;

        @Column(name = "first_name")
        private String firstName;

        @Column(name = "address")
        private String address;

        @Column(name = "phone_num")
        private String phoneNum;

        @Column(name = "email")
        private String email;

        @OneToMany(mappedBy = "members", cascade = {CascadeType.DETACH, CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
        private List<Books> books;

//getters and setters

@Entity
@Table(name = "books")
public class Books {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "title")
    private String title;

    @Column(name = "author_last_name")
    private String authorLastName;

    @Column(name = "author_first_name")
    private String authorFirstName;

    @Column(name = "publisher")
    private String publisher;

    @Column(name = "publishing_year")
    private String publishingYear;

    @ManyToOne(cascade = {CascadeType.DETACH, CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
    @JoinColumn(name = "id_member")
    private Members members;
//getters and setters

@实体
@表（name=“成员”）
公共班级成员{
@身份证
@列（name=“id”）
@GeneratedValue（策略=GenerationType.IDENTITY）
私有int-id；
@列（name=“last_name”）
私有字符串lastName；
@列（name=“first_name”）
私有字符串名；
@列（name=“address”）
私有字符串地址；
@列（name=“phone\u num”）
私有字符串phoneNum；
@列（name=“email”）
私人字符串电子邮件；
@OneToMany（mappedBy=“members”，cascade={CascadeType.DETACH，CascadeType.MERGE，CascadeType.PERSIST，CascadeType.REFRESH}）
私人书目；
//接球手和接球手
@实体
@表（name=“books”）
公共课用书{
@身份证
@列（name=“id”）
@GeneratedValue（策略=GenerationType.IDENTITY）
私有int-id；
@列（name=“title”）
私有字符串标题；
@列（name=“author\u last\u name”）
私有字符串authorLastName；
@列（name=“author\u first\u name”）
私有字符串authorFirstName；
@列（name=“publisher”）
私有字符串发布器；
@列（name=“发布年份”）
私人字符串出版年；
@manytone（cascade={CascadeType.DETACH，CascadeType.MERGE，CascadeType.PERSIST，CascadeType.REFRESH}）
@JoinColumn（name=“id\u成员”）
私人会员；
//接球手和接球手

我已经创建了一个名为LibraryRepository的接口，它扩展了JpaRepository

    public interface LibraryRepository extends JpaRepository<Members, Integer> {
    }

public interface LibraryRepository扩展了JpaRepository{
}

我的图书馆服务界面

public interface LibraryService {
    List<Members> findAll();
}

公共接口库服务{
列出findAll（）；
}

和LibraryServiceImpl类

@Service
public class LibraryServiceImpl implements LibraryService {

    private LibraryRepository libraryRepository;

    @Autowired
    public LibraryServiceImpl(LibraryRepository libraryRepository) {
        this.libraryRepository = libraryRepository;
    }

    @Override
    public List<Members> findAll() {
        return libraryRepository.findAll();
    }
}

@服务
公共类LibraryServiceImpl实现LibraryService{
私人图书馆知识库；
@自动连线
公共LibraryServiceImpl（LibraryRepository LibraryRepository）{
this.libraryRepository=libraryRepository；
}
@凌驾
公共列表findAll（）{
返回libraryRepository.findAll（）；
}
}

和休息控制器

@RestController
@RequestMapping("/api")
public class LibraryRestController {

    private LibraryService libraryService;

    @Autowired
    public LibraryRestController(LibraryService libraryService) {
        this.libraryService = libraryService;
    }

    @GetMapping("/loans")
    public List<Members> findAll(){
        return libraryService.findAll();
    }
}

@RestController
@请求映射（“/api”）
公共类LibraryRestController{
私人图书馆服务图书馆服务；
@自动连线
公共图书馆RestController（图书馆服务图书馆服务）{
this.libraryService=图书馆服务；
}
@GetMapping（“/loans”）
公共列表findAll（）{
return libraryService.findAll（）；
}
}

其中一个成员借了一本书。 当我运行应用程序并在

http://localhost:8080/api/loans

返回的是一个无限列表。一个成员有一本书，此书有一个成员，此成员有一本书，依此类推

---

我相信我的实体类上有一些映射错误，但我找不到确切的映射。

问题是成员和书本之间存在双向映射。这是一个循环依赖关系，如果JSON封送员（Jackson）将对象转换为JSON，它将遵循依赖关系并生成无限循环

您必须使用JSON注释来打破这个循环

例如：

@JsonBackReference
@OneToMany(mappedBy = "members", cascade = {CascadeType.DETACH, CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
private List<Books> books;

这只是一个示例，由您决定哪个依赖项是托管引用

请在此处阅读有关该主题的更多信息：

---

问题在于成员和书籍之间存在双向映射。这是一个循环依赖关系，如果JSON封送员（Jackson）将对象转换为JSON，它将遵循依赖关系并产生无限循环

您必须使用JSON注释来打破这个循环

例如：

@JsonBackReference
@OneToMany(mappedBy = "members", cascade = {CascadeType.DETACH, CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
private List<Books> books;

这只是一个示例，由您决定哪个依赖项是托管引用

请在此处阅读有关该主题的更多信息：