Spring Boot JPA多对多关联数量限制实现方案（MySQL+Hibernate）

我在Spring Boot中使用JPA（Hibernate实现）搭配MySQL数据库，定义了Student和Course的@ManyToMany关联结构。现在需要实现两个限制：每名学生最多可注册3门课程，每门课程最多容纳10名学生，请问该如何处理？

我的现有代码 #

Student实体类 #

@Entity
@NoArgsConstructor
@Getter
@Setter
public class Student extends BaseEntity {
    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<Course> courseList = new ArrayList<>();
}

Course实体类 #

@Entity
@Getter
@Setter
public class Course extends BaseEntity{

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

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

仓库接口 #

StudentRepository

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

}

CourseRepository

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

}

实现限制的几种方案 #

1. 业务层手动校验（最直接易维护） #

在处理选课逻辑的Service中提前检查数量，这是最直观且容易定制业务逻辑的方式：

@Service
@Transactional
public class EnrollmentService {
    private final StudentRepository studentRepo;
    private final CourseRepository courseRepo;

    public EnrollmentService(StudentRepository studentRepo, CourseRepository courseRepo) {
        this.studentRepo = studentRepo;
        this.courseRepo = courseRepo;
    }

    public void enrollStudentToCourse(Long studentId, Long courseId) {
        Student student = studentRepo.findById(studentId)
                .orElseThrow(() -> new IllegalArgumentException("学生不存在"));
        Course course = courseRepo.findById(courseId)
                .orElseThrow(() -> new IllegalArgumentException("课程不存在"));

        // 校验学生选课数量
        if (student.getCourseList().size() >= 3) {
            throw new IllegalStateException("每名学生最多只能注册3门课程");
        }
        // 校验课程容纳人数
        if (course.getStudentList().size() >= 10) {
            throw new IllegalStateException("每门课程最多只能容纳10名学生");
        }
        // 维护双向关联
        student.getCourseList().add(course);
        course.getStudentList().add(student);
        studentRepo.save(student);
    }
}

2. 实体类添加校验注解 #

使用Hibernate的@Size注解配合Spring Validation，在实体保存前自动触发校验：

修改Student类的关联字段：

@JsonIgnore
@ManyToMany(cascade = CascadeType.MERGE, fetch = FetchType.EAGER)
@JoinTable(name = "students_courses", joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id"))
@Size(max = 3, message = "每名学生最多只能注册3门课程")
private List<Course> courseList = new ArrayList<>();

修改Course类的关联字段：

@JsonIgnore
@ManyToMany(mappedBy = "courseList",cascade = CascadeType.ALL ,fetch = FetchType.EAGER)
@Size(max = 10, message = "每门课程最多只能容纳10名学生")
private List<Student> studentList = new ArrayList<>();

在Service或Controller中触发校验，比如手动调用Validator：

@Autowired
private Validator validator;

public void saveStudent(Student student) {
    Set<ConstraintViolation<Student>> violations = validator.validate(student);
    if (!violations.isEmpty()) {
        throw new ConstraintViolationException(violations);
    }
    studentRepo.save(student);
}

3. 数据库触发器（兜底保障） #

为了防止绕过应用层直接操作数据库，可以在中间表students_courses上添加MySQL触发器，从底层限制数量：

-- 限制单个学生选课不超过3门
DELIMITER //
CREATE TRIGGER check_student_course_limit BEFORE INSERT ON students_courses
FOR EACH ROW
BEGIN
    DECLARE count_courses INT;
    SELECT COUNT(*) INTO count_courses FROM students_courses WHERE student_id = NEW.student_id;
    IF count_courses >= 3 THEN
        SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = '学生选课数量不能超过3门';
    END IF;
END //
DELIMITER ;

-- 限制单个课程容纳学生不超过10人
DELIMITER //
CREATE TRIGGER check_course_student_limit BEFORE INSERT ON students_courses
FOR EACH ROW
BEGIN
    DECLARE count_students INT;
    SELECT COUNT(*) INTO count_students FROM students_courses WHERE course_id = NEW.course_id;
    IF count_students >= 10 THEN
        SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = '课程容纳学生数量不能超过10人';
    END IF;
END //
DELIMITER ;

4. Hibernate事件监听器（全局校验） #

通过监听实体的保存/更新事件，在持久化前统一校验：

@Component
public class EnrollmentValidationListener implements PreInsertEventListener, PreUpdateEventListener {

    @Override
    public boolean onPreInsert(PreInsertEvent event) {
        Object entity = event.getEntity();
        if (entity instanceof Student) {
            Student student = (Student) entity;
            if (student.getCourseList().size() >= 3) {
                throw new IllegalStateException("学生选课数量不能超过3门");
            }
        } else if (entity instanceof Course) {
            Course course = (Course) entity;
            if (course.getStudentList().size() >= 10) {
                throw new IllegalStateException("课程容纳学生数量不能超过10人");
            }
        }
        return false;
    }

    @Override
    public boolean onPreUpdate(PreUpdateEvent event) {
        return onPreInsert(new PreInsertEvent(event.getEntity(), event.getId(), event.getState(), event.getPersister(), event.getSession()));
    }
}

注册监听器到Hibernate：

@Configuration
public class HibernateConfig {
    @Autowired
    private EnrollmentValidationListener validationListener;

    @Bean
    public HibernatePropertiesCustomizer hibernatePropertiesCustomizer() {
        return properties -> properties.put("hibernate.event.listeners.pre-insert", validationListener);
    }
}

方案选择建议 #

• 优先用业务层校验，逻辑清晰，方便自定义错误提示和业务流程；
• 搭配**@Size注解**作为补充，减少重复校验代码；
• 加上数据库触发器做兜底，避免直接操作数据库绕过限制；
• 事件监听器适合全局统一校验场景，按需选择即可。

内容的提问来源于stack exchange，提问作者Ekin