pafphgrb2
/
ssgl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

'zsq'

Browse Source
main
ZSQ 4 months ago
parent 4c64ad2731
commit 32463b374b
92 changed files with 5808 additions and 0 deletions
Show Stats Download Patch File Download Diff File

101
zsq/Absence.java
Unescape View File

@ -0,0 +1,101 @@
package com.yanzhen.entity;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
public class Absence extends Entity{// 定义一个名为Absence缺勤的类，继承自Entity类
private Integer id;// 定义私有变量id，用于存储缺勤记录的唯一标识符
private Integer studentId;// 定义私有变量studentId，用于存储学生的唯一标识符
private Integer dormitoryId;// 定义私有变量dormitoryId，用于存储宿舍的唯一标识符
private Date startTime;// 定义私有变量startTime，用于存储缺勤开始时间
private Date endTime;// 定义私有变量endTime，用于存储缺勤结束时间
@Length(max = 200)// 定义私有变量remark，用于存储备注信息，并限制其最大长度为200个字符
private String remark;
private Student student;// 定义私有变量student，用于存储与缺勤记录关联的学生对象
private Dormitory dormitory;// 定义私有变量dormitory，用于存储与缺勤记录关联的宿舍对象
private String name;// 定义私有变量name，用于存储缺勤记录的名称或描述
public Integer getId() {// 获取id的值
return id;
}
public void setId(Integer id) {// 设置id的值
this.id = id;
}
public Integer getStudentId() {// 获取studentId的值
return studentId;
}
public void setStudentId(Integer studentId) {// 设置studentId的值
this.studentId = studentId;
}
public Integer getDormitoryId() {// 获取dormitoryId的值
return dormitoryId;
}
public void setDormitoryId(Integer dormitoryId) {// 设置dormitoryId的值
this.dormitoryId = dormitoryId;
}
public Date getStartTime() {// 获取startTime的值
return startTime;
}
public void setStartTime(Date startTime) {// 设置startTime的值
this.startTime = startTime;
}
public Date getEndTime() {// 获取endTime的值
return endTime;
}
public void setEndTime(Date endTime) {// 设置endTime的值
this.endTime = endTime;
}
public String getRemark() {// 获取remark的值
return remark;
}
public void setRemark(String remark) {// 设置remark的值
this.remark = remark;
}
public Student getStudent() {// 获取student的值
return student;
}
public void setStudent(Student student) {// 设置student的值
this.student = student;
}
public Dormitory getDormitory() {// 获取dormitory的值
return dormitory;
}
public void setDormitory(Dormitory dormitory) { // 设置dormitory的值
this.dormitory = dormitory;
}
public String getName() {// 获取name的值
return name;
}
public void setName(String name) {// 设置name的值
this.name = name;
}
}

85
zsq/AbsenceController.java
Unescape View File

@ -0,0 +1,85 @@
package com.yanzhen.controller; // 定义包名
import com.github.pagehelper.PageInfo; // 导入分页插件
import com.yanzhen.entity.Absence; // 导入Absence实体类
import com.yanzhen.entity.Dormitory; // 导入Dormitory实体类
import com.yanzhen.entity.Student; // 导入Student实体类
import com.yanzhen.service.AbsenceService缺勤管理; // 导入AbsenceService服务接口
import com.yanzhen.service.DormitoryService宿舍编号设置; // 导入DormitoryService服务接口
import com.yanzhen.service.StudentService学生管理; // 导入StudentService服务接口
import com.yanzhen.utils.Result; // 导入Result工具类
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解
import org.springframework.web.bind.annotation.*; // 导入Spring MVC的注解
import java.util.Map; // 导入Map集合
@RestController // 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中
@RequestMapping("/absence") // 设置请求路径前缀为/absence
public class AbsenceController { // 定义AbsenceController类
@Autowired // 自动注入AbsenceService实例
private AbsenceService缺勤管理 absenceService;
@Autowired // 自动注入StudentService实例
private StudentService学生管理 studentService;
@Autowired // 自动注入DormitoryService实例
private DormitoryService宿舍编号设置 dormitoryService;
@PostMapping("create") // 映射HTTP POST请求到create方法
public Result create(@RequestBody Absence absence){ // 接收请求体中的Absence对象
int flag = absenceService.create(absence); // 调用服务层创建记录
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回成功结果
}else{ // 如果创建失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("delete") // 映射HTTP GET请求到delete方法
public Result delete(String ids){ // 接收请求参数ids
int flag = absenceService.delete(ids); // 调用服务层删除记录
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回成功结果
}else{ // 如果删除失败
return Result.fail(); // 返回失败结果
}
}
@PostMapping("update") // 映射HTTP POST请求到update方法
public Result update(@RequestBody Absence absence){ // 接收请求体中的Absence对象
int flag = absenceService.updateSelective(absence); // 调用服务层更新记录
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回成功结果
}else{ // 如果更新失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("detail") // 映射HTTP GET请求到detail方法
public Absence detail(Integer id){ // 接收请求参数id
return absenceService.detail(id); // 调用服务层获取详情并返回
}
@PostMapping("query") // 映射HTTP POST请求到query方法
public Map<String,Object> query(@RequestBody Absence absence){ // 接收请求体中的Absence对象
PageInfo<Absence> pageInfo = new PageInfo<Absence>(); // 创建分页信息对象
if(absence.getName() != null){ // 如果请求体中的name属性不为空
Student detailId = studentService.detailByName(absence.getName()); // 根据name查询学生ID
if(detailId != null){ // 如果找到对应的学生ID
absence.setStudentId(detailId.getId()); // 设置学生ID到absence对象中
}else{ // 如果未找到对应的学生ID
pageInfo.setList(null); // 设置分页列表为空
pageInfo.setSize(0); // 设置分页大小为0
return Result.ok(pageInfo); // 返回空的分页结果
}
}
pageInfo = absenceService.query(absence); // 调用服务层查询记录
pageInfo.getList().forEach(entity->{ // 遍历查询结果列表
Student detail = studentService.detail(entity.getStudentId()); // 根据学生ID查询学生详情
entity.setStudent(detail); // 设置学生详情到absence对象中
Dormitory dormitory = dormitoryService.detail(entity.getDormitoryId()); // 根据宿舍ID查询宿舍详情
entity.setDormitory(dormitory); // 设置宿舍详情到absence对象中
});
return Result.ok(pageInfo); // 返回查询结果
}
}

23
zsq/AbsenceMapper.java
Unescape View File

@ -0,0 +1,23 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import com.yanzhen.entity.Absence; // 导入Absence缺勤实体类，用于操作缺勤信息
public interface AbsenceMapper { // 定义AbsenceMapper接口，提供对Absence缺勤实体进行数据库操作的方法
public int create(Absence absence); // 创建一个新的Absence缺勤记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个Absence缺勤记录，返回影响的行数
public int update(Absence absence); // 更新一个Absence缺勤记录，返回影响的行数
public int updateSelective(Absence absence); // 选择性地更新一个Absence缺勤记录，返回影响的行数
public List<Absence> query(Absence absence); // 根据条件查询Absence缺勤记录，返回符合条件的Absence缺勤列表
public Absence detail(Integer id); // 根据id查询一个Absence缺勤记录的详细信息，返回Absence缺勤对象
public int count(Absence absence); // 根据条件统计Absence缺勤记录的数量，返回记录数量
}

59
zsq/AbsenceService缺勤管理.java
Unescape View File

@ -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方法并返回结果
}
}

46
zsq/Bed.java
Unescape View File

@ -0,0 +1,46 @@
package com.yanzhen.entity; // 定义包名
import org.hibernate.validator.constraints.Length; // 导入Length注解，用于验证字符串长度
import com.yanzhen.utils.Entity; // 导入自定义的Entity类
import java.util.Map; // 导入Map接口
public class Bed extends Entity{ // 定义Bed类，继承自Entity类
private Integer id; // 定义id属性，类型为Integer
@Length(max = 50) // 使用Length注解限制bno的最大长度为50
private String bno; // 定义bno属性，类型为String
private Integer dormitoryId; // 定义dormitoryId属性，类型为Integer
private Map<String,Object> student; // 定义student属性，类型为Map，键为String，值为Object
// 以下为getter和setter方法
public Integer getId() { // 获取id的值
return id;
}
public void setId(Integer id) { // 设置id的值
this.id = id;
}
public String getBno() { // 获取bno的值
return bno;
}
public void setBno(String bno) { // 设置bno的值
this.bno = bno;
}
public Integer getDormitoryId() { // 获取dormitoryId的值
return dormitoryId;
}
public void setDormitoryId(Integer dormitoryId) { // 设置dormitoryId的值
this.dormitoryId = dormitoryId;
}
public Map<String, Object> getStudent() { // 获取student的值
return student;
}
public void setStudent(Map<String, Object> student) { // 设置student的值
this.student = student;
}
}

65
zsq/BedController.java
Unescape View File

@ -0,0 +1,65 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.Bed;
import com.yanzhen.service.BedService在线选宿舍;
import com.yanzhen.service.DormitoryStudentService宿舍预选设置;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController// 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中
@RequestMapping("/bed")// 设置请求路径前缀为/bed，所有的映射都在这个路径之下
public class BedController {
@Autowired// 自动注入BedService实例
private BedService在线选宿舍 bedService;
@Autowired// 自动注入DormitoryStudentService实例，处理与学生宿舍相关的业务逻辑
private DormitoryStudentService宿舍预选设置 dormitoryStudentService;
@PostMapping("create")// 映射HTTP POST请求到create方法
public Result create(@RequestBody Bed bed){// 从请求体中获取Bed对象
int flag = bedService.create(bed);// 调用bedService的create方法创建床位记录
if(flag>0){// 如果创建成功
return Result.ok();// 返回成功结果
}else{// 如果创建失败
return Result.fail();// 返回失败结果
}
}
@GetMapping("delete")// 映射HTTP GET请求到delete方法，删除床位记录
public Result delete(String ids){// 从请求参数中获取要删除的床位ID字符串
int flag = bedService.delete(ids);// 调用bedService的delete方法删除床位记录，传入要删除的床位ID字符串
if(flag>0){// 如果删除成功
return Result.ok();// 返回成功结果
}else{// 如果删除失败
return Result.fail();// 返回失败结果
}
}
@PostMapping("update")// 映射HTTP POST请求到update方法，更新床位信息
public Result update(@RequestBody Bed bed){// 从请求体中获取更新后的Bed对象
int flag = bedService.update(bed);// 调用bedService的update方法更新床位记录
if(flag>0){// 如果更新成功
return Result.ok();// 返回成功结果
}else{// 如果更新失败
return Result.fail();// 返回失败结果
}
}
@GetMapping("detail")// 映射HTTP GET请求到detail方法，获取床位详情
public Bed detail(Integer id){ // 从请求参数中获取床位ID
return bedService.detail(id); // 调用bedService的detail方法获取床位详情并返回
}
@PostMapping("query")// 映射HTTP POST请求到query方法，查询床位列表
public Map<String,Object> query(@RequestBody Bed bed){ // 从请求体中获取查询条件Bed对象
PageInfo<Bed> pageInfo = bedService.query(bed);// 调用bedService的query方法进行分页查询
pageInfo.getList().forEach(entity->{// 遍历查询结果列表
entity.setStudent(dormitoryStudentService.queryStudentByBedId(entity.getId()));// 为每个床位设置对应的学生信息
});
return Result.ok(pageInfo);// 返回包含分页信息的查询结果
}
}

25
zsq/BedMapper.java
Unescape View File

@ -0,0 +1,25 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import com.yanzhen.entity.Bed; // 导入Bed床实体类，用于操作床位信息
public interface BedMapper { // 定义BedMapper接口，提供对Bed床实体进行数据库操作的方法
public int create(Bed bed); // 创建一个新的Bed床记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个Bed床记录，返回影响的行数
public int deleteByDormitoryId(Integer dormitoryId); // 根据宿舍ID删除所有相关的Bed床记录，返回影响的行数
public int update(Bed bed); // 更新一个Bed床记录，返回影响的行数
public int updateSelective(Bed bed); // 选择性地更新一个Bed床记录，返回影响的行数
public List<Bed> query(Bed bed); // 根据条件查询Bed床记录，返回符合条件的Bed床列表
public Bed detail(Integer id); // 根据id查询一个Bed床记录的详细信息，返回Bed床对象
public int count(Bed bed); // 根据条件统计Bed床记录的数量，返回记录数量
}

59
zsq/BedService在线选宿舍.java
Unescape View File

@ -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方法并返回结果
}
}

97
zsq/Building.java
Unescape View File

@ -0,0 +1,97 @@
package com.yanzhen.entity;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
public class Building extends Entity{
private Integer id;// 定义一个私有的Integer类型的id变量，用于存储建筑的唯一标识符
@Length(max = 100)// 使用@Length注解限制name字段的最大长度为100个字符
private String name;
private Integer type;// 定义一个私有的Integer类型的type变量，用于表示宿舍类型（例如4人间、6人间、8人间）
private Integer storeyNum;// 定义一个私有的Integer类型的storeyNum变量，用于存储宿舍的层数
private Integer sex;// 定义一个私有的Integer类型的sex变量，可能用于表示性别或性别比例（例如男多于女或反之）
@Length(max = 200) // 使用@Length注解限制remark字段的最大长度为200个字符
private String remark;
private Integer userId; // 定义一个私有的Integer类型的userId变量，用于关联用户表的主键ID
private User user;// 定义一个User类型的user变量，用于存储与该建筑相关的用户信息
public Integer getId() {
return id;// 获取id的值
}
public void setId(Integer id) {
this.id = id;// 设置id的值
}
public String getName() {
return name;// 获取name的值
}
public void setName(String name) {
this.name = name;// 设置name的值
}
public Integer getType() {
return type; // 获取type的值
}
public void setType(Integer type) {
this.type = type;// 设置type的值
}
public Integer getStoreyNum() {
return storeyNum;// 获取storeyNum的值
}
public void setStoreyNum(Integer storeyNum) {
this.storeyNum = storeyNum;// 设置storeyNum的值
}
public Integer getSex() {
return sex;// 获取sex的值
}
public void setSex(Integer sex) {
this.sex = sex;// 设置sex的值
}
public String getRemark() {
return remark;// 获取remark的值
}
public void setRemark(String remark) {
this.remark = remark;// 设置remark的值
}
public Integer getUserId() {
return userId;// 获取userId的值
}
public void setUserId(Integer userId) {
this.userId = userId;// 设置userId的值
}
public User getUser() {// 获取user的值
return user;
}
public void setUser(User user) {// 设置user的值
this.user = user;
}
}

73
zsq/BuildingController.java
Unescape View File

@ -0,0 +1,73 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.Building;
import com.yanzhen.entity.User;
import com.yanzhen.service.BuildingService楼层设置;
import com.yanzhen.service.UserService用户管理;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.Map;
@RestController // 标记为RESTful控制器
@RequestMapping("/building") // 映射URL路径到该控制器
public class BuildingController {
@Autowired // 自动注入BuildingService
private BuildingService楼层设置 buildingService;
@Autowired // 自动注入UserService
private UserService用户管理 userService;
@PostMapping("create") // 映射POST请求到create方法
public Result create(@RequestBody Building building){ // 接收JSON格式的楼宇对象
int flag = buildingService.create(building); // 调用服务层创建楼宇
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回成功结果
}else{ // 如果创建失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("delete") // 映射GET请求到delete方法
public Result delete(String ids){ // 接收楼宇ID字符串
int flag = buildingService.delete(ids); // 调用服务层删除楼宇
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回成功结果
}else{ // 如果删除失败
return Result.fail(); // 返回失败结果
}
}
@PostMapping("update") // 映射POST请求到update方法
public Result update(@RequestBody Building building){ // 接收JSON格式的楼宇对象
int flag = buildingService.update(building); // 调用服务层更新楼宇信息
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回成功结果
}else{ // 如果更新失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("detail") // 映射GET请求到detail方法
public Building detail(Integer id){ // 接收楼宇ID
return buildingService.detail(id); // 调用服务层获取楼宇详情并返回
}
@PostMapping("query") // 映射POST请求到query方法
public Map<String,Object> query(@RequestBody Building building, HttpServletRequest request){ // 接收JSON格式的楼宇对象和HTTP请求
User param = (User)request.getAttribute("user"); // 从请求中获取用户信息
User loginUser = userService.detail(param.getId()); // 调用服务层获取用户详情
if(loginUser.getType() == 1){ // 如果用户是宿管员
building.setUserId(loginUser.getId()); // 设置楼宇的用户ID为当前登录用户的ID
}
PageInfo<Building> pageInfo = buildingService.query(building); // 调用服务层查询楼宇列表
pageInfo.getList().forEach(entity->{ // 遍历查询结果中的每个楼宇
User user = userService.detail(entity.getUserId()); // 调用服务层获取每个楼宇的用户信息
entity.setUser(user); // 将用户信息设置到楼宇对象中
});
return Result.ok(pageInfo); // 返回查询结果
}
}

23
zsq/BuildingMapper.java
Unescape View File

@ -0,0 +1,23 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import com.yanzhen.entity.Building; // 导入Building楼宇实体类，用于操作楼宇信息
public interface BuildingMapper { // 定义BuildingMapper接口，提供对Building楼宇实体进行数据库操作的方法
public int create(Building building); // 创建一个新的Building楼宇记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个Building楼宇记录，返回影响的行数
public int update(Building building); // 更新一个Building楼宇记录，返回影响的行数
public int updateSelective(Building building); // 选择性地更新一个Building楼宇记录，返回影响的行数
public List<Building> query(Building building); // 根据条件查询Building楼宇记录，返回符合条件的Building楼宇列表
public Building detail(Integer id); // 根据id查询一个Building楼宇记录的详细信息，返回Building楼宇对象
public int count(Building building); // 根据条件统计Building楼宇记录的数量，返回记录数量
}

71
zsq/BuildingService楼层设置.java
Unescape View File

@ -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记录的方法； 目的 ：插入一条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记录数量并返回
}
}

16
zsq/Constant.java
Unescape View File

@ -0,0 +1,16 @@
package com.yanzhen.utils; // 定义包名
import java.util.HashMap; // 导入HashMap类
import java.util.Map; // 导入Map接口
public class Constant { // 定义公共类Constant
//用户类型
public static Map<Integer,String> typeString = new HashMap<>(); // 定义一个静态的Map，用于存储用户类型和对应的字符串描述
static { // 静态初始化块
typeString.put(0,"管理员"); // 将用户类型0映射为"管理员"
typeString.put(1,"宿管员"); // 将用户类型1映射为"宿管员"
}
}

89
zsq/Dormitory.java
Unescape View File

@ -0,0 +1,89 @@
package com.yanzhen.entity;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
public class Dormitory extends Entity{// 定义一个名为Dormitory宿舍的类，继承自Entity类
private Integer id;// 定义一个私有的Integer类型的id变量
@Length(max = 50)// 使用@Length注解限制no字段的最大长度为50
private String no;// 定义一个私有的String类型的no变量
private Integer sex; // 定义一个私有的Integer类型的sex变量
private Integer type;// 定义一个私有的Integer类型的type变量
private Integer capacity;// 定义一个私有的Integer类型的capacity变量
private Integer storeyId;// 定义一个私有的Integer类型的storeyId变量
private Integer buildingId;// 定义一个私有的Integer类型的buildingId变量
public Integer getId() {
return id;// 获取id的值
}
public void setId(Integer id) {
this.id = id;// 设置id的值
}
public String getNo() {
return no;// 获取no的值
}
public void setNo(String no) {
this.no = no; // 设置no的值
}
public Integer getSex() {
return sex;// 获取sex的值
}
public void setSex(Integer sex) {
this.sex = sex;// 设置sex的值
}
public Integer getType() {
return type;// 获取type的值
}
public void setType(Integer type) {
this.type = type;// 设置type的值
}
public Integer getCapacity() {
return capacity;// 获取capacity的值
}
public void setCapacity(Integer capacity) {
this.capacity = capacity;// 设置capacity的值
}
public Integer getStoreyId() {
return storeyId;// 获取storeyId的值
}
public void setStoreyId(Integer storeyId) {
this.storeyId = storeyId;// 设置storeyId的值
}
public Integer getBuildingId() {
return buildingId;// 获取buildingId的值
}
public void setBuildingId(Integer buildingId) {
this.buildingId = buildingId;// 设置buildingId的值
}
}

15
zsq/DormitoryApplication.java
Unescape View File

