SpringDataJpa的使用之一对一、一对多、多对多 关系映射问题

下面是SpringDataJpa关系映射的完整攻略。

一对一

1. 创建实体类

我们在使用SpringDataJpa中的一对一关系映射时，需要创建两个实体类，实体类之间通过@OneToOne建立映射关系。

我们以学生和身份证为例：

@Entity
public class Student {
    @Id
    private Long id;
    private String name;
    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "card_id")
    private IDCard card;
    // 省略getter/setter方法
}

@Entity
public class IDCard {
    @Id
    private Long id;
    private String number;
    // 省略getter/setter方法
}

通过以上实体类，我们就建立了学生和身份证一对一的关系。

2. 创建DAO接口

在创建DAO接口时，我们需要继承JpaRepository接口，同时使用@Repository注解

@Repository
public interface StudentRepository extends JpaRepository<Student, Long> {
}

通过以上接口，我们就建立了Student和数据库之间的关系。

3. 测试

通过以上的操作，我们已经建立了学生和身份证实体类之间的一对一关系，接下来就可以进行测试了。

@SpringBootTest
class ApplicationTests {
    @Autowired
    private StudentRepository studentRepository;

    @Test
    void testSave() {
        IDCard card = new IDCard();
        card.setNumber("1234567890");
        Student student = new Student();
        student.setName("Tom");
        student.setCard(card);

        studentRepository.save(student);
    }
}

在进行测试时，我们首先创建一个身份证实体类，然后再新建一个学生，将身份证设为学生的身份证，最后通过JpaRepository的save()方法保存到数据库中。

一对多

1. 创建实体类

在一对多关系映射时，我们需要创建两个实体类，其中一个实体类中包含多个另一个实体类的引用，通过@OneToMany建立映射关系。

我们以班级和学生为例：

@Entity
public class Student {
    @Id
    private Long id;
    private String name;

    // 关联班级列表
    @OneToMany(mappedBy = "student", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<ClassRelation> relationList;
    // 省略getter/setter方法
}

@Entity
public class ClassRelation {
    @Id
    private Long id;
    private String className;

    // 学生
    @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @JoinColumn(name = "student_id")
    private Student student;
    // 省略getter/setter方法
}

2. 创建DAO接口

DAO接口同理，需要继承JpaRepository并使用@Repository注解。

@Repository
public interface StudentRepository extends JpaRepository<Student, Long> {
}

3. 测试

与一对一关系映射的测试类相似，只是在测试数据的准备过程中需要创建多个班级和学生的对应关系。

@SpringBootTest
class ApplicationTests {
    @Autowired
    private StudentRepository studentRepository;

    @Test
    void testSave() {
        Student student = new Student();
        student.setName("Tom");

        List<ClassRelation> relationList = new ArrayList<>();

        ClassRelation classRelationA = new ClassRelation();
        classRelationA.setClassName("Class A");
        classRelationA.setStudent(student);
        relationList.add(classRelationA);

        ClassRelation classRelationB = new ClassRelation();
        classRelationB.setClassName("Class B");
        classRelationB.setStudent(student);
        relationList.add(classRelationB);

        student.setRelationList(relationList);

        studentRepository.save(student);
    }
}

通过以上测试，我们成功地建立了班级和学生之间的一对多关系。

多对多

1. 创建实体类

在多对多关系映射时，我们需要创建两个实体类，用@ManyToMany注解建立连接关系。

我们以学生和课程为例：

@Entity
public class Student {
    @Id
    private Long id;
    private String name;

    // 选修课程列表
    @ManyToMany(mappedBy = "students", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Course> courseList;
    // 省略getter/setter方法
}

@Entity
public class Course {
    @Id
    private Long id;
    private String name;

    // 学生列表
    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @JoinTable(name = "student_course", joinColumns = {@JoinColumn(name = "course_id", referencedColumnName = "id")},
            inverseJoinColumns = {@JoinColumn(name = "student_id", referencedColumnName = "id")})
    private List<Student> students;
    // 省略getter/setter方法
}

在上述代码中，我们分别在学生和课程实体类中声明了课程列表和选修了该课程的学生列表，两个列表使用@ManyToMany注解相互连接。

需要注意的是，我们使用@JoinTable注解可以指定表名，以及joinColumns和inverseJoinColumns属性分别表示关联关系中两个实体的外键名。

2. 创建DAO接口

创建完实体类以后，我们还需创建对应的DAO接口。同样，需要继承JpaRepository。

@Repository
public interface CourseRepository extends JpaRepository<Course, Long> {
}

3. 测试

在测试时，需要创建多个学生和课程对象，并建立对应的选课关系。

@SpringBootTest
class ApplicationTests {
    @Autowired
    private CourseRepository courseRepository;

    @Test
    void testSave() {
        Course courseA = new Course();
        courseA.setName("Course A");

        Course courseB = new Course();
        courseB.setName("Course B");

        Student studentA = new Student();
        studentA.setName("Tom");

        Student studentB = new Student();
        studentB.setName("Jerry");

        // 根据主从表的关系，需要维护两个方向的数据
        studentA.getCourseList().add(courseA);
        studentA.getCourseList().add(courseB);

        courseA.getStudents().add(studentA);

        studentB.getCourseList().add(courseA);
        studentB.getCourseList().add(courseB);

        courseA.getStudents().add(studentB);
        courseB.getStudents().add(studentB);

        courseRepository.save(courseA);
        courseRepository.save(courseB);
    }
}

通过以上测试，我们成功地建立了学生和课程之间的多对多关系。

综上所述，我们通过以上三个例子详细讲述了SpringDataJpa关系映射的使用方法。在具体开发中，也可按照此方法进行实际应用。