注释

src/com/itheima/service/AdminService.java

@@ -0,0 +1,65 @@
+package com.itheima.service;  // 定义该接口所属的包为 com.itheima.service
+
+import com.itheima.po.Admin;  // 导入 Admin 类，表示管理员对象
+import com.itheima.po.PageInfo;  // 导入 PageInfo 类，用于分页信息封装
+
+import java.util.List;  // 导入 List 类，用于存储多个 Admin 对象
+
+/**
+ * 用户Service层接口
+ * 本接口提供了管理员相关的业务逻辑处理方法
+ */
+public interface AdminService {
+
+    /**
+     * 通过账号和密码查询用户
+     * @param admin 包含账号和密码的 Admin 对象
+     * @return 如果找到匹配的管理员，则返回该 Admin 对象，否则返回 null
+     */
+    public Admin findAdmin(Admin admin);
+
+    /**
+     * 查找所有管理员信息
+     * @return 返回所有管理员的列表
+     */
+    public List<Admin> getAll();
+
+    /**
+     * 分页查询管理员信息
+     * @param a_username 根据用户名进行模糊查询
+     * @param a_describe 根据描述进行模糊查询
+     * @param a_id 根据管理员 ID 进行查询
+     * @param pageIndex 当前页码，表示查询第几页
+     * @param pageSize 每页显示的记录数
+     * @return 返回分页查询后的 PageInfo 对象，包含当前页数据以及分页信息
+     */
+    public PageInfo<Admin> findPageInfo(String a_username, String a_describe, Integer a_id, Integer pageIndex, Integer pageSize);
+
+    /**
+     * 添加管理员信息
+     * @param admin 要添加的 Admin 对象
+     * @return 返回影响的行数，通常是 1（成功）或 0（失败）
+     */
+    public int addAdmin(Admin admin);
+
+    /**
+     * 删除管理员信息
+     * @param a_id 要删除的管理员 ID
+     * @return 返回影响的行数，通常是 1（成功）或 0（失败）
+     */
+    public int deleteAdmin(Integer a_id);
+
+    /**
+     * 更新管理员信息
+     * @param admin 包含新管理员信息的 Admin 对象
+     * @return 返回影响的行数，通常是 1（成功）或 0（失败）
+     */
+    public int updateAdmin(Admin admin);
+
+    /**
+     * 通过管理员 ID 查找管理员信息
+     * @param a_id 管理员的 ID
+     * @return 返回对应的 Admin 对象，如果找不到则返回 null
+     */
+    public Admin findAdminById(Integer a_id);
+}

src/com/itheima/service/ClassService.java

@@ -0,0 +1,65 @@
+package com.itheima.service;  // 定义该接口所属的包为 com.itheima.service
+
+import com.itheima.po.Class;  // 导入 Class 类，表示班级对象
+import com.itheima.po.PageInfo;  // 导入 PageInfo 类，用于封装分页信息
+
+import java.util.List;  // 导入 List 类，用于存储多个 Class 对象
+
+/**
+ * 班级Service层接口
+ * 本接口提供了与班级相关的业务逻辑处理方法
+ */
+public interface ClassService {
+
+    /**
+     * 分页查询班级信息
+     * @param c_classname 班级名称，模糊查询条件
+     * @param c_counsellor 班主任，模糊查询条件
+     * @param c_classid 班级ID，查询条件
+     * @param pageIndex 当前页码，用于分页查询
+     * @param pageSize 每页显示的记录数
+     * @return 返回封装了分页信息的 PageInfo 对象，包含查询的班级数据及分页信息
+     */
+    public PageInfo<Class> findPageInfo(String c_classname, String c_counsellor, Integer c_classid, Integer pageIndex, Integer pageSize);
+
+    /**
+     * 删除班级信息
+     * @param c_id 要删除的班级ID
+     * @return 返回影响的行数，1表示成功删除，0表示删除失败
+     */
+    public int deleteClass(Integer c_id);
+
+    /**
+     * 添加班级信息
+     * @param uclass 要添加的班级对象
+     * @return 返回影响的行数，通常是 1 表示成功，0 表示失败
+     */
+    public int addClass(Class uclass);
+
+    /**
+     * 根据班级ID查找班级信息
+     * @param c_id 班级的ID
+     * @return 返回找到的班级对象，如果没有找到则返回 null
+     */
+    public Class findClassById(Integer c_id);
+
+    /**
+     * 修改班级信息
+     * @param uclass 要更新的班级对象
+     * @return 返回影响的行数，通常是 1 表示成功，0 表示失败
+     */
+    public int updateClass(Class uclass);
+
+    /**
+     * 查询班级中的所有学生信息
+     * @param uclass 要查询的班级对象，通常包含班级ID等信息
+     * @return 返回该班级的所有学生信息列表
+     */
+    public List<Class> findClassStudent(Class uclass);
+
+    /**
+     * 获取所有班级信息
+     * @return 返回所有班级的列表
+     */
+    public List<Class> getAll();
+}

src/com/itheima/service/DormCleanService.java

@@ -0,0 +1,59 @@
+package com.itheima.service;  // 定义该接口所属的包路径为 com.itheima.service
+
+import com.itheima.po.DormClean;  // 导入 DormClean 类，表示宿舍卫生的实体类
+import com.itheima.po.PageInfo;  // 导入 PageInfo 类，用于封装分页信息
+
+import java.util.List;  // 导入 List 类，用于存储多个 DormClean 对象
+
+/**
+ * @program: dormitorySystem  // 程序名称：宿舍管理系统
+ * @description: 宿舍卫生服务接口  // 本接口定义了宿舍卫生相关的服务方法
+ * @author: Joyrocky  // 作者：Joyrocky
+ * @create: 2019-04-24 15:18  // 创建时间：2019年4月24日，15:18
+ **/
+public interface DormCleanService {
+
+    /**
+     * 分页查询宿舍卫生信息
+     * @param d_id 宿舍ID，查询条件
+     * @param d_dormbuilding 宿舍楼名，查询条件
+     * @param pageIndex 当前页码
+     * @param pageSize 每页显示的记录数
+     * @return 返回封装了分页信息的 PageInfo 对象，包含查询结果和分页信息
+     */
+    public PageInfo<DormClean> findPageInfo(Integer d_id, String d_dormbuilding, Integer pageIndex, Integer pageSize);
+
+    /**
+     * 添加宿舍卫生信息
+     * @param dormclean 要添加的宿舍卫生对象
+     * @return 返回影响的行数，通常 1 表示添加成功，0 表示添加失败
+     */
+    public int addDormClean(DormClean dormclean);  // 添加宿舍卫生信息
+
+    /**
+     * 删除宿舍卫生信息
+     * @param g_id 要删除的宿舍卫生记录ID
+     * @return 返回影响的行数，通常 1 表示删除成功，0 表示删除失败
+     */
+    public int deleteDormClean(Integer g_id);  // 删除宿舍卫生信息
+
+    /**
+     * 修改宿舍卫生信息
+     * @param dormclean 要更新的宿舍卫生对象
+     * @return 返回影响的行数，通常 1 表示更新成功，0 表示更新失败
+     */
+    public int updateDormClean(DormClean dormclean);  // 修改宿舍卫生信息
+
+    /**
+     * 根据宿舍卫生ID查询单条记录
+     * @param g_id 宿舍卫生记录的ID
+     * @return 返回一个 DormClean 对象，表示查询到的宿舍卫生信息
+     */
+    public DormClean findDormCleanById(Integer g_id);  // 根据ID查询单条宿舍卫生信息
+
+    /**
+     * 获取所有宿舍卫生记录
+     * @return 返回一个 List<DormClean>，包含所有宿舍卫生记录
+     */
+    public List<DormClean> getAll();  // 获取所有宿舍卫生记录
+}