@ -0,0 +1,15 @@
package com.yanzhen; // 定义包名
import org.mybatis.spring.annotation.MapperScan; // 导入MyBatis的MapperScan注解
import org.springframework.boot.SpringApplication; // 导入Spring Boot的SpringApplication类
import org.springframework.boot.autoconfigure.SpringBootApplication; // 导入Spring Boot的SpringBootApplication注解
@SpringBootApplication // 标注这是一个Spring Boot应用
@MapperScan({"com.yanzhen.mapper"}) // 扫描指定包下的Mapper接口，自动生成实现类
public class DormitoryApplication { // 定义主应用类
public static void main(String[] args) { // 主方法，程序入口
SpringApplication.run(DormitoryApplication.class, args); // 启动Spring Boot应用
}
}

66
zsq/DormitoryController.java
Unescape View File

@ -0,0 +1,66 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.Dormitory;
import com.yanzhen.service.DormitoryService宿舍编号设置;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。
@RequestMapping("/dormitory") // 设置请求的根路径为 /dormitory，所有方法的请求路径都会以 /dormitory 开头。
public class DormitoryController { // 定义一个名为 DormitoryController 的类，用于处理宿舍相关的 HTTP 请求。
@Autowired // 自动注入 DormitoryService 对象，用于调用业务逻辑层的方法。
private DormitoryService宿舍编号设置 dormitoryService;
@PostMapping("create") // 映射 HTTP POST 请求到 create 方法，路径为 /dormitory/create。
public Result create(@RequestBody Dormitory dormitory){ // 从请求体中获取 Dormitory 对象，并调用服务层的 create 方法。
int flag = dormitoryService.create(dormitory); // 调用服务层的 create 方法，传入 Dormitory 对象，返回操作结果标志。
if(flag>0){ // 如果操作成功（flag > 0）。
return Result.ok(); // 返回成功的 Result 对象。
}else{ // 如果操作失败（flag <= 0）。
return Result.fail(); // 返回失败的 Result 对象。
}
}
@GetMapping("delete") // 映射 HTTP GET 请求到 delete 方法，路径为 /dormitory/delete。
public Result delete(String ids){ // 从请求参数中获取要删除的记录的 ID，并调用服务层的 delete 方法。
int flag = dormitoryService.delete(ids); // 调用服务层的 delete 方法，传入 ID，返回操作结果标志。
if(flag>0){ // 如果操作成功（flag > 0）。
return Result.ok(); // 返回成功的 Result 对象。
}else{ // 如果操作失败（flag <= 0）。
return Result.fail(); // 返回失败的 Result 对象。
}
}
@PostMapping("update") // 映射 HTTP POST 请求到 update 方法，路径为 /dormitory/update。
public Result update(@RequestBody Dormitory dormitory){ // 从请求体中获取 Dormitory 对象，并调用服务层的 update 方法。
int flag = dormitoryService.update(dormitory); // 调用服务层的 update 方法，传入 Dormitory 对象，返回操作结果标志。
if(flag>0){ // 如果操作成功（flag > 0）。
return Result.ok(); // 返回成功的 Result 对象。
}else{ // 如果操作失败（flag <= 0）。
return Result.fail(); // 返回失败的 Result 对象。
}
}
@GetMapping("detail") // 映射 HTTP GET 请求到 detail 方法，路径为 /dormitory/detail。
public Dormitory detail(Integer id){ // 从请求参数中获取记录的 ID，并调用服务层的 detail 方法。
return dormitoryService.detail(id); // 调用服务层的 detail 方法，传入 ID，返回对应的 Dormitory 对象。
}
@PostMapping("query") // 映射 HTTP POST 请求到 query 方法，路径为 /dormitory/query。
public Map<String,Object> query(@RequestBody Dormitory dormitory){ // 从请求体中获取 Dormitory 对象，并调用服务层的 query 方法。
PageInfo<Dormitory> pageInfo = dormitoryService.query(dormitory); // 调用服务层的 query 方法，传入 Dormitory 对象，返回分页信息。
return Result.ok(pageInfo); // 将分页信息封装在成功的 Result 对象中并返回。
}
@PostMapping("init") // 映射 HTTP POST 请求到 init 方法，路径为 /dormitory/init。
public Result init(@RequestBody Dormitory dormitory){ // 从请求体中获取 Dormitory 对象，并调用服务层的 init 方法。
dormitoryService.init(dormitory); // 调用服务层的 init 方法，传入 Dormitory 对象。
return Result.ok(); // 返回成功的 Result 对象。
}
}

26
zsq/DormitoryMapper.java
Unescape View File

@ -0,0 +1,26 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import com.yanzhen.entity.Dormitory; // 导入Dormitory宿舍实体类，用于操作宿舍信息
import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解，用于传递参数到SQL语句中
public interface DormitoryMapper { // 定义DormitoryMapper接口，提供对Dormitory宿舍进行数据库操作的方法
public int create(Dormitory dormitory); // 创建一个新的Dormitory宿舍记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个Dormitory宿舍记录，返回影响的行数
public int update(Dormitory dormitory); // 更新一个Dormitory宿舍记录，返回影响的行数
public int updateSelective(Dormitory dormitory); // 选择性地更新一个Dormitory宿舍记录，返回影响的行数
public List<Dormitory> query(Dormitory dormitory); // 根据条件查询Dormitory宿舍记录，返回符合条件的Dormitory宿舍列表
public Dormitory detail(Integer id); // 根据id查询一个Dormitory宿舍记录的详细信息，返回Dormitory宿舍对象
public int count(Dormitory dormitory); // 根据条件统计Dormitory宿舍记录的数量，返回记录数量
public int deleteByBuildingIdAndStoryId(@Param("buildingId") Integer buildingId, @Param("storeyId")Integer storeyId); // 根据建筑ID和楼层ID删除Dormitory宿舍记录，返回影响的行数
}

112
zsq/DormitoryService宿舍编号设置.java
Unescape View File

@ -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); // 创建新的床位记录
}
}
});
}
}

101
zsq/DormitorySet.java
Unescape View File

@ -0,0 +1,101 @@
package com.yanzhen.entity;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
public class DormitorySet extends Entity{// 定义一个名为DormitorySet的类，继承自Entity类
private Integer id;// 定义一个私有的Integer类型的id变量
@Length(max = 50)// 定义一个私有的String类型的prefix变量，并使用@Length注解限制其最大长度为50
private String prefix;
private Integer start;// 定义一个私有的Integer类型的start变量
private Integer end;// 定义一个私有的Integer类型的end变量
private Integer buildingId;// 定义一个私有的Integer类型的buildingId变量
private Integer storeyId;// 定义一个私有的Integer类型的storeyId变量
private Integer capacity;// 定义一个私有的Integer类型的capacity变量
public Integer getId() {
return id;// 获取id的值
}
public void setId(Integer id) {
this.id = id;// 设置id的值
}
public String getPrefix() {
return prefix;// 获取prefix的值
}
public void setPrefix(String prefix) {
this.prefix = prefix;// 设置prefix的值
}
public Integer getStart() {
return start;// 获取start的值
}
public void setStart(Integer start) {
this.start = start;// 设置start的值
}
public Integer getEnd() {
return end;// 获取end的值
}
public void setEnd(Integer end) {
this.end = end;// 设置end的值
}
public Integer getBuildingId() {
return buildingId;// 获取buildingId的值
}
public void setBuildingId(Integer buildingId) {
this.buildingId = buildingId;// 设置buildingId的值
}
public Integer getStoreyId() {
return storeyId;// 获取storeyId的值
}
public void setStoreyId(Integer storeyId) {
this.storeyId = storeyId;// 设置storeyId的值
}
public Integer getCapacity() {
return capacity;// 获取capacity的值
}
public void setCapacity(Integer capacity) {
this.capacity = capacity;// 设置capacity的值
}
}

60
zsq/DormitorySetController.java
Unescape View File

@ -0,0 +1,60 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.DormitorySet;
import com.yanzhen.service.DormitorySetService宿舍设置增删查改数据库;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。
@RequestMapping("/dormitorySet") // 设置请求的根路径为 /dormitorySet
public class DormitorySetController { // 定义一个名为 DormitorySetController 的类
@Autowired // 自动注入 DormitorySetService 对象
private DormitorySetService宿舍设置增删查改数据库 dormitorySetService;
@PostMapping("create") // 映射 HTTP POST 请求到 create 方法
public Result create(@RequestBody DormitorySet dormitorySet){ // 从请求体中获取 DormitorySet 对象
int flag = dormitorySetService.create(dormitorySet); // 调用服务层的 create 方法创建记录
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回成功的 Result 对象
}else{ // 如果创建失败
return Result.fail(); // 返回失败的 Result 对象
}
}
@GetMapping("delete") // 映射 HTTP GET 请求到 delete 方法
public Result delete(String ids){ // 从请求参数中获取要删除的记录 ID
int flag = dormitorySetService.delete(ids); // 调用服务层的 delete 方法删除记录
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回成功的 Result 对象
}else{ // 如果删除失败
return Result.fail(); // 返回失败的 Result 对象
}
}
@PostMapping("update") // 映射 HTTP POST 请求到 update 方法
public Result update(@RequestBody DormitorySet dormitorySet){ // 从请求体中获取 DormitorySet 对象
int flag = dormitorySetService.update(dormitorySet); // 调用服务层的 update 方法更新记录
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回成功的 Result 对象
}else{ // 如果更新失败
return Result.fail(); // 返回失败的 Result 对象
}
}
@GetMapping("detail") // 映射 HTTP GET 请求到 detail 方法
public DormitorySet detail(Integer id){ // 从请求参数中获取记录 ID
return dormitorySetService.detail(id); // 调用服务层的 detail 方法获取记录详情并返回
}
@PostMapping("query") // 映射 HTTP POST 请求到 query 方法
public Map<String,Object> query(@RequestBody DormitorySet dormitorySet){ // 从请求体中获取 DormitorySet 对象作为查询条件
PageInfo<DormitorySet> pageInfo = dormitorySetService.query(dormitorySet); // 调用服务层的 query 方法进行分页查询
return Result.ok(pageInfo); // 返回包含查询结果的成功的 Result 对象
}
}

23
zsq/DormitorySetMapper.java
Unescape View File

@ -0,0 +1,23 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import com.yanzhen.entity.DormitorySet; // 导入DormitorySet宿舍设置实体类，用于操作宿舍设置信息
public interface DormitorySetMapper { // 定义DormitorySetMapper接口，提供对DormitorySet宿舍设置实体进行数据库操作的方法
public int create(DormitorySet dormitorySet); // 创建一个新的DormitorySet宿舍设置记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个DormitorySet宿舍设置记录，返回影响的行数
public int update(DormitorySet dormitorySet); // 更新一个DormitorySet宿舍设置记录，返回影响的行数
public int updateSelective(DormitorySet dormitorySet); // 选择性地更新一个DormitorySet宿舍设置记录，返回影响的行数
public List<DormitorySet> query(DormitorySet dormitorySet); // 根据条件查询DormitorySet宿舍设置记录，返回符合条件的DormitorySet宿舍设置列表
public DormitorySet detail(Integer id); // 根据id查询一个DormitorySet宿舍设置记录的详细信息，返回DormitorySet宿舍设置对象
public int count(DormitorySet dormitorySet); // 根据条件统计DormitorySet宿舍设置记录的数量，返回记录数量
}

59
zsq/DormitorySetService宿舍设置增删查改数据库.java
Unescape View File

@ -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) { // 创建宿舍设置记录的方法
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方法
}
}

77
zsq/DormitoryStudent.java
Unescape View File

@ -0,0 +1,77 @@
package com.yanzhen.entity;
import com.yanzhen.utils.Entity;
import java.util.Date;
public class DormitoryStudent extends Entity{ // 定义一个名为DormitoryStudent的类，继承自Entity类
private Integer id; // 定义一个私有变量id，用于存储学生的宿舍分配ID
private Integer dormitoryId; // 定义一个私有变量dormitoryId，用于存储宿舍ID
private Integer bedId; // 定义一个私有变量bedId，用于存储床位ID
private Integer studentId; // 定义一个私有变量studentId，用于存储学生ID
private Date checkin; // 定义一个私有变量checkin，用于存储入住日期
private Integer status; // 定义一个私有变量status，用于表示入住状态（0为待入住，1为已入住）
private Student student; // 定义一个私有变量student，用于关联Student对象
private Dormitory dormitory; // 定义一个私有变量dormitory，用于关联Dormitory对象
public Integer getId() { // 定义一个公共方法getId，用于获取id的值
return id;
}
public void setId(Integer id) { // 定义一个公共方法setId，用于设置id的值
this.id = id;
}
public Integer getDormitoryId() { // 定义一个公共方法getDormitoryId，用于获取dormitoryId的值
return dormitoryId;
}
public void setDormitoryId(Integer dormitoryId) { // 定义一个公共方法setDormitoryId，用于设置dormitoryId的值
this.dormitoryId = dormitoryId;
}
public Integer getBedId() { // 定义一个公共方法getBedId，用于获取bedId的值
return bedId;
}
public void setBedId(Integer bedId) { // 定义一个公共方法setBedId，用于设置bedId的值
this.bedId = bedId;
}
public Integer getStudentId() { // 定义一个公共方法getStudentId，用于获取studentId的值
return studentId;
}
public void setStudentId(Integer studentId) { // 定义一个公共方法setStudentId，用于设置studentId的值
this.studentId = studentId;
}
public Date getCheckin() { // 定义一个公共方法getCheckin，用于获取checkin的值
return checkin;
}
public void setCheckin(Date checkin) { // 定义一个公共方法setCheckin，用于设置checkin的值
this.checkin = checkin;
}
public Integer getStatus() { // 定义一个公共方法getStatus，用于获取status的值
return status;
}
public void setStatus(Integer status) { // 定义一个公共方法setStatus，用于设置status的值
this.status = status;
}
public Student getStudent() { // 定义一个公共方法getStudent，用于获取student对象的值
return student;
}
public void setStudent(Student student) { // 定义一个公共方法setStudent，用于设置student对象的值
this.student = student;
}
public Dormitory getDormitory() { // 定义一个公共方法getDormitory，用于获取dormitory对象的值
return dormitory;
}
public void setDormitory(Dormitory dormitory) { // 定义一个公共方法setDormitory，用于设置dormitory对象的值
this.dormitory = dormitory;
}
}

72
zsq/DormitoryStudentController.java
Unescape View File

@ -0,0 +1,72 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.DormitoryStudent;
import com.yanzhen.entity.Student;
import com.yanzhen.service.DormitoryService宿舍编号设置;
import com.yanzhen.service.DormitoryStudentService宿舍预选设置;
import com.yanzhen.service.StudentService学生管理;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。
@RequestMapping("/dormitoryStudent") // 设置请求的根路径为 /dormitoryStudent
public class DormitoryStudentController {
@Autowired // 自动注入DormitoryStudentService实例
private DormitoryStudentService宿舍预选设置 dormitoryStudentService;
@Autowired // 自动注入StudentService实例
private StudentService学生管理 studentService;
@Autowired // 自动注入DormitoryService实例
private DormitoryService宿舍编号设置 dormitoryService;
@PostMapping("create") // 映射HTTP POST请求到 create 方法
public Result create(@RequestBody DormitoryStudent dormitoryStudent){ // 从请求体中获取 DormitoryStudent 对象
int flag = dormitoryStudentService.create(dormitoryStudent); // 调用服务层创建学生宿舍记录
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回成功结果
}else{ // 如果创建失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("delete") // 映射HTTP GET请求到 delete 方法
public Result delete(String ids){ // 接收要删除的学生宿舍记录的ID字符串
int flag = dormitoryStudentService.delete(ids); // 调用服务层删除指定ID的学生宿舍记录
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回成功结果
}else{ // 如果删除失败
return Result.fail(); // 返回失败结果
}
}
@PostMapping("update") // 映射HTTP POST请求到 update 方法
public Result update(@RequestBody DormitoryStudent dormitoryStudent){ // 从请求体中获取 DormitoryStudent 对象
int flag = dormitoryStudentService.update(dormitoryStudent); // 调用服务层更新学生宿舍记录
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回成功结果
}else{ // 如果更新失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("detail") // 映射HTTP GET请求到 detail 方法
public DormitoryStudent detail(Integer id){ // 接收学生宿舍记录的ID
return dormitoryStudentService.detail(id); // 调用服务层获取指定ID的学生宿舍记录详情并返回
}
@PostMapping("query") // 映射HTTP POST请求到 query 方法
public Map<String,Object> query(@RequestBody DormitoryStudent dormitoryStudent){ // 从请求体中获取 DormitoryStudent 对象用于查询条件
PageInfo<DormitoryStudent> pageInfo = dormitoryStudentService.query(dormitoryStudent); // 调用服务层进行分页查询
pageInfo.getList().forEach(entity->{ // 遍历查询结果列表
Student detail = studentService.detail(entity.getStudentId()); // 获取每个学生宿舍记录对应的学生详细信息
entity.setStudent(detail); // 将学生信息设置到学生宿舍记录中
});
return Result.ok(pageInfo); // 返回包含分页信息和查询结果的成功结果
}
}

30
zsq/DormitoryStudentMapper.java
Unescape View File

@ -0,0 +1,30 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构
import com.yanzhen.entity.DormitoryStudent; // 导入DormitoryStudent实体类，用于操作学生宿舍信息
import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解，用于传递参数到SQL语句中
public interface DormitoryStudentMapper { // 定义DormitoryStudentMapper接口，提供对DormitoryStudent实体进行数据库操作的方法
public int create(DormitoryStudent dormitoryStudent); // 创建一个新的DormitoryStudent记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个DormitoryStudent记录，返回影响的行数
public int deleteByCond(@Param("studentId") Integer studentId, @Param("dormitoryId")Integer dormitoryId); // 根据条件删除DormitoryStudent记录，返回影响的行数
public int update(DormitoryStudent dormitoryStudent); // 更新一个DormitoryStudent记录，返回影响的行数
public int updateSelective(DormitoryStudent dormitoryStudent); // 选择性地更新一个DormitoryStudent记录，返回影响的行数
public List<DormitoryStudent> query(DormitoryStudent dormitoryStudent); // 根据条件查询DormitoryStudent记录，返回符合条件的DormitoryStudent列表
public DormitoryStudent detail(Integer id); // 根据id查询一个DormitoryStudent记录的详细信息，返回DormitoryStudent对象
public int count(DormitoryStudent dormitoryStudent); // 根据条件统计DormitoryStudent记录的数量，返回记录数量
public int countByBuildingId(Integer buildingId); // 根据buildingId统计DormitoryStudent记录的数量，返回记录数量
public Map<String,Object> queryStudentByBedId(Integer bedId); // 根据bedId查询学生信息，返回包含学生信息的Map对象
}

97
zsq/DormitoryStudentService宿舍预选设置.java
Unescape View File

@ -0,0 +1,97 @@
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方法
}
}

28
zsq/Entity.java
Unescape View File

@ -0,0 +1,28 @@
package com.yanzhen.utils; // 定义包名
import com.fasterxml.jackson.annotation.JsonIgnore; // 导入JsonIgnore注解
import com.fasterxml.jackson.annotation.JsonProperty; // 导入JsonProperty注解
public class Entity { // 定义Entity类
private Integer page = 1; // 页码数，默认为1
private Integer limit = 10; // 页面大小，默认的10
public Integer getPage() { // 获取页码数的方法
return page; // 返回页码数
}
public void setPage(Integer page) { // 设置页码数的方法
this.page = page; // 设置页码数
}
public Integer getLimit() { // 获取页面大小的方法
return limit; // 返回页面大小
}
public void setLimit(Integer limit) { // 设置页面大小的方法
this.limit = limit; // 设置页面大小
}
}

27
zsq/GlobalControllerAdvice.java
Unescape View File

@ -0,0 +1,27 @@
package com.yanzhen.framework.mvc; // 定义包名
import com.yanzhen.framework.exception.MyException; // 导入自定义异常类
import com.yanzhen.utils.Result; // 导入结果处理工具类
import org.springframework.web.bind.annotation.ControllerAdvice; // 导入Spring MVC的ControllerAdvice注解
import org.springframework.web.bind.annotation.ExceptionHandler; // 导入Spring MVC的ExceptionHandler注解
import org.springframework.web.bind.annotation.RequestBody; // 导入Spring MVC的RequestBody注解
import org.springframework.web.bind.annotation.ResponseBody; // 导入Spring MVC的ResponseBody注解
@ControllerAdvice // 标记该类为全局异常处理类
public class GlobalControllerAdvice {
@ExceptionHandler(RuntimeException.class) // 处理所有RuntimeException类型的异常
@ResponseBody // 将返回值作为HTTP响应体
public Result handle(RuntimeException exception){ // 定义处理方法，参数为捕获到的异常
exception.printStackTrace(); // 打印异常堆栈信息
return Result.fail(exception.getMessage()); // 返回失败的结果对象，包含异常信息
}
@ExceptionHandler(MyException.class) // 处理所有MyException类型的异常
@ResponseBody // 将返回值作为HTTP响应体
public Result handle(MyException exception){ // 定义处理方法，参数为捕获到的异常
exception.printStackTrace(); // 打印异常堆栈信息
return Result.fail(Result.TOKEN_ERROR,exception.getMessage()); // 返回失败的结果对象，包含错误码和异常信息
}
}

