在Spring Boot JPA中实现多对多关系的数量约束

本文探讨了在Spring Boot JPA应用中，如何对@ManyToMany关系设置数量限制，例如学生选课数量或课程学生数量的上限。通过在业务逻辑层，利用实体关联集合的大小检查机制，结合Spring Data JPA的持久化操作，实现对多对多关系中关联对象数量的有效控制，确保数据完整性和业务规则的遵循。

1. 理解多对多关系与业务需求

在许多实际应用场景中，多对多（@manytomany）关系并非没有限制。例如，在一个学生选课系统中，可能存在以下业务规则：

• 学生选课数量限制： 每个学生最多只能选择3门课程。
• 课程容量限制： 每门课程最多只能有10名学生。

这些限制不能仅仅通过数据库层面的外键约束来表达，而是需要通过应用程序的业务逻辑进行管理。

2. 实体定义与JPA配置

首先，我们定义Student（学生）和Course（课程）两个实体，它们之间存在多对多关系。

Student 实体：

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

import java.util.
ArrayList;
import java.util.List;

@Entity
@NoArgsConstructor
@Getter
@Setter
public class Student extends BaseEntity { // 假设BaseEntity提供了ID等基础字段
    private String name;
    private String surname;

    @Column(name = "student_number", unique = true)
    private String number; // 学号

    @JsonIgnore
    @ManyToMany(cascade = CascadeType.MERGE, fetch = FetchType.EAGER)
    @JoinTable(name = "students_courses",
            joinColumns = @JoinColumn(name = "student_id"),
            inverseJoinColumns = @JoinColumn(name = "course_id"))
    private List courseList = new ArrayList<>();

    // 辅助方法，用于双向关系维护
    public void addCourse(Course course) {
        if (!this.courseList.contains(course)) {
            this.courseList.add(course);
            course.getStudentList().add(this);
        }
    }

    public void removeCourse(Course course) {
        if (this.courseList.contains(course)) {
            this.courseList.remove(course);
            course.getStudentList().remove(this);
        }
    }
}

Course 实体：

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

import java.util.ArrayList;
import java.util.List;

@Entity
@Getter
@Setter
@NoArgsConstructor
public class Course extends BaseEntity { // 假设BaseEntity提供了ID等基础字段

    @Column(name = "course_name", unique = true)
    private String courseName;

    @JsonIgnore
    @ManyToMany(mappedBy = "courseList", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    private List studentList = new ArrayList<>();

    // 辅助方法，用于双向关系维护
    public void addStudent(Student student) {
        if (!this.studentList.contains(student)) {
            this.studentList.add(student);
            student.getCourseList().add(this);
        }
    }

    public void removeStudent(Student student) {
        if (this.studentList.contains(student)) {
            this.studentList.remove(student);
            student.getCourseList().remove(this);
        }
    }
}

Repository 接口：

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface StudentRepository extends JpaRepository {
}

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface CourseRepository extends JpaRepository {
}

JPA配置说明：

• @ManyToMany：表示多对多关系。
• @JoinTable：在Student实体中定义了连接表students_courses，这是关系的所有者（owning side）。
• mappedBy = "courseList"：在Course实体中，表示Course是关系的被拥有者（inverse side），由Student实体的courseList字段管理。
• cascade = CascadeType.MERGE (在Student侧)：当Student实体被合并（merge）时，其关联的Course实体也会被合并。这对于更新连接表是合适的。
• cascade = CascadeType.ALL (在Course侧)：注意，在mappedBy侧使用CascadeType.ALL通常是不推荐的，因为它可能导致意外的数据删除。例如，删除一门课程可能会删除所有选修该课程的学生。在实际应用中，mappedBy侧通常不需要级联操作，或者只使用CascadeType.PERSIST和CascadeType.MERGE。为了本教程的目的，我们沿用原始设定，但请务必在实际项目中审慎考虑。
• fetch = FetchType.EAGER：表示关联集合在加载主实体时立即加载。这使得我们在检查size()时可以直接访问集合，无需额外的数据库查询（在事务内）。

3. 实现数量约束的业务逻辑

数量约束的实现应放在业务逻辑层（Service层），以确保在数据持久化之前进行验证。

自定义业务异常：

为了更好地处理业务规则违规，我们可以定义一个自定义异常。

public class BusinessValidationException extends RuntimeException {
    public BusinessValidationException(String message) {
        super(message);
    }
}

StudentService 示例（学生选课）：

import jakarta.persistence.EntityNotFoundException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class StudentService {
    private final StudentRepository studentRepository;
    private final CourseRepository courseRepository;

    private static final int MAX_COURSES_PER_STUDENT = 3; // 学生最大选课数
    private static final int MAX_STUDENTS_PER_COURSE = 10; // 课程最大容量

    public StudentService(StudentRepository studentRepository, CourseRepository courseRepository) {
        this.studentRepository = studentRepository;
        this.courseRepository = courseRepository;
    }

    /**
     * 学生注册课程
     * @param studentId 学生ID
     * @param courseId 课程ID
     * @return 更新后的学生实体
     * @throws