refactor: 根包由 com.bestsch.bschclassmanage 重命名为 com.yunhai.bschclassmanage

- git mv src/main/java/com/bestsch/bschclassmanage -> src/main/java/com/yunhai/bschclassmanage
- 255 个 Java 文件的 package/import 同步替换为 com.yunhai.bschclassmanage
- pom.xml 项目 groupId 设为 com.yunhai（与外部依赖 com.bestsch:bsch-* 无关，未改动）
- IDE 缓存 workspace.xml 路径同步更新（外部依赖坐标 com.bestsch:bsch-* 保持不动）

src/main/java/com/yunhai/bschclassmanage/Repository/BaseDicGradeRepository.java

@@ -0,0 +1,11 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.BaseDicGrade;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface BaseDicGradeRepository extends JpaRepository<BaseDicGrade, Integer>, JpaSpecificationExecutor<BaseDicGrade> {
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/BaseDicSubjectRepository.java

@@ -0,0 +1,11 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.BaseDicSubject;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface BaseDicSubjectRepository extends JpaRepository<BaseDicSubject, Integer>, JpaSpecificationExecutor<BaseDicSubject> {
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/BaseSchsystemGradeRepository.java

@@ -0,0 +1,17 @@
+package com.yunhai.bschclassmanage.Repository;
+
+
+import com.yunhai.bschclassmanage.entity.BaseSchsystemGrade;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface BaseSchsystemGradeRepository extends JpaRepository<BaseSchsystemGrade, Integer>, JpaSpecificationExecutor<BaseSchsystemGrade> {
+
+    List<BaseSchsystemGrade> findBySchSystemId(Integer schSystemId);
+
+    List<BaseSchsystemGrade> findBySchSystemIdIn(List<Integer> schSystemIds);
+}

src/main/java/com/yunhai/bschclassmanage/Repository/BaseSchsystemRepository.java

@@ -0,0 +1,11 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.BaseSchsystem;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface BaseSchsystemRepository extends JpaRepository<BaseSchsystem, Integer>, JpaSpecificationExecutor<BaseSchsystem> {
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/BaseYearTermRepository.java

@@ -0,0 +1,11 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.BaseYearTerm;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface BaseYearTermRepository extends JpaRepository<BaseYearTerm, Integer>, JpaSpecificationExecutor<BaseYearTerm> {
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/OperationLogRecordRepository.java

@@ -0,0 +1,14 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.OperationLogRecord;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface OperationLogRecordRepository extends JpaRepository<OperationLogRecord, Integer>, JpaSpecificationExecutor<OperationLogRecord> {
+    Page<OperationLogRecord> findByModule(String module, Pageable pageable);
+    Page<OperationLogRecord> findAllByOrderByOperateTimeDesc(Pageable pageable);
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchBinSchsystemRepository.java

@@ -0,0 +1,13 @@
+package com.yunhai.bschclassmanage.Repository;
+
+
+import com.yunhai.bschclassmanage.entity.BaseSchsystemGrade;
+import com.yunhai.bschclassmanage.entity.SchBinSchsystem;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface SchBinSchsystemRepository extends JpaRepository<SchBinSchsystem, Integer>, JpaSpecificationExecutor<SchBinSchsystem> {
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchClassHistoryRepository.java

@@ -0,0 +1,20 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchClass;
+import com.yunhai.bschclassmanage.entity.SchClassHistory;
+import io.lettuce.core.dynamic.annotation.Param;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface SchClassHistoryRepository extends JpaRepository<SchClassHistory, Integer>, JpaSpecificationExecutor<SchClassHistory> {
+
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchClassRepository.java

@@ -0,0 +1,69 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchClass;
+import io.lettuce.core.dynamic.annotation.Param;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface SchClassRepository extends JpaRepository<SchClass, Integer>, JpaSpecificationExecutor<SchClass> {
+
+    Optional<SchClass> findByIdAndSchId(Integer Id, Integer schId);
+
+    Optional<SchClass> findByClassIdAndSchId(Integer classId, Integer schId);
+
+    @Query(value = "SELECT MAX(sort) FROM sch_class WHERE grade_id = :gradeId AND sch_id = :schId AND graduate = 0", nativeQuery = true)
+    Integer findMaxCodeNumber(@Param("gradeId") Integer gradeId, @Param("schId") Integer schId);
+
+    @Query("SELECT c FROM SchClass c " +
+            "WHERE c.schId = :schId " +
+            "AND (:campusId IS NULL OR c.campusId = :campusId) " +
+            "AND (:divisionId IS NULL OR c.divisionId = :divisionId) " +
+            "AND (:majorsId IS NULL OR c.majorsId = :majorsId) " +
+            "AND (:years IS NULL OR c.enrollYear IN :years)"+
+            "AND c.enrollYear = c.gradeId AND c.graduate = 0")
+    Page<SchClass> findClassesByConditions(@Param("schId") Integer schId,
+                                           @Param("campusId") Integer campusId,
+                                           @Param("divisionId") Integer divisionId,
+                                           @Param("majorsId") Integer majorsId,
+                                           @Param("years") List<Integer> years,
+                                           Pageable pageable);
+
+    boolean existsBySchIdAndGroupIdAndName(Integer schId, Integer groupId, String name);
+
+    boolean existsBySchIdAndGroupIdAndNameAndIdNot(Integer schId, Integer groupId, String name, Integer id);
+
+    long countByFirstTeacherIdOrSecondTeacherId(Integer firstTeacherId, Integer secondTeacherId);
+
+    long countByCampusId(Integer campusId);
+
+    long countByDivisionId(Integer divisionId);
+
+    long countByMajorsId(Integer majorsId);
+
+    List<SchClass> findBySchIdAndEnrollYear(Integer schId, Integer enrollYear);
+
+    boolean existsBySchIdAndClassId(Integer schId, Integer classId);
+
+    @Query("SELECT COUNT(c) FROM SchClass c WHERE (c.firstTeacherId IN (:ids) OR c.secondTeacherId IN (:ids)) AND c.schId = :schId AND c.graduate = 0")
+    long countByFirstTeacherIdInOrSecondTeacherIdInAndSchId(
+            @Param("ids") List<Integer> ids,
+            @Param("schId") Integer schId
+    );
+
+    /**
+     * 根据学校ID和年级ID列表，查询最小的注册年份
+     * @param schId 学校ID
+     * @param gradeIds 年级ID列表（可为空）
+     * @return 最小注册年份，如果没有匹配记录则返回 null
+     */
+    @Query("SELECT MIN(c.enrollYear) FROM SchClass c WHERE c.schId = :schId AND c.gradeId IN :gradeIds")
+    Integer findMinEnrollYear(@Param("schId") Integer schId, @Param("gradeIds") List<Integer> gradeIds);
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchClassTeachHistoryRepository.java

@@ -0,0 +1,12 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.BaseDicGrade;
+import com.yunhai.bschclassmanage.entity.SchClassTeachHistory;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface SchClassTeachHistoryRepository extends JpaRepository<SchClassTeachHistory, Integer>, JpaSpecificationExecutor<SchClassTeachHistory> {
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchClassTeachRepository.java

@@ -0,0 +1,23 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchClassTeach;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface SchClassTeachRepository extends JpaRepository<SchClassTeach, Integer>, JpaSpecificationExecutor<SchClassTeach> {
+
+
+    List<SchClassTeach> findBySchIdAndClassIdIn(Integer schId, List<Integer> classIds);
+
+    Optional<SchClassTeach> findBySchIdAndClassIdAndSubId(Integer schId, Integer classId, String subId);
+
+    Optional<SchClassTeach> findBySchIdAndId(Integer schId, Integer id);
+
+    List<SchClassTeach> findBySchIdAndClassId(Integer schId, Integer classId);
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchDicCampusRepository.java

@@ -0,0 +1,23 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchDicCampus;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface SchDicCampusRepository extends JpaRepository<SchDicCampus, Integer>, JpaSpecificationExecutor<SchDicCampus> {
+
+    boolean existsBySchIdAndName(Integer schId, String name);
+
+    boolean existsBySchIdAndNameAndIdNot(Integer schId, String name, Integer id);
+
+    Optional<SchDicCampus> findByIdAndSchId(Integer Id, Integer schId);
+
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchDicCourseDivisionRepository.java

@@ -0,0 +1,27 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchDicCourseDivision;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface SchDicCourseDivisionRepository extends JpaRepository<SchDicCourseDivision, Integer>, JpaSpecificationExecutor<SchDicCourseDivision> {
+
+    List<SchDicCourseDivision> findByCourseIdAndSchId(Integer courseId, Integer schId);
+
+    /**
+     * 根据课程 ID 列表和学校 ID 批量查询关联的学部关系
+     * @param courseIds 课程 ID 列表
+     * @param schId 学校 ID
+     * @return 匹配的关联关系列表
+     */
+    List<SchDicCourseDivision> findByCourseIdInAndSchId(List<Integer> courseIds, Integer schId);
+
+    void deleteByCourseIdAndSchId(Integer courseId, Integer schId);
+
+    Optional<SchDicCourseDivision> findByIdAndSchId(Integer Id, Integer schId);
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchDicCourseMajorsRepository.java

@@ -0,0 +1,27 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchDicCourseMajors;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface SchDicCourseMajorsRepository extends JpaRepository<SchDicCourseMajors, Integer>, JpaSpecificationExecutor<SchDicCourseMajors> {
+
+    List<SchDicCourseMajors> findByCourseIdAndSchId(Integer courseId, Integer schId);
+
+    /**
+     * 根据课程 ID 列表和学校 ID 批量查询关联的学部关系
+     * @param courseIds 课程 ID 列表
+     * @param schId 学校 ID
+     * @return 匹配的关联关系列表
+     */
+    List<SchDicCourseMajors> findByCourseIdInAndSchId(List<Integer> courseIds, Integer schId);
+
+    void deleteByCourseIdAndSchId(Integer courseId, Integer schId);
+
+    Optional<SchDicCourseMajors> findByIdAndSchId(Integer Id, Integer schId);
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchDicCourseRepository.java

@@ -0,0 +1,45 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchDicCampus;
+import com.yunhai.bschclassmanage.entity.SchDicCourse;
+import io.lettuce.core.dynamic.annotation.Param;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface SchDicCourseRepository extends JpaRepository<SchDicCourse, Integer>, JpaSpecificationExecutor<SchDicCourse> {
+    boolean existsBySchIdAndName(Integer schId, String name);
+    boolean existsBySchIdAndNameAndIdNot(Integer schId, String name, Integer id);
+    Optional<SchDicCourse> findByIdAndSchId(Integer Id, Integer schId);
+    @Query(value = "SELECT c FROM SchDicCourse c " +
+            "WHERE c.schId = :schId " +
+            "AND (:type IS NULL OR c.type = :type) " +
+            "AND (:keyword IS NULL OR (c.name LIKE CONCAT('%', :keyword, '%') " +
+            "                       OR c.nickname LIKE CONCAT('%', :keyword, '%') " +
+            "                       OR c.code LIKE CONCAT('%', :keyword, '%'))) " +
+            "AND (:divisionId IS NULL OR EXISTS (SELECT 1 FROM SchDicCourseDivision d WHERE d.courseId = c.id AND d.divisionId = :divisionId)) " +
+            "AND (:majorsId IS NULL OR EXISTS (SELECT 1 FROM SchDicCourseMajors m WHERE m.courseId = c.id AND m.majorsId = :majorsId))",
+            countQuery = "SELECT COUNT(c) FROM SchDicCourse c " +
+                    "WHERE c.schId = :schId " +
+                    "AND (:type IS NULL OR c.type = :type) " +
+                    "AND (:keyword IS NULL OR (c.name LIKE CONCAT('%', :keyword, '%') " +
+                    "                       OR c.nickname LIKE CONCAT('%', :keyword, '%') " +
+                    "                       OR c.code LIKE CONCAT('%', :keyword, '%'))) " +
+                    "AND (:divisionId IS NULL OR EXISTS (SELECT 1 FROM SchDicCourseDivision d WHERE d.courseId = c.id AND d.divisionId = :divisionId)) " +
+                    "AND (:majorsId IS NULL OR EXISTS (SELECT 1 FROM SchDicCourseMajors m WHERE m.courseId = c.id AND m.majorsId = :majorsId))")
+    Page<SchDicCourse> findCoursesByConditions(@Param("schId") Integer schId,
+                                               @Param("type") Integer type,
+                                               @Param("keyword") String keyword,
+                                               @Param("divisionId") Integer divisionId,
+                                               @Param("majorsId") Integer majorsId,
+                                               Pageable pageable);
+
+
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchDicDivisionRepository.java

@@ -0,0 +1,15 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchDicDivision;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface SchDicDivisionRepository extends JpaRepository<SchDicDivision, Integer>, JpaSpecificationExecutor<SchDicDivision> {
+    boolean existsBySchIdAndName(Integer schId, String name);
+    boolean existsBySchIdAndNameAndIdNot(Integer schId, String name, Integer id);
+    Optional<SchDicDivision> findByIdAndSchId(Integer Id, Integer schId);
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchDicMajorsRepository.java

@@ -0,0 +1,20 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchDicMajors;
+import io.lettuce.core.dynamic.annotation.Param;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface SchDicMajorsRepository extends JpaRepository<SchDicMajors, Integer>, JpaSpecificationExecutor<SchDicMajors> {
+    boolean existsBySchIdAndName(Integer schId, String name);
+    boolean existsBySchIdAndNameAndIdNot(Integer schId, String name, Integer id);
+    Optional<SchDicMajors> findByIdAndSchId(Integer Id, Integer schId);
+
+    @Query("SELECT MAX(m.schsystemLeng) FROM SchDicMajors m WHERE m.schId = :schId")
+    Optional<Integer> findMaxSchsystemLengBySchId(Integer schId);
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchDicSubjectRepository.java

@@ -0,0 +1,23 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.BaseDicGrade;
+import com.yunhai.bschclassmanage.entity.SchDicSubject;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface SchDicSubjectRepository extends JpaRepository<SchDicSubject, Integer>, JpaSpecificationExecutor<SchDicSubject> {
+
+    @Query(value = "SELECT MAX(CAST(SUBSTRING(code, 4) AS UNSIGNED)) FROM sch_dic_subject WHERE code LIKE 'SUB%' AND sch_id = ?1", nativeQuery = true)
+    Integer findMaxSubjectCodeNumber(Integer schId);
+
+    Optional<SchDicSubject> findByIdAndSchId(Integer Id, Integer schId);
+
+    boolean existsBySchIdAndSchSystemIdAndName(Integer schId, Integer schSystemId, String name);
+
+    boolean existsBySchIdAndSchSystemIdAndNameAndIdNot(Integer schId, Integer schSystemId, String name, Integer id);
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchInfoRepository.java

@@ -0,0 +1,16 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchInfo;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface SchInfoRepository extends JpaRepository<SchInfo, Integer>, JpaSpecificationExecutor<SchInfo> {
+
+    Optional<SchInfo> findBySchId(Integer schId);
+
+    Optional<SchInfo> findBySchSerId(String schSerId);
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchStudentHistoryRepository.java

@@ -0,0 +1,12 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchClassTeachHistory;
+import com.yunhai.bschclassmanage.entity.SchStudentHistory;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface SchStudentHistoryRepository extends JpaRepository<SchStudentHistory, Integer>, JpaSpecificationExecutor<SchStudentHistory> {
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchStudentRepository.java

@@ -0,0 +1,114 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchStudent;
+import io.lettuce.core.dynamic.annotation.Param;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface SchStudentRepository extends JpaRepository<SchStudent, Integer>, JpaSpecificationExecutor<SchStudent> {
+
+    Optional<SchStudent> findByStuId(Integer stuId);
+
+    List<SchStudent> findByStuIdIn(List<Integer> stuIds);
+
+    boolean existsByAccount(String account);
+
+    Optional<SchStudent> findByAccount(String account);
+
+    Optional<SchStudent> findByIdAndSchId(Integer Id, Integer schId);
+
+    @Query("SELECT s FROM SchStudent s WHERE s.schId = :schId AND s.classId = :classId AND s.abnormalStatus = 1 AND s.transferStatus=1 AND s.status = 1")
+    List<SchStudent> findBySchIdAndClassId(@Param("schId") Integer schId, @Param("classId") Integer classId);
+
+    List<SchStudent> findAllByIdInAndSchId(List<Integer> ids, Integer schId);
+
+
+
+    boolean existsBySchIdAndClassIdAndName(Integer schId,Integer classId, String name);
+
+    boolean existsBySchIdAndClassIdAndNameAndIdNot(Integer schId,Integer classId, String name, Integer id);
+
+    @Modifying(clearAutomatically = true)
+    @Query("UPDATE SchStudent s SET s.classId = :newClassId, s.groupId = :newClassId, s.updateDate = :updateDate, s.updateUserId = :updateUserId WHERE s.id IN (:ids) AND s.schId = :schId")
+    int batchUpdateClassId(@Param("ids") List<Integer> ids,
+                           @Param("newClassId") Integer newClassId,
+                           @Param("schId") Integer schId,
+                           @Param("updateDate") Date updateDate,
+                           @Param("updateUserId") Integer updateUserId);
+
+    @Modifying
+    @Query("UPDATE SchStudent s SET s.schId = :schId, s.classId = :newClassId,s.groupId = :newClassId, s.updateDate = :updateDate, s.updateUserId = :updateUserId , s.transferStatus =1 WHERE s.id IN :ids")
+    int batchUpdateSchIdAndClassId(@Param("ids") List<Integer> ids,
+                           @Param("schId") Integer schId,          // 目标学校ID
+                           @Param("newClassId") Integer newClassId,
+                           @Param("updateDate") Date updateDate,
+                           @Param("updateUserId") Integer updateUserId);
+
+
+    /**
+     * 批量更新学生异常状态，同时记录异常发生时间和修改时间（两者相同）
+     *
+     * @param ids             学生ID列表
+     * @param abnormalStatus  异常状态值
+     * @param schId           学校ID（安全过滤）
+     * @param commonDate      异常时间 / 修改时间
+     * @param updateUserId    操作用户ID
+     * @return 实际更新的行数
+     */
+    @Modifying(clearAutomatically = true)
+    @Query("UPDATE SchStudent s SET " +
+            "s.abnormalStatus = :abnormalStatus, " +
+            "s.abnormalDate = :commonDate, " +
+            "s.updateDate = :commonDate, " +
+            "s.updateUserId = :updateUserId " +
+            "WHERE s.id IN (:ids) AND s.schId = :schId")
+    int batchUpdateAbnormalStatus(@Param("ids") List<Integer> ids,
+                                  @Param("abnormalStatus") Integer abnormalStatus,
+                                  @Param("schId") Integer schId,
+                                  @Param("commonDate") Date commonDate,
+                                  @Param("updateUserId") Integer updateUserId);
+
+
+    /**
+     * 批量更新学生异常状态，同时记录异常发生时间和修改时间（两者相同）
+     *
+     * @param ids             学生ID列表
+     * @param transferStatus  转出状态值
+     * @param schId           学校ID（安全过滤）
+     * @param commonDate      异常时间 / 修改时间
+     * @param updateUserId    操作用户ID
+     * @return 实际更新的行数
+     */
+    @Modifying(clearAutomatically = true)
+    @Query("UPDATE SchStudent s SET " +
+            "s.transferStatus = :transferStatus, " +
+            "s.abnormalDate = :commonDate, " +
+            "s.updateDate = :commonDate, " +
+            "s.updateUserId = :updateUserId, " +
+            "s.stuClassNo = null " +
+            "WHERE s.id IN (:ids) AND s.schId = :schId")
+    int batchUpdateTransferStatus(@Param("ids") List<Integer> ids,
+                                  @Param("transferStatus") Integer transferStatus,
+                                  @Param("schId") Integer schId,
+                                  @Param("commonDate") Date commonDate,
+                                  @Param("updateUserId") Integer updateUserId);
+
+
+    /**
+     * 获取所有转出学生的学校ID（去重）
+     * 转出条件：transfer_status = 0
+     * 关联：s.class_id = c.group_class_id
+     */
+    @Query(value = "SELECT DISTINCT c.sch_id FROM sch_student s " +
+            "INNER JOIN sch_class c ON s.class_id = c.group_class_id " +
+            "WHERE s.transfer_status = 0 AND s.sch_id = c.sch_id AND s.status=1 ", nativeQuery = true)
+    List<Integer> findDistinctSchIdsByTransferOut();
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchTeacherCustomGroupInGradeRepository.java

@@ -0,0 +1,15 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchTeacherCustomGroupInGrade;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface SchTeacherCustomGroupInGradeRepository extends JpaRepository<SchTeacherCustomGroupInGrade, Integer>, JpaSpecificationExecutor<SchTeacherCustomGroupInGrade> {
+    List<SchTeacherCustomGroupInGrade> findByCgGroupIdIn(List<Integer> groupIds);
+
+    void deleteByCgGroupId(Integer groupId);
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchTeacherCustomGroupInSubjectRepository.java

@@ -0,0 +1,15 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchTeacherCustomGroupInSubject;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface SchTeacherCustomGroupInSubjectRepository extends JpaRepository<SchTeacherCustomGroupInSubject, Integer>, JpaSpecificationExecutor<SchTeacherCustomGroupInSubject> {
+    List<SchTeacherCustomGroupInSubject> findByCgGroupIdIn(List<Integer> groupIds);
+
+    void deleteByCgGroupId(Integer groupId);
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchTeacherCustomGroupInTeacherRepository.java

@@ -0,0 +1,31 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchTeacherCustomGroup;
+import com.yunhai.bschclassmanage.entity.SchTeacherCustomGroupInTeacher;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface SchTeacherCustomGroupInTeacherRepository extends JpaRepository<SchTeacherCustomGroupInTeacher, Integer>, JpaSpecificationExecutor<SchTeacherCustomGroupInTeacher> {
+    /**
+     * 根据组ID列表查询所有教师关联
+     * @param groupIds 组ID列表
+     * @return 教师关联列表
+     */
+    List<SchTeacherCustomGroupInTeacher> findByCgGroupIdIn(List<Integer> groupIds);
+
+    List<SchTeacherCustomGroupInTeacher> findByCgGroupId(Integer groupId);
+
+    List<SchTeacherCustomGroupInTeacher> findByCgGroupIdAndGroupType(Integer groupId, Integer groupType);
+
+    void deleteByCgGroupIdAndGroupType(Integer groupId, Integer groupType);
+
+    void deleteByCgGroupIdAndTeaIdInAndGroupType(Integer groupId, List<Integer> teaIds, Integer groupType);
+
+    void deleteByCgGroupId(Integer groupId);
+
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchTeacherCustomGroupRepository.java

@@ -0,0 +1,21 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchTeacherCustomGroup;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface SchTeacherCustomGroupRepository extends JpaRepository<SchTeacherCustomGroup, Integer>, JpaSpecificationExecutor<SchTeacherCustomGroup> {
+
+    List<SchTeacherCustomGroup> findBySchId(Integer schId);
+
+    List<SchTeacherCustomGroup> findBySchIdAndGroupType(Integer schId, Integer groupType);
+
+    List<SchTeacherCustomGroup> findBySchIdAndGroupTypeAndGroupName(Integer schId, Integer groupType, String groupName);
+
+    boolean existsBySchIdAndGroupTypeAndGroupName(Integer schId, Integer groupType, String groupName);
+    boolean existsBySchIdAndGroupTypeAndGroupNameAndIdNot(Integer schId, Integer groupType, String groupName, Integer id);
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchTeacherGroupRepository.java

@@ -0,0 +1,97 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchTeacherGroup;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+import java.util.List;
+
+import io.lettuce.core.dynamic.annotation.Param;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface SchTeacherGroupRepository extends JpaRepository<SchTeacherGroup, Integer>, JpaSpecificationExecutor<SchTeacherGroup> {
+
+
+    /**
+     * 根据 teaId 列表查询所有组关联（不限学校）
+     * 适用场景：全局查询（如跨校操作前校验）
+     */
+    List<SchTeacherGroup> findByTeaIdIn(List<Integer> teaIds);
+
+
+    List<SchTeacherGroup> findByGroupIdAndSchId(Integer groupId, Integer schId);
+
+
+    List<SchTeacherGroup> findByTeaIdAndSchId(Integer teaId, Integer schId);
+
+    /**
+     * 根据 teaId 列表和学校 ID 查询组关联
+     * 适用场景：查询某教师在指定学校的组归属
+     */
+    List<SchTeacherGroup> findByTeaIdInAndSchId(List<Integer> teaIds, Integer schId);
+
+    /**
+     * 根据 teaId 列表、学校 ID 和转入状态查询组关联
+     * 适用场景：只查询转入状态的记录（transferStatus = 1）
+     */
+    List<SchTeacherGroup> findByTeaIdInAndSchIdAndTransferStatus(List<Integer> teaIds, Integer schId, Integer transferStatus);
+
+    /**
+     * 根据学校 ID 查询该学校所有教师的 teaId（去重）
+     * 适用场景：获取该校所有教师列表
+     */
+    @Query("SELECT DISTINCT t.teaId FROM SchTeacherGroup t WHERE t.schId = :schId")
+    List<Integer> findTeaIdsBySchId(@Param("schId") Integer schId);
+
+    /**
+     * 校验某教师是否属于某学校（根据 teaId 和 schId）
+     */
+    boolean existsByTeaIdAndSchId(Integer teaId, Integer schId);
+
+    // ==================== 删除方法 ====================
+
+    /**
+     * 根据 teaId 列表删除所有学校的关联（谨慎使用）
+     * 适用场景：全局删除（如教师彻底注销）
+     */
+    @Modifying
+    @Query("DELETE FROM SchTeacherGroup g WHERE g.teaId IN :teaIds")
+    int deleteByTeaIdIn(@Param("teaIds") List<Integer> teaIds);
+
+    /**
+     * 根据 teaId 列表和学校 ID 删除关联（推荐）
+     * 适用场景：转出/删除时只移除该教师在当前学校的组归属
+     */
+    @Modifying
+    @Query("DELETE FROM SchTeacherGroup g WHERE g.teaId IN :teaIds AND g.schId = :schId")
+    int deleteByTeaIdInAndSchId(@Param("teaIds") List<Integer> teaIds, @Param("schId") Integer schId);
+
+    // ==================== 批量更新方法 ====================
+
+    /**
+     * 批量更新某学校下教师的转入状态
+     * 适用场景：批量转出/转入
+     */
+    @Modifying
+    @Query("UPDATE SchTeacherGroup g SET g.transferStatus = :status WHERE g.teaId IN :teaIds AND g.schId = :schId")
+    int batchUpdateTransferStatus(@Param("teaIds") List<Integer> teaIds,
+                                  @Param("schId") Integer schId,
+                                  @Param("status") Integer status);
+
+    // 根据学校ID和组ID查询教师 teaId 列表
+    @Query("SELECT DISTINCT t.teaId FROM SchTeacherGroup t WHERE t.schId = :schId AND t.groupId = :groupId")
+    List<Integer> findTeaIdsBySchIdAndGroupId(@Param("schId") Integer schId, @Param("groupId") Integer groupId);
+
+    // 查询某学校下所有不同的组ID
+    @Query("SELECT DISTINCT t.groupId FROM SchTeacherGroup t WHERE t.schId = :schId")
+    List<Integer> findGroupIdsBySchId(@Param("schId") Integer schId);
+
+    /**
+     * 根据状态获取学校ID（去重）
+     */
+    @Query("SELECT DISTINCT g.schId FROM SchTeacherGroup g WHERE g.transferStatus = 0")
+    List<Integer> findSchoolIdsByTransferOut();
+}

src/main/java/com/yunhai/bschclassmanage/Repository/SchTeacherRepository.java

@@ -0,0 +1,79 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.SchTeacher;
+import com.yunhai.bschclassmanage.model.vo.TeacherSchVO;
+import io.lettuce.core.dynamic.annotation.Param;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface SchTeacherRepository extends JpaRepository<SchTeacher, Integer>, JpaSpecificationExecutor<SchTeacher> {
+
+    List<SchTeacher> findByTeaIdIn(List<Integer> teaIds);
+
+    Optional<SchTeacher> findByTeaId(Integer teaId);
+
+
+    @Query(value = "SELECT DISTINCT t.* FROM sch_teacher t " +
+            "INNER JOIN sch_teacher_group g ON t.tea_id = g.tea_id " +
+            "WHERE g.sch_id = :schId " +
+            "AND g.transfer_status = 1 " +  // 只查转入状态的教师
+            "AND (:groupId IS NULL OR g.group_id = :groupId) " +
+            "AND (:keyword IS NULL OR t.name LIKE CONCAT('%', :keyword, '%') OR t.account LIKE CONCAT('%', :keyword, '%')) " ,
+            countQuery = "SELECT COUNT(DISTINCT t.id) FROM sch_teacher t " +
+                    "INNER JOIN sch_teacher_group g ON t.tea_id = g.tea_id " +
+                    "WHERE g.sch_id = :schId " +
+                    "AND g.transfer_status = 1 " +
+                    "AND (:groupId IS NULL OR g.group_id = :groupId) " +
+                    "AND (:keyword IS NULL OR t.name LIKE CONCAT('%', :keyword, '%') OR t.account LIKE CONCAT('%', :keyword, '%'))",
+            nativeQuery = true)
+    Page<SchTeacher> searchTeachersBySchIdAndGroupId(@Param("schId") Integer schId,
+                                                     @Param("groupId") Integer groupId,
+                                                     @Param("keyword") String keyword,
+                                                     Pageable pageable);
+
+
+    @Query(value = "SELECT DISTINCT g.tea_id AS teaId, g.sch_id AS schId, t.name AS teaName, t.id_card AS idCard " +
+            "FROM sch_teacher_group g " +
+            "INNER JOIN sch_teacher t ON t.tea_id = g.tea_id " +
+            "WHERE g.transfer_status = 0 " +
+            "AND t.status = 1 " +
+            "AND (:schId IS NULL OR g.sch_id = :schId) " +
+            "AND (:groupId IS NULL OR g.group_id = :groupId) " +
+            "AND (:keyword IS NULL OR t.name LIKE CONCAT('%', :keyword, '%') OR t.account LIKE CONCAT('%', :keyword, '%')) " +
+            "ORDER BY t.name",  //只按教师姓名排序，避免引用未选择列
+            countQuery = "SELECT COUNT(DISTINCT CONCAT(g.tea_id, '_', g.sch_id)) " +
+                    "FROM sch_teacher_group g " +
+                    "INNER JOIN sch_teacher t ON t.tea_id = g.tea_id " +
+                    "WHERE g.transfer_status = 0 " +
+                    "AND t.status = 1 " +
+                    "AND (:schId IS NULL OR g.sch_id = :schId) " +
+                    "AND (:groupId IS NULL OR g.group_id = :groupId) " +
+                    "AND (:keyword IS NULL OR t.name LIKE CONCAT('%', :keyword, '%') OR t.account LIKE CONCAT('%', :keyword, '%'))",
+            nativeQuery = true)
+    Page<TeacherSchVO> searchTransferredOutTeachers(@Param("schId") Integer schId,
+                                                                         @Param("groupId") Integer groupId,
+                                                                         @Param("keyword") String keyword,
+                                                                         Pageable pageable);
+
+
+    @Modifying
+    @Query("UPDATE SchTeacher t SET t.status = :status, t.updateDate = :updateDate, t.updateUserId = :updateUserId WHERE t.id IN :ids")
+    int batchUpdateStatus(@Param("ids") List<Integer> ids,
+                          @Param("status") Integer status,
+                          @Param("updateDate") Date updateDate,
+                          @Param("updateUserId") Integer updateUserId);
+
+
+    List<SchTeacher> findByAccountIn(List<String> accountList);
+
+}

src/main/java/com/yunhai/bschclassmanage/Repository/UpgradeLogRepository.java

@@ -0,0 +1,13 @@
+package com.yunhai.bschclassmanage.Repository;
+
+import com.yunhai.bschclassmanage.entity.UpgradeLog;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface UpgradeLogRepository extends JpaRepository<UpgradeLog, Integer>, JpaSpecificationExecutor<UpgradeLog> {
+    boolean existsBySchIdAndSysIdAndYearAndStatus(
+            Integer schId, Integer sysId, Integer year,Boolean status
+    );
+}

src/main/java/com/yunhai/bschclassmanage/Repository/specification/OperationLogSpecifications.java

@@ -0,0 +1,42 @@
+package com.yunhai.bschclassmanage.Repository.specification;
+
+import com.yunhai.bschclassmanage.entity.OperationLogRecord;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.util.StringUtils;
+
+import javax.persistence.criteria.Predicate;
+
+public class OperationLogSpecifications {
+
+    public static Specification<OperationLogRecord> schIdEquals(Integer schId) {
+        return (root, query, cb) -> {
+            if (schId == null || schId <= 0) {
+                return cb.conjunction();
+            }
+            return cb.equal(root.get("schId"), schId);
+        };
+    }
+
+    public static Specification<OperationLogRecord> IsSystem(boolean IsSystem) {
+        return (root, query, cb) -> {
+            if (IsSystem) {
+                return cb.equal(root.get("module"), "系统管理");
+            }else{
+                return cb.notEqual(root.get("module"), "系统管理");
+            }
+        };
+    }
+
+    public static Specification<OperationLogRecord> keywordLike(String keyword) {
+        return (root, query, cb) -> {
+            if (!StringUtils.hasText(keyword)) {
+                return cb.conjunction();
+            }
+            String likePattern = "%" + keyword.trim() + "%";
+            Predicate p1 = cb.like(root.get("operator"), likePattern);
+            Predicate p2 = cb.like(root.get("module"), likePattern);
+            Predicate p3 = cb.like(root.get("content"), likePattern);
+            return cb.or(p1, p2, p3);
+        };
+    }
+}

src/main/java/com/yunhai/bschclassmanage/Repository/specification/SchClassSpecifications.java

@@ -0,0 +1,138 @@
+package com.yunhai.bschclassmanage.Repository.specification;
+
+import com.yunhai.bschclassmanage.entity.SchClass;
+import com.yunhai.bschclassmanage.entity.SchTeacher;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.util.StringUtils;
+
+import javax.persistence.criteria.Join;
+import javax.persistence.criteria.JoinType;
+import javax.persistence.criteria.Predicate;
+import java.util.ArrayList;
+import java.util.List;
+
+public class SchClassSpecifications {
+
+    /**
+     * 按学校 ID 查询（班级表中直接存储了 schId）
+     */
+    public static Specification<SchClass> schIdEquals(Integer schId) {
+        return (root, query, cb) -> {
+            if (schId == null || schId <= 0) {
+                return cb.conjunction();
+            }
+            return cb.equal(root.get("schId"), schId);
+        };
+    }
+
+    /**
+     * 按年级 ID 查询
+     */
+    public static Specification<SchClass> gradeIdEquals(Integer gradeId) {
+        return (root, query, cb) -> {
+            if (gradeId == null || gradeId <= 0) {
+                return cb.conjunction();
+            }
+            return cb.equal(root.get("gradeId"), gradeId);
+        };
+    }
+
+    /**
+     * 按班级名称模糊查询
+     */
+    public static Specification<SchClass> classNameLike(String className) {
+        return (root, query, cb) -> {
+            if (!StringUtils.hasText(className)) {
+                return cb.conjunction();
+            }
+            return cb.like(root.get("className"), "%" + className + "%");
+        };
+    }
+
+    /**
+     * 按班主任教师 ID 查询（firstTeacherId）
+     */
+    public static Specification<SchClass> firstTeacherIdEquals(Integer teacherId) {
+        return (root, query, cb) -> {
+            if (teacherId == null || teacherId <= 0) {
+                return cb.conjunction();
+            }
+            return cb.equal(root.get("firstTeacherId"), teacherId);
+        };
+    }
+
+    /**
+     * 按副班主任教师 ID 查询（secondTeacherId）
+     */
+    public static Specification<SchClass> secondTeacherIdEquals(Integer teacherId) {
+        return (root, query, cb) -> {
+            if (teacherId == null || teacherId <= 0) {
+                return cb.conjunction();
+            }
+            return cb.equal(root.get("secondTeacherId"), teacherId);
+        };
+    }
+
+    /**
+     * 按班主任或副班主任教师 ID 查询（任意一个匹配）
+     */
+    public static Specification<SchClass> teacherIsHeadOrAssistant(Integer teacherId) {
+        return (root, query, cb) -> {
+            if (teacherId == null || teacherId <= 0) {
+                return cb.conjunction();
+            }
+            Predicate p1 = cb.equal(root.get("firstTeacherId"), teacherId);
+            Predicate p2 = cb.equal(root.get("secondTeacherId"), teacherId);
+            return cb.or(p1, p2);
+        };
+    }
+
+    /**
+     * 按年级名称模糊查询（需关联年级表，假设有 @ManyToOne 关系）
+     * 注意：SchClass 实体中需有 grade 关联字段，例如：@ManyToOne @JoinColumn(name = "grade_id") private SchGrade grade;
+     */
+    public static Specification<SchClass> gradeNameLike(String gradeName) {
+        return (root, query, cb) -> {
+            if (!StringUtils.hasText(gradeName)) {
+                return cb.conjunction();
+            }
+            Join<Object, Object> gradeJoin = root.join("grade", JoinType.INNER);
+            return cb.like(gradeJoin.get("name"), "%" + gradeName + "%");
+        };
+    }
+
+    /**
+     * 动态组合查询（多条件），便于一次性传入多个参数
+     */
+    public static Specification<SchClass> dynamicQuery(Integer schId, Integer gradeId, String keyword,
+                                                       Integer teacherId, Boolean isHeadTeacher) {
+        return (root, query, cb) -> {
+            List<Predicate> predicates = new ArrayList<>();
+
+            if (schId != null && schId > 0) {
+                predicates.add(cb.equal(root.get("schId"), schId));
+            }
+            if (gradeId != null && gradeId > 0) {
+                predicates.add(cb.equal(root.get("gradeId"), gradeId));
+            }
+            if (StringUtils.hasText(keyword)) {
+                predicates.add(cb.like(root.get("className"), "%" + keyword + "%"));
+            }
+            if (teacherId != null && teacherId > 0) {
+                if (isHeadTeacher != null && isHeadTeacher) {
+                    predicates.add(cb.equal(root.get("firstTeacherId"), teacherId));
+                } else if (isHeadTeacher != null && !isHeadTeacher) {
+                    predicates.add(cb.equal(root.get("secondTeacherId"), teacherId));
+                } else {
+                    // 没有指定角色，默认查班主任或副班主任任意一个
+                    Predicate p1 = cb.equal(root.get("firstTeacherId"), teacherId);
+                    Predicate p2 = cb.equal(root.get("secondTeacherId"), teacherId);
+                    predicates.add(cb.or(p1, p2));
+                }
+            }
+
+            query.distinct(true);
+            return cb.and(predicates.toArray(new Predicate[0]));
+        };
+    }
+}

src/main/java/com/yunhai/bschclassmanage/Repository/specification/SchTeacherSpecifications.java

@@ -0,0 +1,94 @@
+package com.yunhai.bschclassmanage.Repository.specification;
+
+import com.yunhai.bschclassmanage.entity.SchTeacher;
+import com.yunhai.bschclassmanage.entity.SchTeacherGroup;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.util.StringUtils;
+
+import javax.persistence.criteria.Join;
+import javax.persistence.criteria.JoinType;
+import javax.persistence.criteria.Predicate;
+import java.util.ArrayList;
+import java.util.List;
+
+public class SchTeacherSpecifications {
+
+    /**
+     * 按姓名模糊查询
+     */
+    public static Specification<SchTeacher> nameLike(String keyword) {
+        return (root, query, cb) -> {
+            if (!StringUtils.hasText(keyword)) {
+                return cb.conjunction();
+            }
+            return cb.like(root.get("name"), "%" + keyword + "%");
+        };
+    }
+
+    /**
+     * 按状态精确查询（0-正常, 1-禁用等）
+     */
+    public static Specification<SchTeacher> statusEquals(Integer status) {
+        return (root, query, cb) -> {
+            if (status == null || status < 0) {
+                return cb.conjunction();
+            }
+            return cb.equal(root.get("status"), status);
+        };
+    }
+
+    /**
+     * 按学校 ID 查询（通过关联表 SchTeacherGroup）
+     */
+    public static Specification<SchTeacher> belongsToSchool(Integer schId) {
+        return (root, query, cb) -> {
+            if (schId == null || schId <= 0) {
+                return cb.conjunction();
+            }
+            Join<SchTeacher, SchTeacherGroup> groupJoin = root.join("schTeacherGroups", JoinType.INNER);
+            query.distinct(true);  // 避免因关联导致重复记录
+            return cb.equal(groupJoin.get("schId"), schId);
+        };
+    }
+
+    /**
+     * 按组 ID 查询（通过关联表）
+     */
+    public static Specification<SchTeacher> belongsToGroup(Integer groupId) {
+        return (root, query, cb) -> {
+            if (groupId == null || groupId <= 0) {
+                return cb.conjunction();
+            }
+            Join<SchTeacher, SchTeacherGroup> groupJoin = root.join("schTeacherGroups", JoinType.INNER);
+            query.distinct(true);
+            return cb.equal(groupJoin.get("groupId"), groupId);
+        };
+    }
+
+    /**
+     * 组合查询：支持多条件动态组合（用于复杂搜索）
+     */
+    public static Specification<SchTeacher> dynamicQuery(Integer schId, Integer groupId, String keyword, Integer status) {
+        return (root, query, cb) -> {
+            List<Predicate> predicates = new ArrayList<>();
+
+            if (schId != null && schId > 0) {
+                Join<SchTeacher, SchTeacherGroup> groupJoin = root.join("schTeacherGroups", JoinType.INNER);
+                predicates.add(cb.equal(groupJoin.get("schId"), schId));
+            }
+            if (groupId != null && groupId > 0) {
+                Join<SchTeacher, SchTeacherGroup> groupJoin = root.join("schTeacherGroups", JoinType.INNER);
+                predicates.add(cb.equal(groupJoin.get("groupId"), groupId));
+            }
+            if (StringUtils.hasText(keyword)) {
+                predicates.add(cb.like(root.get("name"), "%" + keyword + "%"));
+            }
+            if (status != null && status >= 0) {
+                predicates.add(cb.equal(root.get("status"), status));
+            }
+
+            query.distinct(true);
+            return cb.and(predicates.toArray(new Predicate[0]));
+        };
+    }
+}