src/com/itheima/service/DormRepairService.java

@@ -0,0 +1,59 @@
+package com.itheima.service;  // 定义接口所属的包路径：com.itheima.service
+
+import com.itheima.po.DormRepair;  // 导入 DormRepair 类，表示宿舍维修登记实体类
+import com.itheima.po.PageInfo;  // 导入 PageInfo 类，用于分页信息封装
+
+import java.util.List;  // 导入 List 类，用于存储多个 DormRepair 对象
+
+/**
+ * @program: dormitorySystem  // 程序名称：dormitorySystem
+ * @description: 维修登记  // 该接口用于处理宿舍维修登记相关业务
+ * @author: Joyrocky  // 作者信息：Joyrocky
+ * @create: 2019-04-28 00:25  // 创建日期：2019-04-28
+ **/
+public interface DormRepairService {
+
+    /**
+     * 分页查询宿舍维修登记信息
+     * @param d_id 宿舍ID（可选查询条件）
+     * @param d_dormbuilding 宿舍楼名称（可选查询条件）
+     * @param pageIndex 当前页码
+     * @param pageSize 每页显示的记录数
+     * @return 返回一个 PageInfo<DormRepair> 对象，封装了分页信息和查询结果
+     */
+    public PageInfo<DormRepair> findPageInfo(Integer d_id, String d_dormbuilding, Integer pageIndex, Integer pageSize);
+
+    /**
+     * 添加宿舍维修登记信息
+     * @param dormrepair 要添加的宿舍维修信息对象
+     * @return 返回影响的行数，通常 1 表示添加成功，0 表示添加失败
+     */
+    public int addDormRepair(DormRepair dormrepair);  // 添加宿舍维修信息
+
+    /**
+     * 删除宿舍维修登记信息
+     * @param r_id 维修登记的ID
+     * @return 返回影响的行数，通常 1 表示删除成功，0 表示删除失败
+     */
+    public int deleteDormRepair(Integer r_id);  // 删除宿舍维修登记信息
+
+    /**
+     * 修改宿舍维修登记信息
+     * @param dormrepair 要更新的宿舍维修信息对象
+     * @return 返回影响的行数，通常 1 表示更新成功，0 表示更新失败
+     */
+    public int updateDormRepair(DormRepair dormrepair);  // 修改宿舍维修信息
+
+    /**
+     * 根据维修登记ID查询单条宿舍维修登记信息
+     * @param r_id 维修登记的ID
+     * @return 返回查询到的宿舍维修信息对象，如果没有找到，返回 null
+     */
+    public DormRepair findDormRepairById(Integer r_id);  // 根据维修登记ID查询单条宿舍维修信息
+
+    /**
+     * 获取所有宿舍维修登记信息
+     * @return 返回一个 List<DormRepair>，包含所有宿舍维修登记记录
+     */
+    public List<DormRepair> getAll();  // 获取所有宿舍维修登记信息
+}

src/com/itheima/service/DormitoryService.java

@@ -0,0 +1,64 @@
+package com.itheima.service;  // 定义接口所属的包路径：com.itheima.service
+
+import com.itheima.po.Dormitory;  // 导入 Dormitory 类，表示宿舍实体类
+import com.itheima.po.PageInfo;  // 导入 PageInfo 类，用于分页信息封装
+
+import java.util.List;  // 导入 List 类，用于存储多个 Dormitory 对象
+
+/**
+ * 用户Service层接口  // 该接口定义了宿舍管理服务层的各种业务操作
+ */
+public interface DormitoryService {
+
+    /**
+     * 分页查询宿舍信息
+     * @param a_name 宿舍管理员的姓名（可选的查询条件）
+     * @param s_dormitoryid 宿舍ID（可选的查询条件）
+     * @param d_dormbuilding 宿舍楼名称（可选的查询条件）
+     * @param pageIndex 当前页码
+     * @param pageSize 每页显示的记录数
+     * @return 返回一个 PageInfo<Dormitory> 对象，封装了分页信息和查询结果
+     */
+    public PageInfo<Dormitory> findPageInfo(String a_name, Integer s_dormitoryid, String d_dormbuilding, Integer pageIndex, Integer pageSize);
+
+    /**
+     * 添加宿舍信息
+     * @param dormitory 要添加的宿舍对象
+     * @return 返回影响的行数，通常 1 表示添加成功，0 表示添加失败
+     */
+    public int addDormitory(Dormitory dormitory);  // 添加宿舍信息
+
+    /**
+     * 删除宿舍信息
+     * @param d_id 要删除的宿舍ID
+     * @return 返回影响的行数，通常 1 表示删除成功，0 表示删除失败
+     */
+    public int deleteDormitory(Integer d_id);  // 删除宿舍信息
+
+    /**
+     * 修改宿舍信息
+     * @param dormitory 要更新的宿舍对象
+     * @return 返回影响的行数，通常 1 表示更新成功，0 表示更新失败
+     */
+    public int updateDormitory(Dormitory dormitory);  // 修改宿舍信息
+
+    /**
+     * 根据宿舍ID查询单条宿舍信息
+     * @param d_id 宿舍ID
+     * @return 返回查询到的宿舍信息对象，如果没有找到，返回 null
+     */
+    public Dormitory findDormitoryById(Integer d_id);  // 根据宿舍ID查询单条宿舍信息
+
+    /**
+     * 查询宿舍的人员信息
+     * @param dormitory 包含查询条件的宿舍对象
+     * @return 返回宿舍中所有相关的人员信息列表
+     */
+    public List<Dormitory> findDormitoryStudent(Dormitory dormitory);  // 查询宿舍人员信息
+
+    /**
+     * 获取所有宿舍信息
+     * @return 返回一个 List<Dormitory>，包含所有宿舍记录
+     */
+    public List<Dormitory> getAll();  // 获取所有宿舍信息
+}

src/com/itheima/service/StudentCleanService.java

