注释

src/com/itheima/controller/AdminController.java

@@ -1,6 +1,5 @@
 package com.itheima.controller;
 
-
 import com.itheima.po.Admin;
 import com.itheima.po.PageInfo;
 import com.itheima.service.AdminService;
@@ -13,117 +12,148 @@ import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
 
-
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpSession;
 import java.util.List;
 
 /**
- * 用户控制器类
+ * 用户控制器类，用于处理与管理员相关的各类业务操作，如登录、查询、添加、删除、修改等，并和相应视图进行交互
  */
 @Controller
 public class AdminController {
-	// 依赖注入
+
+	// 依赖注入，通过Spring框架自动装配AdminService的实例，方便在本类中调用其提供的业务方法
 	@Autowired
 	private AdminService adminService;
+
 	/**
-	 * 用户登录
+	 * 用户登录的方法
-	 */
+	 * 接收前端传入的包含用户名和密码等信息的Admin对象，以及Model、HttpSession、HttpServletRequest对象，用于后续的数据处理、会话管理和请求相关操作
-	/**
+	 * 此方法的主要功能是验证用户登录信息并根据验证结果进行相应的页面跳转
-	 * 将提交数据(username,password)写入Admin对象
 	 */
 	@RequestMapping(value = "/login")
-	public String login( Admin admin, Model model, HttpSession session, HttpServletRequest request) {
+	public String login(Admin admin, Model model, HttpSession session, HttpServletRequest request) {
 		// 通过账号和密码查询用户
-
+		// 对用户输入的密码进行MD5加密处理，保证密码在传输和存储过程中的安全性，使用MD5Util工具类的MD5EncodeUtf8方法进行加密
 		admin.setA_password(MD5Util.MD5EncodeUtf8(admin.getA_password()));
+		// 调用AdminService的findAdmin方法，根据传入的包含加密后密码的Admin对象去数据库等存储介质中查找对应的管理员信息
 		Admin ad = adminService.findAdmin(admin);
-		if(ad!=null){
+		// 如果查找到对应的管理员信息（即验证通过）
+		if (ad!= null) {
+			// 将查询到的管理员信息存入HttpSession中，方便在后续的页面访问中获取管理员相关数据，比如权限判断等
 			session.setAttribute("ad", ad);
+			// 登录成功，返回"homepage"视图名称，通常会跳转到系统的首页等相关页面
 			return "homepage";
 		}
+		// 如果未找到对应的管理员信息（验证失败），向Model中添加错误提示信息，用于在登录页面展示给用户
 		model.addAttribute("msg", "用户名或密码错误，请重新登录！");
+		// 返回"login"视图名称，即跳回登录页面，让用户重新输入登录信息
 		return "login";
 	}
 
 	/**
-	 * 退出登录
+	 * 退出登录的方法
+	 * 接收Admin对象、Model对象和HttpSession对象，主要功能是使当前的HttpSession失效，实现用户退出登录的操作，然后跳回登录页面
 	 */
 	@RequestMapping(value = "/loginOut")
 	public String loginOut(Admin admin, Model model, HttpSession session) {
+		// 使当前的HttpSession失效，清除会话中存储的所有数据，如用户登录信息等，实现退出登录的效果
 		session.invalidate();
+		// 返回"login"视图名称，跳转到登录页面
 		return "login";
-
 	}
 
 	/**
-	 * 分页查询
+	 * 分页查询管理员信息的方法
+	 * 接收用于筛选管理员信息的多个参数，如用户名、描述、管理员ID、当前页码、每页显示数量等，以及Model对象用于向视图传递数据
+	 * 此方法通过调用AdminService的findPageInfo方法进行分页查询操作，并将查询结果传递给视图展示
 	 */
 	@RequestMapping(value = "/findAdmin")
-	public String findAdmin(String a_username, String a_describe,Integer pageIndex,
+	public String findAdmin(String a_username, String a_describe, Integer pageIndex,
-							Integer a_id ,Integer pageSize, Model model) {
+							Integer a_id, Integer pageSize, Model model) {
-
+
-		PageInfo<Admin> ai = adminService.findPageInfo(a_username,a_describe,
+		// 调用AdminService的findPageInfo方法，传入相应的筛选参数，获取包含分页后的管理员信息的PageInfo对象
-								a_id,pageIndex,pageSize);
+		PageInfo<Admin> ai = adminService.findPageInfo(a_username, a_describe,
-		model.addAttribute("ai",ai);
+				a_id, pageIndex, pageSize);
+		// 将包含管理员信息的PageInfo对象存入Model中，以便传递给视图（如"admin_list"页面）进行展示
+		model.addAttribute("ai", ai);
+		// 返回"admin_list"视图名称，跳转到展示管理员信息列表的页面
 		return "admin_list";
 	}
 
 	/**
-	 * 导出Excel
+	 * 导出Excel的方法
+	 * 该方法接收POST请求，使用@ResponseBody注解表示返回的数据会直接作为响应体内容，通常以JSON等格式返回给客户端（此处返回管理员列表数据）
+	 * 主要功能是获取所有管理员信息，以便后续进行Excel文件生成等相关导出操作
 	 */
-	@RequestMapping(value = "/exportadminlist" , method = RequestMethod.POST)
+	@RequestMapping(value = "/exportadminlist", method = RequestMethod.POST)
-    @ResponseBody
+	@ResponseBody
-	public List<Admin> exportAdmin(){
+	public List<Admin> exportAdmin() {
+		// 调用AdminService的getAll方法获取所有管理员信息的列表
 		List<Admin> admin = adminService.getAll();
+		// 返回管理员信息列表，便于后续进行Excel文件生成等相关操作
 		return admin;
 	}
 
 	/**
-	 * 添加管理员信息
+	 * 添加管理员信息的方法
+	 * 接收一个包含管理员信息的Admin对象（通过@RequestBody注解从请求体中获取JSON等格式数据并转换为Admin对象），对密码进行MD5加密后，调用业务层方法进行添加操作，然后返回视图名称"admin_list"
 	 */
-	@RequestMapping(value = "/addAdmin" ,method = RequestMethod.POST)
+	@RequestMapping(value = "/addAdmin", method = RequestMethod.POST)
 	@ResponseBody
-	public String addAdmin( @RequestBody Admin admin) {
+	public String addAdmin(@RequestBody Admin admin) {
 
+		// 对要添加的管理员对象中的密码进行MD5加密处理，保证密码存储的安全性
 		admin.setA_password(MD5Util.MD5EncodeUtf8(admin.getA_password()));
+		// 调用AdminService的addAdmin方法，传入加密后密码的Admin对象，执行添加管理员信息到数据库等存储介质的操作
 		int a = adminService.addAdmin(admin);
+		// 返回视图名称"admin_list"，用于页面刷新等操作，展示添加后的管理员信息列表情况
 		return "admin_list";
 	}
 
 	/**
-	 * 删除管理员信息；将请求体a_id写入参数a_id
+	 * 删除管理员信息的方法
+	 * 接收要删除的管理员的ID作为参数，调用业务层方法进行删除操作，并返回视图名称"admin_list"
+	 * 此方法会将请求体中的a_id参数写入对应的参数变量a_id中，用于指定要删除的管理员记录
 	 */
-	@RequestMapping( "/deleteAdmin")
+	@RequestMapping("/deleteAdmin")
 	@ResponseBody
 	public String deleteAdmin(Integer a_id) {
+		// 调用AdminService的deleteAdmin方法，传入要删除的管理员ID，执行删除操作
 		int a = adminService.deleteAdmin(a_id);
+		// 返回视图名称"admin_list"，可能用于页面刷新等操作，展示删除后的管理员信息列表情况
 		return "admin_list";
 	}
 
 	/**
-	 * 修改管理员信息
+	 * 修改管理员信息的方法
+	 * 接收包含修改后管理员信息的Admin对象，对密码进行MD5加密后，调用业务层方法进行更新操作，更新成功后重定向到分页查询管理员信息的方法对应的请求路径（"/findAdmin"），以便刷新页面展示最新的管理员信息列表
+	 * 此方法会将提交的包含管理员相关信息（如ID、用户名等）的数据写入Admin对象中，用于后续的更新操作
 	 */
-	/**
+	@RequestMapping(value = "/updateAdmin", method = RequestMethod.POST)
-	 * 将提交数据(a_id,a_username...)写入Admin对象
-	 */
-	@RequestMapping( value = "/updateAdmin", method = RequestMethod.POST)
 	public String updateAdmin(Admin admin) {
 
+		// 对修改后的管理员对象中的密码进行MD5加密处理，保证密码存储的安全性
 		admin.setA_password(MD5Util.MD5EncodeUtf8(admin.getA_password()));
+		// 调用AdminService的updateAdmin方法，传入加密后密码的Admin对象，执行更新管理员信息到数据库等存储介质的操作
 		int a = adminService.updateAdmin(admin);
+		// 返回重定向的路径"/findAdmin"，实现页面刷新展示更新后的管理员信息
 		return "redirect:/findAdmin";
 	}
 
 
 	/**
-	 * 根据管理员Id搜索;将请求数据a_id写入参数a_id
+	 * 根据管理员Id搜索管理员信息的方法
+	 * 接收要查询的管理员的ID作为参数，调用业务层方法进行查询操作，将查询到的管理员信息存入HttpSession中，方便在后续的操作中（比如在不同请求之间共享数据）使用，然后返回视图名称"admin_edit"，可能用于展示管理员信息以便进行编辑等操作
+	 * 此方法会将请求数据中的a_id参数写入对应的参数变量a_id中，用于指定要查询的管理员记录
 	 */
-	@RequestMapping( "/findAdminById")
+	@RequestMapping("/findAdminById")
-	public String findAdminById( Integer a_id,HttpSession session) {
+	public String findAdminById(Integer a_id, HttpSession session) {
-		Admin a= adminService.findAdminById(a_id);
+		// 调用AdminService的findAdminById方法，传入要查询的管理员ID，执行查询操作
-		session.setAttribute("a",a);
+		Admin a = adminService.findAdminById(a_id);
+		// 将查询到的管理员信息存入HttpSession中，便于后续在编辑等相关页面获取该管理员数据
+		session.setAttribute("a", a);
+		// 返回视图名称"admin_edit"，用于展示管理员详细信息，可能是编辑页面等
 		return "admin_edit";
 	}
-
+}
-}

src/com/itheima/controller/ClassController.java

@@ -1,6 +1,5 @@
 package com.itheima.controller;
 
-
 import com.itheima.po.Class;
 import com.itheima.po.PageInfo;
 import com.itheima.service.ClassService;
@@ -16,44 +15,58 @@ import javax.servlet.http.HttpSession;
 import java.util.List;
 
 /**
- * 用户控制器类
+ * 用户控制器类，用于处理与班级相关的各种业务请求，如查询、添加、删除、修改等操作，并和相应的视图进行交互
  */
 @Controller
 public class ClassController {
-	// 依赖注入
+
+	// 依赖注入，通过Spring框架自动装配ClassService的实例，方便在本类中调用其提供的业务方法
 	@Autowired
 	private ClassService classService;
 
 	/**
-	 * 分页查询
+	 * 分页查询班级信息的方法
-	 * pageIndex 当前页码
+	 *
-	 * pageSize  显示条数
+	 * @param c_classid 班级ID，用于精确查询指定班级，可为null表示不按此条件筛选
+	 * @param c_classname 班级名称，用于模糊查询匹配名称的班级，可为null表示不按此条件筛选
+	 * @param c_counsellor 辅导员信息，用于模糊查询匹配辅导员的班级，可为null表示不按此条件筛选
+	 * @param pageIndex 当前页码，用于确定要显示的页面
+	 * @param pageSize  显示条数，即每页显示的记录数量
+	 * @param model Spring框架的Model对象，用于向视图传递数据
+	 * @return 返回视图名称 "class_list"，该视图会展示分页查询后的班级信息列表
 	 */
 	@RequestMapping(value = "/findClass")
 	public String findClass(Integer c_classid, String c_classname, String c_counsellor,
 							Integer pageIndex, Integer pageSize, Model model) {
 
-	  PageInfo<Class> ci = classService.findPageInfo(c_classname,c_counsellor,
+		PageInfo<Class> ci = classService.findPageInfo(c_classname, c_counsellor,
-			  c_classid,pageIndex,pageSize);
+				c_classid, pageIndex, pageSize);
-	  model.addAttribute("ci",ci);
+		model.addAttribute("ci", ci);
-	  model.addAttribute("c_classid",c_classid);
+		model.addAttribute("c_classid", c_classid);
 		return "class_list";
 	}
 
 	/**
-	 * 导出Excel
+	 * 导出Excel的方法，将班级信息导出为Excel文件
+	 * 此方法接收POST请求，使用@ResponseBody注解表示返回的数据会直接作为响应体内容，通常以JSON等格式返回给客户端（此处返回班级列表数据）
+	 *
+	 * @return 返回班级信息的列表，便于后续进行Excel文件生成等相关操作
 	 */
 	@RequestMapping(value = "/exportclasslist", method = RequestMethod.POST)
 	@ResponseBody
-	public List<Class> exportClass(){
+	public List<Class> exportClass() {
 		List<Class> classList = classService.getAll();
 		return classList;
 	}
 
 	/**
-	 * 删除学生信息
+	 * 删除班级信息的方法
+	 * 接收要删除的班级的ID作为参数，调用业务层方法进行删除操作，并返回视图名称 "class_list"
+	 *
+	 * @param c_id 要删除的班级的唯一标识ID
+	 * @return 返回视图名称 "class_list"，可能用于页面刷新等操作，展示删除后的班级信息列表情况
 	 */
-	@RequestMapping( "/deleteClass")
+	@RequestMapping("/deleteClass")
 	@ResponseBody
 	public String deleteClass(Integer c_id) {
 		int c = classService.deleteClass(c_id);
@@ -61,47 +74,67 @@ public class ClassController {
 	}
 
 	/**
-	 * 添加班级信息
+	 * 添加班级信息的方法
+	 * 接收一个包含班级信息的Class对象（通过@RequestBody注解从请求体中获取JSON等格式数据并转换为Class对象），调用业务层方法进行添加操作，然后返回视图名称 "class_list"
+	 *
+	 * @param uclass 包含要添加的班级详细信息的对象
+	 * @return 返回视图名称 "class_list"，用于页面刷新等操作，展示添加后的班级信息列表情况
 	 */
-	@RequestMapping(value = "/addClass" ,method = RequestMethod.POST)
+	@RequestMapping(value = "/addClass", method = RequestMethod.POST)
 	@ResponseBody
-	public String addClass( @RequestBody Class uclass) {
+	public String addClass(@RequestBody Class uclass) {
 		int c = classService.addClass(uclass);
 		return "class_list";
 	}
 
-	@RequestMapping( "/findClassById")
+	/**
-	public String findClassById( Integer c_id,HttpSession session) {
+	 * 根据班级ID查询班级信息的方法
-		Class c= classService.findClassById(c_id);
+	 * 将查询到的班级信息存入HttpSession中，方便在后续的操作中（比如在不同请求之间共享数据）使用，然后返回视图名称 "class_edit"，可能用于展示班级信息以便进行编辑等操作
-		session.setAttribute("c",c);
+	 *
+	 * @param c_id 要查询的班级的唯一标识ID
+	 * @param session HttpSession对象，用于存储和获取会话相关的数据
+	 * @return 返回视图名称 "class_edit"，用于展示班级详细信息，可能是编辑页面等
+	 */
+	@RequestMapping("/findClassById")
+	public String findClassById(Integer c_id, HttpSession session) {
+		Class c = classService.findClassById(c_id);
+		session.setAttribute("c", c);
 		return "class_edit";
 	}
 
 	/**
-	 * 修改班级信息
+	 * 修改班级信息的方法
+	 * 接收包含修改后班级信息的Class对象，调用业务层方法进行更新操作，更新成功后重定向到分页查询班级信息的方法对应的请求路径（"/findClass"），以便刷新页面展示最新的班级信息列表
+	 *
+	 * @param uclass 包含修改后的班级详细信息的对象
+	 * @return 返回重定向的路径 "/findClass"，实现页面刷新展示更新后的班级信息
 	 */
-	@RequestMapping(value = "/updateClass" ,method = RequestMethod.POST)
+	@RequestMapping(value = "/updateClass", method = RequestMethod.POST)
-
+	public String updateClass(Class uclass) {
-	public String updateClass( Class uclass) {
 		int c = classService.updateClass(uclass);
 		return "redirect:/findClass";
 	}
 
 	/**
-	 * 班级人员信息查询
+	 * 班级人员信息查询的方法
+	 * 查询指定班级的人员信息，将查询到的班级人员信息列表存入Model对象中，以便传递给视图进行展示，最后返回视图名称 "class_Studentlist"
+	 *
+	 * @param uclass 包含班级相关筛选条件等信息的对象，可用于精确查询某个班级的人员信息
+	 * @param model Spring框架的Model对象，用于向视图传递数据
+	 * @return 返回视图名称 "class_Studentlist"，用于展示班级人员信息列表
 	 */
 	@RequestMapping(value = "/findClassStudent")
-	public String findClassStudent(Class uclass,Model model) {
+	public String findClassStudent(Class uclass, Model model) {
 		List<Class> c = classService.findClassStudent(uclass);
-		model.addAttribute("cs",c);
+		model.addAttribute("cs", c);
 		return "class_Studentlist";
 	}
 
-	//采用Ajax来提交表单，并返回JSON数据
+	// 采用Ajax来提交表单，并返回JSON数据
-//	@RequestMapping(value = "/findClassStudentlist",method = RequestMethod.POST)
+	// @RequestMapping(value = "/findClassStudentlist", method = RequestMethod.POST)
-//	@ResponseBody
+	// @ResponseBody
-//	public List<Class> findClassStudentlist(@RequestBody Class uclass){
+	// public List<Class> findClassStudentlist(@RequestBody Class uclass) {
-//		List<Class> c = classService.findClassStudent(uclass);
+	//     List<Class> c = classService.findClassStudent(uclass);
-//		return c;
+	//     return c;
-//	}
+	// }
-}
+}

src/com/itheima/controller/DormCleanController.java

@@ -18,7 +18,7 @@ import java.util.List;
 
 /**
  * @program: dormitorySystem
- * @description: 宿舍卫生控制器
+ * @description: 宿舍卫生控制器，用于处理与宿舍卫生相关的各类业务操作，例如查询、添加、删除、修改等，并且和对应的视图进行交互。
  * @author: Joyrocky
  * @create: 2019-04-24 11:19
  **/
@@ -26,73 +26,106 @@ import java.util.List;
 @Controller
 public class DormCleanController {
 
-    //依赖注入
+    // 依赖注入，通过Spring框架自动装配DormCleanService的实例，方便在本类中调用其提供的业务方法来处理宿舍卫生相关业务逻辑。
     @Autowired
     private DormCleanService dormCleanService;
 
     /**
-     * 分页查询
+     * 分页查询宿舍卫生信息的方法
-     * pageIndex 当前页码
+     *
-     * pageSize  显示条数
+     * @param d_id 宿舍卫生记录的唯一标识ID（可为null，用于根据具体ID精确筛选记录，若为null则不按此条件筛选）。
+     * @param d_dormbuilding 宿舍楼栋信息（可为null，用于模糊或精确筛选对应楼栋的宿舍卫生记录，若为null则不按此条件筛选）。
+     * @param pageIndex 当前页码，用于确定要显示的页面，比如pageIndex为1表示显示第一页数据。
+     * @param pageSize  显示条数，即每页显示的宿舍卫生记录数量，例如pageSize为10表示每页展示10条记录。
+     * @param model Spring框架的Model对象，用于向视图传递数据，如将查询到的宿舍卫生信息传递给视图进行展示。
+     * @return 返回视图名称 "dormclean_list"，该视图会展示分页查询后的宿舍卫生信息列表。
      */
     @RequestMapping(value = "/findDormClean")
-    public String findDormClean(Integer d_id,String d_dormbuilding,
+    public String findDormClean(Integer d_id, String d_dormbuilding,
                                 Integer pageIndex, Integer pageSize, Model model) {
 
-        PageInfo<DormClean> di = dormCleanService.findPageInfo(d_id,d_dormbuilding,
+        // 调用DormCleanService的findPageInfo方法，传入相应的筛选参数，获取包含分页后的宿舍卫生信息的PageInfo对象。
-                                            pageIndex,pageSize);
+        PageInfo<DormClean> di = dormCleanService.findPageInfo(d_id, d_dormbuilding,
-        model.addAttribute("di",di);
+                pageIndex, pageSize);
+        // 将包含宿舍卫生信息的PageInfo对象存入Model中，以便传递给视图（如"dormclean_list"页面）进行展示。
+        model.addAttribute("di", di);
         return "dormclean_list";
     }
 
     /**
-     * 导出Excel
+     * 导出Excel的方法，将宿舍卫生信息导出为Excel文件。
+     * 此方法接收POST请求，使用@ResponseBody注解表示返回的数据会直接作为响应体内容，通常以JSON等格式返回给客户端（此处返回宿舍卫生信息列表数据）。
+     *
+     * @return 返回宿舍卫生信息的列表，便于后续进行Excel文件生成等相关操作。
      */
     @RequestMapping(value = "/exportdormcleanlist", method = RequestMethod.POST)
     @ResponseBody
-    public List<DormClean> exportDormclean(){
+    public List<DormClean> exportDormclean() {
+        // 调用DormCleanService的getAll方法获取所有宿舍卫生信息的列表。
         List<DormClean> dormclean = dormCleanService.getAll();
         return dormclean;
     }
 
     /**
-     * 添加宿舍卫生信息
+     * 添加宿舍卫生信息的方法
+     * 接收一个包含宿舍卫生详细信息的DormClean对象（通过@RequestBody注解从请求体中获取JSON等格式数据并转换为DormClean对象），调用业务层方法进行添加操作，然后返回视图名称 "dormclean_list"。
+     *
+     * @param dormclean 包含要添加的宿舍卫生详细信息的对象，例如宿舍编号、打扫时间、卫生情况等信息。
+     * @return 返回视图名称 "dormclean_list"，用于页面刷新等操作，展示添加后的宿舍卫生信息列表情况。
      */
-    @RequestMapping(value = "/addDormClean" ,method = RequestMethod.POST)
+    @RequestMapping(value = "/addDormClean", method = RequestMethod.POST)
     @ResponseBody
-    public String addDormClean( @RequestBody DormClean dormclean) {
+    public String addDormClean(@RequestBody DormClean dormclean) {
+        // 调用DormCleanService的addDormClean方法，传入包含宿舍卫生信息的DormClean对象，执行添加宿舍卫生信息到数据库等存储介质的操作。
         int d = dormCleanService.addDormClean(dormclean);
         return "dormclean_list";
     }
 
     /**
-     * 删除宿舍卫生信息
+     * 删除宿舍卫生信息的方法
+     * 接收要删除的宿舍卫生记录的ID作为参数，调用业务层方法进行删除操作，并返回视图名称 "dormclean_list"。
+     *
+     * @param g_id 要删除的宿舍卫生记录的唯一标识ID。
+     * @return 返回视图名称 "dormclean_list"，可能用于页面刷新等操作，展示删除后的宿舍卫生信息列表情况。
      */
-    @RequestMapping( "/deleteDormClean")
+    @RequestMapping("/deleteDormClean")
     @ResponseBody
     public String deleteDormClean(Integer g_id) {
+        // 调用DormCleanService的deleteDormClean方法，传入要删除的宿舍卫生记录ID，执行删除操作。
         int d = dormCleanService.deleteDormClean(g_id);
         return "dormclean_list";
     }
 
     /**
-     * 修改宿舍卫生信息
+     * 修改宿舍卫生信息的方法
+     * 接收包含修改后宿舍卫生信息的DormClean对象，调用业务层方法进行更新操作，更新成功后重定向到分页查询宿舍卫生信息的方法对应的请求路径（"/findDormClean"），以便刷新页面展示最新的宿舍卫生信息列表。
+     *
+     * @param dormclean 包含修改后的宿舍卫生详细信息的对象，例如更新后的打扫时间、卫生评价等信息。
+     * @return 返回重定向的路径 "/findDormClean"，实现页面刷新展示更新后的宿舍卫生信息。
      */
-    @RequestMapping( "/updateDormClean")
+    @RequestMapping("/updateDormClean")
-    public String updateDormClean( DormClean dormclean) {
+    public String updateDormClean(DormClean dormclean) {
+        // 调用DormCleanService的updateDormClean方法，传入包含修改后宿舍卫生信息的DormClean对象，执行更新宿舍卫生信息到数据库等存储介质的操作。
         int d = dormCleanService.updateDormClean(dormclean);
         return "redirect:/findDormClean";
     }
 
 
-    @RequestMapping( "/findDormCleanById")
+    /**
+     * 根据宿舍卫生记录ID查询宿舍卫生信息的方法
+     * 将查询到的宿舍卫生信息存入HttpSession中，方便在后续的操作中（比如在不同请求之间共享数据）使用，然后返回视图名称 "dormclean_edit"，可能用于展示宿舍卫生信息以便进行编辑等操作。
+     *
+     * @param g_id 要查询的宿舍卫生记录的唯一标识ID。
+     * @param session HttpSession对象，用于存储和获取会话相关的数据，如将查询到的宿舍卫生记录暂存于此，供后续编辑页面获取使用。
+     * @return 返回视图名称 "dormclean_edit"，用于展示宿舍卫生详细信息，可能是编辑页面等。
+     */
+    @RequestMapping("/findDormCleanById")
     public String findDormCleanById(Integer g_id, HttpSession session) {
 
-        DormClean d= dormCleanService.findDormCleanById(g_id);
+        DormClean d = dormCleanService.findDormCleanById(g_id);
-        session.setAttribute("d",d);
+        session.setAttribute("d", d);
         return "dormclean_edit";
     }
 
 
-}
+}
-

src/com/itheima/controller/DormRepairController.java

@@ -17,79 +17,113 @@ import java.util.List;
 
 /**
  * @program: dormitorySystem
- * @description: 维修登记
+ * @description: 维修登记，该控制器类主要用于处理宿舍维修相关的各种业务操作，比如查询维修记录、导出维修记录、添加、删除、修改维修信息等，并与相应的视图进行交互。
  * @author: Joyrocky
  * @create: 2019-04-27 17:13
  **/
 @Controller
 public class DormRepairController {
-    // 依赖注入
+
+    // 依赖注入，通过Spring框架自动装配DormRepairService的实例，方便后续在本类中调用其提供的业务方法，以此来处理宿舍维修相关的具体业务逻辑。
     @Autowired
     private DormRepairService dormRepairService;
 
     /**
-     * 分页查询
+     * 分页查询宿舍维修记录的方法
-     * pageIndex 当前页码
+     *
-     * pageSize  显示条数
+     * @param d_id 维修记录的唯一标识ID（可为null，用于根据具体ID精确筛选维修记录，若为null则不按此条件筛选）。
+     * @param d_dormbuilding 宿舍楼栋信息（可为null，用于模糊或精确筛选对应楼栋的维修记录，若为null则不按此条件筛选）。
+     * @param pageIndex 当前页码，用于确定要显示的页面，例如pageIndex为1表示显示第一页的维修记录信息。
+     * @param pageSize  显示条数，即每页显示的维修记录数量，比如pageSize为10表示每页展示10条维修记录信息。
+     * @param model Spring框架的Model对象，用于向视图传递数据，像将查询到的维修记录信息传递给视图进行展示。
+     * @return 返回视图名称 "dormrepair_list"，该视图会展示分页查询后的宿舍维修记录信息列表。
      */
     @RequestMapping(value = "/findDormRepair")
-    public String findDormRepair(Integer d_id,String d_dormbuilding,
+    public String findDormRepair(Integer d_id, String d_dormbuilding,
                                  Integer pageIndex, Integer pageSize, Model model) {
 
-        PageInfo<DormRepair> di = dormRepairService.findPageInfo(d_id,d_dormbuilding,
+        // 调用DormRepairService的findPageInfo方法，传入相应的筛选参数，获取包含分页后的宿舍维修记录信息的PageInfo对象。
-                                                    pageIndex,pageSize);
+        PageInfo<DormRepair> di = dormRepairService.findPageInfo(d_id, d_dormbuilding,
-        model.addAttribute("di",di);
+                pageIndex, pageSize);
+        // 将包含维修记录信息的PageInfo对象存入Model中，以便传递给视图（如"dormrepair_list"页面）进行展示。
+        model.addAttribute("di", di);
         return "dormrepair_list";
     }
 
     /**
-     * 导出Excel
+     * 导出Excel的方法，用于将宿舍维修记录信息导出为Excel文件。
+     * 此方法接收POST请求，使用@ResponseBody注解表示返回的数据会直接作为响应体内容，通常以JSON等格式返回给客户端（此处返回维修记录信息列表数据）。
+     *
+     * @return 返回宿舍维修记录信息的列表，便于后续进行Excel文件生成等相关操作。
      */
     @RequestMapping(value = "/exportdormrepairlist", method = RequestMethod.POST)
     @ResponseBody
-    public List<DormRepair> exportDormrepair(){
+    public List<DormRepair> exportDormrepair() {
+        // 调用DormRepairService的getAll方法获取所有宿舍维修记录信息的列表。
         List<DormRepair> dormRepairList = dormRepairService.getAll();
         return dormRepairList;
     }
 
 
     /**
-     * 添加宿舍信息
+     * 添加宿舍维修信息的方法
+     * 接收一个包含宿舍维修详细信息的DormRepair对象（通过@RequestBody注解从请求体中获取JSON等格式数据并转换为DormRepair对象），调用业务层方法进行添加操作，然后返回视图名称 "dormrepair_list"。
+     *
+     * @param dormrepair 包含要添加的宿舍维修详细信息的对象，例如维修的宿舍编号、维修项目、报修时间等信息。
+     * @return 返回视图名称 "dormrepair_list"，用于页面刷新等操作，展示添加后的宿舍维修信息列表情况。
      */
-    @RequestMapping(value = "/addDormRepair" ,method = RequestMethod.POST)
+    @RequestMapping(value = "/addDormRepair", method = RequestMethod.POST)
     @ResponseBody
-    public String addDormitory( @RequestBody DormRepair dormrepair) {
+    public String addDormitory(@RequestBody DormRepair dormrepair) {
+        // 调用DormRepairService的addDormRepair方法，传入包含宿舍维修信息的DormRepair对象，执行添加宿舍维修信息到数据库等存储介质的操作。
         int d = dormRepairService.addDormRepair(dormrepair);
         return "dormrepair_list";
     }
 
     /**
-     * 删除宿舍信息
+     * 删除宿舍维修信息的方法
+     * 接收要删除的宿舍维修记录的ID作为参数，调用业务层方法进行删除操作，并返回视图名称 "dormrepair_list"。
+     *
+     * @param r_id 要删除的宿舍维修记录的唯一标识ID。
+     * @return 返回视图名称 "dormrepair_list"，可能用于页面刷新等操作，展示删除后的宿舍维修信息列表情况。
      */
-    @RequestMapping( "/deleteDormRepair")
+    @RequestMapping("/deleteDormRepair")
     @ResponseBody
     public String deleteDormRepair(Integer r_id) {
+        // 调用DormRepairService的deleteDormRepair方法，传入要删除的宿舍维修记录ID，执行删除操作。
         int d = dormRepairService.deleteDormRepair(r_id);
         return "dormrepair_list";
     }
 
     /**
-     * 修改学生信息
+     * 修改宿舍维修信息的方法
+     * 接收包含修改后宿舍维修信息的DormRepair对象，调用业务层方法进行更新操作，更新成功后重定向到分页查询宿舍维修记录的方法对应的请求路径（"/findDormRepair"），以便刷新页面展示最新的宿舍维修信息列表。
+     *
+     * @param dormrepair 包含修改后的宿舍维修详细信息的对象，例如更新后的维修进度、维修完成时间等信息。
+     * @return 返回重定向的路径 "/findDormRepair"，实现页面刷新展示更新后的宿舍维修信息。
      */
-    @RequestMapping( "/updateDormRepair")
+    @RequestMapping("/updateDormRepair")
-    public String updateDormRepair( DormRepair dormrepair) {
+    public String updateDormRepair(DormRepair dormrepair) {
+        // 调用DormRepairService的updateDormRepair方法，传入包含修改后宿舍维修信息的DormRepair对象，执行更新宿舍维修信息到数据库等存储介质的操作。
         int d = dormRepairService.updateDormRepair(dormrepair);
         return "redirect:/findDormRepair";
     }
 
 
-    @RequestMapping( "/findDormRepairById")
+    /**
+     * 根据宿舍维修记录ID查询宿舍维修信息的方法
+     * 将查询到的宿舍维修信息存入HttpSession中，方便在后续的操作中（比如在不同请求之间共享数据）使用，然后返回视图名称 "dormrepair_edit"，可能用于展示宿舍维修信息以便进行编辑等操作。
+     *
+     * @param r_id 要查询的宿舍维修记录的唯一标识ID。
+     * @param session HttpSession对象，用于存储和获取会话相关的数据，如将查询到的宿舍维修信息暂存于此，供后续编辑页面获取使用。
+     * @return 返回视图名称 "dormrepair_edit"，用于展示宿舍维修详细信息，可能是编辑页面等。
+     */
+    @RequestMapping("/findDormRepairById")
     public String findDormRepairById(Integer r_id, HttpSession session) {
 
-        DormRepair d= dormRepairService.findDormRepairById(r_id);
+        DormRepair d = dormRepairService.findDormRepairById(r_id);
-        session.setAttribute("d",d);
+        session.setAttribute("d", d);
         return "dormrepair_edit";
     }
 
-}
+}
-

src/com/itheima/controller/DormitoryController.java

@@ -1,7 +1,5 @@
 package com.itheima.controller;
 
-
-
 import com.itheima.po.Dormitory;
 import com.itheima.po.PageInfo;
 import com.itheima.service.DormitoryService;
@@ -17,86 +15,129 @@ import javax.servlet.http.HttpSession;
 import java.util.List;
 
 /**
- * 用户控制器类
+ * 用户控制器类，主要负责处理与宿舍相关的各类业务操作，比如查询宿舍信息、添加、删除、修改宿舍信息以及查询宿舍人员信息等，并且与相应的视图进行交互。
  */
 @Controller
 public class DormitoryController {
-	// 依赖注入
+
+	// 依赖注入，通过Spring框架自动装配DormitoryService的实例，方便后续在本类中调用其提供的业务方法，来处理具体的宿舍业务逻辑。
 	@Autowired
 	private DormitoryService dormitoryService;
 
 	/**
-	 * 分页查询
+	 * 分页查询宿舍信息的方法
-	 * pageIndex 当前页码
+	 *
-	 * pageSize  显示条数
+	 * @param a_name 宿舍相关的名称属性（具体含义可能根据业务而定，可为null，用于根据名称进行模糊或精确筛选宿舍记录，若为null则不按此条件筛选）。
+	 * @param s_dormitoryid 宿舍的唯一标识ID（可为null，用于根据具体ID精确筛选宿舍记录，若为null则不按此条件筛选）。
+	 * @param d_dormbuilding 宿舍楼栋信息（可为null，用于模糊或精确筛选对应楼栋的宿舍记录，若为null则不按此条件筛选）。
+	 * @param pageIndex 当前页码，用于确定要显示的页面，比如pageIndex为1表示显示第一页的宿舍信息。
+	 * @param pageSize  显示条数，即每页显示的宿舍记录数量，例如pageSize为10表示每页展示10条宿舍信息。
+	 * @param model Spring框架的Model对象，用于向视图传递数据，比如将查询到的宿舍信息传递给视图进行展示。
+	 * @return 返回视图名称 "dormitory_list"，该视图会展示分页查询后的宿舍信息列表。
 	 */
 	@RequestMapping(value = "/findDormitory")
-	public String findDormitory(String a_name,Integer s_dormitoryid,String d_dormbuilding,
+	public String findDormitory(String a_name, Integer s_dormitoryid, String d_dormbuilding,
 								Integer pageIndex, Integer pageSize, Model model) {
 
-	  PageInfo<Dormitory> di = dormitoryService.findPageInfo(a_name,s_dormitoryid,
+		// 调用DormitoryService的findPageInfo方法，传入相应的筛选参数，获取包含分页后的宿舍信息的PageInfo对象。
-			  d_dormbuilding,pageIndex,pageSize);
+		PageInfo<Dormitory> di = dormitoryService.findPageInfo(a_name, s_dormitoryid,
-	  model.addAttribute("di",di);
+				d_dormbuilding, pageIndex, pageSize);
+		// 将包含宿舍信息的PageInfo对象存入Model中，以便传递给视图（如"dormitory_list"页面）进行展示。
+		model.addAttribute("di", di);
 		return "dormitory_list";
 	}
 
 	/**
-	 * 导出Excel
+	 * 导出Excel的方法，用于将宿舍信息导出为Excel文件。
+	 * 此方法接收POST请求，使用@ResponseBody注解表示返回的数据会直接作为响应体内容，通常以JSON等格式返回给客户端（此处返回宿舍信息列表数据）。
+	 *
+	 * @return 返回宿舍信息的列表，便于后续进行Excel文件生成等相关操作。
 	 */
 	@RequestMapping(value = "/exportdormitorylist", method = RequestMethod.POST)
 	@ResponseBody
-	public List<Dormitory> exportDormitory(){
+	public List<Dormitory> exportDormitory() {
+		// 调用DormitoryService的getAll方法获取所有宿舍信息的列表。
 		List<Dormitory> dormitoryList = dormitoryService.getAll();
 		return dormitoryList;
 	}
 
 	/**
-	 * 添加宿舍信息
+	 * 添加宿舍信息的方法
+	 * 接收一个包含宿舍详细信息的Dormitory对象（通过@RequestBody注解从请求体中获取JSON等格式数据并转换为Dormitory对象），调用业务层方法进行添加操作，然后返回视图名称 "dormitory_list"。
+	 *
+	 * @param dormitory 包含要添加的宿舍详细信息的对象，例如宿舍编号、可容纳人数、所属楼栋等信息。
+	 * @return 返回视图名称 "dormitory_list"，用于页面刷新等操作，展示添加后的宿舍信息列表情况。
 	 */
-	@RequestMapping(value = "/addDormitory" ,method = RequestMethod.POST)
+	@RequestMapping(value = "/addDormitory", method = RequestMethod.POST)
 	@ResponseBody
-	public String addDormitory( @RequestBody Dormitory dormitory) {
+	public String addDormitory(@RequestBody Dormitory dormitory) {
+		// 调用DormitoryService的addDormitory方法，传入包含宿舍信息的Dormitory对象，执行添加宿舍信息到数据库等存储介质的操作。
 		int d = dormitoryService.addDormitory(dormitory);
 		return "dormitory_list";
 	}
 
 	/**
-	 * 删除宿舍信息
+	 * 删除宿舍信息的方法
+	 * 接收要删除的宿舍的ID作为参数，调用业务层方法进行删除操作，并返回视图名称 "dormitory_list"。
+	 *
+	 * @param d_id 要删除的宿舍的唯一标识ID。
+	 * @return 返回视图名称 "dormitory_list"，可能用于页面刷新等操作，展示删除后的宿舍信息列表情况。
 	 */
-	@RequestMapping( "/deleteDormitory")
+	@RequestMapping("/deleteDormitory")
 	@ResponseBody
 	public String deleteDormitory(Integer d_id) {
+		// 调用DormitoryService的deleteDormitory方法，传入要删除的宿舍ID，执行删除操作。
 		int d = dormitoryService.deleteDormitory(d_id);
 		return "dormitory_list";
 	}
 
 	/**
-	 * 修改学生信息
+	 * 修改宿舍信息的方法
+	 * 接收包含修改后宿舍信息的Dormitory对象，调用业务层方法进行更新操作，更新成功后重定向到分页查询宿舍信息的方法对应的请求路径（"/findDormitory"），以便刷新页面展示最新的宿舍信息列表。
+	 *
+	 * @param dormitory 包含修改后的宿舍详细信息的对象，例如更新后的宿舍可容纳人数、宿舍设施情况等信息。
+	 * @return 返回重定向的路径 "/findDormitory"，实现页面刷新展示更新后的宿舍信息。
 	 */
-	@RequestMapping( "/updateDormitory")
+	@RequestMapping("/updateDormitory")
-	public String updateDormitory( Dormitory dormitory) {
+	public String updateDormitory(Dormitory dormitory) {
+		// 调用DormitoryService的updateDormitory方法，传入包含修改后宿舍信息的Dormitory对象，执行更新宿舍信息到数据库等存储介质的操作。
 		int d = dormitoryService.updateDormitory(dormitory);
 		return "redirect:/findDormitory";
 	}
 
 
-	@RequestMapping( "/findDormitoryById")
+	/**
-	public String findDormitoryById(Integer d_id,HttpSession session) {
+	 * 根据宿舍ID查询宿舍信息的方法
+	 * 将查询到的宿舍信息存入HttpSession中，方便在后续的操作中（比如在不同请求之间共享数据）使用，然后返回视图名称 "dormitory_edit"，可能用于展示宿舍信息以便进行编辑等操作。
+	 *
+	 * @param d_id 要查询的宿舍的唯一标识ID。
+	 * @param session HttpSession对象，用于存储和获取会话相关的数据，如将查询到的宿舍信息暂存于此，供后续编辑页面获取使用。
+	 * @return 返回视图名称 "dormitory_edit"，用于展示宿舍详细信息，可能是编辑页面等。
+	 */
+	@RequestMapping("/findDormitoryById")
+	public String findDormitoryById(Integer d_id, HttpSession session) {
 
-		Dormitory d= dormitoryService.findDormitoryById(d_id);
+		Dormitory d = dormitoryService.findDormitoryById(d_id);
-		session.setAttribute("d",d);
+		session.setAttribute("d", d);
 		return "dormitory_edit";
 	}
 
 	/**
-	 * 宿舍人员信息查询
+	 * 宿舍人员信息查询的方法
+	 * 查询指定宿舍的人员信息，将查询到的宿舍人员信息列表存入Model对象中，以便传递给视图进行展示，最后返回视图名称 "dormitory_Studentlist"。
+	 *
+	 * @param dormitory 包含宿舍相关筛选条件等信息的对象，可用于精确查询某个宿舍的人员信息。
+	 * @param model Spring框架的Model对象，用于向视图传递数据。
+	 * @return 返回视图名称 "dormitory_Studentlist"，用于展示宿舍人员信息列表。
 	 */
 	@RequestMapping(value = "/findDormitoryStudent")
-	public String findDormitoryStudent(Dormitory dormitory,Model model) {
+	public String findDormitoryStudent(Dormitory dormitory, Model model) {
+		// 调用DormitoryService的findDormitoryStudent方法，传入包含宿舍相关条件的Dormitory对象，查询对应宿舍的人员信息。
 		List<Dormitory> d = dormitoryService.findDormitoryStudent(dormitory);
-		model.addAttribute("ds",d);
+		// 将查询到的宿舍人员信息列表存入Model中，以便传递给视图进行展示。
+		model.addAttribute("ds", d);
 		return "dormitory_Studentlist";
 	}
 
 
-}
+}

src/com/itheima/controller/StudentCleanController.java

@@ -16,75 +16,110 @@ import java.util.List;
 
 /**
  * @program: dormitorySystem
- * @description: 学生卫生控制器
+ * @description: 学生卫生控制器，该类主要用于处理和学生卫生相关的各类业务操作，例如进行学生卫生信息的分页查询、导出Excel、添加、删除、修改以及根据ID查询等操作，并与相应的视图进行交互。
  * @author: Joyrocky
  * @create: 2019-04-25 12:13
  **/
 @Controller
 public class StudentCleanController {
-    //依赖注入
+
+    // 依赖注入，通过Spring框架自动装配StudentCleanService的实例，方便后续在本类中调用其提供的业务方法，以此来处理学生卫生相关的具体业务逻辑。
     @Autowired
     private StudentCleanService studentCleanService;
 
     /**
-     * 分页查询
+     * 分页查询学生卫生信息的方法
-     * pageIndex 当前页码
+     *
-     * pageSize  显示条数
+     * @param s_studentid 学生的唯一标识ID（可为null，用于根据具体学生ID精确筛选对应的卫生信息记录，若为null则不按此条件筛选）。
+     * @param s_name 学生姓名（可为null，用于根据学生姓名进行模糊或精确筛选卫生信息记录，若为null则不按此条件筛选）。
+     * @param s_dormitoryid 宿舍的唯一标识ID（可为null，用于根据学生所在宿舍ID筛选对应的卫生信息记录，若为null则不按此条件筛选）。
+     * @param pageIndex 当前页码，用于确定要显示的页面，例如pageIndex为1表示显示第一页的学生卫生信息。
+     * @param pageSize  显示条数，即每页显示的学生卫生信息记录数量，比如pageSize为10表示每页展示10条学生卫生信息记录。
+     * @param model Spring框架的Model对象，用于向视图传递数据，像将查询到的学生卫生信息传递给视图进行展示。
+     * @return 返回视图名称 "studentclean_list"，该视图会展示分页查询后的学生卫生信息列表。
      */
     @RequestMapping(value = "/findStudentClean")
     public String findDormClean(Integer s_studentid, String s_name, Integer s_dormitoryid, Integer pageIndex, Integer pageSize, Model model) {
 
-        PageInfo<StudentClean> di = studentCleanService.findPageInfo(s_studentid,s_name,s_dormitoryid,pageIndex,pageSize);
+        // 调用StudentCleanService的findPageInfo方法，传入相应的筛选参数，获取包含分页后的学生卫生信息的PageInfo对象。
-        model.addAttribute("di",di);
+        PageInfo<StudentClean> di = studentCleanService.findPageInfo(s_studentid, s_name, s_dormitoryid, pageIndex, pageSize);
+        // 将包含学生卫生信息的PageInfo对象存入Model中，以便传递给视图（如"studentclean_list"页面）进行展示。
+        model.addAttribute("di", di);
         return "studentclean_list";
     }
 
     /**
-     * 导出Excel
+     * 导出Excel的方法，用于将学生卫生信息导出为Excel文件。
+     * 此方法接收POST请求，使用@ResponseBody注解表示返回的数据会直接作为响应体内容，通常以JSON等格式返回给客户端（此处返回学生卫生信息列表数据）。
+     *
+     * @return 返回学生卫生信息的列表，便于后续进行Excel文件生成等相关操作。
      */
     @RequestMapping(value = "/exportstudentcleanlist", method = RequestMethod.POST)
     @ResponseBody
-    public List<StudentClean> exportStudentclean(){
+    public List<StudentClean> exportStudentclean() {
+        // 调用StudentCleanService的getAll方法获取所有学生卫生信息的列表。
         List<StudentClean> studentCleanList = studentCleanService.getAll();
         return studentCleanList;
     }
 
     /**
-     * 添加宿舍卫生信息
+     * 添加学生卫生信息的方法
+     * 接收一个包含学生卫生详细信息的StudentClean对象（通过@RequestBody注解从请求体中获取JSON等格式数据并转换为StudentClean对象），调用业务层方法进行添加操作，然后返回视图名称 "studentclean_list"。
+     *
+     * @param studentclean 包含要添加的学生卫生详细信息的对象，例如学生打扫的宿舍区域、打扫时间、卫生评价等信息。
+     * @return 返回视图名称 "studentclean_list"，用于页面刷新等操作，展示添加后的学生卫生信息列表情况。
      */
-    @RequestMapping(value = "/addStudentClean" ,method = RequestMethod.POST)
+    @RequestMapping(value = "/addStudentClean", method = RequestMethod.POST)
     @ResponseBody
-    public String addDormClean( @RequestBody StudentClean studentclean) {
+    public String addDormClean(@RequestBody StudentClean studentclean) {
+        // 调用StudentCleanService的addStudentClean方法，传入包含学生卫生信息的StudentClean对象，执行添加学生卫生信息到数据库等存储介质的操作。
         int d = studentCleanService.addStudentClean(studentclean);
         return "studentclean_list";
     }
 
     /**
-     * 删除宿舍卫生信息
+     * 删除学生卫生信息的方法
+     * 接收要删除的学生卫生记录的ID作为参数，调用业务层方法进行删除操作，并返回视图名称 "studentclean_list"。
+     *
+     * @param g_id 要删除的学生卫生记录的唯一标识ID。
+     * @return 返回视图名称 "studentclean_list"，可能用于页面刷新等操作，展示删除后的学生卫生信息列表情况。
      */
-    @RequestMapping( "/deleteStudentClean")
+    @RequestMapping("/deleteStudentClean")
     @ResponseBody
     public String deleteDormClean(Integer g_id) {
+        // 调用StudentCleanService的deleteStudentClean方法，传入要删除的学生卫生记录ID，执行删除操作。
         int d = studentCleanService.deleteStudentClean(g_id);
         return "studentclean_list";
     }
 
     /**
-     * 修改宿舍卫生信息
+     * 修改学生卫生信息的方法
+     * 接收包含修改后学生卫生信息的StudentClean对象，调用业务层方法进行更新操作，更新成功后重定向到分页查询学生卫生信息的方法对应的请求路径（"/findStudentClean"），以便刷新页面展示最新的学生卫生信息列表。
+     *
+     * @param studentclean 包含修改后的学生卫生详细信息的对象，例如更新后的卫生评价、打扫时间等信息。
+     * @return 返回重定向的路径 "/findStudentClean"，实现页面刷新展示更新后的学生卫生信息。
      */
-    @RequestMapping( "/updateStudentClean")
+    @RequestMapping("/updateStudentClean")
-    public String updateDormClean( StudentClean studentclean) {
+    public String updateDormClean(StudentClean studentclean) {
+        // 调用StudentCleanService的updateStudentClean方法，传入包含修改后学生卫生信息的StudentClean对象，执行更新学生卫生信息到数据库等存储介质的操作。
         int d = studentCleanService.updateStudentClean(studentclean);
         return "redirect:/findStudentClean";
     }
 
 
-    @RequestMapping( "/findStudentCleanById")
+    /**
+     * 根据学生卫生记录ID查询学生卫生信息的方法
+     * 将查询到的学生卫生信息存入HttpSession中，方便在后续的操作中（比如在不同请求之间共享数据）使用，然后返回视图名称 "studentclean_edit"，可能用于展示学生卫生信息以便进行编辑等操作。
+     *
+     * @param g_id 要查询的学生卫生记录的唯一标识ID。
+     * @param session HttpSession对象，用于存储和获取会话相关的数据，如将查询到的学生卫生信息暂存于此，供后续编辑页面获取使用。
+     * @return 返回视图名称 "studentclean_edit"，用于展示学生卫生详细信息，可能是编辑页面等。
+     */
+    @RequestMapping("/findStudentCleanById")
     public String findDormCleanById(Integer g_id, HttpSession session) {
 
-        StudentClean d= studentCleanService.findStudentCleanById(g_id);
+        StudentClean d = studentCleanService.findStudentCleanById(g_id);
-        session.setAttribute("d",d);
+        session.setAttribute("d", d);
         return "studentclean_edit";
     }
-}
+}
-

src/com/itheima/controller/StudentController.java

@@ -1,6 +1,5 @@
 package com.itheima.controller;
 
-
 import com.itheima.po.PageInfo;
 import com.itheima.po.Student;
 import com.itheima.service.StudentService;
@@ -15,76 +14,113 @@ import javax.servlet.http.HttpSession;
 import java.util.List;
 
 /**
- * 用户控制器类
+ * 用户控制器类，主要用于处理与学生相关的各种业务操作，例如对学生信息进行分页查询、导出Excel、添加、删除、修改以及根据学生ID查询等操作，并且与相应的视图进行交互。
  */
 @Controller
 public class StudentController {
-	// 依赖注入
+
+	// 依赖注入，通过Spring框架自动装配StudentService的实例，方便后续在本类中调用其提供的业务方法，以此来处理学生相关的具体业务逻辑。
 	@Autowired
 	private StudentService studentService;
 
 	/**
-	 * 分页查询
+	 * 分页查询学生信息的方法
-	 * pageIndex 当前页码
+	 *
-	 * pageSize  显示条数
+	 * @param s_name 学生姓名（可为null，用于根据学生姓名进行模糊或精确筛选学生信息记录，若为null则不按此条件筛选）。
+	 * @param s_studentid 学生的唯一标识ID（可为null，用于根据具体学生ID精确筛选对应的学生信息记录，若为null则不按此条件筛选）。
+	 * @param s_classid 班级的唯一标识ID（可为null，用于根据学生所在班级ID筛选对应的学生信息记录，若为null则不按此条件筛选）。
+	 * @param s_classname 班级名称（可为null，用于根据班级名称进行模糊或精确筛选对应班级里的学生信息记录，若为null则不按此条件筛选）。
+	 * @param pageIndex 当前页码，用于确定要显示的页面，例如pageIndex为1表示显示第一页的学生信息。
+	 * @param pageSize  显示条数，即每页显示的学生信息记录数量，比如pageSize为10表示每页展示10条学生信息记录。
+	 * @param model Spring框架的Model对象，用于向视图传递数据，像将查询到的学生信息传递给视图进行展示。
+	 * @return 返回视图名称 "student_list"，该视图会展示分页查询后的学生信息列表。
 	 */
 	@RequestMapping(value = "/findStudent")
-	public String findStudent(String s_name, Integer s_studentid,Integer s_classid, String s_classname,
+	public String findStudent(String s_name, Integer s_studentid, Integer s_classid, String s_classname,
 							  Integer pageIndex, Integer pageSize, Model model) {
 
-	  PageInfo<Student> pi = studentService.findPageInfo(s_name,s_studentid,s_classid,
+		// 调用StudentService的findPageInfo方法，传入相应的筛选参数，获取包含分页后的学生信息的PageInfo对象。
-			  					s_classname,pageIndex,pageSize);
+		PageInfo<Student> pi = studentService.findPageInfo(s_name, s_studentid, s_classid,
-	  model.addAttribute("pi",pi);
+				s_classname, pageIndex, pageSize);
-	  model.addAttribute("s_name",s_name);
+		// 将包含学生信息的PageInfo对象存入Model中，以便传递给视图（如"student_list"页面）进行展示。
+		model.addAttribute("pi", pi);
+		// 同时也将学生姓名存入Model，可能用于在视图中回显查询条件等操作。
+		model.addAttribute("s_name", s_name);
 		return "student_list";
 	}
 
 	/**
-	 * 导出Excel
+	 * 导出Excel的方法，用于将学生信息导出为Excel文件。
+	 * 此方法接收POST请求，使用@ResponseBody注解表示返回的数据会直接作为响应体内容，通常以JSON等格式返回给客户端（此处返回学生信息列表数据）。
+	 *
+	 * @return 返回学生信息的列表，便于后续进行Excel文件生成等相关操作。
 	 */
 	@RequestMapping(value = "/exportstudentlist", method = RequestMethod.POST)
 	@ResponseBody
-	public List<Student> exportStudent(){
+	public List<Student> exportStudent() {
+		// 调用StudentService的getAll方法获取所有学生信息的列表。
 		List<Student> studentList = studentService.getAll();
 		return studentList;
 	}
 
 	/**
-	 * 删除学生信息
+	 * 删除学生信息的方法
+	 * 接收要删除的学生的ID作为参数，调用业务层方法进行删除操作，并返回视图名称 "student_list"。
+	 *
+	 * @param s_id 要删除的学生的唯一标识ID。
+	 * @return 返回视图名称 "student_list"，可能用于页面刷新等操作，展示删除后的学生信息列表情况。
 	 */
-	@RequestMapping( "/deleteStudent")
+	@RequestMapping("/deleteStudent")
 	@ResponseBody
 	public String deleteStudent(Integer s_id) {
+		// 调用StudentService的deleteStudent方法，传入要删除的学生ID，执行删除操作。
 		int s = studentService.deleteStudent(s_id);
 		return "student_list";
 	}
 
-/**
+	/**
- * 添加学生信息
+	 * 添加学生信息的方法
- */
+	 * 接收一个包含学生详细信息的Student对象（通过@RequestBody注解从请求体中获取JSON等格式数据并转换为Student对象），调用业务层方法进行添加操作，然后返回视图名称 "student_list"。
-
+	 *
-   @RequestMapping(value = "/addStudent" ,method = RequestMethod.POST)
+	 * @param student 包含要添加的学生详细信息的对象，例如学生姓名、学号、班级等信息。
-   @ResponseBody
+	 * @return 返回视图名称 "student_list"，用于页面刷新等操作，展示添加后的学生信息列表情况。
-   public String addStudent(@RequestBody Student student) {
+	 */
-	   int s = studentService.addStudent(student);
+	@RequestMapping(value = "/addStudent", method = RequestMethod.POST)
-	    return "student_list";
+	@ResponseBody
-    }
+	public String addStudent(@RequestBody Student student) {
+		// 调用StudentService的addStudent方法，传入包含学生信息的Student对象，执行添加学生信息到数据库等存储介质的操作。
+		int s = studentService.addStudent(student);
+		return "student_list";
+	}
 
 	/**
-	 * 修改学生信息
+	 * 修改学生信息的方法
+	 * 接收包含修改后学生信息的Student对象，调用业务层方法进行更新操作，更新成功后重定向到分页查询学生信息的方法对应的请求路径（"/findStudent"），以便刷新页面展示最新的学生信息列表。
+	 *
+	 * @param student 包含修改后的学生详细信息的对象，例如更新后的学生联系方式、家庭住址等信息。
+	 * @return 返回重定向的路径 "/findStudent"，实现页面刷新展示更新后的学生信息。
 	 */
-	@RequestMapping(value = "/updateStudent" ,method = RequestMethod.POST )
+	@RequestMapping(value = "/updateStudent", method = RequestMethod.POST)
-	public String updateStudent( Student student) {
+	public String updateStudent(Student student) {
+		// 调用StudentService的updateStudent方法，传入包含修改后学生信息的Student对象，执行更新学生信息到数据库等存储介质的操作。
 		int s = studentService.updateStudent(student);
 		return "redirect:/findStudent";
 	}
 
 
-    @RequestMapping( "/findStudentById")
+	/**
-    public String findStudentById(Integer s_id,HttpSession session) {
+	 * 根据学生ID查询学生信息的方法
+	 * 将查询到的学生信息存入HttpSession中，方便在后续的操作中（比如在不同请求之间共享数据）使用，然后返回视图名称 "student_edit"，可能用于展示学生信息以便进行编辑等操作。
+	 *
+	 * @param s_id 要查询的学生的唯一标识ID。
+	 * @param session HttpSession对象，用于存储和获取会话相关的数据，如将查询到的学生信息暂存于此，供后续编辑页面获取使用。
+	 * @return 返回视图名称 "student_edit"，用于展示学生详细信息，可能是编辑页面等。
+	 */
+	@RequestMapping("/findStudentById")
+	public String findStudentById(Integer s_id, HttpSession session) {
 
-        Student s= studentService.findStudentById(s_id);
+		Student s = studentService.findStudentById(s_id);
-        session.setAttribute("s",s);
+		session.setAttribute("s", s);
-        return "student_edit";
+		return "student_edit";
-    }
+	}
-}
+}

src/com/itheima/controller/VisitorController.java

@@ -15,51 +15,68 @@ import java.util.List;
 
 /**
  * @program: dormitorySystem
- * @description: 访客管理
+ * @description: 访客管理，该类主要用于处理与访客相关的各类业务操作，例如对访客信息进行分页查询、导出Excel、添加访客信息等操作，并与相应的视图进行交互。
  * @author: Joyrocky
  * @create: 2019-05-14 12:37
  **/
 @Controller
 public class VisitorController {
-    //依赖注入
+
+    // 依赖注入，通过Spring框架自动装配VisitorService的实例，方便后续在本类中调用其提供的业务方法，以此来处理访客相关的具体业务逻辑。
     @Autowired
     private VisitorService visitorService;
+
     /**
-     * 分页查询
+     * 分页查询访客信息的方法
-     * pageIndex 当前页码
+     *
-     * pageSize  显示条数
+     * @param v_name 访客姓名（可为null，用于根据访客姓名进行模糊或精确筛选访客信息记录，若为null则不按此条件筛选）。
+     * @param v_phone 访客电话号码（可为null，用于根据访客电话号码进行精确筛选访客信息记录，若为null则不按此条件筛选）。
+     * @param pageIndex 当前页码，用于确定要显示的页面，例如pageIndex为1表示显示第一页的访客信息。
+     * @param pageSize  显示条数，即每页显示的访客信息记录数量，比如pageSize为10表示每页展示10条访客信息记录。
+     * @param model Spring框架的Model对象，用于向视图传递数据，像将查询到的访客信息传递给视图进行展示。
+     * @return 返回视图名称 "visitor_list"，该视图会展示分页查询后的访客信息列表。
      */
     @RequestMapping(value = "/findVisitor")
-    public String findVisitor(String v_name, Integer v_phone , Integer pageIndex,
+    public String findVisitor(String v_name, Integer v_phone, Integer pageIndex,
                               Integer pageSize, Model model) {
 
-        PageInfo<Visitor> pi = visitorService.findPageInfo(v_name,v_phone,
+        // 调用VisitorService的findPageInfo方法，传入相应的筛选参数，获取包含分页后的访客信息的PageInfo对象。
-                                                pageIndex,pageSize);
+        PageInfo<Visitor> pi = visitorService.findPageInfo(v_name, v_phone,
-        model.addAttribute("pi",pi);
+                pageIndex, pageSize);
-        model.addAttribute("v_name",v_name);
+        // 将包含访客信息的PageInfo对象存入Model中，以便传递给视图（如"visitor_list"页面）进行展示。
+        model.addAttribute("pi", pi);
+        // 同时也将访客姓名存入Model，可能用于在视图中回显查询条件等操作。
+        model.addAttribute("v_name", v_name);
         return "visitor_list";
     }
 
     /**
-     * 导出Excel
+     * 导出Excel的方法，用于将访客信息导出为Excel文件。
+     * 此方法接收POST请求，使用@ResponseBody注解表示返回的数据会直接作为响应体内容，通常以JSON等格式返回给客户端（此处返回访客信息列表数据）。
+     *
+     * @return 返回访客信息的列表，便于后续进行Excel文件生成等相关操作。
      */
     @RequestMapping(value = "/exportvisitorlist", method = RequestMethod.POST)
     @ResponseBody
-    public List<Visitor> exportVisitor(){
+    public List<Visitor> exportVisitor() {
+        // 调用VisitorService的getAll方法获取所有访客信息的列表。
         List<Visitor> visitorList = visitorService.getAll();
         return visitorList;
     }
 
     /**
-     * 添加学生信息
+     * 添加访客信息的方法
+     * 接收一个包含访客详细信息的Visitor对象（通过@RequestBody注解从请求体中获取JSON等格式数据并转换为Visitor对象），调用业务层方法进行添加操作，然后返回视图名称 "visitor_list"。
+     *
+     * @param visitor 包含要添加的访客详细信息的对象，例如访客姓名、电话号码、来访事由等信息。
+     * @return 返回视图名称 "visitor_list"，用于页面刷新等操作，展示添加后的访客信息列表情况。
      */
-
+    @RequestMapping(value = "/addVisitor", method = RequestMethod.POST)
-    @RequestMapping(value = "/addVisitor" ,method = RequestMethod.POST)
     @ResponseBody
     public String addStudent(@RequestBody Visitor visitor) {
+        // 调用VisitorService的addVisitor方法，传入包含访客信息的Visitor对象，执行添加访客信息到数据库等存储介质的操作。
         int v = visitorService.addVisitor(visitor);
         return "visitor_list";
     }
 
-}
+}
-

src/com/itheima/dao/AdminDao.java

@@ -1,31 +1,99 @@
 package com.itheima.dao;
+
 import com.itheima.po.Admin;
 import org.apache.ibatis.annotations.Param;
 
-
 import java.util.List;
 
 /**
- * 管理员DAO层接口
+ * 管理员DAO层接口，用于定义与管理员数据操作相关的各种方法，这些方法会在具体的数据库访问实现类（如MyBatis的Mapper XML文件对应的实现）中被实现，
+ * 从而完成对管理员数据在数据库中的增删改查等操作。
  */
 public interface AdminDao {
+
 	/**
-	 * 通过账号和密码查询管理员
+	 * 通过账号和密码查询管理员的方法声明
+	 * 传入一个Admin对象，该对象中应包含了要查询的管理员的账号和密码等信息，通过此方法可以从数据库中查找与之匹配的管理员记录，并返回对应的Admin对象（若找到）。
+	 *
+	 * @param admin 包含账号、密码等信息的Admin对象，用于作为查询条件查找对应的管理员记录。
+	 * @return 返回查找到的Admin对象，如果没有找到匹配的管理员记录，则返回null。
 	 */
 	public Admin findAdmin(Admin admin);
 
 	/**
-	 * 进行分页查询
+	 * 进行分页查询相关操作的方法声明部分
+	 * 分页查询通常分为两步，一是获取符合条件的记录总条数，二是获取当前页对应的用户列表数据，以下两个方法分别对应这两个功能。
 	 */
 
+	/**
+	 * 获取总条数的方法声明
+	 * 根据传入的管理员用户名、描述以及管理员ID等条件，从数据库中统计出符合这些条件的管理员记录的总条数。
+	 * 这里使用了@Param注解来为参数指定名称，方便在对应的SQL语句（如MyBatis的Mapper XML文件中的SQL）中引用这些参数。
+	 *
+	 * @param a_username 管理员用户名（可为null，用于根据用户名进行模糊或精确筛选统计，若为null则不按此条件筛选）。
+	 * @param a_describe 管理员相关描述信息（可为null，用于根据描述进行模糊或精确筛选统计，若为null则不按此条件筛选）。
+	 * @param a_id 管理员的唯一标识ID（可为null，用于根据具体ID精确筛选统计，若为null则不按此条件筛选）。
+	 * @return 返回符合条件的管理员记录的总条数，类型为Integer。
+	 */
 	//获取总条数
-	public Integer totalCount(@Param("a_username") String a_username, @Param("a_describe") String a_describe,@Param("a_id") Integer a_id);
+	public Integer totalCount(@Param("a_username") String a_username, @Param("a_describe") String a_describe, @Param("a_id") Integer a_id);
+
+	/**
+	 * 获取用户列表的方法声明
+	 * 根据传入的管理员用户名、描述、管理员ID以及当前页码、每页显示数量等条件，从数据库中获取对应页的管理员信息列表。
+	 * 同样使用了@Param注解来明确参数名称，便于在SQL语句中准确引用。
+	 *
+	 * @param a_username 管理员用户名（可为null，用于根据用户名进行模糊或精确筛选获取列表，若为null则不按此条件筛选）。
+	 * @param a_describe 管理员相关描述信息（可为null，用于根据描述进行模糊或精确筛选获取列表，若为null则不按此条件筛选）。
+	 * @param a_id 管理员的唯一标识ID（可为null，用于根据具体ID精确筛选获取列表，若为null则不按此条件筛选）。
+	 * @param currentPage 当前页码，用于确定要获取哪一页的数据，例如currentPage为1表示获取第一页数据。
+	 * @param pageSize  每页显示的记录数量，比如pageSize为10表示每页展示10条记录。
+	 * @return 返回符合条件的当前页的管理员信息列表，类型为List<Admin>。
+	 */
 	//获取用户列表
-	public List<Admin> getAdminList(@Param("a_username") String a_username, @Param("a_describe") String a_describe,@Param("a_id") Integer a_id, @Param("currentPage") Integer currentPage, @Param("pageSize") Integer pageSize);
+	public List<Admin> getAdminList(@Param("a_username") String a_username, @Param("a_describe") String a_describe, @Param("a_id") Integer a_id, @Param("currentPage") Integer currentPage, @Param("pageSize") Integer pageSize);
 
+	/**
+	 * 添加管理员信息的方法声明
+	 * 接收一个包含管理员详细信息的Admin对象，将其信息插入到数据库中，实现添加管理员的操作。
+	 *
+	 * @param admin 包含要添加的管理员详细信息的对象，例如用户名、密码、相关描述等信息。
+	 * @return 返回一个整数，表示数据库受影响的行数，一般插入成功返回1，插入失败返回0等情况（具体取决于数据库操作的返回机制）。
+	 */
 	public int addAdmin(Admin admin);    //添加管理员信息
+
+	/**
+	 * 删除管理员信息的方法声明
+	 * 根据传入的管理员ID，从数据库中删除对应的管理员记录。
+	 *
+	 * @param a_id 要删除的管理员的唯一标识ID。
+	 * @return 返回一个整数，表示数据库受影响的行数，一般删除成功返回1，未找到对应记录删除失败返回0等情况（具体取决于数据库操作的返回机制）。
+	 */
 	public int deleteAdmin(Integer a_id);   //删除管理员信息
+
+	/**
+	 * 修改管理员信息的方法声明
+	 * 接收一个包含修改后管理员信息的Admin对象，根据对象中的信息更新数据库中对应的管理员记录。
+	 *
+	 * @param admin 包含修改后的管理员详细信息的对象，例如更新后的用户名、密码等信息。
+	 * @return 返回一个整数，表示数据库受影响的行数，一般更新成功返回1，更新失败返回0等情况（具体取决于数据库操作的返回机制）。
+	 */
 	public int updateAdmin(Admin admin); //修改管理员信息
+
+	/**
+	 * 根据管理员ID查询管理员信息的方法声明
+	 * 根据传入的管理员ID，从数据库中查找并返回对应的管理员记录信息（以Admin对象形式返回）。
+	 *
+	 * @param a_id 要查询的管理员的唯一标识ID。
+	 * @return 返回查找到的Admin对象，如果没有找到对应记录则返回null。
+	 */
 	public Admin findAdminById(Integer a_id);
+
+	/**
+	 * 获取所有管理员信息的方法声明
+	 * 从数据库中查询并返回所有的管理员记录信息列表，用于一些需要获取全部管理员数据的场景，比如导出所有管理员信息到Excel等操作。
+	 *
+	 * @return 返回包含所有管理员信息的列表，类型为List<Admin>。
+	 */
 	public List<Admin> getAll();
-}
+}

src/com/itheima/dao/ClassDao.java

@@ -6,22 +6,94 @@ import org.apache.ibatis.annotations.Param;
 import java.util.List;
 
 /**
- * 管理员DAO层接口
+ * 管理员DAO层接口，定义了与班级相关数据操作的各种方法，这些方法会在具体的数据库访问实现类（例如MyBatis的Mapper XML文件对应的实现类）中被实现，
+ * 进而完成针对班级数据在数据库中的增删改查以及其他相关查询操作。
  */
 public interface ClassDao {
+
+	/**
+	 * 进行分页查询相关操作的方法声明部分
+	 * 分页查询通常包含两个主要步骤，一是统计符合条件的记录总条数，二是获取指定页码下的记录列表，以下两个方法分别对应这两个功能。
+	 */
+
 	/**
-	 * 进行分页查询
+	 * 获取总条数的方法声明
+	 * 根据传入的班级名称、班级ID以及辅导员信息等条件，从数据库中统计出符合这些条件的班级记录的总条数。
+	 * 使用了@Param注解为参数指定名称，方便在对应的SQL语句（如MyBatis的Mapper XML文件里的SQL语句）中准确引用这些参数。
+	 *
+	 * @param c_classname 班级名称（可为null，用于根据班级名称进行模糊或精确筛选统计，若为null则不按此条件筛选）。
+	 * @param c_classid 班级的唯一标识ID（可为null，用于根据具体ID精确筛选统计，若为null则不按此条件筛选）。
+	 * @param c_counsellor 辅导员信息（可为null，用于根据辅导员姓名等相关信息进行模糊或精确筛选统计，若为null则不按此条件筛选）。
+	 * @return 返回符合条件的班级记录的总条数，数据类型为Integer。
 	 */
+	//获取总条数
+	public Integer totalCount(@Param("c_classname") String c_classname, @Param("c_classid") Integer c_classid, @Param("c_counsellor") String c_counsellor);
 
-	 //获取总条数
+	/**
-     public Integer totalCount(@Param("c_classname") String c_classname, @Param("c_classid") Integer c_classid, @Param("c_counsellor") String c_counsellor);
+	 * 获取用户列表的方法声明
-	 //获取用户列表
+	 * 根据传入的班级名称、班级ID、辅导员信息以及当前页码、每页显示数量等条件，从数据库中获取对应页的班级信息列表。
-     public List<Class> getClassList(@Param("c_classname") String c_classname, @Param("c_classid") Integer c_classid, @Param("c_counsellor") String c_counsellor, @Param("currentPage") Integer currentPage, @Param("pageSize") Integer pageSize);
+	 * 通过@Param注解明确参数名称，以确保在SQL语句中能正确引用各参数来获取准确的数据。
+	 *
+	 * @param c_classname 班级名称（可为null，用于根据班级名称进行模糊或精确筛选获取列表，若为null则不按此条件筛选）。
+	 * @param c_classid 班级的唯一标识ID（可为null，用于根据具体ID精确筛选获取列表，若为null则不按此条件筛选）。
+	 * @param c_counsellor 辅导员信息（可为null，用于根据辅导员相关信息进行模糊或精确筛选获取列表，若为null则不按此条件筛选）。
+	 * @param currentPage 当前页码，用于确定要获取哪一页的数据，例如currentPage为1表示获取第一页的班级信息。
+	 * @param pageSize  每页显示的记录数量，比如pageSize为10表示每页展示10条班级信息记录。
+	 * @return 返回符合条件的当前页的班级信息列表，类型为List<Class>。
+	 */
+	//获取用户列表
+	public List<Class> getClassList(@Param("c_classname") String c_classname, @Param("c_classid") Integer c_classid, @Param("c_counsellor") String c_counsellor, @Param("currentPage") Integer currentPage, @Param("pageSize") Integer pageSize);
 
+	/**
+	 * 删除班级信息的方法声明
+	 * 根据传入的班级的唯一标识ID，从数据库中删除对应的班级记录。
+	 *
+	 * @param c_id 要删除的班级的唯一标识ID。
+	 * @return 返回一个整数，表示数据库受影响的行数，一般来说，删除成功返回1，若未找到对应记录则删除失败返回0（具体取决于数据库操作的返回机制）。
+	 */
 	public int deleteClass(Integer c_id);   //删除班级信息
+
+	/**
+	 * 添加班级信息的方法声明
+	 * 接收一个包含班级详细信息的Class对象，将其信息插入到数据库中，实现添加班级的操作。
+	 *
+	 * @param ucalss 包含要添加的班级详细信息的对象，例如班级名称、班级人数、辅导员等相关信息。
+	 * @return 返回一个整数，表示数据库受影响的行数，通常添加成功返回1，添加失败返回0等情况（具体取决于数据库操作的返回机制）。
+	 */
 	public int addClass(Class ucalss);    //添加班级信息
+
+	/**
+	 * 修改班级信息的方法声明
+	 * 接收一个包含修改后班级信息的Class对象，依据对象中的信息更新数据库中对应的班级记录。
+	 *
+	 * @param uclass 包含修改后的班级详细信息的对象，比如更新后的班级名称、班级人数变动等信息。
+	 * @return 返回一个整数，表示数据库受影响的行数，一般更新成功返回1，更新失败返回0等情况（具体取决于数据库操作的返回机制）。
+	 */
 	public int updateClass(Class uclass); //修改班级信息
+
+	/**
+	 * 根据班级ID查询班级信息的方法声明
+	 * 根据传入的班级的唯一标识ID，从数据库中查找并返回对应的班级记录信息（以Class对象形式返回）。
+	 *
+	 * @param c_id 要查询的班级的唯一标识ID。
+	 * @return 返回查找到的Class对象，如果没有找到对应记录则返回null。
+	 */
 	public Class findClassById(Integer c_id);
+
+	/**
+	 * 查询班级人员信息的方法声明
+	 * 接收一个包含班级相关筛选条件等信息的Class对象，依据这些条件从数据库中查询出该班级的人员信息列表。
+	 *
+	 * @param uclass 包含班级相关条件信息的对象，可用于精确查询某个班级的人员信息，例如通过班级ID等关联条件来查找对应班级下的学生等人员信息。
+	 * @return 返回符合条件的班级人员信息列表，类型为List<Class>。
+	 */
 	public List<Class> findClassStudent(Class uclass);//查询班级人员信息
+
+	/**
+	 * 获取所有班级信息的方法声明
+	 * 从数据库中查询并返回所有的班级记录信息列表，用于一些需要获取全部班级数据的场景，比如展示所有班级的基本情况等操作。
+	 *
+	 * @return 返回包含所有班级信息的列表，类型为List<Class>。
+	 */
 	public List<Class> getAll();
-}
+}

src/com/itheima/dao/DormCleanDao.java

@@ -7,23 +7,86 @@ import java.util.List;
 
 /**
  * @program: dormitorySystem
- * @description: 宿舍卫生
+ * @description: 宿舍卫生，该接口主要定义了与宿舍卫生数据操作相关的各种方法，这些方法会在具体的数据库访问实现类（比如MyBatis的Mapper XML文件对应的实现类）中进行实现，
+ * 进而完成针对宿舍卫生数据在数据库中的增删改查以及分页查询等操作。
  * @author: Joyrocky
  * @create: 2019-04-24 14:37
  **/
 public interface DormCleanDao {
+
+    /**
+     * 进行分页查询相关操作的方法声明部分
+     * 分页查询通常包含两个关键步骤，一是统计符合条件的记录总条数，二是获取指定页码对应的记录列表，以下两个方法分别对应这两个功能。
+     */
+
     /**
-     * 进行分页查询
+     * 获取总条数的方法声明
+     * 根据传入的宿舍卫生记录的唯一标识ID以及宿舍楼栋信息等条件，从数据库中统计出符合这些条件的宿舍卫生记录的总条数。
+     * 使用了@Param注解为参数指定名称，方便在对应的SQL语句（例如MyBatis的Mapper XML文件里的SQL语句）中准确引用这些参数。
+     *
+     * @param d_id 宿舍卫生记录的唯一标识ID（可为null，用于根据具体ID精确筛选统计，若为null则不按此条件筛选）。
+     * @param d_dormbuilding 宿舍楼栋信息（可为null，用于根据楼栋信息进行模糊或精确筛选统计，若为null则不按此条件筛选）。
+     * @return 返回符合条件的宿舍卫生记录的总条数，类型为Integer。
      */
     //获取总条数
     public Integer totalCount(@Param("d_id") Integer d_id, @Param("d_dormbuilding") String d_dormbuilding);
+
+    /**
+     * 获取用户列表的方法声明
+     * 根据传入的宿舍卫生记录的唯一标识ID、宿舍楼栋信息以及当前页码、每页显示数量等条件，从数据库中获取对应页的宿舍卫生记录信息列表。
+     * 通过@Param注解明确参数名称，确保在SQL语句中能正确引用各参数来获取准确的数据。
+     *
+     * @param d_id 宿舍卫生记录的唯一标识ID（可为null，用于根据具体ID精确筛选获取列表，若为null则不按此条件筛选）。
+     * @param d_dormbuilding 宿舍楼栋信息（可为null，用于根据楼栋信息进行模糊或精确筛选获取列表，若为null则不按此条件筛选）。
+     * @param currentPage 当前页码，用于确定要获取哪一页的数据，例如currentPage为1表示获取第一页的宿舍卫生记录信息。
+     * @param pageSize  每页显示的记录数量，比如pageSize为10表示每页展示10条宿舍卫生记录信息。
+     * @return 返回符合条件的当前页的宿舍卫生记录信息列表，类型为List<DormClean>。
+     */
     //获取用户列表
     public List<DormClean> getDormCleanList(@Param("d_id") Integer d_id, @Param("d_dormbuilding") String d_dormbuilding, @Param("currentPage") Integer currentPage, @Param("pageSize") Integer pageSize);
 
+    /**
+     * 添加宿舍卫生信息的方法声明
+     * 接收一个包含宿舍卫生详细信息的DormClean对象，将其信息插入到数据库中，实现添加宿舍卫生记录的操作。
+     *
+     * @param dormclean 包含要添加的宿舍卫生详细信息的对象，例如宿舍编号、打扫时间、卫生情况等相关信息。
+     * @return 返回一个整数，表示数据库受影响的行数，通常添加成功返回1，添加失败返回0等情况（具体取决于数据库操作的返回机制）。
+     */
     public int addDormClean(DormClean dormclean);    //添加宿舍卫生信息
+
+    /**
+     * 删除宿舍卫生信息的方法声明
+     * 根据传入的宿舍卫生记录的唯一标识ID，从数据库中删除对应的宿舍卫生记录。
+     *
+     * @param g_id 要删除的宿舍卫生记录的唯一标识ID。
+     * @return 返回一个整数，表示数据库受影响的行数，一般删除成功返回1，若未找到对应记录则删除失败返回0（具体取决于数据库操作的返回机制）。
+     */
     public int deleteDormClean(Integer g_id);   //删除宿舍卫生信息
+
+    /**
+     * 修改宿舍卫生信息的方法声明
+     * 接收一个包含修改后宿舍卫生信息的DormClean对象，依据对象中的信息更新数据库中对应的宿舍卫生记录。
+     *
+     * @param dormclean 包含修改后的宿舍卫生详细信息的对象，比如更新后的打扫时间、卫生评价等信息。
+     * @return 返回一个整数，表示数据库受影响的行数，一般更新成功返回1，更新失败返回0等情况（具体取决于数据库操作的返回机制）。
+     */
     public int updateDormClean(DormClean dormclean); //修改宿舍卫生信息
+
+    /**
+     * 根据宿舍卫生记录ID查询宿舍卫生信息的方法声明
+     * 根据传入的宿舍卫生记录的唯一标识ID，从数据库中查找并返回对应的宿舍卫生记录信息（以DormClean对象形式返回）。
+     *
+     * @param g_id 要查询的宿舍卫生记录的唯一标识ID。
+     * @return 返回查找到的DormClean对象，如果没有找到对应记录则返回null。
+     */
     public DormClean findDormCleanById(Integer g_id);
+
+    /**
+     * 获取所有宿舍卫生信息的方法声明
+     * 从数据库中查询并返回所有的宿舍卫生记录信息列表，用于一些需要获取全部宿舍卫生数据的场景，比如导出所有宿舍卫生信息等操作。
+     *
+     * @return 返回包含所有宿舍卫生信息的列表，类型为List<DormClean>。
+     */
     public List<DormClean> getAll();
 
-}
+}

src/com/itheima/dao/DormRepairDao.java

@@ -7,25 +7,86 @@ import java.util.List;
 
 /**
  * @program: dormitorySystem
- * @description: 维修登记
+ * @description: 维修登记，该接口主要定义了针对宿舍维修相关数据进行操作的一系列方法，这些方法会在对应的数据库访问实现类（例如MyBatis框架下的Mapper XML文件对应的具体实现类）中得以实现，
+ * 进而完成宿舍维修数据在数据库中的增删改查以及分页查询等业务操作。
  * @author: Joyrocky
  * @create: 2019-04-27 17:20
  **/
 public interface DormRepairDao {
 
     /**
-     * 进行分页查询
+     * 进行分页查询相关操作的方法声明部分
+     * 分页查询通常涉及两个核心步骤，一是统计符合特定条件的记录总条数，二是获取指定页码对应的记录列表，以下两个方法分别对应这两个功能。
      */
 
+    /**
+     * 获取总条数的方法声明
+     * 根据传入的宿舍维修记录的唯一标识ID以及宿舍楼栋信息等条件，从数据库中统计出符合这些条件的宿舍维修记录的总条数。
+     * 使用@Param注解为参数指定名称，方便在对应的SQL语句（例如MyBatis的Mapper XML文件里的SQL语句）中准确引用这些参数进行条件筛选和数据统计。
+     *
+     * @param d_id 宿舍维修记录的唯一标识ID（可为null，用于根据具体ID精确筛选统计，若为null则不按此条件筛选）。
+     * @param d_dormbuilding 宿舍楼栋信息（可为null，用于根据楼栋信息进行模糊或精确筛选统计，若为null则不按此条件筛选）。
+     * @return 返回符合条件的宿舍维修记录的总条数，类型为Integer。
+     */
     //获取总条数
     public Integer totalCount(@Param("d_id") Integer d_id, @Param("d_dormbuilding") String d_dormbuilding);
+
+    /**
+     * 获取用户列表的方法声明
+     * 根据传入的宿舍维修记录的唯一标识ID、宿舍楼栋信息以及当前页码、每页显示数量等条件，从数据库中获取对应页的宿舍维修记录信息列表。
+     * 通过@Param注解明确参数名称，确保在SQL语句中能正确引用各参数来获取准确的数据。
+     *
+     * @param d_id 宿舍维修记录的唯一标识ID（可为null，用于根据具体ID精确筛选获取列表，若为null则不按此条件筛选）。
+     * @param d_dormbuilding 宿舍楼栋信息（可为null，用于根据楼栋信息进行模糊或精确筛选获取列表，若为null则不按此条件筛选）。
+     * @param currentPage 当前页码，用于确定要获取哪一页的数据，例如currentPage为1表示获取第一页的宿舍维修记录信息。
+     * @param pageSize  每页显示的记录数量，比如pageSize为10表示每页展示10条宿舍维修记录信息。
+     * @return 返回符合条件的当前页的宿舍维修记录信息列表，类型为List<DormRepair>。
+     */
     //获取用户列表
     public List<DormRepair> getDormRepairList(@Param("d_id") Integer d_id, @Param("d_dormbuilding") String d_dormbuilding, @Param("currentPage") Integer currentPage, @Param("pageSize") Integer pageSize);
 
+    /**
+     * 添加宿舍信息的方法声明，这里准确来说是添加宿舍维修信息的方法声明
+     * 接收一个包含宿舍维修详细信息的DormRepair对象，将其信息插入到数据库中，实现添加宿舍维修记录的操作。
+     *
+     * @param dormrepair 包含要添加的宿舍维修详细信息的对象，例如维修的宿舍编号、维修项目、报修时间等相关信息。
+     * @return 返回一个整数，表示数据库受影响的行数，通常添加成功返回1，添加失败返回0等情况（具体取决于数据库操作的返回机制）。
+     */
     public int addDormRepair(DormRepair dormrepair);    //添加宿舍信息
+
+    /**
+     * 删除宿舍信息的方法声明，此处确切是删除宿舍维修信息的方法声明
+     * 根据传入的宿舍维修记录的唯一标识ID，从数据库中删除对应的宿舍维修记录。
+     *
+     * @param r_id 要删除的宿舍维修记录的唯一标识ID。
+     * @return 返回一个整数，表示数据库受影响的行数，一般删除成功返回1，若未找到对应记录则删除失败返回0（具体取决于数据库操作的返回机制）。
+     */
     public int deleteDormRepair(Integer r_id);   //删除宿舍信息
+
+    /**
+     * 修改宿舍信息的方法声明，也就是修改宿舍维修信息的方法声明
+     * 接收一个包含修改后宿舍维修信息的DormRepair对象，依据对象中的信息更新数据库中对应的宿舍维修记录。
+     *
+     * @param dormrepair 包含修改后的宿舍维修详细信息的对象，比如更新后的维修进度、维修完成时间等信息。
+     * @return 返回一个整数，表示数据库受影响的行数，一般更新成功返回1，更新失败返回0等情况（具体取决于数据库操作的返回机制）。
+     */
     public int updateDormRepair(DormRepair dormrepair); //修改宿舍信息
+
+    /**
+     * 根据宿舍维修记录ID查询宿舍维修信息的方法声明
+     * 根据传入的宿舍维修记录的唯一标识ID，从数据库中查找并返回对应的宿舍维修记录信息（以DormRepair对象形式返回）。
+     *
+     * @param r_id 要查询的宿舍维修记录的唯一标识ID。
+     * @return 返回查找到的DormRepair对象，如果没有找到对应记录则返回null。
+     */
     public DormRepair findDormRepairById(Integer r_id);
+
+    /**
+     * 获取所有宿舍维修信息的方法声明
+     * 从数据库中查询并返回所有的宿舍维修记录信息列表，用于一些需要获取全部宿舍维修数据的场景，比如导出所有宿舍维修信息等操作。
+     *
+     * @return 返回包含所有宿舍维修信息的列表，类型为List<DormRepair>。
+     */
     public List<DormRepair> getAll();
 
-}
+}

src/com/itheima/dao/DormitoryDao.java

@@ -6,24 +6,95 @@ import org.apache.ibatis.annotations.Param;
 import java.util.List;
 
 /**
- * 管理员DAO层接口
+ * 管理员DAO层接口，该接口定义了一系列用于操作宿舍相关数据的方法声明，这些方法会在对应的数据库持久层实现类（例如基于MyBatis框架实现的Mapper类）中被具体实现，
+ * 从而与数据库进行交互，完成诸如宿舍数据的查询、添加、删除、修改等业务操作。
  */
 public interface DormitoryDao {
+
+	/**
+	 * 进行分页查询相关操作的方法声明部分
+	 * 分页查询功能通常分为两个关键步骤，一是统计符合特定筛选条件的宿舍记录的总条数，二是依据同样的筛选条件以及指定的页码和每页显示数量来获取相应的宿舍信息列表，以下两个方法分别承担这两项任务。
+	 */
+
 	/**
-	 * 进行分页查询
+	 * 获取总条数的方法声明
+	 * 此方法用于根据传入的不同筛选条件，从数据库中统计出满足这些条件的宿舍记录的总数。
+	 * 通过 @Param 注解为每个参数指定名称，目的在于在后续关联的 SQL 语句（比如在 MyBatis 的 Mapper XML 文件中编写的 SQL 语句）中能够清晰准确地引用这些参数，实现灵活的条件筛选统计。
+	 *
+	 * @param a_name 表示宿舍相关的名称属性（其具体指代的内容可根据实际业务场景确定，该参数可为 null，若为 null 则在统计总条数时不按照此名称条件进行筛选）。
+	 * @param s_dormitoryid 宿舍的唯一标识编号（可为 null，若传入具体的编号值，则按照此精确的编号对宿舍记录进行筛选统计，若为 null 则不以此编号条件筛选）。
+	 * @param d_dormbuilding 代表宿舍楼栋信息（可为 null，若提供相应的值，可根据此楼栋信息对宿舍记录进行模糊或精确筛选统计，若为 null 则不按此条件操作）。
+	 * @return 返回一个 Integer 类型的值，表示符合上述传入条件的宿舍记录的总条数。
 	 */
+	//获取总条数
+	public Integer totalCount(@Param("a_name") String a_name, @Param("s_dormitoryid") Integer s_dormitoryid, @Param("d_dormbuilding") String d_dormbuilding);
 
-	 //获取总条数
+	/**
-     public Integer totalCount(@Param("a_name") String a_name, @Param("s_dormitoryid") Integer s_dormitoryid,@Param("d_dormbuilding") String d_dormbuilding);
+	 * 获取用户列表的方法声明
-	 //获取用户列表
+	 * 依据传入的多个筛选条件（包含宿舍名称、宿舍编号、宿舍楼栋信息等）以及指定的当前页码和每页显示数量，从数据库中获取相应页码对应的宿舍信息列表。
-     public List<Dormitory> getDormitoryList(@Param("a_name") String a_name, @Param("s_dormitoryid") Integer s_dormitoryid, @Param("d_dormbuilding") String d_dormbuilding, @Param("currentPage") Integer currentPage, @Param("pageSize") Integer pageSize);
+	 * 使用 @Param 注解来明确各个参数的名称，确保在对应的 SQL 语句中可以精准地引用这些参数，进而正确获取期望的数据。
+	 *
+	 * @param a_name 宿舍相关的名称属性（可为 null，用于在查询宿舍列表时根据名称进行模糊或精确筛选，若为 null 则不按此条件筛选）。
+	 * @param s_dormitoryid 宿舍的唯一标识编号（可为 null，用于按照具体编号精确筛选宿舍记录来获取列表，若为 null 则不按此条件筛选）。
+	 * @param d_dormbuilding 宿舍楼栋信息（可为 null，用于依据楼栋信息进行模糊或精确筛选获取宿舍信息列表，若为 null 则不按此条件筛选）。
+	 * @param currentPage 用于指定当前页码，例如传入值为 1 时，表示要获取第一页的宿舍信息数据。
+	 * @param pageSize 用来确定每页显示的宿舍记录数量，比如传入值为 10，则每页会展示 10 条宿舍信息记录。
+	 * @return 返回一个 List<Dormitory> 类型的列表，其中包含了符合条件的当前页码对应的宿舍信息记录，每条记录以 Dormitory 对象的形式呈现。
+	 */
+	//获取用户列表
+	public List<Dormitory> getDormitoryList(@Param("a_name") String a_name, @Param("s_dormitoryid") Integer s_dormitoryid, @Param("d_dormbuilding") String d_dormbuilding, @Param("currentPage") Integer currentPage, @Param("pageSize") Integer pageSize);
 
+	/**
+	 * 添加宿舍信息的方法声明
+	 * 接收一个包含完整宿舍详细信息的 Dormitory 对象，将该对象所承载的宿舍相关信息插入到数据库中，以此实现添加新宿舍记录的业务操作。
+	 *
+	 * @param dormitory 一个 Dormitory 类型的对象，里面封装了要添加到数据库的宿舍的各项详细信息，比如宿舍的名称、所在楼层、可容纳人数等具体属性信息。
+	 * @return 返回一个整数类型的值，该值表示数据库受此插入操作影响的行数，通常情况下，如果插入操作成功，则返回值为 1；若插入过程出现异常等导致失败，则返回值为 0（具体返回值情况取决于所使用的数据库操作的返回机制）。
+	 */
 	public int addDormitory(Dormitory dormitory);    //添加宿舍信息
+
+	/**
+	 * 删除宿舍信息的方法声明
+	 * 根据传入的代表宿舍唯一标识的编号（d_id），在数据库中查找并删除与之对应的宿舍记录，实现删除宿舍信息的业务功能。
+	 *
+	 * @param d_id 要删除的宿舍的唯一标识编号，通过这个编号可以准确地定位到数据库中需要删除的那条宿舍记录。
+	 * @return 返回一个整数类型的值，用以表示数据库受此删除操作影响的行数，正常情况下，若成功删除对应的宿舍记录，返回值为 1；若数据库中不存在该编号对应的宿舍记录导致删除失败，则返回值为 0（具体依据数据库操作的返回机制而定）。
+	 */
 	public int deleteDormitory(Integer d_id);   //删除宿舍信息
+
+	/**
+	 * 修改宿舍信息的方法声明
+	 * 接收一个包含已修改后的宿舍详细信息的 Dormitory 对象，依据该对象中的信息去更新数据库中对应的宿舍记录内容，完成宿舍信息修改的业务操作。
+	 *
+	 * @param dormitory 一个 Dormitory 类型的对象，其中包含了经过修改后的宿舍各项信息，例如宿舍的房间布局发生变化后、可容纳人数调整后的新信息等，通过这些信息来更新数据库中原有的宿舍记录。
+	 * @return 返回一个整数类型的值，用来体现数据库受此更新操作影响的行数，一般而言，更新操作成功时返回值为 1；若因某些原因（如数据不合法、记录不存在等）导致更新失败，则返回值为 0（具体取决于数据库操作的返回机制）。
+	 */
 	public int updateDormitory(Dormitory dormitory); //修改宿舍信息
+
+	/**
+	 * 根据宿舍ID查询宿舍信息的方法声明
+	 * 依据传入的宿舍唯一标识编号（d_id），从数据库中查找并返回与之对应的宿舍详细记录信息，查询结果以 Dormitory 对象的形式呈现，如果没有找到匹配的宿舍记录，则返回 null。
+	 *
+	 * @param d_id 用于在数据库中准确查找对应宿舍记录的唯一标识编号，通过它可以定位到特定的宿舍信息。
+	 * @return 返回一个 Dormitory 类型的对象，里面封装了查找到的对应宿舍的详细信息，若数据库中不存在该编号对应的宿舍记录，则返回 null。
+	 */
 	public Dormitory findDormitoryById(Integer d_id);
 
+	/**
+	 * 查询宿舍人员信息的方法声明
+	 * 接收一个 Dormitory 对象，该对象中包含了用于筛选查询宿舍人员信息的相关条件（例如宿舍编号等信息，具体条件依据业务逻辑而定），然后基于这些条件从数据库中查询出该宿舍内的人员信息列表。
+	 *
+	 * @param dormitory 一个 Dormitory 类型的对象，其承载了查询宿舍人员信息所需的筛选条件，通过这些条件来精准查找特定宿舍下的人员信息情况。
+	 * @return 返回一个 List<Dormitory> 类型的列表，列表中的每个 Dormitory 对象（此处可能根据业务实际情况进行了相应的封装或转换）代表了查询到的宿舍内的人员相关信息，若没有符合条件的人员信息，则返回空列表。
+	 */
 	public List<Dormitory> findDormitoryStudent(Dormitory dormitory);//查询宿舍人员信息
+
+	/**
+	 * 获取所有宿舍信息的方法声明
+	 * 用于从数据库中查询并返回所有的宿舍记录信息列表，这个方法在一些需要展示全部宿舍基本情况或者进行全量数据处理等业务场景下会被调用使用。
+	 *
+	 * @return 返回一个 List<Dormitory> 类型的列表，里面包含了数据库中存储的所有宿舍的详细记录信息，以 Dormitory 对象形式呈现。
+	 */
 	public List<Dormitory> getAll();
 
-}
+}

src/com/itheima/dao/StudentCleanDao.java

@@ -7,23 +7,88 @@ import java.util.List;
 
 /**
  * @program: dormitorySystem
- * @description: 学生卫生
+ * @description: 学生卫生，该接口主要定义了针对学生卫生相关数据进行操作的一系列方法，这些方法会在对应的数据库访问实现类（比如MyBatis的Mapper XML文件对应的实现类）中进行实现，
+ * 进而完成学生卫生数据在数据库中的增删改查以及分页查询等操作。
  * @author: Joyrocky
  * @create: 2019-04-25 12:14
  **/
 public interface StudentCleanDao {
+
+    /**
+     * 进行分页查询相关操作的方法声明部分
+     * 分页查询通常包含两个关键步骤，一是统计符合条件的记录总条数，二是获取指定页码对应的记录列表，以下两个方法分别对应这两个功能。
+     */
+
     /**
-     * 进行分页查询
+     * 获取总条数的方法声明
+     * 根据传入的学生的唯一标识ID、学生姓名以及学生所在宿舍的唯一标识ID等条件，从数据库中统计出符合这些条件的学生卫生记录的总条数。
+     * 使用了@Param注解为参数指定名称，方便在对应的SQL语句（例如MyBatis的Mapper XML文件里的SQL语句）中准确引用这些参数进行条件筛选和数据统计。
+     *
+     * @param s_studentid 学生的唯一标识ID（可为null，用于根据具体学生ID精确筛选统计，若为null则不按此条件筛选）。
+     * @param s_name 学生姓名（可为null，用于根据学生姓名进行模糊或精确筛选统计，若为null则不按此条件筛选）。
+     * @param s_dormitoryid 学生所在宿舍的唯一标识ID（可为null，用于根据宿舍ID筛选统计，若为null则不按此条件筛选）。
+     * @return 返回符合条件的学生卫生记录的总条数，类型为Integer。
      */
     //获取总条数
-    public Integer totalCount(@Param("s_studentid") Integer s_studentid, @Param("s_name") String s_name,@Param("s_dormitoryid") Integer s_dormitoryid);
+    public Integer totalCount(@Param("s_studentid") Integer s_studentid, @Param("s_name") String s_name, @Param("s_dormitoryid") Integer s_dormitoryid);
+
+    /**
+     * 获取用户列表的方法声明
+     * 根据传入的学生的唯一标识ID、学生姓名、学生所在宿舍的唯一标识ID以及当前页码、每页显示数量等条件，从数据库中获取对应页的学生卫生记录信息列表。
+     * 通过@Param注解明确参数名称，确保在SQL语句中能正确引用各参数来获取准确的数据。
+     *
+     * @param s_studentid 学生的唯一标识ID（可为null，用于根据具体学生ID精确筛选获取列表，若为null则不按此条件筛选）。
+     * @param s_name 学生姓名（可为null，用于根据学生姓名进行模糊或精确筛选获取列表，若为null则不按此条件筛选）。
+     * @param s_dormitoryid 学生所在宿舍的唯一标识ID（可为null，用于根据宿舍ID筛选获取列表，若为null则不按此条件筛选）。
+     * @param currentPage 当前页码，用于确定要获取哪一页的数据，例如currentPage为1表示获取第一页的学生卫生记录信息。
+     * @param pageSize  每页显示的记录数量，比如pageSize为10表示每页展示10条学生卫生记录信息。
+     * @return 返回符合条件的当前页的学生卫生记录信息列表，类型为List<StudentClean>。
+     */
     //获取用户列表
     public List<StudentClean> getStudentCleanList(@Param("s_studentid") Integer s_studentid, @Param("s_name") String s_name, @Param("s_dormitoryid") Integer s_dormitoryid, @Param("currentPage") Integer currentPage, @Param("pageSize") Integer pageSize);
 
+    /**
+     * 添加宿舍卫生信息的方法声明
+     * 接收一个包含学生卫生详细信息的StudentClean对象，将其信息插入到数据库中，实现添加学生卫生记录的操作。
+     *
+     * @param studentclean 包含要添加的学生卫生详细信息的对象，例如学生打扫的宿舍区域、打扫时间、卫生评价等相关信息。
+     * @return 返回一个整数，表示数据库受影响的行数，通常添加成功返回1，添加失败返回0等情况（具体取决于数据库操作的返回机制）。
+     */
     public int addStudentClean(StudentClean studentclean);    //添加宿舍卫生信息
+
+    /**
+     * 删除宿舍卫生信息的方法声明
+     * 根据传入的学生卫生记录的唯一标识ID，从数据库中删除对应的学生卫生记录。
+     *
+     * @param g_id 要删除的学生卫生记录的唯一标识ID。
+     * @return 返回一个整数，表示数据库受影响的行数，一般删除成功返回1，若未找到对应记录则删除失败返回0（具体取决于数据库操作的返回机制）。
+     */
     public int deleteStudentClean(Integer g_id);   //删除宿舍卫生信息
+
+    /**
+     * 修改宿舍卫生信息的方法声明
+     * 接收一个包含修改后学生卫生信息的StudentClean对象，依据对象中的信息更新数据库中对应的学生卫生记录。
+     *
+     * @param studentclean 包含修改后的学生卫生详细信息的对象，比如更新后的卫生评价、打扫时间等信息。
+     * @return 返回一个整数，表示数据库受影响的行数，一般更新成功返回1，更新失败返回0等情况（具体取决于数据库操作的返回机制）。
+     */
     public int updateStudentClean(StudentClean studentclean); //修改宿舍卫生信息
+
+    /**
+     * 根据学生卫生记录ID查询学生卫生信息的方法声明
+     * 根据传入的学生卫生记录的唯一标识ID，从数据库中查找并返回对应的学生卫生记录信息（以StudentClean对象形式返回）。
+     *
+     * @param g_id 要查询的学生卫生记录的唯一标识ID。
+     * @return 返回查找到的StudentClean对象，如果没有找到对应记录则返回null。
+     */
     public StudentClean findStudentCleanById(Integer g_id);
 
+    /**
+     * 获取所有学生卫生信息的方法声明
+     * 从数据库中查询并返回所有的学生卫生记录信息列表，用于一些需要获取全部学生卫生数据的场景，比如导出所有学生卫生信息等操作。
+     *
+     * @return 返回包含所有学生卫生信息的列表，类型为List<StudentClean>。
+     */
     public List<StudentClean> getAll();
-}
+
+}

src/com/itheima/dao/StudentDao.java

@@ -1,28 +1,96 @@
 package com.itheima.dao;
+
 import com.itheima.po.Student;
 import org.apache.ibatis.annotations.Param;
 
-
 import java.util.List;
 
 /**
- * 管理员DAO层接口
+ * 管理员DAO层接口，此接口定义了一系列用于操作学生相关数据的方法声明，这些方法后续会在对应的数据库持久层实现类（例如基于MyBatis框架实现的Mapper类）中被具体实现，
+ * 从而与数据库进行交互，完成诸如学生数据的查询、添加、删除、修改等业务操作。
  */
 public interface StudentDao {
+
+	/**
+	 * 进行分页查询相关操作的方法声明部分
+	 * 分页查询功能通常分为两个关键步骤，一是统计符合特定筛选条件的学生记录的总条数，二是依据同样的筛选条件以及指定的页码和每页显示数量来获取相应的学生信息列表，以下两个方法分别承担这两项任务。
+	 */
+
+	/**
+	 * 获取总条数的方法声明
+	 * 此方法用于根据传入的不同筛选条件，从数据库中统计出满足这些条件的学生记录的总数。
+	 * 通过 @Param 注解为每个参数指定名称，目的在于在后续关联的 SQL 语句（比如在 MyBatis 的 Mapper XML 文件中编写的 SQL 语句）中能够清晰准确地引用这些参数，实现灵活的条件筛选统计。
+	 *
+	 * @param s_name 表示学生的姓名（该参数可为 null，若为 null 则在统计总条数时不按照学生姓名条件进行筛选）。
+	 * @param s_studentid 学生的唯一标识编号（可为 null，若传入具体的编号值，则按照此精确的编号对学生记录进行筛选统计，若为 null 则不以此编号条件筛选）。
+	 * @param s_classid 代表学生所在班级的唯一标识编号（可为 null，若提供相应的值，可根据此班级编号对学生记录进行筛选统计，若为 null 则不按此条件操作）。
+	 * @param s_classname 代表学生所在班级的名称（可为 null，若提供相应的值，可根据此班级名称对学生记录进行模糊或精确筛选统计，若为 null 则不按此条件操作）。
+	 * @return 返回一个 Integer 类型的值，表示符合上述传入条件的学生记录的总条数。
+	 */
+	//获取总条数
+	public Integer totalCount(@Param("s_name") String s_name, @Param("s_studentid") Integer s_studentid,
+							  @Param("s_classid") Integer s_classid, @Param("s_classname") String s_classname);
+
+	/**
+	 * 获取用户列表的方法声明
+	 * 依据传入的多个筛选条件（包含学生姓名、学生编号、所在班级编号、所在班级名称等）以及指定的当前页码和每页显示数量，从数据库中获取相应页码对应的学生信息列表。
+	 * 使用 @Param 注解来明确各个参数的名称，确保在对应的 SQL 语句中可以精准地引用这些参数，进而正确获取期望的数据。
+	 *
+	 * @param s_name 学生的姓名（可为 null，用于在查询学生列表时根据姓名进行模糊或精确筛选，若为 null 则不按此条件筛选）。
+	 * @param s_studentid 学生的唯一标识编号（可为 null，用于按照具体编号精确筛选学生记录来获取列表，若为 null 则不按此条件筛选）。
+	 * @param s_classid 学生所在班级的唯一标识编号（可为 null，用于依据班级编号进行模糊或精确筛选获取学生信息列表，若为 null 则不按此条件筛选）。
+	 * @param s_classname 学生所在班级的名称（可为 null，用于依据班级名称进行模糊或精确筛选获取学生信息列表，若为 null 则不按此条件筛选）。
+	 * @param currentPage 用于指定当前页码，例如传入值为 1 时，表示要获取第一页的学生信息数据。
+	 * @param pageSize 用来确定每页显示的学生记录数量，比如传入值为 10，则每页会展示 10 条学生信息记录。
+	 * @return 返回一个 List<Student> 类型的列表，其中包含了符合条件的当前页码对应的学生信息记录，每条记录以 Student 对象的形式呈现。
+	 */
+	//获取用户列表
+	public List<Student> getStudentList(@Param("s_name") String s_name, @Param("s_studentid") Integer s_studentid,
+										@Param("s_classid") Integer s_classid, @Param("s_classname") String s_classname,
+										@Param("currentPage") Integer currentPage, @Param("pageSize") Integer pageSize);
+
 	/**
-	 * 进行分页查询
+	 * 删除学生信息的方法声明
+	 * 根据传入的代表学生唯一标识的编号（s_id），在数据库中查找并删除与之对应的学生记录，实现删除学生信息的业务功能。
+	 *
+	 * @param s_id 要删除的学生的唯一标识编号，通过这个编号可以准确地定位到数据库中需要删除的那条学生记录。
+	 * @return 返回一个整数类型的值，用以表示数据库受此删除操作影响的行数，正常情况下，若成功删除对应的学生记录，返回值为 1；若数据库中不存在该编号对应的学生记录导致删除失败，则返回值为 0（具体依据数据库操作的返回机制而定）。
 	 */
+	public int deleteStudent(Integer s_id);   //删除学生信息
 
-	 //获取总条数
+	/**
-     public Integer totalCount(@Param("s_name") String s_name, @Param("s_studentid")Integer s_studentid,
+	 * 添加学生信息的方法声明
-							   @Param("s_classid")Integer s_classid,@Param("s_classname")String s_classname);
+	 * 接收一个包含完整学生详细信息的 Student 对象，将该对象所承载的学生相关信息插入到数据库中，以此实现添加新学生记录的业务操作。
-	 //获取用户列表
+	 *
-     public List<Student> getStudentList(@Param("s_name") String s_name, @Param("s_studentid")Integer s_studentid,@Param("s_classid")Integer s_classid,
+	 * @param student 一个 Student 类型的对象，里面封装了要添加到数据库的学生的各项详细信息，比如学生的姓名、学号、所在班级等具体属性信息。
-										 @Param("s_classname")String s_classname, @Param("currentPage")Integer currentPage, @Param("pageSize")Integer pageSize);
+	 * @return 返回一个整数类型的值，该值表示数据库受此插入操作影响的行数，通常情况下，如果插入操作成功，则返回值为 1；若插入过程出现异常等导致失败，则返回值为 0（具体返回值情况取决于所使用的数据库操作的返回机制）。
+	 */
+	public int addStudent(Student student);   //添加学生信息
+
+	/**
+	 * 修改学生信息的方法声明
+	 * 接收一个包含已修改后的学生详细信息的 Student 对象，依据该对象中的信息去更新数据库中对应的学生记录内容，完成学生信息修改的业务操作。
+	 *
+	 * @param student 一个 Student 类型的对象，其中包含了经过修改后的学生各项信息，例如学生的联系方式发生变化后、家庭住址调整后的新信息等，通过这些信息来更新数据库中原有的学生记录。
+	 * @return 返回一个整数类型的值，用来体现数据库受此更新操作影响的行数，一般而言，更新操作成功时返回值为 1；若因某些原因（如数据不合法、记录不存在等）导致更新失败，则返回值为 0（具体取决于数据库操作的返回机制）。
+	 */
+	public int updateStudent(Student student); //修改学生信息
+
+	/**
+	 * 根据学生ID查询学生信息的方法声明
+	 * 依据传入的学生唯一标识编号（s_id），从数据库中查找并返回与之对应的学生详细记录信息，查询结果以 Student 对象的形式呈现，如果没有找到匹配的学生记录，则返回 null。
+	 *
+	 * @param s_id 用于在数据库中准确查找对应学生记录的唯一标识编号，通过它可以定位到特定的学生信息。
+	 * @return 返回一个 Student 类型的对象，里面封装了查找到的对应学生的详细信息，若数据库中不存在该编号对应的学生记录，则返回 null。
+	 */
+	public Student findStudentById(Integer s_id);
+
+	/**
+	 * 获取所有学生信息的方法声明
+	 * 用于从数据库中查询并返回所有的学生记录信息列表，这个方法在一些需要展示全部学生基本情况或者进行全量数据处理等业务场景下会被调用使用。
+	 *
+	 * @return 返回一个 List<Student> 类型的列表，里面包含了数据库中存储的所有学生的详细记录信息，以 Student 对象形式呈现。
+	 */
+	public List<Student> getAll();
 
-	 public int deleteStudent(Integer s_id);   //删除学生信息
+}
-	 public int addStudent(Student student);   //添加学生信息
-	 public int updateStudent(Student student); //修改学生信息
-	 public Student findStudentById(Integer s_id);
-	 public List<Student> getAll();
-}

src/com/itheima/dao/VisitorDao.java

@@ -7,21 +7,59 @@ import java.util.List;
 
 /**
  * @program: dormitorySystem
- * @description: 访客
+ * @description: 访客，该接口主要定义了针对访客相关数据进行操作的一系列方法，这些方法会在对应的数据库访问实现类（例如MyBatis的Mapper XML文件对应的实现类）中进行实现，
+ * 进而完成访客数据在数据库中的分页查询、添加以及获取全部访客信息等操作。
  * @author: Joyrocky
  * @create: 2019-05-14 12:57
  **/
 public interface VisitorDao {
+
     /**
-     * 进行分页查询
+     * 进行分页查询相关操作的方法声明部分
+     * 分页查询通常包含两个关键步骤，一是统计符合条件的记录总条数，二是获取指定页码对应的记录列表，以下两个方法分别对应这两个功能。
      */
 
+    /**
+     * 获取总条数的方法声明
+     * 根据传入的访客姓名以及访客电话号码等条件，从数据库中统计出符合这些条件的访客记录的总条数。
+     * 使用了@Param注解为参数指定名称，方便在对应的SQL语句（例如MyBatis的Mapper XML文件里的SQL语句）中准确引用这些参数进行条件筛选和数据统计。
+     *
+     * @param v_name 访客姓名（可为null，用于根据访客姓名进行模糊或精确筛选统计，若为null则不按此条件筛选）。
+     * @param v_phone 访客电话号码（可为null，用于根据访客电话号码进行精确筛选统计，若为null则不按此条件筛选）。
+     * @return 返回符合条件的访客记录的总条数，类型为Integer。
+     */
     //获取总条数
-    public Integer totalCount(@Param("v_name") String v_name, @Param("v_phone")Integer v_phone);
+    public Integer totalCount(@Param("v_name") String v_name, @Param("v_phone") Integer v_phone);
+
+    /**
+     * 获取用户列表的方法声明
+     * 根据传入的访客姓名、访客电话号码以及当前页码、每页显示数量等条件，从数据库中获取对应页的访客记录信息列表。
+     * 通过@Param注解明确参数名称，确保在SQL语句中能正确引用各参数来获取准确的数据。
+     *
+     * @param v_name 访客姓名（可为null，用于根据访客姓名进行模糊或精确筛选获取列表，若为null则不按此条件筛选）。
+     * @param v_phone 访客电话号码（可为null，用于根据访客电话号码进行精确筛选获取列表，若为null则不按此条件筛选）。
+     * @param currentPage 当前页码，用于确定要获取哪一页的数据，例如currentPage为1表示获取第一页的访客记录信息。
+     * @param pageSize  每页显示的记录数量，比如pageSize为10表示每页展示10条访客记录信息。
+     * @return 返回符合条件的当前页的访客记录信息列表，类型为List<Visitor>。
+     */
     //获取用户列表
-    public List<Visitor> getVisitorList(@Param("v_name") String v_name, @Param("v_phone")Integer v_phone,@Param("currentPage")Integer currentPage, @Param("pageSize")Integer pageSize);
+    public List<Visitor> getVisitorList(@Param("v_name") String v_name, @Param("v_phone") Integer v_phone, @Param("currentPage") Integer currentPage, @Param("pageSize") Integer pageSize);
 
+    /**
+     * 添加学生信息的方法声明，此处准确来说应该是添加访客信息的方法声明，可能存在命名上的小瑕疵。
+     * 接收一个包含访客详细信息的Visitor对象，将其信息插入到数据库中，实现添加访客记录的操作。
+     *
+     * @param visitor 包含要添加的访客详细信息的对象，例如访客姓名、电话号码、来访事由等相关信息。
+     * @return 返回一个整数，表示数据库受影响的行数，通常添加成功返回1，添加失败返回0等情况（具体取决于数据库操作的返回机制）。
+     */
     public int addVisitor(Visitor visitor);   //添加学生信息
+
+    /**
+     * 获取所有访客信息的方法声明
+     * 从数据库中查询并返回所有的访客记录信息列表，用于一些需要获取全部访客数据的场景，比如展示所有访客的基本情况或者进行全量访客数据处理等操作。
+     *
+     * @return 返回包含所有访客信息的列表，类型为List<Visitor>。
+     */
     public List<Visitor> getAll();
 
-}
+}

src/com/itheima/interceptor/Loginlnterceptor.java

@@ -9,39 +9,84 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 
 /**
- * 登录拦截器
+ * 登录拦截器，用于对系统中的请求进行拦截并判断用户是否登录，以此来控制对不同页面或资源的访问权限，
+ * 确保只有已登录的用户能够访问受保护的页面或执行相应的操作。
  */
 public class Loginlnterceptor implements HandlerInterceptor {
+
+    /**
+     * preHandle方法在请求处理之前被调用，主要用于进行请求的预处理和访问控制判断。
+     *
+     * @param request 当前的HttpServletRequest对象，包含了客户端发送过来的请求相关信息，比如请求的URL、请求参数等。
+     * @param response 当前的HttpServletResponse对象，用于向客户端返回响应信息，如设置响应状态码、响应头、响应内容等。
+     * @param handler 被拦截的请求对应的处理器对象（例如Controller中的方法对应的处理器），可以用来获取更多关于请求处理的相关信息，不过在这里代码中暂未体现对其的使用。
+     * @return 返回一个布尔值，若返回true，表示允许请求继续向下执行，后续的请求处理流程（如调用相应的Controller方法等）会正常进行；若返回false，则会中断请求，直接返回响应给客户端，不再执行后续的处理逻辑。
+     * @throws Exception 如果在处理过程中出现异常，则会抛出异常，异常会根据Spring框架的异常处理机制进行相应的处理。
+     */
     @Override
     public boolean preHandle(HttpServletRequest request,
                              HttpServletResponse response, Object handler) throws Exception {
-        // 获取请求的URL
+        // 获取请求的URL，通过getRequestURI方法可以得到客户端请求的具体资源路径（不包含上下文路径等额外信息），例如：/user/list这样的格式，方便后续根据URL进行访问权限判断。
         String url = request.getRequestURI();
-        // URL:除了login.jsp是可以公开访问的，其它的URL都进行拦截控制
+
-        if(url.indexOf("/login")>=0){
+        // URL:除了login.jsp是可以公开访问的，其它的URL都进行拦截控制，这里通过判断URL中是否包含"/login"来确定是否是登录相关的页面请求。
+        // 如果包含"/login"，说明是登录页面的请求，允许其直接访问，所以返回true。
+        if (url.indexOf("/login") >= 0) {
             return true;
         }
-        // 获取Session
+
+        // 获取Session，通过HttpServletRequest的getSession方法可以获取到与当前请求关联的HttpSession对象，
+        // HttpSession用于在服务器端存储和获取用户相关的数据，实现跨请求的数据共享等功能。
         HttpSession session = request.getSession();
+
+        // 从Session中尝试获取名为"admin"的属性值，并将其转换为Admin对象，这里假设在用户登录成功后，会将用户的登录信息（以Admin对象形式）存储在Session中，方便后续进行登录状态验证等操作。
         Admin admin = (Admin) session.getAttribute("admin");
-        // 判断Session中是否有用户数据，如果有，则返回true,继续向下执行
+
-        if(admin != null){
+        // 判断Session中是否有用户数据（即Admin对象是否为null），如果不为null，说明用户已经登录，允许请求继续向下执行，返回true。
+        if (admin!= null) {
             return true;
         }
-        // 不符合条件的给出提示信息，并转发到主页面
+
+        // 不符合条件的给出提示信息，并转发到主页面，这里通过向请求对象中设置属性"msga"，将提示信息传递给页面进行显示。
         request.setAttribute("msga", "您还没有登录，请先登录！");
+
+        // 使用getRequestDispatcher方法获取请求转发器，然后将请求转发到"/shopping homepage.jsp"页面，这样客户端接收到的响应就是该页面的内容，同时显示相应的提示信息。
         request.getRequestDispatcher("/shopping homepage.jsp")
                 .forward(request, response);
+
+        // 由于不符合登录验证条件，不允许请求继续向下执行，所以返回false，中断请求处理流程。
         return false;
     }
+
+    /**
+     * postHandle方法在请求处理之后、视图渲染之前被调用，可用于对请求处理后的结果进行一些额外的处理或修改，
+     * 例如可以向ModelAndView对象中添加额外的数据等操作，但在当前代码中并没有具体的实现逻辑，为空方法体。
+     *
+     * @param request 当前的HttpServletRequest对象，同preHandle方法中的作用类似，包含请求相关信息。
+     * @param response 当前的HttpServletResponse对象，用于响应相关操作，同preHandle方法中的作用类似。
+     * @param handler 被拦截的请求对应的处理器对象，同preHandle方法中的含义相同。
+     * @param modelAndView 包含了视图和模型数据的对象，可用于在视图渲染前对视图和数据进行调整，不过这里暂未使用。
+     * @throws Exception 如果在处理过程中出现异常，则会抛出异常，由框架进行相应处理。
+     */
     @Override
     public void postHandle(HttpServletRequest request,
                            HttpServletResponse response, Object handler,
                            ModelAndView modelAndView) throws Exception {
     }
+
+    /**
+     * afterCompletion方法在整个请求处理完成（包括视图渲染完成）之后被调用，可用于进行一些资源清理、记录日志等收尾工作，
+     * 在当前代码中也没有具体的实现逻辑，为空方法体。
+     *
+     * @param request 当前的HttpServletRequest对象，包含请求相关信息。
+     * @param response 当前的HttpServletResponse对象，用于响应相关操作。
+     * @param handler 被拦截的请求对应的处理器对象。
+     * @param ex 如果在请求处理过程中出现了异常，此处会传入该异常对象，方便进行异常相关的后续处理，不过这里暂未体现对异常的处理操作。
+     * @throws Exception 如果在处理过程中出现新的异常，则会抛出异常，由框架进行相应处理。
+     */
     @Override
     public void afterCompletion(HttpServletRequest request,
                                 HttpServletResponse response, Object handler, Exception ex)
             throws Exception {
     }
-}
+}

src/com/itheima/po/Admin.java

@@ -2,74 +2,101 @@ package com.itheima.po;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 
+// Admin类，通常用于表示系统中的管理员实体信息，包含了管理员的各种属性，如编号、用户名、密码、姓名、电话号码、权限等级以及描述信息等。
 public class Admin {
-    private  Integer a_id;
-    private  String  a_username;
 
+    // 管理员的唯一标识编号，用于在系统中唯一确定一个管理员，通常对应数据库表中的主键字段。
+    private Integer a_id;
+
+    // 管理员的登录用户名，用于登录系统时进行身份验证，是管理员在系统中对外展示的标识之一。
+    private String a_username;
+
+    // 使用@JsonIgnore注解标注，表示在进行JSON序列化（例如将该对象转换为JSON格式数据返回给前端等场景）时，忽略该属性，不将其包含在生成的JSON数据中，以此来隐藏密码信息，增强安全性。
+    // 管理员登录系统时使用的密码，是重要的隐私信息，需要进行妥善保护，避免在数据传输等过程中被泄露。
     @JsonIgnore
-    private  String  a_password;
+    private String a_password;
+
+    // 管理员的真实姓名，用于在系统中更直观地展示管理员的个人信息，方便内部识别和管理。
+    private String a_name;
 
-    private  String  a_name;
+    // 管理员的联系电话号码，可用于在必要时进行沟通联系等操作。
-    private  Integer a_phone;
+    private Integer a_phone;
 
+    // 使用@JsonIgnore注解标注，同样在JSON序列化时会忽略该属性，不对外暴露管理员的权限等级信息，防止权限信息被随意获取，保障系统的权限管理安全性。
+    // 代表管理员在系统中所拥有的权限等级，不同的权限等级可能对应不同的操作权限，例如可以操作哪些模块、执行哪些功能等。
     @JsonIgnore
-    private  Integer a_power;
+    private Integer a_power;
 
-    private  String  a_describe;
+    // 管理员的相关描述信息，可用于记录一些关于管理员的额外备注内容，比如所属部门、工作职责等相关说明。
+    private String a_describe;
 
+    // 获取管理员的唯一标识编号的方法，供外部类访问该私有属性的值。
     public Integer getA_id() {
         return a_id;
     }
 
+    // 设置管理员的唯一标识编号的方法，供外部类修改该私有属性的值。
     public void setA_id(Integer a_id) {
         this.a_id = a_id;
     }
 
+    // 获取管理员登录用户名的方法，方便外部类获取该属性值用于相关业务逻辑处理，比如登录验证等操作。
     public String getA_username() {
         return a_username;
     }
 
+    // 设置管理员登录用户名的方法，外部类可以通过该方法来更新管理员的用户名信息（不过在实际应用中，用户名的修改可能会受到一些业务规则限制）。
     public void setA_username(String a_username) {
         this.a_username = a_username;
     }
 
+    // 获取管理员登录密码的方法，由于有@JsonIgnore注解，外部一般不会在JSON数据获取场景下得到该密码，这里主要用于在类内部或者特定的业务逻辑需要获取密码时使用（如密码验证等操作）。
     public String getA_password() {
         return a_password;
     }
 
+    // 设置管理员登录密码的方法，用于更新管理员的密码信息，在密码修改等业务场景中会被调用，同时要注意密码的加密存储等安全处理方式。
     public void setA_password(String a_password) {
         this.a_password = a_password;
     }
 
+    // 获取管理员真实姓名的方法，外部类可以获取该属性值用于在界面展示管理员姓名等相关操作。
     public String getA_name() {
         return a_name;
     }
 
+    // 设置管理员真实姓名的方法，供外部类修改管理员的姓名信息（同样可能受到业务规则限制，比如需要审核等情况）。
     public void setA_name(String a_name) {
         this.a_name = a_name;
     }
 
+    // 获取管理员联系电话号码的方法，方便外部类获取该属性值用于诸如发送通知短信等相关业务操作。
     public Integer getA_phone() {
         return a_phone;
     }
 
+    // 设置管理员联系电话号码的方法，用于更新管理员的电话号码信息，不过要遵循相应的号码格式验证等业务规则。
     public void setA_phone(Integer a_phone) {
         this.a_phone = a_phone;
     }
 
+    // 获取管理员权限等级的方法，因为有@JsonIgnore注解，外部通常不会在JSON相关获取场景下拿到权限值，主要用于内部的权限判断等业务逻辑。
     public Integer getA_power() {
         return a_power;
     }
 
+    // 设置管理员权限等级的方法，用于更新管理员的权限等级信息，一般需要严格的权限管理流程来控制谁能修改以及如何修改权限等级。
     public void setA_power(Integer a_power) {
         this.a_power = a_power;
     }
 
+    // 获取管理员相关描述信息的方法，外部类可以获取该属性值用于查看管理员的备注说明等相关操作。
     public String getA_describe() {
         return a_describe;
     }
 
+    // 设置管理员相关描述信息的方法，供外部类更新管理员的描述内容，例如修改所属部门等备注信息时会使用到。
     public void setA_describe(String a_describe) {
         this.a_describe = a_describe;
     }
-}
+}

src/com/itheima/po/Class.java

@@ -2,51 +2,71 @@ package com.itheima.po;
 
 import java.util.List;
 
+// Class类，通常用于表示班级这一实体信息，包含了班级相关的各种属性以及和学生之间的关联关系，用于在系统中对班级相关数据进行建模和操作。
 public class Class {
-    private  Integer c_id;
-    private  Integer c_classid;
-    private  String  c_classname;
-    private  String  c_counsellor;
-    //班级与学生为一对多关系，使用链表
-    private List<Student>  students;
 
+    // 班级的唯一标识编号，用于在系统中唯一确定一个班级实体，大概率对应数据库表中的主键字段，方便在数据库操作以及系统业务逻辑中准确地定位和区分不同班级。
+    private Integer c_id;
+
+    // 班级的编号（可能是业务上特定的班级编号，与主键编号有所区别，具体取决于业务场景设定），用于标识班级在学校等机构内部的编号情况，例如年级+班级序号等形式的编号。
+    private Integer c_classid;
+
+    // 班级的名称，直观地展示班级的称呼，例如“高三（1）班”等，方便在系统界面以及相关业务操作中进行识别和展示。
+    private String c_classname;
+
+    // 班级辅导员的姓名，用于记录负责该班级管理和指导工作的辅导员信息，方便在需要联系辅导员或者查询班级管理相关责任人时使用。
+    private String c_counsellor;
+
+    // 班级与学生为一对多关系，使用链表。这里表示一个班级可以包含多个学生，通过List<Student>类型的属性来存储与该班级关联的所有学生信息，体现了面向对象编程中对象之间的关联关系，方便进行诸如查询班级所有学生、对班级学生进行批量操作等业务逻辑处理。
+    private List<Student> students;
+
+    // 获取班级的唯一标识编号的方法，供外部类访问该私有属性的值，以便在其他业务逻辑中使用班级编号进行相关操作，比如根据班级编号查询班级详细信息等。
     public Integer getC_id() {
         return c_id;
     }
 
+    // 设置班级的唯一标识编号的方法，供外部类修改该私有属性的值，不过在实际应用中班级编号的修改可能会受到业务规则的严格限制，因为它通常作为重要的标识信息。
     public void setC_id(Integer c_id) {
         this.c_id = c_id;
     }
 
+    // 获取班级编号（业务特定编号）的方法，外部类可获取该属性值用于如按特定编号规则进行班级筛选、统计等业务操作。
     public Integer getC_classid() {
         return c_classid;
     }
 
+    // 设置班级编号（业务特定编号）的方法，用于更新班级的这个特定编号信息，同样可能需要遵循一定的业务规则来确保编号的合理性和唯一性等。
     public void setC_classid(Integer c_classid) {
         this.c_classid = c_classid;
     }
 
+    // 获取班级名称的方法，方便外部类获取该属性值用于在系统界面展示班级名称、进行班级搜索等相关业务操作。
     public String getC_classname() {
         return c_classname;
     }
 
+    // 设置班级名称的方法，供外部类修改班级的名称信息，例如班级名称发生变更时可通过此方法来更新，不过可能需要经过相应的审批流程等业务环节。
     public void setC_classname(String c_classname) {
         this.c_classname = c_classname;
     }
 
+    // 获取班级辅导员姓名的方法，外部类可以获取该属性值用于联系辅导员、查看班级管理责任人等相关业务操作。
     public String getC_counsellor() {
         return c_counsellor;
     }
 
+    // 设置班级辅导员姓名的方法，用于更新班级辅导员的相关信息，比如辅导员更换时可通过此方法来记录新的辅导员姓名。
     public void setC_counsellor(String c_counsellor) {
         this.c_counsellor = c_counsellor;
     }
 
+    // 获取与该班级关联的所有学生信息的列表的方法，外部类可以通过此方法获取班级学生集合，进而进行如遍历学生、对学生进行批量操作等业务逻辑，例如统计班级学生人数、查询班级成绩排名等操作都可能会用到这个学生列表。
     public List<Student> getStudents() {
         return students;
     }
 
+    // 设置与该班级关联的所有学生信息的列表的方法，供外部类更新班级学生的关联情况，不过在实际应用中，对学生列表的更新可能涉及较为复杂的业务逻辑，比如新增学生到班级、将学生从班级移除等操作都需要相应的业务规则和数据处理逻辑来保证数据的准确性和一致性。
     public void setStudents(List<Student> students) {
         this.students = students;
     }
-}
+}

src/com/itheima/po/DormClean.java

@@ -6,67 +6,93 @@ import java.util.Date;
 
 /**
  * @program: dormitorySystem
- * @description: 宿舍卫生
+ * @description: 宿舍卫生，该类用于表示宿舍卫生相关的实体信息，包含了诸如宿舍卫生记录的唯一标识、宿舍相关编号、宿舍楼栋信息、卫生评分等级以及创建时间和更新时间等属性，
+ * 方便在宿舍管理系统等相关业务场景中对宿舍卫生数据进行存储、传输和操作。
  * @author: Joyrocky
  * @create: 2019-04-24 11:21
  **/
 public class DormClean {
+
+    // 宿舍卫生记录的唯一标识编号，通常对应数据库表中的主键字段，用于在系统中唯一确定一条宿舍卫生记录，方便进行诸如查询、修改、删除等针对具体卫生记录的操作。
     private Integer g_id;
+
+    // 宿舍的编号或者相关标识ID（具体含义取决于业务系统中的定义），用于关联到具体的宿舍，可能在查询某个宿舍的卫生情况或者按宿舍进行卫生数据统计等业务场景中会用到。
     private Integer d_id;
-    private String  d_dormbuilding;
+
+    // 宿舍楼栋信息，例如可以是楼栋的名称（如“1号楼”）或者编号等，用于区分不同的宿舍楼，便于从不同维度（按楼栋）来查看和管理宿舍卫生情况。
+    private String d_dormbuilding;
+
+    // 宿舍卫生的评分等级，用于量化宿舍卫生的好坏程度，不同的数值可能对应不同的卫生评价标准，比如1 - 5分，分数越高表示卫生状况越好等情况，方便进行卫生情况的比较和统计分析。
     private Integer d_grade;
 
-    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
+    // 使用@JsonFormat注解对日期格式进行格式化设置，指定了将Date类型的时间数据转换为指定格式的字符串（"yyyy-MM-dd HH:mm:ss"这种常见的日期时间格式），
+    // 并且设置了时区为"GMT+8"（东八区，即北京时间所在时区），这样在将该对象转换为JSON数据（比如返回给前端展示）时，日期时间数据会按照指定格式和时区进行正确展示，增强数据展示的可读性和规范性。
+    // 宿舍卫生记录的创建时间，记录该条卫生记录首次生成的时间点，可用于查看卫生记录的历史情况、按时间范围查询卫生记录等业务操作。
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date create_time;
-    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
+
+    // 同样使用@JsonFormat注解进行日期格式和时区设置，用于将Date类型的更新时间按照指定格式转换。
+    // 宿舍卫生记录的更新时间，记录该条卫生记录最后一次被修改的时间点，例如宿舍卫生情况发生变化后重新评分、记录相关备注信息修改等操作都会更新这个时间字段，方便跟踪记录的变更历史。
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date update_time;
 
+    // 获取宿舍卫生记录的唯一标识编号的方法，供外部类访问该私有属性的值，以便在其他业务逻辑中依据此编号对相应的卫生记录进行操作，比如根据编号查找特定的卫生记录详情等。
     public Integer getG_id() {
         return g_id;
     }
 
+    // 设置宿舍卫生记录的唯一标识编号的方法，供外部类修改该私有属性的值，不过在实际应用中，这个编号作为主键通常不会随意修改，可能会受到业务规则的严格限制。
     public void setG_id(Integer g_id) {
         this.g_id = g_id;
     }
 
+    // 获取宿舍编号（或相关标识ID）的方法，外部类可获取该属性值用于关联到具体宿舍进行相关卫生数据操作，例如查询某个宿舍的多次卫生记录等。
     public Integer getD_id() {
         return d_id;
     }
 
+    // 设置宿舍编号（或相关标识ID）的方法，用于更新宿舍对应的这个标识信息，不过也要遵循相应的业务规则来保证数据的准确性和关联性。
     public void setD_id(Integer d_id) {
         this.d_id = d_id;
     }
 
+    // 获取宿舍楼栋信息的方法，方便外部类获取该属性值用于按楼栋查看卫生情况、统计各楼栋的卫生数据等相关业务操作。
     public String getD_dormbuilding() {
         return d_dormbuilding;
     }
 
+    // 设置宿舍楼栋信息的方法，供外部类修改该属性值，比如楼栋名称发生变更等情况下可通过此方法来更新，不过可能需要相应的审核等业务流程。
     public void setD_dormbuilding(String d_dormbuilding) {
         this.d_dormbuilding = d_dormbuilding;
     }
 
+    // 获取宿舍卫生评分等级的方法，外部类可以获取该属性值用于查看宿舍卫生状况、进行卫生等级统计分析等业务操作，比如统计各等级卫生宿舍的数量等。
     public Integer getD_grade() {
         return d_grade;
     }
 
+    // 设置宿舍卫生评分等级的方法，用于更新宿舍的卫生评分信息，例如重新检查宿舍卫生后调整评分时会用到此方法，要遵循相应的评分标准和业务规则来修改等级。
     public void setD_grade(Integer d_grade) {
         this.d_grade = d_grade;
     }
 
+    // 获取宿舍卫生记录创建时间的方法，外部类可以获取该属性值用于查看卫生记录的创建历史、按时间范围筛选卫生记录等业务操作，比如查询某个时间段内新创建的卫生记录等。
     public Date getCreate_time() {
         return create_time;
     }
 
+    // 设置宿舍卫生记录创建时间的方法，一般来说创建时间在记录首次生成时确定，后续很少会去修改它，不过如果有特殊的业务需求（比如数据纠错等情况）可通过此方法来更新，同样要遵循相关业务规范。
     public void setCreate_time(Date create_time) {
         this.create_time = create_time;
     }
 
+    // 获取宿舍卫生记录更新时间的方法，外部类可以获取该属性值用于查看卫生记录的最近修改情况、跟踪记录变更历史等业务操作，例如查看哪些卫生记录近期有过变动等。
     public Date getUpdate_time() {
         return update_time;
     }
 
+    // 设置宿舍卫生记录更新时间的方法，在宿舍卫生记录相关信息发生修改时，系统内部会调用此方法来更新这个时间字段，以准确记录最后一次更新的时间点，保证数据变更历史的准确性。
     public void setUpdate_time(Date update_time) {
         this.update_time = update_time;
     }
-}
+}
-

src/com/itheima/po/DormRepair.java

@@ -6,76 +6,106 @@ import java.util.Date;
 
 /**
  * @program: dormitorySystem
- * @description: 维修登记
+ * @description: 维修登记，该类用于表示宿舍维修相关的实体信息，包含了如维修记录的唯一标识、宿舍相关编号、宿舍楼栋编号、维修项目名称、维修原因以及维修记录的创建时间和更新时间等属性，
+ * 便于在宿舍维修管理相关业务场景中对维修数据进行存储、查询、展示以及操作等。
  * @author: Joyrocky
  * @create: 2019-04-28 00:23
  **/
 public class DormRepair {
+
+    // 宿舍维修记录的唯一标识编号，通常对应数据库表中的主键字段，用于在系统中唯一确定一条宿舍维修记录，方便后续针对具体的维修记录进行查看详情、修改或者删除等操作。
     private int r_id;
+
+    // 宿舍的编号或者相关标识ID（具体含义取决于业务系统中的定义），用于关联到具体的宿舍，这样就能明确是哪个宿舍需要进行维修或者查看某个宿舍过往的维修历史情况等。
     private int d_id;
+
+    // 宿舍楼栋的编号（可能与前面宿舍编号关联使用来更精准地定位宿舍位置），用于区分不同的宿舍楼，便于从楼栋维度来统计维修情况、安排维修人员等，比如查看某栋楼的维修任务量等业务操作。
     private int d_dormbuilding;
+
+    // 维修项目的名称，例如“水龙头维修”“电路检修”等，清晰地表明此次维修具体针对的是宿舍内哪方面设施的问题，方便维修人员知晓维修内容以及后续进行维修情况统计分析等。
     private String r_name;
+
+    // 维修原因的描述信息，详细说明了宿舍设施出现问题的缘由，比如“水龙头漏水”“灯泡损坏”等具体情况，有助于维修人员提前准备维修工具和材料等，也方便对维修问题进行分类和查询。
     private String reason;
 
-    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
+    // 使用@JsonFormat注解对日期格式进行格式化设置，指定了将Date类型的时间数据转换为指定格式的字符串（"yyyy-MM-dd HH:mm:ss"这种常见的日期时间格式），
+    // 并且设置了时区为"GMT+8"（东八区，即北京时间所在时区），这样在将该对象转换为JSON数据（比如返回给前端展示）时，日期时间数据会按照指定格式和时区进行正确展示，增强数据展示的可读性和规范性。
+    // 宿舍维修记录的创建时间，记录该条维修记录首次生成的时间点，可用于查看维修记录的历史情况、按时间范围查询维修记录等业务操作，例如统计某个时间段内新增了多少维修任务等。
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date create_time;
-    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
+
+    // 同样使用@JsonFormat注解进行日期格式和时区设置，用于将Date类型的更新时间按照指定格式转换。
+    // 宿舍维修记录的更新时间，记录该条维修记录最后一次被修改的时间点，比如维修进度有更新、维修结果有变动等情况都会更新这个时间字段，方便跟踪维修记录的变更历史。
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date update_time;
 
+    // 获取宿舍维修记录的唯一标识编号的方法，供外部类访问该私有属性的值，以便在其他业务逻辑中依据此编号对相应的维修记录进行操作，比如根据编号查找特定维修记录的详细情况等。
     public int getR_id() {
         return r_id;
     }
 
+    // 设置宿舍维修记录的唯一标识编号的方法，供外部类修改该私有属性的值，不过在实际应用中，这个编号作为主键通常不会随意修改，可能会受到业务规则的严格限制。
     public void setR_id(int r_id) {
         this.r_id = r_id;
     }
 
+    // 获取宿舍编号（或相关标识ID）的方法，外部类可获取该属性值用于关联到具体宿舍进行相关维修数据操作，例如查询某个宿舍的多次维修记录等。
     public int getD_id() {
         return d_id;
     }
 
+    // 设置宿舍编号（或相关标识ID）的方法，用于更新宿舍对应的这个标识信息，不过也要遵循相应的业务规则来保证数据的准确性和关联性。
     public void setD_id(int d_id) {
         this.d_id = d_id;
     }
 
+    // 获取宿舍楼栋编号的方法，方便外部类获取该属性值用于按楼栋查看维修情况、统计各楼栋的维修数据等相关业务操作，比如统计各楼栋的维修次数等。
     public int getD_dormbuilding() {
         return d_dormbuilding;
     }
 
+    // 设置宿舍楼栋编号的方法，供外部类修改该属性值，不过楼栋编号的修改一般需要谨慎操作，要确保与实际的楼栋情况相符，且遵循相应的业务流程。
     public void setD_dormbuilding(int d_dormbuilding) {
         this.d_dormbuilding = d_dormbuilding;
     }
 
+    // 获取维修项目名称的方法，外部类可以获取该属性值用于查看维修内容、进行维修项目分类统计等业务操作，例如统计各类维修项目的出现频率等。
     public String getR_name() {
         return r_name;
     }
 
+    // 设置维修项目名称的方法，用于更新维修项目的相关信息，比如维修内容有变更或者记录有误需要修改时可通过此方法来调整，要确保名称能准确反映实际维修情况。
     public void setR_name(String r_name) {
         this.r_name = r_name;
     }
 
+    // 获取维修原因描述信息的方法，外部类可以获取该属性值用于了解宿舍设施具体问题、对维修原因进行分类分析等业务操作，例如查找因同一类原因导致的维修记录等。
     public String getReason() {
         return reason;
     }
 
+    // 设置维修原因描述信息的方法，用于更新维修原因的相关内容，比如对问题原因描述不准确进行修正或者补充更详细的情况时可通过此方法来操作，保证维修原因记录的准确性。
     public void setReason(String reason) {
         this.reason = reason;
     }
 
+    // 获取宿舍维修记录创建时间的方法，外部类可以获取该属性值用于查看维修记录的创建历史、按时间范围筛选维修记录等业务操作，比如查询某个时间段内新生成的维修记录等。
     public Date getCreate_time() {
         return create_time;
     }
 
+    // 设置宿舍维修记录创建时间的方法，一般来说创建时间在记录首次生成时确定，后续很少会去修改它，不过如果有特殊的业务需求（比如数据纠错等情况）可通过此方法来更新，同样要遵循相关业务规范。
     public void setCreate_time(Date create_time) {
         this.create_time = create_time;
     }
 
+    // 获取宿舍维修记录更新时间的方法，外部类可以获取该属性值用于查看维修记录的最近修改情况、跟踪记录变更历史等业务操作，例如查看哪些维修记录近期有过变动等。
     public Date getUpdate_time() {
         return update_time;
     }
 
+    // 设置宿舍维修记录更新时间的方法，在宿舍维修记录相关信息发生修改时，系统内部会调用此方法来更新这个时间字段，以准确记录最后一次更新的时间点，保证数据变更历史的准确性。
     public void setUpdate_time(Date update_time) {
         this.update_time = update_time;
     }
-}
+}
-

src/com/itheima/po/Dormitory.java

@@ -3,70 +3,107 @@ package com.itheima.po;
 import java.io.Serializable;
 import java.util.List;
 
+// Dormitory类，通常用于表示宿舍这一实体信息，实现了Serializable接口以支持对象的序列化操作（例如在网络传输、持久化存储等场景下将对象转换为字节流的形式），
+// 该类包含了宿舍相关的各种属性以及和学生之间的关联关系，方便在宿舍管理相关系统中对宿舍数据进行操作、存储和传递等。
 public class Dormitory implements Serializable {
+
+    // serialVersionUID是用于在序列化和反序列化过程中验证类版本一致性的唯一标识符。
+    // 当类的结构发生变化（如新增、删除字段等）时，如果这个版本号不一致，可能会导致反序列化失败，这里定义了一个固定的版本号1L，表明当前类的初始版本状态。
     private static final long serialVersionUID = 1L;
-    private  Integer d_id;
-    private  Integer s_dormitoryid;
-    private  String  d_dormbuilding;
-    private  String  d_bedtotal;
-    private  String  d_bed;
-    private  String  a_name;
 
+    // 宿舍的唯一标识编号，大概率对应数据库表中的主键字段，用于在系统中唯一确定一个宿舍实体，方便进行诸如查询宿舍详情、对宿舍进行管理操作（修改、删除等）时准确地定位到具体的宿舍。
+    private Integer d_id;
+
+    // 宿舍的编号（可能是业务上特定的宿舍编号，与主键编号有所区别，具体取决于业务场景设定），例如按照一定规则编排的宿舍房间号等，用于在系统中更明确地标识每个宿舍，便于管理和区分不同的宿舍单元。
+    private Integer s_dormitoryid;
+
+    // 宿舍楼栋信息，比如可以是楼栋的名称（像“2号楼”）或者编号等形式，用于区分不同的宿舍楼，方便从楼栋维度来管理和查询宿舍相关信息，例如查看某栋楼的所有宿舍情况等。
+    private String d_dormbuilding;
+
+    // 宿舍床位总数的相关描述信息，可能是以数字形式（如“6”表示有6个床位）或者包含一些其他说明的字符串（如“6人间”）来体现宿舍可容纳的床位数量，便于了解宿舍的规模情况。
+    private String d_bedtotal;
+
+    // 宿舍已占用床位的相关信息，同样可以是用数字或者特定格式的字符串来表示当前宿舍哪些床位已经有学生入住等情况，方便进行宿舍床位管理和统计。
+    private String d_bed;
+
+    // 宿舍管理员的姓名，用于记录负责该宿舍管理工作的人员信息，方便在需要联系管理员或者查看宿舍管理责任人时使用。
+    private String a_name;
+
+    // 宿舍与学生为一对多关系，使用链表。这里表示一个宿舍可以容纳多个学生，通过List<Student>类型的属性来存储与该宿舍关联的所有学生信息，体现了对象之间的关联关系，方便后续进行诸如查询宿舍内学生名单、对宿舍学生进行统一管理等业务逻辑处理。
     private List<Student> students;
 
+    // 获取类的序列化版本号的方法，不过由于serialVersionUID是静态常量，一般不会去修改它，此方法主要是遵循Java中获取该属性的规范写法，外部类可以通过此方法获取版本号信息（虽然实际使用场景相对较少）。
     public static long getSerialVersionUID() {
         return serialVersionUID;
     }
 
+    // 获取宿舍的唯一标识编号的方法，供外部类访问该私有属性的值，以便在其他业务逻辑中使用宿舍编号进行相关操作，比如根据编号查询宿舍详细信息、在宿舍分配等业务中依据编号来确定具体宿舍等。
     public Integer getD_id() {
         return d_id;
     }
 
+    // 设置宿舍的唯一标识编号的方法，供外部类修改该私有属性的值，不过在实际应用中宿舍编号作为重要的标识信息，其修改可能会受到业务规则的严格限制。
     public void setD_id(Integer d_id) {
         this.d_id = d_id;
     }
 
+    // 获取宿舍编号（业务特定编号）的方法，外部类可获取该属性值用于如按特定编号规则进行宿舍筛选、统计等业务操作，例如按照房间号顺序查找宿舍等情况。
     public Integer getS_dormitoryid() {
         return s_dormitoryid;
     }
 
+    // 设置宿舍编号（业务特定编号）的方法，用于更新宿舍的这个特定编号信息，同样可能需要遵循一定的业务规则来确保编号的合理性和唯一性等。
     public void setS_dormitoryid(Integer s_dormitoryid) {
         this.s_dormitoryid = s_dormitoryid;
     }
 
-    public String getD_dormbuilding() {return d_dormbuilding;}
+    // 获取宿舍楼栋信息的方法，方便外部类获取该属性值用于按楼栋查看宿舍情况、统计各楼栋宿舍数据等相关业务操作，比如查询某栋楼的空宿舍数量等。
+    public String getD_dormbuilding() {
+        return d_dormbuilding;
+    }
 
-    public void setD_dormbuilding(String d_dormbuilding) {this.d_dormbuilding = d_dormbuilding;}
+    // 设置宿舍楼栋信息的方法，供外部类修改该属性值，比如楼栋名称发生变更等情况下可通过此方法来更新，不过可能需要相应的审核等业务流程。
+    public void setD_dormbuilding(String d_dormbuilding) {
+        this.d_dormbuilding = d_dormbuilding;
+    }
 
+    // 获取宿舍床位总数描述信息的方法，外部类可以获取该属性值用于了解宿舍规模、进行床位资源相关的统计分析等业务操作，例如统计各宿舍楼不同床位数量的宿舍分布情况等。
     public String getD_bedtotal() {
         return d_bedtotal;
     }
 
+    // 设置宿舍床位总数描述信息的方法，用于更新宿舍床位总数相关的信息，比如宿舍经过改造增加或减少了床位数量时可通过此方法来记录新的情况，不过要遵循相应的业务规范来保证数据准确性。
     public void setD_bedtotal(String d_bedtotal) {
         this.d_bedtotal = d_bedtotal;
     }
 
+    // 获取宿舍已占用床位信息的方法，外部类可以获取该属性值用于查看宿舍入住情况、进行床位分配和管理等业务操作，例如为新学生分配空闲床位时需要参考已占用床位信息。
     public String getD_bed() {
         return d_bed;
     }
 
+    // 设置宿舍已占用床位信息的方法，用于更新宿舍床位占用情况的相关信息，比如有学生入住或退房时及时更新此信息，以保证床位状态数据的实时性和准确性。
     public void setD_bed(String d_bed) {
         this.d_bed = d_bed;
     }
 
+    // 获取宿舍管理员姓名的方法，外部类可以获取该属性值用于联系管理员、查看宿舍管理责任人等相关业务操作，例如学生遇到宿舍设施问题时可以通过管理员姓名找到对应的负责人反馈问题。
     public String getA_name() {
         return a_name;
     }
 
+    // 设置宿舍管理员姓名的方法，用于更新宿舍管理员的相关信息，比如管理员更换时可通过此方法来记录新的管理员姓名，不过通常也需要相应的交接和信息更新流程来确保管理工作的顺畅。
     public void setA_name(String a_name) {
         this.a_name = a_name;
     }
 
+    // 获取与该宿舍关联的所有学生信息的列表的方法，外部类可以通过此方法获取宿舍学生集合，进而进行如遍历学生、对学生进行批量操作等业务逻辑，例如统计宿舍学生的学习成绩情况、查看宿舍内学生的考勤情况等操作都可能会用到这个学生列表。
     public List<Student> getStudents() {
         return students;
     }
 
+    // 设置与该宿舍关联的所有学生信息的列表的方法，供外部类更新宿舍学生的关联情况，不过在实际应用中，对学生列表的更新可能涉及较为复杂的业务逻辑，比如新生入住宿舍、学生调整宿舍等操作都需要相应的业务规则和数据处理逻辑来保证数据的准确性和一致性。
     public void setStudents(List<Student> students) {
         this.students = students;
     }
-}
+}

src/com/itheima/po/PageInfo.java

@@ -4,63 +4,83 @@ import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
 
+// PageInfo类是一个泛型类，用于封装分页相关的信息，实现了Serializable接口，使其可以进行序列化操作，方便在网络传输、持久化存储等场景下使用，
+// 比如在Web应用中用于在不同层之间传递分页数据，向客户端返回分页后的结果集等情况。
 public class PageInfo<T> implements Serializable {
-    private Integer pageIndex =1;//页码
+
-    private Integer pageSize =3;//显示条数
+    // 表示当前页码，初始值默认为1，即默认显示第一页的数据，在实际应用中可通过对应的set方法进行修改，并且设置了一些校验逻辑来保证页码的合理性。
-    private Integer totalCount =0; //总条数
+    private Integer pageIndex = 1;
-    private Integer pageTotalCount =0; //总页数
+
-    //每页显示的数据集合
+    // 表示每页显示的记录条数，初始值默认为3，意味着每页默认展示3条数据，同样可通过set方法进行调整，也有相应的校验机制确保显示条数的合法性。
+    private Integer pageSize = 3;
+
+    // 用于记录符合查询条件的总数据条数，初始值为0，在进行数据查询统计后可通过set方法更新该值，以便后续计算总页数等操作。
+    private Integer totalCount = 0;
+
+    // 代表总页数，根据总数据条数和每页显示条数来计算得出，初始值为0，其计算逻辑在对应的获取方法中实现，会根据总条数能否被每页条数整除来准确确定总页数。
+    private Integer pageTotalCount = 0;
+
+    // 每页显示的数据集合，使用ArrayList作为默认的实现，用于存储对应页码下要展示的具体数据内容，数据类型为泛型T，意味着可以存储任意类型的对象集合，只要符合实际业务场景中对应分页数据的类型要求。
     private List<T> list = new ArrayList<T>();
 
+    // 获取当前页码的方法，供外部类获取该私有属性的值，方便在其他业务逻辑中知晓当前显示的是第几页数据，例如用于页面导航栏中显示当前页码等操作。
     public Integer getPageIndex() {
         return pageIndex;
     }
 
+    // 设置当前页码的方法，外部类可以通过此方法来修改页码，同时在方法内部做了校验，如果传入的页码为null或者小于1（不符合实际页码逻辑），则将页码重置为默认的1，保证页码始终处于合理范围。
     public void setPageIndex(Integer pageIndex) {
         this.pageIndex = pageIndex;
-        if (pageIndex==null || pageIndex<1){
+        if (pageIndex == null || pageIndex < 1) {
-            this.pageIndex =1;
+            this.pageIndex = 1;
         }
     }
 
+    // 获取每页显示条数的方法，供外部类获取该私有属性的值，可用于知晓每页展示的数据量情况，比如在前端页面展示每页数据数量提示等场景会用到。
     public Integer getPageSize() {
         return pageSize;
     }
 
+    // 设置每页显示条数的方法，外部类可通过此方法来调整每页显示的记录数量，并且在方法内部进行了校验，如果传入的每页条数为null或者小于1，则将其重置为默认的3，确保每页显示条数的合理性。
     public void setPageSize(Integer pageSize) {
         this.pageSize = pageSize;
-        if (pageSize ==null || pageSize<1){
+        if (pageSize == null || pageSize < 1) {
-            this.pageSize =3;
+            this.pageSize = 3;
         }
     }
 
+    // 获取符合查询条件的总数据条数的方法，供外部类获取该私有属性的值，常用于判断数据总量情况，例如在前端展示数据总量提示，或者根据总条数来进一步做分页相关的逻辑判断等。
     public Integer getTotalCount() {
         return totalCount;
     }
 
+    // 设置符合查询条件的总数据条数的方法，外部类可以通过此方法来更新总条数信息，比如在执行完数据库查询统计操作后，将实际的总记录数设置到这个属性中，为后续分页计算做准备。
     public void setTotalCount(Integer totalCount) {
         this.totalCount = totalCount;
     }
 
-    //获取总页数
+    // 获取总页数的方法，此方法根据总数据条数和每页显示条数来计算总页数。计算逻辑是先通过总条数除以每页条数得到一个商值，
+    // 如果总条数除以每页条数有余数（即不能整除），说明还有剩余数据需要额外占一页，此时总页数需要加1，最后返回计算得出的总页数，用于在分页导航等业务场景中展示总共有多少页数据。
     public Integer getPageTotalCount() {
-
+        this.pageTotalCount = totalCount / pageSize;
-        this.pageTotalCount = totalCount/pageSize;
+        if (totalCount % pageSize!= 0) {
-        if(totalCount%pageSize!=0){
+            this.pageTotalCount++;
-            this.pageTotalCount ++;
         }
         return pageTotalCount;
     }
 
+    // 设置总页数的方法，供外部类修改总页数属性的值，不过在实际应用中，通常是由前面的计算逻辑自动得出总页数，较少会直接去手动设置这个值，除非有特殊的业务需求或者数据修正情况。
     public void setPageTotalCount(Integer pageTotalCount) {
         this.pageTotalCount = pageTotalCount;
     }
 
+    // 获取每页显示的数据集合的方法，外部类可以通过此方法获取对应页码下存储的具体数据列表，进而进行数据展示、遍历等操作，例如在前端页面循环展示每页的具体数据内容。
     public List<T> getList() {
         return list;
     }
 
+    // 设置每页显示的数据集合的方法，供外部类更新当前页要展示的数据内容，比如在从数据库查询出对应页码的数据后，通过此方法将数据设置到该属性中，以便后续展示给用户等操作。
     public void setList(List<T> list) {
         this.list = list;
     }
-}
+}

src/com/itheima/po/Student.java

@@ -1,91 +1,131 @@
 package com.itheima.po;
 
+// Student类，通常用于表示学生这一实体信息，包含了学生的各种基本属性，方便在学生管理相关系统中对学生数据进行存储、查询、更新等操作。
 public class Student {
+
+    // serialVersionUID是用于在序列化和反序列化过程中验证类版本一致性的唯一标识符。
+    // 当类的结构发生变化（如新增、删除字段等）时，如果这个版本号不一致，可能会导致反序列化失败，这里定义了一个固定的版本号1L，表明当前类的初始版本状态。
     private static final long serialVersionUID = 1L;
-    private  Integer s_id;
-    private  Integer s_studentid;
-    private  String  s_name;
-    private  String  s_sex;
-    private  Integer  s_age;
-    private  Integer  s_phone;
-    private  Integer  s_classid;
-    private  String s_classname;
-    private  Integer  s_dormitoryid;
 
+    // 学生的唯一标识编号，大概率对应数据库表中的主键字段，用于在系统中唯一确定一个学生实体，方便进行诸如查询学生详情、对学生信息进行修改、删除等操作时准确地定位到具体的学生。
+    private Integer s_id;
+
+    // 学生的学号，是学生在学校等教育机构中的特定编号，用于区分不同的学生，通常具有唯一性，在各类学生相关业务操作中（如成绩查询、选课等）会经常用到该编号来标识学生身份。
+    private Integer s_studentid;
+
+    // 学生的姓名，直观地展示学生的称呼，方便在系统界面以及相关业务操作中进行识别和展示，例如在班级名单、宿舍分配表等地方显示学生的名字。
+    private String s_name;
+
+    // 学生的性别，用于记录学生的生理性别信息，一般取值可能为“男”或“女”等（具体取值范围可根据业务系统设定），有助于进行性别相关的统计分析以及在一些特定业务场景（如宿舍按性别分配等）中使用该信息。
+    private String s_sex;
+
+    // 学生的年龄，记录学生当前所处的年龄阶段，可用于了解学生群体的年龄分布情况，在一些与年龄相关的业务规则判断（如是否满足某些活动参与年龄要求等）中会用到该属性。
+    private Integer s_age;
+
+    // 学生的电话号码，用于在必要时与学生或其监护人进行沟通联系，例如发送通知短信、处理紧急情况等业务场景下需要通过电话号码来联系学生。
+    private Integer s_phone;
+
+    // 学生所在班级的编号，用于关联到具体的班级，方便查询某个班级下的所有学生信息，也便于进行班级与学生相关的业务操作，比如班级内成绩统计、班级活动安排等都会涉及到班级编号与学生的关联。
+    private Integer s_classid;
+
+    // 学生所在班级的名称，直观地展示学生所属班级的称呼，例如“高三（1）班”等，方便在系统界面以及相关业务操作中快速识别学生所在班级情况，与班级编号属性结合可更全面地定位学生的班级信息。
+    private String s_classname;
+
+    // 学生所在宿舍的编号，用于关联到具体的宿舍，可用于查询某个宿舍居住的学生信息，在宿舍管理相关业务（如宿舍人员调整、宿舍卫生安排等）中会依据该编号来确定学生的宿舍归属。
+    private Integer s_dormitoryid;
+
+    // 获取类的序列化版本号的方法，不过由于serialVersionUID是静态常量，一般不会去修改它，此方法主要是遵循Java中获取该属性的规范写法，外部类可以通过此方法获取版本号信息（虽然实际使用场景相对较少）。
     public static long getSerialVersionUID() {
         return serialVersionUID;
     }
 
+    // 获取学生的唯一标识编号的方法，供外部类访问该私有属性的值，以便在其他业务逻辑中使用学生编号进行相关操作，比如根据编号查询学生详细信息、在学生信息管理系统中进行学生数据的增删改查等操作时依据该编号定位具体学生。
     public Integer getS_id() {
         return s_id;
     }
 
+    // 设置学生的唯一标识编号的方法，供外部类修改该私有属性的值，不过在实际应用中，学生编号作为重要的标识信息，其修改可能会受到业务规则的严格限制，通常情况下不会随意更改。
     public void setS_id(Integer s_id) {
         this.s_id = s_id;
     }
 
+    // 获取学生学号的方法，外部类可获取该属性值用于如按学号进行学生筛选、统计等业务操作，例如根据学号查询学生成绩、考勤记录等情况。
     public Integer getS_studentid() {
         return s_studentid;
     }
 
+    // 设置学生学号的方法，用于更新学生的学号信息，不过学号的修改往往需要遵循严格的业务流程和规范，因为学号在学校管理等场景中具有重要的标识作用。
     public void setS_studentid(Integer s_studentid) {
         this.s_studentid = s_studentid;
     }
 
+    // 获取学生姓名的方法，方便外部类获取该属性值用于在系统界面展示学生姓名、进行学生搜索等相关业务操作，例如在学生信息列表中显示学生的名字，方便查看和识别具体学生。
     public String getS_name() {
         return s_name;
     }
 
+    // 设置学生姓名的方法，供外部类修改学生的姓名信息，比如学生姓名发生变更（因更名等原因）时可通过此方法来更新，不过可能需要相应的证明材料和审核流程等业务环节。
     public void setS_name(String s_name) {
         this.s_name = s_name;
     }
 
+    // 获取学生性别的方法，外部类可以获取该属性值用于查看学生性别情况、进行性别相关的统计分析等业务操作，例如统计班级内男女生的人数比例等情况。
     public String getS_sex() {
         return s_sex;
     }
 
+    // 设置学生性别的方法，用于更新学生的性别信息，不过在实际应用中，性别信息一般相对固定，修改的情况较少，若有特殊情况需要修改也应遵循相应的业务规范和审核流程。
     public void setS_sex(String s_sex) {
         this.s_sex = s_sex;
     }
 
+    // 获取学生年龄的方法，外部类可以获取该属性值用于了解学生年龄状况、进行年龄相关的业务规则判断等操作，例如判断学生是否达到参加某项活动的年龄要求等。
     public Integer getS_age() {
         return s_age;
     }
 
+    // 设置学生年龄的方法，用于更新学生的年龄信息，一般随着时间自然增长，特殊情况下（如录入错误等）如需修改年龄也要遵循相应的业务流程来保证数据的准确性。
     public void setS_age(Integer s_age) {
         this.s_age = s_age;
     }
 
+    // 获取学生电话号码的方法，外部类可以获取该属性值用于联系学生、发送通知等相关业务操作，例如老师需要与学生沟通学习情况时通过电话号码联系学生。
     public Integer getS_phone() {
         return s_phone;
     }
 
+    // 设置学生电话号码的方法，用于更新学生的电话号码信息，比如学生更换了手机号码时可通过此方法来记录新的号码，同时要注意号码格式的合法性校验等业务规则。
     public void setS_phone(Integer s_phone) {
         this.s_phone = s_phone;
     }
 
+    // 获取学生所在班级编号的方法，外部类可获取该属性值用于关联到具体班级进行相关学生数据操作，例如查询某个班级的所有学生名单、统计班级内学生的相关数据等情况。
     public Integer getS_classid() {
         return s_classid;
     }
 
+    // 设置学生所在班级编号的方法，用于更新学生所在班级的编号信息，通常在学生进行班级调整等情况下会用到该方法来记录新的班级归属，不过要遵循相应的班级变动业务流程。
     public void setS_classid(Integer s_classid) {
         this.s_classid = s_classid;
     }
 
+    // 获取学生所在班级名称的方法，方便外部类获取该属性值用于快速知晓学生所属班级情况，在系统界面展示以及相关业务操作中更直观地体现班级信息，可与班级编号属性配合使用。
     public String getS_classname() {
         return s_classname;
     }
 
+    // 设置学生所在班级名称的方法，用于更新学生所在班级的名称信息，一般在班级名称发生变更（如班级重新命名等情况）时可通过此方法来记录新的班级名称，不过同样需要遵循相应的业务流程。
     public void setS_classname(String s_classname) {
         this.s_classname = s_classname;
     }
 
+    // 获取学生所在宿舍编号的方法，外部类可以获取该属性值用于关联到具体宿舍进行相关学生数据操作，例如查询某个宿舍内居住的学生信息、进行宿舍相关的管理操作（如宿舍卫生安排、设施维护等）时依据该编号确定学生与宿舍的关联。
     public Integer getS_dormitoryid() {
         return s_dormitoryid;
     }
 
+    // 设置学生所在宿舍编号的方法，用于更新学生所在宿舍的编号信息，通常在学生宿舍调整等情况下会用到该方法来记录新的宿舍分配情况，并且要遵循相应的宿舍分配业务流程来保证数据的准确性和合理性。
     public void setS_dormitoryid(Integer s_dormitoryid) {
         this.s_dormitoryid = s_dormitoryid;
     }
-
+}
-}

src/com/itheima/po/StudentClean.java

@@ -6,85 +6,119 @@ import java.util.Date;
 
 /**
  * @program: dormitorySystem
- * @description: 学生卫生
+ * @description: 学生卫生，该类用于表示学生卫生相关的实体信息，包含了如卫生记录的唯一标识、学生的学号、姓名、卫生评分等级、所在班级编号、所在宿舍编号以及卫生记录的创建时间和更新时间等属性，
+ * 便于在宿舍管理、学生综合评价等相关业务场景中对学生卫生数据进行存储、查询、展示以及操作等。
  * @author: Joyrocky
  * @create: 2019-04-25 12:12
  **/
 public class StudentClean {
+
+    // 学生卫生记录的唯一标识编号，通常对应数据库表中的主键字段，用于在系统中唯一确定一条学生卫生记录，方便后续针对具体的卫生记录进行查看详情、修改或者删除等操作。
     private Integer g_id;
+
+    // 学生的学号，用于准确关联到具体的学生，通过学号可以知晓是哪位学生对应的卫生记录，也方便在统计学生个人卫生情况随时间变化等业务场景中使用该学号进行数据关联和查询。
     private Integer s_studentid;
+
+    // 学生的姓名，直观地展示对应卫生记录所属学生的称呼，便于在查看卫生记录时快速识别是哪位学生的情况，同时在一些需要展示学生姓名的统计报表或者界面展示场景中会用到该属性。
     private String s_name;
+
+    // 学生卫生的评分等级，用于量化学生此次卫生打扫等情况的好坏程度，不同的数值可能对应不同的卫生评价标准，比如1 - 5分，分数越高表示卫生状况越好等情况，方便进行卫生情况的比较和统计分析，例如统计班级内各分数段卫生情况的学生人数等。
     private Integer s_grade;
+
+    // 学生所在班级的编号，用于关联到具体的班级，这样就能从班级维度来查看和统计学生卫生情况，比如统计某个班级整体的卫生水平、查看班级内卫生表现较好或较差的学生分布情况等，便于进行班级层面的卫生管理和分析。
     private Integer s_classid;
+
+    // 学生所在宿舍的编号，用于确定该学生所在的宿舍，方便从宿舍角度来管理和分析学生卫生情况，例如查看某个宿舍内学生的卫生整体情况、对比不同宿舍间学生卫生水平的差异等，对于宿舍卫生管理以及了解宿舍环境状况有重要作用。
     private Integer s_dormitoryid;
 
-    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
+    // 使用@JsonFormat注解对日期格式进行格式化设置，指定了将Date类型的时间数据转换为指定格式的字符串（"yyyy-MM-dd HH:mm:ss"这种常见的日期时间格式），
+    // 并且设置了时区为"GMT+8"（东八区，即北京时间所在时区），这样在将该对象转换为JSON数据（比如返回给前端展示）时，日期时间数据会按照指定格式和时区进行正确展示，增强数据展示的可读性和规范性。
+    // 学生卫生记录的创建时间，记录该条卫生记录首次生成的时间点，可用于查看卫生记录的历史情况、按时间范围查询卫生记录等业务操作，例如统计某个时间段内新增了多少学生卫生记录等。
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date create_time;
-    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
+
+    // 同样使用@JsonFormat注解进行日期格式和时区设置，用于将Date类型的更新时间按照指定格式转换。
+    // 学生卫生记录的更新时间，记录该条卫生记录最后一次被修改的时间点，比如卫生评分有调整、备注信息有变动等情况都会更新这个时间字段，方便跟踪卫生记录的变更历史。
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date update_time;
 
+    // 获取学生卫生记录的唯一标识编号的方法，供外部类访问该私有属性的值，以便在其他业务逻辑中依据此编号对相应的卫生记录进行操作，比如根据编号查找特定卫生记录的详细情况等。
     public Integer getG_id() {
         return g_id;
     }
 
+    // 设置学生卫生记录的唯一标识编号的方法，供外部类修改该私有属性的值，不过在实际应用中，这个编号作为主键通常不会随意修改，可能会受到业务规则的严格限制。
     public void setG_id(Integer g_id) {
         this.g_id = g_id;
     }
 
+    // 获取学生学号的方法，外部类可获取该属性值用于关联到具体学生进行相关卫生数据操作，例如查询某个学生的多次卫生记录等。
     public Integer getS_studentid() {
         return s_studentid;
     }
 
+    // 设置学生学号的方法，用于更新学生对应的这个标识信息，不过也要遵循相应的业务规则来保证数据的准确性和关联性。
     public void setS_studentid(Integer s_studentid) {
         this.s_studentid = s_studentid;
     }
 
+    // 获取学生姓名的方法，外部类可以获取该属性值用于查看卫生记录所属学生的情况、进行学生姓名相关的展示等业务操作，例如在卫生记录列表中展示学生姓名等。
     public String getS_name() {
         return s_name;
     }
 
+    // 设置学生姓名的方法，用于更新学生的姓名信息，比如学生姓名发生变更（因更名等原因）时可通过此方法来记录新的姓名，不过可能需要相应的证明材料和审核流程等业务环节。
     public void setS_name(String s_name) {
         this.s_name = s_name;
     }
 
+    // 获取学生卫生评分等级的方法，外部类可以获取该属性值用于查看学生卫生状况、进行卫生等级统计分析等业务操作，例如统计班级内各等级卫生情况的学生人数等。
     public Integer getS_grade() {
         return s_grade;
     }
 
+    // 设置学生卫生评分等级的方法，用于更新学生的卫生评分信息，例如重新检查卫生情况后调整评分时会用到此方法，要遵循相应的评分标准和业务规则来修改等级。
     public void setS_grade(Integer s_grade) {
         this.s_grade = s_grade;
     }
 
+    // 获取学生所在班级编号的方法，方便外部类获取该属性值用于按班级查看卫生情况、统计各班级的卫生数据等相关业务操作，比如统计各班级的平均卫生评分等。
     public Integer getS_classid() {
         return s_classid;
     }
 
+    // 设置学生所在班级编号的方法，供外部类修改该属性值，不过班级编号的修改一般需要谨慎操作，要确保与实际的班级情况相符，且遵循相应的业务流程，例如学生进行班级调整后更新相应记录。
     public void setS_classid(Integer s_classid) {
         this.s_classid = s_classid;
     }
 
+    // 获取学生所在宿舍编号的方法，外部类可以获取该属性值用于按宿舍查看卫生情况、统计各宿舍的卫生数据等相关业务操作，比如统计各宿舍的卫生达标情况等。
     public Integer getS_dormitoryid() {
         return s_dormitoryid;
     }
 
+    // 设置学生所在宿舍编号的方法，供外部类修改该属性值，不过宿舍编号的修改同样要谨慎，通常在学生宿舍调整等情况下按照相应业务流程来操作，确保数据的准确性和合理性。
     public void setS_dormitoryid(Integer s_dormtoryid) {
         this.s_dormitoryid = s_dormtoryid;
     }
 
+    // 获取学生卫生记录创建时间的方法，外部类可以获取该属性值用于查看卫生记录的创建历史、按时间范围筛选卫生记录等业务操作，比如查询某个时间段内新生成的卫生记录等。
     public Date getCreate_time() {
         return create_time;
     }
 
+    // 设置学生卫生记录创建时间的方法，一般来说创建时间在记录首次生成时确定，后续很少会去修改它，不过如果有特殊的业务需求（比如数据纠错等情况）可通过此方法来更新，同样要遵循相关业务规范。
     public void setCreate_time(Date create_time) {
         this.create_time = create_time;
     }
 
+    // 获取学生卫生记录更新时间的方法，外部类可以获取该属性值用于查看卫生记录的最近修改情况、跟踪记录变更历史等业务操作，例如查看哪些卫生记录近期有过变动等。
     public Date getUpdate_time() {
         return update_time;
     }
 
+    // 设置学生卫生记录更新时间的方法，在学生卫生记录相关信息发生修改时，系统内部会调用此方法来更新这个时间字段，以准确记录最后一次更新的时间点，保证数据变更历史的准确性。
     public void setUpdate_time(Date update_time) {
         this.update_time = update_time;
     }
-}
+}
-

src/com/itheima/po/Visitor.java

@@ -6,66 +6,91 @@ import java.util.Date;
 
 /**
  * @program: dormitorySystem
- * @description: 访客
+ * @description: 访客，该类用于表示宿舍访客相关的实体信息，包含了如访客的唯一标识编号、访客姓名、访客电话号码、要访问的宿舍编号、宿舍楼栋信息以及访客记录的创建时间等属性，
+ * 便于在宿舍访客管理相关业务场景中对访客数据进行存储、查询、展示以及操作等。
  * @author: Joyrocky
  * @create: 2019-05-14 00:37
  **/
 public class Visitor {
+
+    // 访客的唯一标识编号，通常对应数据库表中的主键字段，用于在系统中唯一确定一条访客记录，方便后续针对具体的访客进行查看详情、修改或者删除等操作，例如根据编号查找特定访客的来访信息等。
     private Integer v_id;
+
+    // 访客的姓名，直观地展示访客的称呼，便于在查看访客记录、进行来访人员登记以及相关业务操作中快速识别是哪位访客，同时在一些需要展示访客姓名的统计报表或者界面展示场景中会用到该属性。
     private String v_name;
+
+    // 访客的电话号码，用于在必要时与访客进行沟通联系，比如访客在进入宿舍区遇到问题时工作人员可以通过电话号码联系访客，也方便对访客信息进行核实等操作，同时在一些基于电话号码的查询、统计场景中可作为依据。
     private Integer v_phone;
+
+    // 访客要访问的宿舍编号，用于关联到具体的宿舍，这样就能明确访客的访问目标，便于宿舍管理人员知晓哪些宿舍有访客来访，也方便从宿舍维度来统计访客情况，例如查看某个宿舍的访客频繁程度等。
     private Integer v_dormitoryid;
+
+    // 宿舍楼栋信息，比如可以是楼栋的名称（像“2号楼”）或者编号等形式，用于区分不同的宿舍楼，方便从楼栋角度来管理和查询访客情况，例如统计各楼栋的访客数量、查看特定楼栋的访客记录等，对于整体的宿舍访客管理有重要作用。
     private String v_dormbuilding;
 
-    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
+    // 使用@JsonFormat注解对日期格式进行格式化设置，指定了将Date类型的时间数据转换为指定格式的字符串（"yyyy-MM-dd HH:mm:ss"这种常见的日期时间格式），
+    // 并且设置了时区为"GMT+8"（东八区，即北京时间所在时区），这样在将该对象转换为JSON数据（比如返回给前端展示）时，日期时间数据会按照指定格式和时区进行正确展示，增强数据展示的可读性和规范性。
+    // 访客记录的创建时间，记录该条访客记录首次生成的时间点，可用于查看访客记录的历史情况、按时间范围查询访客记录等业务操作，例如统计某个时间段内有多少访客来访等。
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date create_time;
 
+    // 获取访客的唯一标识编号的方法，供外部类访问该私有属性的值，以便在其他业务逻辑中依据此编号对相应的访客记录进行操作，比如根据编号查找特定访客的详细情况等。
     public Integer getV_id() {
         return v_id;
     }
 
+    // 设置访客的唯一标识编号的方法，供外部类修改该私有属性的值，不过在实际应用中，这个编号作为主键通常不会随意修改，可能会受到业务规则的严格限制。
     public void setV_id(Integer v_id) {
         this.v_id = v_id;
     }
 
+    // 获取访客姓名的方法，外部类可以获取该属性值用于查看访客的称呼、进行访客姓名相关的展示等业务操作，例如在访客登记列表中展示访客姓名等。
     public String getV_name() {
         return v_name;
     }
 
+    // 设置访客姓名的方法，用于更新访客的姓名信息，比如访客登记有误需要修改姓名或者访客提供了新的姓名等情况时可通过此方法来记录新的姓名，不过可能需要相应的核实流程等业务环节。
     public void setV_name(String v_name) {
         this.v_name = v_name;
     }
 
+    // 获取访客电话号码的方法，外部类可以获取该属性值用于联系访客、进行电话号码相关的查询统计等业务操作，例如根据电话号码查找访客的来访记录等。
     public Integer getV_phone() {
         return v_phone;
     }
 
+    // 设置访客电话号码的方法，用于更新访客的电话号码信息，比如访客更换了手机号码时可通过此方法来记录新的号码，同时要注意号码格式的合法性校验等业务规则。
     public void setV_phone(Integer v_phone) {
         this.v_phone = v_phone;
     }
 
+    // 获取访客要访问的宿舍编号的方法，方便外部类获取该属性值用于关联到具体宿舍进行相关访客数据操作，例如查询某个宿舍的访客名单等。
     public Integer getV_dormitoryid() {
         return v_dormitoryid;
     }
 
+    // 设置访客要访问的宿舍编号的方法，供外部类修改该属性值，不过宿舍编号的修改一般需要谨慎操作，要确保与实际的访问目标相符，且遵循相应的业务流程，例如访客更改了要访问的宿舍后进行相应记录更新。
     public void setV_dormitoryid(Integer v_dormitoryid) {
         this.v_dormitoryid = v_dormitoryid;
     }
 
+    // 获取宿舍楼栋信息的方法，外部类可以获取该属性值用于按楼栋查看访客情况、统计各楼栋的访客数据等相关业务操作，比如统计各楼栋的访客流量等。
     public String getV_dormbuilding() {
         return v_dormbuilding;
     }
 
+    // 设置宿舍楼栋信息的方法，供外部类修改该属性值，比如楼栋名称发生变更等情况下可通过此方法来更新，不过可能需要相应的审核等业务流程。
     public void setV_dormbuilding(String v_dormbuilding) {
         this.v_dormbuilding = v_dormbuilding;
     }
 
+    // 获取访客记录创建时间的方法，外部类可以获取该属性值用于查看访客记录的创建历史、按时间范围筛选访客记录等业务操作，比如查询某个时间段内新生成的访客记录等。
     public Date getCreate_time() {
         return create_time;
     }
 
+    // 设置访客记录创建时间的方法，一般来说创建时间在记录首次生成时确定，后续很少会去修改它，不过如果有特殊的业务需求（比如数据纠错等情况）可通过此方法来更新，同样要遵循相关业务规范。
     public void setCreate_time(Date create_time) {
         this.create_time = create_time;
     }
-}
+}
-

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

@@ -12,15 +12,28 @@ import org.springframework.transaction.annotation.Transactional;
 import java.util.List;
 
 /**
- * 用户Service接口实现类
+ * 用户Service接口实现类，该类实现了AdminService接口，用于处理与管理员相关的业务逻辑，
+ * 并通过依赖注入的方式使用AdminDao来与数据库进行交互，完成诸如管理员信息的查询、添加、删除、修改以及分页查询等操作，
+ * 同时利用了Spring的事务管理特性来确保数据操作的一致性和完整性。
  */
 @Service("adminService")
 @Transactional
 public class AdminServiceImpl implements AdminService {
-	// 注入UserDao
+
+	// 注入AdminDao，通过Spring的依赖注入机制，使得在这里可以方便地调用AdminDao中定义的数据库操作方法，
+	// 实现与数据库的交互，获取或操作管理员相关的数据，例如查询管理员信息、执行增删改操作等都依赖于AdminDao的具体实现。
 	@Autowired
 	private AdminDao adminDao;
 
+	/**
+	 * 管理登陆查询方法，用于根据传入的Admin对象中的条件（可能包含用户名、密码等信息）在数据库中查找对应的管理员信息，
+	 * 并返回查找到的Admin对象，如果没有找到匹配的管理员，则返回null。
+	 * 该方法主要是调用AdminDao中的对应查找方法来实现具体的查询逻辑。
+	 *
+	 * @param admin 包含查询条件的Admin对象，比如可以通过设置用户名、密码等属性来指定查找的条件，
+	 *              实际应用中可能会根据业务需求对传入的对象中的属性进行验证等前置处理。
+	 * @return 返回查找到的符合条件的Admin对象，如果数据库中不存在满足条件的管理员记录，则返回null。
+	 */
 	//管理登陆查询
 	@Override
 	public Admin findAdmin(Admin admin) {
@@ -28,52 +41,101 @@ public class AdminServiceImpl implements AdminService {
 		return a;
 	}
 
+	/**
+	 * 获取所有管理员信息的方法，通过调用AdminDao中的相应方法，从数据库中查询并返回所有的管理员记录信息列表，
+	 * 用于一些需要展示全部管理员基本情况或者进行全量管理员数据处理等业务场景，比如管理员列表展示、数据备份等操作。
+	 *
+	 * @return 返回包含所有管理员信息的列表，类型为List<Admin>，如果数据库中没有管理员记录，则返回一个空列表。
+	 */
 	@Override
-	public List<Admin> getAll(){
+	public List<Admin> getAll() {
-
 		List<Admin> adminList = adminDao.getAll();
 		return adminList;
-    }
+	}
 
+	/**
+	 * 分页查询管理员信息的方法，根据传入的多个筛选条件（如管理员用户名、描述信息、管理员编号等）以及分页相关的参数（当前页码和每页显示数量），
+	 * 实现管理员信息的分页查询功能，返回一个包含分页信息和对应页管理员列表的PageInfo对象。
+	 * 具体实现过程为先创建一个PageInfo对象，设置好当前页码和每页显示数量，然后通过AdminDao获取符合条件的管理员总条数，
+	 * 如果总条数大于0，则设置到PageInfo对象中，并根据分页计算逻辑获取对应页的管理员信息列表，同样设置到PageInfo对象中，最后返回该PageInfo对象。
+	 *
+	 * @param a_username 管理员用户名，用于按用户名进行模糊或精确筛选查询管理员信息，可为null，表示不按此条件筛选。
+	 * @param a_describe 管理员的描述信息，用于按描述内容进行筛选查询，可为null，即不依据此条件查找管理员记录。
+	 * @param a_id 管理员的唯一标识编号，用于精确查找特定编号的管理员，可为null，意味着不按照编号条件进行筛选。
+	 * @param pageIndex 当前页码，用于确定要获取哪一页的管理员信息，例如pageIndex为1表示获取第一页的管理员数据。
+	 * @param pageSize  每页显示的管理员记录数量，比如pageSize为10表示每页展示10条管理员信息记录。
+	 * @return 返回一个PageInfo<Admin>对象，其中包含了分页相关的信息（如总页数、总条数、当前页码等）以及对应页的管理员信息列表。
+	 */
 	@Override
-	public PageInfo<Admin> findPageInfo(String a_username, String a_describe,Integer a_id,Integer pageIndex, Integer pageSize) {
+	public PageInfo<Admin> findPageInfo(String a_username, String a_describe, Integer a_id, Integer pageIndex, Integer pageSize) {
 		PageInfo<Admin> pi = new PageInfo<Admin>();
 		pi.setPageIndex(pageIndex);
 		pi.setPageSize(pageSize);
 		//获取总条数
-		Integer totalCount = adminDao.totalCount(a_username,a_describe,a_id);
+		Integer totalCount = adminDao.totalCount(a_username, a_describe, a_id);
-		if (totalCount>0){
+		if (totalCount > 0) {
 			pi.setTotalCount(totalCount);
-			//每一页显示管理员信息数
+			//每一页显示管理员信息数，计算当前页数据在数据库查询中的起始位置，公式为：当前页码数减1乘以每页最大条数，得到开始行数，
-			//currentPage = (pageIndex-1)*pageSize  当前页码数减1*最大条数=开始行数
+			// 以此来准确获取对应页的数据，例如第2页（pageIndex为2），每页显示10条（pageSize为10），则开始行数就是(2 - 1) * 10 = 10，即从第11条数据开始获取本页的数据。
-			List<Admin> adminList =	adminDao.getAdminList(a_username,a_describe,a_id,
+			List<Admin> adminList = adminDao.getAdminList(a_username, a_describe, a_id,
-					(pi.getPageIndex()-1)*pi.getPageSize(),pi.getPageSize());
+					(pi.getPageIndex() - 1) * pi.getPageSize(), pi.getPageSize());
 			pi.setList(adminList);
 		}
 		return pi;
 	}
 
+	/**
+	 * 添加管理员信息的方法，接收一个包含完整管理员详细信息的Admin对象，将该对象所承载的管理员相关信息插入到数据库中，
+	 * 以此实现添加新管理员记录的业务操作，该方法通过调用AdminDao中的对应添加方法来完成具体的数据库插入操作，
+	 * 并返回一个整数表示数据库受影响的行数，通常添加成功返回1，添加失败返回0等情况（具体取决于数据库操作的返回机制）。
+	 *
+	 * @param admin 一个Admin类型的对象，里面封装了要添加到数据库的管理员的各项详细信息，比如管理员用户名、密码、姓名、权限等具体属性信息。
+	 * @return 返回一个整数，表示数据库受此次添加操作影响的行数，正常添加成功时返回值为1，若插入过程出现异常等导致失败，则返回值为0（具体返回值情况取决于所使用的数据库操作的返回机制）。
+	 */
 	//添加管理员信息
 	@Override
 	public int addAdmin(Admin admin) {
 		return adminDao.addAdmin(admin);
 	}
 
+	/**
+	 * 通过id删除管理员信息的方法，根据传入的代表管理员唯一标识的编号（a_id），在数据库中查找并删除与之对应的管理员记录，
+	 * 实现删除管理员信息的业务功能，通过调用AdminDao中的对应删除方法来执行具体的数据库删除操作，
+	 * 并返回一个整数表示数据库受影响的行数，一般删除成功返回1，若数据库中不存在该编号对应的管理员记录导致删除失败，则返回值为0（具体依据数据库操作的返回机制而定）。
+	 *
+	 * @param a_id 要删除的管理员的唯一标识编号，通过这个编号可以准确地定位到数据库中需要删除的那条管理员记录。
+	 * @return 返回一个整数类型的值，用以表示数据库受此删除操作影响的行数，正常情况下，若成功删除对应的管理员记录，返回值为1；若数据库中不存在该编号对应的管理员记录导致删除失败，则返回值为0（具体依据数据库操作的返回机制而定）。
+	 */
 	//通过id删除管理员信息
 	@Override
 	public int deleteAdmin(Integer a_id) {
 		return adminDao.deleteAdmin(a_id);
 	}
 
+	/**
+	 * 修改管理员信息的方法，接收一个包含已修改后的管理员详细信息的Admin对象，依据该对象中的信息去更新数据库中对应的管理员记录内容，
+	 * 完成管理员信息修改的业务操作，通过调用AdminDao中的对应修改方法来实现具体的数据库更新操作，
+	 * 并返回一个整数用来体现数据库受此更新操作影响的行数，一般而言，更新操作成功时返回值为1；若因某些原因（如数据不合法、记录不存在等）导致更新失败，则返回值为0（具体取决于数据库操作的返回机制）。
+	 *
+	 * @param admin 一个Admin类型的对象，其中包含了经过修改后的管理员各项信息，例如管理员的联系方式发生变化后、权限等级调整后的新信息等，通过这些信息来更新数据库中原有的管理员记录。
+	 * @return 返回一个整数类型的值，用来体现数据库受此更新操作影响的行数，一般更新成功时返回值为1；若因某些原因（如数据不合法、记录不存在等）导致更新失败，则返回值为0（具体取决于数据库操作的返回机制）。
+	 */
 	//修改管理员信息
 	@Override
 	public int updateAdmin(Admin admin) {
 		return adminDao.updateAdmin(admin);
 	}
 
+	/**
+	 * 根据管理员ID查询管理员信息的方法，依据传入的管理员唯一标识编号（a_id），从数据库中查找并返回与之对应的管理员详细记录信息，
+	 * 查找过程通过调用AdminDao中的对应查找方法来实现，查询结果以Admin对象的形式呈现，如果没有找到匹配的管理员记录，则返回null。
+	 *
+	 * @param a_id 用于在数据库中准确查找对应管理员记录的唯一标识编号，通过它可以定位到特定的管理员信息。
+	 * @return 返回一个Admin类型的对象，里面封装了查找到的对应管理员的详细信息，若数据库中不存在该编号对应的管理员记录，则返回null。
+	 */
 	@Override
-	public Admin findAdminById (Integer a_id){
+	public Admin findAdminById(Integer a_id) {
 		Admin a = adminDao.findAdminById(a_id);
-		return  a;
+		return a;
 	}
-}
+}

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

@@ -1,6 +1,5 @@
 package com.itheima.service.impl;
 
-
 import com.itheima.dao.ClassDao;
 import com.itheima.po.Class;
 import com.itheima.po.PageInfo;
@@ -12,16 +11,32 @@ import org.springframework.transaction.annotation.Transactional;
 import java.util.List;
 
 /**
- * 用户Service接口实现类
+ * 用户Service接口实现类，该类实现了ClassService接口，主要负责处理与班级相关的业务逻辑。
+ * 通过依赖注入获取ClassDao对象来与数据库进行交互，完成如班级信息的分页查询、增删改查以及查询班级关联的学生信息等操作，
+ * 同时借助Spring的事务管理特性保障数据操作的一致性和完整性。
  */
 @Service("classService")
 @Transactional
 public class ClassServiceImpl implements ClassService {
-	// classDao
+
+	// 注入ClassDao，利用Spring框架的依赖注入功能，使得此处能方便地调用ClassDao中定义的各种数据库操作方法，
+	// 以此实现与数据库的交互，完成诸如查询班级数据、对班级记录执行增删改等操作，它是实现业务逻辑与数据持久化操作衔接的关键。
 	@Autowired
 	private ClassDao classDao;
 
-
+	/**
+	 * 分页查询班级信息的方法，根据传入的班级相关筛选条件（班级名称、班级辅导员、班级编号）以及分页参数（当前页码、每页显示数量），
+	 * 实现班级信息的分页查询功能，并返回包含分页信息和对应页班级列表的PageInfo对象。
+	 * 具体步骤为先创建PageInfo对象并设置当前页码和每页显示数量，接着通过ClassDao获取符合条件的班级总条数，
+	 * 若总条数大于0，则将其设置到PageInfo对象中，然后依据分页计算逻辑获取对应页的班级信息列表并设置到PageInfo对象内，最后返回该对象。
+	 *
+	 * @param c_classname 班级名称，用于按班级名称进行模糊或精确筛选查询班级信息，可为null，表示不按此条件筛选。
+	 * @param c_counsellor 班级辅导员姓名，用于按辅导员姓名来筛选班级，可为null，即不依据此条件查找班级记录。
+	 * @param c_classid 班级编号，用于精确查找特定编号的班级，可为null，意味着不按照编号条件进行筛选。
+	 * @param pageIndex 当前页码，用于确定要获取哪一页的班级信息，例如pageIndex为1表示获取第一页的班级数据。
+	 * @param pageSize  每页显示的班级记录数量，比如pageSize为10表示每页展示10条班级信息记录。
+	 * @return 返回一个PageInfo<Class>对象，其中涵盖了分页相关的信息（如总页数、总条数、当前页码等）以及对应页的班级信息列表。
+	 */
 	//分页查询
 	@Override
 	public PageInfo<Class> findPageInfo(String c_classname, String c_counsellor, Integer c_classid, Integer pageIndex, Integer pageSize) {
@@ -29,51 +44,96 @@ public class ClassServiceImpl implements ClassService {
 		pi.setPageIndex(pageIndex);
 		pi.setPageSize(pageSize);
 		//获取总条数
-		Integer totalCount = classDao.totalCount(c_classname,c_classid,c_counsellor);
+		Integer totalCount = classDao.totalCount(c_classname, c_classid, c_counsellor);
-		if (totalCount>0){
+		if (totalCount > 0) {
 			pi.setTotalCount(totalCount);
-			//每一页显示班级信息数
+			//每一页显示班级信息数，此处根据分页算法计算当前页数据在数据库查询中的起始位置，计算公式为：当前页码数减1乘以每页最大条数，所得结果就是开始行数，
-			//currentPage = (pageIndex-1)*pageSize  当前页码数减1*最大条数=开始行数
+			// 例如，当要获取第3页（pageIndex为3），每页显示5条（pageSize为5）时，开始行数就是(3 - 1) * 5 = 10，即从第11条数据开始获取本页的数据。
-		List<Class> classList =	classDao.getClassList(c_classname,c_classid,c_counsellor,
+			List<Class> classList = classDao.getClassList(c_classname, c_classid, c_counsellor,
-				     (pi.getPageIndex()-1)*pi.getPageSize(),pi.getPageSize());
+					(pi.getPageIndex() - 1) * pi.getPageSize(), pi.getPageSize());
-		  pi.setList(classList);
+			pi.setList(classList);
 		}
 		return pi;
 	}
 
+	/**
+	 * 获取所有班级信息的方法，通过调用ClassDao中的相应方法，从数据库中查询并返回所有的班级记录信息列表，
+	 * 常用于需要展示全部班级基本情况或者进行全量班级数据处理等业务场景，比如班级列表展示、数据统计分析等操作。
+	 *
+	 * @return 返回包含所有班级信息的列表，类型为List<Class>，如果数据库中不存在班级记录，则返回一个空列表。
+	 */
 	@Override
-	public List<Class> getAll(){
+	public List<Class> getAll() {
 		List<Class> classList = classDao.getAll();
-		return  classList;
+		return classList;
 	}
 
+	/**
+	 * 通过班级ID删除班级信息的方法，依据传入的代表班级唯一标识的编号（c_id），在数据库中查找并删除与之对应的班级记录，
+	 * 以此实现删除班级信息的业务操作，通过调用ClassDao中的对应删除方法来执行具体的数据库删除操作，
+	 * 并返回一个整数表示数据库受影响的行数，一般删除成功返回1，若数据库中不存在该编号对应的班级记录导致删除失败，则返回值为0（具体取决于数据库操作的返回机制）。
+	 *
+	 * @param c_id 要删除的班级的唯一标识编号，通过这个编号可以准确地定位到数据库中需要删除的那条班级记录。
+	 * @return 返回一个整数类型的值，用以表示数据库受此删除操作影响的行数，正常情况下，若成功删除对应的班级记录，返回值为1；若数据库中不存在该编号对应的班级记录导致删除失败，则返回值为0（具体依据数据库操作的返回机制而定）。
+	 */
 	//通过id删除班级信息
 	@Override
 	public int deleteClass(Integer c_id) {
 		return classDao.deleteClass(c_id);
 	}
 
+	/**
+	 * 添加班级信息的方法，接收一个包含完整班级详细信息的Class对象，将该对象所承载的班级相关信息插入到数据库中，
+	 * 从而实现添加新班级记录的业务操作，该方法通过调用ClassDao中的对应添加方法来完成具体的数据库插入操作，
+	 * 并返回一个整数表示数据库受影响的行数，通常添加成功返回1，添加失败返回0等情况（具体取决于数据库操作的返回机制）。
+	 *
+	 * @param uclass 一个Class类型的对象，里面封装了要添加到数据库的班级的各项详细信息，比如班级名称、班级编号、辅导员姓名等具体属性信息。
+	 * @return 返回一个整数，表示数据库受此次添加操作影响的行数，正常添加成功时返回值为1，若插入过程出现异常等导致失败，则返回值为0（具体返回值情况取决于所使用的数据库操作的返回机制）。
+	 */
 	//添加班级信息
 	@Override
 	public int addClass(Class uclass) {
 		return classDao.addClass(uclass);
 	}
 
+	/**
+	 * 根据班级ID查询班级信息的方法，依据传入的班级唯一标识编号（c_id），从数据库中查找并返回与之对应的班级详细记录信息，
+	 * 查找过程通过调用ClassDao中的对应查找方法来实现，查询结果以Class对象的形式呈现，如果没有找到匹配的班级记录，则返回null。
+	 *
+	 * @param c_id 用于在数据库中准确查找对应班级记录的唯一标识编号，通过它可以定位到特定的班级信息。
+	 * @return 返回一个Class类型的对象，里面封装了查找到的对应班级的详细信息，若数据库中不存在该编号对应的班级记录，则返回null。
+	 */
 	@Override
-	public Class findClassById (Integer c_id){
+	public Class findClassById(Integer c_id) {
 		Class c = classDao.findClassById(c_id);
-		return  c;
+		return c;
 	}
+
+	/**
+	 * 修改班级信息的方法，接收一个包含已修改后的班级详细信息的Class对象，依据该对象中的信息去更新数据库中对应的班级记录内容，
+	 * 完成班级信息修改的业务操作，通过调用ClassDao中的对应修改方法来实现具体的数据库更新操作，
+	 * 并返回一个整数用来体现数据库受此更新操作影响的行数，一般而言，更新操作成功时返回值为1；若因某些原因（如数据不合法、记录不存在等）导致更新失败，则返回值为0（具体取决于数据库操作的返回机制）。
+	 *
+	 * @param uclass 一个Class类型的对象，其中包含了经过修改后的班级各项信息，例如班级名称变更、辅导员更换后的新信息等，通过这些信息来更新数据库中原有的班级记录。
+	 * @return 返回一个整数类型的值，用来体现数据库受此更新操作影响的行数，一般更新成功时返回值为1；若因某些原因（如数据不合法、记录不存在等）导致更新失败，则返回值为0（具体取决于数据库操作的返回机制）。
+	 */
 	//修改班级信息
 	@Override
 	public int updateClass(Class uclass) {
 		return classDao.updateClass(uclass);
 	}
 
-	//查询宿舍人员信息
+	/**
+	 * 查询班级关联的学生信息的方法，接收一个Class对象（可能包含班级相关的筛选条件等信息），通过调用ClassDao中的对应方法，
+	 * 从数据库中查找并返回与该班级相关联的学生信息列表，用于展示班级内学生情况、进行班级学生相关业务处理等场景。
+	 *
+	 * @param uclass 一个Class类型的对象，可能包含用于筛选或定位特定班级的相关信息，依据此对象中的条件来查询与之关联的学生信息。
+	 * @return 返回一个List<Class>类型的列表，其中包含了与传入的班级对象相关联的学生信息（这里返回值类型List<Class>可能不太准确，或许应该是List<Student>更符合语义，需根据实际业务逻辑确定），如果没有找到对应的学生信息，则返回一个空列表。
+	 */
+	//查询宿舍人员信息（此处命名可能不太准确，从方法功能看更像是查询班级学生信息）
 	@Override
 	public List<Class> findClassStudent(Class uclass) {
 		List<Class> c = classDao.findClassStudent(uclass);
 		return c;
 	}
-}
+}

src/com/itheima/util/MD5Util.java

@@ -4,14 +4,20 @@ import java.security.MessageDigest;
 
 /**
  * @program: Student_dorm_System
- * @description: MD5加密
+ * @description: MD5加密，该类提供了用于对字符串进行MD5加密的相关方法，通过将输入的字符串按照MD5算法进行处理，
+ * 生成对应的加密后的字符串结果，可用于密码加密等场景，保障数据的安全性，确保敏感信息以加密形式存储和传输等。
  * @author: Joyrocky
  * @create: 2019-04-13 13:04
  **/
-
-
 public class MD5Util {
 
+    /**
+     * 将字节数组转换为十六进制字符串的方法，它遍历字节数组中的每个字节，调用byteToHexString方法将每个字节转换为对应的十六进制表示形式，
+     * 然后将这些十六进制字符串依次拼接起来，最终返回拼接好的十六进制字符串结果，主要用于后续MD5加密结果的格式化处理。
+     *
+     * @param b 要转换的字节数组，通常是经过MD5摘要算法处理后得到的字节数组，用于将其转换为便于查看和使用的十六进制字符串形式。
+     * @return 返回由字节数组转换而来的十六进制字符串，代表了对应数据的十六进制表示形式，例如字节数组[1, 2, 3]可能会转换为类似"010203"的十六进制字符串（实际取决于具体字节值对应的十六进制转换结果）。
+     */
     private static String byteArrayToHexString(byte b[]) {
         StringBuffer resultSb = new StringBuffer();
         for (int i = 0; i < b.length; i++)
@@ -20,6 +26,14 @@ public class MD5Util {
         return resultSb.toString();
     }
 
+    /**
+     * 将单个字节转换为十六进制字符串的方法，首先对传入的字节值进行处理，如果字节值为负数（在Java中字节是有符号的，范围是 -128到127），
+     * 则将其加上256转换为无符号的整数值（使其落在0到255的范围内），然后将这个整数值分别除以16和取余16，得到两个十六进制位对应的数字，
+     * 再通过查找hexDigits数组获取对应的十六进制字符表示，最后将这两个十六进制字符拼接起来返回，以此实现将字节转换为十六进制字符串的功能。
+     *
+     * @param b 要转换的单个字节，该字节将被转换为十六进制字符串表示形式，例如字节值为10，可能会转换为十六进制字符串"0a"。
+     * @return 返回代表该字节的十六进制字符串，格式如"0a"、"1f"等，是将字节按照十六进制规则转换后的结果。
+     */
     private static String byteToHexString(byte b) {
         int n = b;
         if (n < 0)
@@ -30,11 +44,14 @@ public class MD5Util {
     }
 
     /**
-     * 返回大写MD5
+     * 执行MD5加密并返回大写结果的私有方法，它接收原始字符串和字符编码名称作为参数，首先将原始字符串赋值给结果字符串变量，
+     * 然后获取MD5的消息摘要实例（MessageDigest），根据传入的字符编码情况，对原始字符串进行字节转换并使用MD5算法进行摘要计算，
+     * 最后将得到的字节数组通过byteArrayToHexString方法转换为十六进制字符串，并将结果转换为大写形式返回，该方法是实际进行MD5加密处理的核心逻辑所在。
      *
-     * @param origin
+     * @param origin 要进行MD5加密的原始字符串，比如可以是用户输入的密码等需要加密存储的敏感信息字符串。
-     * @param charsetname
+     * @param charsetname 字符编码名称，用于指定在将原始字符串转换为字节数组时采用的编码方式，可为null或者空字符串，表示采用默认编码，
-     * @return
+     *                    也可以传入具体的编码如"utf-8"等，来确保在不同环境下字符串字节转换的准确性。
+     * @return 返回经过MD5加密并转换为大写形式的十六进制字符串结果，代表了原始字符串的MD5加密后的表现形式，例如原始字符串为"abc"，加密后可能返回类似"900150983CD24FB0D6963F7D28E17F72"的大写十六进制字符串。
      */
     private static String MD5Encode(String origin, String charsetname) {
         String resultString = null;
@@ -50,16 +67,29 @@ public class MD5Util {
         return resultString.toUpperCase();
     }
 
+    /**
+     * 对外公开的MD5加密方法，默认采用"utf-8"编码进行MD5加密，并且原本可能有盐值（Salt）加密的逻辑（当前代码中被注释掉了），
+     * 盐值加密常用于增加密码等信息的安全性，通过在原始字符串基础上添加特定的盐值再进行加密，使加密结果更难被破解，
+     * 此处调用了MD5Encode私有方法，传入原始字符串和"utf-8"编码来完成具体的MD5加密操作，并返回加密后的结果字符串。
+     *
+     * @param origin 要进行MD5加密的原始字符串，同样可以是密码等需要加密的数据内容。
+     * @return 返回经过MD5加密后的十六进制字符串结果，采用"utf-8"编码进行加密处理，字符串为大写形式，代表了原始字符串加密后的最终表现形式。
+     */
     public static String MD5EncodeUtf8(String origin) {
 
-        //盐值Salt加密
+        //盐值Salt加密，此处代码被注释掉了，原本的意图可能是从配置文件（通过PropertiesUtil.getProperty方法）中获取盐值，
+        //然后将盐值添加到原始字符串后面再进行MD5加密，以此增加加密的安全性和破解难度，例如密码在加密存储时结合一个固定的盐值，
+        //即使两个相同的密码，由于盐值不同，加密后的结果也会不同，提高了密码存储的安全性。
         //origin = origin + PropertiesUtil.getProperty("password.salt", "");
         return MD5Encode(origin, "utf-8");
     }
 
-
+    /**
+     * 定义十六进制字符数组，用于在将字节转换为十六进制字符串时查找对应的十六进制字符表示，
+     * 例如字节值10对应的十六进制数字为"a"，可以通过查找该数组中索引为10的元素获取到对应的十六进制字符表示，
+     * 数组中的元素依次代表了十六进制中从0到f的字符表示形式，按照顺序排列，方便字节到十六进制转换过程中的字符查找操作。
+     */
     private static final String hexDigits[] = {"0", "1", "2", "3", "4", "5",
             "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"};
 
-}
+}
-

src/com/itheima/util/PropertiesUtil.java

@@ -2,7 +2,9 @@ package com.itheima.util;
 
 /**
  * @program: dormitorySystem
- * @description: 属性工具
+ * @description: 属性工具，该类主要用于读取配置文件（在这里是名为"mmall.properties"的文件）中的属性信息，
+ * 提供了方便获取属性值的方法，并且对获取到的值进行了一些必要的处理（如去除空白字符、处理默认值等），
+ * 同时在读取配置文件出现异常时能够进行相应的日志记录，方便排查问题。
  * @author: Joyrocky
  * @create: 2019-04-28 23:10
  **/
@@ -15,38 +17,58 @@ import java.util.Properties;
 
 public class PropertiesUtil {
 
+    // 创建一个Logger对象，用于记录日志信息，这里指定了日志的记录器名称为PropertiesUtil类的全限定名，
+    // 通过这个日志记录器可以方便地输出不同级别的日志（如错误日志、调试日志等），便于在程序运行过程中记录关键信息和排查问题。
     private static Logger logger = LoggerFactory.getLogger(PropertiesUtil.class);
 
+    // 用于存储从配置文件中读取出来的属性信息，Properties类是Java中用于处理属性文件的常用类，
+    // 它以键值对的形式存储配置信息，后续可以通过属性的键（key）来获取对应的属性值（value）。
     private static Properties props;
 
+    // 静态代码块，在类被加载时执行，主要用于初始化配置文件的读取操作，在这里会指定配置文件的名称为"mmall.properties"，
+    // 然后创建一个Properties对象，并尝试从类加载器获取对应的配置文件输入流，使用UTF-8编码将配置文件内容加载到Properties对象中，
+    // 如果在读取过程中出现IOException异常，会通过日志记录器记录错误信息，方便后续排查配置文件读取失败的原因。
     static {
         String fileName = "mmall.properties";
         props = new Properties();
         try {
-            props.load(new InputStreamReader(PropertiesUtil.class.getClassLoader().getResourceAsStream(fileName),"UTF-8"));
+            props.load(new InputStreamReader(PropertiesUtil.class.getClassLoader().getResourceAsStream(fileName), "UTF-8"));
         } catch (IOException e) {
-            logger.error("配置文件读取异常",e);
+            logger.error("配置文件读取异常", e);
         }
     }
 
-    public static String getProperty(String key){
+    /**
+     * 根据给定的键（key）获取对应的属性值，如果获取到的属性值为空字符串或者空白字符（经过trim处理后为空），则返回null。
+     * 该方法首先会对传入的键进行trim操作去除两端可能存在的空白字符，然后从已加载的Properties对象中获取对应键的属性值，
+     * 最后对获取到的属性值再次进行trim操作并判断是否为空，若为空则返回null，否则返回处理后的属性值。
+     *
+     * @param key 要获取属性值的键，在配置文件中是唯一标识一个属性的字符串，例如"database.url"可能代表数据库连接地址的配置项键。
+     * @return 返回对应键的属性值，如果属性值为空字符串或者空白字符，则返回null，否则返回去除两端空白字符后的属性值。
+     */
+    public static String getProperty(String key) {
         String value = props.getProperty(key.trim());
-        if(StringUtils.isBlank(value)){
+        if (StringUtils.isBlank(value)) {
             return null;
         }
         return value.trim();
     }
 
-    public static String getProperty(String key,String defaultValue){
+    /**
+     * 根据给定的键（key）获取对应的属性值，如果获取到的属性值为空字符串或者空白字符（经过trim处理后为空），则返回默认值（defaultValue）。
+     * 同样先对传入的键进行trim操作，从Properties对象中获取属性值后再trim处理，然后判断其是否为空，若为空则将传入的默认值赋给属性值变量，
+     * 最后返回经过处理后的属性值，该方法适用于在配置文件中某个属性可能不存在时提供一个默认的取值情况。
+     *
+     * @param key          要获取属性值的键，与上面的方法类似，用于在配置文件中定位具体的属性项。
+     * @param defaultValue 当配置文件中对应键的属性值为空时要返回的默认值，例如可以为某个连接的默认端口号等默认配置信息。
+     * @return 返回对应键的属性值，如果配置文件中该键对应的属性值为空，则返回默认值，否则返回去除两端空白字符后的实际属性值。
+     */
+    public static String getProperty(String key, String defaultValue) {
 
         String value = props.getProperty(key.trim());
-        if(StringUtils.isBlank(value)){
+        if (StringUtils.isBlank(value)) {
             value = defaultValue;
         }
         return value.trim();
     }
-
+}
-
-
-}
-