1

zy/AbsenceService.java

@@ -0,0 +1,59 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.AbsenceMapper; // 导入AbsenceMapper接口
+import com.yanzhen.entity.Absence; // 导入Absence实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作
+
+@Service // 标注这是一个服务层的组件
+public class AbsenceService { // 定义AbsenceService类
+
+    @Autowired // 自动装配AbsenceMapper对象
+    private AbsenceMapper absenceMapper;
+
+    public int create(Absence absence) { // 创建一个新的Absence记录
+        return absenceMapper.create(absence); // 调用Mapper的create方法并返回结果
+    }
+
+    public int delete(String ids) { // 根据多个ID删除Absence记录
+        String[] arr = ids.split(","); // 将传入的ID字符串按逗号分割成数组
+        int row = 0; // 初始化删除计数器
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果当前ID不为空
+                absenceMapper.delete(Integer.parseInt(s)); // 调用Mapper的delete方法删除对应记录
+                row++; // 删除计数器加1
+            }
+        }
+        return row; // 返回删除的记录数
+    }
+
+    public int delete(Integer id) { // 根据单个ID删除Absence记录
+        return absenceMapper.delete(id); // 调用Mapper的delete方法并返回结果
+    }
+
+    public int update(Absence absence) { // 更新一个Absence记录
+        return absenceMapper.update(absence); // 调用Mapper的update方法并返回结果
+    }
+
+    public int updateSelective(Absence absence) { // 选择性更新一个Absence记录
+        return absenceMapper.updateSelective(absence); // 调用Mapper的updateSelective方法并返回结果
+    }
+
+    public PageInfo<Absence> query(Absence absence) { // 查询Absence记录列表并进行分页处理
+        if(absence != null && absence.getPage() != null){ // 如果Absence对象和分页参数不为空
+            PageHelper.startPage(absence.getPage(),absence.getLimit()); // 设置分页参数
+        }
+        return new PageInfo<Absence>(absenceMapper.query(absence)); // 调用Mapper的query方法进行查询并返回分页信息
+    }
+
+    public Absence detail(Integer id) { // 根据ID获取Absence详情
+        return absenceMapper.detail(id); // 调用Mapper的detail方法并返回结果
+    }
+
+    public int count(Absence absence) { // 统计Absence记录数量
+        return absenceMapper.count(absence); // 调用Mapper的count方法并返回结果
+    }
+}

zy/BedService.java

@@ -0,0 +1,59 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.BedMapper; // 导入BedMapper接口
+import com.yanzhen.entity.Bed; // 导入Bed实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作
+
+@Service // 标注该类为服务层组件
+public class BedService { // 定义BedService类
+
+    @Autowired // 自动装配BedMapper对象
+    private BedMapper bedMapper;
+
+    public int create(Bed bed) { // 创建床位记录的方法
+        return bedMapper.create(bed); // 调用Mapper层的create方法并返回结果
+    }
+
+    public int delete(String ids) { // 根据多个ID删除床位记录的方法
+        String[] arr = ids.split(","); // 将传入的ID字符串按逗号分割成数组
+        int row = 0; // 初始化删除记录数为0
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果当前ID不为空
+                bedMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除对应ID的记录
+                row++; // 删除记录数加1
+            }
+        }
+        return row; // 返回删除的记录数
+    }
+
+    public int delete(Integer id) { // 根据单个ID删除床位记录的方法
+        return bedMapper.delete(id); // 调用Mapper层的delete方法并返回结果
+    }
+
+    public int update(Bed bed) { // 更新床位记录的方法
+        return bedMapper.update(bed); // 调用Mapper层的update方法并返回结果
+    }
+
+    public int updateSelective(Bed bed) { // 选择性更新床位记录的方法
+        return bedMapper.updateSelective(bed); // 调用Mapper层的updateSelective方法并返回结果
+    }
+
+    public PageInfo<Bed> query(Bed bed) { // 查询床位记录的方法，支持分页
+        if(bed != null && bed.getPage() != null){ // 如果床位对象和分页参数不为空
+            PageHelper.startPage(bed.getPage(),bed.getLimit()); // 设置分页参数
+        }
+        return new PageInfo<Bed>(bedMapper.query(bed)); // 调用Mapper层的query方法并封装成PageInfo对象返回
+    }
+
+    public Bed detail(Integer id) { // 根据ID获取床位详情的方法
+        return bedMapper.detail(id); // 调用Mapper层的detail方法并返回结果
+    }
+
+    public int count(Bed bed) { // 统计床位记录数量的方法
+        return bedMapper.count(bed); // 调用Mapper层的count方法并返回结果
+    }
+}

zy/BuildingService.java

@@ -0,0 +1,71 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.entity.Storey; // 导入Storey实体类
+import com.yanzhen.mapper.BuildingMapper; // 导入BuildingMapper接口
+import com.yanzhen.entity.Building; // 导入Building实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作
+
+@Service // 标记为服务层组件
+public class BuildingService { // 定义BuildingService类
+
+    @Autowired // 自动注入BuildingMapper依赖
+    private BuildingMapper buildingMapper;
+    @Autowired // 自动注入StoreyService依赖
+    private StoreyService storeyService;
+
+    public int create(Building building) { // 创建Building记录的方法
+        int row = 0; // 初始化受影响行数为0
+        row = buildingMapper.create(building); // 调用Mapper方法插入Building记录
+        Integer storeyNum = building.getStoreyNum(); // 获取建筑的楼层数量
+        for(int i=1;i<=storeyNum;i++){ // 循环创建每一层
+            Storey storey = new Storey(); // 实例化Storey对象
+            storey.setBuildingId(building.getId()); // 设置Storey所属的建筑ID
+            storey.setName(i+"层"); // 设置Storey的名称为“X层”
+            storeyService.create(storey); // 调用StoreyService方法插入Storey记录
+        }
+        return row; // 返回受影响行数
+    }
+
+    public int delete(String ids) { // 根据多个ID删除Building记录的方法
+        String[] arr = ids.split(","); // 将传入的ID字符串按逗号分割成数组
+        int row = 0; // 初始化受影响行数为0
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                buildingMapper.delete(Integer.parseInt(s)); // 调用Mapper方法删除对应ID的Building记录
+            row++; // 受影响行数加1
+            }
+        }
+        return row; // 返回受影响行数
+    }
+
+    public int delete(Integer id) { // 根据单个ID删除Building记录的方法
+        return buildingMapper.delete(id); // 调用Mapper方法删除对应ID的Building记录并返回受影响行数
+    }
+
+    public int update(Building building) { // 更新Building记录的方法
+        return buildingMapper.update(building); // 调用Mapper方法更新Building记录并返回受影响行数
+    }
+
+    public int updateSelective(Building building) { // 选择性更新Building记录的方法
+        return buildingMapper.updateSelective(building); // 调用Mapper方法选择性更新Building记录并返回受影响行数
+    }
+
+    public PageInfo<Building> query(Building building) { // 查询Building记录的方法，支持分页
+        if(building != null && building.getPage() != null){ // 如果Building对象和分页参数不为空
+            PageHelper.startPage(building.getPage(),building.getLimit()); // 启动分页，设置当前页和每页显示条数
+        }
+        return new PageInfo<Building>(buildingMapper.query(building)); // 调用Mapper方法查询Building记录，并封装成PageInfo对象返回
+    }
+
+    public Building detail(Integer id) { // 根据ID查询Building详情的方法
+        return buildingMapper.detail(id); // 调用Mapper方法查询对应ID的Building记录并返回
+    }
+
+    public int count(Building building) { // 统计Building记录数量的方法
+        return buildingMapper.count(building); // 调用Mapper方法统计Building记录数量并返回
+    }
+}

zy/DormitoryService.java