31
zsq/Grade.java
Unescape View File

@ -0,0 +1,31 @@
package com.yanzhen.entity;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
public class Grade extends Entity{// 定义一个名为Grade的类，继承自Entity类
private Integer id;// 定义一个私有的Integer类型的变量id
@Length(max = 100)// 使用@Length注解限制name字段的最大长度为100个字符
private String name;
public Integer getId() {
return id;// 定义一个公共方法getId，用于获取id的值
}
public void setId(Integer id) {
this.id = id;// 定义一个公共方法setId，用于设置id的值
}
public String getName() {
return name;// 定义一个公共方法getName，用于获取name的值
}
public void setName(String name) {
this.name = name;// 定义一个公共方法setName，用于设置name的值
}
}

60
zsq/GradeController.java
Unescape View File

@ -0,0 +1,60 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.Grade;
import com.yanzhen.service.GradeService年级管理;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController // 声明这是一个RESTful控制器，返回的数据直接写入HTTP响应体中
@RequestMapping("/grade") // 设置请求路径的映射前缀为"/grade"
public class GradeController {
@Autowired // 自动注入GradeService对象
private GradeService年级管理 gradeService;
@PostMapping("create") // 映射HTTP POST请求到create方法
public Result create(@RequestBody Grade grade){ // 从请求体中获取Grade对象
int flag = gradeService.create(grade); // 调用服务层的create方法创建记录
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回成功结果
}else{ // 如果创建失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("delete") // 映射HTTP GET请求到delete方法
public Result delete(String ids){ // 从请求参数中获取要删除的记录ID
int flag = gradeService.delete(ids); // 调用服务层的delete方法删除记录
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回成功结果
}else{ // 如果删除失败
return Result.fail(); // 返回失败结果
}
}
@PostMapping("update") // 映射HTTP POST请求到update方法
public Result update(@RequestBody Grade grade){ // 从请求体中获取Grade对象
int flag = gradeService.update(grade); // 调用服务层的update方法更新记录
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回成功结果
}else{ // 如果更新失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("detail") // 映射HTTP GET请求到detail方法
public Grade detail(Integer id){ // 从请求参数中获取记录ID
return gradeService.detail(id); // 调用服务层的detail方法获取记录详情
}
@PostMapping("query") // 映射HTTP POST请求到query方法
public Map<String,Object> query(@RequestBody Grade grade){ // 从请求体中获取Grade对象作为查询条件
PageInfo<Grade> pageInfo = gradeService.query(grade); // 调用服务层的query方法进行分页查询
return Result.ok(pageInfo); // 返回包含查询结果的成功结果
}
}

24
zsq/GradeMapper.java
Unescape View File

@ -0,0 +1,24 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构
import com.yanzhen.entity.Grade; // 导入Grade实体类，用于操作年级信息
public interface GradeMapper { // 定义GradeMapper接口，提供对Grade实体进行数据库操作的方法
public int create(Grade grade); // 创建一个新的Grade记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个Grade记录，返回影响的行数
public int update(Grade grade); // 更新一个Grade记录，返回影响的行数
public int updateSelective(Grade grade); // 选择性地更新一个Grade记录，返回影响的行数
public List<Grade> query(Grade grade); // 根据条件查询Grade记录，返回符合条件的Grade列表
public Grade detail(Integer id); // 根据id查询一个Grade记录的详细信息，返回Grade对象
public int count(Grade grade); // 根据条件统计Grade记录的数量，返回记录数量
}

59
zsq/GradeService年级管理.java
Unescape View File

@ -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方法并返回结果
}
}

156
zsq/JWTUtil.java
Unescape View File

@ -0,0 +1,156 @@
package com.yanzhen.framework.jwt; // 定义包名
import com.yanzhen.entity.Student; // 导入Student类
import com.yanzhen.entity.User; // 导入User类
import com.yanzhen.framework.exception.MyException; // 导入自定义异常类MyException
import io.jsonwebtoken.*; // 导入JWT相关类
import org.springframework.util.StringUtils; // 导入Spring框架的StringUtils工具类
import java.util.Date; // 导入Date类
import java.util.HashMap; // 导入HashMap类
import java.util.Map; // 导入Map接口
import java.util.UUID; // 导入UUID类
public class JWTUtil {//jwt的工具类
public static String token = "token"; // 定义静态变量token，用于存储token字符串
//秘钥
public static String jwt_secret="yanzhen@cms@cc596183363."; // 定义静态变量jwt_secret，用于存储JWT签名的密钥
//过期时长
public static long jwt_expr = 3600*24*1000; // 定义静态变量jwt_expr，用于设置JWT的过期时间（单位：毫秒）
//1、生成token
public static String sign(User user){ // 定义静态方法sign，用于生成用户类型的JWT
//1、指定签名的时候使用的签名算法
SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256; // 使用HS256算法进行签名
//2、生成签发时间
long nowMillis = System.currentTimeMillis(); // 获取当前时间的毫秒数
Date date = new Date(nowMillis); // 将毫秒数转换为Date对象
//3、创建playLoad的私有声明
Map<String,Object> claims = new HashMap<>(); // 创建一个Map对象，用于存储JWT的负载信息
claims.put("id",user.getId()); // 将用户的ID添加到负载中
claims.put("userName",user.getUserName()); // 将用户名添加到负载中
claims.put("type","USER"); // 添加类型信息到负载中
//4、生成签发人
String subject = user.getUserName(); // 将用户名作为JWT的签发人
JwtBuilder builder = Jwts.builder() // 创建JwtBuilder对象，用于构建JWT
.setClaims(claims) // 设置JWT的负载信息
.setId(UUID.randomUUID().toString()) // 设置JWT的唯一标识符
.setIssuedAt(date) // 设置JWT的签发时间
.setSubject(subject) // 设置JWT的签发人
.signWith(signatureAlgorithm,jwt_secret); // 使用指定的签名算法和密钥对JWT进行签名
//设置过期时间
Date exprDate = new Date(nowMillis + jwt_expr); // 计算JWT的过期时间
builder.setExpiration(exprDate); // 设置JWT的过期时间
return builder.compact(); // 生成并返回JWT字符串
}
//1、生成token
public static String signForStudent(Student student){ // 定义静态方法signForStudent，用于生成学生类型的JWT
//1、指定签名的时候使用的签名算法
SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256; // 使用HS256算法进行签名
//2、生成签发时间
long nowMillis = System.currentTimeMillis(); // 获取当前时间的毫秒数
Date date = new Date(nowMillis); // 将毫秒数转换为Date对象
//3、创建playLoad的私有声明
Map<String,Object> claims = new HashMap<>(); // 创建一个Map对象，用于存储JWT的负载信息
claims.put("id",student.getId()); // 将学生的ID添加到负载中
claims.put("stuNo",student.getStuNo()); // 将学号添加到负载中
claims.put("type","STUDENT"); // 添加类型信息到负载中
//4、生成签发人
String subject = student.getStuNo(); // 将学号作为JWT的签发人
JwtBuilder builder = Jwts.builder() // 创建JwtBuilder对象，用于构建JWT
.setClaims(claims) // 设置JWT的负载信息
.setId(UUID.randomUUID().toString()) // 设置JWT的唯一标识符
.setIssuedAt(date) // 设置JWT的签发时间
.setSubject(subject) // 设置JWT的签发人
.signWith(signatureAlgorithm,jwt_secret); // 使用指定的签名算法和密钥对JWT进行签名
//设置过期时间
Date exprDate = new Date(nowMillis + jwt_expr); // 计算JWT的过期时间
builder.setExpiration(exprDate); // 设置JWT的过期时间
return builder.compact(); // 生成并返回JWT字符串
}
//2、验证token
public static boolean verify(String token){ // 定义静态方法verify，用于验证JWT是否合法
try {
if(StringUtils.isEmpty(token)){ // 如果token为空，则返回false
return false;
}
Jwts.parser().setSigningKey(jwt_secret).parseClaimsJws(token).getBody(); // 解析JWT并验证签名
return true; // 如果解析成功且签名合法，则返回true
} catch (Exception e) { // 如果解析或验证过程中发生异常，则捕获异常
e.printStackTrace(); // 打印异常堆栈信息
return false; // 返回false表示验证失败
}
}
public static String getType(String token){ // 定义静态方法getType，用于获取JWT的类型信息
try {
if(StringUtils.isEmpty(token)){ // 如果token为空，则抛出自定义异常
throw new MyException("token不能为空");
}
if(verify(token)){ // 如果token验证通过，则解析JWT并获取类型信息
Claims claims = Jwts.parser().setSigningKey(jwt_secret).parseClaimsJws(token).getBody(); // 解析JWT并获取负载信息
return claims.get("type")+""; // 返回类型信息
}else{
throw new MyException("超时或不合法token"); // 如果token验证失败，则抛出自定义异常
}
} catch (Exception e) { // 如果解析或验证过程中发生异常，则捕获异常
throw new MyException("超时或不合法token"); // 抛出自定义异常
}
}
//3、获取用户信息
public static User getUser(String token){ // 定义静态方法getUser，用于从JWT中提取用户信息
try {
if(StringUtils.isEmpty(token)){ // 如果token为空，则抛出自定义异常
throw new MyException("token不能为空");
}
if(verify(token)){ // 如果token验证通过，则解析JWT并获取用户信息
Claims claims = Jwts.parser().setSigningKey(jwt_secret).parseClaimsJws(token).getBody(); // 解析JWT并获取负载信息
User user = new User(); // 创建User对象
user.setId(Integer.parseInt(claims.get("id")+"")); // 从负载中提取用户ID并设置到User对象中
user.setUserName(claims.get("userName")+""); // 从负载中提取用户名并设置到User对象中
return user; // 返回User对象
}else{
throw new MyException("超时或不合法token"); // 如果token验证失败，则抛出自定义异常
}
} catch (Exception e) { // 如果解析或验证过程中发生异常，则捕获异常
throw new MyException("超时或不合法token"); // 抛出自定义异常
}
}
public static Student getStudent(String token){ // 定义静态方法getStudent，用于从JWT中提取学生信息
try {
if(StringUtils.isEmpty(token)){ // 如果token为空，则抛出自定义异常
throw new MyException("token不能为空");
}
if(verify(token)){ // 如果token验证通过，则解析JWT并获取学生信息
Claims claims = Jwts.parser().setSigningKey(jwt_secret).parseClaimsJws(token).getBody(); // 解析JWT并获取负载信息
Student student = new Student(); // 创建Student对象
student.setId(Integer.parseInt(claims.get("id")+"")); // 从负载中提取学生ID并设置到Student对象中
student.setStuNo(claims.get("stuNo")+""); // 从负载中提取学号并设置到Student对象中
return student; // 返回Student对象
}else{
throw new MyException("超时或不合法token"); // 如果token验证失败，则抛出自定义异常
}
} catch (Exception e) { // 如果解析或验证过程中发生异常，则捕获异常
throw new MyException("超时或不合法token"); // 抛出自定义异常
}
}
public static void main(String[] args) { // 主方法，程序入口点
User user = new User(); // 创建User对象
user.setId(1); // 设置用户ID
user.setUserName("admin"); // 设置用户名
System.out.println(sign(user)); // 生成用户类型的JWT并打印输出
}
}

52
zsq/LoginController.java
Unescape View File

@ -0,0 +1,52 @@
package com.yanzhen.controller;
import com.yanzhen.entity.Student;
import com.yanzhen.entity.User;
import com.yanzhen.framework.jwt.JWTUtil;
import com.yanzhen.service.StudentService学生管理;
import com.yanzhen.service.UserService用户管理;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。
public class LoginController { // 定义一个名为 LoginController 的类，用于处理登录相关的请求。
@Autowired // 自动注入 UserService 实例，用于处理用户相关的业务逻辑。
private UserService用户管理 userService;
@Autowired // 自动注入 StudentService 实例，用于处理学生相关的业务逻辑。
private StudentService学生管理 studentService;
@PostMapping("/login") // 映射 HTTP POST 请求到 /login 路径上，用于处理登录请求。
public Result login(@RequestBody User user){ // 定义一个方法 login，接收一个 User 对象作为请求体。
if(user.getType() == 2){ // 如果用户类型是学生（假设类型为2表示学生）。
Student entity = studentService.login(user.getUserName(),user.getPassword()); // 调用 studentService 的 login 方法验证学生身份。
if(entity != null){ // 如果学生信息存在，即登录成功。
String token = JWTUtil.signForStudent(entity); // 生成针对学生的 JWT 令牌。
Map map = new HashMap(); // 创建一个 Map 对象存储返回数据。
map.put(JWTUtil.token,token); // 将 JWT 令牌放入 Map。
map.put("student",entity); // 将学生实体信息放入 Map。
return Result.ok("登陆成功",map); // 返回包含成功消息和数据的 Result 对象。
}else{ // 如果学生信息不存在，即登录失败。
return Result.fail("用户名或密码错误"); // 返回包含错误信息的 Result 对象。
}
}else{ // 如果用户类型不是学生（管理员或宿管员）。
User entity = userService.login(user.getUserName(),user.getPassword()); // 调用 userService 的 login 方法验证用户身份。
if(entity != null){ // 如果用户信息存在，即登录成功。
String token = JWTUtil.sign(entity); // 生成通用的 JWT 令牌。
Map map = new HashMap(); // 创建一个 Map 对象存储返回数据。
map.put(JWTUtil.token,token); // 将 JWT 令牌放入 Map。
map.put("user",entity); // 将用户实体信息放入 Map。
return Result.ok("登陆成功",map); // 返回包含成功消息和数据的 Result 对象。
}else{ // 如果用户信息不存在，即登录失败。
return Result.fail("用户名或密码错误"); // 返回包含错误信息的 Result 对象。
}
}
}
}

76
zsq/MainController.java
Unescape View File

@ -0,0 +1,76 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.Building;
import com.yanzhen.entity.Dormitory;
import com.yanzhen.entity.Notice;
import com.yanzhen.service.BuildingService楼层设置;
import com.yanzhen.service.DormitoryService宿舍编号设置;
import com.yanzhen.service.DormitoryStudentService宿舍预选设置;
import com.yanzhen.service.NoticeService公告管理;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。
@RequestMapping("/main") // 设置请求的根路径为 /main，所有该控制器下的请求都会以 /main 开头。
public class MainController {
@Autowired // 自动注入 BuildingService 实例，用于处理楼宇相关的业务逻辑。
private BuildingService楼层设置 buildingService;
@Autowired // 自动注入 DormitoryService 实例，用于处理宿舍相关的业务逻辑。
private DormitoryService宿舍编号设置 dormitoryService;
@Autowired // 自动注入 DormitoryStudentService 实例，用于处理学生宿舍分配的业务逻辑。
private DormitoryStudentService宿舍预选设置 dormitoryStudentService;
@Autowired // 自动注入 NoticeService 实例，用于处理公告通知的业务逻辑。
private NoticeService公告管理 noticeService;
@GetMapping("/building") // 映射 HTTP GET 请求到 /main/building 路径。
public Result building(){
Building building = new Building(); // 创建一个新的楼宇对象。
building.setLimit(1000); // 设置查询限制为1000条记录。
PageInfo<Building> pageInfo = buildingService.query(building); // 调用服务层方法查询楼宇信息。
List<Map<String,Object>> list = new ArrayList<>(); // 创建一个列表来存储每个楼宇的信息。
DecimalFormat df = new DecimalFormat("######0.00"); // 定义一个格式化工具，用于格式化百分比。
pageInfo.getList().forEach(entity->{ // 遍历查询到的楼宇列表。
Map<String,Object> map = new HashMap<>(); // 创建一个 Map 来存储单个楼宇的信息。
Dormitory param = new Dormitory(); // 创建一个新的宿舍对象。
param.setBuildingId(entity.getId()); // 设置宿舍对象的楼宇ID。
param.setLimit(1000000); // 设置查询限制为1000000条记录。
PageInfo<Dormitory> dormitoryPageInfo = dormitoryService.query(param); // 调用服务层方法查询宿舍信息。
int all = dormitoryPageInfo.getList().size(); // 获取该楼宇下的总宿舍数。
map.put("name",entity.getName()); // 将楼宇名称存入 Map。
map.put("all",all); // 将总宿舍数存入 Map。
int used = dormitoryStudentService.countByBuildingId(entity.getId()); // 计算已分配宿舍的学生数量。
map.put("used",used); // 将已分配宿舍的学生数量存入 Map。
int unused = all-used; // 计算未分配宿舍的数量。
map.put("unused",unused); // 将未分配宿舍的数量存入 Map。
if(all == 0){ // 如果总宿舍数为0，则百分比为0。
map.put("percent",0);
}else{ // 否则，计算并格式化已使用宿舍的百分比。
map.put("percent",df.format((float)used/all));
}
list.add(map); // 将当前楼宇的信息添加到列表中。
});
return Result.ok(list); // 返回包含所有楼宇信息的列表。
}
@GetMapping("/notice") // 映射 HTTP GET 请求到 /main/notice 路径。
public Result notice(){
Notice notice = new Notice(); // 创建一个新的公告对象。
notice.setLimit(5); // 设置查询限制为5条记录。
PageInfo<Notice> pageInfo = noticeService.query(notice); // 调用服务层方法查询公告信息。
return Result.ok(pageInfo.getList()); // 返回包含公告信息的列表。
}
}

82
zsq/Menu.java
Unescape View File

@ -0,0 +1,82 @@
package com.yanzhen.entity;
import java.util.List;
public class Menu { // 定义一个名为Menu的公共类
private Integer id; // 私有成员变量，用于存储菜单项的唯一标识符
private String title; // 私有成员变量，用于存储菜单项的标题
private String icon; // 私有成员变量，用于存储菜单项的图标
private String href; // 私有成员变量，用于存储菜单项的链接地址
private String target; // 私有成员变量，用于指定链接打开的目标窗口
private Integer parentId; // 私有成员变量，用于存储父菜单项的ID
private Integer type; // 私有成员变量，用于存储菜单项的类型
private List<Menu> child; // 私有成员变量，用于存储子菜单项的列表
// 以下为该类的成员变量的getter和setter方法
public Integer getId() { // 获取菜单项的ID
return id;
}
public void setId(Integer id) { // 设置菜单项的ID
this.id = id;
}
public String getTitle() { // 获取菜单项的标题
return title;
}
public void setTitle(String title) { // 设置菜单项的标题
this.title = title;
}
public String getIcon() { // 获取菜单项的图标
return icon;
}
public void setIcon(String icon) { // 设置菜单项的图标
this.icon = icon;
}
public String getHref() { // 获取菜单项的链接地址
return href;
}
public void setHref(String href) { // 设置菜单项的链接地址
this.href = href;
}
public String getTarget() { // 获取链接打开的目标窗口
return target;
}
public void setTarget(String target) { // 设置链接打开的目标窗口
this.target = target;
}
public Integer getParentId() { // 获取父菜单项的ID
return parentId;
}
public void setParentId(Integer parentId) { // 设置父菜单项的ID
this.parentId = parentId;
}
public Integer getType() { // 获取菜单项的类型
return type;
}
public void setType(Integer type) { // 设置菜单项的类型
this.type = type;
}
public List<Menu> getChild() { // 获取子菜单项的列表
return child;
}
public void setChild(List<Menu> child) { // 设置子菜单项的列表
this.child = child;
}
}

97
zsq/MenuController.java
Unescape View File