@@ -0,0 +1,60 @@
+package com.itheima.service;  // 定义接口所属的包路径：com.itheima.service
+
+import com.itheima.po.PageInfo;  // 导入 PageInfo 类，用于分页信息的封装
+import com.itheima.po.StudentClean;  // 导入 StudentClean 类，表示学生卫生相关的实体类
+
+import java.util.List;  // 导入 List 类，用于存储多个 StudentClean 对象
+
+/**
+ * @program: dormitorySystem  // 程序名称：dormitorySystem
+ * @description: 学生卫生服务接口  // 该接口用于提供学生卫生管理相关的业务操作
+ * @author: Joyrocky  // 作者信息：Joyrocky
+ * @create: 2019-04-25 12:15  // 创建日期：2019-04-25
+ **/
+public interface StudentCleanService {
+
+    /**
+     * 分页查询学生卫生记录
+     * @param s_studentid 学生ID（可选查询条件）
+     * @param s_name 学生姓名（可选查询条件）
+     * @param s_dormitoryid 宿舍ID（可选查询条件）
+     * @param pageIndex 当前页码
+     * @param pageSize 每页显示的记录数
+     * @return 返回一个 PageInfo<StudentClean> 对象，封装了分页信息和查询结果
+     */
+    public PageInfo<StudentClean> findPageInfo(Integer s_studentid, String s_name, Integer s_dormitoryid, Integer pageIndex, Integer pageSize);
+
+    /**
+     * 添加学生卫生记录
+     * @param studentclean 要添加的学生卫生信息对象
+     * @return 返回影响的行数，通常 1 表示添加成功，0 表示添加失败
+     */
+    public int addStudentClean(StudentClean studentclean);  // 添加学生卫生记录
+
+    /**
+     * 删除学生卫生记录
+     * @param g_id 卫生记录的ID
+     * @return 返回影响的行数，通常 1 表示删除成功，0 表示删除失败
+     */
+    public int deleteStudentClean(Integer g_id);  // 删除学生卫生记录
+
+    /**
+     * 修改学生卫生记录
+     * @param studentclean 要更新的学生卫生信息对象
+     * @return 返回影响的行数，通常 1 表示更新成功，0 表示更新失败
+     */
+    public int updateStudentClean(StudentClean studentclean);  // 修改学生卫生记录
+
+    /**
+     * 根据卫生记录ID查询单条学生卫生记录
+     * @param g_id 卫生记录的ID
+     * @return 返回查询到的学生卫生信息对象，如果没有找到，返回 null
+     */
+    public StudentClean findStudentCleanById(Integer g_id);  // 根据卫生记录ID查询单条学生卫生记录
+
+    /**
+     * 获取所有学生卫生记录
+     * @return 返回一个 List<StudentClean>，包含所有学生卫生记录
+     */
+    public List<StudentClean> getAll();  // 获取所有学生卫生记录
+}

src/com/itheima/service/StudentService.java

@@ -0,0 +1,60 @@
+package com.itheima.service;  // 定义接口所在的包路径：com.itheima.service
+
+import com.itheima.po.PageInfo;  // 导入 PageInfo 类，用于封装分页信息，包含当前页、每页条数、总记录数等
+import com.itheima.po.Student;  // 导入 Student 类，用于表示学生实体类，通常包含学生的各种属性
+import org.apache.ibatis.annotations.Param;  // 导入 MyBatis 注解，用于指定参数名（此处代码没有实际使用）
+
+import java.util.List;  // 导入 List 类，用于存储多个 Student 对象，表示多个学生记录
+
+/**
+ * 用户Service层接口  // 该接口定义了学生管理的业务操作
+ */
+public interface StudentService {
+
+    /**
+     * 分页查询学生信息
+     * @param s_name 学生姓名（可选的查询条件）
+     * @param s_studentid 学生ID（可选的查询条件）
+     * @param s_classid 班级ID（可选的查询条件）
+     * @param s_classname 班级名称（可选的查询条件）
+     * @param pageIndex 当前页码
+     * @param pageSize 每页显示的记录数
+     * @return 返回一个 PageInfo<Student> 对象，封装了分页信息和查询结果
+     */
+    public PageInfo<Student> findPageInfo(String s_name, Integer s_studentid, Integer s_classid, 
+                                          String s_classname, Integer pageIndex, Integer pageSize);
+
+    /**
+     * 通过学生ID删除学生信息
+     * @param s_id 学生ID
+     * @return 返回影响的行数，通常 1 表示删除成功，0 表示删除失败
+     */
+    public int deleteStudent(Integer s_id);  // 删除学生信息
+
+    /**
+     * 添加学生信息
+     * @param student 要添加的学生对象
+     * @return 返回影响的行数，通常 1 表示添加成功，0 表示添加失败
+     */
+    public int addStudent(Student student);  // 添加学生信息
+
+    /**
+     * 修改学生信息
+     * @param student 要更新的学生对象
+     * @return 返回影响的行数，通常 1 表示更新成功，0 表示更新失败
+     */
+    public int updateStudent(Student student);  // 修改学生信息
+
+    /**
+     * 根据学生ID查询学生信息
+     * @param s_id 学生ID
+     * @return 返回查询到的学生对象，如果没有找到，返回 null
+     */
+    public Student findStudentById(Integer s_id);  // 根据学生ID查询学生信息
+
+    /**
+     * 获取所有学生信息
+     * @return 返回一个 List<Student>，包含所有学生的信息
+     */
+    public List<Student> getAll();  // 获取所有学生信息
+}

src/com/itheima/service/VisitorService.java

@@ -0,0 +1,42 @@
+package com.itheima.service;  // 定义接口所在的包路径：com.itheima.service
+
+import com.itheima.po.PageInfo;  // 导入 PageInfo 类，用于封装分页信息，包含当前页、每页条数、总记录数等
+import com.itheima.po.Visitor;  // 导入 Visitor 类，用于表示访客实体类，通常包含访客的各种属性，如姓名、电话等
+import org.springframework.ui.Model;  // 导入 Spring 的 Model 类，通常用于在 Controller 中传递数据给视图（本代码中没有使用）
+
+import java.util.List;  // 导入 List 类，用于存储多个 Visitor 对象，表示多个访客记录
+
+/**
+ * @program: dormitorySystem  // 项目名称：宿舍管理系统
+ * @description: 访客  // 接口描述：访客管理服务接口，定义了访客相关的业务操作
+ * @author: Joyrocky  // 作者：Joyrocky
+ * @create: 2019-05-14 12:39  // 创建时间：2019年5月14日 12:39
+ **/
+public interface VisitorService {
+
+    /**
+     * 分页查询访客信息
+     * @param v_name 访客姓名（可选的查询条件）
+     * @param v_phone 访客电话（可选的查询条件）
+     * @param pageIndex 当前页码
+     * @param pageSize 每页显示的记录数
+     * @return 返回一个 PageInfo<Visitor> 对象，封装了分页信息和查询结果
+     */
+    public PageInfo<Visitor> findPageInfo(String v_name, Integer v_phone, 
+                                          Integer pageIndex, Integer pageSize);  
+    // 分页查询访客信息，根据姓名（v_name）和电话（v_phone）进行筛选查询，分页参数为 pageIndex 和 pageSize。
+    // 返回一个 PageInfo<Visitor> 对象，包含了分页相关信息和查询结果。
+
+    /**
+     * 添加访客信息
+     * @param visitor 要添加的访客对象
+     * @return 返回影响的行数，通常 1 表示添加成功，0 表示添加失败
+     */
+    public int addVisitor(Visitor visitor);  // 添加访客信息，返回受影响的行数，1 表示添加成功，0 表示添加失败
+
+    /**
+     * 获取所有访客信息
+     * @return 返回一个 List<Visitor>，包含所有访客的信息
+     */
+    public List<Visitor> getAll();  // 获取所有访客信息，返回一个 List<Visitor>，表示所有访客记录
+}

src/com/itheima/service/impl/AdminServiceImpl.java