@@ -0,0 +1,112 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.entity.Bed; // 导入Bed实体类
+import com.yanzhen.entity.Building; // 导入Building实体类
+import com.yanzhen.entity.DormitorySet; // 导入DormitorySet实体类
+import com.yanzhen.mapper.BedMapper; // 导入BedMapper接口
+import com.yanzhen.mapper.BuildingMapper; // 导入BuildingMapper接口
+import com.yanzhen.mapper.DormitoryMapper; // 导入DormitoryMapper接口
+import com.yanzhen.entity.Dormitory; // 导入Dormitory实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页插件
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import com.yanzhen.mapper.DormitorySetMapper; // 导入DormitorySetMapper接口
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的@Autowired注解
+import org.springframework.stereotype.Service; // 导入Spring的@Service注解
+import org.springframework.transaction.annotation.Transactional; // 导入Spring的@Transactional注解
+import org.springframework.util.StringUtils; // 导入Spring的StringUtils工具类
+
+import java.util.List; // 导入Java的List集合类
+
+@Service // 标注这是一个服务层的Bean
+public class DormitoryService {
+
+    @Autowired // 自动注入DormitoryMapper依赖
+    private DormitoryMapper dormitoryMapper;
+    @Autowired // 自动注入DormitorySetMapper依赖
+    private DormitorySetMapper dormitorySetMapper;
+    @Autowired // 自动注入BuildingMapper依赖
+    private BuildingMapper buildingMapper;
+    @Autowired // 自动注入BedMapper依赖
+    private BedMapper bedMapper;
+
+    public int create(Dormitory dormitory) { // 创建宿舍记录
+        return dormitoryMapper.create(dormitory); // 调用DormitoryMapper的create方法
+    }
+
+    public int delete(String ids) { // 根据ID字符串批量删除宿舍记录
+        String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组
+        int row = 0; // 初始化删除计数器
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                dormitoryMapper.delete(Integer.parseInt(s)); // 调用DormitoryMapper的delete方法删除记录
+            row++; // 删除计数器加1
+            }
+        }
+        return row; // 返回删除的记录数
+    }
+
+    public int delete(Integer id) { // 根据ID删除单个宿舍记录
+        return dormitoryMapper.delete(id); // 调用DormitoryMapper的delete方法
+    }
+
+    public int update(Dormitory dormitory) { // 更新宿舍记录
+        return dormitoryMapper.update(dormitory); // 调用DormitoryMapper的update方法
+    }
+
+    public int updateSelective(Dormitory dormitory) { // 选择性更新宿舍记录
+        return dormitoryMapper.updateSelective(dormitory); // 调用DormitoryMapper的updateSelective方法
+    }
+
+    public PageInfo<Dormitory> query(Dormitory dormitory) { // 查询宿舍记录并分页
+        if(dormitory != null && dormitory.getPage() != null){ // 如果宿舍对象和分页信息不为空
+            PageHelper.startPage(dormitory.getPage(),dormitory.getLimit()); // 设置分页参数
+        }
+        return new PageInfo<Dormitory>(dormitoryMapper.query(dormitory)); // 返回分页后的宿舍记录列表
+    }
+
+    public Dormitory detail(Integer id) { // 根据ID查询单个宿舍详情
+        return dormitoryMapper.detail(id); // 调用DormitoryMapper的detail方法
+    }
+
+    public int count(Dormitory dormitory) { // 统计符合条件的宿舍记录数
+        return dormitoryMapper.count(dormitory); // 调用DormitoryMapper的count方法
+    }
+
+    @Transactional // 声明该方法需要事务管理
+    public void init(Dormitory dormitory){ // 初始化宿舍数据
+        DormitorySet param = new DormitorySet(); // 创建DormitorySet对象
+        param.setBuildingId(dormitory.getBuildingId()); // 设置建筑ID
+        param.setStoreyId(dormitory.getStoreyId()); // 设置楼层ID
+        List<DormitorySet> dormitorySets = dormitorySetMapper.query(param); // 查询宿舍设置信息
+        Building building = buildingMapper.detail(dormitory.getBuildingId()); // 查询建筑详细信息
+
+        //删除已有床位（先查询出来，然后批量删除）
+        List<Dormitory> dormitoryList = dormitoryMapper.query(dormitory); // 查询现有的宿舍记录
+        dormitoryList.forEach(item->{ // 遍历宿舍记录列表
+            bedMapper.deleteByDormitoryId(item.getId()); // 删除每个宿舍对应的床位记录
+        });
+        //删除以有的数据(删除已有宿舍)
+        dormitoryMapper.deleteByBuildingIdAndStoryId(dormitory.getBuildingId(),dormitory.getStoreyId()); // 删除指定建筑和楼层的所有宿舍记录
+
+        dormitorySets.forEach(dormitorySet -> { // 遍历宿舍设置信息列表
+
+            for(int i=dormitorySet.getStart();i<=dormitorySet.getEnd();i++){ // 根据起始和结束编号生成宿舍编号
+                Dormitory entity = new Dormitory(); // 创建新的宿舍对象
+                entity.setNo(dormitorySet.getPrefix()+i); // 设置宿舍编号
+                entity.setBuildingId(dormitory.getBuildingId()); // 设置建筑ID
+                entity.setStoreyId(dormitory.getStoreyId()); // 设置楼层ID
+                entity.setCapacity(dormitorySet.getCapacity()); // 设置宿舍容量
+                entity.setSex(building.getSex()); // 设置宿舍性别限制
+                entity.setType(building.getType()); // 设置宿舍类型
+                dormitoryMapper.create(entity); // 创建新的宿舍记录
+                for(int j=1;j<=entity.getCapacity();j++){ // 根据宿舍容量生成床位记录
+                    Bed bed = new Bed(); // 创建新的床位对象
+                    bed.setBno(entity.getNo()+"-"+j); // 设置床位编号
+                    bed.setDormitoryId(entity.getId()); // 设置所属宿舍ID
+                    bedMapper.create(bed); // 创建新的床位记录
+                }
+            }
+        });
+    }
+
+}

zy/DormitorySetService.java

@@ -0,0 +1,59 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.DormitorySetMapper; // 导入DormitorySetMapper接口
+import com.yanzhen.entity.DormitorySet; // 导入DormitorySet实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作
+
+@Service // 标记为服务层组件
+public class DormitorySetService { // 定义DormitorySetService类
+
+    @Autowired // 自动装配DormitorySetMapper依赖
+    private DormitorySetMapper dormitorySetMapper;
+
+    public int create(DormitorySet dormitorySet) { // 创建DormitorySet记录的方法
+        return dormitorySetMapper.create(dormitorySet); // 调用Mapper层的create方法
+    }
+
+    public int delete(String ids) { // 根据ID字符串批量删除DormitorySet记录的方法
+        String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组
+        int row = 0; // 初始化受影响行数为0
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                dormitorySetMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录
+            row++; // 受影响行数加1
+            }
+        }
+        return row; // 返回受影响行数
+    }
+
+    public int delete(Integer id) { // 根据ID删除DormitorySet记录的方法
+        return dormitorySetMapper.delete(id); // 调用Mapper层的delete方法
+    }
+
+    public int update(DormitorySet dormitorySet) { // 更新DormitorySet记录的方法
+        return dormitorySetMapper.update(dormitorySet); // 调用Mapper层的update方法
+    }
+
+    public int updateSelective(DormitorySet dormitorySet) { // 选择性更新DormitorySet记录的方法
+        return dormitorySetMapper.updateSelective(dormitorySet); // 调用Mapper层的updateSelective方法
+    }
+
+    public PageInfo<DormitorySet> query(DormitorySet dormitorySet) { // 查询DormitorySet记录列表的方法
+        if(dormitorySet != null && dormitorySet.getPage() != null){ // 如果DormitorySet对象和分页参数不为空
+            PageHelper.startPage(dormitorySet.getPage(),dormitorySet.getLimit()); // 启动分页并设置分页参数
+        }
+        return new PageInfo<DormitorySet>(dormitorySetMapper.query(dormitorySet)); // 返回分页后的查询结果
+    }
+
+    public DormitorySet detail(Integer id) { // 根据ID获取DormitorySet详情的方法
+        return dormitorySetMapper.detail(id); // 调用Mapper层的detail方法
+    }
+
+    public int count(DormitorySet dormitorySet) { // 统计DormitorySet记录数量的方法
+        return dormitorySetMapper.count(dormitorySet); // 调用Mapper层的count方法
+    }
+}