@ -0,0 +1,97 @@
package com.yanzhen.controller;
import com.yanzhen.entity.Menu;
import com.yanzhen.entity.User;
import com.yanzhen.service.MenuService菜单;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。
@RequestMapping("/menu") // 设置请求的根路径为 "/menu"
public class MenuController {
@Autowired // 自动注入 MenuService 对象
private MenuService菜单 menuService;
@GetMapping("/query") // 处理对 "/menu/query" 的 GET 请求
public Result query(HttpServletRequest request){
List<Menu> menus = new ArrayList<>(); // 创建一个空的菜单列表
if(request.getAttribute("user") != null){ // 如果请求中有 "user" 属性
User user = (User) request.getAttribute("user"); // 获取用户信息
menus = menuService.query(user.getId()); // 根据用户ID查询菜单
}else if(request.getAttribute("student") != null){ // 如果请求中有 "student" 属性
menus = menuService.queryByType(); // 查询所有学生类型的菜单
}
List<Menu> menuList1 = new ArrayList<>(); // 创建一级菜单列表
//找出一级菜单
for (Menu menu : menus) { // 遍历所有菜单项
if(menu.getParentId() == 0){ // 如果父ID为0，则为一级菜单
menuList1.add(menu); // 添加到一级菜单列表中
}
}
//嵌套循环找出关联设置child属性
for (Menu parent : menuList1) { // 遍历一级菜单
List<Menu> child = new ArrayList<>(); // 创建子菜单列表
for (Menu entity : menus) { // 遍历所有菜单项
if(parent.getId() == entity.getParentId()){ // 如果当前菜单是某个一级菜单的子菜单
child.add(entity); // 添加到子菜单列表中
}
}
parent.setChild(child); // 设置一级菜单的子菜单列表
}
return Result.ok(menuList1); // 返回包含一级菜单及其子菜单的结果
}
@GetMapping("/tree") // 处理对 "/menu/tree" 的 GET 请求
public Result tree(Integer checked,HttpServletRequest request){
//check查询的时候是否选中状态
List<Integer> checkedMenuId = new ArrayList<>(); // 创建已选中菜单ID列表
if(checked != null){ // 如果请求参数中包含 "checked"
User user = (User) request.getAttribute("user"); // 获取用户信息
//查询出来自己已经设置过得menuId
checkedMenuId = menuService.queryCheckMenuId(user.getId()); // 查询用户已设置的菜单ID
}
List<Menu> list = menuService.list(); // 获取所有菜单列表
List<Map<String,Object>> menus = new ArrayList<>(); // 创建用于存储树形结构的菜单列表
for (Menu menu : list) { // 遍历所有菜单项
if(menu.getParentId()==0){ // 如果父ID为0，则为一级菜单
Map<String,Object> map = new HashMap<>(); // 创建存储一级菜单信息的映射
map.put("id",menu.getId()); // 添加菜单ID
map.put("name",menu.getTitle()); // 添加菜单名称
map.put("isParent",true); // 标记为父节点
map.put("open",true); // 默认展开
if(checked != null){ // 如果存在已选中的菜单ID
map.put("checked",checkedMenuId.contains(menu.getId())); // 设置是否选中
}
List<Map<String,Object>> child = new ArrayList<>(); // 创建子菜单列表
for (Menu menu1 : list) { // 遍历所有菜单项
if(menu1.getParentId()!=0 && menu.getId() == menu1.getParentId()){ // 如果当前菜单是某个一级菜单的子菜单
Map<String,Object> map2 = new HashMap<>(); // 创建存储子菜单信息的映射
map2.put("id",menu1.getId()); // 添加子菜单ID
map2.put("name",menu1.getTitle()); // 添加子菜单名称
map2.put("isParent",false); // 标记为子节点
if(checked != null){ // 如果存在已选中的菜单ID
map2.put("checked",checkedMenuId.contains(menu1.getId())); // 设置是否选中
}
child.add(map2); // 添加到子菜单列表中
}
}
map.put("children",child); // 将子菜单列表添加到一级菜单的映射中
menus.add(map); // 将一级菜单的映射添加到结果列表中
}
}
return Result.ok(menus); // 返回包含树形结构菜单的结果
}
}

23
zsq/MenuMapper.java
Unescape View File

@ -0,0 +1,23 @@
package com.yanzhen.mapper; // 定义包名
import com.yanzhen.entity.Menu; // 导入Menu实体类
import com.yanzhen.entity.User; // 导入User实体类
import org.apache.ibatis.annotations.Param; // 导入MyBatis的@Param注解
import java.util.List; // 导入List集合
public interface MenuMapper { // 定义MenuMapper接口
public List<Menu> query(Integer userId); // 根据用户ID查询菜单列表
public List<Menu> queryByType(); // 查询所有类型的菜单
public List<Menu> list(); // 列出所有菜单
public int createUserMenu(@Param("userId") Integer userId, @Param("menuId") Integer menuId); // 为用户创建菜单，关联用户ID和菜单ID
public int deleteUserMenu(@Param("userId") Integer userId); // 删除用户的菜单，根据用户ID
public List<Integer> queryCheckMenuId(Integer userId); // 查询用户已选择的菜单ID列表
}

31
zsq/MenuService菜单.java
Unescape View File

@ -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方法并返回结果
}
}

11
zsq/MyException.java
Unescape View File

@ -0,0 +1,11 @@
package com.yanzhen.framework.exception;
public class MyException extends RuntimeException { // 定义一个名为MyException的类，继承自RuntimeException
public MyException() { // 无参构造函数
}
public MyException(String message) { // 带一个字符串参数的构造函数
super(message); // 调用父类的构造函数，并传递消息参数
}
}

42
zsq/MyWebMvcConfigurer.java
Unescape View File

@ -0,0 +1,42 @@
package com.yanzhen.framework.mvc; // 定义包名
import org.springframework.context.annotation.Bean; // 导入@Bean注解
import org.springframework.context.annotation.Configuration; // 导入@Configuration注解
import org.springframework.web.cors.CorsConfiguration; // 导入CorsConfiguration类
import org.springframework.web.cors.CorsConfigurationSource; // 导入CorsConfigurationSource接口
import org.springframework.web.cors.UrlBasedCorsConfigurationSource; // 导入UrlBasedCorsConfigurationSource类
import org.springframework.web.filter.CorsFilter; // 导入CorsFilter类
import org.springframework.web.servlet.config.annotation.InterceptorRegistry; // 导入InterceptorRegistry类
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; // 导入WebMvcConfigurer接口
@Configuration // 标记该类为配置类
public class MyWebMvcConfigurer implements WebMvcConfigurer { // 实现WebMvcConfigurer接口
@Bean // 将方法返回的对象注册为Spring容器中的Bean
public TokenInterceptor tokenInterceptor(){ // 定义tokenInterceptor方法，返回TokenInterceptor对象
return new TokenInterceptor(); // 创建并返回TokenInterceptor实例
}
@Override // 重写父类的方法
public void addInterceptors(InterceptorRegistry registry) { // 定义addInterceptors方法，参数为InterceptorRegistry对象
registry.addInterceptor(tokenInterceptor()) // 添加自定义拦截器
.addPathPatterns("/**") // 设置拦截所有路径
.excludePathPatterns("/login"); // 排除登录路径不拦截
}
//使用CorsFilter解决跨域的问题
@Bean // 将方法返回的对象注册为Spring容器中的Bean
public CorsFilter corsFilter(){ // 定义corsFilter方法，返回CorsFilter对象
CorsConfiguration corsConfiguration = new CorsConfiguration(); // 创建CorsConfiguration实例
//允许跨域请求的域名
corsConfiguration.addAllowedOrigin("*"); // 允许所有域名进行跨域请求
corsConfiguration.addAllowedMethod("*"); // 允许所有HTTP方法进行跨域请求
//允许任何头部
corsConfiguration.addAllowedHeader("*"); // 允许所有头部信息进行跨域请求
UrlBasedCorsConfigurationSource urlBasedCorsConfigurationSource = new UrlBasedCorsConfigurationSource(); // 创建UrlBasedCorsConfigurationSource实例
urlBasedCorsConfigurationSource.registerCorsConfiguration("/**",corsConfiguration); // 注册跨域配置到URL模式
CorsFilter corsFilter = new CorsFilter(urlBasedCorsConfigurationSource); // 创建CorsFilter实例
return corsFilter; // 返回CorsFilter实例
}
}

94
zsq/Notice.java
Unescape View File

@ -0,0 +1,94 @@
package com.yanzhen.entity;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
import java.util.List;
public class Notice extends Entity{ // 定义一个继承自Entity的Notice类
private Integer id; // 定义一个私有的Integer类型的id变量，用于存储公告的唯一标识符
@Length(max = 200) // 使用@Length注解限制title字段的最大长度为200个字符
private String title; // 定义一个私有的String类型的title变量，用于存储公告的标题
@Length(max = 0) // 使用@Length注解限制content字段的最大长度为0个字符（这似乎是一个错误，通常应设置为非零值）
private String content; // 定义一个私有的String类型的content变量，用于存储公告的内容
private Date createTime; // 定义一个私有的Date类型的createTime变量，用于存储公告的创建时间
private Integer userId; // 定义一个私有的Integer类型的userId变量，用于存储发布公告的用户ID
@Length(max = 200) // 使用@Length注解限制filepath字段的最大长度为200个字符
private String filepath; // 定义一个私有的String类型的filepath变量，用于存储与公告相关的文件路径
private User user; // 定义一个私有的User类型的user变量，用于存储发布公告的用户信息
private List<Integer> buildingIds; // 定义一个私有的List<Integer>类型的buildingIds变量，用于存储与公告相关的建筑ID列表
private Integer buildingId; // 定义一个私有的Integer类型的buildingId变量，用于存储单个建筑ID
// Getter和Setter方法
public Integer getId() { // 获取公告的ID
return id;
}
public void setId(Integer id) { // 设置公告的ID
this.id = id;
}
public String getTitle() { // 获取公告的标题
return title;
}
public void setTitle(String title) { // 设置公告的标题
this.title = title;
}
public String getContent() { // 获取公告的内容
return content;
}
public void setContent(String content) { // 设置公告的内容
this.content = content;
}
public Date getCreateTime() { // 获取公告的创建时间
return createTime;
}
public void setCreateTime(Date createTime) { // 设置公告的创建时间
this.createTime = createTime;
}
public Integer getUserId() { // 获取发布公告的用户ID
return userId;
}
public void setUserId(Integer userId) { // 设置发布公告的用户ID
this.userId = userId;
}
public String getFilepath() { // 获取与公告相关的文件路径
return filepath;
}
public void setFilepath(String filepath) { // 设置与公告相关的文件路径
this.filepath = filepath;
}
public User getUser() { // 获取发布公告的用户信息
return user;
}
public void setUser(User user) { // 设置发布公告的用户信息
this.user = user;
}
public List<Integer> getBuildingIds() { // 获取与公告相关的建筑ID列表
return buildingIds;
}
public void setBuildingIds(List<Integer> buildingIds) { // 设置与公告相关的建筑ID列表
this.buildingIds = buildingIds;
}
public Integer getBuildingId() { // 获取单个建筑ID
return buildingId;
}
public void setBuildingId(Integer buildingId) { // 设置单个建筑ID
this.buildingId = buildingId;
}
}

70
zsq/NoticeController.java
Unescape View File

@ -0,0 +1,70 @@
package com.yanzhen.controller; // 定义包名
import com.github.pagehelper.PageInfo; // 导入分页插件
import com.yanzhen.entity.Notice; // 导入公告实体类
import com.yanzhen.entity.User; // 导入用户实体类
import com.yanzhen.service.NoticeService公告管理; // 导入公告服务接口
import com.yanzhen.service.UserService用户管理; // 导入用户服务接口
import com.yanzhen.utils.Result; // 导入结果工具类
import org.springframework.beans.factory.annotation.Autowired; // 导入自动装配注解
import org.springframework.web.bind.annotation.*; // 导入Spring MVC相关注解
import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest类
import java.util.Map; // 导入Map接口
@RestController // 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中
@RequestMapping("/notice") // 设置请求路径前缀为/notice
public class NoticeController { // 定义控制器类
@Autowired // 自动注入NoticeService实例
private NoticeService公告管理 noticeService;
@Autowired // 自动注入UserService实例
private UserService用户管理 userService;
@PostMapping("create") // 映射POST请求到create方法
public Result create(@RequestBody Notice notice, HttpServletRequest request){ // 接收JSON格式的公告数据和请求对象
User user = (User) request.getAttribute("user"); // 从请求中获取当前登录的用户信息
notice.setUserId(user.getId()); // 设置公告的用户ID为当前用户的ID
int flag = noticeService.create(notice); // 调用服务层创建公告
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回成功结果
}else{ // 如果创建失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("delete") // 映射GET请求到delete方法
public Result delete(String ids){ // 接收要删除的公告ID字符串
int flag = noticeService.delete(ids); // 调用服务层删除公告
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回成功结果
}else{ // 如果删除失败
return Result.fail(); // 返回失败结果
}
}
@PostMapping("update") // 映射POST请求到update方法
public Result update(@RequestBody Notice notice){ // 接收JSON格式的公告数据
int flag = noticeService.updateSelective(notice); // 调用服务层更新公告
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回成功结果
}else{ // 如果更新失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("detail") // 映射GET请求到detail方法
public Notice detail(Integer id){ // 接收公告ID
return noticeService.detail(id); // 调用服务层获取公告详情并返回
}
@PostMapping("query") // 映射POST请求到query方法
public Map<String,Object> query(@RequestBody Notice notice){ // 接收JSON格式的查询条件
PageInfo<Notice> pageInfo = noticeService.query(notice); // 调用服务层进行分页查询
pageInfo.getList().forEach(entity->{ // 遍历查询结果列表
entity.setUser(userService.detail(entity.getUserId())); // 为每个公告设置对应的用户信息
});
return Result.ok(pageInfo); // 返回包含分页信息的查询结果
}
}

26
zsq/NoticeMapper.java
Unescape View File

@ -0,0 +1,26 @@
package com.yanzhen.mapper; // 定义包名
import java.util.List; // 导入List集合类
import java.util.Map; // 导入Map集合类
import com.yanzhen.entity.Notice; // 导入Notice实体类
public interface NoticeMapper { // 定义NoticeMapper接口
public int create(Notice notice); // 创建Notice记录，返回受影响的行数
public int delete(Integer id); // 根据ID删除Notice记录，返回受影响的行数
public int update(Notice notice); // 更新Notice记录，返回受影响的行数
public int updateSelective(Notice notice); // 选择性更新Notice记录，返回受影响的行数
public List<Notice> query(Notice notice); // 根据条件查询Notice列表
public List<Notice> queryByBuildingId(Notice notice); // 根据建筑ID查询Notice列表
public Notice detail(Integer id); // 根据ID查询Notice详情
public int count(Notice notice); // 统计符合条件的Notice数量
}

42
zsq/NoticeReceive.java
Unescape View File

@ -0,0 +1,42 @@
package com.yanzhen.entity;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
public class NoticeReceive extends Entity{// 定义一个名为NoticeReceive的类，继承自Entity类
private Integer id; // 定义一个私有的Integer类型的变量id
private Integer noticeId;// 定义一个私有的Integer类型的变量noticeId
private Integer buildingId;// 定义一个私有的Integer类型的变量buildingId
public Integer getId() {
return id;// 定义一个公共方法getId，用于获取id的值
}
public void setId(Integer id) {
this.id = id;// 定义一个公共方法setId，用于设置id的值
}
public Integer getNoticeId() {
return noticeId;// 定义一个公共方法getNoticeId，用于获取noticeId的值
}
public void setNoticeId(Integer noticeId) {
this.noticeId = noticeId;// 定义一个公共方法setNoticeId，用于设置noticeId的值
}
public Integer getBuildingId() {
return buildingId;// 定义一个公共方法getBuildingId，用于获取buildingId的值
}
public void setBuildingId(Integer buildingId) {
this.buildingId = buildingId;// 定义一个公共方法setBuildingId，用于设置buildingId的值
}
}

60
zsq/NoticeReceiveController.java
Unescape View File

@ -0,0 +1,60 @@
package com.yanzhen.controller; // 定义包名
import com.github.pagehelper.PageInfo; // 导入分页插件
import com.yanzhen.entity.NoticeReceive; // 导入公告接收实体类
import com.yanzhen.service.NoticeReceiveService公告查看; // 导入公告接收服务接口
import com.yanzhen.utils.Result; // 导入结果工具类
import org.springframework.beans.factory.annotation.Autowired; // 导入自动装配注解
import org.springframework.web.bind.annotation.*; // 导入Spring MVC相关注解
import java.util.Map; // 导入Map接口
@RestController // 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中
@RequestMapping("/noticeReceive") // 设置请求路径前缀为/noticeReceive
public class NoticeReceiveController { // 定义控制器类
@Autowired // 自动注入NoticeReceiveService实例
private NoticeReceiveService公告查看 noticeReceiveService;
@PostMapping("create") // 映射POST请求到create方法
public Result create(@RequestBody NoticeReceive noticeReceive){ // 接收JSON格式的公告接收数据
int flag = noticeReceiveService.create(noticeReceive); // 调用服务层创建公告接收
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回成功结果
}else{ // 如果创建失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("delete") // 映射GET请求到delete方法
public Result delete(String ids){ // 接收要删除的公告接收ID字符串
int flag = noticeReceiveService.delete(ids); // 调用服务层删除公告接收
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回成功结果
}else{ // 如果删除失败
return Result.fail(); // 返回失败结果
}
}
@PostMapping("update") // 映射POST请求到update方法
public Result update(@RequestBody NoticeReceive noticeReceive){ // 接收JSON格式的公告接收数据
int flag = noticeReceiveService.update(noticeReceive); // 调用服务层更新公告接收
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回成功结果
}else{ // 如果更新失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("detail") // 映射GET请求到detail方法
public NoticeReceive detail(Integer id){ // 接收公告接收ID
return noticeReceiveService.detail(id); // 调用服务层获取公告接收详情并返回
}
@PostMapping("query") // 映射POST请求到query方法
public Map<String,Object> query(@RequestBody NoticeReceive noticeReceive){ // 接收JSON格式的查询条件
PageInfo<NoticeReceive> pageInfo = noticeReceiveService.query(noticeReceive); // 调用服务层进行分页查询
return Result.ok(pageInfo); // 返回包含分页信息的查询结果
}
}

25
zsq/NoticeReceiveMapper.java
Unescape View File

@ -0,0 +1,25 @@
package com.yanzhen.mapper; // 定义包名
import java.util.List; // 导入List集合类
import java.util.Map; // 导入Map集合类
import com.yanzhen.entity.NoticeReceive; // 导入NoticeReceive实体类
public interface NoticeReceiveMapper { // 定义NoticeReceiveMapper接口
public int create(NoticeReceive noticeReceive); // 创建NoticeReceive记录的方法
public int delete(Integer id); // 根据ID删除NoticeReceive记录的方法
public int deleteByNoticeId(Integer noticeId); // 根据通知ID删除NoticeReceive记录的方法
public int update(NoticeReceive noticeReceive); // 更新NoticeReceive记录的方法
public int updateSelective(NoticeReceive noticeReceive); // 选择性更新NoticeReceive记录的方法
public List<NoticeReceive> query(NoticeReceive noticeReceive); // 查询NoticeReceive记录列表的方法
public NoticeReceive detail(Integer id); // 根据ID获取NoticeReceive详情的方法
public int count(NoticeReceive noticeReceive); // 统计NoticeReceive记录数量的方法
}

59
zsq/NoticeReceiveService公告查看.java
Unescape View File

@ -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方法
}
}

100
zsq/NoticeService公告管理.java
Unescape View File

@ -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); // 查询并返回符合条件的通知数量
}
}

89
zsq/Org.java
Unescape View File

@ -0,0 +1,89 @@
package com.yanzhen.entity;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
public class Org extends Entity{
// 定义一个私有的Integer类型的变量id，用于存储组织的唯一标识符
private Integer id;
// 使用@Length注解限制name字段的最大长度为100个字符
@Length(max = 100)
private String name;
private Integer type;//定义一个私有的Integer类型的变量type，用于表示组织的类型。--类型说明：1 - 学院; 2 - 系;3 - 专业;4 - 班级
// 定义一个私有的Integer类型的变量gradeId，用于存储年级ID
private Integer gradeId;
// 定义一个私有的Integer类型的变量parentId，用于存储父级组织的ID
private Integer parentId;
// 使用@Length注解限制remark字段的最大长度为200个字符
@Length(max = 200)
private String remark;
// 获取id的值
public Integer getId() {
return id;
}
// 设置id的值
public void setId(Integer id) {
this.id = id;
}
// 获取name的值
public String getName() {
return name;
}
// 设置name的值
public void setName(String name) {
this.name = name;
}
// 获取type的值
public Integer getType() {
return type;
}
// 设置type的值
public void setType(Integer type) {
this.type = type;
}
// 获取gradeId的值
public Integer getGradeId() {
return gradeId;
}
// 设置gradeId的值
public void setGradeId(Integer gradeId) {
this.gradeId = gradeId;
}
// 获取parentId的值
public Integer getParentId() {
return parentId;
}
// 设置parentId的值
public void setParentId(Integer parentId) {
this.parentId = parentId;
}
// 获取remark的值
public String getRemark() {
return remark;
}
// 设置remark的值
public void setRemark(String remark) {
this.remark = remark;
}
}