@@ -0,0 +1,113 @@
+package com.itheima.service.impl;  // 定义包路径，说明该类是实现类，位于 service.impl 包下
+
+import com.itheima.dao.AdminDao;  // 导入 AdminDao，进行数据库操作
+import com.itheima.po.Admin;  // 导入 Admin 实体类，表示管理员
+import com.itheima.po.PageInfo;  // 导入 PageInfo 类，用于分页查询的结果封装
+import com.itheima.service.AdminService;  // 导入 AdminService 接口，定义管理员服务接口
+import com.itheima.util.MD5Util;  // 导入 MD5Util 工具类，用于密码加密（虽然在这个类里没有直接使用）
+import org.springframework.beans.factory.annotation.Autowired;  // 导入 Spring 的注解，自动注入依赖
+import org.springframework.stereotype.Service;  // 导入 Service 注解，表示该类是服务层的实现类
+import org.springframework.transaction.annotation.Transactional;  // 导入事务管理注解
+
+import java.util.List;  // 导入 List 类，用于存储管理员列表
+
+/**
+ * 用户Service接口实现类
+ */
+@Service("adminService")  // 将该类标记为一个 Spring 服务类，名字为 "adminService"
+@Transactional  // 表示该类的所有方法都应该支持事务管理
+public class AdminServiceImpl implements AdminService {  // 实现 AdminService 接口
+
+    // 注入 AdminDao 用于访问数据库
+    @Autowired
+    private AdminDao adminDao;  // 自动注入 AdminDao 对象，Spring 会自动处理该依赖关系
+
+    /**
+     * 管理员登录查询
+     * @param admin 传入的管理员信息，用于查询
+     * @return 返回符合条件的管理员对象，如果找不到，返回 null
+     */
+    @Override
+    public Admin findAdmin(Admin admin) {  // 实现 AdminService 接口的 findAdmin 方法
+        Admin a = adminDao.findAdmin(admin);  // 调用 AdminDao 的 findAdmin 方法查询管理员
+        return a;  // 返回查询结果
+    }
+
+    /**
+     * 获取所有管理员信息
+     * @return 返回所有管理员的信息列表
+     */
+    @Override
+    public List<Admin> getAll() {  // 实现 AdminService 接口的 getAll 方法
+        List<Admin> adminList = adminDao.getAll();  // 调用 AdminDao 的 getAll 方法查询所有管理员
+        return adminList;  // 返回查询到的管理员列表
+    }
+
+    /**
+     * 分页查询管理员信息
+     * @param a_username 管理员用户名，用于筛选
+     * @param a_describe 管理员描述，用于筛选
+     * @param a_id 管理员ID，用于筛选
+     * @param pageIndex 当前页码
+     * @param pageSize 每页显示记录数
+     * @return 返回一个 PageInfo 对象，包含分页信息和管理员列表
+     */
+    @Override
+    public PageInfo<Admin> findPageInfo(String a_username, String a_describe, Integer a_id, Integer pageIndex, Integer pageSize) {  
+        PageInfo<Admin> pi = new PageInfo<Admin>();  // 创建 PageInfo 对象，用于封装分页信息
+        pi.setPageIndex(pageIndex);  // 设置当前页码
+        pi.setPageSize(pageSize);  // 设置每页显示的记录数
+        
+        // 获取符合条件的管理员总数
+        Integer totalCount = adminDao.totalCount(a_username, a_describe, a_id);  // 调用 adminDao 获取符合条件的管理员总数
+        if (totalCount > 0) {  // 如果总记录数大于 0，表示有查询结果
+            pi.setTotalCount(totalCount);  // 设置分页对象的总记录数
+            // 计算查询数据的起始行数 (当前页 - 1) * 每页记录数
+            List<Admin> adminList = adminDao.getAdminList(a_username, a_describe, a_id,
+                    (pi.getPageIndex() - 1) * pi.getPageSize(), pi.getPageSize());  // 调用 adminDao 查询分页数据
+            pi.setList(adminList);  // 将查询结果设置到分页对象中
+        }
+        return pi;  // 返回分页对象
+    }
+
+    /**
+     * 添加管理员信息
+     * @param admin 要添加的管理员对象
+     * @return 返回受影响的行数，1 表示成功，0 表示失败
+     */
+    @Override
+    public int addAdmin(Admin admin) {  // 实现 AdminService 接口的 addAdmin 方法
+        return adminDao.addAdmin(admin);  // 调用 adminDao 的 addAdmin 方法添加管理员信息
+    }
+
+    /**
+     * 通过 ID 删除管理员信息
+     * @param a_id 管理员的 ID
+     * @return 返回受影响的行数，1 表示删除成功，0 表示删除失败
+     */
+    @Override
+    public int deleteAdmin(Integer a_id) {  // 实现 AdminService 接口的 deleteAdmin 方法
+        return adminDao.deleteAdmin(a_id);  // 调用 adminDao 的 deleteAdmin 方法删除管理员信息
+    }
+
+    /**
+     * 修改管理员信息
+     * @param admin 要修改的管理员对象
+     * @return 返回受影响的行数，1 表示修改成功，0 表示修改失败
+     */
+    @Override
+    public int updateAdmin(Admin admin) {  // 实现 AdminService 接口的 updateAdmin 方法
+        return adminDao.updateAdmin(admin);  // 调用 adminDao 的 updateAdmin 方法修改管理员信息
+    }
+
+    /**
+     * 通过管理员 ID 查找管理员信息
+     * @param a_id 管理员 ID
+     * @return 返回符合条件的管理员对象
+     */
+    @Override
+    public Admin findAdminById(Integer a_id) {  // 实现 AdminService 接口的 findAdminById 方法
+        Admin a = adminDao.findAdminById(a_id);  // 调用 adminDao 的 findAdminById 方法查询管理员信息
+        return a;  // 返回查询结果
+    }
+}

src/com/itheima/service/impl/ClassServiceImpl.java

@@ -0,0 +1,112 @@
+package com.itheima.service.impl;  // 定义包路径，表明该类是实现类，位于 service.impl 包下
+
+import com.itheima.dao.ClassDao;  // 导入 ClassDao，用于与数据库交互
+import com.itheima.po.Class;  // 导入 Class 实体类，表示班级
+import com.itheima.po.PageInfo;  // 导入 PageInfo 类，用于封装分页信息
+import com.itheima.service.ClassService;  // 导入 ClassService 接口，定义班级服务
+import org.springframework.beans.factory.annotation.Autowired;  // 导入 Spring 注解，用于自动注入依赖
+import org.springframework.stereotype.Service;  // 导入 Service 注解，标记该类为服务层的实现
+import org.springframework.transaction.annotation.Transactional;  // 导入事务管理注解
+
+import java.util.List;  // 导入 List 类，用于存储班级信息列表
+
+/**
+ * 班级Service接口实现类
+ */
+@Service("classService")  // 将该类标记为 Spring 服务类，bean 名称为 "classService"
+@Transactional  // 表示该类的所有方法都由 Spring 管理事务
+public class ClassServiceImpl implements ClassService {  // 实现 ClassService 接口
+
+    // 自动注入 ClassDao，用于访问数据库操作
+    @Autowired
+    private ClassDao classDao;  // Spring 会自动注入符合类型的 ClassDao 实现
+
+    /**
+     * 分页查询班级信息
+     * @param c_classname 班级名称
+     * @param c_counsellor 班级辅导员
+     * @param c_classid 班级ID
+     * @param pageIndex 当前页码
+     * @param pageSize 每页显示的记录数
+     * @return 返回封装了班级信息的分页对象
+     */
+    @Override
+    public PageInfo<Class> findPageInfo(String c_classname, String c_counsellor, Integer c_classid, Integer pageIndex, Integer pageSize) {
+        PageInfo<Class> pi = new PageInfo<Class>();  // 创建 PageInfo 对象，用于存储分页信息
+        pi.setPageIndex(pageIndex);  // 设置当前页码
+        pi.setPageSize(pageSize);  // 设置每页显示的记录数
+        
+        // 获取符合条件的总记录数
+        Integer totalCount = classDao.totalCount(c_classname, c_classid, c_counsellor);  // 调用 ClassDao 获取总记录数
+        if (totalCount > 0) {  // 如果总记录数大于 0，表示有查询结果
+            pi.setTotalCount(totalCount);  // 设置分页对象的总记录数
+            // 计算查询数据的起始行数 (当前页 - 1) * 每页记录数
+            List<Class> classList = classDao.getClassList(c_classname, c_classid, c_counsellor,
+                    (pi.getPageIndex() - 1) * pi.getPageSize(), pi.getPageSize());  // 调用 ClassDao 获取分页数据
+            pi.setList(classList);  // 将查询结果设置到分页对象中
+        }
+        return pi;  // 返回分页对象
+    }
+
+    /**
+     * 获取所有班级信息
+     * @return 返回所有班级的列表
+     */
+    @Override
+    public List<Class> getAll() {
+        List<Class> classList = classDao.getAll();  // 调用 ClassDao 获取所有班级信息
+        return classList;  // 返回班级列表
+    }
+
+    /**
+     * 通过班级 ID 删除班级信息
+     * @param c_id 班级 ID
+     * @return 返回删除操作受影响的行数，1 表示成功，0 表示失败
+     */
+    @Override
+    public int deleteClass(Integer c_id) {
+        return classDao.deleteClass(c_id);  // 调用 ClassDao 删除班级信息
+    }
+
+    /**
+     * 添加班级信息
+     * @param uclass 要添加的班级对象
+     * @return 返回添加操作受影响的行数，1 表示成功，0 表示失败
+     */
+    @Override
+    public int addClass(Class uclass) {
+        return classDao.addClass(uclass);  // 调用 ClassDao 添加班级信息
+    }
+
+    /**
+     * 根据班级 ID 查询班级信息
+     * @param c_id 班级 ID
+     * @return 返回符合条件的班级对象
+     */
+    @Override
+    public Class findClassById(Integer c_id) {
+        Class c = classDao.findClassById(c_id);  // 调用 ClassDao 根据班级 ID 查询班级信息
+        return c;  // 返回查询结果
+    }
+
+    /**
+     * 修改班级信息
+     * @param uclass 要修改的班级对象
+     * @return 返回修改操作受影响的行数，1 表示成功，0 表示失败
+     */
+    @Override
+    public int updateClass(Class uclass) {
+        return classDao.updateClass(uclass);  // 调用 ClassDao 修改班级信息
+    }
+
+    /**
+     * 查询班级的学生信息
+     * @param uclass 班级对象，包含要查询的班级信息
+     * @return 返回班级内所有学生的信息
+     */
+    @Override
+    public List<Class> findClassStudent(Class uclass) {
+        List<Class> c = classDao.findClassStudent(uclass);  // 调用 ClassDao 查询班级的学生信息
+        return c;  // 返回查询结果
+    }
+}