zy/DormitoryStudentService.java

@@ -0,0 +1,98 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.entity.Dormitory; // 导入Dormitory实体类
+import com.yanzhen.mapper.DormitoryMapper; // 导入DormitoryMapper接口
+import com.yanzhen.mapper.DormitoryStudentMapper; // 导入DormitoryStudentMapper接口
+import com.yanzhen.entity.DormitoryStudent; // 导入DormitoryStudent实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页插件
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的@Autowired注解
+import org.springframework.stereotype.Service; // 导入Spring的@Service注解
+import org.springframework.util.StringUtils; // 导入Spring的StringUtils工具类
+
+import java.util.Date; // 导入Date类
+import java.util.List; // 导入List接口
+import java.util.Map; // 导入Map接口
+
+@Service // 标记为服务层组件
+public class DormitoryStudentService {
+
+    @Autowired // 自动注入DormitoryStudentMapper实例
+    private DormitoryStudentMapper dormitoryStudentMapper;
+    @Autowired // 自动注入DormitoryMapper实例
+    private DormitoryMapper dormitoryMapper;
+
+    public int create(DormitoryStudent dormitoryStudent) { // 创建宿舍学生记录
+        return dormitoryStudentMapper.create(dormitoryStudent); // 调用Mapper的create方法
+    }
+
+    public int delete(String ids) { // 根据ID字符串批量删除宿舍学生记录
+        String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组
+        int row = 0; // 初始化删除计数器
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                dormitoryStudentMapper.delete(Integer.parseInt(s)); // 调用Mapper的delete方法删除记录
+            row++; // 删除计数器加1
+            }
+        }
+        return row; // 返回删除的记录数
+    }
+
+    public int delete(Integer id) { // 根据ID删除宿舍学生记录
+        return dormitoryStudentMapper.delete(id); // 调用Mapper的delete方法
+    }
+
+    public int update(DormitoryStudent dormitoryStudent) { // 更新宿舍学生记录
+        return dormitoryStudentMapper.update(dormitoryStudent); // 调用Mapper的update方法
+    }
+
+    public int updateSelective(DormitoryStudent dormitoryStudent) { // 选择性更新宿舍学生记录
+        return dormitoryStudentMapper.updateSelective(dormitoryStudent); // 调用Mapper的updateSelective方法
+    }
+
+    public PageInfo<DormitoryStudent> query(DormitoryStudent dormitoryStudent) { // 查询宿舍学生记录并分页
+        if(dormitoryStudent != null && dormitoryStudent.getPage() != null){ // 如果查询条件和分页信息不为空
+            PageHelper.startPage(dormitoryStudent.getPage(),dormitoryStudent.getLimit()); // 设置分页参数
+        }
+        return new PageInfo<DormitoryStudent>(dormitoryStudentMapper.query(dormitoryStudent)); // 返回分页结果
+    }
+
+    public DormitoryStudent detail(Integer id) { // 根据ID查询宿舍学生详情
+        return dormitoryStudentMapper.detail(id); // 调用Mapper的detail方法
+    }
+
+    public int count(DormitoryStudent dormitoryStudent) { // 统计宿舍学生记录数
+        return dormitoryStudentMapper.count(dormitoryStudent); // 调用Mapper的count方法
+    }
+
+    public synchronized int select_dormitory_submit(Integer studentId,Integer dormitoryId,Integer bedId){ // 提交选择宿舍操作
+        Dormitory detail = dormitoryMapper.detail(dormitoryId); // 获取宿舍详情
+        //获取容量
+        int capacity = detail.getCapacity(); // 获取宿舍容量
+        DormitoryStudent ds = new DormitoryStudent(); // 创建新的DormitoryStudent对象
+        ds.setDormitoryId(dormitoryId); // 设置宿舍ID
+        List<DormitoryStudent> list = dormitoryStudentMapper.query(ds); // 查询该宿舍的学生列表
+        if(list.size() == capacity){ // 如果宿舍已满
+            return 0; // 返回0表示失败
+        }else{ // 如果宿舍未满
+            dormitoryStudentMapper.deleteByCond(studentId,dormitoryId); // 删除该学生在宿舍中的现有记录
+            DormitoryStudent entity = new DormitoryStudent(); // 创建新的DormitoryStudent对象
+            entity.setDormitoryId(dormitoryId); // 设置宿舍ID
+            entity.setBedId(bedId); // 设置床位ID
+            entity.setStudentId(studentId); // 设置学生ID
+            entity.setCheckin(new Date()); // 设置入住日期为当前日期
+            entity.setStatus(1); // 设置状态为1（入住）
+            dormitoryStudentMapper.create(entity); // 创建新的宿舍学生记录
+        }
+        return 1; // 返回1表示成功
+    }
+
+    public int countByBuildingId(Integer buildingId){ // 根据建筑ID统计宿舍学生记录数
+        return dormitoryStudentMapper.countByBuildingId(buildingId); // 调用Mapper的countByBuildingId方法
+    }
+
+    public Map<String,Object> queryStudentByBedId(Integer bedId){ // 根据床位ID查询学生信息
+        return dormitoryStudentMapper.queryStudentByBedId(bedId); // 调用Mapper的queryStudentByBedId方法
+    }
+
+}

zy/GradeService.java

@@ -0,0 +1,59 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.GradeMapper; // 导入GradeMapper接口
+import com.yanzhen.entity.Grade; // 导入Grade实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作
+
+@Service // 标注该类为服务层组件
+public class GradeService { // 定义GradeService类
+
+    @Autowired // 自动装配GradeMapper对象
+    private GradeMapper gradeMapper;
+
+    public int create(Grade grade) { // 创建Grade记录的方法
+        return gradeMapper.create(grade); // 调用GradeMapper的create方法并返回结果
+    }
+
+    public int delete(String ids) { // 根据ID字符串批量删除Grade记录的方法
+        String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组
+        int row = 0; // 初始化受影响行数为0
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                gradeMapper.delete(Integer.parseInt(s)); // 调用GradeMapper的delete方法删除记录
+                row++; // 受影响行数加1
+            }
+        }
+        return row; // 返回受影响行数
+    }
+
+    public int delete(Integer id) { // 根据ID删除单个Grade记录的方法
+        return gradeMapper.delete(id); // 调用GradeMapper的delete方法并返回结果
+    }
+
+    public int update(Grade grade) { // 更新Grade记录的方法
+        return gradeMapper.update(grade); // 调用GradeMapper的update方法并返回结果
+    }
+
+    public int updateSelective(Grade grade) { // 选择性更新Grade记录的方法
+        return gradeMapper.updateSelective(grade); // 调用GradeMapper的updateSelective方法并返回结果
+    }
+
+    public PageInfo<Grade> query(Grade grade) { // 查询Grade记录列表的方法
+        if(grade != null && grade.getPage() != null){ // 如果Grade对象和分页参数不为空
+            PageHelper.startPage(grade.getPage(),grade.getLimit()); // 启动分页并设置分页参数
+        }
+        return new PageInfo<Grade>(gradeMapper.query(grade)); // 调用GradeMapper的query方法并返回分页信息
+    }
+
+    public Grade detail(Integer id) { // 根据ID获取Grade详情的方法
+        return gradeMapper.detail(id); // 调用GradeMapper的detail方法并返回结果
+    }
+
+    public int count(Grade grade) { // 统计Grade记录数量的方法
+        return gradeMapper.count(grade); // 调用GradeMapper的count方法并返回结果
+    }
+}