111
zsq/OrgController.java
Unescape View File

@ -0,0 +1,111 @@
package com.yanzhen.controller; // 定义包名
import com.github.pagehelper.PageInfo; // 导入分页插件
import com.yanzhen.entity.Org; // 导入组织实体类
import com.yanzhen.service.OrgService机构管理; // 导入组织服务接口
import com.yanzhen.utils.Result; // 导入结果工具类
import org.springframework.beans.factory.annotation.Autowired; // 导入自动装配注解
import org.springframework.web.bind.annotation.*; // 导入Spring MVC相关注解
import java.util.ArrayList; // 导入ArrayList类
import java.util.HashMap; // 导入HashMap类
import java.util.List; // 导入List接口
import java.util.Map; // 导入Map接口
@RestController // 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中
@RequestMapping("/org") // 设置请求路径前缀为/org
public class OrgController { // 定义控制器类
@Autowired // 自动注入OrgService实例
private OrgService机构管理 orgService;
@GetMapping("tree") // 映射GET请求到/org/tree路径
public Result tree(){ // 定义获取树形结构的方法
PageInfo<Org> pageInfo = orgService.query(null); // 查询所有组织数据
//所有的树形数据
List<Org> list = pageInfo.getList(); // 获取查询结果列表
//要构建的树形结构
List<Map<String,Object>> trees = new ArrayList<>(); // 初始化树形结构的列表
for (Org entity : list) { // 遍历所有组织数据
if(entity.getParentId() == 0){ // 如果父ID为0，表示是顶级节点
Map<String,Object> map = new HashMap<>(); // 创建一个新的Map对象
map.put("id",entity.getId()); // 将组织ID放入Map
map.put("name",entity.getName()); // 将组织名称放入Map
if(entity.getType()<4){ // 如果类型小于4，表示有子节点
map.put("isParent",true); // 标记为父节点
map.put("open",true); // 默认展开
map.put("children",getChild(entity,list)); // 递归获取子节点并放入Map
}else{
map.put("isParent",false); // 标记为叶子节点
}
trees.add(map); // 将Map添加到树形结构列表中
}
}
return Result.ok(trees); // 返回包含树形结构的响应结果
}
//自己调自己、有出口
public List<Map<String,Object>> getChild(Org parent,List<Org> list){ // 定义递归方法获取子节点
List<Map<String,Object>> child = new ArrayList<>(); // 初始化子节点列表
for (Org org : list) { // 遍历所有组织数据
if(parent.getId() == org.getParentId()){ // 如果当前组织的父ID等于传入的父节点ID
Map<String,Object> map = new HashMap<>(); // 创建一个新的Map对象
map.put("id",org.getId()); // 将组织ID放入Map
map.put("name",org.getName()); // 将组织名称放入Map
if(org.getType()<4){ // 如果类型小于4，表示有子节点
map.put("isParent",true); // 标记为父节点
map.put("children",getChild(org,list)); // 递归获取子节点并放入Map
}else{
map.put("isParent",false); // 标记为叶子节点
}
child.add(map); // 将Map添加到子节点列表中
}
}
return child; // 返回子节点列表
}
@PostMapping("create") // 映射POST请求到/org/create路径
public Result create(@RequestBody Org org){ // 定义创建组织的方法
//未设置则为一级栏目
if(org.getParentId() == null){ // 如果父ID为空，设置为0（顶级节点）
org.setParentId(0);
}
int flag = orgService.create(org); // 调用服务层方法创建组织
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回成功结果
}else{
return Result.fail(); // 返回失败结果
}
}
@GetMapping("delete") // 映射GET请求到/org/delete路径
public Result delete(String id){ // 定义删除组织的方法
int flag = orgService.delete(id); // 调用服务层方法删除组织
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回成功结果
}else{
return Result.fail(); // 返回失败结果
}
}
@PostMapping("update") // 映射POST请求到/org/update路径
public Result update(@RequestBody Org org){ // 定义更新组织的方法
int flag = orgService.update(org); // 调用服务层方法更新组织信息
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回成功结果
}else{
return Result.fail(); // 返回失败结果
}
}
@GetMapping("detail") // 映射GET请求到/org/detail路径
public Org detail(Integer id){ // 定义获取组织详情的方法
return orgService.detail(id); // 调用服务层方法获取组织详情并返回
}
@PostMapping("query") // 映射POST请求到/org/query路径
public Map<String,Object> query(@RequestBody Org org){ // 定义查询组织的方法
PageInfo<Org> pageInfo = orgService.query(org); // 调用服务层方法查询组织数据
return Result.ok(pageInfo); // 返回包含查询结果的响应结果
}
}

25
zsq/OrgMapper.java
Unescape View File

@ -0,0 +1,25 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构
import com.yanzhen.entity.Org; // 导入Org实体类，用于操作组织信息
public interface OrgMapper { // 定义OrgMapper接口，提供对Org实体进行数据库操作的方法
public int create(Org org); // 创建一个新的Org记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个Org记录，返回影响的行数
public int update(Org org); // 更新一个Org记录，返回影响的行数
public int updateSelective(Org org); // 选择性地更新一个Org记录，返回影响的行数
public List<Org> query(Org org); // 根据条件查询Org记录，返回符合条件的Org列表
public Org detail(Integer id); // 根据id查询一个Org记录的详细信息，返回Org对象
public int count(Org org); // 根据条件统计Org记录的数量，返回记录数量
public List<Org> queryOrgBySelectionId(Integer selectionId); // 根据selectionId查询相关的Org记录，返回符合条件的Org列表
}

65
zsq/OrgService机构管理.java
Unescape View File

@ -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方法
}
}

59
zsq/Record.java
Unescape View File

@ -0,0 +1,59 @@
package com.yanzhen.entity;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
public class Record extends Entity{ // 定义一个名为Record的类，继承自Entity类
private Integer id; // 定义一个私有的Integer类型的变量id
private Integer studentId; // 定义一个私有的Integer类型的变量studentId
private Integer dormitoryId; // 定义一个私有的Integer类型的变量dormitoryId
private Integer bedId; // 定义一个私有的Integer类型的变量bedId
private Integer status; // 定义一个私有的Integer类型的变量status，用于表示入住或退宿状态（ 1入住/2退宿）
private Date createDate; // 定义一个私有的Date类型的变量createDate，用于记录创建日期
public Integer getId() { // 定义一个公共方法getId，用于获取id的值
return id;
}
public void setId(Integer id) { // 定义一个公共方法setId，用于设置id的值
this.id = id;
}
public Integer getStudentId() { // 定义一个公共方法getStudentId，用于获取studentId的值
return studentId;
}
public void setStudentId(Integer studentId) { // 定义一个公共方法setStudentId，用于设置studentId的值
this.studentId = studentId;
}
public Integer getDormitoryId() { // 定义一个公共方法getDormitoryId，用于获取dormitoryId的值
return dormitoryId;
}
public void setDormitoryId(Integer dormitoryId) { // 定义一个公共方法setDormitoryId，用于设置dormitoryId的值
this.dormitoryId = dormitoryId;
}
public Integer getBedId() { // 定义一个公共方法getBedId，用于获取bedId的值
return bedId;
}
public void setBedId(Integer bedId) { // 定义一个公共方法setBedId，用于设置bedId的值
this.bedId = bedId;
}
public Integer getStatus() { // 定义一个公共方法getStatus，用于获取status的值
return status;
}
public void setStatus(Integer status) { // 定义一个公共方法setStatus，用于设置status的值
this.status = status;
}
public Date getCreateDate() { // 定义一个公共方法getCreateDate，用于获取createDate的值
return createDate;
}
public void setCreateDate(Date createDate) { // 定义一个公共方法setCreateDate，用于设置createDate的值
this.createDate = createDate;
}
}

60
zsq/RecordController.java
Unescape View File

@ -0,0 +1,60 @@
package com.yanzhen.controller; // 定义包名
import com.github.pagehelper.PageInfo; // 导入分页插件
import com.yanzhen.entity.Record; // 导入记录实体类
import com.yanzhen.service.RecordService用户id的增删查改数据库; // 导入记录服务接口
import com.yanzhen.utils.Result; // 导入结果工具类
import org.springframework.beans.factory.annotation.Autowired; // 导入自动装配注解
import org.springframework.web.bind.annotation.*; // 导入Spring MVC相关注解
import java.util.Map; // 导入Map接口
@RestController // 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中
@RequestMapping("/record") // 设置请求路径前缀为/record
public class RecordController { // 定义控制器类
@Autowired // 自动注入RecordService实例
private RecordService用户id的增删查改数据库 recordService;
@PostMapping("create") // 映射POST请求到create方法
public Result create(@RequestBody Record record){ // 接收JSON格式的记录数据
int flag = recordService.create(record); // 调用服务层创建记录
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回成功结果
}else{ // 如果创建失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("delete") // 映射GET请求到delete方法
public Result delete(String ids){ // 接收要删除的记录ID字符串
int flag = recordService.delete(ids); // 调用服务层删除记录
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回成功结果
}else{ // 如果删除失败
return Result.fail(); // 返回失败结果
}
}
@PostMapping("update") // 映射POST请求到update方法
public Result update(@RequestBody Record record){ // 接收JSON格式的记录数据
int flag = recordService.update(record); // 调用服务层更新记录
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回成功结果
}else{ // 如果更新失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("detail") // 映射GET请求到detail方法
public Record detail(Integer id){ // 接收记录ID
return recordService.detail(id); // 调用服务层获取记录详情并返回
}
@PostMapping("query") // 映射POST请求到query方法
public Map<String,Object> query(@RequestBody Record record){ // 接收JSON格式的查询条件
PageInfo<Record> pageInfo = recordService.query(record); // 调用服务层进行分页查询
return Result.ok(pageInfo); // 返回包含分页信息的查询结果
}
}

24
zsq/RecordMapper.java
Unescape View File

@ -0,0 +1,24 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构
import com.yanzhen.entity.Record; // 导入Record实体类，用于操作记录信息
public interface RecordMapper { // 定义RecordMapper接口，提供对Record实体进行数据库操作的方法
public int create(Record record); // 创建一个新的Record记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个Record记录，返回影响的行数
public int update(Record record); // 更新一个Record记录，返回影响的行数
public int updateSelective(Record record); // 选择性地更新一个Record记录，返回影响的行数
public List<Record> query(Record record); // 根据条件查询Record记录，返回符合条件的Record列表
public Record detail(Integer id); // 根据id查询一个Record记录的详细信息，返回Record对象
public int count(Record record); // 根据条件统计Record记录的数量，返回记录数量
}

59
zsq/RecordService用户id的增删查改数据库.java
Unescape View File

@ -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用户id的增删查改数据库 { // 定义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方法
}
}

108
zsq/Repair.java
Unescape View File

@ -0,0 +1,108 @@
package com.yanzhen.entity;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
public class Repair extends Entity{ // 定义一个名为Repair的类，继承自Entity类
private Integer id; // 定义一个私有的Integer类型的变量id
private Integer studentId; // 定义一个私有的Integer类型的变量studentId
private Integer dormitoryId; // 定义一个私有的Integer类型的变量dormitoryId
private Integer buildingId; // 定义一个私有的Integer类型的变量buildingId
@Length(max = 500) // 限制description字段的最大长度为500
private String description; // 定义一个私有的String类型的变量description
private Date createDate; // 定义一个私有的Date类型的变量createDate
private Integer status; // 定义一个私有的Integer类型的变量status，用于表示维修状态（0待解决/1已解决）
private Student student; // 定义一个私有的Student类型的变量student
private Dormitory dormitory; // 定义一个私有的Dormitory类型的变量dormitory，并命名为“宿舍”
private Building building; // 定义一个私有的Building类型的变量building，并命名为“楼宇”
private String name; // 定义一个私有的String类型的变量name
public Integer getId() { // 定义一个公共方法getId，用于获取id的值
return id;
}
public void setId(Integer id) { // 定义一个公共方法setId，用于设置id的值
this.id = id;
}
public Integer getStudentId() { // 定义一个公共方法getStudentId，用于获取studentId的值
return studentId;
}
public void setStudentId(Integer studentId) { // 定义一个公共方法setStudentId，用于设置studentId的值
this.studentId = studentId;
}
public Integer getDormitoryId() { // 定义一个公共方法getDormitoryId，用于获取dormitoryId的值
return dormitoryId;
}
public void setDormitoryId(Integer dormitoryId) { // 定义一个公共方法setDormitoryId，用于设置dormitoryId的值
this.dormitoryId = dormitoryId;
}
public Integer getBuildingId() { // 定义一个公共方法getBuildingId，用于获取buildingId的值
return buildingId;
}
public void setBuildingId(Integer buildingId) { // 定义一个公共方法setBuildingId，用于设置buildingId的值
this.buildingId = buildingId;
}
public String getDescription() { // 定义一个公共方法getDescription，用于获取description的值
return description;
}
public void setDescription(String description) { // 定义一个公共方法setDescription，用于设置description的值
this.description = description;
}
public Date getCreateDate() { // 定义一个公共方法getCreateDate，用于获取createDate的值
return createDate;
}
public void setCreateDate(Date createDate) { // 定义一个公共方法setCreateDate，用于设置createDate的值
this.createDate = createDate;
}
public Integer getStatus() { // 定义一个公共方法getStatus，用于获取status的值
return status;
}
public void setStatus(Integer status) { // 定义一个公共方法setStatus，用于设置status的值
this.status = status;
}
public Student getStudent() { // 定义一个公共方法getStudent，用于获取student的值
return student;
}
public void setStudent(Student student) { // 定义一个公共方法setStudent，用于设置student的值
this.student = student;
}
public Dormitory getDormitory() { // 定义一个公共方法getDormitory，用于获取dormitory的值
return dormitory;
}
public void setDormitory(Dormitory dormitory) { // 定义一个公共方法setDormitory，用于设置dormitory的值
this.dormitory = dormitory;
}
public Building getBuilding() { // 定义一个公共方法getBuilding，用于获取building的值
return building;
}
public void setBuilding(Building building) { // 定义一个公共方法setBuilding，用于设置building的值
this.building = building;
}
public String getName() { // 定义一个公共方法getName，用于获取name的值
return name;
}
public void setName(String name) { // 定义一个公共方法setName，用于设置name的值
this.name = name;
}
}

85
zsq/RepairController.java
Unescape View File

@ -0,0 +1,85 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.Repair;
import com.yanzhen.entity.Student;
import com.yanzhen.service.BuildingService楼层设置;
import com.yanzhen.service.DormitoryService宿舍编号设置;
import com.yanzhen.service.RepairService报修管理;
import com.yanzhen.service.StudentService学生管理;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController // 声明这是一个RESTful控制器
@RequestMapping("/repair") // 设置请求路径前缀为/repair
public class RepairController {
@Autowired // 自动注入RepairService实例
private RepairService报修管理 repairService;
@Autowired // 自动注入StudentService实例
private StudentService学生管理 studentService;
@Autowired // 自动注入DormitoryService实例
private DormitoryService宿舍编号设置 dormitoryService;
@Autowired // 自动注入BuildingService实例
private BuildingService楼层设置 buildingService;
@PostMapping("create") // 映射HTTP POST请求到create方法
public Result create(@RequestBody Repair repair){ // 接收一个Repair对象作为请求体
int flag = repairService.create(repair); // 调用服务层创建维修记录
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回成功结果
}else{ // 如果创建失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("delete") // 映射HTTP GET请求到delete方法
public Result delete(String ids){ // 接收要删除的记录ID字符串
int flag = repairService.delete(ids); // 调用服务层删除指定ID的维修记录
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回成功结果
}else{ // 如果删除失败
return Result.fail(); // 返回失败结果
}
}
@PostMapping("update") // 映射HTTP POST请求到update方法
public Result update(@RequestBody Repair repair){ // 接收一个Repair对象作为请求体
int flag = repairService.updateSelective(repair); // 调用服务层更新维修记录，只更新非空字段
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回成功结果
}else{ // 如果更新失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("detail") // 映射HTTP GET请求到detail方法
public Repair detail(Integer id){ // 接收维修记录的ID
return repairService.detail(id); // 调用服务层获取指定ID的维修记录详情并返回
}
@PostMapping("query") // 映射HTTP POST请求到query方法
public Map<String,Object> query(@RequestBody Repair repair){ // 接收一个Repair对象作为查询条件
PageInfo<Repair> pageInfo = new PageInfo<>(); // 创建一个分页信息对象
if(repair.getName() != null){ // 如果查询条件中包含学生姓名
Student detailId = studentService.detailByName(repair.getName()); // 根据姓名查找学生ID
if(detailId != null){ // 如果找到对应的学生ID
repair.setStudentId(detailId.getId()); // 设置查询条件的studentId属性
}else{ // 如果没有找到对应的学生ID
pageInfo.setList(null); // 设置分页列表为空
pageInfo.setSize(0); // 设置分页大小为0
return Result.ok(pageInfo); // 返回空的查询结果
}
}
pageInfo = repairService.query(repair); // 调用服务层进行查询操作
pageInfo.getList().forEach(entity->{ // 遍历查询结果列表
entity.setBuilding(buildingService.detail(entity.getBuildingId())); // 设置每个维修记录的楼宇信息
entity.setStudent(studentService.detail(entity.getStudentId())); // 设置每个维修记录的学生信息
entity.setDormitory(dormitoryService.detail(entity.getDormitoryId())); // 设置每个维修记录的宿舍信息
});
return Result.ok(pageInfo); // 返回查询结果
}
}

24
zsq/RepairMapper.java
Unescape View File

@ -0,0 +1,24 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构
import com.yanzhen.entity.Repair; // 导入Repair实体类，用于操作维修记录信息
public interface RepairMapper { // 定义RepairMapper接口，提供对Repair实体进行数据库操作的方法
public int create(Repair repair); // 创建一个新的Repair记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个Repair记录，返回影响的行数
public int update(Repair repair); // 更新一个Repair记录，返回影响的行数
public int updateSelective(Repair repair); // 选择性地更新一个Repair记录，返回影响的行数
public List<Repair> query(Repair repair); // 根据条件查询Repair记录，返回符合条件的Repair列表
public Repair detail(Integer id); // 根据id查询一个Repair记录的详细信息，返回Repair对象
public int count(Repair repair); // 根据条件统计Repair记录的数量，返回记录数量
}

123
zsq/RepairService报修管理.java
Unescape View File

@ -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);
}
}

105
zsq/Result.java
Unescape View File

@ -0,0 +1,105 @@
package com.yanzhen.utils; // 定义包名
import com.github.pagehelper.PageInfo; // 导入分页信息类
import java.util.HashMap; // 导入HashMap类
import java.util.Map; // 导入Map接口
public class Result { // 定义Result类
public static final Integer SUCCESS_CODE = 200; // 成功状态码
public static final Integer TOKEN_ERROR = 400; // 令牌错误状态码
public static final Integer ERROR_CODE = 500; // 错误状态码
private Integer code; // 响应码
private String msg; // 响应消息
private Object data = null; // 响应数据，默认为null
// 根据分页信息创建成功的响应结果
public static Map<String,Object> ok(PageInfo pageInfo){
Map<String,Object> map = new HashMap<>(); // 创建HashMap存储响应结果
map.put("code",SUCCESS_CODE); // 设置响应码为成功
map.put("msg","查询成功"); // 设置响应消息
map.put("count",pageInfo.getTotal()); // 设置总记录数
map.put("data",pageInfo.getList()); // 设置数据列表
return map; // 返回响应结果
}
// 创建自定义状态码、消息和数据的响应结果
public static Result ok(Integer status,String msg,Object data){
return new Result(status,msg,data); // 返回新的Result对象
}
// 创建自定义消息和数据的响应结果，状态码为成功
public static Result ok(String msg,Object data){
return new Result(SUCCESS_CODE,msg,data); // 返回新的Result对象
}
// 创建仅包含数据的响应结果，状态码为成功，消息为"操作成功"
public static Result ok(Object data){
return new Result(SUCCESS_CODE,"操作成功",data); // 返回新的Result对象
}
// 创建无数据的成功响应结果，状态码为成功，消息为"操作成功"
public static Result ok(){
return new Result(SUCCESS_CODE,"操作成功",null); // 返回新的Result对象
}
// 创建自定义状态码和消息的失败响应结果
public static Result fail(Integer status,String msg){
return new Result(status,msg); // 返回新的Result对象
}
// 创建自定义消息的失败响应结果，状态码为错误
public static Result fail(String msg){
return new Result(ERROR_CODE,msg); // 返回新的Result对象
}
// 创建无消息的失败响应结果，状态码为错误，消息为"操作失败"
public static Result fail(){
return new Result(ERROR_CODE,"操作失败"); // 返回新的Result对象
}
// 构造函数，初始化响应码和消息
public Result(Integer code, String msg) {
this.code = code; // 设置响应码
this.msg = msg; // 设置响应消息
}
// 构造函数，初始化响应码、消息和数据
public Result(Integer code, String msg, Object data) {
this.code = code; // 设置响应码
this.msg = msg; // 设置响应消息
this.data = data; // 设置响应数据
}
// 获取响应码
public Integer getCode() {
return code; // 返回响应码
}
// 设置响应码
public void setCode(Integer code) {
this.code = code; // 设置响应码
}
// 获取响应消息
public String getMsg() {
return msg; // 返回响应消息
}
// 设置响应消息
public void setMsg(String msg) {
this.msg = msg; // 设置响应消息
}
// 获取响应数据
public Object getData() {
return data; // 返回响应数据
}
// 设置响应数据
public void setData(Object data) {
this.data = data; // 设置响应数据
}
}