src/com/itheima/service/impl/DormCleanServiceImpl.java

@@ -0,0 +1,111 @@
+package com.itheima.service.impl;  // 定义该类所在的包路径，表示是服务实现类
+
+import com.itheima.dao.DormCleanDao;  // 导入 DormCleanDao，用于与数据库交互，操作宿舍卫生相关数据
+import com.itheima.po.DormClean;  // 导入 DormClean 类，表示宿舍卫生信息实体
+import com.itheima.po.PageInfo;  // 导入 PageInfo 类，封装分页信息
+import com.itheima.service.DormCleanService;  // 导入 DormCleanService 接口，表示宿舍卫生服务
+import org.springframework.beans.factory.annotation.Autowired;  // 导入 Spring 的注解，用于自动注入依赖
+import org.springframework.stereotype.Service;  // 导入 Service 注解，表示该类是 Spring 的服务类
+import org.springframework.transaction.annotation.Transactional;  // 导入事务管理注解，用于声明事务管理
+
+import java.util.List;  // 导入 List 类，用于存储宿舍卫生信息列表
+
+/**
+ * @program: dormitorySystem
+ * @description: 宿舍卫生服务接口实现
+ * @author: Joyrocky
+ * @create: 2019-04-24 15:19
+ **/
+@Service("dormCleanService")  // 将该类标记为 Spring 的服务类，bean 名称为 "dormCleanService"
+@Transactional  // 标明该类中的所有方法都由 Spring 管理事务
+public class DormCleanServiceImpl implements DormCleanService {  // 实现 DormCleanService 接口
+
+    // 自动注入 DormCleanDao，用于访问宿舍卫生数据
+    @Autowired
+    private DormCleanDao dormCleanDao;  // Spring 会自动注入符合类型的 DormCleanDao 实现类
+
+    /**
+     * 分页查询宿舍卫生信息
+     * @param d_id 宿舍 ID
+     * @param d_dormbuilding 宿舍楼名称
+     * @param pageIndex 当前页码
+     * @param pageSize 每页显示的记录数
+     * @return 返回分页后的宿舍卫生信息
+     */
+    @Override
+    public PageInfo<DormClean> findPageInfo(Integer d_id, String d_dormbuilding, Integer pageIndex, Integer pageSize) {
+        // 创建 PageInfo 对象来存储分页信息
+        PageInfo<DormClean> pi = new PageInfo<DormClean>();
+        pi.setPageIndex(pageIndex);  // 设置当前页码
+        pi.setPageSize(pageSize);  // 设置每页的记录数
+
+        // 获取符合条件的总记录数
+        Integer totalCount = dormCleanDao.totalCount(d_id, d_dormbuilding);  // 调用 Dao 层方法获取总条数
+
+        if (totalCount > 0) {  // 如果查询结果不为空
+            pi.setTotalCount(totalCount);  // 设置总记录数
+            // 计算分页查询的起始行数，并获取当前页的宿舍卫生信息列表
+            List<DormClean> dormCleanList = dormCleanDao.getDormCleanList(d_id, d_dormbuilding,
+                    (pi.getPageIndex() - 1) * pi.getPageSize(), pi.getPageSize());  // 调用 Dao 层方法获取分页数据
+            pi.setList(dormCleanList);  // 设置分页对象的班级列表
+        }
+
+        return pi;  // 返回分页信息对象
+    }
+
+    /**
+     * 获取所有宿舍卫生信息
+     * @return 返回所有宿舍卫生信息的列表
+     */
+    @Override
+    public List<DormClean> getAll() {
+        // 获取所有宿舍卫生信息并返回
+        List<DormClean> dormCleanList = dormCleanDao.getAll();  // 调用 Dao 层方法获取所有宿舍卫生信息
+        return dormCleanList;  // 返回所有宿舍卫生信息
+    }
+
+    /**
+     * 添加宿舍卫生信息
+     * @param dormclean 要添加的宿舍卫生信息
+     * @return 返回受影响的行数，1 表示成功，0 表示失败
+     */
+    @Override
+    public int addDormClean(DormClean dormclean) {
+        // 调用 Dao 层方法将宿舍卫生信息插入数据库
+        return dormCleanDao.addDormClean(dormclean);  // 返回数据库操作受影响的行数
+    }
+
+    /**
+     * 根据 ID 删除宿舍卫生信息
+     * @param g_id 宿舍卫生信息的 ID
+     * @return 返回受影响的行数，1 表示成功，0 表示失败
+     */
+    @Override
+    public int deleteDormClean(Integer g_id) {
+        // 调用 Dao 层方法根据 ID 删除宿舍卫生信息
+        return dormCleanDao.deleteDormClean(g_id);  // 返回删除操作受影响的行数
+    }
+
+    /**
+     * 修改宿舍卫生信息
+     * @param dormclean 要修改的宿舍卫生信息
+     * @return 返回受影响的行数，1 表示成功，0 表示失败
+     */
+    @Override
+    public int updateDormClean(DormClean dormclean) {
+        // 调用 Dao 层方法更新宿舍卫生信息
+        return dormCleanDao.updateDormClean(dormclean);  // 返回更新操作受影响的行数
+    }
+
+    /**
+     * 根据 ID 查询宿舍卫生信息
+     * @param g_id 宿舍卫生信息的 ID
+     * @return 返回匹配的宿舍卫生信息
+     */
+    @Override
+    public DormClean findDormCleanById(Integer g_id) {
+        // 调用 Dao 层方法根据 ID 查询宿舍卫生信息
+        DormClean d = dormCleanDao.findDormCleanById(g_id);  // 获取宿舍卫生信息
+        return d;  // 返回查询结果
+    }
+}