zy/MenuService.java

@@ -0,0 +1,31 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.MenuMapper; // 导入MenuMapper接口
+import com.yanzhen.entity.Menu; // 导入Menu实体类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+
+import java.util.List; // 导入List集合类
+
+@Service // 标记为服务层组件
+public class MenuService { // 定义MenuService类
+
+    @Autowired // 自动注入MenuMapper依赖
+    private MenuMapper menuMapper;
+
+    public List<Menu> query(Integer userId){ // 根据用户ID查询菜单的方法
+        return menuMapper.query(userId); // 调用menuMapper的query方法并返回结果
+    }
+    public List<Menu> list(){ // 查询所有菜单的方法
+        return menuMapper.list(); // 调用menuMapper的list方法并返回结果
+    }
+
+    public List<Integer> queryCheckMenuId(Integer userId){ // 根据用户ID查询选中的菜单ID的方法
+        return menuMapper.queryCheckMenuId(userId); // 调用menuMapper的queryCheckMenuId方法并返回结果
+    }
+
+    public List<Menu> queryByType(){ // 按类型查询菜单的方法
+        return menuMapper.queryByType(); // 调用menuMapper的queryByType方法并返回结果
+    }
+
+}

zy/NoticeReceiveService.java

@@ -0,0 +1,59 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.NoticeReceiveMapper; // 导入NoticeReceiveMapper接口
+import com.yanzhen.entity.NoticeReceive; // 导入NoticeReceive实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作
+
+@Service // 标注该类为服务层组件
+public class NoticeReceiveService { // 定义NoticeReceiveService类
+
+    @Autowired // 自动装配NoticeReceiveMapper对象
+    private NoticeReceiveMapper noticeReceiveMapper;
+
+    public int create(NoticeReceive noticeReceive) { // 创建NoticeReceive记录的方法
+        return noticeReceiveMapper.create(noticeReceive); // 调用Mapper层的create方法
+    }
+
+    public int delete(String ids) { // 根据ID字符串批量删除NoticeReceive记录的方法
+        String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组
+        int row = 0; // 初始化受影响行数为0
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                noticeReceiveMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录
+                row++; // 受影响行数加1
+            }
+        }
+        return row; // 返回受影响行数
+    }
+
+    public int delete(Integer id) { // 根据ID删除NoticeReceive记录的方法
+        return noticeReceiveMapper.delete(id); // 调用Mapper层的delete方法
+    }
+
+    public int update(NoticeReceive noticeReceive) { // 更新NoticeReceive记录的方法
+        return noticeReceiveMapper.update(noticeReceive); // 调用Mapper层的update方法
+    }
+
+    public int updateSelective(NoticeReceive noticeReceive) { // 选择性更新NoticeReceive记录的方法
+        return noticeReceiveMapper.updateSelective(noticeReceive); // 调用Mapper层的updateSelective方法
+    }
+
+    public PageInfo<NoticeReceive> query(NoticeReceive noticeReceive) { // 查询NoticeReceive记录列表的方法
+        if(noticeReceive != null && noticeReceive.getPage() != null){ // 如果查询条件和分页信息不为空
+            PageHelper.startPage(noticeReceive.getPage(),noticeReceive.getLimit()); // 启动分页并设置分页参数
+        }
+        return new PageInfo<NoticeReceive>(noticeReceiveMapper.query(noticeReceive)); // 调用Mapper层的query方法并封装成PageInfo对象返回
+    }
+
+    public NoticeReceive detail(Integer id) { // 根据ID获取NoticeReceive详情的方法
+        return noticeReceiveMapper.detail(id); // 调用Mapper层的detail方法
+    }
+
+    public int count(NoticeReceive noticeReceive) { // 统计NoticeReceive记录数量的方法
+        return noticeReceiveMapper.count(noticeReceive); // 调用Mapper层的count方法
+    }
+}

zy/NoticeService.java

@@ -0,0 +1,100 @@
+package com.yanzhen.service;
+
+import com.yanzhen.entity.NoticeReceive;
+import com.yanzhen.mapper.NoticeMapper;
+import com.yanzhen.entity.Notice;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.yanzhen.mapper.NoticeReceiveMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.util.List;
+
+@Service // 标记为Spring的服务组件
+public class NoticeService {
+
+    @Autowired // 自动注入NoticeMapper依赖
+    private NoticeMapper noticeMapper;
+    @Autowired // 自动注入NoticeReceiveMapper依赖
+    private NoticeReceiveMapper noticeReceiveMapper;
+
+    // 创建通知，并关联到多个建筑
+    public int create(Notice notice) {
+        noticeMapper.create(notice); // 在数据库中创建通知记录
+        List<Integer> buildingIds = notice.getBuildingIds(); // 获取通知关联的建筑ID列表
+        for (Integer buildingId : buildingIds) { // 遍历每个建筑ID
+            NoticeReceive noticeReceive = new NoticeReceive(); // 创建新的NoticeReceive对象
+            noticeReceive.setBuildingId(buildingId); // 设置建筑ID
+            noticeReceive.setNoticeId(notice.getId()); // 设置通知ID
+            noticeReceiveMapper.create(noticeReceive); // 在数据库中创建通知接收记录
+        }
+        return 1; // 返回成功标志
+    }
+
+    // 根据逗号分隔的ID字符串批量删除通知
+    public int delete(String ids) {
+        String[] arr = ids.split(","); // 将ID字符串分割成数组
+        int row = 0; // 初始化受影响行数计数器
+        for (String s : arr) { // 遍历每个ID
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                noticeReceiveMapper.deleteByNoticeId(Integer.parseInt(s)); // 删除相关的通知接收记录
+                noticeMapper.delete(Integer.parseInt(s)); // 删除通知记录
+                row++; // 增加受影响行数计数器
+            }
+        }
+        return row; // 返回受影响行数
+    }
+
+    // 根据单个ID删除通知
+    public int delete(Integer id) {
+        noticeReceiveMapper.deleteByNoticeId(id); // 删除相关的通知接收记录
+        return noticeMapper.delete(id); // 删除通知记录并返回结果
+    }
+
+    // 更新通知信息
+    public int update(Notice notice) {
+        return noticeMapper.update(notice); // 更新通知记录并返回结果
+    }
+
+    // 选择性更新通知信息，同时重新关联建筑
+    public int updateSelective(Notice notice) {
+        noticeMapper.updateSelective(notice); // 选择性更新通知记录
+        noticeReceiveMapper.deleteByNoticeId(notice.getId()); // 删除旧的通知接收记录
+        List<Integer> buildingIds = notice.getBuildingIds(); // 获取新的通知关联的建筑ID列表
+        for (Integer buildingId : buildingIds) { // 遍历每个建筑ID
+            NoticeReceive noticeReceive = new NoticeReceive(); // 创建新的NoticeReceive对象
+            noticeReceive.setBuildingId(buildingId); // 设置建筑ID
+            noticeReceive.setNoticeId(notice.getId()); // 设置通知ID
+            noticeReceiveMapper.create(noticeReceive); // 在数据库中创建新的通知接收记录
+        }
+        return 1; // 返回成功标志
+    }
+
+    // 分页查询通知
+    public PageInfo<Notice> query(Notice notice) {
+        if(notice != null && notice.getPage() != null){ // 如果通知对象和分页信息不为空
+            PageHelper.startPage(notice.getPage(), notice.getLimit()); // 启动分页
+        }
+        return new PageInfo<Notice>(noticeMapper.query(notice)); // 执行查询并返回分页结果
+    }
+
+    // 根据建筑ID分页查询通知
+    public PageInfo<Notice> queryByBuildingId(Notice notice){
+        if(notice != null && notice.getPage() != null){ // 如果通知对象和分页信息不为空
+            PageHelper.startPage(notice.getPage(), notice.getLimit()); // 启动分页
+        }
+        return new PageInfo<Notice>(noticeMapper.queryByBuildingId(notice)); // 执行查询并返回分页结果
+    }
+
+    // 根据ID获取通知详情
+    public Notice detail(Integer id) {
+        return noticeMapper.detail(id); // 查询并返回通知详情
+    }
+
+    // 统计符合条件的通知数量
+    public int count(Notice notice) {
+        return noticeMapper.count(notice); // 查询并返回符合条件的通知数量
+    }
+}

