JPA Hibernate中多实体关联的建模：使用中间实体与复合主键

本教程深入探讨了在jpa hibernate中如何优雅地建模多对多关系及涉及多于两个实体的复杂关联。通过引入一个专用的中间实体（join entity）来表示联结表，并结合使用`@embeddedid`定义复合主键以及`@manytoone`和`@mapsid`进行关系映射，我们能够构建出灵活且可扩展的实体模型。这种方法不仅清晰地反映了数据库层面的结构，还为关系本身添加属性或扩展至更多实体提供了可能。

在关系型数据库管理系统（RDBMS）中，传统意义上的“多对多”关系并非直接存在，而是通过一个联结表（Join Table）来实现的。这个联结表通常包含两个外键，分别指向参与多对多关系的两个主表的主键。当这个联结表除了包含外键之外，还需要存储额外的属性（例如，学生对课程的评分、用户在项目中的角色等），或者当关系涉及三个或更多实体时，简单地使用@ManyToMany注解可能无法满足需求。此时，将联结表映射为一个独立的JPA实体，并为其定义复合主键，成为一种强大且灵活的解决方案。

核心策略：引入中间实体

为了在JPA中更精细地控制多对多关系或构建多实体关联，我们通常会引入一个“中间实体”（Join Entity）。这个中间实体直接映射到数据库中的联结表，它拥有自己的生命周期和属性，可以存储关系本身的附加信息。通过这种方式，原本的“多对多”关系被分解为两个“一对多”关系，即主实体与中间实体之间是“一对多”，中间实体与另一个主实体之间也是“一对多”。

定义中间实体与复合主键

当联结表的主键由其所关联的两个（或多个）实体的主键共同构成时，我们需要在JPA中使用复合主键。@EmbeddedId是实现复合主键的一种常用方式，它允许我们将一个自定义的、可嵌入的类作为实体的主键。

首先，定义一个可嵌入的复合主键类：

import java.io.Serializable;
import java.util.Objects;
import javax.persistence.Column;
import javax.persistence.Embeddable;

@Embeddable
public class CourseRatingKey implements Serializable {
    @Column(name = "student_id")
    private Long studentId;

    @Column(name = "course_id")
    private Long courseId;

    public CourseRatingKey() {}

    public CourseRatingKey(Long studentId, Long courseId) {
        this.studentId = studentId;
        this.courseId = courseId;
    }

    // Getters and Setters
    public Long getStudentId() { return studentId; }
    public void setStudentId(Long studentId) { this.studentId = studentId; }
    public Long getCourseId() { return courseId; }
    public void setCourseId(Long courseId) { this.courseId = courseId; }

    // 必须重写 equals 和 hashCode 方法，这是复合主键的关键
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        CourseRatingKey that = (CourseRatingKey) o;
        return Objects.equals(studentId, that.studentId) &&
               Objects.equals(courseId, that.courseId);
    }

    @Override
    public int hashCode() {
        return Objects.hash(studentId, courseId);
    }
}

接着，创建中间实体并使用@EmbeddedId注解来引用这个复合主键类：

Replit Agent

Replit最新推出的AI编程工具，可以帮助用户从零开始自动构建应用程序。

下载

import javax.persistence.*;

@Entity
@Table(name = "course_rating") // 映射到数据库中的联结表
public class CourseRating {

    @EmbeddedId
    private CourseRatingKey id; // 使用复合主键类

    // 其他属性，例如评分
    @Column(name = "rating")
    private int rating;

    // ... 构造函数、Getter/Setter 方法
}

映射参与实体：@ManyToOne 与 @MapsId

在中间实体中，我们需要将它与参与关系的各个主实体进行关联。由于中间实体中的外键构成了其复合主键的一部分，因此我们需要一种机制来告诉JPA，这些@ManyToOne关联的外键字段实际上是复合主键的组成部分。这就是@MapsId注解的作用。

@MapsId注解用于指定@ManyToOne关联的外键列是@EmbeddedId或@IdClass所定义的复合主键的一部分。它将@ManyToOne关系映射到复合主键的相应属性上。

继续完善CourseRating实体：

import javax.persistence.*;
import java.util.Objects; // 导入Objects类

@Entity
@Table(name = "course_rating")
public class CourseRating {

    @EmbeddedId
    private CourseRatingKey id;

    @ManyToOne
    @MapsId("studentId") // 将此ManyToOne关系的外键映射到CourseRatingKey中的"studentId"部分
    @JoinColumn(name = "student_id") // 实际的数据库列名
    private Student student;

    @ManyToOne
    @MapsId("courseId") // 将此ManyToOne关系的外键映射到CourseRatingKey中的"courseId"部分
    @JoinColumn(name = "course_id") // 实际的数据库列名
    private Course course;

    @Column(name = "rating")
    private int rating;

    public CourseRating() {}

    public CourseRating(Student student, Course course, int rating) {
        this.student = student;
        this.course = course;
        this.rating = rating;
        // 在构造函数中初始化复合主键，确保其与关联实体的主键一致
        this.id = new CourseRatingKey(student.getId(), course.getId());
    }

    // Getters and Setters
    public CourseRatingKey getId() { return id; }
    public void setId(CourseRatingKey id) { this.id = id; }
    public Student getStudent() { return student; }
    public void setStudent(Student student) { this.student = student; }
    public Course getCourse() { return course; }
    public void setCourse(Course course) { this.course = course; }
    public int getRating() { return rating; }
    public void setRating(int rating) { this.rating = rating; }

    // 同样，equals和hashCode对于实体也很重要
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        CourseRating that = (CourseRating) o;
        return Objects.equals(id, that.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

建立双向关系：@OneToMany

为了在主实体（如Student和Course）中也能方便地访问其关联的中间实体，我们需要建立反向的@OneToMany关系。

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

@Entity
@Table(name = "student")
public class Student {

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

    private String name;

    // 与CourseRating建立一对多关系
    @OneToMany(mappedBy = "student", cascade = CascadeType.ALL, orphanRemoval = true)
    private Set ratings = new HashSet<>();

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

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public Set getRatings() { return ratings; }
    public void setRatings(Set ratings) { this.ratings = ratings; }

    // 辅助方法，用于方便地添加和移除评分
    public void addRating(CourseRating rating) {
        ratings.add(rating);
        rating.setStudent(this);
        // 确保复合主