src/com/itheima/service/impl/DormRepairServiceImpl.java

@@ -0,0 +1,91 @@
+package com.itheima.service.impl;
+
+import com.itheima.dao.DormRepairDao;  // 导入DormRepairDao接口，用于数据访问操作
+import com.itheima.po.DormRepair;      // 导入DormRepair类，用于表示宿舍维修记录
+import com.itheima.po.PageInfo;        // 导入PageInfo类，用于分页信息
+import com.itheima.service.DormRepairService; // 导入DormRepairService接口，该类实现该接口
+import org.springframework.beans.factory.annotation.Autowired; // 导入自动注入的注解
+import org.springframework.stereotype.Service; // 导入Service注解，标识这是一个Service类
+import org.springframework.transaction.annotation.Transactional; // 导入事务管理注解
+
+import java.util.List; // 导入List类，用于存储多个维修记录对象
+
+/**
+ * @program: dormitorySystem
+ * @description: 维修登记服务实现类
+ * @author: Joyrocky
+ * @create: 2019-04-28 00:24
+ **/
+@Service("dormRepairService")  // 标注该类为一个Spring服务组件，名称为dormRepairService
+@Transactional  // 启用事务管理，确保该类中数据库操作的原子性
+public class DormRepairServiceImpl implements DormRepairService {
+
+    // 自动注入DormRepairDao，DAO层用于与数据库交互
+    @Autowired
+    private DormRepairDao dormRepairDao;
+
+    // 分页查询维修记录的方法
+    @Override
+    public PageInfo<DormRepair> findPageInfo(Integer d_id, String d_dormbuilding, Integer pageIndex, Integer pageSize) {
+        // 创建PageInfo对象，用于存储分页信息
+        PageInfo<DormRepair> pi = new PageInfo<DormRepair>();
+        pi.setPageIndex(pageIndex);  // 设置当前页码
+        pi.setPageSize(pageSize);    // 设置每页显示的记录数
+
+        // 获取符合条件的总记录数
+        Integer totalCount = dormRepairDao.totalCount(d_id, d_dormbuilding);
+        
+        // 如果总记录数大于0，进行分页查询
+        if (totalCount > 0) {
+            pi.setTotalCount(totalCount); // 设置总记录数
+
+            // 计算当前页的起始位置，并查询当前页的维修记录列表
+            // currentPage = (pageIndex - 1) * pageSize
+            List<DormRepair> dormRepairList = dormRepairDao.getDormRepairList(
+                    d_id, d_dormbuilding, 
+                    (pi.getPageIndex() - 1) * pi.getPageSize(), pi.getPageSize()
+            );
+            pi.setList(dormRepairList); // 设置当前页的维修记录列表
+        }
+
+        return pi;  // 返回包含分页信息的PageInfo对象
+    }
+
+    // 获取所有维修记录的方法
+    @Override
+    public List<DormRepair> getAll() {
+        // 调用DAO层获取所有维修记录，并返回列表
+        List<DormRepair> dormRepairList = dormRepairDao.getAll();
+        return dormRepairList;  // 返回维修记录列表
+    }
+
+    // 添加维修记录的方法
+    @Override
+    public int addDormRepair(DormRepair dormrepair) {
+        // 调用DAO层的addDormRepair方法添加维修记录，并返回受影响的行数
+        return dormRepairDao.addDormRepair(dormrepair);
+    }
+
+    // 通过维修记录ID删除维修记录的方法
+    @Override
+    public int deleteDormRepair(Integer r_id) {
+        // 调用DAO层的deleteDormRepair方法删除指定ID的维修记录，并返回受影响的行数
+        return dormRepairDao.deleteDormRepair(r_id);
+    }
+
+    // 修改维修记录的方法
+    @Override
+    public int updateDormRepair(DormRepair dormrepair) {
+        // 调用DAO层的updateDormRepair方法更新维修记录，并返回受影响的行数
+        return dormRepairDao.updateDormRepair(dormrepair);
+    }
+
+    // 根据维修记录ID查询单条维修记录的方法
+    @Override
+    public DormRepair findDormRepairById(Integer r_id) {
+        // 调用DAO层的findDormRepairById方法根据ID查询维修记录
+        DormRepair d = dormRepairDao.findDormRepairById(r_id);
+        return d;  // 返回查询到的维修记录
+    }
+
+}

src/com/itheima/service/impl/DormitoryServiceImpl.java

@@ -0,0 +1,116 @@
+package com.itheima.service.impl;
+
+import com.itheima.dao.DormitoryDao;
+import com.itheima.po.Dormitory;
+import com.itheima.po.PageInfo;
+import com.itheima.service.DormitoryService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * 宿舍管理 Service 接口实现类
+ */
+@Service("dormitoryService") // 将该类标识为 Spring 服务类，能够被 Spring 容器自动管理
+@Transactional // 开启事务管理，确保在操作宿舍数据时进行事务控制
+public class DormitoryServiceImpl implements DormitoryService {
+    
+    // 自动注入 DormitoryDao，DAO层处理宿舍数据的操作
+    @Autowired
+    private DormitoryDao dormitoryDao;
+
+    /**
+     * 分页查询宿舍信息
+     * @param a_name 宿舍名称
+     * @param s_dormitoryid 宿舍ID
+     * @param d_dormbuilding 宿舍楼
+     * @param pageIndex 当前页码
+     * @param pageSize 每页显示的条数
+     * @return 返回分页信息
+     */
+    @Override
+    public PageInfo<Dormitory> findPageInfo(String a_name, Integer s_dormitoryid, String d_dormbuilding, Integer pageIndex, Integer pageSize) {
+        PageInfo<Dormitory> pi = new PageInfo<Dormitory>(); // 创建分页信息对象
+        pi.setPageIndex(pageIndex); // 设置当前页码
+        pi.setPageSize(pageSize); // 设置每页显示的条数
+        
+        // 获取总条数，分页需要使用总记录数来计算总页数
+        Integer totalCount = dormitoryDao.totalCount(a_name, s_dormitoryid, d_dormbuilding);
+        
+        // 如果总条数大于0，则进行分页查询
+        if (totalCount > 0) {
+            pi.setTotalCount(totalCount); // 设置总记录数
+            // 计算分页查询时的开始行数
+            List<Dormitory> dormitoryList = dormitoryDao.getDormitoryList(
+                a_name, s_dormitoryid, d_dormbuilding, 
+                (pi.getPageIndex() - 1) * pi.getPageSize(), pi.getPageSize()
+            );
+            pi.setList(dormitoryList); // 设置当前页的数据列表
+        }
+        return pi; // 返回分页信息
+    }
+
+    /**
+     * 获取所有宿舍信息
+     * @return 返回所有宿舍信息的列表
+     */
+    @Override
+    public List<Dormitory> getAll() {
+        List<Dormitory> dormitoryList = dormitoryDao.getAll(); // 调用 DAO 层获取所有宿舍信息
+        return dormitoryList; // 返回宿舍信息列表
+    }
+
+    /**
+     * 添加宿舍信息
+     * @param dormitory 要添加的宿舍对象
+     * @return 返回添加操作的结果
+     */
+    @Override
+    public int addDormitory(Dormitory dormitory) {
+        return dormitoryDao.addDormitory(dormitory); // 调用 DAO 层的添加宿舍方法
+    }
+
+    /**
+     * 根据宿舍ID删除宿舍信息
+     * @param d_id 宿舍ID
+     * @return 返回删除操作的结果
+     */
+    @Override
+    public int deleteDormitory(Integer d_id) {
+        return dormitoryDao.deleteDormitory(d_id); // 调用 DAO 层删除宿舍信息的方法
+    }
+
+    /**
+     * 修改宿舍信息
+     * @param dormitory 要修改的宿舍对象
+     * @return 返回修改操作的结果
+     */
+    @Override
+    public int updateDormitory(Dormitory dormitory) {
+        return dormitoryDao.updateDormitory(dormitory); // 调用 DAO 层修改宿舍信息的方法
+    }
+
+    /**
+     * 根据宿舍ID查询单个宿舍的信息
+     * @param d_id 宿舍ID
+     * @return 返回对应宿舍的详细信息
+     */
+    @Override
+    public Dormitory findDormitoryById(Integer d_id) {
+        Dormitory d = dormitoryDao.findDormitoryById(d_id); // 调用 DAO 层根据宿舍ID查询宿舍信息
+        return d; // 返回宿舍对象
+    }
+
+    /**
+     * 查询宿舍中的学生信息
+     * @param dormitory 宿舍对象，包含查询条件
+     * @return 返回宿舍中的学生信息列表
+     */
+    @Override
+    public List<Dormitory> findDormitoryStudent(Dormitory dormitory) {
+        List<Dormitory> d = dormitoryDao.findDormitoryStudent(dormitory); // 调用 DAO 层查询宿舍人员信息的方法
+        return d; // 返回宿舍学生信息列表
+    }
+}