zy/OrgService.java

@@ -0,0 +1,65 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.OrgMapper; // 导入OrgMapper接口
+import com.yanzhen.entity.Org; // 导入Org实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作
+
+import java.util.List; // 导入Java的List接口
+
+@Service // 标注该类为服务层组件
+public class OrgService { // 定义OrgService类
+
+    @Autowired // 自动装配OrgMapper对象
+    private OrgMapper orgMapper;
+
+    public int create(Org org) { // 创建Org记录的方法
+        return orgMapper.create(org); // 调用Mapper层的create方法
+    }
+
+    public int delete(String ids) { // 根据ID字符串批量删除Org记录的方法
+        String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组
+        int row = 0; // 初始化受影响行数为0
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                orgMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录
+                row++; // 受影响行数加1
+            }
+        }
+        return row; // 返回受影响行数
+    }
+
+    public int delete(Integer id) { // 根据ID删除Org记录的方法
+        return orgMapper.delete(id); // 调用Mapper层的delete方法
+    }
+
+    public int update(Org org) { // 更新Org记录的方法
+        return orgMapper.update(org); // 调用Mapper层的update方法
+    }
+
+    public int updateSelective(Org org) { // 选择性更新Org记录的方法
+        return orgMapper.updateSelective(org); // 调用Mapper层的updateSelective方法
+    }
+
+    public PageInfo<Org> query(Org org) { // 查询Org记录列表的方法
+        if(org != null && org.getPage() != null){ // 如果查询条件和分页信息不为空
+            PageHelper.startPage(org.getPage(),org.getLimit()); // 启动分页并设置分页参数
+        }
+        return new PageInfo<Org>(orgMapper.query(org)); // 调用Mapper层的query方法并封装成PageInfo对象返回
+    }
+
+    public Org detail(Integer id) { // 根据ID获取Org详情的方法
+        return orgMapper.detail(id); // 调用Mapper层的detail方法
+    }
+
+    public int count(Org org) { // 统计Org记录数量的方法
+        return orgMapper.count(org); // 调用Mapper层的count方法
+    }
+
+    public List<Org> queryOrgBySelectionId(Integer selectionId){ // 根据selectionId查询Org列表的方法
+        return orgMapper.queryOrgBySelectionId(selectionId); // 调用Mapper层的queryOrgBySelectionId方法
+    }
+}

zy/RecordService.java

@@ -0,0 +1,59 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.RecordMapper; // 导入RecordMapper接口
+import com.yanzhen.entity.Record; // 导入Record实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作
+
+@Service // 标注该类为服务层组件
+public class RecordService { // 定义RecordService类
+
+    @Autowired // 自动装配RecordMapper对象
+    private RecordMapper recordMapper;
+
+    public int create(Record record) { // 创建记录的方法
+        return recordMapper.create(record); // 调用Mapper层的create方法
+    }
+
+    public int delete(String ids) { // 根据ID字符串批量删除记录的方法
+        String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组
+        int row = 0; // 初始化受影响行数为0
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                recordMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录
+                row++; // 受影响行数加1
+            }
+        }
+        return row; // 返回受影响行数
+    }
+
+    public int delete(Integer id) { // 根据ID删除记录的方法
+        return recordMapper.delete(id); // 调用Mapper层的delete方法
+    }
+
+    public int update(Record record) { // 更新记录的方法
+        return recordMapper.update(record); // 调用Mapper层的update方法
+    }
+
+    public int updateSelective(Record record) { // 选择性更新记录的方法
+        return recordMapper.updateSelective(record); // 调用Mapper层的updateSelective方法
+    }
+
+    public PageInfo<Record> query(Record record) { // 查询记录列表的方法
+        if(record != null && record.getPage() != null){ // 如果查询条件和分页信息不为空
+            PageHelper.startPage(record.getPage(),record.getLimit()); // 启动分页并设置分页参数
+        }
+        return new PageInfo<Record>(recordMapper.query(record)); // 调用Mapper层的query方法并封装成PageInfo对象返回
+    }
+
+    public Record detail(Integer id) { // 根据ID获取详情的方法
+        return recordMapper.detail(id); // 调用Mapper层的detail方法
+    }
+
+    public int count(Record record) { // 统计记录数量的方法
+        return recordMapper.count(record); // 调用Mapper层的count方法
+    }
+}

zy/RepairService.java

@@ -0,0 +1,123 @@
+package com.yanzhen.service;
+
+import com.yanzhen.mapper.RepairMapper;
+import com.yanzhen.entity.Repair;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+@Service
+public class RepairService {// 自动注入RepairMapper接口，用于数据库操作
+
+    @Autowired
+    private RepairMapper repairMapper;
+
+    /**
+     * 创建一个新的维修记录
+     * @param repair 包含维修信息的Repair对象
+     * @return 返回插入操作的结果，通常是受影响的行数
+     */
+    public int create(Repair repair) {//创建一个新的维修记录,@param repair 包含维修信息的Repair对象, @return 返回插入操作的结果，通常是受影响的行数
+        // 调用repairMapper的create方法将repair对象插入数据库
+        return repairMapper.create(repair);
+    }
+
+    /**
+     * 删除指定ID的记录
+     * @param ids 以逗号分隔的字符串，包含要删除的记录ID
+     * @return 成功删除的记录数
+     */
+    public int delete(String ids) {//删除指定ID的记录,@param ids 以逗号分隔的字符串，包含要删除的记录ID, @return 成功删除的记录数
+    
+        // 将传入的ID字符串按逗号分割成数组
+        String[] arr = ids.split(",");
+        // 初始化删除计数器
+        int row = 0;
+        // 遍历ID数组
+        for (String s : arr) {
+            // 如果当前ID不为空
+            if(!StringUtils.isEmpty(s)){
+                // 调用repairMapper的delete方法删除对应ID的记录
+                repairMapper.delete(Integer.parseInt(s));
+                // 删除计数器加1
+                row++;
+            }
+        }
+        // 返回成功删除的记录数
+        return row;
+    }
+
+    /**
+     * 删除指定ID的记录
+     * @param id 要删除的记录的ID
+     * @return 返回删除操作的结果，通常是受影响的行数
+     */
+    public int delete(Integer id) {//删除指定ID的记录,@param id 要删除的记录的ID, @return 返回删除操作的结果，通常是受影响的行数
+    
+        // 调用repairMapper对象的delete方法，传入要删除的记录ID
+        return repairMapper.delete(id);
+    }
+
+    /**
+     * 更新维修记录
+     *
+     * @param repair 需要更新的维修记录对象
+     * @return 更新操作影响的行数
+     */
+    public int update(Repair repair) {//更新维修记录,@param repair 需要更新的维修记录对象, @return 更新操作影响的行数
+    
+        // 调用repairMapper的update方法，将传入的repair对象进行更新操作
+        return repairMapper.update(repair);
+    }
+
+    /**
+     * 更新维修记录，只更新非空字段
+     * @param repair 包含需要更新的维修记录信息的对象
+     * @return 返回更新操作影响的行数
+     */
+    public int updateSelective(Repair repair) {//更新维修记录，只更新非空字段,@param repair 包含需要更新的维修记录信息的对象, @return 返回更新操作影响的行数
+    
+        // 调用repairMapper的updateSelective方法，传入repair对象进行更新操作
+        return repairMapper.updateSelective(repair);
+    }
+
+    /**
+     * 查询维修记录的方法
+     * @param repair 包含查询条件的Repair对象
+     * @return 包含查询结果的PageInfo对象
+     */
+    public PageInfo<Repair> query(Repair repair) {//查询维修记录的方法,@param repair 包含查询条件的Repair对象, @return 包含查询结果的PageInfo对象
+    
+        // 如果repair对象和其分页信息不为空
+        if(repair != null && repair.getPage() != null){
+            // 使用PageHelper设置分页参数，开始分页
+            PageHelper.startPage(repair.getPage(), repair.getLimit());
+        }
+        // 返回包含查询结果的PageInfo对象
+        return new PageInfo<Repair>(repairMapper.query(repair));
+    }
+
+    /**
+     * 获取指定ID的维修详情
+     * @param id 维修记录的唯一标识符
+     * @return 返回对应ID的维修详情对象
+     */
+    public Repair detail(Integer id) {//获取指定ID的维修详情,@param id 维修记录的唯一标识符, @return 返回对应ID的维修详情对象
+    
+        // 调用repairMapper对象的detail方法，根据传入的id获取对应的维修详情
+        return repairMapper.detail(id);
+    }
+
+    /**
+     * 计算维修记录的数量
+     * @param repair 包含查询条件的Repair对象
+     * @return 返回符合条件的维修记录数量
+     */
+    public int count(Repair repair) {//计算维修记录的数量,@param repair 包含查询条件的Repair对象, @return 返回符合条件的维修记录数量
+
+        // 调用repairMapper的count方法，传入repair对象，返回符合条件的维修记录数量
+        return repairMapper.count(repair);
+    }
+}