96
zsq/Selection.java
Unescape View File

@ -0,0 +1,96 @@
package com.yanzhen.entity;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
import java.util.List;
public class Selection extends Entity{// 定义一个名为Selection的类，继承自Entity类
private Integer id; // 定义一个私有的Integer类型的变量id
@Length(max = 100) // 定义一个私有的String类型的变量name，并设置其最大长度为100
private String name;
private Date startTime;// 定义一个私有的Date类型的变量startTime
private Date endTime;// 定义一个私有的Date类型的变量endTime
@Length(max = 100)// 定义一个私有的String类型的变量remark，并设置其最大长度为100
private String remark;
private List<Integer> clazzIds; // 定义一个私有的List<Integer>类型的变量clazzIds
private List<Org> clazzes;// 定义一个私有的List<Org>类型的变量clazzes
public Integer getId() {// 定义一个公共方法getId，用于获取id的值
return id;
}
public void setId(Integer id) { // 定义一个公共方法setId，用于设置id的值
this.id = id;
}
public String getName() { // 定义一个公共方法getName，用于获取name的值
return name;
}
public void setName(String name) { // 定义一个公共方法setName，用于设置name的值
this.name = name;
}
public Date getStartTime() { // 定义一个公共方法getStartTime，用于获取startTime的值
return startTime;
}
public void setStartTime(Date startTime) {// 定义一个公共方法setStartTime，用于设置startTime的值
this.startTime = startTime;
}
public Date getEndTime() {// 定义一个公共方法getEndTime，用于获取endTime的值
return endTime;
}
public void setEndTime(Date endTime) {// 定义一个公共方法setEndTime，用于设置endTime的值
this.endTime = endTime;
}
public String getRemark() {// 定义一个公共方法getRemark，用于获取remark的值
return remark;
}
public void setRemark(String remark) {// 定义一个公共方法setRemark，用于设置remark的值
this.remark = remark;
}
public List<Integer> getClazzIds() { // 定义一个公共方法getClazzIds，用于获取clazzIds的值
return clazzIds;
}
public void setClazzIds(List<Integer> clazzIds) {// 定义一个公共方法setClazzIds，用于设置clazzIds的值
this.clazzIds = clazzIds;
}
public List<Org> getClazzes() { // 定义一个公共方法getClazzes，用于获取clazzes的值
return clazzes;
}
public void setClazzes(List<Org> clazzes) {// 定义一个公共方法setClazzes，用于设置clazzes的值
this.clazzes = clazzes;
}
}

71
zsq/SelectionController.java
Unescape View File

@ -0,0 +1,71 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.Org;
import com.yanzhen.entity.Selection;
import com.yanzhen.service.OrgService机构管理;
import com.yanzhen.service.SelectionJoinerService用户id筛选增删查改数据库;
import com.yanzhen.service.SelectionService学生查询管理;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
@RestController // 声明这是一个RESTful控制器，返回的数据直接写入HTTP响应体中
@RequestMapping("/selection") // 设置请求路径的映射前缀为/selection
public class SelectionController { // 定义一个名为SelectionController的类
@Autowired // 自动注入SelectionService实例
private SelectionService学生查询管理 selectionService;
@Autowired // 自动注入SelectionJoinerService实例
private SelectionJoinerService用户id筛选增删查改数据库 selectionJoinerService;
@Autowired // 自动注入OrgService实例
private OrgService机构管理 orgService;
@PostMapping("create") // 映射HTTP POST请求到create方法
public Result create(@RequestBody Selection selection){ // 接收JSON格式的Selection对象作为请求体
int flag = selectionService.create(selection); // 调用selectionService的create方法创建记录
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回操作成功的Result对象
}else{ // 如果创建失败
return Result.fail(); // 返回操作失败的Result对象
}
}
@GetMapping("delete") // 映射HTTP GET请求到delete方法
public Result delete(String ids){ // 接收要删除的记录ID字符串
int flag = selectionService.delete(ids); // 调用selectionService的delete方法删除记录
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回操作成功的Result对象
}else{ // 如果删除失败
return Result.fail(); // 返回操作失败的Result对象
}
}
@PostMapping("update") // 映射HTTP POST请求到update方法
public Result update(@RequestBody Selection selection){ // 接收JSON格式的Selection对象作为请求体
int flag = selectionService.update(selection); // 调用selectionService的update方法更新记录
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回操作成功的Result对象
}else{ // 如果更新失败
return Result.fail(); // 返回操作失败的Result对象
}
}
@GetMapping("detail") // 映射HTTP GET请求到detail方法
public Selection detail(Integer id){ // 接收记录的ID作为参数
return selectionService.detail(id); // 调用selectionService的detail方法获取详细信息并返回
}
@PostMapping("query") // 映射HTTP POST请求到query方法
public Map<String,Object> query(@RequestBody Selection selection){ // 接收JSON格式的Selection对象作为请求体
PageInfo<Selection> pageInfo = selectionService.query(selection); // 调用selectionService的query方法查询记录
pageInfo.getList().forEach(item->{ // 遍历查询结果列表
List<Org> clazzes = orgService.queryOrgBySelectionId(item.getId()); // 根据选择ID查询关联的组织信息
item.setClazzes(clazzes); // 将组织信息设置到选择项中
});
return Result.ok(pageInfo); // 返回包含分页信息的Result对象
}
}

46
zsq/SelectionDormitory.java
Unescape View File

@ -0,0 +1,46 @@
package com.yanzhen.entity; // 定义包名，表示该类属于com.yanzhen.entity包
import javax.validation.constraints.NotNull; // 导入NotNull注解，用于字段验证
import org.hibernate.validator.constraints.Length; // 导入Length注解，用于字符串长度验证
import com.yanzhen.utils.Entity; // 导入Entity类，SelectionDormitory类继承自Entity类
import java.util.Date; // 导入Date类，用于日期处理
public class SelectionDormitory extends Entity{// 定义一个名为SelectionDormitory的类，继承自Entity类
private Integer id;// 定义一个私有的Integer类型的变量id
private Integer dormitoryId;// 定义一个私有的Integer类型的变量dormitoryId
private Integer clazzId;// 定义一个私有的Integer类型的变量clazzId
public Integer getId() {// 定义一个公共方法getId，用于获取id的值
return id;
}
public void setId(Integer id) {// 定义一个公共方法setId，用于设置id的值
this.id = id;
}
public Integer getDormitoryId() {// 定义一个公共方法getDormitoryId，用于获取dormitoryId的值
return dormitoryId;
}
public void setDormitoryId(Integer dormitoryId) {// 定义一个公共方法setDormitoryId，用于设置dormitoryId的值
this.dormitoryId = dormitoryId;
}
public Integer getClazzId() {// 定义一个公共方法getClazzId，用于获取clazzId的值
return clazzId;
}
public void setClazzId(Integer clazzId) {// 定义一个公共方法setClazzId，用于设置clazzId的值
this.clazzId = clazzId;
}
}

63
zsq/SelectionDormitoryController.java
Unescape View File

@ -0,0 +1,63 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.SelectionDormitory;
import com.yanzhen.service.SelectionDormitoryService宿舍管理;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。
@RequestMapping("/selectionDormitory") // 设置请求的根路径为 "/selectionDormitory"
public class SelectionDormitoryController {
@Autowired // 自动注入 SelectionDormitoryService 对象
private SelectionDormitoryService宿舍管理 selectionDormitoryService;
@PostMapping("create") // 映射 HTTP POST 请求到 create 方法
public Result create(@RequestBody Map<String,String> map){ // 从请求体中获取 JSON 数据并转换为 Map
//clazzId,dormitoryIds
String clazzId = map.get("clazzId"); // 从 Map 中获取班级ID
String dormitoryIds = map.get("dormitoryIds"); // 从 Map 中获取宿舍ID列表
int flag = selectionDormitoryService.create(clazzId,dormitoryIds); // 调用服务层的创建方法
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回成功结果
}else{ // 如果创建失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("delete") // 映射 HTTP GET 请求到 delete 方法
public Result delete(String ids){ // 从请求参数中获取要删除的记录ID
int flag = selectionDormitoryService.delete(ids); // 调用服务层的删除方法
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回成功结果
}else{ // 如果删除失败
return Result.fail(); // 返回失败结果
}
}
@PostMapping("update") // 映射 HTTP POST 请求到 update 方法
public Result update(@RequestBody SelectionDormitory selectionDormitory){ // 从请求体中获取 JSON 数据并转换为 SelectionDormitory 对象
int flag = selectionDormitoryService.update(selectionDormitory); // 调用服务层的更新方法
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回成功结果
}else{ // 如果更新失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("detail") // 映射 HTTP GET 请求到 detail 方法
public SelectionDormitory detail(Integer id){ // 从请求参数中获取记录ID
return selectionDormitoryService.detail(id); // 调用服务层的详情查询方法并返回结果
}
@PostMapping("query") // 映射 HTTP POST 请求到 query 方法
public Map<String,Object> query(@RequestBody SelectionDormitory selectionDormitory){ // 从请求体中获取 JSON 数据并转换为 SelectionDormitory 对象
PageInfo<SelectionDormitory> pageInfo = selectionDormitoryService.query(selectionDormitory); // 调用服务层的查询方法并获取分页信息
return Result.ok(pageInfo); // 返回包含分页信息的查询结果
}
}

25
zsq/SelectionDormitoryMapper.java
Unescape View File

@ -0,0 +1,25 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构
import com.yanzhen.entity.SelectionDormitory; // 导入SelectionDormitory实体类，用于操作宿舍选择信息
public interface SelectionDormitoryMapper { // 定义SelectionDormitoryMapper接口，提供对SelectionDormitory实体进行数据库操作的方法
public int create(SelectionDormitory selectionDormitory); // 创建一个新的SelectionDormitory记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个SelectionDormitory记录，返回影响的行数
public int deleteByClazzId(Integer clazzId); // 根据clazzId删除SelectionDormitory记录，返回影响的行数
public int update(SelectionDormitory selectionDormitory); // 更新一个SelectionDormitory记录，返回影响的行数
public int updateSelective(SelectionDormitory selectionDormitory); // 选择性地更新一个SelectionDormitory记录，返回影响的行数
public List<SelectionDormitory> query(SelectionDormitory selectionDormitory); // 根据条件查询SelectionDormitory记录，返回符合条件的SelectionDormitory列表
public SelectionDormitory detail(Integer id); // 根据id查询一个SelectionDormitory记录的详细信息，返回SelectionDormitory对象
public int count(SelectionDormitory selectionDormitory); // 根据条件统计SelectionDormitory记录的数量，返回记录数量
}

77
zsq/SelectionDormitoryService宿舍管理.java
Unescape View File

@ -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方法统计记录数量并返回结果
}
}

40
zsq/SelectionJoiner.java
Unescape View File

@ -0,0 +1,40 @@
package com.yanzhen.entity;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
public class SelectionJoiner extends Entity{// 定义一个名为SelectionJoiner的类，继承自Entity类
private Integer id;// 定义一个私有的Integer类型的变量id
private Integer selectionId;// 定义一个私有的Integer类型的变量selectionId
private Integer clazzId;// 定义一个私有的Integer类型的变量clazzId
public Integer getId() {// 定义一个公共方法getId，用于获取id的值
return id;
}
public void setId(Integer id) {// 定义一个公共方法setId，用于设置id的值
this.id = id;
}
public Integer getSelectionId() {// 定义一个公共方法getSelectionId，用于获取selectionId的值
return selectionId;
}
public void setSelectionId(Integer selectionId) {// 定义一个公共方法setSelectionId，用于设置selectionId的值
this.selectionId = selectionId;
}
public Integer getClazzId() {// 定义一个公共方法getClazzId，用于获取clazzId的值
return clazzId;
}
public void setClazzId(Integer clazzId) {// 定义一个公共方法setClazzId，用于设置clazzId的值
this.clazzId = clazzId;
}
}

60
zsq/SelectionJoinerController.java
Unescape View File

@ -0,0 +1,60 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.SelectionJoiner;
import com.yanzhen.service.SelectionJoinerService用户id筛选增删查改数据库;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController // 声明这是一个RESTful控制器，返回的数据直接写入HTTP响应体中
@RequestMapping("/selectionJoiner") // 设置请求路径的映射前缀为/selectionJoiner
public class SelectionJoinerController {
@Autowired // 自动注入SelectionJoinerService实例
private SelectionJoinerService用户id筛选增删查改数据库 selectionJoinerService;
@PostMapping("create") // 映射HTTP POST请求到create方法
public Result create(@RequestBody SelectionJoiner selectionJoiner){ // 从请求体中获取SelectionJoiner对象
int flag = selectionJoinerService.create(selectionJoiner); // 调用服务层的create方法创建记录
if(flag>0){ // 如果创建成功
return Result.ok(); // 返回成功结果
}else{ // 如果创建失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("delete") // 映射HTTP GET请求到delete方法
public Result delete(String ids){ // 从请求参数中获取要删除的记录ID
int flag = selectionJoinerService.delete(ids); // 调用服务层的delete方法删除记录
if(flag>0){ // 如果删除成功
return Result.ok(); // 返回成功结果
}else{ // 如果删除失败
return Result.fail(); // 返回失败结果
}
}
@PostMapping("update") // 映射HTTP POST请求到update方法
public Result update(@RequestBody SelectionJoiner selectionJoiner){ // 从请求体中获取SelectionJoiner对象
int flag = selectionJoinerService.update(selectionJoiner); // 调用服务层的update方法更新记录
if(flag>0){ // 如果更新成功
return Result.ok(); // 返回成功结果
}else{ // 如果更新失败
return Result.fail(); // 返回失败结果
}
}
@GetMapping("detail") // 映射HTTP GET请求到detail方法
public SelectionJoiner detail(Integer id){ // 从请求参数中获取记录ID
return selectionJoinerService.detail(id); // 调用服务层的detail方法获取记录详情并返回
}
@PostMapping("query") // 映射HTTP POST请求到query方法
public Map<String,Object> query(@RequestBody SelectionJoiner selectionJoiner){ // 从请求体中获取SelectionJoiner对象作为查询条件
PageInfo<SelectionJoiner> pageInfo = selectionJoinerService.query(selectionJoiner); // 调用服务层的query方法进行分页查询
return Result.ok(pageInfo); // 返回包含查询结果的成功结果
}
}

25
zsq/SelectionJoinerMapper.java
Unescape View File

@ -0,0 +1,25 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构
import com.yanzhen.entity.SelectionJoiner; // 导入SelectionJoiner实体类，用于操作宿舍层信息
public interface SelectionJoinerMapper { // 定义SelectionJoinerMapper接口，提供对SelectionJoiner实体进行数据库操作的方法
public int create(SelectionJoiner selectionJoiner); // 创建一个新的SelectionJoiner记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个SelectionJoiner记录，返回影响的行数
public int deleteBySelectionId(Integer selectionId); // 根据selectionId删除SelectionJoiner记录，返回影响的行数
public int update(SelectionJoiner selectionJoiner); // 更新一个SelectionJoiner记录，返回影响的行数
public int updateSelective(SelectionJoiner selectionJoiner); // 选择性地更新一个SelectionJoiner记录，返回影响的行数
public List<SelectionJoiner> query(SelectionJoiner selectionJoiner); // 根据条件查询SelectionJoiner记录，返回符合条件的SelectionJoiner列表
public SelectionJoiner detail(Integer id); // 根据id查询一个SelectionJoiner记录的详细信息，返回SelectionJoiner对象
public int count(SelectionJoiner selectionJoiner); // 根据条件统计SelectionJoiner记录的数量，返回记录数量
}

59
zsq/SelectionJoinerService用户id筛选增删查改数据库.java
Unescape View File

@ -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用户id筛选增删查改数据库 { // 定义SelectionJoinerService类 “筛选用户id----管理员”
@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方法
}
}

26
zsq/SelectionMapper.java
Unescape View File

@ -0,0 +1,26 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构
import com.yanzhen.entity.Selection; // 导入Selection实体类，用于操作选择信息
public interface SelectionMapper { // 定义SelectionMapper接口，提供对Selection实体进行数据库操作的方法
public int create(Selection selection); // 创建一个新的Selection记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个Selection记录，返回影响的行数
public int update(Selection selection); // 更新一个Selection记录，返回影响的行数
public int updateSelective(Selection selection); // 选择性地更新一个Selection记录，返回影响的行数
public List<Selection> query(Selection selection); // 根据条件查询Selection记录，返回符合条件的Selection列表
public List<Selection> queryByClazzId(Integer clazzId); // 根据clazzId查询Selection记录，返回符合条件的Selection列表
public Selection detail(Integer id); // 根据id查询一个Selection记录的详细信息，返回Selection对象
public int count(Selection selection); // 根据条件统计Selection记录的数量，返回记录数量
}

110
zsq/SelectionService学生查询管理.java
Unescape View File

@ -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记录数并返回结果
}
}

59
zsq/Storey.java
Unescape View File

@ -0,0 +1,59 @@
package com.yanzhen.entity;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
public class Storey extends Entity{// 定义一个名为Storey的类，继承自Entity类
private Integer id;// 定义一个私有的Integer类型的变量id，用于存储楼层的唯一标识符
@Length(max = 100)// 使用@Length注解限制name字段的最大长度为100个字符
private String name;// 定义一个私有的String类型的变量name，用于存储楼层的名称
private Integer buildingId;// 定义一个私有的Integer类型的变量buildingId，用于存储所属建筑的ID
@Length(max = 200)// 使用@Length注解限制remark字段的最大长度为200个字符
private String remark;// 定义一个私有的String类型的变量remark，用于存储楼层的备注信息
public Integer getId() {// 定义一个公共方法getId，用于获取楼层的唯一标识符
return id;
}
public void setId(Integer id) {// 定义一个公共方法setId，用于设置楼层的唯一标识符
this.id = id;
}
public String getName() {// 定义一个公共方法getName，用于获取楼层的名称
return name;
}
public void setName(String name) {// 定义一个公共方法setName，用于设置楼层的名称
this.name = name;
}
public Integer getBuildingId() {// 定义一个公共方法getBuildingId，用于获取所属建筑的ID
return buildingId;
}
public void setBuildingId(Integer buildingId) {// 定义一个公共方法setBuildingId，用于设置所属建筑的ID
this.buildingId = buildingId;
}
public String getRemark() {// 定义一个公共方法getRemark，用于获取楼层的备注信息
return remark;
}
public void setRemark(String remark) {// 定义一个公共方法setRemark，用于设置楼层的备注信息
this.remark = remark;
}
}

60
zsq/StoreyController.java
Unescape View File

