userclass/UserclassService
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
- 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-* 保持不动）
This commit is contained in:
Allen
2026-08-12 17:21:22 +08:00
parent 66cd0f1515
commit dc217ca7a9
258 changed files with 1082 additions and 1067 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main/java/com/yunhai/bschclassmanage/service/impl/sync/SyncGroupService.java
+62
View File
@@ -0,0 +1,62 @@
package com.yunhai.bschclassmanage.service.impl.sync;
import com.yunhai.bschclassmanage.Repository.SchInfoRepository;
import com.yunhai.bschclassmanage.entity.SchInfo;
import com.yunhai.bschclassmanage.enums.NodeType;
import com.yunhai.bschclassmanage.model.tool.BaseGroup;
import com.yunhai.bschclassmanage.service.ISyncGroupService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Optional;
import java.util.UUID;
@Service
public class SyncGroupService implements ISyncGroupService {
@Autowired
private SchInfoRepository schInfoRepository;
public void syncAddOrUpdate(BaseGroup group) {
//学校组 年级组 班级组
if(group.getType().equals(NodeType.SCHOOL.getId())){
addOrUpdateSchool(group);
}
if(group.getType().equals(NodeType.CLASS.getId())){
//添加班级组 202406
//添加班级 gradeid ?
// 获取年级组 2024 获取当前学校学制 >1 获取学段组 初中 高中
}
}
public void addOrUpdateSchool(BaseGroup group)
{
Optional<SchInfo> schOpt=schInfoRepository.findBySchId(group.getId());
if(schOpt.isPresent()){
SchInfo schInfo=schOpt.get();
schInfo.setName(group.getName());
schInfo.setSort(group.getNo());
schInfoRepository.save(schInfo);
}else {
String uuid= UUID.randomUUID().toString().toUpperCase();
SchInfo schInfo=new SchInfo();
schInfo.setName(group.getName());
schInfo.setSchId(group.getId());
schInfo.setSchSerId(uuid);
schInfo.setSort(group.getNo());
schInfoRepository.save(schInfo);
}
}
}
src/main/java/com/yunhai/bschclassmanage/service/impl/sync/SyncUserService.java
+361
View File
@@ -0,0 +1,361 @@
package com.yunhai.bschclassmanage.service.impl.sync;
import com.yunhai.bschclassmanage.Repository.SchInfoRepository;
import com.yunhai.bschclassmanage.Repository.SchStudentRepository;
import com.yunhai.bschclassmanage.Repository.SchTeacherGroupRepository;
import com.yunhai.bschclassmanage.Repository.SchTeacherRepository;
import com.yunhai.bschclassmanage.entity.SchInfo;
import com.yunhai.bschclassmanage.entity.SchStudent;
import com.yunhai.bschclassmanage.entity.SchTeacher;
import com.yunhai.bschclassmanage.entity.SchTeacherGroup;
import com.yunhai.bschclassmanage.enums.NodeType;
import com.yunhai.bschclassmanage.enums.StuAbnormalStatus;
import com.yunhai.bschclassmanage.enums.TransferStatus;
import com.yunhai.bschclassmanage.enums.UserRole;
import com.yunhai.bschclassmanage.model.tool.BaseGroup;
import com.yunhai.bschclassmanage.model.tool.BaseUser;
import com.yunhai.bschclassmanage.model.tool.DeleteUser;
import com.yunhai.bschclassmanage.service.ISchTeacherService;
import com.yunhai.bschclassmanage.service.ISyncUserService;
import com.yunhai.bschclassmanage.service.impl.student.SchStudentCacheService;
import com.yunhai.bschclassmanage.service.impl.teacher.SchTeacherCacheService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
@Service
public class SyncUserService implements ISyncUserService {
@Autowired
private SchStudentRepository schStudentRepository;
@Autowired
private SchTeacherRepository schTeacherRepository;
@Autowired
private SchTeacherGroupRepository schTeacherGroupRepository;
@Autowired
private SchStudentCacheService schStudentCacheService;
@Autowired
private SchTeacherCacheService schTeacherCacheService;
// ==================== 同步入口 ====================
@Override
@Transactional(rollbackFor = Exception.class)
public void syncAddOrUpdate(List<BaseUser> userList) {
if (userList == null || userList.isEmpty()) return;
// 按角色分组
List<BaseUser> syncStudentList = new ArrayList<>();
List<BaseUser> syncTeacherList = new ArrayList<>();
for (BaseUser user : userList) {
if (isStudent(user)) syncStudentList.add(user);
if (isTeacher(user)) syncTeacherList.add(user);
}
Date now = new Date();
if (!syncStudentList.isEmpty()) {
syncStudents(syncStudentList, now);
}
if (!syncTeacherList.isEmpty()) {
syncTeachers(syncTeacherList, now);
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteUser(List<DeleteUser> deleteUserList) {
if (deleteUserList == null || deleteUserList.isEmpty()) return;
// 提取所有 userId
List<Integer> allUserIds = deleteUserList.stream()
.map(DeleteUser::getUserId)
.filter(Objects::nonNull)
.distinct()
.collect(Collectors.toList());
if (allUserIds.isEmpty()) return;
// ---------- 1. 物理删除学生 ----------
List<DeleteUser> studentDeletes = deleteUserList.stream()
.filter(du -> du.getUserId() != null && du.getGroupId() != null)
.collect(Collectors.toList());
if (!studentDeletes.isEmpty()) {
// 批量查询学生
List<SchStudent> allStudents = schStudentRepository.findByStuIdIn(allUserIds);
Map<String, SchStudent> studentMap = allStudents.stream()
.collect(Collectors.toMap(
s -> buildStudentKey(s.getStuId(), s.getGroupId()),
Function.identity()
));
List<SchStudent> toDelete = new ArrayList<>();
for (DeleteUser du : studentDeletes) {
String key = buildStudentKey(du.getUserId(), du.getGroupId());
SchStudent stu = studentMap.get(key);
if (stu != null) {
toDelete.add(stu);
}
}
if (!toDelete.isEmpty()) {
// 先清除缓存（需要 schId，可从学生实体获取或查询）
for (SchStudent stu : toDelete) {
// 假设 SchStudent 有 schId 字段，若没有则需通过 groupId 查询
Integer schId = stu.getSchId(); // 若没有，调用 service 查询
if (schId != null) {
schStudentCacheService.clearClassStudentCache(schId, stu.getGroupId());
}
}
// 物理删除
schStudentRepository.deleteAll(toDelete);
}
}
// ---------- 2. 物理删除教师分组（不删教师主体） ----------
List<DeleteUser> teacherDeletes = deleteUserList.stream()
.filter(du -> du.getUserId() != null && du.getGroupId() != null)
.collect(Collectors.toList());
if (!teacherDeletes.isEmpty()) {
// 查询所有涉及的分组
List<SchTeacherGroup> allGroups = schTeacherGroupRepository.findByTeaIdIn(allUserIds);
Map<String, SchTeacherGroup> groupMap = allGroups.stream()
.collect(Collectors.toMap(
g -> buildTeacherGroupKey(g.getTeaId(), g.getGroupId()),
Function.identity()
));
List<SchTeacherGroup> toDeleteGroups = new ArrayList<>();
for (DeleteUser du : teacherDeletes) {
String key = buildTeacherGroupKey(du.getUserId(), du.getGroupId());
SchTeacherGroup group = groupMap.get(key);
if (group != null) {
toDeleteGroups.add(group);
}
}
if (!toDeleteGroups.isEmpty()) {
// 按学校维度分组，用于缓存清除和剩余分组检查
Map<Integer, List<SchTeacherGroup>> groupsBySchool = toDeleteGroups.stream()
.collect(Collectors.groupingBy(SchTeacherGroup::getSchId));
// 先清除缓存（针对每个分组所属学校）
for (SchTeacherGroup group : toDeleteGroups) {
schTeacherCacheService.clearTeacherCache(group.getSchId());
}
// 物理删除分组
schTeacherGroupRepository.deleteAll(toDeleteGroups);
}
}
}
// ==================== 角色判断 ====================
private boolean isStudent(BaseUser user) {
if (user.getRoleList() == null) return false;
return user.getRoleList().stream()
.anyMatch(r -> r.getRoleId() != null && r.getRoleId().equals(UserRole.STU_USER.getValue()));
}
private boolean isTeacher(BaseUser user) {
if (user.getRoleList() == null) return false;
return user.getRoleList().stream()
.anyMatch(r -> r.getRoleId() != null &&
(r.getRoleId().equals(UserRole.TEACHER_USER.getValue()) ||
r.getRoleId().equals(UserRole.SCH_LEADER_USER.getValue())));
}
// ==================== 学生同步 ====================
private void syncStudents(List<BaseUser> studentUsers, Date now) {
List<Integer> stuIds = studentUsers.stream().map(BaseUser::getId).distinct().collect(Collectors.toList());
// 已有学生记录 (stuId, groupId) -> SchStudent
Map<String, SchStudent> studentMap = schStudentRepository.findByStuIdIn(stuIds)
.stream()
.collect(Collectors.toMap(
s -> buildStudentKey(s.getStuId(), s.getGroupId()),
Function.identity()
));
List<SchStudent> saveList = new ArrayList<>();
for (BaseUser user : studentUsers) {
if (user.getGroups() == null) continue;
for (BaseUser.GroupInfo group : user.getGroups()) {
Integer groupId = group.getGroupId();
Integer schId = group.getSchoolId();
if (groupId == null || schId == null) continue;
String key = buildStudentKey(user.getId(), groupId);
SchStudent student = studentMap.get(key);
if (student != null) {
updateStudent(student, user, group, now);
} else {
student = createStudent(user, group, now);
}
saveList.add(student);
}
}
if (!saveList.isEmpty()) {
schStudentRepository.saveAll(saveList);
// 缓存：将学生加入班级缓存（Set结构）
// for (SchStudent stu : saveList) {
// if (stu.getSchId() != null && stu.getGroupId() != null) {
// schStudentCacheService.addClassStudentCache(stu.getSchId(), stu.getGroupId(), stu.getStuId());
// }
// }
}
}
private void updateStudent(SchStudent student, BaseUser user, BaseUser.GroupInfo group, Date now) {
student.setAccount(user.getAccount());
student.setName(user.getName());
student.setGender(user.getGender());
student.setIdCard(user.getIdcard());
student.setStatus(user.getStatus());
student.setGroupId(group.getGroupId());
student.setClassId(group.getGroupId());
student.setSchId(group.getSchoolId());
student.setStuClassNo(group.getNo() != null ? String.valueOf(group.getNo()) : null);
student.setUpdateDate(now);
}
private SchStudent createStudent(BaseUser user, BaseUser.GroupInfo group, Date now) {
SchStudent student = new SchStudent();
student.setStuId(user.getId());
student.setAccount(user.getAccount());
student.setName(user.getName());
student.setGender(user.getGender());
student.setIdCard(user.getIdcard());
student.setStatus(user.getStatus());
student.setGroupId(group.getGroupId());
student.setClassId(group.getGroupId());
student.setSchId(group.getSchoolId());
student.setStuClassNo(group.getNo() != null ? String.valueOf(group.getNo()) : null);
student.setTransferStatus(TransferStatus.IN.getId());
student.setAbnormalStatus(StuAbnormalStatus.NORMAL.getId());
student.setCreateDate(now);
student.setUpdateDate(now);
return student;
}
// ==================== 教师同步 ====================
private void syncTeachers(List<BaseUser> teacherUsers, Date now) {
List<Integer> teaIds = teacherUsers.stream().map(BaseUser::getId).distinct().collect(Collectors.toList());
// 教师主体（唯一）
Map<Integer, SchTeacher> teacherMap = schTeacherRepository.findByTeaIdIn(teaIds)
.stream()
.collect(Collectors.toMap(SchTeacher::getTeaId, Function.identity()));
// 教师分组 (teaId, groupId, schId) -> SchTeacherGroup
Map<String, SchTeacherGroup> groupMap = schTeacherGroupRepository.findByTeaIdIn(teaIds)
.stream()
.collect(Collectors.toMap(
g -> buildTeacherGroupKeyWithSchId(g.getTeaId(), g.getGroupId(), g.getSchId()),
Function.identity()
));
List<SchTeacher> saveTeacherList = new ArrayList<>();
List<SchTeacherGroup> saveGroupList = new ArrayList<>();
for (BaseUser user : teacherUsers) {
// 教师主体（只存一条）
SchTeacher teacher = teacherMap.get(user.getId());
if (teacher != null) {
updateTeacher(teacher, user, now);
} else {
teacher = createTeacher(user, now);
}
saveTeacherList.add(teacher);
// 教师分组（遍历 groups）
if (user.getGroups() == null) continue;
for (BaseUser.GroupInfo group : user.getGroups()) {
Integer groupId = group.getGroupId();
Integer schId = group.getSchoolId();
if (groupId == null || schId == null) continue;
String key = buildTeacherGroupKeyWithSchId(user.getId(), groupId, schId);
SchTeacherGroup tg = groupMap.get(key);
if (tg != null) {
tg.setTransferStatus(TransferStatus.IN.getId());
// 如有其他字段更新可在此添加
} else {
tg = createTeacherGroup(user, group, now);
}
saveGroupList.add(tg);
}
}
if (!saveTeacherList.isEmpty()) {
schTeacherRepository.saveAll(saveTeacherList);
}
if (!saveGroupList.isEmpty()) {
schTeacherGroupRepository.saveAll(saveGroupList);
// // 缓存：更新教师缓存（学校维度）
// // 为简单起见，清除每个涉及的学校缓存，然后重新添加该学校所有教师（但这里我们只添加本次更新的教师，因为Set可重复）
// // 更稳健：清除后重建，但为了减少数据库查询，我们使用 add 方法
// for (SchTeacherGroup g : saveGroupList) {
// if (g.getSchId() != null) {
// schTeacherCacheService.addSchoolTeacherCache(g.getSchId(), g.getTeaId());
// }
// }
}
}
private void updateTeacher(SchTeacher teacher, BaseUser user, Date now) {
teacher.setAccount(user.getAccount());
teacher.setName(user.getName());
teacher.setGender(user.getGender());
teacher.setIdCard(user.getIdcard());
teacher.setStatus(user.getStatus() != null ? user.getStatus() : 0);
teacher.setTel(user.getPhone());
teacher.setUpdateDate(now);
}
private SchTeacher createTeacher(BaseUser user, Date now) {
SchTeacher teacher = new SchTeacher();
teacher.setTeaId(user.getId());
teacher.setAccount(user.getAccount());
teacher.setName(user.getName());
teacher.setGender(user.getGender());
teacher.setIdCard(user.getIdcard());
teacher.setStatus(user.getStatus() != null ? user.getStatus() : 0);
teacher.setTel(user.getPhone());
teacher.setCreateDate(now);
teacher.setUpdateDate(now);
return teacher;
}
private SchTeacherGroup createTeacherGroup(BaseUser user, BaseUser.GroupInfo group, Date now) {
SchTeacherGroup tg = new SchTeacherGroup();
tg.setTeaId(user.getId());
tg.setGroupId(group.getGroupId());
tg.setSchId(group.getSchoolId());
tg.setTransferStatus(TransferStatus.IN.getId());
return tg;
}
// ==================== 辅助键生成 ====================
private String buildStudentKey(Integer stuId, Integer groupId) {
return stuId + "_" + groupId;
}
private String buildTeacherGroupKey(Integer teaId, Integer groupId) {
return teaId + "_" + groupId;
}
private String buildTeacherGroupKeyWithSchId(Integer teaId, Integer groupId, Integer schId) {
return teaId + "_" + groupId + "_" + schId;
}
}