zy/SelectionDormitoryService.java

@@ -0,0 +1,77 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.SelectionDormitoryMapper; // 导入SelectionDormitoryMapper类
+import com.yanzhen.entity.SelectionDormitory; // 导入SelectionDormitory实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的@Autowired注解
+import org.springframework.stereotype.Service; // 导入Spring的@Service注解
+import org.springframework.util.StringUtils; // 导入Spring的StringUtils工具类
+
+@Service // 标记该类为Spring的服务层组件
+public class SelectionDormitoryService {
+
+    @Autowired // 自动注入SelectionDormitoryMapper依赖
+    private SelectionDormitoryMapper selectionDormitoryMapper;
+
+    // 创建选择宿舍记录的方法
+    public int create(String clazzId, String dormitoryIds) {
+        String[] arr = dormitoryIds.split(","); // 将宿舍ID字符串按逗号分割成数组
+        selectionDormitoryMapper.deleteByClazzId(Integer.parseInt(clazzId)); // 根据班级ID删除已有的选择记录
+        for (String s : arr) { // 遍历宿舍ID数组
+            if (!StringUtils.isEmpty(s)) { // 如果宿舍ID不为空
+                SelectionDormitory selectionDormitory = new SelectionDormitory(); // 创建新的选择宿舍对象
+                selectionDormitory.setClazzId(Integer.parseInt(clazzId)); // 设置班级ID
+                selectionDormitory.setDormitoryId(Integer.parseInt(s)); // 设置宿舍ID
+                selectionDormitoryMapper.create(selectionDormitory); // 插入新的选择宿舍记录
+            }
+        }
+        return 1; // 返回操作成功标志
+    }
+
+    // 批量删除选择宿舍记录的方法
+    public int delete(String ids) {
+        String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组
+        int row = 0; // 初始化受影响行数计数器
+        for (String s : arr) { // 遍历ID数组
+            if (!StringUtils.isEmpty(s)) { // 如果ID不为空
+                selectionDormitoryMapper.delete(Integer.parseInt(s)); // 删除对应的选择宿舍记录
+                row++; // 增加受影响行数计数器
+            }
+        }
+        return row; // 返回受影响行数
+    }
+
+    // 根据ID删除选择宿舍记录的方法
+    public int delete(Integer id) {
+        return selectionDormitoryMapper.delete(id); // 调用Mapper方法删除记录并返回结果
+    }
+
+    // 更新选择宿舍记录的方法
+    public int update(SelectionDormitory selectionDormitory) {
+        return selectionDormitoryMapper.update(selectionDormitory); // 调用Mapper方法更新记录并返回结果
+    }
+
+    // 选择性更新选择宿舍记录的方法
+    public int updateSelective(SelectionDormitory selectionDormitory) {
+        return selectionDormitoryMapper.updateSelective(selectionDormitory); // 调用Mapper方法选择性更新记录并返回结果
+    }
+
+    // 查询选择宿舍记录的方法，支持分页
+    public PageInfo<SelectionDormitory> query(SelectionDormitory selectionDormitory) {
+        if (selectionDormitory != null && selectionDormitory.getPage() != null) { // 如果查询条件和分页信息不为空
+            PageHelper.startPage(selectionDormitory.getPage(), selectionDormitory.getLimit()); // 启动分页
+        }
+        return new PageInfo<SelectionDormitory>(selectionDormitoryMapper.query(selectionDormitory)); // 执行查询并返回分页信息
+    }
+
+    // 根据ID查询选择宿舍详情的方法
+    public SelectionDormitory detail(Integer id) {
+        return selectionDormitoryMapper.detail(id); // 调用Mapper方法查询详情并返回结果
+    }
+
+    // 统计选择宿舍记录数量的方法
+    public int count(SelectionDormitory selectionDormitory) {
+        return selectionDormitoryMapper.count(selectionDormitory); // 调用Mapper方法统计记录数量并返回结果
+    }
+}

zy/SelectionJoinerService.java

@@ -0,0 +1,59 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.SelectionJoinerMapper; // 导入SelectionJoinerMapper接口
+import com.yanzhen.entity.SelectionJoiner; // 导入SelectionJoiner实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作
+
+@Service // 标注该类为服务层组件
+public class SelectionJoinerService { // 定义SelectionJoinerService类
+
+    @Autowired // 自动装配SelectionJoinerMapper对象
+    private SelectionJoinerMapper selectionJoinerMapper;
+
+    public int create(SelectionJoiner selectionJoiner) { // 创建SelectionJoiner记录的方法
+        return selectionJoinerMapper.create(selectionJoiner); // 调用Mapper层的create方法
+    }
+
+    public int delete(String ids) { // 根据ID字符串批量删除SelectionJoiner记录的方法
+        String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组
+        int row = 0; // 初始化受影响行数为0
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                selectionJoinerMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录
+                row++; // 受影响行数加1
+            }
+        }
+        return row; // 返回受影响行数
+    }
+
+    public int delete(Integer id) { // 根据ID删除SelectionJoiner记录的方法
+        return selectionJoinerMapper.delete(id); // 调用Mapper层的delete方法
+    }
+
+    public int update(SelectionJoiner selectionJoiner) { // 更新SelectionJoiner记录的方法
+        return selectionJoinerMapper.update(selectionJoiner); // 调用Mapper层的update方法
+    }
+
+    public int updateSelective(SelectionJoiner selectionJoiner) { // 选择性更新SelectionJoiner记录的方法
+        return selectionJoinerMapper.updateSelective(selectionJoiner); // 调用Mapper层的updateSelective方法
+    }
+
+    public PageInfo<SelectionJoiner> query(SelectionJoiner selectionJoiner) { // 查询SelectionJoiner记录列表的方法
+        if(selectionJoiner != null && selectionJoiner.getPage() != null){ // 如果查询条件和分页信息不为空
+            PageHelper.startPage(selectionJoiner.getPage(),selectionJoiner.getLimit()); // 启动分页并设置分页参数
+        }
+        return new PageInfo<SelectionJoiner>(selectionJoinerMapper.query(selectionJoiner)); // 调用Mapper层的query方法并封装成PageInfo对象返回
+    }
+
+    public SelectionJoiner detail(Integer id) { // 根据ID获取SelectionJoiner详情的方法
+        return selectionJoinerMapper.detail(id); // 调用Mapper层的detail方法
+    }
+
+    public int count(SelectionJoiner selectionJoiner) { // 统计SelectionJoiner记录数量的方法
+        return selectionJoinerMapper.count(selectionJoiner); // 调用Mapper层的count方法
+    }
+}