@ -0,0 +1,60 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.Storey;
import com.yanzhen.service.StoreyService楼宇管理;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController // 声明这是一个RESTful控制器，返回的数据直接写入HTTP响应体中
@RequestMapping("/storey") // 设置请求路径前缀为/storey
public class StoreyController {
@Autowired // 自动注入StoreyService对象
private StoreyService楼宇管理 storeyService;
@PostMapping("create") // 映射HTTP POST请求到create方法
public Result create(@RequestBody Storey storey){ // @RequestBody注解用于将请求体中的JSON转换为Storey对象
int flag = storeyService.create(storey); // 调用storeyService的create方法创建记录
if(flag>0){ // 如果创建成功，返回成功的Result对象
return Result.ok();
}else{ // 如果创建失败，返回失败的Result对象
return Result.fail();
}
}
@GetMapping("delete") // 映射HTTP GET请求到delete方法
public Result delete(String ids){ // 接收要删除的记录ID字符串
int flag = storeyService.delete(ids); // 调用storeyService的delete方法删除记录
if(flag>0){ // 如果删除成功，返回成功的Result对象
return Result.ok();
}else{ // 如果删除失败，返回失败的Result对象
return Result.fail();
}
}
@PostMapping("update") // 映射HTTP POST请求到update方法
public Result update(@RequestBody Storey storey){ // @RequestBody注解用于将请求体中的JSON转换为Storey对象
int flag = storeyService.update(storey); // 调用storeyService的update方法更新记录
if(flag>0){ // 如果更新成功，返回成功的Result对象
return Result.ok();
}else{ // 如果更新失败，返回失败的Result对象
return Result.fail();
}
}
@GetMapping("detail") // 映射HTTP GET请求到detail方法
public Storey detail(Integer id){ // 接收要查询的记录ID
return storeyService.detail(id); // 调用storeyService的detail方法获取记录详情并返回
}
@PostMapping("query") // 映射HTTP POST请求到query方法
public Map<String,Object> query(@RequestBody Storey storey){ // @RequestBody注解用于将请求体中的JSON转换为Storey对象
PageInfo<Storey> pageInfo = storeyService.query(storey); // 调用storeyService的query方法查询记录，返回分页信息
return Result.ok(pageInfo); // 返回包含分页信息的成功的Result对象
}
}

23
zsq/StoreyMapper.java
Unescape View File

@ -0,0 +1,23 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构
import com.yanzhen.entity.Storey; // 导入Storey实体类，用于操作宿舍层信息
public interface StoreyMapper { // 定义StoreyMapper接口，提供对Storey实体进行数据库操作的方法
public int create(Storey storey); // 创建一个新的Storey记录，返回影响的行数
public int delete(Integer id); // 根据id删除一个Storey记录，返回影响的行数
public int update(Storey storey); // 更新一个Storey记录，返回影响的行数
public int updateSelective(Storey storey); // 选择性地更新一个Storey记录，返回影响的行数
public List<Storey> query(Storey storey); // 根据条件查询Storey记录，返回符合条件的Storey列表
public Storey detail(Integer id); // 根据id查询一个Storey记录的详细信息，返回Storey对象
public int count(Storey storey); // 根据条件统计Storey记录的数量，返回记录数量
}

59
zsq/StoreyService楼宇管理.java
Unescape View File

@ -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方法
}
}

179
zsq/StuController.java
Unescape View File

@ -0,0 +1,179 @@
package com.yanzhen.controller; // 定义包名
import com.github.pagehelper.PageInfo; // 导入分页插件
import com.yanzhen.entity.*; // 导入实体类
import com.yanzhen.service.*; // 导入服务接口
import com.yanzhen.utils.Result; // 导入结果封装类
import org.springframework.beans.factory.annotation.Autowired; // 导入自动装配注解
import org.springframework.web.bind.annotation.*; // 导入Spring MVC相关注解
import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest类
import java.util.ArrayList; // 导入ArrayList类
import java.util.Date; // 导入Date类
import java.util.HashMap; // 导入HashMap类
import java.util.List; // 导入List接口
import java.util.Map; // 导入Map接口
@RestController // 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中
@RequestMapping("/stu") // 设置请求路径前缀
public class StuController {
@Autowired // 自动注入StudentService实例
private StudentService学生管理 studentService;
@Autowired // 自动注入OrgService实例
private OrgService机构管理 orgService;
@Autowired // 自动注入GradeService实例
private GradeService年级管理 gradeService;
@Autowired // 自动注入SelectionDormitoryService实例
private SelectionDormitoryService宿舍管理 selectionDormitoryService;
@Autowired // 自动注入DormitoryService实例
private DormitoryService宿舍编号设置 dormitoryService;
@Autowired // 自动注入DormitoryStudentService实例
private DormitoryStudentService宿舍预选设置 dormitoryStudentService;
@Autowired // 自动注入AbsenceService实例
private AbsenceService缺勤管理 absenceService;
@Autowired // 自动注入RepairService实例
private RepairService报修管理 repairService;
@Autowired // 自动注入NoticeService实例
private NoticeService公告管理 noticeService;
@Autowired // 自动注入UserService实例
private UserService用户管理 userService;
@Autowired // 自动注入BuildingService实例
private BuildingService楼层设置 buildingService;
@Autowired // 自动注入SelectionService实例
private SelectionService学生查询管理 selectionService;
@GetMapping("/info") // 映射GET请求到/info路径
public Result info(HttpServletRequest request) { // 定义info方法，参数为HttpServletRequest对象
Student param = (Student)request.getAttribute("student"); // 从请求属性中获取学生信息
Student student = studentService.detail(param.getId()); // 根据学生ID获取学生详细信息
student.setOrg(orgService.detail(student.getClazzId())); // 设置学生所属组织信息
student.setGrade(gradeService.detail(student.getGradeId())); // 设置学生所在年级信息
return Result.ok(student); // 返回包含学生信息的Result对象
}
@GetMapping("/select_dormitory") // 映射GET请求到/select_dormitory路径
public Result select_dormitory(HttpServletRequest request) { // 定义select_dormitory方法，参数为HttpServletRequest对象
Student param = (Student)request.getAttribute("student"); // 从请求属性中获取学生信息
Student student = studentService.detail(param.getId()); // 根据学生ID获取学生详细信息
SelectionDormitory selectionDormitory = new SelectionDormitory(); // 创建SelectionDormitory对象
selectionDormitory.setClazzId(student.getClazzId()); // 设置班级ID
selectionDormitory.setLimit(1000); // 设置查询限制条数
PageInfo<SelectionDormitory> pageInfo = selectionDormitoryService.query(selectionDormitory); // 查询可选宿舍列表
List<Map<String,Object>> list = new ArrayList<>(); // 创建用于存储宿舍信息的列表
List<SelectionDormitory> selectionDormitorys = pageInfo.getList(); // 获取查询结果列表
for (SelectionDormitory sd : selectionDormitorys) { // 遍历查询结果列表
Map<String,Object> map = new HashMap<>(); // 创建用于存储单个宿舍信息的Map对象
//查询宿舍的基本信息
Dormitory dormitory = dormitoryService.detail(sd.getDormitoryId()); // 根据宿舍ID获取宿舍详细信息
map.put("capacity",dormitory.getCapacity()); // 设置宿舍容量
map.put("id",dormitory.getId()); // 设置宿舍ID
map.put("no",dormitory.getNo()); // 设置宿舍编号
map.put("sex",dormitory.getSex()); // 设置宿舍性别要求
map.put("buildingName",buildingService.detail(dormitory.getBuildingId()).getName()); // 设置宿舍所在建筑名称
//查询已选择的所有学生
DormitoryStudent ds = new DormitoryStudent(); // 创建DormitoryStudent对象
ds.setDormitoryId(sd.getDormitoryId()); // 设置宿舍ID
ds.setLimit(1000); // 设置查询限制条数
PageInfo<DormitoryStudent> pageInfo1 = dormitoryStudentService.query(ds); // 查询已选择的学生列表
map.put("selected",pageInfo1.getTotal()); // 设置已选择的学生数量
//构造已经选择的同学信息
List<Map<String,Object>> studentList = new ArrayList<>(); // 创建用于存储已选择学生信息的列表
List<DormitoryStudent> list1 = pageInfo1.getList(); // 获取已选择学生列表
for(DormitoryStudent ds1 : list1){ // 遍历已选择学生列表
Map<String,Object> studentMap = new HashMap<>(); // 创建用于存储单个学生信息的Map对象
Student detail = studentService.detail(ds1.getStudentId()); // 根据学生ID获取学生详细信息
studentMap.put("stuNo",detail.getStuNo()); // 设置学生学号
studentMap.put("name",detail.getName()); // 设置学生姓名
studentMap.put("bedId",ds1.getBedId()); // 设置学生床位ID
studentList.add(studentMap); // 将学生信息添加到列表中
}
map.put("studentList",studentList); // 将已选择学生信息列表添加到宿舍信息Map中
list.add(map); // 将宿舍信息添加到最终列表中
}
return Result.ok(list); // 返回包含宿舍信息的Result对象
}
@PostMapping("select_dormitory_submit") // 映射POST请求到/select_dormitory_submit路径
public Result select_dormitory(@RequestBody Map<String,String> map, HttpServletRequest request){ // 定义select_dormitory方法，参数为请求体中的Map和HttpServletRequest对象
Student param = (Student)request.getAttribute("student"); // 从请求属性中获取学生信息
Student student = studentService.detail(param.getId()); // 根据学生ID获取学生详细信息
List<Selection> selections = selectionService.queryByClazzId(student.getClazzId()); // 根据班级ID查询可选时间段列表
if(selections != null && selections.size()==0){ // 如果未设置或没有可选时间段
return Result.fail("操作失败，未设置！请联系管理员"); // 返回失败结果
}
Selection selection = selections.get(0); // 获取第一个可选时间段
if(selection.getStartTime().getTime() > System.currentTimeMillis() || System.currentTimeMillis() > selection.getEndTime().getTime()){ // 如果当前时间不在可选时间段内
return Result.fail("操作失败，不在时间段内选择"); // 返回失败结果
}
String bedId = map.get("bedId"); // 从请求体中获取床位ID
String dormitoryId = map.get("dormitoryId"); // 从请求体中获取宿舍ID
int row = dormitoryStudentService.select_dormitory_submit(student.getId(),Integer.parseInt(dormitoryId),Integer.parseInt(bedId)); // 根据学生ID、宿舍ID和床位ID提交选择宿舍请求
if(row > 0){ // 如果提交成功
return Result.ok(); // 返回成功结果
}else{
return Result.fail(); // 如果提交失败，返回失败结果
}
}
@PostMapping("repair_create") // 映射POST请求到/repair_create路径
public Result repair_create(@RequestBody Repair repair,HttpServletRequest request){ // 定义repair_create方法，参数为请求体中的Repair对象和HttpServletRequest对象
Student param = (Student)request.getAttribute("student"); // 从请求属性中获取学生信息
DormitoryStudent ds = new DormitoryStudent(); // 创建DormitoryStudent对象
ds.setStudentId(param.getId()); // 设置学生ID
PageInfo<DormitoryStudent> pageInfo = dormitoryStudentService.query(ds); // 查询学生关联的宿舍信息
PageInfo<Notice> noticePageInfo = null; // 初始化通知信息分页对象
if(pageInfo.getList() != null && pageInfo.getList().size() > 0){ // 如果存在关联的宿舍信息
DormitoryStudent dormitoryStudent = pageInfo.getList().get(0); // 获取第一个关联的宿舍信息
Dormitory detail = dormitoryService.detail(dormitoryStudent.getDormitoryId()); // 根据宿舍ID获取宿舍详细信息
repair.setBuildingId(detail.getBuildingId()); // 设置维修记录的建筑ID
repair.setDormitoryId(dormitoryStudent.getDormitoryId()); // 设置维修记录的宿舍ID
repair.setStudentId(param.getId()); // 设置维修记录的学生ID
repair.setCreateDate(new Date()); // 设置维修记录的创建日期
repair.setStatus(0); // 设置维修记录的状态为0（未完成）
int flag = repairService.create(repair); // 提交维修记录并获取操作结果标志
if(flag > 0){ // 如果提交成功
return Result.ok(); // 返回成功结果
}else{
return Result.fail(); // 如果提交失败，返回失败结果
}
}else{
return Result.fail("操作失败，没有关联的宿舍"); // 如果不存在关联的宿舍信息，返回失败结果
}
}
@PostMapping("notice_query") // 映射POST请求到/notice_query路径
public Map<String, Object> notice_query(@RequestBody Notice notice,HttpServletRequest request){ // 定义notice_query方法，参数为请求体中的Notice对象和HttpServletRequest对象
Student param = (Student)request.getAttribute("student"); // 从请求属性中获取学生信息
DormitoryStudent ds = new DormitoryStudent(); // 创建DormitoryStudent对象
ds.setStudentId(param.getId()); // 设置学生ID
PageInfo<DormitoryStudent> pageInfo = dormitoryStudentService.query(ds); // 查询学生关联的宿舍信息
PageInfo<Notice> noticePageInfo = null; // 初始化通知信息分页对象
if(pageInfo.getList() != null && pageInfo.getList().size() > 0){ // 如果存在关联的宿舍信息
DormitoryStudent dormitoryStudent = pageInfo.getList().get(0); // 获取第一个关联的宿舍信息
Dormitory detail = dormitoryService.detail(dormitoryStudent.getDormitoryId()); // 根据宿舍ID获取宿舍详细信息
notice.setBuildingId(detail.getBuildingId()); // 设置通知的建筑ID
noticePageInfo = noticeService.queryByBuildingId(notice); // 根据建筑ID查询通知列表
noticePageInfo.getList().forEach(entity->{ // 遍历通知列表
entity.setUser(userService.detail(entity.getUserId())); // 根据用户ID获取用户详细信息并设置到通知对象中
});
}else{
noticePageInfo = new PageInfo<>(null); // 如果不存在关联的宿舍信息，初始化空的通知分页对象
}
return Result.ok(noticePageInfo); // 返回包含通知信息的Result对象
}
}

128
zsq/Student.java
Unescape View File

@ -0,0 +1,128 @@
package com.yanzhen.entity;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
public class Student extends Entity{
private Integer id; // 学生ID
@Length(max = 50) // 学号，最大长度50
private String stuNo;
@Length(max = 50) // 姓名，最大长度50
private String name;
@Length(max = 50)// 身份证号，最大长度50
private String idcard;
private Integer gradeId;// 年级ID
private Integer sex;// 性别（1为男，2为女）
@Length(max = 50)// 电话号码，最大长度50
private String phone;
@Length(max = 50)// 密码，最大长度50
private String password;
private Integer clazzId;// 班级ID
private Org org;// 所属组织
private Grade grade;// 所属年级
public Integer getId() {
return id;// 获取学生ID
}
public void setId(Integer id) {// 设置学生ID
this.id = id;
}
public String getStuNo() {// 获取学号
return stuNo;
}
public void setStuNo(String stuNo) {// 设置学号
this.stuNo = stuNo;
}
public String getName() {// 获取姓名
return name;
}
public void setName(String name) {// 设置姓名
this.name = name;
}
public String getIdcard() {// 获取身份证号
return idcard;
}
public void setIdcard(String idcard) {// 设置身份证号
this.idcard = idcard;
}
public Integer getGradeId() {// 获取年级ID
return gradeId;
}
public void setGradeId(Integer gradeId) {// 设置年级ID
this.gradeId = gradeId;
}
public Integer getSex() {// 获取性别
return sex;
}
public void setSex(Integer sex) {// 设置性别
this.sex = sex;
}
public String getPhone() {// 获取电话号码
return phone;
}
public void setPhone(String phone) {// 设置电话号码
this.phone = phone;
}
public String getPassword() { // 获取密码
return password;
}
public void setPassword(String password) {// 设置密码
this.password = password;
}
public Integer getClazzId() {// 获取班级ID
return clazzId;
}
public void setClazzId(Integer clazzId) {// 设置班级ID
this.clazzId = clazzId;
}
public Org getOrg() {// 获取所属组织
return org;
}
public void setOrg(Org org) {// 设置所属组织
this.org = org;
}
public Grade getGrade() {// 获取所属年级
return grade;
}
public void setGrade(Grade grade) {// 设置所属年级
this.grade = grade;
}
}

77
zsq/StudentController.java
Unescape View File

@ -0,0 +1,77 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.Grade;
import com.yanzhen.entity.Org;
import com.yanzhen.entity.Student;
import com.yanzhen.service.GradeService年级管理;
import com.yanzhen.service.OrgService机构管理;
import com.yanzhen.service.StudentService学生管理;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。
@RequestMapping("/student") // 设置请求的根路径为 "/student"，所有方法的请求路径都会以这个为基础。
public class StudentController { // 定义一个名为 StudentController 的类，用于处理学生相关的请求。
@Autowired // 自动注入 StudentService 对象，用于处理学生数据的业务逻辑。
private StudentService学生管理 studentService;
@Autowired // 自动注入 GradeService 对象，用于处理年级数据的业务逻辑。
private GradeService年级管理 gradeService;
@Autowired // 自动注入 OrgService 对象，用于处理班级数据的业务逻辑。
private OrgService机构管理 orgService;
@PostMapping("create") // 映射 HTTP POST 请求到 create 方法，用于创建新的学生记录。
public Result create(@RequestBody Student student){ // 接收一个 JSON 格式的学生对象作为请求体。
int flag = studentService.create(student); // 调用 studentService 的 create 方法保存学生信息，并返回操作结果标志。
if(flag>0){ // 如果操作成功（flag > 0）。
return Result.ok(); // 返回成功的 Result 对象。
}else{ // 如果操作失败（flag <= 0）。
return Result.fail(); // 返回失败的 Result 对象。
}
}
@GetMapping("delete") // 映射 HTTP GET 请求到 delete 方法，用于删除学生记录。
public Result delete(String ids){ // 接收要删除的学生 ID 列表作为请求参数。
int flag = studentService.delete(ids); // 调用 studentService 的 delete 方法删除指定的学生记录，并返回操作结果标志。
if(flag>0){ // 如果操作成功（flag > 0）。
return Result.ok(); // 返回成功的 Result 对象。
}else{ // 如果操作失败（flag <= 0）。
return Result.fail(); // 返回失败的 Result 对象。
}
}
@PostMapping("update") // 映射 HTTP POST 请求到 update 方法，用于更新学生记录。
public Result update(@RequestBody Student student){ // 接收一个 JSON 格式的学生对象作为请求体。
int flag = studentService.updateSelective(student); // 调用 studentService 的 updateSelective 方法更新学生信息，并返回操作结果标志。
if(flag>0){ // 如果操作成功（flag > 0）。
return Result.ok(); // 返回成功的 Result 对象。
}else{ // 如果操作失败（flag <= 0）。
return Result.fail(); // 返回失败的 Result 对象。
}
}
@GetMapping("detail") // 映射 HTTP GET 请求到 detail 方法，用于获取单个学生的详细信息。
public Student detail(Integer id){ // 接收学生 ID 作为请求参数。
return studentService.detail(id); // 调用 studentService 的 detail 方法获取指定 ID 的学生信息，并返回该学生对象。
}
@PostMapping("query") // 映射 HTTP POST 请求到 query 方法，用于查询学生列表。
public Map<String,Object> query(@RequestBody Student student){ // 接收一个 JSON 格式的学生对象作为请求体，用于查询条件。
PageInfo<Student> pageInfo = studentService.query(student); // 调用 studentService 的 query 方法查询符合条件的学生列表，并返回分页信息。
pageInfo.getList().forEach(entity->{ // 遍历查询结果中的每个学生对象。
Grade grade = gradeService.detail(entity.getGradeId()); // 根据学生对象的年级 ID 获取对应的年级信息。
entity.setGrade(grade); // 将年级信息设置到学生对象中。
Org org = orgService.detail(entity.getClazzId()); // 根据学生对象的班级 ID 获取对应的班级信息。
entity.setOrg(org); // 将班级信息设置到学生对象中。
});
return Result.ok(pageInfo); // 返回包含分页信息的成功的 Result 对象。
}
}

26
zsq/StudentMapper.java
Unescape View File

@ -0,0 +1,26 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构
import com.yanzhen.entity.Student; // 导入Student实体类，用于操作学生信息
public interface StudentMapper { // 定义一个名为StudentMapper的公共接口
public int create(Student student); // 定义一个创建学生记录的方法，返回值为int类型，参数为Student对象
public int delete(Integer id); // 定义一个删除学生记录的方法，返回值为int类型，参数为学生的ID
public int update(Student student); // 定义一个更新学生记录的方法，返回值为int类型，参数为Student对象
public int updateSelective(Student student); // 定义一个选择性更新学生记录的方法，返回值为int类型，参数为Student对象
public List<Student> query(Student student); // 定义一个查询学生记录的方法，返回值为List<Student>类型，参数为Student对象
public Student detail(Integer id); // 定义一个获取学生详细信息的方法，返回值为Student对象，参数为学生的ID
public Student detailByName(String name); // 定义一个通过名字获取学生详细信息的方法，返回值为Student对象，参数为学生的名字
public int count(Student student); // 定义一个统计学生数量的方法，返回值为int类型，参数为Student对象
public Student login(String userName,String password); // 定义一个登录方法，返回值为Student对象，参数为用户名称和密码
}

67
zsq/StudentService学生管理.java
Unescape View File

@ -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方法进行登录验证
}
}

53
zsq/TokenInterceptor.java
Unescape View File