src/com/itheima/service/impl/StudentCleanServiceImpl.java

@@ -0,0 +1,90 @@
+package com.itheima.service.impl;
+
+import com.itheima.dao.StudentCleanDao;  // 导入StudentCleanDao接口，用于数据访问操作
+import com.itheima.po.PageInfo;          // 导入PageInfo类，用于封装分页信息
+import com.itheima.po.StudentClean;     // 导入StudentClean类，用于表示学生宿舍卫生记录
+import com.itheima.service.StudentCleanService; // 导入StudentCleanService接口，该类实现该接口
+import org.springframework.beans.factory.annotation.Autowired; // 导入自动注入的注解
+import org.springframework.stereotype.Service; // 导入Service注解，标识这是一个Service类
+import org.springframework.transaction.annotation.Transactional; // 导入事务管理注解
+
+import java.util.List;  // 导入List类，用于存储多个学生宿舍卫生记录对象
+
+/**
+ * @program: dormitorySystem
+ * @description: 学生卫生接口实现类
+ * @author: Joyrocky
+ * @create: 2019-04-25 12:16
+ **/
+@Service("studentCleanService")  // 标注该类为一个Spring服务组件，名称为studentCleanService
+@Transactional  // 启用事务管理，确保该类中数据库操作的原子性
+public class StudentCleanServiceImpl implements StudentCleanService {
+
+    // 自动注入StudentCleanDao，DAO层用于与数据库交互
+    @Autowired
+    private StudentCleanDao studentCleanDao;
+
+    // 分页查询学生宿舍卫生记录的方法
+    @Override
+    public PageInfo<StudentClean> findPageInfo(Integer s_studentid, String s_name, Integer s_dormitoryid, Integer pageIndex, Integer pageSize) {
+        // 创建PageInfo对象，用于存储分页信息
+        PageInfo<StudentClean> pi = new PageInfo<StudentClean>();
+        pi.setPageIndex(pageIndex);  // 设置当前页码
+        pi.setPageSize(pageSize);    // 设置每页显示的记录数
+
+        // 获取符合条件的总记录数
+        Integer totalCount = studentCleanDao.totalCount(s_studentid, s_name, s_dormitoryid);
+        
+        // 如果总记录数大于0，进行分页查询
+        if (totalCount > 0) {
+            pi.setTotalCount(totalCount);  // 设置总记录数
+
+            // 计算当前页的起始位置，并查询当前页的学生宿舍卫生记录列表
+            // currentPage = (pageIndex - 1) * pageSize
+            List<StudentClean> studentCleanList = studentCleanDao.getStudentCleanList(
+                    s_studentid, s_name, s_dormitoryid, 
+                    (pi.getPageIndex() - 1) * pi.getPageSize(), pi.getPageSize()
+            );
+            pi.setList(studentCleanList);  // 设置当前页的学生宿舍卫生记录列表
+        }
+
+        return pi;  // 返回包含分页信息的PageInfo对象
+    }
+
+    // 获取所有学生宿舍卫生记录的方法
+    @Override
+    public List<StudentClean> getAll() {
+        // 调用DAO层获取所有学生宿舍卫生记录，并返回列表
+        List<StudentClean> studentCleanList = studentCleanDao.getAll();
+        return studentCleanList;  // 返回学生宿舍卫生记录列表
+    }
+
+    // 添加学生宿舍卫生记录的方法
+    @Override
+    public int addStudentClean(StudentClean studentclean) {
+        // 调用DAO层的addStudentClean方法添加新的学生宿舍卫生记录，并返回受影响的行数
+        return studentCleanDao.addStudentClean(studentclean);
+    }
+
+    // 通过ID删除学生宿舍卫生记录的方法
+    @Override
+    public int deleteStudentClean(Integer g_id) {
+        // 调用DAO层的deleteStudentClean方法删除指定ID的学生宿舍卫生记录，并返回受影响的行数
+        return studentCleanDao.deleteStudentClean(g_id);
+    }
+
+    // 修改学生宿舍卫生记录的方法
+    @Override
+    public int updateStudentClean(StudentClean studentclean) {
+        // 调用DAO层的updateStudentClean方法更新学生宿舍卫生记录，并返回受影响的行数
+        return studentCleanDao.updateStudentClean(studentclean);
+    }
+
+    // 根据ID查询学生宿舍卫生记录的方法
+    @Override
+    public StudentClean findStudentCleanById(Integer g_id) {
+        // 调用DAO层的findStudentCleanById方法根据ID查询学生宿舍卫生记录
+        StudentClean d = studentCleanDao.findStudentCleanById(g_id);
+        return d;  // 返回查询到的学生宿舍卫生记录
+    }
+}

src/com/itheima/service/impl/StudentServiceImpl.java

