Spring Data JPA：在所有者方面坚持许多可能的关系

Question

我设法在子方面保持了多对多的关系，（mappedBy），而且效果很好，如下所示：

---

学生实体（所有者）

package com.main.manytomany.models;

import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

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

@Entity
@Table(name = "students")
@Getter
@Setter
@NoArgsConstructor
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;


    @JsonIgnore
    @ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.PERSIST)
    @JoinTable
            (
                    name = "students_courses",
                    joinColumns = {
                            @JoinColumn
                                    (
                                            name = "student_id",
                                            referencedColumnName = "id",
                                            nullable = false,
                                            updatable = false
                                    )
                    },
                    inverseJoinColumns = {
                            @JoinColumn
                                    (
                                            name = "course_id",
                                            referencedColumnName = "id",
                                            nullable = false,
                                            updatable = false
                                    )
                    }
            )
    private Set<Course> courses = new HashSet<>();


}

课程实体（子级）

package com.main.manytomany.models;

import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

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

@Entity
@Table(name = "courses")
@Getter@Setter
@NoArgsConstructor
public class Course {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToMany(mappedBy = "courses", fetch = FetchType.LAZY)
    private Set<Student> students = new HashSet<>();
}

---

学生服务

package com.main.manytomany.services;

import com.main.manytomany.models.Student;
import com.main.manytomany.repositories.StudentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class StudentService {

    private final StudentRepository studentRepository;

    @Autowired
    public StudentService(StudentRepository studentRepository) {
        this.studentRepository = studentRepository;
    }

    public List<Student> findAll() {
        return this.studentRepository.findAll();
    }

    public Student getOneById(Long id) {
        return this.studentRepository.getOne(id);
    }

    public void store(Student student) {

        this.studentRepository.save(student);
    }
}

课程服务

package com.main.manytomany.services;

import com.main.manytomany.models.Course;
import com.main.manytomany.models.Student;
import com.main.manytomany.repositories.CourseRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class CourseService {

    private final CourseRepository courseRepository;
    private final StudentService studentService;

    @Autowired
    public CourseService(CourseRepository courseRepository, StudentService studentService) {
        this.courseRepository = courseRepository;
        this.studentService = studentService;
    }

    public List<Course> findAll() {
        return this.courseRepository.findAll();
    }

    public void store(Course course) {

        course.getStudents()
                .addAll(course
                        .getStudents()
                        .stream()
                        .map(s -> {
                            Student student = studentService.getOneById(s.getId());
                            student.getCourses().add(course);
                            return student;
                        }).collect(Collectors.toList()));

        this.courseRepository.save(course);
    }
}

---

学生控制器|帖子映射

@PostMapping
public ResponseEntity<Void> create(@RequestBody Student student) {
    this.studentService.store(student);
    return new ResponseEntity<>(HttpStatus.CREATED);
}

课程控制器|帖子映射

@PostMapping
public ResponseEntity<Void> create(@RequestBody Course course) {
    this.courseService.store(course);
    return new ResponseEntity<>(HttpStatus.CREATED);
}

---

学生列表|邮递员

课程表|邮递员

Students_Courses |数据透视表+休眠查询

---

如何使它在所有者表中起作用？

因此，持久性应在in StudentService]中运行，而不是在CourseService中运行持久性。

因此，在邮递员中，我将写类似的内容来吸引学生，以及他附带的课程

：

{
    "name" : "John Doe",
    "courses" : [
        {
            "id" : 1
        },
                {
            "id" : 2
        }
        ]
}
    

我设法在子方面保持了多对多的关系，（mappedBy），并且工作正常，如下所示：学生实体（所有者）包com.main.manytomany.models; import com ....

Answer 1

您需要在Course实体中级联更改（几乎与在另一个方向上所做的相同：]