@ -0,0 +1,53 @@
package com.yanzhen.framework.mvc; // 定义包名
import com.yanzhen.entity.Student; // 导入Student类
import com.yanzhen.entity.User; // 导入User类
import com.yanzhen.framework.exception.MyException; // 导入自定义异常类MyException
import com.yanzhen.framework.jwt.JWTUtil; // 导入JWT工具类JWTUtil
import org.springframework.web.servlet.HandlerInterceptor; // 导入Spring MVC的HandlerInterceptor接口
import org.springframework.web.servlet.ModelAndView; // 导入Spring MVC的ModelAndView类
import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest类
import javax.servlet.http.HttpServletResponse; // 导入HttpServletResponse类
public class TokenInterceptor implements HandlerInterceptor { // 定义TokenInterceptor类并实现HandlerInterceptor接口
@Override // 重写preHandle方法，在请求处理之前进行调用
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String token = request.getHeader(JWTUtil.token); // 从请求头中获取token
String type = JWTUtil.getType(token); // 根据token获取类型
if("USER".equals(type)){ // 如果类型是USER
//根据token获取user对象
User user = JWTUtil.getUser(token); // 通过JWT工具类获取User对象
if(user == null){ // 如果User对象为空
throw new MyException("超时或不合法的token"); // 抛出自定义异常
}
String newToken = JWTUtil.sign(user); // 重新生成新的token
response.setHeader(JWTUtil.token,newToken); // 将新token设置到响应头中
response.setHeader("Access-Control-Expose-Headers", JWTUtil.token); // 设置允许暴露的响应头
request.setAttribute("user",user); // 将User对象设置到请求属性中
}else if("STUDENT".equals(type)){ // 如果类型是STUDENT
//根据token获取user对象
Student student = JWTUtil.getStudent(token); // 通过JWT工具类获取Student对象
if(student == null){ // 如果Student对象为空
throw new MyException("超时或不合法的token"); // 抛出自定义异常
}
String newToken = JWTUtil.signForStudent(student); // 重新生成新的token
response.setHeader(JWTUtil.token,newToken); // 将新token设置到响应头中
response.setHeader("Access-Control-Expose-Headers", JWTUtil.token); // 设置允许暴露的响应头
request.setAttribute("student",student); // 将Student对象设置到请求属性中
}
return true; // 返回true表示继续执行后续的拦截器和处理器
}
@Override // 重写postHandle方法，在请求处理之后但在视图渲染之前进行调用
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
}
@Override // 重写afterCompletion方法，在整个请求结束之后进行调用
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
}
}

89
zsq/User.java
Unescape View File

@ -0,0 +1,89 @@
package com.yanzhen.entity;
import javax.validation.constraints.NotNull;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
import java.util.List;
public class User extends Entity{ // 定义一个User类，继承自Entity类
private Integer id; // 用户的唯一标识符
@Length(max = 100) // 用户名的最大长度限制为100个字符
private String userName; // 用户的用户名
@Length(max = 100) // 密码的最大长度限制为100个字符
private String password; // 用户的密码
@Length(max = 100) // 姓名的最大长度限制为100个字符
private String name; // 用户的姓名
@Length(max = 100) // 电话号码的最大长度限制为100个字符
private String phone; // 用户的电话号码
private Integer type; // 用户的类型，0表示管理员，1表示宿管员
@Length(max = 200) // 备注信息的最大长度限制为200个字符
private String remark; // 用户的备注信息
private List<Integer> ids; // 存储多个ID的列表
public Integer getId() { // 获取用户ID的方法
return id;
}
public void setId(Integer id) { // 设置用户ID的方法
this.id = id;
}
public String getUserName() { // 获取用户名的方法
return userName;
}
public void setUserName(String userName) { // 设置用户名的方法
this.userName = userName;
}
@JsonIgnore // 在序列化时忽略此属性
public String getPassword() { // 获取用户密码的方法
return password;
}
@JsonProperty // 在序列化时包含此属性
public void setPassword(String password) { // 设置用户密码的方法
this.password = password;
}
public String getName() { // 获取用户姓名的方法
return name;
}
public void setName(String name) { // 设置用户姓名的方法
this.name = name;
}
public String getPhone() { // 获取用户电话号码的方法
return phone;
}
public void setPhone(String phone) { // 设置用户电话号码的方法
this.phone = phone;
}
public Integer getType() { // 获取用户类型的方法
return type;
}
public void setType(Integer type) { // 设置用户类型的方法
this.type = type;
}
public String getRemark() { // 获取用户备注信息的方法
return remark;
}
public void setRemark(String remark) { // 设置用户备注信息的方法
this.remark = remark;
}
public List<Integer> getIds() { // 获取ID列表的方法
return ids;
}
public void setIds(List<Integer> ids) { // 设置ID列表的方法
this.ids = ids;
}
}

107
zsq/UserController.java
Unescape View File

@ -0,0 +1,107 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.Student;
import com.yanzhen.entity.User;
import com.yanzhen.service.StudentService学生管理;
import com.yanzhen.service.UserService用户管理;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.Map;
@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。
@RequestMapping("/user") // 设置请求的基础路径为 "/user"，所有方法的请求路径都会以 "/user" 开头。
public class UserController {
@Autowired // 自动注入 UserService 对象，用于处理用户相关的业务逻辑。
private UserService用户管理 userService;
@Autowired // 自动注入 StudentService 对象，用于处理学生相关的业务逻辑。
private StudentService学生管理 studentService;
@PostMapping("create") // 映射 HTTP POST 请求到 "create" 方法，用于创建新用户。
public Result create(@RequestBody User user){ // 从请求体中获取 User 对象。
int flag = userService.create(user); // 调用 userService 的 create 方法创建用户，并返回操作结果标志。
if(flag>0){ // 如果创建成功（flag > 0）。
return Result.ok(); // 返回成功的 Result 对象。
}else{ // 如果创建失败（flag <= 0）。
return Result.fail(); // 返回失败的 Result 对象。
}
}
@GetMapping("delete") // 映射 HTTP GET 请求到 "delete" 方法，用于删除用户。
public Result delete(String ids){ // 从请求参数中获取要删除的用户 ID 字符串。
int flag = userService.delete(ids); // 调用 userService 的 delete 方法删除用户，并返回操作结果标志。
if(flag>0){ // 如果删除成功（flag > 0）。
return Result.ok(); // 返回成功的 Result 对象。
}else{ // 如果删除失败（flag <= 0）。
return Result.fail(); // 返回失败的 Result 对象。
}
}
@PostMapping("update") // 映射 HTTP POST 请求到 "update" 方法，用于更新用户信息。
public Result update(@RequestBody User user){ // 从请求体中获取 User 对象。
int flag = userService.updateSelective(user); // 调用 userService 的 updateSelective 方法更新用户信息，并返回操作结果标志。
if(flag>0){ // 如果更新成功（flag > 0）。
return Result.ok(); // 返回成功的 Result 对象。
}else{ // 如果更新失败（flag <= 0）。
return Result.fail(); // 返回失败的 Result 对象。
}
}
@GetMapping("detail") // 映射 HTTP GET 请求到 "detail" 方法，用于获取用户详细信息。
public User detail(Integer id){ // 从请求参数中获取用户 ID。
return userService.detail(id); // 调用 userService 的 detail 方法获取用户详细信息，并返回该用户对象。
}
@GetMapping("info") // 映射 HTTP GET 请求到 "info" 方法，用于获取当前登录用户的详细信息。
public Result info(HttpServletRequest request){ // 从请求中获取当前用户信息。
User user = (User)request.getAttribute("user"); // 从请求属性中获取当前用户对象。
return Result.ok(userService.detail(user.getId())); // 调用 userService 的 detail 方法获取用户详细信息，并返回成功的 Result 对象。
}
@PostMapping("pwd") // 映射 HTTP POST 请求到 "pwd" 方法，用于修改用户密码。
public Result pwd(@RequestBody Map<String,String> map,HttpServletRequest request){ // 从请求体中获取包含原密码和新密码的 Map，并从请求中获取当前用户或学生信息。
String spassword = map.get("spassword"); // 获取原密码。
String npassword = map.get("npassword"); // 获取新密码。
//用户修改
if(request.getAttribute("user") != null){ // 如果当前用户是普通用户。
User user = (User)request.getAttribute("user"); // 从请求属性中获取当前用户对象。
User entity = userService.detail(user.getId()); // 调用 userService 的 detail 方法获取用户详细信息。
if(entity.getPassword().equals(spassword)){ // 如果原密码正确。
User param = new User(); // 创建新的 User 对象用于更新密码。
param.setId(entity.getId()); // 设置用户 ID。
param.setPassword(npassword); // 设置新密码。
userService.updatePwd(param); // 调用 userService 的 updatePwd 方法更新密码。
return Result.ok("修改密码成功"); // 返回成功的 Result 对象。
}else{ // 如果原密码错误。
return Result.fail("原密码错误"); // 返回失败的 Result 对象。
}
}
//学生修改
if(request.getAttribute("student") != null){ // 如果当前用户是学生。
Student student = (Student)request.getAttribute("student"); // 从请求属性中获取当前学生对象。
Student entity = studentService.detail(student.getId()); // 调用 studentService 的 detail 方法获取学生详细信息。
if(entity.getPassword().equals(spassword)){ // 如果原密码正确。
Student param = new Student(); // 创建新的 Student 对象用于更新密码。
param.setId(entity.getId()); // 设置学生 ID。
param.setPassword(npassword); // 设置新密码。
studentService.updateSelective(param); // 调用 studentService 的 updateSelective 方法更新密码。
return Result.ok("修改密码成功"); // 返回成功的 Result 对象。
}else{ // 如果原密码错误。
return Result.fail("原密码错误"); // 返回失败的 Result 对象。
}
}
return Result.ok(); // 如果既不是普通用户也不是学生，返回成功的 Result 对象。
}
@PostMapping("query") // 映射 HTTP POST 请求到 "query" 方法，用于查询用户列表。
public Map<String,Object> query(@RequestBody User user){ // 从请求体中获取 User 对象作为查询条件。
PageInfo<User> pageInfo = userService.query(user); // 调用 userService 的 query 方法进行分页查询，并返回分页信息。
return Result.ok(pageInfo); // 返回包含分页信息的成功的 Result 对象。
}
}

26
zsq/UserMapper.java
Unescape View File

@ -0,0 +1,26 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java的List类，用于处理列表数据结构
import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构
import com.yanzhen.entity.User; // 导入User实体类，用于操作用户数据
import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解，用于传递参数到SQL语句中
public interface UserMapper { // 定义UserMapper接口，作为MyBatis的Mapper接口
public int create(User user); // 定义create方法，用于创建新用户，返回影响的行数
public int delete(Integer id); // 定义delete方法，根据用户ID删除用户，返回影响的行数
public int update(User user); // 定义update方法，更新用户信息，返回影响的行数
public int updateSelective(User user); // 定义updateSelective方法，选择性更新用户信息，返回影响的行数
public List<User> query(User user); // 定义query方法，根据条件查询用户列表，返回用户列表
public User detail(Integer id); // 定义detail方法，根据用户ID查询用户详情，返回用户对象
public User login(@Param("userName") String userName, @Param("password") String password); // 定义login方法，根据用户名和密码查询用户，返回用户对象
public int count(User user); // 定义count方法，统计符合条件的用户数量，返回用户数量
}

96
zsq/UserService用户管理.java
Unescape View File

@ -0,0 +1,96 @@
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) {// 目的：根据多个ID删除对应的用户记录，并清除中间表中的关联关系
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) {// 目的：该函数 updatePwd 的主要作用是通过调用 userMapper 对象的 updateSelective 方法来更新用户密码。
return userMapper.updateSelective(user); // 更新用户密码并返回受影响的行数
}
public int updateSelective(User user) {// 目的：该函数通过调用多个数据访问对象（DAO）的方法，实现了对用户信息的选择性更新以及用户-菜单关系的更新。
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){//实现了一个简单的用户登录功能，通过调用数据访问层的 login 方法，根据用户名和密码查询用户信息并返回。
return userMapper.login(userName,password); // 根据用户名和密码查询用户信息并返回
}
public User detail(Integer id) {// 目的：该函数的主要作用是通过调用 userMapper 对象的 detail 方法，根据用户ID查询用户的详细信息。
return userMapper.detail(id); // 根据用户ID查询用户详情并返回
}
public int count(User user) {// 目的：定义了一个名为 count 的方法，用于统计符合特定条件的用户数量。
return userMapper.count(user); // 统计符合条件的用户数量并返回
}
}

128
zsq/Visit.java
Unescape View File

@ -0,0 +1,128 @@
package com.yanzhen.entity;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.Length;
import com.yanzhen.utils.Entity;
import java.util.Date;
public class Visit extends Entity{// 定义一个名为Visit的类，继承自Entity类
private Integer id;// 定义一个私有的Integer类型的变量id
@Length(max = 100)// 定义一个私有的String类型的变量visitor，并设置其最大长度为100
private String visitor;
@Length(max = 100)// 定义一个私有的String类型的变量phone，并设置其最大长度为100
private String phone;
private Integer sex; // 定义一个私有的Integer类型的变量sex
@Length(max = 100) // 定义一个私有的String类型的变量idcard，并设置其最大长度为100
private String idcard;
private Integer studentId; // 定义一个私有的Integer类型的变量studentId
private Date visitTime; // 定义一个私有的Date类型的变量visitTime
private Date leaveTime;// 定义一个私有的Date类型的变量leaveTime
@Length(max = 200) // 定义一个私有的String类型的变量remark，并设置其最大长度为200
private String remark;
private Student student;// 定义一个私有的Student类型的变量student
public Integer getId() {// 定义一个公共方法getId，用于获取id的值
return id;
}
public void setId(Integer id) {// 定义一个公共方法setId，用于设置id的值
this.id = id;
}
public String getVisitor() {// 定义一个公共方法getVisitor，用于获取visitor的值
return visitor;
}
public void setVisitor(String visitor) {// 定义一个公共方法setVisitor，用于设置visitor的值
this.visitor = visitor;
}
public String getPhone() {// 定义一个公共方法getPhone，用于获取phone的值
return phone;
}
public void setPhone(String phone) {// 定义一个公共方法setPhone，用于设置phone的值
this.phone = phone;
}
public Integer getSex() {// 定义一个公共方法getSex，用于获取sex的值
return sex;
}
public void setSex(Integer sex) {// 定义一个公共方法setSex，用于设置sex的值
this.sex = sex;
}
public String getIdcard() {// 定义一个公共方法getIdcard，用于获取idcard的值
return idcard;
}
public void setIdcard(String idcard) {// 定义一个公共方法setIdcard，用于设置idcard的值
this.idcard = idcard;
}
public Integer getStudentId() {// 定义一个公共方法getStudentId，用于获取studentId的值
return studentId;
}
public void setStudentId(Integer studentId) {// 定义一个公共方法setStudentId，用于设置studentId的值
this.studentId = studentId;
}
public Date getVisitTime() {// 定义一个公共方法getVisitTime，用于获取visitTime的值
return visitTime;
}
public void setVisitTime(Date visitTime) {// 定义一个公共方法setVisitTime，用于设置visitTime的值
this.visitTime = visitTime;
}
public Date getLeaveTime() {// 定义一个公共方法getLeaveTime，用于获取leaveTime的值
return leaveTime;
}
public void setLeaveTime(Date leaveTime) {// 定义一个公共方法setLeaveTime，用于设置leaveTime的值
this.leaveTime = leaveTime;
}
public String getRemark() {// 定义一个公共方法getRemark，用于获取remark的值
return remark;
}
public void setRemark(String remark) {// 定义一个公共方法setRemark，用于设置remark的值
this.remark = remark;
}
public Student getStudent() {// 定义一个公共方法getStudent，用于获取student的值
return student;
}
public void setStudent(Student student) {// 定义一个公共方法setStudent，用于设置student的值
this.student = student;
}
}

68
zsq/VisitController.java
Unescape View File

@ -0,0 +1,68 @@
package com.yanzhen.controller;
import com.github.pagehelper.PageInfo;
import com.yanzhen.entity.Student;
import com.yanzhen.entity.Visit;
import com.yanzhen.service.StudentService学生管理;
import com.yanzhen.service.VisitService来访管理;
import com.yanzhen.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。
@RequestMapping("/visit") // 设置请求的根路径为 "/visit"，所有方法的请求路径都会以 "/visit" 开头。
public class VisitController { // 定义一个名为 VisitController 的类，用于处理与访问相关的请求。
@Autowired // 自动注入 VisitService 对象，用于处理访问数据的业务逻辑。
private VisitService来访管理 visitService;
@Autowired // 自动注入 StudentService 对象，用于处理学生数据的业务逻辑。
private StudentService学生管理 studentService;
@PostMapping("create") // 映射 HTTP POST 请求到 create 方法，用于创建新的访问记录。
public Result create(@RequestBody Visit visit){ // 从请求体中获取 Visit 对象。
int flag = visitService.create(visit); // 调用 VisitService 的 create 方法保存访问记录，并返回操作结果标志。
if(flag>0){ // 如果操作成功（flag > 0）。
return Result.ok(); // 返回成功的 Result 对象。
}else{ // 如果操作失败（flag <= 0）。
return Result.fail(); // 返回失败的 Result 对象。
}
}
@GetMapping("delete") // 映射 HTTP GET 请求到 delete 方法，用于删除访问记录。
public Result delete(String ids){ // 从请求参数中获取要删除的记录的 ID 字符串。
int flag = visitService.delete(ids); // 调用 VisitService 的 delete 方法删除指定 ID 的记录，并返回操作结果标志。
if(flag>0){ // 如果操作成功（flag > 0）。
return Result.ok(); // 返回成功的 Result 对象。
}else{ // 如果操作失败（flag <= 0）。
return Result.fail(); // 返回失败的 Result 对象。
}
}
@PostMapping("update") // 映射 HTTP POST 请求到 update 方法，用于更新访问记录。
public Result update(@RequestBody Visit visit){ // 从请求体中获取 Visit 对象。
int flag = visitService.updateSelective(visit); // 调用 VisitService 的 updateSelective 方法更新访问记录，并返回操作结果标志。
if(flag>0){ // 如果操作成功（flag > 0）。
return Result.ok(); // 返回成功的 Result 对象。
}else{ // 如果操作失败（flag <= 0）。
return Result.fail(); // 返回失败的 Result 对象。
}
}
@GetMapping("detail") // 映射 HTTP GET 请求到 detail 方法，用于获取访问记录的详细信息。
public Visit detail(Integer id){ // 从请求参数中获取访问记录的 ID。
return visitService.detail(id); // 调用 VisitService 的 detail 方法获取指定 ID 的访问记录，并返回该记录。
}
@PostMapping("query") // 映射 HTTP POST 请求到 query 方法，用于查询访问记录。
public Map<String,Object> query(@RequestBody Visit visit){ // 从请求体中获取 Visit 对象作为查询条件。
PageInfo<Visit> pageInfo = visitService.query(visit); // 调用 VisitService 的 query 方法查询符合条件的访问记录，并返回分页信息。
pageInfo.getList().forEach(entity->{ // 遍历查询结果中的每条记录。
Student detail = studentService.detail(entity.getStudentId()); // 根据学生 ID 获取学生的详细信息。
entity.setStudent(detail); // 将学生详细信息设置到访问记录中。
});
return Result.ok(pageInfo); // 返回包含分页信息的成功的 Result 对象。
}
}

24
zsq/VisitMapper.java
Unescape View File

@ -0,0 +1,24 @@
package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包
import java.util.List; // 导入Java标准库中的List类
import java.util.Map; // 导入Java标准库中的Map类
import com.yanzhen.entity.Visit; // 导入自定义的Visit实体类
public interface VisitMapper { // 定义一个名为VisitMapper的公共接口
public int create(Visit visit); // 定义一个创建访问记录的方法，返回值为int类型
public int delete(Integer id); // 定义一个删除访问记录的方法，参数为访问记录的ID，返回值为int类型
public int update(Visit visit); // 定义一个更新访问记录的方法，参数为Visit对象，返回值为int类型
public int updateSelective(Visit visit); // 定义一个选择性更新访问记录的方法，参数为Visit对象，返回值为int类型
public List<Visit> query(Visit visit); // 定义一个查询访问记录的方法，参数为Visit对象，返回值为Visit对象的列表
public Visit detail(Integer id); // 定义一个获取访问记录详情的方法，参数为访问记录的ID，返回值为Visit对象
public int count(Visit visit); // 定义一个统计访问记录数量的方法，参数为Visit对象，返回值为int类型
}

59
zsq/VisitService来访管理.java
Unescape View File

@ -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方法
}
}
Write Preview
Loading…
Cancel
Save