@@ -0,0 +1,117 @@
+package com.itheima.service.impl;
+
+import com.itheima.dao.StudentDao;  // 导入StudentDao接口，用于数据访问操作
+import com.itheima.po.PageInfo;    // 导入PageInfo类，用于封装分页信息
+import com.itheima.po.Student;     // 导入Student类，用于表示学生对象
+import com.itheima.service.StudentService;  // 导入StudentService接口，该类实现该接口
+import org.springframework.beans.factory.annotation.Autowired;  // 导入自动注入的注解
+import org.springframework.stereotype.Service;  // 导入Service注解，标识这是一个Service类
+import org.springframework.transaction.annotation.Transactional;  // 导入事务管理注解
+
+import java.util.List;  // 导入List类，用于存储多个学生对象
+
+/**
+ * 用户Service接口实现类
+ */
+@Service("studentService")  // 标注该类为一个Spring管理的服务组件，名称为studentService
+@Transactional  // 启用事务管理，确保该类中的数据库操作要么全部成功，要么全部回滚，保证数据一致性和完整性
+public class StudentServiceImpl implements StudentService {
+
+    // 自动注入StudentDao，DAO层用于与数据库交互
+    @Autowired
+    private StudentDao studentDao;
+
+    /**
+     * 分页查询学生信息
+     * @param s_name 学生姓名
+     * @param s_studentid 学生ID
+     * @param s_classid 班级ID
+     * @param s_classname 班级名称
+     * @param pageIndex 当前页码
+     * @param pageSize 每页显示的记录数
+     * @return 返回分页信息（PageInfo）
+     */
+    @Override
+    public PageInfo<Student> findPageInfo(String s_name, Integer s_studentid, Integer s_classid,
+                                          String s_classname, Integer pageIndex, Integer pageSize) {
+        // 创建PageInfo对象，用于封装分页信息
+        PageInfo<Student> pi = new PageInfo<Student>();
+        pi.setPageIndex(pageIndex);  // 设置当前页码
+        pi.setPageSize(pageSize);    // 设置每页显示的记录数
+
+        // 获取符合条件的总记录数
+        Integer totalCount = studentDao.totalCount(s_name, s_studentid, s_classid, s_classname);
+
+        // 如果总记录数大于0，进行分页查询
+        if (totalCount > 0) {
+            pi.setTotalCount(totalCount);  // 设置总记录数
+
+            // 根据页码和每页大小计算出查询的起始位置，并获取当前页的学生列表
+            // currentPage = (pageIndex - 1) * pageSize，当前页码减去1，乘以每页记录数，得到查询的起始位置
+            List<Student> studentList = studentDao.getStudentList(
+                    s_name, s_studentid, s_classid, s_classname, 
+                    (pi.getPageIndex() - 1) * pi.getPageSize(), pi.getPageSize()
+            );
+
+            pi.setList(studentList);  // 设置当前页的学生列表
+        }
+
+        return pi;  // 返回封装了分页信息的PageInfo对象
+    }
+
+    /**
+     * 获取所有学生信息
+     * @return 返回所有学生的列表
+     */
+    @Override
+    public List<Student> getAll() {
+        // 调用DAO层的getAll方法获取所有学生信息
+        List<Student> studentList = studentDao.getAll();
+        return studentList;  // 返回所有学生的列表
+    }
+
+    /**
+     * 删除指定ID的学生信息
+     * @param s_id 学生ID
+     * @return 返回受影响的行数，通常为1表示删除成功
+     */
+    @Override
+    public int deleteStudent(Integer s_id) {
+        // 调用DAO层的deleteStudent方法删除指定ID的学生记录
+        return studentDao.deleteStudent(s_id);
+    }
+
+    /**
+     * 添加学生信息
+     * @param student 学生对象，包含要添加的学生信息
+     * @return 返回受影响的行数，通常为1表示插入成功
+     */
+    @Override
+    public int addStudent(Student student) {
+        // 调用DAO层的addStudent方法添加新的学生记录
+        return studentDao.addStudent(student);
+    }
+
+    /**
+     * 更新学生信息
+     * @param student 学生对象，包含要更新的学生信息
+     * @return 返回受影响的行数，通常为1表示更新成功
+     */
+    @Override
+    public int updateStudent(Student student) {
+        // 调用DAO层的updateStudent方法更新指定学生的信息
+        return studentDao.updateStudent(student);
+    }
+
+    /**
+     * 根据学生ID查找学生信息
+     * @param s_id 学生ID
+     * @return 返回对应ID的学生信息
+     */
+    @Override
+    public Student findStudentById(Integer s_id) {
+        // 调用DAO层的findStudentById方法根据学生ID查询学生信息
+        Student s = studentDao.findStudentById(s_id);
+        return s;  // 返回查询到的学生对象
+    }
+}

src/com/itheima/service/impl/VisitorServiceImpl.java

@@ -0,0 +1,79 @@
+package com.itheima.service.impl;
+
+import com.itheima.dao.VisitorDao;  // 导入VisitorDao接口，用于数据访问操作
+import com.itheima.po.PageInfo;    // 导入PageInfo类，用于封装分页信息
+import com.itheima.po.Visitor;     // 导入Visitor类，用于表示访客对象
+import com.itheima.service.VisitorService;  // 导入VisitorService接口，该类实现该接口
+import org.springframework.beans.factory.annotation.Autowired;  // 导入自动注入的注解
+import org.springframework.stereotype.Service;  // 导入Service注解，标识这是一个Service类
+import org.springframework.transaction.annotation.Transactional;  // 导入事务管理注解
+
+import java.util.List;  // 导入List类，用于存储多个访客对象
+
+/**
+ * 访客Service接口实现类
+ */
+@Service("visitorService")  // 标注该类为一个Spring管理的服务组件，名称为visitorService
+@Transactional  // 启用事务管理，确保该类中的数据库操作要么全部成功，要么全部回滚，保证数据一致性和完整性
+public class VisitorServiceImpl implements VisitorService {
+    // 自动注入VisitorDao，DAO层用于与数据库交互
+    @Autowired
+    private VisitorDao visitorDao;
+
+    /**
+     * 分页查询访客信息
+     * @param v_name 访客姓名
+     * @param v_phone 访客电话
+     * @param pageIndex 当前页码
+     * @param pageSize 每页显示的记录数
+     * @return 返回分页信息（PageInfo）
+     */
+    @Override
+    public PageInfo<Visitor> findPageInfo(String v_name, Integer v_phone, Integer pageIndex, Integer pageSize) {
+        // 创建PageInfo对象，用于封装分页信息
+        PageInfo<Visitor> pi = new PageInfo<Visitor>();
+        pi.setPageIndex(pageIndex);  // 设置当前页码
+        pi.setPageSize(pageSize);    // 设置每页显示的记录数
+
+        // 获取符合条件的总记录数
+        Integer totalCount = visitorDao.totalCount(v_name, v_phone);
+
+        // 如果总记录数大于0，进行分页查询
+        if (totalCount > 0) {
+            pi.setTotalCount(totalCount);  // 设置总记录数
+
+            // 根据页码和每页大小计算出查询的起始位置，并获取当前页的访客列表
+            // currentPage = (pageIndex - 1) * pageSize，当前页码减去1，乘以每页记录数，得到查询的起始位置
+            List<Visitor> visitorList = visitorDao.getVisitorList(
+                    v_name, v_phone, 
+                    (pi.getPageIndex() - 1) * pi.getPageSize(), pi.getPageSize()
+            );
+
+            pi.setList(visitorList);  // 设置当前页的访客列表
+        }
+
+        return pi;  // 返回封装了分页信息的PageInfo对象
+    }
+
+    /**
+     * 获取所有访客信息
+     * @return 返回所有访客的列表
+     */
+    @Override
+    public List<Visitor> getAll() {
+        // 调用DAO层的getAll方法获取所有访客信息
+        List<Visitor> visitorList = visitorDao.getAll();
+        return visitorList;  // 返回所有访客的列表
+    }
+
+    /**
+     * 添加访客信息
+     * @param visitor 访客对象，包含要添加的访客信息
+     * @return 返回受影响的行数，通常为1表示插入成功
+     */
+    @Override
+    public int addVisitor(Visitor visitor) {
+        // 调用DAO层的addVisitor方法添加新的访客记录
+        return visitorDao.addVisitor(visitor);
+    }
+}