zy/SelectionService.java

@@ -0,0 +1,110 @@
+package com.yanzhen.service;
+
+import com.yanzhen.entity.Org;
+import com.yanzhen.entity.SelectionJoiner;
+import com.yanzhen.mapper.SelectionJoinerMapper;
+import com.yanzhen.mapper.SelectionMapper;
+import com.yanzhen.entity.Selection;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Service // 标记该类为Spring的服务组件
+public class SelectionService {
+
+    @Autowired // 自动注入SelectionMapper依赖
+    private SelectionMapper selectionMapper;
+    @Autowired // 自动注入OrgService依赖
+    private OrgService orgService;
+
+    @Autowired // 自动注入SelectionJoinerMapper依赖
+    private SelectionJoinerMapper selectionJoinerMapper;
+
+    @Transactional // 声明该方法需要事务管理
+    public int create(Selection selection) {
+        selectionMapper.create(selection); // 创建新的Selection记录
+        List<Integer> clazzIds = selection.getClazzIds(); // 获取班级ID列表
+        //筛选出对应的班级
+        List<Integer> selectIds = new ArrayList(); // 初始化选择的班级ID列表
+        clazzIds.forEach(item->{ // 遍历班级ID列表
+            Org detail = orgService.detail(item); // 获取班级详细信息
+            if(detail.getType() == 4){ // 如果班级类型为4
+                selectIds.add(detail.getId()); // 将班级ID添加到选择的班级ID列表中
+            }
+        });
+        selectIds.forEach(item->{ // 遍历选择的班级ID列表
+            SelectionJoiner joiner = new SelectionJoiner(); // 创建新的SelectionJoiner对象
+            joiner.setClazzId(item); // 设置班级ID
+            joiner.setSelectionId(selection.getId()); // 设置Selection ID
+            selectionJoinerMapper.create(joiner); // 创建新的SelectionJoiner记录
+        });
+        return 1; // 返回操作成功标志
+    }
+
+    public int delete(String ids) {
+        String[] arr = ids.split(","); // 将传入的ID字符串按逗号分割成数组
+        int row = 0; // 初始化删除计数器
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                selectionMapper.delete(Integer.parseInt(s)); // 根据ID删除Selection记录
+                row++; // 删除计数器加一
+            }
+        }
+        return row; // 返回删除的记录数
+    }
+
+    public int delete(Integer id) {
+        return selectionMapper.delete(id); // 根据ID删除Selection记录并返回操作结果
+    }
+
+    public int update(Selection selection) {
+        selectionMapper.update(selection); // 更新Selection记录
+        //先删除已设置的信息
+        selectionJoinerMapper.deleteBySelectionId(selection.getId()); // 根据Selection ID删除所有相关的SelectionJoiner记录
+        List<Integer> clazzIds = selection.getClazzIds(); // 获取班级ID列表
+        //筛选出对应的班级
+        List<Integer> selectIds = new ArrayList(); // 初始化选择的班级ID列表
+        clazzIds.forEach(item->{ // 遍历班级ID列表
+            Org detail = orgService.detail(item); // 获取班级详细信息
+            if(detail.getType() == 4){ // 如果班级类型为4
+                selectIds.add(detail.getId()); // 将班级ID添加到选择的班级ID列表中
+            }
+        });
+        selectIds.forEach(item->{ // 遍历选择的班级ID列表
+            SelectionJoiner joiner = new SelectionJoiner(); // 创建新的SelectionJoiner对象
+            joiner.setClazzId(item); // 设置班级ID
+            joiner.setSelectionId(selection.getId()); // 设置Selection ID
+            selectionJoinerMapper.create(joiner); // 创建新的SelectionJoiner记录
+        });
+        return 1; // 返回操作成功标志
+    }
+
+    public int updateSelective(Selection selection) {
+        return selectionMapper.updateSelective(selection); // 选择性更新Selection记录并返回操作结果
+    }
+
+    public PageInfo<Selection> query(Selection selection) {
+        if(selection != null && selection.getPage() != null){ // 如果Selection对象和分页信息不为空
+            PageHelper.startPage(selection.getPage(),selection.getLimit()); // 启动分页查询
+        }
+        return new PageInfo<Selection>(selectionMapper.query(selection)); // 执行查询并返回分页结果
+    }
+
+    public List<Selection> queryByClazzId(Integer clazzId){
+        return selectionMapper.queryByClazzId(clazzId); // 根据班级ID查询Selection记录并返回结果列表
+    }
+
+    public Selection detail(Integer id) {
+        return selectionMapper.detail(id); // 根据ID查询Selection详情并返回结果
+    }
+
+    public int count(Selection selection) {
+        return selectionMapper.count(selection); // 统计符合条件的Selection记录数并返回结果
+    }
+}

zy/StoreyService.java

@@ -0,0 +1,59 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.StoreyMapper; // 导入StoreyMapper接口
+import com.yanzhen.entity.Storey; // 导入Storey实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作
+
+@Service // 标注该类为服务层组件
+public class StoreyService { // 定义StoreyService类
+
+    @Autowired // 自动装配StoreyMapper对象
+    private StoreyMapper storeyMapper;
+
+    public int create(Storey storey) { // 创建Storey记录的方法
+        return storeyMapper.create(storey); // 调用Mapper层的create方法
+    }
+
+    public int delete(String ids) { // 根据ID字符串批量删除Storey记录的方法
+        String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组
+        int row = 0; // 初始化受影响行数为0
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                storeyMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录
+                row++; // 受影响行数加1
+            }
+        }
+        return row; // 返回受影响行数
+    }
+
+    public int delete(Integer id) { // 根据ID删除Storey记录的方法
+        return storeyMapper.delete(id); // 调用Mapper层的delete方法
+    }
+
+    public int update(Storey storey) { // 更新Storey记录的方法
+        return storeyMapper.update(storey); // 调用Mapper层的update方法
+    }
+
+    public int updateSelective(Storey storey) { // 选择性更新Storey记录的方法
+        return storeyMapper.updateSelective(storey); // 调用Mapper层的updateSelective方法
+    }
+
+    public PageInfo<Storey> query(Storey storey) { // 查询Storey记录列表的方法
+        if(storey != null && storey.getPage() != null){ // 如果查询条件和分页信息不为空
+            PageHelper.startPage(storey.getPage(),storey.getLimit()); // 启动分页并设置分页参数
+        }
+        return new PageInfo<Storey>(storeyMapper.query(storey)); // 调用Mapper层的query方法并封装成PageInfo对象返回
+    }
+
+    public Storey detail(Integer id) { // 根据ID获取Storey详情的方法
+        return storeyMapper.detail(id); // 调用Mapper层的detail方法
+    }
+
+    public int count(Storey storey) { // 统计Storey记录数量的方法
+        return storeyMapper.count(storey); // 调用Mapper层的count方法
+    }
+}

zy/StudentService.java

@@ -0,0 +1,67 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.StudentMapper; // 导入StudentMapper接口
+import com.yanzhen.entity.Student; // 导入Student实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作
+
+@Service // 标注该类为服务层组件
+public class StudentService { // 定义StudentService类
+
+    @Autowired // 自动装配StudentMapper对象
+    private StudentMapper studentMapper;
+
+    public int create(Student student) { // 创建学生记录的方法
+        return studentMapper.create(student); // 调用Mapper层的create方法
+    }
+
+    public int delete(String ids) { // 根据ID字符串批量删除学生记录的方法
+        String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组
+        int row = 0; // 初始化受影响行数为0
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                studentMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录
+                row++; // 受影响行数加1
+            }
+        }
+        return row; // 返回受影响行数
+    }
+
+    public int delete(Integer id) { // 根据ID删除学生记录的方法
+        return studentMapper.delete(id); // 调用Mapper层的delete方法
+    }
+
+    public int update(Student student) { // 更新学生记录的方法
+        return studentMapper.update(student); // 调用Mapper层的update方法
+    }
+
+    public int updateSelective(Student student) { // 选择性更新学生记录的方法
+        return studentMapper.updateSelective(student); // 调用Mapper层的updateSelective方法
+    }
+
+    public PageInfo<Student> query(Student student) { // 查询学生记录列表的方法
+        if(student != null && student.getPage() != null){ // 如果查询条件和分页信息不为空
+            PageHelper.startPage(student.getPage(),student.getLimit()); // 启动分页并设置分页参数
+        }
+        return new PageInfo<Student>(studentMapper.query(student)); // 调用Mapper层的query方法并封装成PageInfo对象返回
+    }
+
+    public Student detail(Integer id) { // 根据ID获取学生详情的方法
+        return studentMapper.detail(id); // 调用Mapper层的detail方法
+    }
+
+    public Student detailByName(String name) { // 根据姓名获取学生详情的方法
+        return studentMapper.detailByName(name); // 调用Mapper层的detailByName方法
+    }
+
+    public int count(Student student) { // 统计学生记录数量的方法
+        return studentMapper.count(student); // 调用Mapper层的count方法
+    }
+
+    public Student login(String userName,String password){ // 登录验证的方法
+        return studentMapper.login(userName,password); // 调用Mapper层的login方法进行登录验证
+    }
+}

zy/UserService.java

@@ -0,0 +1,93 @@
+package com.yanzhen.service;
+
+import com.yanzhen.mapper.MenuMapper;
+import com.yanzhen.mapper.UserMapper;
+import com.yanzhen.entity.User;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+@Service
+public class UserService {
+
+    @Autowired // 自动注入UserMapper
+    private UserMapper userMapper;
+    @Autowired // 自动注入MenuMapper
+    private MenuMapper menuMapper;
+
+    public int create(User user) {
+        //保存到中间表
+        int row = 0; // 初始化受影响的行数为0
+        userMapper.create(user); // 调用userMapper的create方法保存用户信息
+        for (Integer menuId : user.getIds()) { // 遍历用户关联的菜单ID列表
+            menuMapper.createUserMenu(user.getId(),menuId); // 将用户和菜单的关系保存到中间表
+        }
+        row = 1; // 设置受影响的行数为1，表示成功创建一条记录
+        return row; // 返回受影响的行数
+    }
+
+    public int delete(String ids) {
+        String[] arr = ids.split(","); // 将传入的字符串按逗号分割成数组
+        int row = 0; // 初始化受影响的行数为0
+        for (String s : arr) { // 遍历数组中的每个元素
+            if(!StringUtils.isEmpty(s)){ // 如果元素不为空
+                menuMapper.deleteUserMenu(Integer.parseInt(s)); // 删除中间表中对应的记录
+                userMapper.delete(Integer.parseInt(s)); // 删除用户表中对应的记录
+            row++; // 增加受影响的行数
+            }
+        }
+        return row; // 返回受影响的行数
+    }
+
+    public int delete(Integer id) {
+        menuMapper.deleteUserMenu(id); // 删除中间表中对应的记录
+        return userMapper.delete(id); // 删除用户表中对应的记录并返回受影响的行数
+    }
+
+    public int update(User user) {
+        int row = 0; // 初始化受影响的行数为0
+        userMapper.update(user); // 更新用户信息
+        menuMapper.deleteUserMenu(user.getId()); // 删除旧的用户-菜单关系
+        for (Integer menuId : user.getIds()) { // 遍历新的用户-菜单关系
+            menuMapper.createUserMenu(user.getId(),menuId); // 保存新的用户-菜单关系
+        }
+        row = 1; // 设置受影响的行数为1，表示成功更新一条记录
+        return row; // 返回受影响的行数
+    }
+
+    public int updatePwd(User user) {
+        return userMapper.updateSelective(user); // 更新用户密码并返回受影响的行数
+    }
+
+    public int updateSelective(User user) {
+        int row = 0; // 初始化受影响的行数为0
+        userMapper.updateSelective(user); // 选择性更新用户信息
+        menuMapper.deleteUserMenu(user.getId()); // 删除旧的用户-菜单关系
+        for (Integer menuId : user.getIds()) { // 遍历新的用户-菜单关系
+            menuMapper.createUserMenu(user.getId(),menuId); // 保存新的用户-菜单关系
+        }
+        row = 1; // 设置受影响的行数为1，表示成功更新一条记录
+        return row; // 返回受影响的行数
+    }
+
+    public PageInfo<User> query(User user) {
+        if(user != null && user.getPage() != null){ // 如果用户对象不为空且分页参数不为空
+            PageHelper.startPage(user.getPage(),user.getLimit()); // 设置分页参数
+        }
+        return new PageInfo<User>(userMapper.query(user)); // 查询用户列表并返回分页信息
+    }
+
+    public User login(String userName,String password){
+        return userMapper.login(userName,password); // 根据用户名和密码查询用户信息并返回
+    }
+
+    public User detail(Integer id) {
+        return userMapper.detail(id); // 根据用户ID查询用户详情并返回
+    }
+
+    public int count(User user) {
+        return userMapper.count(user); // 统计符合条件的用户数量并返回
+    }
+}

zy/VisitService.java

@@ -0,0 +1,59 @@
+package com.yanzhen.service; // 定义包名
+
+import com.yanzhen.mapper.VisitMapper; // 导入VisitMapper接口
+import com.yanzhen.entity.Visit; // 导入Visit实体类
+import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类
+import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类
+import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
+import org.springframework.stereotype.Service; // 导入Spring的服务层注解
+import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作
+
+@Service // 标注该类为服务层组件
+public class VisitService { // 定义VisitService类
+
+    @Autowired // 自动装配VisitMapper对象
+    private VisitMapper visitMapper;
+
+    public int create(Visit visit) { // 创建Visit记录的方法
+        return visitMapper.create(visit); // 调用Mapper层的create方法
+    }
+
+    public int delete(String ids) { // 根据ID字符串批量删除Visit记录的方法
+        String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组
+        int row = 0; // 初始化受影响行数为0
+        for (String s : arr) { // 遍历ID数组
+            if(!StringUtils.isEmpty(s)){ // 如果ID不为空
+                visitMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录
+                row++; // 受影响行数加1
+            }
+        }
+        return row; // 返回受影响行数
+    }
+
+    public int delete(Integer id) { // 根据ID删除Visit记录的方法
+        return visitMapper.delete(id); // 调用Mapper层的delete方法
+    }
+
+    public int update(Visit visit) { // 更新Visit记录的方法
+        return visitMapper.update(visit); // 调用Mapper层的update方法
+    }
+
+    public int updateSelective(Visit visit) { // 选择性更新Visit记录的方法
+        return visitMapper.updateSelective(visit); // 调用Mapper层的updateSelective方法
+    }
+
+    public PageInfo<Visit> query(Visit visit) { // 查询Visit记录列表的方法
+        if(visit != null && visit.getPage() != null){ // 如果查询条件和分页信息不为空
+            PageHelper.startPage(visit.getPage(),visit.getLimit()); // 启动分页并设置分页参数
+        }
+        return new PageInfo<Visit>(visitMapper.query(visit)); // 调用Mapper层的query方法并封装成PageInfo对象返回
+    }
+
+    public Visit detail(Integer id) { // 根据ID获取Visit详情的方法
+        return visitMapper.detail(id); // 调用Mapper层的detail方法
+    }
+
+    public int count(Visit visit) { // 统计Visit记录数量的方法
+        return visitMapper.count(visit); // 调用Mapper层的count方法
+    }
+}