Merge branch 'develop1'

# Conflicts:
#	src/web/servlet/student/DeleteSelectStudentServlet.java
#	src/web/servlet/verifycode/CheckCodeServlet.java

src/dao/AdminDao.java

@@ -1,12 +1,34 @@
 package dao;
 
-import domain.Admin;
+import domain.Admin;  // 引入 Admin 类，表示管理员数据
 
+/**
+ * AdminDao 接口，定义了管理员信息的数据库访问方法。
+ */
 public interface AdminDao {
+
+    /**
+     * 根据管理员 ID 和密码查询管理员信息。
+     * 
+     * @param id       管理员 ID
+     * @param password 管理员密码
+     * @return 如果匹配成功，返回管理员对象；否则返回 null
+     */
     Admin findAdminidAndPassword(String id, String password);
 
+    /**
+     * 更新管理员密码。
+     * 
+     * @param adminid     管理员 ID
+     * @param newpassword 新密码
+     */
     void updatePassword(String adminid, String newpassword);
 
+    /**
+     * 根据管理员 ID 查询管理员信息。
+     * 
+     * @param a_id 管理员 ID
+     * @return 如果存在，返回管理员对象；否则返回 null
+     */
     Admin findAdminById(String a_id);
 }
-//dashdhasd

src/dao/CDCDao.java

@@ -1,15 +1,39 @@
 package dao;
 
-import domain.CDC;
+import domain.CDC;  // 引入 CDC 类，表示学院、部门和班级的数据
 
-import java.util.List;
+import java.util.List;  // 引入 List 类，用于存储返回的查询结果
 
+/**
+ * CDCDao 接口，定义了对学院、部门和班级等数据的数据库访问方法。
+ */
 public interface CDCDao {
+
+    /**
+     * 查询所有学院信息。
+     * 
+     * @return 返回所有学院的列表
+     */
     List<CDC> findAllCollege();
 
+    /**
+     * 查询所有部门信息。
+     * 
+     * @return 返回所有部门的列表
+     */
     List<CDC> findAllDepartment();
 
+    /**
+     * 查询所有班级信息。
+     * 
+     * @return 返回所有班级的列表
+     */
     List<CDC> findAllClass();
 
+    /**
+     * 查询所有学院、部门和班级的综合信息。
+     * 
+     * @return 返回所有学院、部门和班级的列表
+     */
     List<CDC> findAll();
 }

src/dao/ComplaintDao.java

@@ -1,11 +1,25 @@
 package dao;
 
-import domain.Complaint;
+import domain.Complaint;  // 引入 Complaint 类，表示投诉数据
 
-import java.util.List;
+import java.util.List;  // 引入 List 类，用于存储返回的投诉列表
 
+/**
+ * ComplaintDao 接口，定义了对投诉数据的数据库访问方法。
+ */
 public interface ComplaintDao {
+
+    /**
+     * 查询所有的投诉记录。
+     * 
+     * @return 返回所有投诉的列表
+     */
     List<Complaint> findAllComplaint();
 
+    /**
+     * 添加一条投诉记录。
+     * 
+     * @param complaint 需要添加的投诉对象
+     */
     void addComplaint(Complaint complaint);
 }

src/dao/CourseDao.java

@@ -1,11 +1,31 @@
 package dao;
 
-import domain.Course;
+import domain.Course;  // 引入 Course 类，表示课程数据
 
+/**
+ * CourseDao 接口，定义了对课程数据的数据库访问方法。
+ */
 public interface CourseDao {
+
+    /**
+     * 添加一门选修课程。
+     * 
+     * @param course 需要添加的课程对象
+     */
     void addOptionalCourse(Course course);
 
+    /**
+     * 根据课程 ID 查询课程信息。
+     * 
+     * @param cid 课程 ID
+     * @return 返回对应课程的 Course 对象，若未找到，则返回 null
+     */
     Course findSelectCourseByCourseId(String cid);
 
+    /**
+     * 根据课程 ID 删除课程记录。
+     * 
+     * @param cid 课程 ID
+     */
     void deleteServiceById(String cid);
 }

src/dao/NotifyDao.java

@@ -1,16 +1,39 @@
 package dao;
 
-import domain.Notify;
+import domain.Notify;  // 引入 Notify 类，表示通知数据
 
-import java.util.List;
+import java.util.List;  // 引入 List 类，表示通知列表
 
+/**
+ * NotifyDao 接口，定义了对通知数据的数据库访问方法。
+ */
 public interface NotifyDao {
+
+    /**
+     * 添加一条通知记录。
+     * 
+     * @param notify 需要添加的通知对象
+     */
     void add(Notify notify);
 
+    /**
+     * 查询最新的 3 条通知。
+     * 
+     * @return 返回包含最新 3 条通知的 List<Notify> 列表
+     */
     List<Notify> findNotify();
 
+    /**
+     * 查询所有通知，按通知 ID 降序排列。
+     * 
+     * @return 返回所有通知的 List<Notify> 列表
+     */
     List<Notify> findAllNotify();
 
+    /**
+     * 根据通知 ID 删除通知记录。
+     * 
+     * @param notifyid 通知的 ID
+     */
     void deleteNotifyById(String notifyid);
-
 }

src/dao/PhotoDao.java

@@ -1,11 +1,31 @@
 package dao;
 
-import domain.Photo;
+import domain.Photo;  // 引入 Photo 类，表示照片数据
 
+/**
+ * PhotoDao 接口，定义了与照片数据相关的数据库访问方法。
+ */
 public interface PhotoDao {
+
+    /**
+     * 添加一张照片。
+     * 
+     * @param photo 需要添加的照片对象
+     */
     void addPhoto(Photo photo);
 
+    /**
+     * 根据照片 ID 查找对应的照片。
+     * 
+     * @param id 照片的 ID
+     * @return 返回对应的 Photo 对象，如果没有找到则返回 null
+     */
     Photo findPhotoByPhotoId(String id);
 
+    /**
+     * 更新照片的信息。
+     * 
+     * @param photo 包含新信息的照片对象
+     */
     void updatePhoto(Photo photo);
 }

src/dao/SelectCourseDao.java

@@ -1,13 +1,37 @@
 package dao;
 
-import domain.SelectCourse;
+import domain.SelectCourse;  // 引入 SelectCourse 类，表示学生选课数据
 
-import java.util.List;
+import java.util.List;  // 引入 List 类，用于返回多个选课记录
 
+/**
+ * SelectCourseDao 接口，定义了与学生选课相关的数据库访问方法。
+ */
 public interface SelectCourseDao {
+
+    /**
+     * 根据课程 ID 查找已选择该课程的所有学生。
+     * 
+     * @param cid 课程的 ID
+     * @return 返回选修该课程的学生列表，每个学生的选课信息包含课程 ID、学生 ID、学生姓名等
+     */
     List<SelectCourse> findStudentSelectedCourseByCourseId(String cid);
 
+    /**
+     * 根据课程 ID 和学生 ID 查找该学生在该课程中的成绩。
+     * 
+     * @param cid 课程的 ID
+     * @param sid 学生的 ID
+     * @return 返回该学生在该课程中的选课信息，包括成绩等
+     */
     SelectCourse findScoreByCourseIdAndStudentId(String cid, String sid);
 
+    /**
+     * 更新学生在某课程中的成绩。
+     * 
+     * @param cid    课程的 ID
+     * @param sid    学生的 ID
+     * @param sScore 学生在该课程中的新成绩
+     */
     void upDateScoreByCidAndSid(String cid, String sid, String sScore);
 }

src/dao/StudentDao.java

@@ -1,41 +1,122 @@
 package dao;
 
-import domain.Course;
-import domain.SelectCourse;
-import domain.Student;
+import domain.Course;  // 引入 Course 类，表示课程信息
+import domain.SelectCourse;  // 引入 SelectCourse 类，表示学生的选课信息
+import domain.Student;  // 引入 Student 类，表示学生信息
 
-import java.util.List;
-import java.util.Map;
+import java.util.List;  // 引入 List 类，用于返回多个学生或选课记录
+import java.util.Map;  // 引入 Map 类，用于接收条件查询参数
 
 /**
- * 学生操作的DAO
+ * 学生操作的DAO接口，定义了与学生信息、选课等相关的数据库操作方法。
  */
 public interface StudentDao {
+
+    /**
+     * 根据分页条件和查询条件获取学生列表。
+     * 
+     * @param start     起始位置（分页）
+     * @param rows      每页显示的学生数
+     * @param condition 查询条件的 Map 集合（如：学生姓名、学号等）
+     * @return 返回符合条件的学生列表
+     */
     List<Student> findByPage(int start, int rows, Map<String, String[]> condition);
 
+    /**
+     * 获取所有学生信息。
+     * 
+     * @return 返回所有学生的列表
+     */
     List<Student> findAll();
 
+    /**
+     * 根据学生 ID 和密码查询学生信息。
+     * 
+     * @param id       学生的学号
+     * @param password 学生的密码
+     * @return 如果匹配成功，返回学生对象；否则返回 null
+     */
     Student findStudentidAndPassword(String id, String password);
 
+    /**
+     * 根据学生 ID 查找学生信息。
+     * 
+     * @param s_id 学生的学号
+     * @return 返回学生对象
+     */
     Student findStudentById(String s_id);
 
+    /**
+     * 添加新学生信息。
+     * 
+     * @param student 学生对象，包含要插入的学生信息
+     */
     void addStudent(Student student);
 
+    /**
+     * 更新学生信息。
+     * 
+     * @param student 学生对象，包含要更新的学生信息
+     */
     void updateInfo(Student student);
 
+    /**
+     * 更新学生密码。
+     * 
+     * @param studentid 学生的学号
+     * @param newpassword 新的密码
+     */
     void updatePassword(String studentid, String newpassword);
 
+    /**
+     * 查找学生已选的所有课程信息。
+     * 
+     * @param studentid 学生的学号
+     * @return 返回该学生已选课程的列表
+     */
     List<SelectCourse> findAllSelectCourse(String studentid);
 
+    /**
+     * 查找所有可选课程。
+     * 
+     * @return 返回所有可选课程的列表
+     */
     List<Course> findAllOptionalCourse();
 
+    /**
+     * 为学生添加一门课程。
+     * 
+     * @param studentid 学生的学号
+     * @param courseid  课程的 ID
+     */
     void addSelectCourse(String studentid, String courseid);
 
+    /**
+     * 根据学生 ID 删除学生。
+     * 
+     * @param studentid 学生的学号
+     */
     void deleteStudentById(String studentid);
 
+    /**
+     * 根据查询条件统计学生总数。
+     * 
+     * @param condition 查询条件的 Map 集合
+     * @return 返回符合条件的学生总数
+     */
     int findTotalCount(Map<String, String[]> condition);
 
+    /**
+     * 添加包含完整信息的新学生。
+     * 
+     * @param updateStudent 学生对象，包含要插入的完整学生信息
+     */
     void addStudentAllInfo(Student updateStudent);
 
+    /**
+     * 查找所有学生的选课信息。
+     * 
+     * @return 返回所有学生的选课信息列表
+     */
     List<SelectCourse> findSelectCourseAllStudent();
 }

src/dao/TeacherDao.java

@@ -1,33 +1,95 @@
 package dao;
 
-import domain.Course;
-import domain.Teacher;
+import domain.Course;  // 引入 Course 类，表示课程信息
+import domain.Teacher;  // 引入 Teacher 类，表示教师信息
 
-import java.util.List;
+import java.util.List;  // 引入 List 类，用于返回多个教师或课程信息
 
 /**
- * 管理员操作的DAO
+ * 管理员操作的DAO接口，定义了与教师信息、课程管理等相关的数据库操作方法。
  */
 public interface TeacherDao {
+
+    /**
+     * 根据教师 ID 和密码查询教师信息。
+     * 
+     * @param id       教师的工号
+     * @param password 教师的密码
+     * @return 如果匹配成功，返回教师对象；否则返回 null
+     */
     Teacher findTeacheridAndPassword(String id, String password);
 
+    /**
+     * 获取所有教师信息。
+     * 
+     * @return 返回所有教师的列表
+     */
     List<Teacher> findAll();
 
+    /**
+     * 根据教师 ID 查找该教师的所有可选课程。
+     * 
+     * @param t_id 教师的工号
+     * @return 返回该教师的所有可选课程
+     */
     List<Course> findMySelfOptionalCourse(String t_id);
 
+    /**
+     * 根据课程 ID 查找课程信息。
+     * 
+     * @param cid 课程 ID
+     * @return 返回课程对象
+     */
     Course findOptionalCourseByCourseId(String cid);
 
+    /**
+     * 更新课程信息。
+     * 
+     * @param updateCourse 包含更新信息的课程对象
+     */
     void updateCourseInfo(Course updateCourse);
 
+    /**
+     * 删除课程。
+     * 
+     * @param cid 课程 ID
+     */
     void deleteCourseById(String cid);
 
+    /**
+     * 更新教师密码。
+     * 
+     * @param teacherid   教师的工号
+     * @param newpassword 新的密码
+     */
     void updatePassword(String teacherid, String newpassword);
 
+    /**
+     * 根据教师 ID 查找教师信息。
+     * 
+     * @param t_id 教师的工号
+     * @return 返回教师对象
+     */
     Teacher findTeacherById(String t_id);
 
+    /**
+     * 添加教师的完整信息。
+     * 
+     * @param updateTeacher 包含教师完整信息的教师对象
+     */
     void addTeacherAllInfo(Teacher updateTeacher);
 
+    /**
+     * 根据教师 ID 删除教师信息。
+     * 
+     * @param teacherid 教师的工号
+     */
     void deleteTeacherById(String teacherid);
 
+    /**
+     * 更新教师个人信息。
+     * 
+     * @param updateTeacher 包含更新信息的教师对象
+     */
     void updateInfo(Teacher updateTeacher);
 }

src/dao/impl/AdminDaoImpl.java

@@ -1,46 +1,79 @@
 package dao.impl;
 
-import dao.AdminDao;
-import domain.Admin;
-import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.core.BeanPropertyRowMapper;
-import org.springframework.jdbc.core.JdbcTemplate;
-import utils.JDBCUtils;
+import dao.AdminDao;  // 引入 AdminDao 接口，定义管理员相关的数据访问方法
+import domain.Admin;  // 引入 Admin 实体类，表示管理员数据
+import org.springframework.dao.DataAccessException;  // 引入数据库访问异常类
+import org.springframework.jdbc.core.BeanPropertyRowMapper;  // 用于将查询结果映射为 Java 对象
+import org.springframework.jdbc.core.JdbcTemplate;  // JDBC 操作模板，用于简化数据库操作
+import utils.JDBCUtils;  // 自定义工具类，用于获取数据库数据源
 
+/**
+ * AdminDaoImpl 实现类，负责对管理员信息进行数据库操作。
+ */
 public class AdminDaoImpl implements AdminDao {
+
+    // 使用 JdbcTemplate 对数据库进行操作，JDBCUtils 提供数据源
     private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
 
+    /**
+     * 根据管理员 ID 和密码查询管理员信息。
+     * 
+     * @param id       管理员 ID
+     * @param password 管理员密码
+     * @return 如果匹配成功，返回管理员对象；否则返回 null
+     */
     @Override
     public Admin findAdminidAndPassword(String id, String password) {
         try {
+            // SQL 查询语句：根据管理员 ID 和密码查询管理员
             String sql = "select * from admin where a_id = ? and a_password = ?";
-            Admin admin = template.queryForObject(sql,new BeanPropertyRowMapper<Admin>(Admin.class),id,password);
-            return admin;
+            // 执行查询，并将结果映射为 Admin 对象
+            Admin admin = template.queryForObject(sql, new BeanPropertyRowMapper<>(Admin.class), id, password);
+            return admin;  // 返回找到的管理员
         } catch (DataAccessException e) {
+            // 捕获数据库访问异常并打印堆栈信息
             e.printStackTrace();
-            return null;
+            return null;  // 查询失败时返回 null
         }
     }
 
+    /**
+     * 更新管理员密码。
+     * 
+     * @param adminid     管理员 ID
+     * @param newpassword 新密码
+     */
     @Override
     public void updatePassword(String adminid, String newpassword) {
         try {
+            // SQL 更新语句：根据管理员 ID 更新密码
             String sql = "update admin set a_password=? where a_id=?";
-            template.update(sql,newpassword,adminid);
+            // 执行更新操作
+            template.update(sql, newpassword, adminid);
         } catch (Exception e) {
+            // 捕获异常并打印堆栈信息
             e.printStackTrace();
         }
     }
 
+    /**
+     * 根据管理员 ID 查询管理员信息。
+     * 
+     * @param id 管理员 ID
+     * @return 如果存在，返回管理员对象；否则返回 null
+     */
     @Override
     public Admin findAdminById(String id) {
         try {
+            // SQL 查询语句：根据管理员 ID 查询管理员
             String sql = "select * from admin where a_id = ?";
-            Admin admin = template.queryForObject(sql,new BeanPropertyRowMapper<Admin>(Admin.class),id);
-            return admin;
+            // 执行查询，并将结果映射为 Admin 对象
+            Admin admin = template.queryForObject(sql, new BeanPropertyRowMapper<>(Admin.class), id);
+            return admin;  // 返回找到的管理员
         } catch (DataAccessException e) {
+            // 捕获数据库访问异常并打印堆栈信息
             e.printStackTrace();
-            return null;
+            return null;  // 查询失败时返回 null
         }
     }
 }

src/dao/impl/CDCDaoImpl.java

@@ -1,62 +1,92 @@
 package dao.impl;
 
-import dao.CDCDao;
-import domain.CDC;
-import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.core.BeanPropertyRowMapper;
-import org.springframework.jdbc.core.JdbcTemplate;
-import utils.JDBCUtils;
+// 引入相关类和接口
+import dao.CDCDao; // 数据访问对象（DAO）接口
+import domain.CDC; // 表示 CDC 表数据结构的实体类
+import org.springframework.dao.DataAccessException; // 数据访问异常类
+import org.springframework.jdbc.core.BeanPropertyRowMapper; // 用于将结果集映射为实体类
+import org.springframework.jdbc.core.JdbcTemplate; // Spring 的 JDBC 模板类
+import utils.JDBCUtils; // 自定义的工具类，用于获取数据源
 
-import java.util.List;
+import java.util.List; // Java 的 List 接口
 
+/**
+ * CDCDaoImpl 实现了 CDCDao 接口，负责与数据库交互以获取 CDC 数据表的信息。
+ */
 public class CDCDaoImpl implements CDCDao {
+
+    // 使用 JdbcTemplate 进行数据库操作，通过 JDBCUtils 获取数据源
     private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
 
+    /**
+     * 查询所有学院名称（去重）
+     * @return 包含所有学院名称的 CDC 对象列表；查询失败返回 null
+     */
     @Override
     public List<CDC> findAllCollege() {
         try {
+            // SQL 语句：获取去重的学院名称
             String sql = "select distinct college from college_department_class";
+            // 使用 JdbcTemplate 执行查询，并将结果映射为 CDC 对象
             List<CDC> cdcs = template.query(sql, new BeanPropertyRowMapper<CDC>(CDC.class));
-            return cdcs;
+            return cdcs; // 返回查询结果
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return  null;
+            e.printStackTrace(); // 打印异常堆栈信息
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 查询所有系名称（去重）
+     * @return 包含所有系名称的 CDC 对象列表；查询失败返回 null
+     */
     @Override
     public List<CDC> findAllDepartment() {
         try {
+            // SQL 语句：获取去重的系名称
             String sql = "select distinct department from college_department_class";
+            // 使用 JdbcTemplate 执行查询，并将结果映射为 CDC 对象
             List<CDC> cdcs = template.query(sql, new BeanPropertyRowMapper<CDC>(CDC.class));
-            return cdcs;
+            return cdcs; // 返回查询结果
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 打印异常堆栈信息
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 查询所有班级名称（去重）
+     * @return 包含所有班级名称的 CDC 对象列表；查询失败返回 null
+     */
     @Override
     public List<CDC> findAllClass() {
         try {
+            // SQL 语句：获取去重的班级名称
             String sql = "select distinct cclass from college_department_class";
+            // 使用 JdbcTemplate 执行查询，并将结果映射为 CDC 对象
             List<CDC> cdcs = template.query(sql, new BeanPropertyRowMapper<CDC>(CDC.class));
-            return cdcs;
+            return cdcs; // 返回查询结果
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 打印异常堆栈信息
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 查询表中的所有数据
+     * @return 包含所有数据的 CDC 对象列表；查询失败返回 null
+     */
     @Override
     public List<CDC> findAll() {
         try {
+            // SQL 语句：获取表中所有数据
             String sql = "select * from college_department_class";
+            // 使用 JdbcTemplate 执行查询，并将结果映射为 CDC 对象
             List<CDC> cdcs = template.query(sql, new BeanPropertyRowMapper<CDC>(CDC.class));
-            return cdcs;
+            return cdcs; // 返回查询结果
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 打印异常堆栈信息
+            return null; // 查询失败时返回 null
         }
     }
 }

src/dao/impl/ComplaintDaoImpl.java

@@ -1,36 +1,54 @@
 package dao.impl;
 
-import dao.ComplaintDao;
-import domain.Complaint;
-import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.core.BeanPropertyRowMapper;
-import org.springframework.jdbc.core.JdbcTemplate;
-import utils.JDBCUtils;
+// 引入相关类和接口
+import dao.ComplaintDao; // 数据访问对象（DAO）接口
+import domain.Complaint; // 表示 Complaint 表数据结构的实体类
+import org.springframework.dao.DataAccessException; // 数据访问异常类
+import org.springframework.jdbc.core.BeanPropertyRowMapper; // 用于将结果集映射为实体类
+import org.springframework.jdbc.core.JdbcTemplate; // Spring 的 JDBC 模板类
+import utils.JDBCUtils; // 自定义工具类，用于获取数据源
 
-import java.util.List;
+import java.util.List; // Java 的 List 接口
 
+/**
+ * ComplaintDaoImpl 实现了 ComplaintDao 接口，负责与数据库交互以操作 Complaint 数据表。
+ */
 public class ComplaintDaoImpl implements ComplaintDao {
+
+    // 使用 JdbcTemplate 进行数据库操作，通过 JDBCUtils 获取数据源
     private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
 
+    /**
+     * 查询所有投诉记录，并按 ID 降序排序
+     * @return 包含所有投诉记录的列表；查询失败时返回 null
+     */
     @Override
     public List<Complaint> findAllComplaint() {
         try {
+            // SQL 语句：查询所有投诉记录并按 ID 倒序排列
             String sql = "select * from complaint order by id DESC";
+            // 使用 JdbcTemplate 执行查询，并将结果映射为 Complaint 对象列表
             List<Complaint> complaints = template.query(sql, new BeanPropertyRowMapper<Complaint>(Complaint.class));
-            return complaints;
+            return complaints; // 返回查询结果
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 打印异常堆栈信息
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 添加一条新的投诉记录
+     * @param complaint 包含投诉信息的对象（日期和内容）
+     */
     @Override
     public void addComplaint(Complaint complaint) {
         try {
+            // SQL 语句：向 complaint 表插入记录
             String sql = "insert into complaint(cdate,content) values(?,?)";
-            template.update(sql,complaint.getCdate(),complaint.getContent());
+            // 使用 JdbcTemplate 执行更新操作
+            template.update(sql, complaint.getCdate(), complaint.getContent());
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 打印异常堆栈信息
         }
     }
 }

src/dao/impl/CourseDaoImpl.java

@@ -1,44 +1,69 @@
 package dao.impl;
 
-import dao.CourseDao;
-import domain.Course;
-import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.core.BeanPropertyRowMapper;
-import org.springframework.jdbc.core.JdbcTemplate;
-import utils.JDBCUtils;
+// 引入相关类和接口
+import dao.CourseDao; // 数据访问对象（DAO）接口
+import domain.Course; // 表示 Course 表数据结构的实体类
+import org.springframework.dao.DataAccessException; // 数据访问异常类
+import org.springframework.jdbc.core.BeanPropertyRowMapper; // 用于将结果集映射为实体类
+import org.springframework.jdbc.core.JdbcTemplate; // Spring 的 JDBC 模板类
+import utils.JDBCUtils; // 自定义工具类，用于获取数据源
 
+/**
+ * CourseDaoImpl 实现了 CourseDao 接口，负责与数据库交互以操作 Course 数据表。
+ */
 public class CourseDaoImpl implements CourseDao {
+
+    // 使用 JdbcTemplate 进行数据库操作，通过 JDBCUtils 获取数据源
     private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
 
+    /**
+     * 添加一门可选课程
+     * @param c 包含课程信息的 Course 对象
+     */
     @Override
     public void addOptionalCourse(Course c) {
         try {
+            // SQL 语句：向 course 表插入课程记录
             String sql = "insert into course values(?,?,?,?)";
-            template.update(sql,c.getC_id(),c.getC_name(),c.getT_id(),c.getC_info());
+            // 使用 JdbcTemplate 执行插入操作
+            template.update(sql, c.getC_id(), c.getC_name(), c.getT_id(), c.getC_info());
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 打印异常堆栈信息
         }
     }
 
+    /**
+     * 根据课程 ID 查找已选课程
+     * @param cid 课程 ID
+     * @return 查找到的课程对象；未找到时返回 null
+     */
     @Override
     public Course findSelectCourseByCourseId(String cid) {
         try {
+            // SQL 语句：根据课程 ID 查找对应课程信息
             String sql = "select * from course where c_id = ?";
-            Course course = template.queryForObject(sql,new BeanPropertyRowMapper<Course>(Course.class),cid);
-            return course;
+            // 使用 JdbcTemplate 执行查询，并将结果映射为 Course 对象
+            Course course = template.queryForObject(sql, new BeanPropertyRowMapper<Course>(Course.class), cid);
+            return course; // 返回查询结果
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 打印异常堆栈信息
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 根据课程 ID 删除课程
+     * @param cid 课程 ID
+     */
     @Override
     public void deleteServiceById(String cid) {
         try {
+            // SQL 语句：根据课程 ID 删除对应课程记录
             String sql = "delete from course where c_id=?";
-            template.update(sql,cid);
+            // 使用 JdbcTemplate 执行删除操作
+            template.update(sql, cid);
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 打印异常堆栈信息
         }
     }
 }

src/dao/impl/NotifyDaoImpl.java

@@ -1,58 +1,88 @@
 package dao.impl;
 
-import dao.NotifyDao;
-import domain.Notify;
-import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.core.BeanPropertyRowMapper;
-import org.springframework.jdbc.core.JdbcTemplate;
-import utils.JDBCUtils;
+// 引入相关类和接口
+import dao.NotifyDao; // 数据访问对象（DAO）接口
+import domain.Notify; // 表示 Notify 表数据结构的实体类
+import org.springframework.dao.DataAccessException; // 数据访问异常类
+import org.springframework.jdbc.core.BeanPropertyRowMapper; // 用于将结果集映射为实体类
+import org.springframework.jdbc.core.JdbcTemplate; // Spring 的 JDBC 模板类
+import utils.JDBCUtils; // 自定义工具类，用于获取数据源
 
-import java.util.List;
+import java.util.List; // Java 的 List 接口
 
+/**
+ * NotifyDaoImpl 实现了 NotifyDao 接口，负责与数据库交互以操作 Notify 数据表。
+ */
 public class NotifyDaoImpl implements NotifyDao {
+
+    // 使用 JdbcTemplate 进行数据库操作，通过 JDBCUtils 获取数据源
     private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
 
+    /**
+     * 添加一条通知记录
+     * @param notify 包含通知信息的 Notify 对象
+     */
     @Override
     public void add(Notify notify) {
         try {
-            String sql = "insert into notify(notifyDate,notifyInfo) values(?,?)";
-            template.update(sql,notify.getNotifyDate(),notify.getNotifyInfo());
+            // SQL 语句：向 notify 表插入通知记录
+            String sql = "insert into notify(notifyDate, notifyInfo) values(?, ?)";
+            // 使用 JdbcTemplate 执行插入操作
+            template.update(sql, notify.getNotifyDate(), notify.getNotifyInfo());
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 打印异常堆栈信息
         }
     }
 
+    /**
+     * 查询所有通知记录，并按 ID 降序排序
+     * @return 包含所有通知记录的 List；查询失败时返回 null
+     */
     @Override
     public List<Notify> findAllNotify() {
         try {
+            // SQL 语句：查询所有通知记录并按 ID 倒序排列
             String sql = "select * from notify order by id DESC";
+            // 使用 JdbcTemplate 执行查询，并将结果映射为 Notify 对象列表
             List<Notify> notifys = template.query(sql, new BeanPropertyRowMapper<Notify>(Notify.class));
-            return notifys;
+            return notifys; // 返回查询结果
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 打印异常堆栈信息
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 根据通知 ID 删除通知记录
+     * @param notifyid 通知 ID
+     */
     @Override
     public void deleteNotifyById(String notifyid) {
         try {
+            // SQL 语句：根据通知 ID 删除对应的通知记录
             String sql = "delete from notify where id=?";
-            template.update(sql,notifyid);
+            // 使用 JdbcTemplate 执行删除操作
+            template.update(sql, notifyid);
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 打印异常堆栈信息
         }
     }
 
+    /**
+     * 查询最近的三条通知记录
+     * @return 包含最近三条通知记录的 List；查询失败时返回 null
+     */
     @Override
     public List<Notify> findNotify() {
         try {
+            // SQL 语句：查询最近三条通知记录
             String sql = "select * from notify order by id DESC limit 3";
+            // 使用 JdbcTemplate 执行查询，并将结果映射为 Notify 对象列表
             List<Notify> notify = template.query(sql, new BeanPropertyRowMapper<Notify>(Notify.class));
-            return notify;
+            return notify; // 返回查询结果
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 打印异常堆栈信息
+            return null; // 查询失败时返回 null
         }
     }
 }

src/dao/impl/PhotoDaoImpl.java

@@ -1,44 +1,69 @@
 package dao.impl;
 
-import dao.PhotoDao;
-import domain.Photo;
-import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.core.BeanPropertyRowMapper;
-import org.springframework.jdbc.core.JdbcTemplate;
-import utils.JDBCUtils;
+// 引入相关类和接口
+import dao.PhotoDao; // 数据访问对象（DAO）接口
+import domain.Photo; // 表示 Photo 表数据结构的实体类
+import org.springframework.dao.DataAccessException; // 数据访问异常类
+import org.springframework.jdbc.core.BeanPropertyRowMapper; // 用于将结果集映射为实体类
+import org.springframework.jdbc.core.JdbcTemplate; // Spring 的 JDBC 模板类
+import utils.JDBCUtils; // 自定义工具类，用于获取数据源
 
+/**
+ * PhotoDaoImpl 实现了 PhotoDao 接口，负责与数据库交互以操作 Photo 数据表。
+ */
 public class PhotoDaoImpl implements PhotoDao {
+
+    // 使用 JdbcTemplate 进行数据库操作，通过 JDBCUtils 获取数据源
     private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
 
+    /**
+     * 添加一条照片记录
+     * @param photo 包含照片信息的 Photo 对象
+     */
     @Override
     public void addPhoto(Photo photo) {
         try {
-            String sql = "insert into photo(photo_id,photo_name) values(?,?)";
-            template.update(sql,photo.getPhotoId(),photo.getPhotoName());
+            // SQL 语句：向 photo 表插入照片记录
+            String sql = "insert into photo(photo_id, photo_name) values(?, ?)";
+            // 使用 JdbcTemplate 执行插入操作
+            template.update(sql, photo.getPhotoId(), photo.getPhotoName());
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 打印异常堆栈信息
         }
     }
 
+    /**
+     * 根据照片 ID 查找照片
+     * @param id 照片 ID
+     * @return 查找到的 Photo 对象；未找到时返回 null
+     */
     @Override
     public Photo findPhotoByPhotoId(String id) {
         try {
+            // SQL 语句：根据照片 ID 查找对应的照片记录
             String sql = "select * from photo where photo_id = ?";
-            Photo photo = template.queryForObject(sql,new BeanPropertyRowMapper<Photo>(Photo.class),id);
-            return photo;
+            // 使用 JdbcTemplate 执行查询，并将结果映射为 Photo 对象
+            Photo photo = template.queryForObject(sql, new BeanPropertyRowMapper<Photo>(Photo.class), id);
+            return photo; // 返回查询结果
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 打印异常堆栈信息
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 更新照片信息
+     * @param photo 包含更新信息的 Photo 对象
+     */
     @Override
     public void updatePhoto(Photo photo) {
         try {
-            String sql = "update photo set photo_name=? where photo_id=?";
-            template.update(sql,photo.getPhotoName(),photo.getPhotoId());
+            // SQL 语句：更新 photo 表中的照片名称
+            String sql = "update photo set photo_name = ? where photo_id = ?";
+            // 使用 JdbcTemplate 执行更新操作
+            template.update(sql, photo.getPhotoName(), photo.getPhotoId());
         } catch (Exception e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 打印异常堆栈信息
         }
     }
 }

src/dao/impl/SelectCourseDaoImpl.java

@@ -1,53 +1,81 @@
 package dao.impl;
 
-import dao.SelectCourseDao;
-import domain.SelectCourse;
-import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.core.BeanPropertyRowMapper;
-import org.springframework.jdbc.core.JdbcTemplate;
-import utils.JDBCUtils;
+// 引入相关类和接口
+import dao.SelectCourseDao; // 数据访问对象（DAO）接口
+import domain.SelectCourse; // 表示 SelectCourse 表数据结构的实体类
+import org.springframework.dao.DataAccessException; // 数据访问异常类
+import org.springframework.jdbc.core.BeanPropertyRowMapper; // 用于将结果集映射为实体类
+import org.springframework.jdbc.core.JdbcTemplate; // Spring 的 JDBC 模板类
+import utils.JDBCUtils; // 自定义工具类，用于获取数据源
 
-import java.util.List;
+import java.util.List; // Java 的 List 接口
 
+/**
+ * SelectCourseDaoImpl 实现了 SelectCourseDao 接口，负责与数据库交互以操作 select_course 数据表。
+ */
 public class SelectCourseDaoImpl implements SelectCourseDao {
+
+    // 使用 JdbcTemplate 进行数据库操作，通过 JDBCUtils 获取数据源
     private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
 
+    /**
+     * 根据课程 ID 查找选修该课程的所有学生及成绩
+     * @param cid 课程 ID
+     * @return 包含学生选课信息的 List；查询失败时返回 null
+     */
     @Override
     public List<SelectCourse> findStudentSelectedCourseByCourseId(String cid) {
         try {
-            String sql = "select course.c_id,course.c_name,course.c_info,student.s_id,student.s_name,select_course.score\n" +
-                    "from select_course,student,course\n" +
-                    "where student.s_id=select_course.s_id\n" +
-                    "and select_course.c_id=course.c_id\n" +
-                    "and select_course.c_id=?";
-            List<SelectCourse> scs = template.query(sql, new BeanPropertyRowMapper<SelectCourse>(SelectCourse.class),cid);
-            return scs;
+            // SQL 语句：查询选修该课程的所有学生及成绩信息
+            String sql = "select course.c_id, course.c_name, course.c_info, student.s_id, student.s_name, select_course.score\n" +
+                         "from select_course, student, course\n" +
+                         "where student.s_id = select_course.s_id\n" +
+                         "and select_course.c_id = course.c_id\n" +
+                         "and select_course.c_id = ?";
+            // 使用 JdbcTemplate 执行查询，并将结果映射为 SelectCourse 对象列表
+            List<SelectCourse> scs = template.query(sql, new BeanPropertyRowMapper<SelectCourse>(SelectCourse.class), cid);
+            return scs; // 返回查询结果
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 打印异常堆栈信息
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 根据课程 ID 和学生 ID 查找选课记录和成绩
+     * @param cid 课程 ID
+     * @param sid 学生 ID
+     * @return 查找到的 SelectCourse 对象；未找到时返回 null
+     */
     @Override
     public SelectCourse findScoreByCourseIdAndStudentId(String cid, String sid) {
         try {
-            String sql = "select * from select_course where c_id=? and s_id=?";
+            // SQL 语句：查询指定课程和学生的选课记录
+            String sql = "select * from select_course where c_id = ? and s_id = ?";
+            // 使用 JdbcTemplate 执行查询，并将结果映射为 SelectCourse 对象
             SelectCourse sc = template.queryForObject(sql, new BeanPropertyRowMapper<SelectCourse>(SelectCourse.class), cid, sid);
-            return sc;
-        } catch (
-        DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            return sc; // 返回查询结果
+        } catch (DataAccessException e) {
+            e.printStackTrace(); // 打印异常堆栈信息
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 根据课程 ID 和学生 ID 更新成绩
+     * @param cid 课程 ID
+     * @param sid 学生 ID
+     * @param sScore 学生成绩
+     */
     @Override
     public void upDateScoreByCidAndSid(String cid, String sid, String sScore) {
         try {
+            // SQL 语句：根据课程 ID 和学生 ID 更新成绩
             String sql = "update select_course set score = ? where c_id = ? and s_id = ?";
-            template.update(sql,sScore,cid,sid);
+            // 使用 JdbcTemplate 执行更新操作
+            template.update(sql, sScore, cid, sid);
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 打印异常堆栈信息
         }
     }
 }

src/dao/impl/StudentDaoImpl.java

@@ -1,233 +1,318 @@
 package dao.impl;
 
-import dao.StudentDao;
-import domain.Course;
-import domain.SelectCourse;
-import domain.Student;
-import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.core.BeanPropertyRowMapper;
-import org.springframework.jdbc.core.JdbcTemplate;
-import utils.JDBCUtils;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+// 引入相关类和接口
+import dao.StudentDao; // StudentDao 接口，定义学生相关的数据访问方法
+import domain.Course; // Course 实体类，表示课程数据
+import domain.SelectCourse; // SelectCourse 实体类，表示学生选课信息
+import domain.Student; // Student 实体类，表示学生数据
+import org.springframework.dao.DataAccessException; // 数据访问异常
+import org.springframework.jdbc.core.BeanPropertyRowMapper; // 将查询结果映射为 Java 对象
+import org.springframework.jdbc.core.JdbcTemplate; // JDBC 操作模板
+import utils.JDBCUtils; // 自定义工具类，用于获取数据库数据源
 
+import java.util.ArrayList; // ArrayList 类，用于存储参数和结果
+import java.util.List; // List 接口，表示列表
+import java.util.Map; // Map 接口，用于存储查询条件
+import java.util.Set; // Set 接口，用于存储条件的键集合
+
+/**
+ * StudentDaoImpl 实现了 StudentDao 接口，负责操作学生数据表。
+ */
 public class StudentDaoImpl implements StudentDao {
+
+    // 使用 JdbcTemplate 来简化数据库操作，JDBCUtils 提供数据源
     private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
 
+    /**
+     * 获取所有学生信息
+     * @return 返回所有学生的 List；查询失败时返回 null
+     */
     @Override
     public List<Student> findAll() {
-        //使用JDBC操作数据库
         try {
+            // SQL 语句：查询所有学生
             String sql = "select * from student";
+            // 执行查询并返回结果，使用 BeanPropertyRowMapper 将结果映射为 Student 实体类
             List<Student> students = template.query(sql, new BeanPropertyRowMapper<Student>(Student.class));
             return students;
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 捕获并打印异常堆栈
+            return null; // 查询失败时返回 null
         }
-
     }
 
+    /**
+     * 根据学生 ID 和密码查找学生
+     * @param id 学生 ID
+     * @param password 学生密码
+     * @return 找到的学生；未找到时返回 null
+     */
     @Override
-    public Student findStudentidAndPassword(String id,String password) {
+    public Student findStudentidAndPassword(String id, String password) {
         try {
+            // SQL 语句：根据学生 ID 和密码查询学生
             String sql = "select * from student where s_id = ? and s_password = ?";
-            Student student = template.queryForObject(sql,new BeanPropertyRowMapper<Student>(Student.class),id,password);
+            // 执行查询并返回结果
+            Student student = template.queryForObject(sql, new BeanPropertyRowMapper<Student>(Student.class), id, password);
             return student;
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 捕获并打印异常堆栈
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 根据学生 ID 查找学生
+     * @param id 学生 ID
+     * @return 找到的学生；未找到时返回 null
+     */
     @Override
     public Student findStudentById(String id) {
         try {
+            // SQL 语句：根据学生 ID 查询学生信息
             String sql = "select * from student where s_id = ?";
-            Student student = template.queryForObject(sql,new BeanPropertyRowMapper<Student>(Student.class),id);
+            // 执行查询并返回结果
+            Student student = template.queryForObject(sql, new BeanPropertyRowMapper<Student>(Student.class), id);
             return student;
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 捕获并打印异常堆栈
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 添加新学生
+     * @param student 学生对象
+     */
     @Override
     public void addStudent(Student student) {
         try {
-            String sql = "insert into student(s_id,s_password) values(?,?)";
-            template.update(sql,student.getS_id(),student.getS_password());
+            // SQL 语句：插入学生数据
+            String sql = "insert into student(s_id, s_password) values(?, ?)";
+            // 执行插入操作
+            template.update(sql, student.getS_id(), student.getS_password());
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 捕获并打印异常堆栈
         }
     }
 
+    /**
+     * 更新学生信息
+     * @param student 学生对象，包含要更新的信息
+     */
     @Override
     public void updateInfo(Student student) {
         try {
-            String sql = "update student set s_name =?,s_sex=?,s_age=?,s_phone=?,s_email=?,s_address=?,s_college=?,s_department=?,s_class=? where s_id=?";
-            template.update(sql,student.getS_name(),student.getS_sex(),student.getS_age(),student.getS_phone(),student.getS_email(),student.getS_address(),student.getS_college(),student.getS_department(),student.getS_class(),student.getS_id());
+            // SQL 语句：更新学生信息
+            String sql = "update student set s_name = ?, s_sex = ?, s_age = ?, s_phone = ?, s_email = ?, s_address = ?, s_college = ?, s_department = ?, s_class = ? where s_id = ?";
+            // 执行更新操作
+            template.update(sql, student.getS_name(), student.getS_sex(), student.getS_age(),
+                            student.getS_phone(), student.getS_email(), student.getS_address(),
+                            student.getS_college(), student.getS_department(), student.getS_class(), student.getS_id());
         } catch (Exception e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 捕获并打印异常堆栈
         }
     }
 
+    /**
+     * 更新学生密码
+     * @param studentid 学生 ID
+     * @param newpassword 新密码
+     */
     @Override
     public void updatePassword(String studentid, String newpassword) {
         try {
-            String sql = "update student set s_password=? where s_id=?";
-            template.update(sql,newpassword,studentid);
+            // SQL 语句：更新学生密码
+            String sql = "update student set s_password = ? where s_id = ?";
+            // 执行更新操作
+            template.update(sql, newpassword, studentid);
         } catch (Exception e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 捕获并打印异常堆栈
         }
     }
 
+    /**
+     * 查找指定学生的所有选课信息
+     * @param studentid 学生 ID
+     * @return 包含学生选课信息的 List；查询失败时返回 null
+     */
     @Override
     public List<SelectCourse> findAllSelectCourse(String studentid) {
         try {
-            String sql = "select student.s_id,student.s_name,course.c_id,course.c_name,course.c_info,teacher.t_id,t_name,select_course.score\n" +
-                    "from select_course,student,course,teacher\n" +
-                    "where student.s_id=select_course.s_id\n" +
-                    "and select_course.c_id=course.c_id\n" +
-                    "and course.t_id=teacher.t_id\n" +
-                    "and student.s_id=?";
-            List<SelectCourse> scs = template.query(sql, new BeanPropertyRowMapper<SelectCourse>(SelectCourse.class),studentid);
+            // SQL 语句：查询学生的所有选课信息
+            String sql = "select student.s_id, student.s_name, course.c_id, course.c_name, course.c_info, teacher.t_id, t_name, select_course.score " +
+                         "from select_course, student, course, teacher " +
+                         "where student.s_id = select_course.s_id " +
+                         "and select_course.c_id = course.c_id " +
+                         "and course.t_id = teacher.t_id " +
+                         "and student.s_id = ?";
+            // 执行查询并返回结果
+            List<SelectCourse> scs = template.query(sql, new BeanPropertyRowMapper<SelectCourse>(SelectCourse.class), studentid);
             return scs;
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 捕获并打印异常堆栈
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 获取所有可选课程
+     * @return 包含所有可选课程的 List；查询失败时返回 null
+     */
     @Override
     public List<Course> findAllOptionalCourse() {
         try {
-            String sql = "select course.c_id,course.c_name,course.c_info,teacher.t_id,t_name\n" +
-                    "from course,teacher\n" +
-                    "where course.t_id=teacher.t_id";
+            // SQL 语句：查询所有可选课程
+            String sql = "select course.c_id, course.c_name, course.c_info, teacher.t_id, t_name " +
+                         "from course, teacher " +
+                         "where course.t_id = teacher.t_id";
+            // 执行查询并返回结果
             List<Course> cs = template.query(sql, new BeanPropertyRowMapper<Course>(Course.class));
             return cs;
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 捕获并打印异常堆栈
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 学生选修课程
+     * @param studentid 学生 ID
+     * @param courseid 课程 ID
+     */
     @Override
     public void addSelectCourse(String studentid, String courseid) {
         try {
-            String sql = "insert into select_course(s_id,c_id) values(?,?)";
-            template.update(sql,studentid,courseid);
+            // SQL 语句：学生选修课程
+            String sql = "insert into select_course(s_id, c_id) values(?, ?)";
+            // 执行插入操作
+            template.update(sql, studentid, courseid);
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 捕获并打印异常堆栈
         }
     }
 
+    /**
+     * 根据学生 ID 删除学生
+     * @param studentid 学生 ID
+     */
     @Override
     public void deleteStudentById(String studentid) {
         try {
-            String sql = "delete from student where s_id=?";
-            template.update(sql,studentid);
+            // SQL 语句：删除学生
+            String sql = "delete from student where s_id = ?";
+            // 执行删除操作
+            template.update(sql, studentid);
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 捕获并打印异常堆栈
         }
     }
 
+    /**
+     * 查找符合条件的学生总数
+     * @param condition 查询条件
+     * @return 符合条件的学生总数
+     */
     @Override
     public int findTotalCount(Map<String, String[]> condition) {
-        //定义模板初始化sql
-        String sql = "select count(*) from student where 1=1";
+        // 初始化 SQL 语句
+        String sql = "select count(*) from student where 1 = 1";
         StringBuilder sb = new StringBuilder(sql);
-        //遍历map
+        List<Object> params = new ArrayList<Object>(); // 存储查询参数
+        // 遍历查询条件
         Set<String> keySet = condition.keySet();
-        //定义参数集合
-        List<Object> params = new ArrayList<Object>();
         for (String key : keySet) {
-            System.out.println(key);
-            //排除分页条件参数
+            // 排除分页相关的参数
             if ("currentPage".equals(key) || "rows".equals(key)) {
                 continue;
             }
-
-            //获取value
             String value = condition.get(key)[0];
-            //判断value是否有值
             if (value != null && !"".equals(value)) {
-                //有值
-                sb.append(" and "+key+" like ? ");
-                params.add("%"+value+"%");//?条件的值
+                // 添加条件到 SQL 语句
+                sb.append(" and " + key + " like ? ");
+                params.add("%" + value + "%"); // ? 条件的值
             }
         }
-        System.out.println(sb.toString());
-        System.out.println(params);
-        return template.queryForObject(sb.toString(),Integer.class,params.toArray());
+        // 执行查询并返回结果
+        return template.queryForObject(sb.toString(), Integer.class, params.toArray());
     }
 
+    /**
+     * 添加学生的所有信息
+     * @param s 学生对象，包含所有信息
+     */
     @Override
     public void addStudentAllInfo(Student s) {
         try {
-            String sql = "insert into student(s_id,s_college,s_department,s_class,s_name,s_sex,s_age,s_phone,s_email,s_address) values(?,?,?,?,?,?,?,?,?,?)";
-            template.update(sql,s.getS_id(),s.getS_college(),s.getS_department(),s.getS_class(),s.getS_name(),s.getS_sex(),s.getS_age(),s.getS_phone(),s.getS_email(),s.getS_address());
+            // SQL 语句：插入学生所有信息
+            String sql = "insert into student(s_id, s_college, s_department, s_class, s_name, s_sex, s_age, s_phone, s_email, s_address) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+            // 执行插入操作
+            template.update(sql, s.getS_id(), s.getS_college(), s.getS_department(), s.getS_class(), s.getS_name(),
+                            s.getS_sex(), s.getS_age(), s.getS_phone(), s.getS_email(), s.getS_address());
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 捕获并打印异常堆栈
         }
     }
 
+    /**
+     * 获取所有学生的选课信息
+     * @return 所有学生的选课信息；查询失败时返回 null
+     */
     @Override
     public List<SelectCourse> findSelectCourseAllStudent() {
         try {
-            String sql = "select student.s_id,student.s_name,course.c_id,course.c_name,course.c_info,teacher.t_id,t_name,select_course.score\n" +
-                    "from select_course,student,course,teacher\n" +
-                    "where student.s_id=select_course.s_id\n" +
-                    "and select_course.c_id=course.c_id\n" +
-                    "and course.t_id=teacher.t_id\n";
+            // SQL 语句：查询所有学生的选课信息
+            String sql = "select student.s_id, student.s_name, course.c_id, course.c_name, course.c_info, teacher.t_id, t_name, select_course.score " +
+                         "from select_course, student, course, teacher " +
+                         "where student.s_id = select_course.s_id " +
+                         "and select_course.c_id = course.c_id " +
+                         "and course.t_id = teacher.t_id";
+            // 执行查询并返回结果
             List<SelectCourse> scs = template.query(sql, new BeanPropertyRowMapper<SelectCourse>(SelectCourse.class));
             return scs;
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 捕获并打印异常堆栈
+            return null; // 查询失败时返回 null
         }
-
     }
 
+    /**
+     * 根据条件分页查询学生
+     * @param start 起始记录
+     * @param rows 每页记录数
+     * @param condition 查询条件
+     * @return 符合条件的学生列表
+     */
     @Override
     public List<Student> findByPage(int start, int rows, Map<String, String[]> condition) {
         try {
-            String sql = "select * from student where 1=1";
+            // 初始化 SQL 语句
+            String sql = "select * from student where 1 = 1";
             StringBuilder sb = new StringBuilder(sql);
-            //遍历map
+            List<Object> params = new ArrayList<Object>(); // 存储查询参数
+            // 遍历查询条件
             Set<String> keySet = condition.keySet();
-            //定义参数集合
-            List<Object> params = new ArrayList<Object>();
             for (String key : keySet) {
-                //排除分页条件参数
+                // 排除分页相关的参数
                 if ("currentPage".equals(key) || "rows".equals(key)) {
                     continue;
                 }
-
-                //获取value
                 String value = condition.get(key)[0];
-                //判断value是否有值
                 if (value != null && !"".equals(value)) {
-                    //有值
-                    sb.append(" and "+key+" like ? ");
-                    params.add("%"+value+"%");//?条件的值
+                    // 添加条件到 SQL 语句
+                    sb.append(" and " + key + " like ? ");
+                    params.add("%" + value + "%"); // ? 条件的值
                 }
             }
-            //添加分页查询
-            sb.append(" limit ? , ?");
-            //添加分页查询参数值
+            // 添加分页条件
+            sb.append(" limit ?, ?");
             params.add(start);
             params.add(rows);
-            System.out.println(sb.toString());
-            System.out.println(params);
-            return template.query(sb.toString(),new BeanPropertyRowMapper<Student>(Student.class),params.toArray());
+            // 执行查询并返回结果
+            return template.query(sb.toString(), new BeanPropertyRowMapper<Student>(Student.class), params.toArray());
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 捕获并打印异常堆栈
+            return null; // 查询失败时返回 null
         }
     }
 }

src/dao/impl/TeacherDaoImpl.java

@@ -1,137 +1,213 @@
 package dao.impl;
 
-import dao.TeacherDao;
-import domain.Course;
-import domain.Student;
-import domain.Teacher;
-import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.core.BeanPropertyRowMapper;
-import org.springframework.jdbc.core.JdbcTemplate;
-import utils.JDBCUtils;
+// 引入相关类和接口
+import dao.TeacherDao; // TeacherDao 接口，定义教师相关的数据访问方法
+import domain.Course; // Course 实体类，表示课程数据
+import domain.Teacher; // Teacher 实体类，表示教师数据
+import org.springframework.dao.DataAccessException; // 数据访问异常
+import org.springframework.jdbc.core.BeanPropertyRowMapper; // 将查询结果映射为 Java 对象
+import org.springframework.jdbc.core.JdbcTemplate; // JDBC 操作模板
+import utils.JDBCUtils; // 自定义工具类，用于获取数据库数据源
 
-import java.util.List;
+import java.util.List; // List 接口，表示列表
 
+/**
+ * TeacherDaoImpl 实现了 TeacherDao 接口，负责操作教师相关的数据表。
+ */
 public class TeacherDaoImpl implements TeacherDao {
+
+    // 使用 JdbcTemplate 来简化数据库操作，JDBCUtils 提供数据源
     private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
 
+    /**
+     * 根据教师 ID 和密码查找教师
+     * @param id 教师 ID
+     * @param password 教师密码
+     * @return 找到的教师；未找到时返回 null
+     */
     @Override
     public Teacher findTeacheridAndPassword(String id, String password) {
         try {
+            // SQL 语句：根据教师 ID 和密码查询教师
             String sql = "select * from teacher where t_id = ? and t_password = ?";
-            Teacher teacher = template.queryForObject(sql,new BeanPropertyRowMapper<Teacher>(Teacher.class),id,password);
+            // 执行查询并返回结果
+            Teacher teacher = template.queryForObject(sql, new BeanPropertyRowMapper<Teacher>(Teacher.class), id, password);
             return teacher;
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 捕获并打印异常堆栈
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 获取所有教师信息
+     * @return 所有教师的 List；查询失败时返回 null
+     */
     @Override
     public List<Teacher> findAll() {
         try {
+            // SQL 语句：查询所有教师
             String sql = "select * from teacher";
+            // 执行查询并返回结果
             List<Teacher> teachers = template.query(sql, new BeanPropertyRowMapper<Teacher>(Teacher.class));
             return teachers;
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 捕获并打印异常堆栈
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 查找指定教师教授的所有课程
+     * @param t_id 教师 ID
+     * @return 教师教授的课程列表；查询失败时返回 null
+     */
     @Override
     public List<Course> findMySelfOptionalCourse(String t_id) {
         try {
+            // SQL 语句：查询教师教授的课程
             String sql = "select * from course where t_id = ?";
-            List<Course> courses = template.query(sql, new BeanPropertyRowMapper<Course>(Course.class),t_id);
+            // 执行查询并返回结果
+            List<Course> courses = template.query(sql, new BeanPropertyRowMapper<Course>(Course.class), t_id);
             return courses;
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 捕获并打印异常堆栈
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 根据课程 ID 查找课程信息
+     * @param cid 课程 ID
+     * @return 找到的课程；未找到时返回 null
+     */
     @Override
     public Course findOptionalCourseByCourseId(String cid) {
         try {
+            // SQL 语句：根据课程 ID 查询课程信息
             String sql = "select * from course where c_id = ?";
-            Course c = template.queryForObject(sql,new BeanPropertyRowMapper<Course>(Course.class),cid);
-            return c;
+            // 执行查询并返回结果
+            Course course = template.queryForObject(sql, new BeanPropertyRowMapper<Course>(Course.class), cid);
+            return course;
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 捕获并打印异常堆栈
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 更新课程信息
+     * @param updateCourse 要更新的课程信息
+     */
     @Override
     public void updateCourseInfo(Course updateCourse) {
         try {
-            String sql = "update course set c_name =?,c_info=? where c_id=?";
-            template.update(sql,updateCourse.getC_name(),updateCourse.getC_info(),updateCourse.getC_id());
+            // SQL 语句：更新课程信息
+            String sql = "update course set c_name = ?, c_info = ? where c_id = ?";
+            // 执行更新操作
+            template.update(sql, updateCourse.getC_name(), updateCourse.getC_info(), updateCourse.getC_id());
         } catch (Exception e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 捕获并打印异常堆栈
         }
     }
 
+    /**
+     * 根据课程 ID 删除课程
+     * @param cid 课程 ID
+     */
     @Override
     public void deleteCourseById(String cid) {
         try {
-            String sql = "delete from course where c_id=?";
-            template.update(sql,cid);
+            // SQL 语句：删除课程
+            String sql = "delete from course where c_id = ?";
+            // 执行删除操作
+            template.update(sql, cid);
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 捕获并打印异常堆栈
         }
     }
 
+    /**
+     * 更新教师密码
+     * @param teacherid 教师 ID
+     * @param newpassword 新密码
+     */
     @Override
     public void updatePassword(String teacherid, String newpassword) {
         try {
-            String sql = "update teacher set t_password=? where t_id=?";
-            template.update(sql,newpassword,teacherid);
+            // SQL 语句：更新教师密码
+            String sql = "update teacher set t_password = ? where t_id = ?";
+            // 执行更新操作
+            template.update(sql, newpassword, teacherid);
         } catch (Exception e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 捕获并打印异常堆栈
         }
     }
 
+    /**
+     * 根据教师 ID 查找教师信息
+     * @param t_id 教师 ID
+     * @return 找到的教师；未找到时返回 null
+     */
     @Override
     public Teacher findTeacherById(String t_id) {
         try {
+            // SQL 语句：根据教师 ID 查询教师信息
             String sql = "select * from teacher where t_id = ?";
-            Teacher teacher = template.queryForObject(sql,new BeanPropertyRowMapper<Teacher>(Teacher.class),t_id);
+            // 执行查询并返回结果
+            Teacher teacher = template.queryForObject(sql, new BeanPropertyRowMapper<Teacher>(Teacher.class), t_id);
             return teacher;
         } catch (DataAccessException e) {
-            e.printStackTrace();
-            return null;
+            e.printStackTrace(); // 捕获并打印异常堆栈
+            return null; // 查询失败时返回 null
         }
     }
 
+    /**
+     * 添加教师所有信息
+     * @param teacher 教师对象，包含所有信息
+     */
     @Override
-    public void addTeacherAllInfo(Teacher t) {
+    public void addTeacherAllInfo(Teacher teacher) {
         try {
-            String sql = "insert into teacher(t_id,t_name,t_sex,t_education,t_title) values(?,?,?,?,?)";
-            template.update(sql,t.getT_id(),t.getT_name(),t.getT_sex(),t.getT_education(),t.getT_title());
+            // SQL 语句：插入教师信息
+            String sql = "insert into teacher(t_id, t_name, t_sex, t_education, t_title) values(?, ?, ?, ?, ?)";
+            // 执行插入操作
+            template.update(sql, teacher.getT_id(), teacher.getT_name(), teacher.getT_sex(), teacher.getT_education(), teacher.getT_title());
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 捕获并打印异常堆栈
         }
     }
 
+    /**
+     * 根据教师 ID 删除教师
+     * @param teacherid 教师 ID
+     */
     @Override
     public void deleteTeacherById(String teacherid) {
         try {
-            String sql = "delete from teacher where t_id=?";
-            template.update(sql,teacherid);
+            // SQL 语句：删除教师
+            String sql = "delete from teacher where t_id = ?";
+            // 执行删除操作
+            template.update(sql, teacherid);
         } catch (DataAccessException e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 捕获并打印异常堆栈
         }
     }
 
+    /**
+     * 更新教师信息
+     * @param teacher 教师对象，包含要更新的信息
+     */
     @Override
-    public void updateInfo(Teacher t) {
+    public void updateInfo(Teacher teacher) {
         try {
-            String sql = "update teacher set t_name =?,t_sex=?,t_education=?,t_title=? where t_id=?";
-            template.update(sql,t.getT_name(),t.getT_sex(),t.getT_education(),t.getT_title(),t.getT_id());
+            // SQL 语句：更新教师信息
+            String sql = "update teacher set t_name = ?, t_sex = ?, t_education = ?, t_title = ? where t_id = ?";
+            // 执行更新操作
+            template.update(sql, teacher.getT_name(), teacher.getT_sex(), teacher.getT_education(), teacher.getT_title(), teacher.getT_id());
         } catch (Exception e) {
-            e.printStackTrace();
+            e.printStackTrace(); // 捕获并打印异常堆栈
         }
-
     }
 }

src/domain/Admin.java

@@ -1,25 +1,54 @@
-package domain;
+package domain;  // 定义在 domain 包下，表示该类是领域对象类，用于存储管理员信息。
 
+/**
+ * 管理员类，表示系统中的管理员信息。
+ * 包括管理员的工号和密码。
+ */
 public class Admin {
-    private String a_id;
-    private String a_password;
+    private String a_id;  // 管理员工号
+    private String a_password;  // 管理员密码
 
+    /**
+     * 获取管理员工号。
+     * 
+     * @return 返回管理员的工号
+     */
     public String getA_id() {
         return a_id;
     }
 
+    /**
+     * 设置管理员工号。
+     * 
+     * @param a_id 管理员的工号
+     */
     public void setA_id(String a_id) {
         this.a_id = a_id;
     }
 
+    /**
+     * 获取管理员密码。
+     * 
+     * @return 返回管理员的密码
+     */
     public String getA_password() {
         return a_password;
     }
 
+    /**
+     * 设置管理员密码。
+     * 
+     * @param a_password 管理员的密码
+     */
     public void setA_password(String a_password) {
         this.a_password = a_password;
     }
 
+    /**
+     * 重写 toString 方法，返回管理员信息的字符串表示。
+     * 
+     * @return 返回管理员信息的字符串
+     */
     @Override
     public String toString() {
         return "Admin{" +
@@ -28,3 +57,4 @@ public class Admin {
                 '}';
     }
 }
+

src/domain/CDC.java

@@ -1,35 +1,74 @@
-package domain;
+package domain;  // 定义在 domain 包下，表示该类是领域对象类，用于存储学院、系、班级等信息。
 
+/**
+ * CDC类，表示学院、系、班级信息。
+ * 该类用于表示和操作学院、系及班级的相关信息。
+ */
 public class CDC {
 
-    private String college;
-    private String department;
-    private String cclass;
+    private String college;  // 学院名称
+    private String department;  // 系名称
+    private String cclass;  // 班级名称
 
+    /**
+     * 获取学院名称。
+     * 
+     * @return 返回学院名称
+     */
     public String getCollege() {
         return college;
     }
 
+    /**
+     * 设置学院名称。
+     * 
+     * @param college 学院名称
+     */
     public void setCollege(String college) {
         this.college = college;
     }
 
+    /**
+     * 获取系名称。
+     * 
+     * @return 返回系名称
+     */
     public String getDepartment() {
         return department;
     }
 
+    /**
+     * 设置系名称。
+     * 
+     * @param department 系名称
+     */
     public void setDepartment(String department) {
         this.department = department;
     }
 
+    /**
+     * 获取班级名称。
+     * 
+     * @return 返回班级名称
+     */
     public String getCclass() {
         return cclass;
     }
 
+    /**
+     * 设置班级名称。
+     * 
+     * @param cclass 班级名称
+     */
     public void setCclass(String cclass) {
         this.cclass = cclass;
     }
 
+    /**
+     * 重写 toString 方法，返回学院、系、班级信息的字符串表示。
+     * 
+     * @return 返回一个包含学院、系、班级信息的字符串
+     */
     @Override
     public String toString() {
         return "CDC{" +

src/domain/Complaint.java

@@ -1,34 +1,74 @@
-package domain;
+package domain;  // 定义在 domain 包下，表示该类是领域对象类，用于存储投诉信息。
 
+/**
+ * Complaint类，表示投诉信息。
+ * 该类用于存储和处理用户或学生的投诉数据，包括投诉ID、投诉日期和投诉内容。
+ */
 public class Complaint {
-    private String id;
-    private String cdate;
-    private String content;
 
+    private String id;  // 投诉ID
+    private String cdate;  // 投诉日期
+    private String content;  // 投诉内容
+
+    /**
+     * 获取投诉ID。
+     * 
+     * @return 返回投诉的ID
+     */
     public String getId() {
         return id;
     }
 
+    /**
+     * 设置投诉ID。
+     * 
+     * @param id 投诉ID
+     */
     public void setId(String id) {
         this.id = id;
     }
 
+    /**
+     * 获取投诉日期。
+     * 
+     * @return 返回投诉日期
+     */
     public String getCdate() {
         return cdate;
     }
 
+    /**
+     * 设置投诉日期。
+     * 
+     * @param cdate 投诉日期
+     */
     public void setCdate(String cdate) {
         this.cdate = cdate;
     }
 
+    /**
+     * 获取投诉内容。
+     * 
+     * @return 返回投诉的详细内容
+     */
     public String getContent() {
         return content;
     }
 
+    /**
+     * 设置投诉内容。
+     * 
+     * @param content 投诉内容
+     */
     public void setContent(String content) {
         this.content = content;
     }
 
+    /**
+     * 重写 toString 方法，返回投诉ID、投诉日期、投诉内容的字符串表示。
+     * 
+     * @return 返回一个包含投诉ID、投诉日期、投诉内容信息的字符串
+     */
     @Override
     public String toString() {
         return "Complaint{" +

src/domain/Course.java

@@ -1,60 +1,80 @@
-package domain;
+package domain;  // 定义在 domain 包下，表示该类是领域对象类，用于存储投诉信息。
 
-public class Course {
-    private String c_id;
-    private String c_name;
-    private String c_info;
-    private String t_id;
-    private String t_name;
+/**
+ * Complaint类，表示投诉信息。
+ * 该类用于存储和处理用户或学生的投诉数据，包括投诉ID、投诉日期和投诉内容。
+ */
+public class Complaint {
 
-    public String getC_id() {
-        return c_id;
-    }
-
-    public void setC_id(String c_id) {
-        this.c_id = c_id;
-    }
-
-    public String getC_name() {
-        return c_name;
-    }
-
-    public void setC_name(String c_name) {
-        this.c_name = c_name;
-    }
+    private String id;  // 投诉ID
+    private String cdate;  // 投诉日期
+    private String content;  // 投诉内容
 
-    public String getC_info() {
-        return c_info;
+    /**
+     * 获取投诉ID。
+     * 
+     * @return 返回投诉的ID
+     */
+    public String getId() {
+        return id;
     }
 
-    public void setC_info(String c_info) {
-        this.c_info = c_info;
+    /**
+     * 设置投诉ID。
+     * 
+     * @param id 投诉ID
+     */
+    public void setId(String id) {
+        this.id = id;
     }
 
-    public String getT_id() {
-        return t_id;
+    /**
+     * 获取投诉日期。
+     * 
+     * @return 返回投诉日期
+     */
+    public String getCdate() {
+        return cdate;
     }
 
-    public void setT_id(String t_id) {
-        this.t_id = t_id;
+    /**
+     * 设置投诉日期。
+     * 
+     * @param cdate 投诉日期
+     */
+    public void setCdate(String cdate) {
+        this.cdate = cdate;
     }
 
-    public String getT_name() {
-        return t_name;
+    /**
+     * 获取投诉内容。
+     * 
+     * @return 返回投诉的详细内容
+     */
+    public String getContent() {
+        return content;
     }
 
-    public void setT_name(String t_name) {
-        this.t_name = t_name;
+    /**
+     * 设置投诉内容。
+     * 
+     * @param content 投诉内容
+     */
+    public void setContent(String content) {
+        this.content = content;
     }
 
-@Override
+    /**
+     * 重写 toString 方法，返回投诉ID、投诉日期、投诉内容的字符串表示。
+     * 
+     * @return 返回一个包含投诉ID、投诉日期、投诉内容信息的字符串
+     */
+    @Override
     public String toString() {
-        return "Course{" +
-                "c_id='" + c_id + '\'' +
-                ", c_name='" + c_name + '\'' +
-                ", c_info='" + c_info + '\'' +
-                ", t_id='" + t_id + '\'' +
-                ", t_name='" + t_name + '\'' +
+        return "Complaint{" +
+                "id='" + id + '\'' +
+                ", cdate='" + cdate + '\'' +
+                ", content='" + content + '\'' +
                 '}';
     }
 }

src/domain/FileClass.java

@@ -1,34 +1,74 @@
-package domain;
+package domain;  // 定义在 domain 包下，表示该类是领域对象类，用于存储文件信息。
 
+/**
+ * FileClass类，表示文件信息。
+ * 该类用于存储文件的名称、路径和大小等基本信息，常用于文件管理或上传功能中。
+ */
 public class FileClass {
-    private String fileName;
-    private String filePath;
-    private String fileSize;
 
+    private String fileName;  // 文件名
+    private String filePath;  // 文件路径
+    private String fileSize;  // 文件大小
+
+    /**
+     * 获取文件名。
+     * 
+     * @return 返回文件的名称
+     */
     public String getFileName() {
         return fileName;
     }
 
+    /**
+     * 设置文件名。
+     * 
+     * @param fileName 文件名
+     */
     public void setFileName(String fileName) {
         this.fileName = fileName;
     }
 
+    /**
+     * 获取文件路径。
+     * 
+     * @return 返回文件的路径
+     */
     public String getFilePath() {
         return filePath;
     }
 
+    /**
+     * 设置文件路径。
+     * 
+     * @param filePath 文件路径
+     */
     public void setFilePath(String filePath) {
         this.filePath = filePath;
     }
 
+    /**
+     * 获取文件大小。
+     * 
+     * @return 返回文件的大小
+     */
     public String getFileSize() {
         return fileSize;
     }
 
+    /**
+     * 设置文件大小。
+     * 
+     * @param fileSize 文件大小
+     */
     public void setFileSize(String fileSize) {
         this.fileSize = fileSize;
     }
 
+    /**
+     * 重写 toString 方法，返回文件名、路径和大小的字符串表示。
+     * 
+     * @return 返回包含文件名、文件路径和文件大小信息的字符串
+     */
     @Override
     public String toString() {
         return "FileClass{" +

src/domain/Notify.java

@@ -1,35 +1,74 @@
-package domain;
+package domain;  // 定义在 domain 包下，表示该类是领域对象类，用于存储通知信息。
 
+/**
+ * Notify类，表示通知信息。
+ * 该类用于存储系统或管理员发送的通知信息，包括通知ID、通知内容和通知日期。
+ */
 public class Notify {
 
-    private String id;
-    private String notifyInfo;
-    private String notifyDate;
+    private String id;  // 通知ID
+    private String notifyInfo;  // 通知内容
+    private String notifyDate;  // 通知日期
 
+    /**
+     * 获取通知ID。
+     * 
+     * @return 返回通知的ID
+     */
     public String getId() {
         return id;
     }
 
+    /**
+     * 设置通知ID。
+     * 
+     * @param id 通知ID
+     */
     public void setId(String id) {
         this.id = id;
     }
 
+    /**
+     * 获取通知内容。
+     * 
+     * @return 返回通知的详细内容
+     */
     public String getNotifyInfo() {
         return notifyInfo;
     }
 
+    /**
+     * 设置通知内容。
+     * 
+     * @param notifyInfo 通知内容
+     */
     public void setNotifyInfo(String notifyInfo) {
         this.notifyInfo = notifyInfo;
     }
 
+    /**
+     * 获取通知日期。
+     * 
+     * @return 返回通知日期
+     */
     public String getNotifyDate() {
         return notifyDate;
     }
 
+    /**
+     * 设置通知日期。
+     * 
+     * @param notifyDate 通知日期
+     */
     public void setNotifyDate(String notifyDate) {
         this.notifyDate = notifyDate;
     }
 
+    /**
+     * 重写 toString 方法，返回通知ID、通知内容和通知日期的字符串表示。
+     * 
+     * @return 返回一个包含通知ID、通知内容、通知日期信息的字符串
+     */
     @Override
     public String toString() {
         return "Notify{" +

src/domain/PageBean.java

@@ -1,57 +1,115 @@
-package domain;
+package domain;  // 定义在 domain 包下，表示该类是领域对象类，用于存储分页信息。
 
 import java.util.List;
 
 /**
- * 分页对象
+ * PageBean类，表示分页信息。
+ * 该类用于分页查询的结果封装，存储每页的记录数据、总记录数、总页数等分页信息。
+ * 泛型 T 表示分页数据项的类型。
  */
 public class PageBean<T> {
-    private int totalCount; //总记录数
-    private int totalPage;  //总页码
-    private List<T> list;  //每页数据
-    private int currentPage;    //当前页码
-    private int rows;   //每页显示的记录数
+    
+    private int totalCount; // 总记录数
+    private int totalPage;  // 总页码数
+    private List<T> list;   // 当前页的数据
+    private int currentPage;    // 当前页码
+    private int rows;   // 每页显示的记录数
 
+    /**
+     * 获取总记录数。
+     * 
+     * @return 返回总记录数
+     */
     public int getTotalCount() {
         return totalCount;
     }
 
+    /**
+     * 设置总记录数。
+     * 
+     * @param totalCount 总记录数
+     */
     public void setTotalCount(int totalCount) {
         this.totalCount = totalCount;
     }
 
+    /**
+     * 获取总页数。
+     * 
+     * @return 返回总页数
+     */
     public int getTotalPage() {
         return totalPage;
     }
 
+    /**
+     * 设置总页数。
+     * 
+     * @param totalPage 总页数
+     */
     public void setTotalPage(int totalPage) {
         this.totalPage = totalPage;
     }
 
+    /**
+     * 获取当前页的数据列表。
+     * 
+     * @return 返回当前页的数据列表
+     */
     public List<T> getList() {
         return list;
     }
 
+    /**
+     * 设置当前页的数据列表。
+     * 
+     * @param list 当前页的数据列表
+     */
     public void setList(List<T> list) {
         this.list = list;
     }
 
+    /**
+     * 获取当前页码。
+     * 
+     * @return 返回当前页码
+     */
     public int getCurrentPage() {
         return currentPage;
     }
 
+    /**
+     * 设置当前页码。
+     * 
+     * @param currentPage 当前页码
+     */
     public void setCurrentPage(int currentPage) {
         this.currentPage = currentPage;
     }
 
+    /**
+     * 获取每页显示的记录数。
+     * 
+     * @return 返回每页显示的记录数
+     */
     public int getRows() {
         return rows;
     }
 
+    /**
+     * 设置每页显示的记录数。
+     * 
+     * @param rows 每页显示的记录数
+     */
     public void setRows(int rows) {
         this.rows = rows;
     }
 
+    /**
+     * 重写 toString 方法，返回分页对象的字符串表示。
+     * 
+     * @return 返回分页信息的字符串
+     */
     @Override
     public String toString() {
         return "PageBean{" +

src/domain/Photo.java

@@ -1,22 +1,46 @@
-package domain;
+package domain;  // 定义在 domain 包下，表示该类是领域对象类，用于存储照片信息。
 
+/**
+ * Photo类，表示照片信息。
+ * 该类用于存储和处理照片的基本数据，包括照片ID和照片名称。
+ */
 public class Photo {
 
-    private String photoId;
-    private String photoName;
+    private String photoId;  // 照片ID
+    private String photoName;  // 照片名称
 
+    /**
+     * 获取照片ID。
+     * 
+     * @return 返回照片的ID
+     */
     public String getPhotoId() {
         return photoId;
     }
 
+    /**
+     * 设置照片ID。
+     * 
+     * @param photoId 照片ID
+     */
     public void setPhotoId(String photoId) {
         this.photoId = photoId;
     }
 
+    /**
+     * 获取照片名称。
+     * 
+     * @return 返回照片的名称
+     */
     public String getPhotoName() {
         return photoName;
     }
 
+    /**
+     * 设置照片名称。
+     * 
+     * @param photoName 照片名称
+     */
     public void setPhotoName(String photoName) {
         this.photoName = photoName;
     }

src/domain/SelectCourse.java

@@ -1,79 +1,169 @@
-package domain;
+package domain;  // 定义在 domain 包下，表示该类是领域对象类，用于存储学生选课信息。
 
+/**
+ * SelectCourse类，表示学生的选课信息。
+ * 该类用于存储和处理学生选修课程的数据，包括学生ID、课程ID、教师信息及成绩等。
+ */
 public class SelectCourse {
-    private String s_id;
-    private String s_name;
-    private String c_id;
-    private String c_name;
-    private String c_info;
-    private String t_id;
-    private String t_name;
-    private String score;
 
+    private String s_id;  // 学生ID
+    private String s_name;  // 学生姓名
+    private String c_id;  // 课程ID
+    private String c_name;  // 课程名称
+    private String c_info;  // 课程信息
+    private String t_id;  // 教师ID
+    private String t_name;  // 教师姓名
+    private String score;  // 学生的课程成绩
+
+    /**
+     * 获取学生ID。
+     * 
+     * @return 返回学生的ID
+     */
     public String getS_id() {
         return s_id;
     }
 
+    /**
+     * 设置学生ID。
+     * 
+     * @param s_id 学生ID
+     */
     public void setS_id(String s_id) {
         this.s_id = s_id;
     }
 
+    /**
+     * 获取学生姓名。
+     * 
+     * @return 返回学生的姓名
+     */
     public String getS_name() {
         return s_name;
     }
 
+    /**
+     * 设置学生姓名。
+     * 
+     * @param s_name 学生姓名
+     */
     public void setS_name(String s_name) {
         this.s_name = s_name;
     }
 
+    /**
+     * 获取课程ID。
+     * 
+     * @return 返回课程的ID
+     */
     public String getC_id() {
         return c_id;
     }
 
+    /**
+     * 设置课程ID。
+     * 
+     * @param c_id 课程ID
+     */
     public void setC_id(String c_id) {
         this.c_id = c_id;
     }
 
+    /**
+     * 获取课程名称。
+     * 
+     * @return 返回课程的名称
+     */
     public String getC_name() {
         return c_name;
     }
 
+    /**
+     * 设置课程名称。
+     * 
+     * @param c_name 课程名称
+     */
     public void setC_name(String c_name) {
         this.c_name = c_name;
     }
 
+    /**
+     * 获取课程信息。
+     * 
+     * @return 返回课程的详细信息
+     */
     public String getC_info() {
         return c_info;
     }
 
+    /**
+     * 设置课程信息。
+     * 
+     * @param c_info 课程信息
+     */
     public void setC_info(String c_info) {
         this.c_info = c_info;
     }
 
+    /**
+     * 获取教师ID。
+     * 
+     * @return 返回教师的ID
+     */
     public String getT_id() {
         return t_id;
     }
 
+    /**
+     * 设置教师ID。
+     * 
+     * @param t_id 教师ID
+     */
     public void setT_id(String t_id) {
         this.t_id = t_id;
     }
 
+    /**
+     * 获取教师姓名。
+     * 
+     * @return 返回教师的姓名
+     */
     public String getT_name() {
         return t_name;
     }
 
+    /**
+     * 设置教师姓名。
+     * 
+     * @param t_name 教师姓名
+     */
     public void setT_name(String t_name) {
         this.t_name = t_name;
     }
 
+    /**
+     * 获取学生的课程成绩。
+     * 
+     * @return 返回学生的成绩
+     */
     public String getScore() {
         return score;
     }
 
+    /**
+     * 设置学生的课程成绩。
+     * 
+     * @param score 学生的成绩
+     */
     public void setScore(String score) {
         this.score = score;
     }
 
+    /**
+     * 重写 toString 方法，返回选课信息的字符串表示。
+     * 
+     * @return 返回一个包含学生ID、学生姓名、课程ID、课程名称、课程信息、教师ID、教师姓名和成绩的字符串
+     */
     @Override
     public String toString() {
         return "SelectCourse{" +

src/domain/Student.java

@@ -1,106 +1,226 @@
-package domain;
+package domain;  // 定义在 domain 包下，表示该类是领域对象类，用于存储学生的个人信息。
 
+/**
+ * Student类，表示学生的个人信息。
+ * 该类用于存储学生的基本信息，包括学生ID、姓名、性别、年龄、联系方式等。
+ */
 public class Student {
-    private String s_id;
-    private String s_college;
-    private String s_department;
-    private String s_class;
-    private String s_name;
-    private String s_sex;
-    private String s_age;
-    private String s_address;
-    private String s_phone;
-    private String s_email;
-    private String s_password;
 
+    private String s_id;  // 学生ID
+    private String s_college;  // 学院名称
+    private String s_department;  // 学院下的系别
+    private String s_class;  // 所属班级
+    private String s_name;  // 学生姓名
+    private String s_sex;  // 学生性别
+    private String s_age;  // 学生年龄
+    private String s_address;  // 学生住址
+    private String s_phone;  // 学生联系电话
+    private String s_email;  // 学生电子邮件
+    private String s_password;  // 学生登录密码
+
+    /**
+     * 获取学生ID。
+     * 
+     * @return 返回学生的ID
+     */
     public String getS_id() {
         return s_id;
     }
 
+    /**
+     * 设置学生ID。
+     * 
+     * @param s_id 学生ID
+     */
     public void setS_id(String s_id) {
         this.s_id = s_id;
     }
 
+    /**
+     * 获取学生所属学院。
+     * 
+     * @return 返回学生的学院名称
+     */
     public String getS_college() {
         return s_college;
     }
 
+    /**
+     * 设置学生所属学院。
+     * 
+     * @param s_college 学生的学院名称
+     */
     public void setS_college(String s_college) {
         this.s_college = s_college;
     }
 
+    /**
+     * 获取学生所属系别。
+     * 
+     * @return 返回学生所属的系别
+     */
     public String getS_department() {
         return s_department;
     }
 
+    /**
+     * 设置学生所属系别。
+     * 
+     * @param s_department 学生的系别
+     */
     public void setS_department(String s_department) {
         this.s_department = s_department;
     }
 
+    /**
+     * 获取学生所属班级。
+     * 
+     * @return 返回学生所属的班级
+     */
     public String getS_class() {
         return s_class;
     }
 
+    /**
+     * 设置学生所属班级。
+     * 
+     * @param s_class 学生的班级
+     */
     public void setS_class(String s_class) {
         this.s_class = s_class;
     }
 
+    /**
+     * 获取学生姓名。
+     * 
+     * @return 返回学生的姓名
+     */
     public String getS_name() {
         return s_name;
     }
 
+    /**
+     * 设置学生姓名。
+     * 
+     * @param s_name 学生姓名
+     */
     public void setS_name(String s_name) {
         this.s_name = s_name;
     }
 
+    /**
+     * 获取学生性别。
+     * 
+     * @return 返回学生的性别
+     */
     public String getS_sex() {
         return s_sex;
     }
 
+    /**
+     * 设置学生性别。
+     * 
+     * @param s_sex 学生性别
+     */
     public void setS_sex(String s_sex) {
         this.s_sex = s_sex;
     }
 
+    /**
+     * 获取学生年龄。
+     * 
+     * @return 返回学生的年龄
+     */
     public String getS_age() {
         return s_age;
     }
 
+    /**
+     * 设置学生年龄。
+     * 
+     * @param s_age 学生的年龄
+     */
     public void setS_age(String s_age) {
         this.s_age = s_age;
     }
 
+    /**
+     * 获取学生地址。
+     * 
+     * @return 返回学生的住址
+     */
     public String getS_address() {
         return s_address;
     }
 
+    /**
+     * 设置学生地址。
+     * 
+     * @param s_address 学生的住址
+     */
     public void setS_address(String s_address) {
         this.s_address = s_address;
     }
 
+    /**
+     * 获取学生联系电话。
+     * 
+     * @return 返回学生的联系电话
+     */
     public String getS_phone() {
         return s_phone;
     }
 
+    /**
+     * 设置学生联系电话。
+     * 
+     * @param s_phone 学生的联系电话
+     */
     public void setS_phone(String s_phone) {
         this.s_phone = s_phone;
     }
 
+    /**
+     * 获取学生电子邮件。
+     * 
+     * @return 返回学生的电子邮件地址
+     */
     public String getS_email() {
         return s_email;
     }
 
+    /**
+     * 设置学生电子邮件。
+     * 
+     * @param s_email 学生的电子邮件地址
+     */
     public void setS_email(String s_email) {
         this.s_email = s_email;
     }
 
+    /**
+     * 获取学生登录密码。
+     * 
+     * @return 返回学生的登录密码
+     */
     public String getS_password() {
         return s_password;
     }
 
+    /**
+     * 设置学生登录密码。
+     * 
+     * @param s_password 学生的登录密码
+     */
     public void setS_password(String s_password) {
         this.s_password = s_password;
     }
 
+    /**
+     * 重写 toString 方法，返回学生信息的字符串表示。
+     * 
+     * @return 返回一个包含学生ID、学院、系别、班级、姓名、性别、年龄、地址、电话、电子邮件和密码的字符串
+     */
     @Override
     public String toString() {
         return "Student{" +

src/domain/Teacher.java

@@ -1,61 +1,131 @@
-package domain;
+package domain;  // 定义在 domain 包下，表示该类是领域对象类，用于存储教师的个人信息。
 
+/**
+ * Teacher类，表示教师的个人信息。
+ * 该类用于存储教师的基本信息，包括教师ID、姓名、性别、教育背景、职称和登录密码。
+ */
 public class Teacher {
-    private String t_id;
-    private String t_name;
-    private String t_sex;
-    private String t_education;
-    private String t_title;
-    private String t_password;
 
+    private String t_id;  // 教师ID
+    private String t_name;  // 教师姓名
+    private String t_sex;  // 教师性别
+    private String t_education;  // 教师教育背景
+    private String t_title;  // 教师职称
+    private String t_password;  // 教师登录密码
+
+    /**
+     * 获取教师ID。
+     * 
+     * @return 返回教师的ID
+     */
     public String getT_id() {
         return t_id;
     }
 
+    /**
+     * 设置教师ID。
+     * 
+     * @param t_id 教师ID
+     */
     public void setT_id(String t_id) {
         this.t_id = t_id;
     }
 
+    /**
+     * 获取教师姓名。
+     * 
+     * @return 返回教师的姓名
+     */
     public String getT_name() {
         return t_name;
     }
 
+    /**
+     * 设置教师姓名。
+     * 
+     * @param t_name 教师姓名
+     */
     public void setT_name(String t_name) {
         this.t_name = t_name;
     }
 
+    /**
+     * 获取教师性别。
+     * 
+     * @return 返回教师的性别
+     */
     public String getT_sex() {
         return t_sex;
     }
 
+    /**
+     * 设置教师性别。
+     * 
+     * @param t_sex 教师性别
+     */
     public void setT_sex(String t_sex) {
         this.t_sex = t_sex;
     }
 
+    /**
+     * 获取教师教育背景。
+     * 
+     * @return 返回教师的教育背景
+     */
     public String getT_education() {
         return t_education;
     }
 
+    /**
+     * 设置教师教育背景。
+     * 
+     * @param t_education 教师教育背景
+     */
     public void setT_education(String t_education) {
         this.t_education = t_education;
     }
 
+    /**
+     * 获取教师职称。
+     * 
+     * @return 返回教师的职称
+     */
     public String getT_title() {
         return t_title;
     }
 
+    /**
+     * 设置教师职称。
+     * 
+     * @param t_title 教师职称
+     */
     public void setT_title(String t_title) {
         this.t_title = t_title;
     }
 
+    /**
+     * 获取教师登录密码。
+     * 
+     * @return 返回教师的登录密码
+     */
     public String getT_password() {
         return t_password;
     }
 
+    /**
+     * 设置教师登录密码。
+     * 
+     * @param t_password 教师的登录密码
+     */
     public void setT_password(String t_password) {
         this.t_password = t_password;
     }
 
+    /**
+     * 重写 toString 方法，返回教师信息的字符串表示。
+     * 
+     * @return 返回一个包含教师ID、姓名、性别、教育背景、职称和密码的字符串
+     */
     @Override
     public String toString() {
         return "Teacher{" +

src/service/AdminService.java

@@ -1,18 +1,43 @@
-package service;
+以下是添加注释后的代码：
 
+```java
+package service;
 
 import domain.Admin;
 
 /**
- * 管理员的业务接口
+ * 管理员的业务接口，定义了与管理员相关的业务操作方法，供具体的服务实现类去实现这些方法，以完成相应的业务逻辑。
  */
 public interface AdminService {
     /**
-     * 管理员登录
+     * 管理员登录方法。
+     * 接收一个表示管理员信息的Admin对象作为参数，用于验证管理员登录的合法性，
+     * 如果登录验证通过，则返回对应的Admin对象（通常包含登录成功后的相关信息等），若验证失败可能返回null或者抛出相应异常（具体取决于实现类的设计）。
+     *
+     * @param admin 包含管理员登录相关信息（如用户名、密码等）的Admin对象
+     * @return 登录成功的Admin对象，如果登录失败则返回情况依具体实现而定
      */
     Admin login(Admin admin);
 
+    /**
+     * 更新管理员密码的方法。
+     * 通过传入管理员的唯一标识（adminid）以及新密码（newpassword）来更新对应的管理员账户密码。
+     * 具体的更新操作细节（如数据库更新等）由实现该接口的类去完成。
+     *
+     * @param adminid    管理员的唯一标识，用于定位到具体要更新密码的管理员账户
+     * @param newpassword 要设置的新密码字符串
+     */
     void updatePassword(String adminid, String newpassword);
 
+    /**
+     * 根据管理员对象中的相关标识（比如ID等信息，具体取决于Admin类的定义）查找对应的管理员信息。
+     * 返回查找到的Admin对象，如果未找到可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param admin 包含用于查找管理员的相关标识信息的Admin对象
+     * @return 查找到的Admin对象，如果查找失败则返回情况依具体实现而定
+     */
     Admin findAdminById(Admin admin);
 }
+```
+
+注释对接口的整体作用以及每个方法的功能、参数含义、返回值情况等进行了详细的说明，有助于后续代码的阅读和维护，以及其他开发人员理解该接口的用途和使用方式。 

src/service/CDCService.java

@@ -1,20 +1,47 @@
 package service;
 
-
 import domain.Admin;
 import domain.CDC;
-
 import java.util.List;
 
 /**
- * 学院专业班级的业务接口
+ * 学院专业班级的业务接口，用于定义与学院、专业、班级相关业务操作的抽象方法，
+ * 具体的业务逻辑将由实现该接口的类来完成，通过该接口可以统一操作规范，方便进行不同实现的替换等操作。
  */
 public interface CDCService {
+    /**
+     * 查询所有学院信息的方法。
+     * 返回一个包含所有学院信息的CDC对象列表，列表中每个CDC对象代表一个学院，
+     * 如果没有查询到学院信息，则返回一个空列表。
+     *
+     * @return 包含所有学院信息的CDC对象列表
+     */
     List<CDC> findAllCollege();
 
+    /**
+     * 查询所有专业信息的方法。
+     * 返回一个包含所有专业信息的CDC对象列表，列表中每个CDC对象代表一个专业，
+     * 若未查询到专业信息则返回空列表，具体的专业信息获取逻辑由实现该接口的类负责。
+     *
+     * @return 包含所有专业信息的CDC对象列表
+     */
     List<CDC> findAllDepartment();
 
+    /**
+     * 查询所有班级信息的方法。
+     * 会返回一个装有所有班级信息的CDC对象列表，每个CDC对象对应一个班级，
+     * 当不存在班级信息时返回空列表，具体的班级信息查询实现由接口实现类来确定。
+     *
+     * @return 包含所有班级信息的CDC对象列表
+     */
     List<CDC> findAllClass();
 
+    /**
+     * 查询所有学院、专业、班级相关信息的方法。
+     * 返回一个综合了所有学院、专业、班级信息的CDC对象列表，
+     * 如果没有任何相关信息则返回空列表，具体如何整合以及查询这些信息取决于实现该接口的类。
+     *
+     * @return 包含所有学院、专业、班级信息的CDC对象列表
+     */
     List<CDC> findAll();
 }

src/service/ComplaintService.java

@@ -1,14 +1,28 @@
 package service;
 
 import domain.Complaint;
-
 import java.util.List;
 
 /**
- * 小吐槽的业务接口
+ * 小吐槽的业务接口，主要用于定义与用户吐槽相关业务操作的抽象方法，
+ * 具体的业务逻辑将由实现该接口的类去完成，方便在不同场景下按照统一规范来处理吐槽相关事务。
  */
 public interface ComplaintService {
+    /**
+     * 查询所有吐槽信息的方法。
+     * 该方法会返回一个包含所有吐槽信息的Complaint对象列表，
+     * 如果当前没有任何吐槽记录，那么将会返回一个空列表。
+     *
+     * @return 包含所有吐槽信息的Complaint对象列表
+     */
     List<Complaint> findAll();
 
+    /**
+     * 添加吐槽信息的方法。
+     * 接收一个Complaint对象作为参数，这个对象包含了用户提交的吐槽相关内容，
+     * 具体的添加操作（比如将吐槽信息保存到数据库等）由实现该接口的类来负责完成。
+     *
+     * @param complaint 包含吐槽相关内容的Complaint对象
+     */
     void addComplaint(Complaint complaint);
-}
+}

src/service/CourseService.java

@@ -2,10 +2,36 @@ package service;
 
 import domain.Course;
 
+/**
+ * 课程相关业务的接口，定义了针对课程进行操作的一些抽象方法，
+ * 具体的业务逻辑实现将由实现该接口的类来完成，以此来规范课程相关业务操作的流程。
+ */
 public interface CourseService {
+    /**
+     * 添加选修课程的方法。
+     * 接收一个Course对象作为参数，该Course对象包含了选修课程的相关信息（如课程名称、授课教师、学分等），
+     * 由具体实现该接口的类来负责将该选修课程信息添加到相应的存储介质（比如数据库等）中，完成选修课程的添加操作。
+     *
+     * @param course 包含选修课程相关信息的Course对象
+     */
     void addOptionalCourse(Course course);
 
+    /**
+     * 根据课程编号查找已选课程的方法。
+     * 通过传入课程的唯一标识符（课程编号cid），在已选课程相关的数据存储（例如数据库中已选课程记录等）中查找对应的课程信息，
+     * 如果找到，则返回对应的Course对象（该对象包含课程详细信息），若未找到则可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param cid 课程的唯一编号，用于定位要查找的已选课程
+     * @return 查找到的已选课程对应的Course对象，如果未找到则返回情况依具体实现而定
+     */
     Course findSelectCourseByCourseId(String cid);
 
+    /**
+     * 根据课程编号删除课程相关服务记录的方法。
+     * 传入课程的唯一编号（cid），由实现该接口的类来负责从相应的存储（比如数据库中课程服务相关记录等）中删除该编号对应的课程相关记录，
+     * 具体的删除逻辑及涉及的相关操作（如关联数据的处理等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param cid 课程的唯一编号，用于定位要删除的课程相关记录
+     */
     void deleteServiceById(String cid);
-}
+}

src/service/NotifyService.java

@@ -1,23 +1,47 @@
 package service;
 
 import domain.Notify;
-
 import java.util.List;
 
 /**
- * 公告的业务接口
+ * 公告的业务接口，用于定义与公告相关业务操作的抽象方法，
+ * 为具体实现公告的发布、查询、删除等业务逻辑提供统一的规范，方便后续不同的实现类遵循此规范来操作公告相关事务。
  */
 public interface NotifyService {
     /**
-     * 公告发布
+     * 公告发布方法。
+     * 接收一个Notify对象作为参数，该对象包含了要发布公告的详细内容（如公告标题、正文、发布时间等信息），
+     * 由具体实现该接口的类负责将此公告信息添加到相应的存储介质（比如数据库等）中，完成公告的发布操作。
+     *
+     * @param notify 包含公告详细内容的Notify对象
      */
     void addNotify(Notify notify);
 
+    /**
+     * 查询公告的方法。
+     * 此方法用于获取符合特定条件的公告信息，具体的查询条件及逻辑由实现该接口的类去定义，
+     * 返回一个包含满足条件的公告信息的Notify对象列表，若没有符合条件的公告则返回空列表。
+     *
+     * @return 包含满足条件的公告信息的Notify对象列表
+     */
     List<Notify> find();
 
+    /**
+     * 查询所有公告信息的方法。
+     * 会返回一个包含所有已发布公告的Notify对象列表，不管是否有筛选条件等情况，
+     * 如果当前没有任何已发布的公告，则返回一个空列表。
+     *
+     * @return 包含所有已发布公告的Notify对象列表
+     */
     List<Notify> findAll();
 
+    /**
+     * 根据公告编号删除公告的方法。
+     * 传入公告的唯一编号（notifyid），由实现该接口的类负责从相应的存储（比如数据库中公告记录等）中删除该编号对应的公告信息，
+     * 具体的删除逻辑及涉及的相关操作（如关联数据的处理等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param notifyid 公告的唯一编号，用于定位要删除的公告
+     */
     void deleteNotifyById(String notifyid);
-
-
+}
 }

src/service/PhotoService.java

@@ -2,10 +2,36 @@ package service;
 
 import domain.Photo;
 
+/**
+ * 照片相关业务的接口，定义了针对照片进行操作的一些抽象方法，
+ * 其具体业务逻辑将由实现该接口的类来完成，通过该接口可以规范照片相关业务操作流程，方便在不同应用场景下进行拓展和维护。
+ */
 public interface PhotoService {
+    /**
+     * 添加照片的方法。
+     * 接收一个Photo对象作为参数，该Photo对象包含了要添加照片的相关信息，比如照片本身的数据、照片名称、拍摄时间等（具体取决于Photo类的定义），
+     * 由具体实现该接口的类负责将此照片信息保存到相应的存储位置（例如数据库、文件系统等）中，完成照片的添加操作。
+     *
+     * @param photo 包含照片相关信息的Photo对象
+     */
     void addPhoto(Photo photo);
 
+    /**
+     * 根据照片编号查找照片的方法。
+     * 通过传入照片的唯一标识符（照片编号id），在存储照片信息的地方（如数据库的照片表等）查找对应的照片，
+     * 如果找到，则返回对应的Photo对象（该对象包含照片的详细信息），若没找到则可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param id 照片的唯一编号，用于定位要查找的照片
+     * @return 查找到的照片对应的Photo对象，如果未找到则返回情况依具体实现而定
+     */
     Photo findPhotoByPhotoId(String id);
 
+    /**
+     * 更新照片信息的方法。
+     * 接收一个Photo对象作为参数，该对象包含了更新后的照片相关信息，例如对照片进行了重新命名、修改了拍摄时间等（具体视业务需求而定），
+     * 由具体实现该接口的类根据传入的Photo对象来更新相应存储位置（如数据库中对应记录等）里照片的信息，完成照片信息的更新操作。
+     *
+     * @param photo 包含更新后照片相关信息的Photo对象
+     */
     void updatePhoto(Photo photo);
-}
+}

src/service/SelectCourseService.java

@@ -1,13 +1,44 @@
 package service;
 
 import domain.SelectCourse;
-
 import java.util.List;
 
+/**
+ * 选课相关业务的接口，定义了针对学生选课情况以及课程成绩等相关操作的抽象方法，
+ * 具体的业务逻辑将由实现该接口的类来完成，为处理选课及成绩相关事务提供统一的规范和调用入口。
+ */
 public interface SelectCourseService {
+    /**
+     * 根据课程编号查找学生已选该课程情况的方法。
+     * 通过传入课程的唯一标识符（课程编号cid），从相关存储（例如数据库中选课记录等）里查询出选修了该课程的所有学生的选课信息，
+     * 并以SelectCourse对象列表的形式返回，列表中的每个SelectCourse对象代表一名学生关于该课程的选课相关信息（如选课时间、是否退选等情况），
+     * 如果没有学生选修该课程，则返回一个空列表。
+     *
+     * @param cid 课程的唯一编号，用于定位要查找学生选课情况的课程
+     * @return 包含选修该课程的学生选课信息的SelectCourse对象列表，若没有学生选修则返回空列表
+     */
     List<SelectCourse> findStudentSelectedCourseByCourseId(String cid);
 
-    SelectCourse findScoreByCourseIdAndStudentId(String cid,String sid);
+    /**
+     * 根据课程编号和学生编号查找学生该课程成绩的方法。
+     * 传入课程的唯一编号（cid）以及学生的唯一编号（sid），在存储成绩信息的相关数据结构（比如数据库成绩表等）中查找对应的学生在该课程上的成绩记录，
+     * 如果找到，则返回对应的SelectCourse对象（该对象包含成绩等相关选课信息），若未找到相应成绩记录则可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param cid 课程的唯一编号，用于定位要查找成绩的课程
+     * @param sid 学生的唯一编号，用于定位要查找成绩的学生
+     * @return 查找到的包含学生该课程成绩的SelectCourse对象，如果未找到则返回情况依具体实现而定
+     */
+    SelectCourse findScoreByCourseIdAndStudentId(String cid, String sid);
 
+    /**
+     * 根据课程编号和学生编号更新学生该课程成绩的方法。
+     * 接收课程的唯一编号（cid）、学生的唯一编号（sid）以及要更新的成绩（sScore）作为参数，
+     * 由实现该接口的类负责根据传入的参数在相应存储（如数据库中成绩记录等）里更新指定学生在指定课程上的成绩信息，
+     * 具体的更新逻辑及涉及的关联数据处理（比如成绩更新后的相关统计等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param cid 课程的唯一编号，用于定位要更新成绩的课程
+     * @param sid 学生的唯一编号，用于定位要更新成绩的学生
+     * @param sScore 要更新的学生该课程的成绩
+     */
     void upDateScoreByCidAndSid(String cid, String sid, String sScore);
-}
+}

src/service/StudentService.java

@@ -8,44 +8,146 @@ import java.util.List;
 import java.util.Map;
 
 /**
- * 学生管理的业务接口
+ * 学生管理的业务接口，定义了一系列与学生相关业务操作的抽象方法，
+ * 这些方法涵盖了学生信息查询、登录、注册、信息更新、选课操作以及学生相关数据删除等多方面内容，
+ * 具体的业务逻辑将由实现该接口的类来完成，方便对学生管理相关业务进行统一规范和拓展。
  */
 public interface StudentService {
     /**
-     * 分页条件查询
-     * @param currentPage
-     * @param rows
-     * @param condition
-     * @return
+     * 分页条件查询方法。
+     * 根据传入的当前页码（currentPage）、每页显示行数（rows）以及查询条件（condition，以Map形式存储，键为查询条件字段名，值为对应字段值的数组），
+     * 从数据源（如数据库等）中按照分页和给定条件筛选出相应的学生信息，返回一个PageBean对象，该对象中包含了符合条件的学生信息列表以及分页相关的元数据（如总页数、总记录数等）。
+     *
+     * @param currentPage 当前页码，用于确定要获取哪一页的数据
+     * @param rows 每页显示的行数，用于控制每页展示的学生信息数量
+     * @param condition 包含查询条件的Map对象，用于筛选出符合特定条件的学生信息
+     * @return 包含符合条件学生信息及分页相关元数据的PageBean<Student>对象
      */
     PageBean<Student> findStudentByPage(String currentPage, String rows, Map<String, String[]> condition);
 
     /**
-     * 查询所有学生信息
+     * 查询所有学生信息的方法。
+     * 该方法会从数据源（例如数据库中的学生表）中获取所有已存储的学生信息，
+     * 并以List<Student>列表形式返回，列表中的每个Student对象代表一名学生的详细信息，
+     * 如果没有学生信息记录，则返回一个空列表。
+     *
+     * @return 包含所有学生详细信息的List<Student>对象，若没有学生信息则返回空列表
      */
     List<Student> findAll();
 
+    /**
+     * 学生登录方法。
+     * 接收一个Student对象作为参数，该对象包含了学生登录时提供的相关信息（如学号、密码等），
+     * 通过具体实现该接口的类来验证这些登录信息是否正确，若验证通过则返回对应的Student对象（通常包含更多学生相关信息），
+     * 若验证失败可能返回null或者抛出相应异常（具体取决于实现类的设计）。
+     *
+     * @param student 包含学生登录相关信息的Student对象
+     * @return 登录成功的Student对象，如果登录失败则返回情况依具体实现而定
+     */
     Student login(Student student);
 
+    /**
+     * 根据学生对象中的相关标识（比如学号等信息，具体取决于Student类的定义）查找对应的学生信息的方法。
+     * 返回查找到的Student对象，如果未找到可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param student 包含用于查找学生的相关标识信息的Student对象
+     * @return 查找到的Student对象，如果查找失败则返回情况依具体实现而定
+     */
     Student findStudentById(Student student);
 
+    /**
+     * 学生注册方法。
+     * 接收一个Student对象作为参数，该对象包含了新学生注册时需要填写的各项信息（如姓名、学号、密码、个人资料等），
+     * 由实现该接口的类负责将这些学生信息保存到相应的存储介质（比如数据库中的学生表）中，完成学生注册操作。
+     *
+     * @param student 包含新学生注册相关信息的Student对象
+     */
     void register(Student student);
 
+    /**
+     * 更新学生信息的方法。
+     * 接收一个Student对象作为参数，该对象包含了更新后的学生个人信息（如修改后的姓名、联系方式等），
+     * 具体实现该接口的类会根据传入的Student对象来更新相应存储位置（如数据库中对应学生记录）里的学生信息，完成信息更新操作。
+     *
+     * @param student 包含更新后学生相关信息的Student对象
+     */
     void updateInfo(Student student);
 
+    /**
+     * 更新学生密码的方法。
+     * 通过传入学生的唯一标识（studentid，如学号等）以及新密码（newpassword）来更新对应的学生账户密码。
+     * 具体的更新操作细节（如数据库更新等）由实现该接口的类去完成。
+     *
+     * @param studentid 学生的唯一标识，用于定位到具体要更新密码的学生账户
+     * @param newpassword 要设置的新密码字符串
+     */
     void updatePassword(String studentid, String newpassword);
 
+    /**
+     * 根据学生编号查找该学生所有已选课程信息的方法。
+     * 传入学生的唯一编号（studentid），从相关存储（例如数据库中选课记录等）里查询出该学生已选修的所有课程信息，
+     * 并以List<SelectCourse>列表形式返回，列表中的每个SelectCourse对象代表一门该学生已选课程的相关信息（如课程名称、成绩等情况），
+     * 如果该学生没有选修任何课程，则返回一个空列表。
+     *
+     * @param studentid 学生的唯一编号，用于定位要查找选课信息的学生
+     * @return 包含该学生所有已选课程信息的List<SelectCourse>对象，若该学生未选课则返回空列表
+     */
     List<SelectCourse> findAllSelectCourse(String studentid);
 
+    /**
+     * 查询所有可选课程信息的方法。
+     * 会从相关存储（比如数据库中的课程表）中获取所有可供学生选择的课程信息，
+     * 并以List<Course>列表形式返回，列表中的每个Course对象代表一门可选课程的详细信息（如课程名称、授课教师、学分等），
+     * 如果没有可选课程信息，则返回一个空列表。
+     *
+     * @return 包含所有可选课程详细信息的List<Course>对象，若没有可选课程则返回空列表
+     */
     List<Course> findAllOptionalCourse();
 
+    /**
+     * 学生添加选课的方法。
+     * 接收学生的唯一编号（studentid）以及课程的唯一编号（courseid）作为参数，
+     * 由实现该接口的类负责将该学生选择该课程的相关记录保存到相应存储介质（比如数据库中的选课表）中，完成选课操作。
+     *
+     * @param studentid 学生的唯一编号，用于定位要选课的学生
+     * @param courseid 课程的唯一编号，用于定位要选的课程
+     */
     void addSelectCourse(String studentid, String courseid);
 
+    /**
+     * 根据学生编号删除学生信息的方法。
+     * 传入学生的唯一编号（studentid），由实现该接口的类负责从相应的存储（比如数据库中的学生记录等）中删除该编号对应的学生信息，
+     * 具体的删除逻辑及涉及的相关操作（如关联数据的处理等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param studentid 学生的唯一编号，用于定位要删除的学生信息
+     */
     void deleteStudentById(String studentid);
 
+    /**
+     * 根据学生编号数组批量删除学生选课信息的方法。
+     * 传入包含多个学生编号的数组（sids），由实现该接口的类负责从相应存储（如数据库中的选课记录等）中批量删除这些学生编号对应的选课信息，
+     * 具体的批量删除逻辑及涉及的相关操作（如数据一致性检查等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param sids 包含要删除选课信息的学生编号的数组
+     */
     void deleteSelectStudent(String[] sids);
 
+    /**
+     * 添加学生所有信息的方法，通常用于更新学生的全部信息场景（可能涉及多个表或复杂的数据结构更新）。
+     * 接收一个Student对象作为参数，该对象包含了要更新的学生全部相关信息，
+     * 由实现该接口的类按照业务需求和数据存储规则来更新相应存储位置里的学生所有信息，完成信息更新操作。
+     *
+     * @param updateStudent 包含更新后学生全部相关信息的Student对象
+     */
     void addStudentAllInfo(Student updateStudent);
 
+    /**
+     * 查询所有学生选课信息的方法。
+     * 会从相关存储（比如数据库中选课记录等）中获取所有学生的选课信息，
+     * 并以List<SelectCourse>列表形式返回，列表中的每个SelectCourse对象代表一名学生关于某门课程的选课相关信息（如课程名称、成绩等情况），
+     * 如果没有任何选课信息，则返回一个空列表。
+     *
+     * @return 包含所有学生选课信息的List<SelectCourse>对象，若没有选课信息则返回空列表
+     */
     List<SelectCourse> findSelectCourseAllStudent();
-}
+}

src/service/TeacherService.java

@@ -2,35 +2,107 @@ package service;
 
 import domain.Course;
 import domain.Teacher;
-
 import java.util.List;
 
 /**
- * 教师管理的业务接口
+ * 教师管理的业务接口，定义了一系列与教师相关业务操作的抽象方法，
+ * 涵盖教师登录验证、教师信息查询、课程相关操作（如查找授课课程、更新课程信息、删除课程等）以及教师个人信息更新、密码修改等多方面功能，
+ * 具体的业务逻辑将由实现该接口的类来完成，以此规范教师管理相关业务流程，方便在不同应用场景下进行拓展与维护。
  */
 public interface TeacherService {
     /**
-     * 教师登录
+     * 教师登录方法。
+     * 接收一个Teacher对象作为参数，该对象包含了教师登录时提供的相关信息（如工号、密码等），
+     * 通过具体实现该接口的类来验证这些登录信息是否正确，若验证通过则返回对应的Teacher对象（通常包含更多教师相关信息），
+     * 若验证失败可能返回null或者抛出相应异常（具体取决于实现类的设计）。
+     *
+     * @param teacher 包含教师登录相关信息的Teacher对象
+     * @return 登录成功的Teacher对象，如果登录失败则返回情况依具体实现而定
      */
     Teacher login(Teacher teacher);
 
+    /**
+     * 查询所有教师信息的方法。
+     * 该方法会从数据源（例如数据库中的教师表）中获取所有已存储的教师信息，
+     * 并以List<Teacher>列表形式返回，列表中的每个Teacher对象代表一名教师的详细信息，
+     * 如果没有教师信息记录，则返回一个空列表。
+     *
+     * @return 包含所有教师详细信息的List<Teacher>对象，若没有教师信息则返回空列表
+     */
     List<Teacher> findAll();
 
+    /**
+     * 根据教师编号查找该教师所授的所有可选课程信息的方法。
+     * 传入教师的唯一编号（T_id），从相关存储（例如数据库中课程与教师关联表等）里查询出该教师可以授课的所有可选课程信息，
+     * 并以List<Course>列表形式返回，列表中的每个Course对象代表一门该教师可授的可选课程的详细信息（如课程名称、学分、授课时间等情况），
+     * 如果该教师没有可授的可选课程，则返回一个空列表。
+     *
+     * @param T_id 教师的唯一编号，用于定位要查找可选课程信息的教师
+     * @return 包含该教师所授所有可选课程信息的List<Course>对象，若该教师无可选课程则返回空列表
+     */
     List<Course> findMySelfOptionalCourse(String T_id);
 
+    /**
+     * 根据课程编号查找对应的可选课程信息的方法。
+     * 通过传入课程的唯一标识符（课程编号cid），在存储课程信息的地方（如数据库的课程表等）查找对应的可选课程，
+     * 如果找到，则返回对应的Course对象（该对象包含课程的详细信息），若没找到则可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param cid 课程的唯一编号，用于定位要查找的可选课程
+     * @return 查找到的可选课程对应的Course对象，如果未找到则返回情况依具体实现而定
+     */
     Course findOptionalCourseByCourseId(String cid);
 
+    /**
+     * 更新课程信息的方法。
+     * 接收一个Course对象作为参数，该对象包含了更新后的课程相关信息（如修改后的课程名称、授课时间、学分等），
+     * 具体实现该接口的类会根据传入的Course对象来更新相应存储位置（如数据库中对应课程记录）里的课程信息，完成课程信息更新操作。
+     *
+     * @param updateCourse 包含更新后课程相关信息的Course对象
+     */
     void updateCourseInfo(Course updateCourse);
 
-    void deleteCourseById(String cid);
-
+    /**
+     * 根据课程编号删除课程信息的方法。
+     * 传入课程的唯一编号（cid），由实现该接口的类负责从相应的存储（比如数据库中的课程记录等）中删除该编号对应的课程信息，
+     * 具体的删除逻辑及涉及的相关操作（如关联数据的处理等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param cid 课程的唯一编号，用于定位要删除的课程信息
+     */
     void updatePassword(String teacherid, String newpassword);
 
+    /**
+     * 根据教师对象中的相关标识（比如工号等信息，具体取决于Teacher类的定义）查找对应的教师信息的方法。
+     * 返回查找到的Teacher对象，如果未找到可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param teacher 包含用于查找教师的相关标识信息的Teacher对象
+     * @return 查找到的Teacher对象，如果查找失败则返回情况依具体实现而定
+     */
     Teacher findTeacherById(Teacher teacher);
 
+    /**
+     * 添加教师所有信息的方法，通常用于更新教师的全部信息场景（可能涉及多个表或复杂的数据结构更新）。
+     * 接收一个Teacher对象作为参数，该对象包含了要更新的教师全部相关信息，
+     * 由实现该接口的类按照业务需求和数据存储规则来更新相应存储位置里的教师所有信息，完成信息更新操作。
+     *
+     * @param updateTeacher 包含更新后教师全部相关信息的Teacher对象
+     */
     void addTeacherAllInfo(Teacher updateTeacher);
 
+    /**
+     * 根据教师编号删除教师信息的方法。
+     * 传入教师的唯一编号（teacherid），由实现该接口的类负责从相应的存储（比如数据库中的教师记录等）中删除该编号对应的教师信息，
+     * 具体的删除逻辑及涉及的相关操作（如关联数据的处理等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param teacherid 教师的唯一编号，用于定位要删除的教师信息
+     */
     void deleteTeacherById(String teacherid);
 
+    /**
+     * 更新教师个人信息的方法。
+     * 接收一个Teacher对象作为参数，该对象包含了更新后的教师个人信息（如修改后的姓名、联系方式等），
+     * 具体实现该接口的类会根据传入的Teacher对象来更新相应存储位置（如数据库中对应教师记录）里的教师信息，完成信息更新操作。
+     *
+     * @param updateTeacher 包含更新后教师个人信息的Teacher对象
+     */
     void updateInfo(Teacher updateTeacher);
 }

src/service/impl/AdminServiceImpl.java

@@ -1,25 +1,48 @@
 package service.impl;
 
-import dao.AdminDao;
-import dao.impl.AdminDaoImpl;
-import domain.Admin;
-import service.AdminService;
+import dao.AdminDao;  // 导入 AdminDao 接口，用于操作管理员相关的数据。
+import dao.impl.AdminDaoImpl;  // 导入 AdminDaoImpl 类，实际的管理员数据访问实现。
+import domain.Admin;  // 导入 Admin 类，表示管理员实体。
+import service.AdminService;  // 导入 AdminService 接口，定义管理员服务层的业务逻辑。
 
+/**
+ * AdminServiceImpl 类，负责实现管理员相关的业务逻辑。
+ * 该类调用 AdminDao 实现与数据库的交互，为管理员提供登录、密码更新等操作。
+ */
 public class AdminServiceImpl implements AdminService {
-    private AdminDao dao = new AdminDaoImpl();
 
+    private AdminDao dao = new AdminDaoImpl();  // 实例化 AdminDaoImpl 对象，操作管理员数据。
+
+    /**
+     * 实现管理员登录功能。
+     * 
+     * @param admin 传入管理员对象，包含管理员ID和密码。
+     * @return 返回管理员对象，如果登录成功，则返回对应的管理员信息，否则返回null。
+     */
     @Override
     public Admin login(Admin admin) {
-        return dao.findAdminidAndPassword(admin.getA_id(),admin.getA_password());
+        return dao.findAdminidAndPassword(admin.getA_id(), admin.getA_password());
     }
 
+    /**
+     * 更新管理员密码。
+     * 
+     * @param adminid 管理员ID。
+     * @param newpassword 新密码。
+     */
     @Override
     public void updatePassword(String adminid, String newpassword) {
-        dao.updatePassword(adminid,newpassword);
+        dao.updatePassword(adminid, newpassword);  // 调用 Dao 层方法更新密码。
     }
 
+    /**
+     * 根据管理员ID查找管理员信息。
+     * 
+     * @param admin 管理员对象，包含要查询的管理员ID。
+     * @return 返回对应的管理员信息，如果没有找到则返回 null。
+     */
     @Override
     public Admin findAdminById(Admin admin) {
-        return dao.findAdminById(admin.getA_id());
+        return dao.findAdminById(admin.getA_id());  // 调用 Dao 层方法根据管理员ID查询信息。
     }
 }

src/service/impl/CDCServiceImpl.java

@@ -1,32 +1,57 @@
 package service.impl;
 
-import dao.CDCDao;
-import dao.impl.CDCDaoImpl;
-import domain.CDC;
-import service.CDCService;
+import dao.CDCDao;  // 导入 CDCDao 接口，操作与 CDC（学院、部门、班级）相关的数据。
+import dao.impl.CDCDaoImpl;  // 导入 CDCDaoImpl 类，实际的 CDC 数据访问实现。
+import domain.CDC;  // 导入 CDC 类，表示学院、部门、班级等信息的实体。
+import service.CDCService;  // 导入 CDCService 接口，定义 CDC 服务层的业务逻辑。
 
-import java.util.List;
+import java.util.List;  // 导入 List 类，作为返回的数据类型，用于返回多个结果。
 
+/**
+ * CDCServiceImpl 类，负责实现与学院、部门和班级相关的业务逻辑。
+ * 该类调用 CDCDao 实现与数据库的交互，为客户端提供学院、部门、班级数据查询服务。
+ */
 public class CDCServiceImpl implements CDCService {
-    private CDCDao dao = new CDCDaoImpl();
 
+    private CDCDao dao = new CDCDaoImpl();  // 实例化 CDCDaoImpl 对象，用于操作 CDC 数据。
+
+    /**
+     * 获取所有学院信息。
+     * 
+     * @return 返回包含所有学院信息的 List。
+     */
     @Override
     public List<CDC> findAllCollege() {
-        return dao.findAllCollege();
+        return dao.findAllCollege();  // 调用 DAO 层方法获取所有学院数据。
     }
 
+    /**
+     * 获取所有部门信息。
+     * 
+     * @return 返回包含所有部门信息的 List。
+     */
     @Override
     public List<CDC> findAllDepartment() {
-        return dao.findAllDepartment();
+        return dao.findAllDepartment();  // 调用 DAO 层方法获取所有部门数据。
     }
 
+    /**
+     * 获取所有班级信息。
+     * 
+     * @return 返回包含所有班级信息的 List。
+     */
     @Override
     public List<CDC> findAllClass() {
-        return dao.findAllClass();
+        return dao.findAllClass();  // 调用 DAO 层方法获取所有班级数据。
     }
 
+    /**
+     * 获取所有学院、部门、班级的信息。
+     * 
+     * @return 返回包含所有学院、部门、班级信息的 List。
+     */
     @Override
     public List<CDC> findAll() {
-        return dao.findAll();
+        return dao.findAll();  // 调用 DAO 层方法获取所有学院、部门和班级数据。
     }
 }

src/service/impl/ComplaintServiceImpl.java

@@ -1,22 +1,37 @@
 package service.impl;
 
-import dao.ComplaintDao;
-import dao.impl.ComplaintDaoImpl;
-import domain.Complaint;
-import service.ComplaintService;
+import dao.ComplaintDao;  // 导入 ComplaintDao 接口，操作与投诉相关的数据。
+import dao.impl.ComplaintDaoImpl;  // 导入 ComplaintDaoImpl 类，实际的 Complaint 数据访问实现。
+import domain.Complaint;  // 导入 Complaint 类，表示投诉信息的实体类。
+import service.ComplaintService;  // 导入 ComplaintService 接口，定义投诉服务层的业务逻辑。
 
-import java.util.List;
+import java.util.List;  // 导入 List 类，作为返回的数据类型，用于返回多个结果。
 
+/**
+ * ComplaintServiceImpl 类，负责实现与投诉信息相关的业务逻辑。
+ * 该类调用 ComplaintDao 实现与数据库的交互，为客户端提供投诉数据的查询和添加服务。
+ */
 public class ComplaintServiceImpl implements ComplaintService {
-    private ComplaintDao dao = new ComplaintDaoImpl();
 
+    private ComplaintDao dao = new ComplaintDaoImpl();  // 实例化 ComplaintDaoImpl 对象，用于操作投诉数据。
+
+    /**
+     * 获取所有投诉信息。
+     * 
+     * @return 返回所有投诉信息的 List。
+     */
     @Override
     public List<Complaint> findAll() {
-        return dao.findAllComplaint();
+        return dao.findAllComplaint();  // 调用 DAO 层方法获取所有投诉数据。
     }
 
+    /**
+     * 添加投诉信息。
+     * 
+     * @param complaint 需要添加的投诉信息。
+     */
     @Override
     public void addComplaint(Complaint complaint) {
-        dao.addComplaint(complaint);
+        dao.addComplaint(complaint);  // 调用 DAO 层方法将投诉数据添加到数据库。
     }
 }

src/service/impl/CourseServiceImpl.java

@@ -1,24 +1,46 @@
 package service.impl;
 
-import dao.CourseDao;
-import dao.impl.CourseDaoImpl;
-import domain.Course;
-import service.CourseService;
+import dao.CourseDao;  // 导入 CourseDao 接口，操作与课程相关的数据。
+import dao.impl.CourseDaoImpl;  // 导入 CourseDaoImpl 类，实际的 Course 数据访问实现。
+import domain.Course;  // 导入 Course 类，表示课程信息的实体类。
+import service.CourseService;  // 导入 CourseService 接口，定义课程服务层的业务逻辑。
 
+/**
+ * CourseServiceImpl 类，实现了 CourseService 接口，负责处理与课程信息相关的业务逻辑。
+ * 该类通过调用 CourseDao 实现与数据库的交互，提供添加课程、查询课程及删除课程的服务。
+ */
 public class CourseServiceImpl implements CourseService {
-    private CourseDao dao = new CourseDaoImpl();
+
+    private CourseDao dao = new CourseDaoImpl();  // 实例化 CourseDaoImpl 对象，用于操作课程数据。
+
+    /**
+     * 添加一门选修课。
+     * 
+     * @param course 要添加的课程信息。
+     */
     @Override
     public void addOptionalCourse(Course course) {
-        dao.addOptionalCourse(course);
+        dao.addOptionalCourse(course);  // 调用 DAO 层方法将课程信息添加到数据库。
     }
 
+    /**
+     * 根据课程 ID 查询已选课程信息。
+     * 
+     * @param cid 课程 ID。
+     * @return 返回对应课程的 Course 对象。
+     */
     @Override
     public Course findSelectCourseByCourseId(String cid) {
-        return dao.findSelectCourseByCourseId(cid);
+        return dao.findSelectCourseByCourseId(cid);  // 调用 DAO 层方法根据课程 ID 查询已选课程。
     }
 
+    /**
+     * 删除选修课程信息。
+     * 
+     * @param cid 课程 ID。
+     */
     @Override
     public void deleteServiceById(String cid) {
-        dao.deleteServiceById(cid);
+        dao.deleteServiceById(cid);  // 调用 DAO 层方法删除课程信息。
     }
 }

src/service/impl/NotifyServiceImpl.java

@@ -1,32 +1,57 @@
 package service.impl;
 
-import dao.NotifyDao;
-import dao.impl.NotifyDaoImpl;
-import domain.Notify;
-import service.NotifyService;
+import dao.NotifyDao;  // 导入 NotifyDao 接口，操作通知相关的数据。
+import dao.impl.NotifyDaoImpl;  // 导入 NotifyDaoImpl 类，实际的 Notify 数据访问实现。
+import domain.Notify;  // 导入 Notify 类，表示通知信息的实体类。
+import service.NotifyService;  // 导入 NotifyService 接口，定义通知服务层的业务逻辑。
 
 import java.util.List;
 
+/**
+ * NotifyServiceImpl 类，实现了 NotifyService 接口，负责处理与通知信息相关的业务逻辑。
+ * 该类通过调用 NotifyDao 实现与数据库的交互，提供添加通知、查询通知、删除通知等服务。
+ */
 public class NotifyServiceImpl implements NotifyService {
-    private NotifyDao dao = new NotifyDaoImpl();
 
+    private NotifyDao dao = new NotifyDaoImpl();  // 实例化 NotifyDaoImpl 对象，用于操作通知数据。
+
+    /**
+     * 添加通知。
+     * 
+     * @param notify 要添加的通知信息。
+     */
     @Override
     public void addNotify(Notify notify) {
-        dao.add(notify);
+        dao.add(notify);  // 调用 DAO 层方法将通知信息添加到数据库。
     }
 
+    /**
+     * 查询通知信息。
+     * 
+     * @return 返回通知信息的列表。
+     */
     @Override
     public List<Notify> find() {
-        return dao.findNotify();
+        return dao.findNotify();  // 调用 DAO 层方法查询通知信息。
     }
 
+    /**
+     * 查询所有通知信息。
+     * 
+     * @return 返回所有通知信息的列表。
+     */
     @Override
     public List<Notify> findAll() {
-        return dao.findAllNotify();
+        return dao.findAllNotify();  // 调用 DAO 层方法查询所有通知信息。
     }
 
+    /**
+     * 根据通知 ID 删除通知。
+     * 
+     * @param notifyid 通知 ID。
+     */
     @Override
     public void deleteNotifyById(String notifyid) {
-        dao.deleteNotifyById(notifyid);
+        dao.deleteNotifyById(notifyid);  // 调用 DAO 层方法删除指定通知 ID 的通知。
     }
 }

src/service/impl/PhotoServiceImpl.java

@@ -1,25 +1,46 @@
 package service.impl;
 
-import dao.PhotoDao;
-import dao.impl.PhotoDaoImpl;
-import domain.Photo;
-import service.PhotoService;
+import dao.PhotoDao;  // 导入 PhotoDao 接口，操作与照片相关的数据。
+import dao.impl.PhotoDaoImpl;  // 导入 PhotoDaoImpl 类，实际的 Photo 数据访问实现。
+import domain.Photo;  // 导入 Photo 类，表示照片信息的实体类。
+import service.PhotoService;  // 导入 PhotoService 接口，定义照片服务层的业务逻辑。
 
+/**
+ * PhotoServiceImpl 类，实现了 PhotoService 接口，负责处理与照片信息相关的业务逻辑。
+ * 该类通过调用 PhotoDao 实现与数据库的交互，提供添加照片、查询照片、更新照片等服务。
+ */
 public class PhotoServiceImpl implements PhotoService {
-    private PhotoDao dao = new PhotoDaoImpl();
 
+    private PhotoDao dao = new PhotoDaoImpl();  // 实例化 PhotoDaoImpl 对象，用于操作照片数据。
+
+    /**
+     * 添加照片。
+     * 
+     * @param photo 要添加的照片信息。
+     */
     @Override
     public void addPhoto(Photo photo) {
-        dao.addPhoto(photo);
+        dao.addPhoto(photo);  // 调用 DAO 层方法将照片信息添加到数据库。
     }
 
+    /**
+     * 根据照片 ID 查找照片。
+     * 
+     * @param id 照片 ID。
+     * @return 返回指定 ID 的照片信息。
+     */
     @Override
     public Photo findPhotoByPhotoId(String id) {
-        return dao.findPhotoByPhotoId(id);
+        return dao.findPhotoByPhotoId(id);  // 调用 DAO 层方法查询指定 ID 的照片。
     }
 
+    /**
+     * 更新照片信息。
+     * 
+     * @param photo 要更新的照片信息。
+     */
     @Override
     public void updatePhoto(Photo photo) {
-        dao.updatePhoto(photo);
+        dao.updatePhoto(photo);  // 调用 DAO 层方法更新照片信息。
     }
 }

src/service/impl/SelectCourseServiceImpl.java

@@ -1,27 +1,52 @@
 package service.impl;
 
-import dao.SelectCourseDao;
-import dao.impl.SelectCourseDaoImpl;
-import domain.SelectCourse;
-import service.SelectCourseService;
+import dao.SelectCourseDao;  // 导入 SelectCourseDao 接口，操作选课数据。
+import dao.impl.SelectCourseDaoImpl;  // 导入 SelectCourseDaoImpl 类，实际的选课数据访问实现。
+import domain.SelectCourse;  // 导入 SelectCourse 类，表示选课信息的实体类。
+import service.SelectCourseService;  // 导入 SelectCourseService 接口，定义选课服务层的业务逻辑。
 
 import java.util.List;
 
+/**
+ * SelectCourseServiceImpl 类，实现了 SelectCourseService 接口，负责处理与选课信息相关的业务逻辑。
+ * 该类通过调用 SelectCourseDao 实现与数据库的交互，提供查询学生选课、查询成绩、更新成绩等服务。
+ */
 public class SelectCourseServiceImpl implements SelectCourseService {
-    private SelectCourseDao dao = new SelectCourseDaoImpl();
 
+    private SelectCourseDao dao = new SelectCourseDaoImpl();  // 实例化 SelectCourseDaoImpl 对象，用于操作选课数据。
+
+    /**
+     * 根据课程 ID 查找选了该课程的学生列表。
+     * 
+     * @param cid 课程 ID。
+     * @return 返回选了该课程的所有学生信息列表。
+     */
     @Override
     public List<SelectCourse> findStudentSelectedCourseByCourseId(String cid) {
-        return dao.findStudentSelectedCourseByCourseId(cid);
+        return dao.findStudentSelectedCourseByCourseId(cid);  // 调用 DAO 层方法根据课程 ID 查找所有选课学生。
     }
 
+    /**
+     * 根据课程 ID 和学生 ID 查找学生的成绩信息。
+     * 
+     * @param cid 课程 ID。
+     * @param sid 学生 ID。
+     * @return 返回指定课程和学生的成绩信息。
+     */
     @Override
     public SelectCourse findScoreByCourseIdAndStudentId(String cid, String sid) {
-        return dao.findScoreByCourseIdAndStudentId(cid,sid);
+        return dao.findScoreByCourseIdAndStudentId(cid, sid);  // 调用 DAO 层方法查找指定课程和学生的成绩。
     }
 
+    /**
+     * 更新指定课程和学生的成绩。
+     * 
+     * @param cid 课程 ID。
+     * @param sid 学生 ID。
+     * @param sScore 新的成绩。
+     */
     @Override
     public void upDateScoreByCidAndSid(String cid, String sid, String sScore) {
-        dao.upDateScoreByCidAndSid(cid,sid,sScore);
+        dao.upDateScoreByCidAndSid(cid, sid, sScore);  // 调用 DAO 层方法更新指定学生和课程的成绩。
     }
 }

src/service/impl/StudentServiceImpl.java

@@ -1,114 +1,196 @@
 package service.impl;
 
-import dao.StudentDao;
-import dao.impl.StudentDaoImpl;
-import domain.Course;
-import domain.PageBean;
-import domain.SelectCourse;
-import domain.Student;
-import service.StudentService;
+import dao.StudentDao;  // 导入 StudentDao 接口，操作学生数据。
+import dao.impl.StudentDaoImpl;  // 导入 StudentDaoImpl 类，实际的学生数据访问实现。
+import domain.Course;  // 导入 Course 类，表示课程信息。
+import domain.PageBean;  // 导入 PageBean 类，表示分页对象。
+import domain.SelectCourse;  // 导入 SelectCourse 类，表示选课信息。
+import domain.Student;  // 导入 Student 类，表示学生信息。
+import service.StudentService;  // 导入 StudentService 接口，定义学生服务层的业务逻辑。
+
 import java.util.List;
 import java.util.Map;
 
+/**
+ * StudentServiceImpl 类实现了 StudentService 接口，负责学生相关业务逻辑的处理。
+ * 该类通过调用 StudentDao 实现与数据库的交互，提供了学生登录、注册、信息更新、分页查询等功能。
+ */
 public class StudentServiceImpl implements StudentService {
-    private StudentDao dao = new StudentDaoImpl();
 
+    private StudentDao dao = new StudentDaoImpl();  // 实例化 StudentDaoImpl 对象，用于操作学生数据。
+
+    /**
+     * 分页查询学生信息。
+     * 
+     * @param _currentPage 当前页码。
+     * @param _rows 每页显示的记录数。
+     * @param condition 查询条件，包含多个条件的 Map。
+     * @return 返回封装了学生信息的 PageBean 对象。
+     */
     @Override
     public PageBean<Student> findStudentByPage(String _currentPage, String _rows, Map<String, String[]> condition) {
-
+        // 转换当前页和每页记录数
         int currentPage = Integer.parseInt(_currentPage);
         int rows = Integer.parseInt(_rows);
 
-        //创建新的PageBean对象
+        // 创建新的 PageBean 对象
         PageBean<Student> pb = new PageBean<Student>();
 
-        //设置参数
+        // 设置分页参数
         pb.setCurrentPage(currentPage);
         pb.setRows(rows);
 
-        //调用dao查询总记录数
+        // 查询总记录数并设置到 PageBean
         int totalCount = dao.findTotalCount(condition);
         pb.setTotalCount(totalCount);
 
-        //调用dao查询List集合
-        //计算开始记录的索引
+        // 计算开始记录的索引
         int start = (currentPage - 1) * rows;
-        List<Student>list = dao.findByPage(start,rows,condition);
+        List<Student> list = dao.findByPage(start, rows, condition);  // 查询分页数据
         pb.setList(list);
 
-        //计算总页码
-        int totalPage = (totalCount % rows) == 0 ? totalCount/rows : (totalCount/rows) + 1;
+        // 计算总页码
+        int totalPage = (totalCount % rows) == 0 ? totalCount / rows : (totalCount / rows) + 1;
         pb.setTotalPage(totalPage);
         return pb;
     }
 
+    /**
+     * 查询所有学生信息。
+     * 
+     * @return 返回所有学生的列表。
+     */
     @Override
     public List<Student> findAll() {
-        return dao.findAll();
+        return dao.findAll();  // 调用 DAO 层的 findAll 方法获取所有学生信息
     }
 
+    /**
+     * 学生登录验证。
+     * 
+     * @param student 学生对象，包含学生 ID 和密码。
+     * @return 如果验证通过，返回学生信息；否则返回 null。
+     */
     @Override
     public Student login(Student student) {
-        return dao.findStudentidAndPassword(student.getS_id(),student.getS_password());
+        return dao.findStudentidAndPassword(student.getS_id(), student.getS_password());  // 调用 DAO 层方法进行登录验证
     }
 
+    /**
+     * 根据学生 ID 查询学生信息。
+     * 
+     * @param student 学生对象，包含学生 ID。
+     * @return 返回指定学生的详细信息。
+     */
     @Override
     public Student findStudentById(Student student) {
-        return dao.findStudentById(student.getS_id());
+        return dao.findStudentById(student.getS_id());  // 调用 DAO 层方法根据学生 ID 查询学生信息
     }
 
+    /**
+     * 学生注册。
+     * 
+     * @param student 学生对象，包含学生注册所需的所有信息。
+     */
     @Override
     public void register(Student student) {
-        dao.addStudent(student);
+        dao.addStudent(student);  // 调用 DAO 层方法注册学生
     }
 
+    /**
+     * 更新学生信息。
+     * 
+     * @param student 学生对象，包含更新后的信息。
+     */
     @Override
     public void updateInfo(Student student) {
-        dao.updateInfo(student);
+        dao.updateInfo(student);  // 调用 DAO 层方法更新学生信息
     }
 
+    /**
+     * 更新学生密码。
+     * 
+     * @param studentid 学生 ID。
+     * @param newpassword 新密码。
+     */
     @Override
     public void updatePassword(String studentid, String newpassword) {
-        dao.updatePassword(studentid,newpassword);
+        dao.updatePassword(studentid, newpassword);  // 调用 DAO 层方法更新学生密码
     }
 
+    /**
+     * 根据学生 ID 查询该学生选修的所有课程。
+     * 
+     * @param studentid 学生 ID。
+     * @return 返回该学生选修的所有课程信息。
+     */
     @Override
     public List<SelectCourse> findAllSelectCourse(String studentid) {
-        return dao.findAllSelectCourse(studentid);
+        return dao.findAllSelectCourse(studentid);  // 调用 DAO 层方法获取该学生的选课信息
     }
 
+    /**
+     * 查询所有可选课程。
+     * 
+     * @return 返回所有可选课程的列表。
+     */
     @Override
     public List<Course> findAllOptionalCourse() {
-        return dao.findAllOptionalCourse();
+        return dao.findAllOptionalCourse();  // 调用 DAO 层方法获取所有可选课程信息
     }
 
+    /**
+     * 学生选课。
+     * 
+     * @param studentid 学生 ID。
+     * @param courseid 课程 ID。
+     */
     @Override
     public void addSelectCourse(String studentid, String courseid) {
-        dao.addSelectCourse(studentid,courseid);
+        dao.addSelectCourse(studentid, courseid);  // 调用 DAO 层方法进行选课
     }
 
+    /**
+     * 删除学生信息。
+     * 
+     * @param studentid 学生 ID。
+     */
     @Override
     public void deleteStudentById(String studentid) {
-        dao.deleteStudentById(studentid);
+        dao.deleteStudentById(studentid);  // 调用 DAO 层方法删除指定学生
     }
 
+    /**
+     * 批量删除学生信息。
+     * 
+     * @param sids 学生 ID 数组，包含多个学生 ID。
+     */
     @Override
     public void deleteSelectStudent(String[] sids) {
         if (sids != null && sids.length > 0) {
-            for (String sid: sids) {
-                dao.deleteStudentById(sid);
+            for (String sid : sids) {
+                dao.deleteStudentById(sid);  // 调用 DAO 层方法批量删除学生
             }
         }
-
     }
 
+    /**
+     * 添加学生的完整信息。
+     * 
+     * @param updateStudent 学生对象，包含完整的学生信息。
+     */
     @Override
     public void addStudentAllInfo(Student updateStudent) {
-        dao.addStudentAllInfo(updateStudent);
+        dao.addStudentAllInfo(updateStudent);  // 调用 DAO 层方法添加学生的完整信息
     }
 
+    /**
+     * 查询所有学生选课信息。
+     * 
+     * @return 返回所有学生的选课信息。
+     */
     @Override
     public List<SelectCourse> findSelectCourseAllStudent() {
-        return dao.findSelectCourseAllStudent();
+        return dao.findSelectCourseAllStudent();  // 调用 DAO 层方法获取所有学生的选课信息
     }
 }

src/service/impl/TeacherServiceImpl.java

@@ -1,68 +1,133 @@
 package service.impl;
 
-import dao.TeacherDao;
-import domain.Course;
-import domain.Teacher;
-import dao.impl.TeacherDaoImpl;
-import service.TeacherService;
+import dao.TeacherDao;  // 导入 TeacherDao 接口，处理教师数据访问。
+import domain.Course;  // 导入 Course 类，表示课程信息。
+import domain.Teacher;  // 导入 Teacher 类，表示教师信息。
+import dao.impl.TeacherDaoImpl;  // 导入 TeacherDaoImpl 类，实际的教师数据访问实现。
+import service.TeacherService;  // 导入 TeacherService 接口，定义教师服务层的业务逻辑。
 
 import java.util.List;
 
+/**
+ * TeacherServiceImpl 类实现了 TeacherService 接口，负责教师相关业务逻辑的处理。
+ * 该类通过调用 TeacherDao 实现与数据库的交互，提供了教师登录、信息更新、密码修改、课程管理等功能。
+ */
 public class TeacherServiceImpl implements TeacherService {
-    private TeacherDao dao = new TeacherDaoImpl();
 
+    private TeacherDao dao = new TeacherDaoImpl();  // 实例化 TeacherDaoImpl 对象，用于操作教师数据。
+
+    /**
+     * 教师登录验证。
+     * 
+     * @param teacher 教师对象，包含教师 ID 和密码。
+     * @return 如果验证通过，返回教师信息；否则返回 null。
+     */
     @Override
     public Teacher login(Teacher teacher) {
-        return dao.findTeacheridAndPassword(teacher.getT_id(),teacher.getT_password());
+        return dao.findTeacheridAndPassword(teacher.getT_id(), teacher.getT_password());  // 调用 DAO 层方法进行登录验证
     }
 
+    /**
+     * 查询所有教师信息。
+     * 
+     * @return 返回所有教师的列表。
+     */
     @Override
     public List<Teacher> findAll() {
-        return dao.findAll();
+        return dao.findAll();  // 调用 DAO 层的 findAll 方法获取所有教师信息
     }
 
+    /**
+     * 查询教师自己的可选课程。
+     * 
+     * @param T_id 教师 ID。
+     * @return 返回该教师教授的所有可选课程信息。
+     */
     @Override
     public List<Course> findMySelfOptionalCourse(String T_id) {
-        return dao.findMySelfOptionalCourse(T_id);
+        return dao.findMySelfOptionalCourse(T_id);  // 调用 DAO 层方法获取该教师的可选课程
     }
 
+    /**
+     * 根据课程 ID 查询可选课程信息。
+     * 
+     * @param cid 课程 ID。
+     * @return 返回指定课程的详细信息。
+     */
     @Override
     public Course findOptionalCourseByCourseId(String cid) {
-        return dao.findOptionalCourseByCourseId(cid);
+        return dao.findOptionalCourseByCourseId(cid);  // 调用 DAO 层方法根据课程 ID 查询课程信息
     }
 
+    /**
+     * 更新课程信息。
+     * 
+     * @param updateCourse 课程对象，包含更新后的课程信息。
+     */
     @Override
     public void updateCourseInfo(Course updateCourse) {
-        dao.updateCourseInfo(updateCourse);
+        dao.updateCourseInfo(updateCourse);  // 调用 DAO 层方法更新课程信息
     }
 
+    /**
+     * 删除课程信息。
+     * 
+     * @param cid 课程 ID。
+     */
     @Override
     public void deleteCourseById(String cid) {
-        dao.deleteCourseById(cid);
+        dao.deleteCourseById(cid);  // 调用 DAO 层方法删除指定课程
     }
 
+    /**
+     * 更新教师密码。
+     * 
+     * @param teacherid 教师 ID。
+     * @param newpassword 新密码。
+     */
     @Override
     public void updatePassword(String teacherid, String newpassword) {
-        dao.updatePassword(teacherid,newpassword);
+        dao.updatePassword(teacherid, newpassword);  // 调用 DAO 层方法更新教师密码
     }
 
+    /**
+     * 根据教师 ID 查询教师信息。
+     * 
+     * @param teacher 教师对象，包含教师 ID。
+     * @return 返回指定教师的详细信息。
+     */
     @Override
     public Teacher findTeacherById(Teacher teacher) {
-        return dao.findTeacherById(teacher.getT_id());
+        return dao.findTeacherById(teacher.getT_id());  // 调用 DAO 层方法根据教师 ID 查询教师信息
     }
 
+    /**
+     * 添加教师的完整信息。
+     * 
+     * @param updateTeacher 教师对象，包含完整的教师信息。
+     */
     @Override
     public void addTeacherAllInfo(Teacher updateTeacher) {
-        dao.addTeacherAllInfo(updateTeacher);
+        dao.addTeacherAllInfo(updateTeacher);  // 调用 DAO 层方法添加教师的完整信息
     }
 
+    /**
+     * 删除教师信息。
+     * 
+     * @param teacherid 教师 ID。
+     */
     @Override
     public void deleteTeacherById(String teacherid) {
-        dao.deleteTeacherById(teacherid);
+        dao.deleteTeacherById(teacherid);  // 调用 DAO 层方法删除指定教师
     }
 
+    /**
+     * 更新教师信息。
+     * 
+     * @param updateTeacher 教师对象，包含更新后的教师信息。
+     */
     @Override
     public void updateInfo(Teacher updateTeacher) {
-        dao.updateInfo(updateTeacher);
+        dao.updateInfo(updateTeacher);  // 调用 DAO 层方法更新教师信息
     }
 }

src/utils/JDBCUtils.java

@@ -1,7 +1,6 @@
 package utils;
 
 import com.alibaba.druid.pool.DruidDataSourceFactory;
-
 import javax.sql.DataSource;
 import java.sql.Connection;
 import java.sql.ResultSet;
@@ -10,17 +9,22 @@ import java.sql.Statement;
 import java.util.Properties;
 
 /**
- * Druid连接池工具类,将来dao层调用
+ * Druid连接池工具类，主要用于管理数据库连接相关操作，方便将来dao层调用，
+ * 通过该工具类可以获取数据库连接、释放相关资源（如关闭结果集、语句对象、连接等）以及获取连接池对象等，有助于更规范、高效地进行数据库交互操作。
  */
 public class JDBCUtils {
-    private static DataSource dataSource;   //定义成员变量DataSource
+    // 定义成员变量DataSource，用于存储通过Druid连接池工厂创建的数据源对象，后续通过该数据源获取数据库连接
+    private static DataSource dataSource;  
+
     static {
         try {
-            //加载配置文件
+            // 加载配置文件，此处通过类加载器获取类路径下名为"druid.properties"的配置文件，并将其加载到Properties对象中，
+            // 配置文件中通常包含了连接数据库所需的各种参数，如数据库驱动、连接地址、用户名、密码等信息。
             Properties properties = new Properties();
             properties.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
 
-            //获取DataSource
+            // 获取DataSource，利用Druid提供的DruidDataSourceFactory工厂类，根据加载的配置文件属性创建数据源对象，
+            // 如果创建过程出现异常（如配置文件格式错误、缺少关键配置项等），则会打印异常堆栈信息。
             dataSource = DruidDataSourceFactory.createDataSource(properties);
         } catch (Exception e) {
             e.printStackTrace();
@@ -28,21 +32,38 @@ public class JDBCUtils {
     }
 
     /**
-     * 获取连接
+     * 获取连接方法，用于从之前创建的数据源对象中获取一个数据库连接，
+     * 若获取过程出现SQLException异常（比如数据库连接数已满等情况），则会将该异常抛出，由调用者进行相应处理。
+     *
+     * @return 返回一个可用的数据库连接对象Connection
+     * @throws SQLException 当获取连接出现问题时抛出该异常
      */
     public static Connection getConnection() throws SQLException {
         return dataSource.getConnection();
     }
 
     /**
-     * 释放资源
+     * 释放资源方法（重载形式之一），主要用于关闭Statement和Connection对象，释放相关的数据库资源，
+     * 该方法内部会调用另一个重载的close方法，传入null作为ResultSet参数，以实现关闭Statement和Connection的操作。
+     *
+     * @param statement 要关闭的SQL语句执行对象，用于执行SQL语句操作，使用完后需要关闭释放资源
+     * @param connection 要关闭的数据库连接对象，使用完后需要归还到连接池中，避免资源浪费
      */
-    public static void close(Statement statement,Connection connection) {
-        close(null,statement,connection);
+    public static void close(Statement statement, Connection connection) {
+        close(null, statement, connection);
     }
 
+    /**
+     * 释放资源方法（重载形式之二），用于关闭ResultSet、Statement和Connection对象，全面释放数据库操作相关的资源，
+     * 会按照先关闭ResultSet（如果不为空），再关闭Statement，最后关闭Connection并归还到连接池的顺序进行操作，
+     * 如果在关闭过程中出现SQLException异常（比如资源已经被关闭等情况），则会打印异常堆栈信息。
+     *
+     * @param resultSet 要关闭的查询结果集对象，若执行了查询操作并获取到结果集，使用完后需关闭释放资源，可为null表示无结果集需要关闭
+     * @param statement 要关闭的SQL语句执行对象，同上述close方法中参数含义
+     * @param connection 要关闭的数据库连接对象，同上述close方法中参数含义
+     */
     public static void close(ResultSet resultSet, Statement statement, Connection connection) {
-        if (resultSet != null) {
+        if (resultSet!= null) {
             try {
                 resultSet.close();
             } catch (SQLException e) {
@@ -50,7 +71,7 @@ public class JDBCUtils {
             }
         }
 
-        if (statement != null) {
+        if (statement!= null) {
             try {
                 statement.close();
             } catch (SQLException e) {
@@ -58,19 +79,25 @@ public class JDBCUtils {
             }
         }
 
-        if (connection != null) {
+        if (connection!= null) {
             try {
-                connection.close();//归还连接
-            }catch (SQLException e) {
+                connection.close();// 归还连接，将使用完的数据库连接归还给连接池，以便后续其他操作可以继续复用该连接
+            } catch (SQLException e) {
                 e.printStackTrace();
             }
         }
     }
 
     /**
-     * 获取连接池方法
+     * 获取连接池方法，用于获取之前通过配置文件创建并存储的数据源对象，
+     * 返回该DataSource对象，外部可以通过该对象进一步获取连接或者进行其他与连接池相关的操作。
+     *
+     * @return 返回创建好的数据源对象DataSource
      */
     public static DataSource getDataSource() {
         return dataSource;
     }
 }
+//whdiwfb
+//
+///

src/web/servlet/admin/AddStudentInfoServlet.java

@@ -3,7 +3,6 @@ package web.servlet.admin;
 import domain.Student;
 import service.StudentService;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -12,20 +11,40 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.Date;
 
+/**
+ * AddStudentInfoServlet类，继承自HttpServlet，用于处理添加学生信息相关的请求，
+ * 通过接收前端传来的学生信息参数，判断学生是否已存在，若不存在则将新的学生信息添加到系统中，
+ * 并根据操作结果向前端返回相应提示信息，最终转发到相应页面。该Servlet被映射到"/addStudentInfoServlet"路径下，处理POST和GET请求。
+ */
 @WebServlet("/addStudentInfoServlet")
 public class AddStudentInfoServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，主要逻辑如下：
+     * 1. 设置请求编码为"utf-8"，确保能正确接收和处理包含中文等特殊字符的参数。
+     * 2. 创建StudentService的实现类对象，用于调用学生相关业务逻辑方法，比如查找学生信息、添加学生全部信息等操作。
+     * 3. 从请求参数中获取学生的编号（student-id），通过该编号构建一个Student对象，并调用服务层的方法查找该学生是否已存在于系统中。
+     * 4. 如果学生已存在，则在请求域中设置提示信息，告知前端“已存在该学生，请重新添加！”并附带当前时间，然后转发到“addStudentServlet”页面。
+     * 5. 如果学生不存在，则继续从请求参数中获取学生的其他详细信息（如姓名、性别、年龄、联系方式等），同时对部分可能为空的学院、专业、班级信息进行默认值设置（设置为“待分配”）。
+     * 6. 构建一个完整的Student对象，包含所有获取到的学生信息，然后调用服务层的方法将该学生的全部信息添加到系统中。
+     * 7. 在请求域中设置添加成功的提示信息，告知前端“添加成功！”并附带当前时间，最后转发到“addStudentServlet”页面。
+     *
+     * @param request  HttpServletRequest对象，用于获取前端传来的请求参数等信息
+     * @param response HttpServletResponse对象，用于向前端返回响应信息，如转发页面、设置响应状态码等
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应数据时出现输入输出相关异常，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
-        StudentService service= new StudentServiceImpl();
+        StudentService service = new StudentServiceImpl();
         //先进行判断是否已存在该学生
         String sid = request.getParameter("student-id");
         Student s = new Student();
         s.setS_id(sid);
         Student newStudent = service.findStudentById(s);
-        if (newStudent != null) {
-            request.setAttribute("update_msg","已存在该学生，请重新添加！"+String.format("%tT",new Date()));
+        if (newStudent!= null) {
+            request.setAttribute("update_msg", "已存在该学生，请重新添加！" + String.format("%tT", new Date()));
             request.getRequestDispatcher("addStudentServlet").forward(request, response);
-        }else {
+        } else {
             String name = request.getParameter("student-name");
             String sex = request.getParameter("student-sex");
             String age = request.getParameter("student-age");
@@ -59,13 +78,24 @@ public class AddStudentInfoServlet extends HttpServlet {
             updateStudent.setS_class(cclass);
 
             service.addStudentAllInfo(updateStudent);
-            request.setAttribute("update_msg","添加成功！"+String.format("%tT",new Date()));
+            request.setAttribute("update_msg", "添加成功！" + String.format("%tT", new Date()));
             request.getRequestDispatcher("addStudentServlet").forward(request, response);
 
         }
     }
 
+    /**
+     * 处理GET请求的方法，该方法直接调用doPost方法，使得该Servlet对于GET请求也按照与POST请求相同的逻辑进行处理，
+     * 这样可以简化代码结构，保证无论前端以POST还是GET方式发起请求，都能执行相同的业务逻辑来添加学生信息。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应数据时出现输入输出相关异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
 }
+//mmm
+//mmm

src/web/servlet/admin/AddStudentServlet.java

@@ -6,7 +6,6 @@ import service.CDCService;
 import service.StudentService;
 import service.impl.CDCServiceImpl;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -16,8 +15,28 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
 
+/**
+ * AddStudentServlet类，继承自HttpServlet，用于处理添加学生相关的请求操作，
+ * 主要功能是从业务层获取学院、专业、班级相关信息，并将这些信息存入到HttpSession中，
+ * 然后将请求转发到添加学生信息的JSP页面（/WEB-INF/admin/addStudent.jsp），方便在页面上展示相关下拉选项等内容以供用户填写学生信息。
+ * 该Servlet被映射到"/addStudentServlet"路径下，并且对GET请求和POST请求进行了统一处理，GET请求会调用与POST请求相同的处理逻辑。
+ */
 @WebServlet("/addStudentServlet")
 public class AddStudentServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确处理包含中文等特殊字符的请求参数，避免出现乱码问题。
+     * 2. 获取当前请求对应的HttpSession对象，HttpSession可用于在多个请求之间存储和共享数据，在这里主要用于传递学院、专业、班级信息到后续的JSP页面。
+     * 3. 创建CDCService的实现类对象（CDCServiceImpl），通过该对象调用相应的业务方法来获取学院、专业、班级相关信息。
+     * 4. 分别调用service2的findAllCollege()、findAllDepartment()、findAllClass()方法，获取所有学院信息列表、所有专业信息列表以及所有班级信息列表，这些列表中的元素通常是CDC类型的对象，包含了相应的名称等属性信息。
+     * 5. 将获取到的学院信息列表、专业信息列表、班级信息列表分别存入到HttpSession中，使用自定义的属性名（"collegeLists"、"departmentLists"、"classLists"）进行存储，以便后续在JSP页面中可以通过这些属性名获取并展示相应信息。
+     * 6. 最后将请求转发到"/WEB-INF/admin/addStudent.jsp"页面，这个页面通常是用于展示添加学生信息的表单界面，通过之前存入HttpSession中的信息可以在页面上为用户提供相应的下拉选择框等交互元素，方便填写学生所属的学院、专业、班级等信息。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的参数、属性等信息，比如请求中的参数值以及对应的HttpSession对象等
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，例如将请求转发到指定的JSP页面等操作，以向客户端返回相应的页面内容
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如配置错误、转发异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
@@ -27,14 +46,23 @@ public class AddStudentServlet extends HttpServlet {
         List<CDC> departmentList = service2.findAllDepartment();
         List<CDC> classList = service2.findAllClass();
 
-        session.setAttribute("collegeLists",collegeList);
-        session.setAttribute("departmentLists",departmentList);
-        session.setAttribute("classLists",classList);
+        session.setAttribute("collegeLists", collegeList);
+        session.setAttribute("departmentLists", departmentList);
+        session.setAttribute("classLists", classList);
 
-        request.getRequestDispatcher("/WEB-INF/admin/addStudent.jsp").forward(request,response);
+        request.getRequestDispatcher("/WEB-INF/admin/addStudent.jsp").forward(request, response);
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证将学院、专业、班级信息存入Session并转发到添加学生信息的JSP页面这一核心逻辑得以执行。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/admin/AdminPasswordIndexServlet.java

@@ -7,13 +7,40 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+/**
+ * AdminPasswordIndexServlet类，继承自HttpServlet，用于处理与管理员更新密码相关的请求操作。
+ * 其主要功能是将请求转发到用于管理员更新密码的JSP页面（/WEB-INF/admin/adminUpdatePassword.jsp），
+ * 并且对GET请求和POST请求进行了统一处理，GET请求会调用与POST请求相同的逻辑，即都执行转发到指定JSP页面的操作，
+ * 该Servlet被映射到"/adminPasswordIndexServlet"路径下，以便接收对应的请求并做出相应处理。
+ */
 @WebServlet("/adminPasswordIndexServlet")
 public class AdminPasswordIndexServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 使用request对象的getRequestDispatcher方法获取一个请求转发器，指定要转发的目标页面为"/WEB-INF/admin/adminUpdatePassword.jsp"，
+     * 这个JSP页面通常包含了供管理员输入旧密码、新密码等相关表单元素，用于更新管理员密码的操作界面。
+     * 然后通过转发器的forward方法将当前请求和响应对象传递过去，实现请求的转发，使得客户端浏览器能够展示该JSP页面内容，以便管理员进行后续的密码更新操作。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的信息，如请求的参数等，在此处主要用于获取请求转发器来进行页面转发操作
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，在转发操作中会将响应传递给目标JSP页面，使其能够正确向客户端返回页面内容
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，例如转发配置错误等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求信息失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.getRequestDispatcher("/WEB-INF/admin/adminUpdatePassword.jsp").forward(request,response);
+        request.getRequestDispatcher("/WEB-INF/admin/adminUpdatePassword.jsp").forward(request, response);
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证将请求转发到管理员更新密码的JSP页面这一操作得以执行，
+     * 方便管理员可以通过不同的请求方式进入到密码更新的操作界面。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/admin/AdminPasswordUpdateServlet.java

@@ -6,7 +6,6 @@ import service.AdminService;
 import service.StudentService;
 import service.impl.AdminServiceImpl;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -16,12 +15,39 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.Date;
 
+/**
+ * AdminPasswordUpdateServlet类，继承自HttpServlet，用于处理管理员更新密码的具体业务逻辑，
+ * 主要功能包括验证新密码格式及确认密码是否一致，若验证通过则调用服务层方法更新密码，同时更新会话中的管理员信息，
+ * 最后根据操作结果向前端页面返回相应提示信息，并转发到管理员更新密码的JSP页面（/WEB-INF/admin/adminUpdatePassword.jsp）。
+ * 该Servlet被映射到"/adminPasswordUpdateServlet"路径下，且对GET请求和POST请求进行统一处理，GET请求会复用POST请求的处理逻辑。
+ */
 @WebServlet("/adminPasswordUpdateServlet")
 public class AdminPasswordUpdateServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免出现乱码问题。
+     * 2. 获取当前请求对应的HttpSession对象，通过该对象可以获取之前存储在会话中的管理员信息，这里主要用于获取当前登录的管理员对象，以便后续关联更新其密码等操作。
+     * 3. 从会话中获取到管理员对象后，取出管理员的唯一标识（通常为管理员编号，如a_id），同时从请求参数中获取新密码（admin-newpassword）和确认密码（admin-ennewpassword）的值。
+     * 4. 定义一个正则表达式（regex）用于验证密码格式，要求密码必须是由3到12位的字母、数字或下划线组成（这里通过"^[\\w]{3,12}$"正则表达式来限定），
+     *    然后使用matches方法对新密码进行格式验证，如果新密码不符合该格式要求，就在请求域中设置提示信息告知前端“密码格式错误，重新提交！”并附带当前时间，
+     *    随后将请求转发到"/WEB-INF/admin/adminUpdatePassword.jsp"页面，让管理员重新输入密码。
+     * 5. 如果新密码格式验证通过，则进一步判断新密码和确认密码是否一致，如果不一致，就在请求域中设置提示信息“密码确认错误，请重新提交！”并附带当前时间，
+     *    同样将请求转发到更新密码的JSP页面，提醒管理员再次确认密码输入。
+     * 6. 当新密码格式正确且与确认密码一致时，创建AdminService的实现类对象（AdminServiceImpl），用于调用管理员相关的业务逻辑方法。
+     * 7. 通过服务层对象调用updatePassword方法，传入管理员编号和新密码，实现数据库中管理员密码的更新操作（具体的更新逻辑由服务层实现类内部完成）。
+     * 8. 接着再次调用服务层的findAdminById方法，根据更新后的管理员信息重新查找该管理员对象（可能是为了获取更新后完整的管理员信息，例如包含最新的修改时间等其他相关属性），
+     *    并将获取到的新管理员对象重新赋值给之前的管理员对象变量，然后将更新后的管理员对象重新存入HttpSession中，覆盖原来会话中的管理员信息，确保会话中的数据与数据库中的最新状态保持一致。
+     * 9. 最后在请求域中设置提示信息“修改成功！”并附带当前时间，再将请求转发到"/WEB-INF/admin/adminUpdatePassword.jsp"页面，告知管理员密码修改成功。
+     *
+     * @param request  HttpServletRequest对象，用于获取前端传来的请求参数、会话中的管理员对象等信息，同时用于进行请求转发等操作
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，如将请求转发到指定页面，以向客户端返回相应的页面内容及提示信息
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如转发异常、从会话获取对象异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
-        Admin admin= (Admin) session.getAttribute("admin");
+        Admin admin = (Admin) session.getAttribute("admin");
 
         String adminid = admin.getA_id();
         String newpassword = request.getParameter("admin-newpassword");
@@ -29,19 +55,19 @@ public class AdminPasswordUpdateServlet extends HttpServlet {
         String regex = "^[\\w]{3,12}$";
         boolean flag = newpassword.matches(regex);
         if (!flag) {
-            request.setAttribute("update_msg", "密码格式错误，重新提交！"+String.format("%tT",new Date()));
+            request.setAttribute("update_msg", "密码格式错误，重新提交！" + String.format("%tT", new Date()));
             request.getRequestDispatcher("/WEB-INF/admin/adminUpdatePassword.jsp").forward(request, response);
         } else if (!newpassword.equals(ennewpassword)) {
             request.setAttribute("update_msg", "密码确认错误，请重新提交！" + String.format("%tT", new Date()));
             request.getRequestDispatcher("/WEB-INF/admin/adminUpdatePassword.jsp").forward(request, response);
         } else {
 
-            AdminService service= new AdminServiceImpl();
-            service.updatePassword(adminid,newpassword);
+            AdminService service = new AdminServiceImpl();
+            service.updatePassword(adminid, newpassword);
 
             Admin newAdmin = service.findAdminById(admin);
             admin = newAdmin;
-            session.setAttribute("admin",admin);
+            session.setAttribute("admin", admin);
 
             request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
             request.getRequestDispatcher("/WEB-INF/admin/adminUpdatePassword.jsp").forward(request, response);
@@ -49,7 +75,17 @@ public class AdminPasswordUpdateServlet extends HttpServlet {
 
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证管理员密码更新的整套业务逻辑得以执行，
+     * 包括密码格式验证、更新操作以及根据结果返回提示信息和页面转发等操作，方便管理员通过不同的请求方式来更新密码。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/admin/DoDeleteSelectCourseServlet.java

@@ -5,7 +5,6 @@ import service.CourseService;
 import service.StudentService;
 import service.impl.CourseServiceImpl;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -14,18 +13,49 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 
+/**
+ * DoDeleteSelectCourseServlet类，继承自HttpServlet，用于处理删除选课相关的业务逻辑，
+ * 主要功能是接收前端传来的课程编号参数，调用课程服务层的方法删除对应课程相关服务记录，然后将请求转发到学生可选课程展示的Servlet对应的路径，
+ * 以此实现删除选课操作后页面的相应更新，该Servlet对GET请求和POST请求进行统一处理，GET请求复用POST请求的逻辑，并且被映射到"/doDeleteSelectCourseServlet"路径下以接收对应请求。
+ */
 @WebServlet("/doDeleteSelectCourseServlet")
 public class DoDeleteSelectCourseServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免因编码问题出现乱码情况。
+     * 2. 获取当前请求对应的HttpSession对象，虽然在当前代码中暂时未体现出对该会话对象的进一步使用，但它可用于在后续拓展功能时存储一些与请求相关的中间数据或者用户状态等信息。
+     * 3. 从请求参数中获取课程的唯一编号（cid），这个编号将用于定位要删除的具体课程相关服务记录，它通常由前端页面在发起删除操作时传递过来，指明要删除哪一门课程的相关记录。
+     * 4. 创建CourseService的实现类对象（CourseServiceImpl），通过该对象可以调用课程相关业务逻辑的具体实现方法，在这里主要是为了调用删除课程相关服务记录的方法。
+     * 5. 调用service的deleteServiceById方法，传入获取到的课程编号（cid），由具体的服务层实现类根据该编号去对应的存储介质（比如数据库中课程服务相关表等）里删除相应的课程记录，
+     *    完成课程相关服务记录的删除操作（具体的删除逻辑及涉及的关联数据处理等由服务层实现类内部完成）。
+     * 6. 使用request对象的getRequestDispatcher方法获取一个请求转发器，指定要转发的目标路径为"/studentOptionalCourseServlet"，
+     *    这个路径对应的Servlet通常用于展示学生可选课程相关信息，通过转发到该Servlet对应的页面，使得在删除课程相关服务记录后，页面能够及时更新并展示最新的可选课程情况。
+     *
+     * @param request  HttpServletRequest对象，用于获取前端传来的请求参数（如课程编号cid）以及用于进行请求转发操作等，是处理请求相关逻辑的关键对象
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，在转发操作中会将响应传递给目标Servlet对应的页面，使其能够正确向客户端返回页面内容，完成页面更新展示
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如转发配置错误、获取请求参数异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
         String cid = request.getParameter("cid");
         CourseService service = new CourseServiceImpl();
         service.deleteServiceById(cid);
-        request.getRequestDispatcher("/studentOptionalCourseServlet").forward(request,response);
+        request.getRequestDispatcher("/studentOptionalCourseServlet").forward(request, response);
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证执行课程相关服务记录的删除操作以及页面转发更新这一核心逻辑，
+     * 方便前端可以根据不同的请求方式触发删除选课相关操作后看到最新的可选课程页面展示。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/admin/UpdateStudentInfoServlet.java

@@ -1,14 +1,11 @@
 package web.servlet.admin;
 
-
-
 import domain.CDC;
 import domain.Student;
 import service.CDCService;
 import service.StudentService;
 import service.impl.CDCServiceImpl;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -20,21 +17,50 @@ import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.List;
 
+/**
+ * UpdateStudentInfoServlet类，继承自HttpServlet，用于处理更新学生信息的相关业务逻辑，
+ * 其主要功能包括接收前端传来的学生各方面信息参数，对输入信息的格式进行简单校验，若格式正确则封装学生对象并调用服务层方法更新学生信息，
+ * 最后根据操作结果向前端返回相应提示信息，同时将请求转发到特定的页面（updateStudentServlet对应的页面，并携带学生编号sid作为参数），
+ * 该Servlet对GET请求和POST请求进行统一处理，GET请求复用POST请求的逻辑，且被映射到"/updateStudentInfoServlet"路径下以接收对应请求。
+ */
 @WebServlet("/updateStudentInfoServlet")
 public class UpdateStudentInfoServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免出现乱码问题，使后续获取的参数值能准确使用。
+     * 2. 虽然此处注释掉了获取HttpSession对象的代码，但通常HttpSession可用于存储和共享与用户相关的数据，在某些场景下可用于传递更多信息或者保存用户登录等状态信息，这里暂时未用到该功能。
+     * 3. 从请求参数中获取学生的唯一编号（student-id），并打印出来方便调试查看（此处通过System.out.println输出，可在控制台查看获取到的学生编号具体值），这个编号将用于后续确定要更新信息的具体学生对象。
+     * 4. 依次从请求参数中获取学生的其他各项信息，包括姓名（student-name）、性别（student-sex）、年龄（student-age）、电话号码（student-phone）、邮箱（student-email）、家庭住址（student-address）以及所属学院（selectCollege）、专业（selectDepartment）、班级（selectClass）等信息，
+     *    并且对获取到的部分关键信息也进行了打印输出，同样有助于调试查看获取到的参数值是否符合预期，方便排查问题。
+     * 5. 创建一个新的Student对象（updateStudent），用于封装要更新的学生信息，后续将通过该对象把更新后的信息传递给服务层进行数据库更新操作。
+     * 6. 对获取到的输入信息进行格式校验，判断姓名长度是否大于4位、电话号码长度是否大于11位、邮箱长度是否大于24位、家庭住址长度是否大于24位、年龄长度是否大于2位，
+     *    同时还检查这些字段中是否包含特殊字符“<”（可能是出于防止一些非法输入或者潜在安全风险的考虑），如果有任何一项不符合要求，就在请求域中设置提示信息告知前端“格式错误，请重新提交！”并附带当前时间，
+     *    然后通过请求转发器将请求转发到“updateStudentServlet”页面，并将学生编号（sid）作为参数传递过去，让用户可以根据提示重新填写并提交正确的信息。
+     * 7. 如果输入信息格式校验通过，就将获取到的各项学生信息通过对应的set方法设置到之前创建的updateStudent对象中，完成学生对象的封装，使其包含了完整的要更新的信息内容。
+     * 8. 创建StudentService的实现类对象（StudentServiceImpl），通过该对象可以调用学生相关业务逻辑的具体实现方法，在这里主要是为了调用更新学生信息的方法。
+     * 9. 调用service的updateInfo方法，传入封装好的updateStudent对象，由具体的服务层实现类根据传入的学生对象信息去对应的存储介质（比如数据库中的学生表等）里更新相应学生的记录，
+     *    完成学生信息的更新操作（具体的更新逻辑及涉及的关联数据处理等由服务层实现类内部完成）。
+     * 10. 在请求域中设置提示信息告知前端“修改成功！”并附带当前时间，然后通过请求转发器将请求转发到“updateStudentServlet”页面，并带上学生编号（sid）作为参数，使得页面可以根据学生编号展示更新后的学生信息等相关内容，
+     *     让用户知晓信息更新成功。
+     *
+     * @param request  HttpServletRequest对象，用于获取前端传来的各种学生信息参数、进行请求转发操作以及设置请求域中的提示信息等，是整个请求处理过程中的核心对象
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，如配合请求转发操作将响应传递给目标页面，使其能够正确向客户端返回页面内容及提示信息
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如转发异常、获取请求参数异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
         request.setCharacterEncoding("utf-8");
 //        HttpSession session = request.getSession();
         String sid = request.getParameter("student-id");
-        System.out.println("sid:"+sid);
+        System.out.println("sid:" + sid);
 
 
         //保存输入内容
         String name = request.getParameter("student-name");
-        System.out.println("sname:"+name);
+        System.out.println("sname:" + name);
         String sex = request.getParameter("student-sex");
-        System.out.println("ssex:"+sex);
+        System.out.println("ssex:" + sex);
         String age = request.getParameter("student-age");
         String phone = request.getParameter("student-phone");
         String email = request.getParameter("student-email");
@@ -47,10 +73,10 @@ public class UpdateStudentInfoServlet extends HttpServlet {
         Student updateStudent = new Student();
 
         //判断输入位数是否大于数据库位数
-        if (name.length() > 4 || phone.length() > 11 || email.length()>24 || address.length() > 24 || age.length()>2 || name.contains("<") || phone.contains("<") || email.contains("<") || address.contains("<") || age.contains("<")) {
-            request.setAttribute("update_msg","格式错误，请重新提交！"+String.format("%tT",new Date()));
-            request.getRequestDispatcher("updateStudentServlet?sid="+sid).forward(request, response);
-        }else {
+        if (name.length() > 4 || phone.length() > 11 || email.length() > 24 || address.length() > 24 || age.length() > 2 || name.contains("<") || phone.contains("<") || email.contains("<") || address.contains("<") || age.contains("<")) {
+            request.setAttribute("update_msg", "格式错误，请重新提交！" + String.format("%tT", new Date()));
+            request.getRequestDispatcher("updateStudentServlet?sid=" + sid).forward(request, response);
+        } else {
             //封装学生对象
             updateStudent.setS_id(sid);
             updateStudent.setS_name(name);
@@ -64,16 +90,26 @@ public class UpdateStudentInfoServlet extends HttpServlet {
             updateStudent.setS_class(cclass);
 
             //调用studentUpdata服务
-            StudentService service= new StudentServiceImpl();
+            StudentService service = new StudentServiceImpl();
             service.updateInfo(updateStudent);
 
             //成功则返回并给提示
-            request.setAttribute("update_msg", "修改成功！"+String.format("%tT",new Date()));
-            request.getRequestDispatcher("updateStudentServlet?sid="+sid).forward(request, response);
+            request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
+            request.getRequestDispatcher("updateStudentServlet?sid=" + sid).forward(request, response);
         }
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证执行学生信息格式校验、更新以及根据结果返回提示信息和页面转发等核心逻辑，
+     * 方便前端可以根据不同的请求方式触发学生信息更新操作并看到相应的反馈结果。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/admin/UpdateStudentServlet.java

@@ -6,7 +6,6 @@ import service.CDCService;
 import service.StudentService;
 import service.impl.CDCServiceImpl;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -16,8 +15,36 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
 
+/**
+ * UpdateStudentServlet类，继承自HttpServlet，用于处理与更新学生信息相关的请求操作，
+ * 其主要功能是根据传入的学生编号查找对应的学生信息，并将该学生信息存入请求属性中，同时获取学院、专业、班级的相关列表信息存入HttpSession中，
+ * 最后将请求转发到用于更新学生信息的JSP页面（/WEB-INF/admin/updateStudent.jsp），方便在页面上展示学生当前信息以及相关下拉选项等内容以供后续更新操作，
+ * 该Servlet对GET请求和POST请求进行统一处理，GET请求复用POST请求的逻辑，且被映射到"/updateStudentServlet"路径下以接收对应请求。
+ */
 @WebServlet("/updateStudentServlet")
 public class UpdateStudentServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免出现乱码问题，使后续获取的参数值能准确使用。
+     * 2. 获取当前请求对应的HttpSession对象，HttpSession可用于在多个请求之间存储和共享数据，在这里主要用于传递学生编号以及学院、专业、班级相关列表信息到后续的JSP页面。
+     * 3. 从请求参数中获取学生的唯一编号（sid），这个编号将用于查找特定的学生信息，它由前端页面在发起更新学生信息请求时传递过来，指明要操作的是哪一位学生的信息更新。
+     * 4. 创建一个新的Student对象，通过设置其学生编号（S_id）属性为获取到的studentid，以此构建一个用于查询的学生对象，后续将依据这个对象去查找对应的学生详细信息。
+     * 5. 创建StudentService的实现类对象（StudentServiceImpl），通过该对象可以调用学生相关业务逻辑的具体实现方法，在这里主要是为了调用根据学生编号查找学生信息的方法。
+     * 6. 调用service的findStudentById方法，传入构建好的student对象，由具体的服务层实现类根据该学生编号去对应的存储介质（比如数据库中的学生表等）里查找相应学生的记录，
+     *    获取到对应的Student对象（包含学生的详细信息，如姓名、性别、年龄等），并将该对象存入请求的属性中，属性名为"student"，以便后续在转发的JSP页面中可以获取并展示该学生的当前信息，方便进行信息更新操作。
+     * 7. 创建CDCService的实现类对象（CDCServiceImpl），用于调用获取学院、专业、班级相关信息的业务方法，为更新学生信息页面提供相应的下拉选项数据等。
+     * 8. 分别调用service2的findAllCollege()、findAllDepartment()、findAllClass()方法，获取所有学院信息列表、所有专业信息列表以及所有班级信息列表，这些列表中的元素通常是CDC类型的对象，包含了相应的名称等属性信息，
+     *    它们将用于在更新学生信息的JSP页面上展示可供选择的学院、专业、班级选项。
+     * 9. 将获取到的学院信息列表、专业信息列表、班级信息列表分别存入到HttpSession中，使用自定义的属性名（"collegeLists"、"departmentLists"、"classLists"）进行存储，以便后续在JSP页面中可以通过这些属性名获取并展示相应信息，
+     *    例如在页面上生成下拉列表展示所有学院、专业、班级供用户选择，方便更新学生所属的学院、专业、班级等信息。
+     * 10. 使用request对象的getRequestDispatcher方法获取一个请求转发器，指定要转发的目标页面为"/WEB-INF/admin/updateStudent.jsp"，
+     *     这个JSP页面通常是用于展示学生当前信息以及提供表单元素供用户更新学生信息的界面，通过之前存入请求属性和HttpSession中的信息可以在页面上准确展示学生当前情况以及相关的可选项内容，方便用户进行更新操作。
+     *
+     * @param request  HttpServletRequest对象，用于获取前端传来的请求参数（如学生编号sid）、设置请求属性（存入查找到的学生信息）以及进行请求转发操作等，是处理请求相关逻辑的关键对象
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，如配合请求转发操作将响应传递给目标JSP页面，使其能够正确向客户端返回页面内容，完成页面展示以供信息更新操作
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如转发异常、从数据库查询学生信息异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
@@ -28,21 +55,31 @@ public class UpdateStudentServlet extends HttpServlet {
         student.setS_id(studentid);
         StudentService service = new StudentServiceImpl();
         Student newStudent = service.findStudentById(student);
-        request.setAttribute("student",newStudent);
+        request.setAttribute("student", newStudent);
 
         CDCService service2 = new CDCServiceImpl();
         List<CDC> collegeList = service2.findAllCollege();
         List<CDC> departmentList = service2.findAllDepartment();
         List<CDC> classList = service2.findAllClass();
 
-        session.setAttribute("collegeLists",collegeList);
-        session.setAttribute("departmentLists",departmentList);
-        session.setAttribute("classLists",classList);
+        session.setAttribute("collegeLists", collegeList);
+        session.setAttribute("departmentLists", departmentList);
+        session.setAttribute("classLists", classList);
 
-        request.getRequestDispatcher("/WEB-INF/admin/updateStudent.jsp").forward(request,response);
+        request.getRequestDispatcher("/WEB-INF/admin/updateStudent.jsp").forward(request, response);
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证执行查找学生信息、获取学院等相关列表信息以及页面转发等核心逻辑，
+     * 方便前端可以根据不同的请求方式进入到更新学生信息的操作页面，并看到相应的学生当前信息和可选项内容。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/cdc/CDCListServlet.java

@@ -8,7 +8,6 @@ import service.CDCService;
 import service.StudentService;
 import service.impl.CDCServiceImpl;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -18,33 +17,69 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
 
+/**
+ * CDCListServlet类，继承自HttpServlet，用于处理获取学院、专业、班级（CDC）相关信息列表的请求，并根据当前登录用户的角色（学生、管理员、教师）不同，
+ * 将请求转发到相应的展示CDC信息列表的JSP页面，若无法确定有效角色则转发到错误页面。该Servlet对GET请求和POST请求进行统一处理，GET请求复用POST请求的逻辑，且被映射到"/cdcListServlet"路径下以接收对应请求。
+ */
 @WebServlet("/cdcListServlet")
 public class CDCListServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免出现乱码问题，使后续获取和处理相关数据能准确进行。
+     * 2. 创建CDCService的实现类对象（CDCServiceImpl），通过该对象可以调用与学院、专业、班级（CDC）相关业务逻辑的具体实现方法，在这里主要是为了获取所有的CDC信息列表。
+     * 3. 调用service的findAll方法，由具体的服务层实现类去对应的存储介质（比如数据库中存储CDC相关信息的表等）里查询出所有的CDC信息，
+     *    并以List<CDC>列表形式返回，列表中的每个CDC对象包含了学院、专业或班级的具体信息（如名称、相关描述等），获取到的信息列表后续将用于在页面上展示。
+     * 4. 将获取到的CDC信息列表存入请求的属性中，属性名为"cdcs"，这样在转发到相应的JSP页面后，可以在页面中通过获取该属性来展示具体的CDC信息列表内容，方便用户查看。
+     * 5. 获取当前请求对应的HttpSession对象，HttpSession可用于在多个请求之间存储和共享数据，在这里主要是为了获取当前登录用户的相关信息，以判断用户角色，进而决定转发到哪个对应的页面进行展示。
+     * 6. 尝试从HttpSession中获取学生（Student）、管理员（Admin）、教师（Teacher）对象，通过判断这些对象是否为空来确定当前登录用户的角色。
+     * 7. 如果从会话中获取到学生对象不为空，且管理员对象和教师对象都为空，说明当前登录用户是学生角色，那么就使用请求转发器将请求转发到"/WEB-INF/student/sCDCList.jsp"页面，
+     *    这个页面通常是专门为学生设计的用于展示CDC信息列表的界面，页面内容和展示方式可能会根据学生的权限和需求进行定制。
+     * 8. 如果获取到管理员对象不为空，而学生对象和教师对象都为空，表明当前登录用户是管理员角色，此时将请求转发到"/WEB-INF/admin/aCDCList.jsp"页面，
+     *    该页面是面向管理员展示CDC信息列表的，可能会提供更多的操作选项或者展示不同的数据细节，符合管理员的使用场景。
+     * 9. 若获取到教师对象不为空，同时管理员对象和学生对象都为空，则意味着当前登录用户是教师角色，会把请求转发到"/WEB-INF/teacher/tCDCList.jsp"页面，
+     *    此页面专为教师展示CDC信息列表而设计，展示内容和功能可能与教师对CDC信息的使用需求相关联。
+     * 10. 如果上述三种角色判断情况都不满足，即无法确定一个有效的登录用户角色，就将请求转发到"error.jsp"页面，该页面一般用于提示出现了错误情况，比如用户未正常登录或者角色信息出现异常等，告知用户相应的错误提示信息。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的参数（虽然此处未体现使用请求参数的情况，但可用于后续拓展）、设置请求属性（存入CDC信息列表）以及进行请求转发操作等，是处理请求相关逻辑的关键对象
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，如配合请求转发操作将响应传递给目标JSP页面，使其能够正确向客户端返回页面内容，根据用户角色展示相应的CDC信息列表页面或者错误提示页面
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如转发异常、获取会话对象异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         //调用StudentService完成查询
         CDCService service = new CDCServiceImpl();
         List<CDC> cdcs = service.findAll();
         //将list存入request域
-        request.setAttribute("cdcs",cdcs);
+        request.setAttribute("cdcs", cdcs);
 
         HttpSession session = request.getSession();
-        Student student= (Student)session.getAttribute("student");
-        Admin admin= (Admin)session.getAttribute("admin");
-        Teacher teacher= (Teacher)session.getAttribute("teacher");
+        Student student = (Student) session.getAttribute("student");
+        Admin admin = (Admin) session.getAttribute("admin");
+        Teacher teacher = (Teacher) session.getAttribute("teacher");
 
-        if (student != null && admin == null && teacher == null) {
+        if (student!= null && admin == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/student/sCDCList.jsp").forward(request, response);
-        } else if (admin != null && student == null && teacher == null) {
+        } else if (admin!= null && student == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/admin/aCDCList.jsp").forward(request, response);
-        } else if (teacher != null && admin == null && student == null) {
+        } else if (teacher!= null && admin == null && student == null) {
             request.getRequestDispatcher("/WEB-INF/teacher/tCDCList.jsp").forward(request, response);
         } else {
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证执行获取CDC信息列表、判断用户角色以及转发到相应页面等核心逻辑，
+     * 方便前端可以根据不同的请求方式获取并查看适合当前登录用户角色的CDC信息列表页面，或者在出现异常情况时看到相应的错误提示页面。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        this.doPost(request,response);
+        this.doPost(request, response);
     }
-}
+}

src/web/servlet/complaints/AddComplaintsServlet.java

@@ -4,7 +4,6 @@ import domain.Complaint;
 import service.ComplaintService;
 import service.NotifyService;
 import service.impl.ComplaintServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -14,8 +13,35 @@ import java.io.IOException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 
+/**
+ * AddComplaintsServlet类，继承自HttpServlet，用于处理添加投诉（小吐槽）相关的业务逻辑，
+ * 主要功能包括从请求中获取投诉内容参数，对内容进行简单的安全校验（过滤可能存在的脚本标签），
+ * 若内容合法则封装成投诉对象并添加到系统中，最后重定向到展示投诉列表的Servlet对应的路径（或原本注释掉的转发到另一个相关页面的操作），
+ * 该Servlet对GET请求和POST请求进行统一处理，GET请求复用POST请求的逻辑，且被映射到"/addComplaintsServlet"路径下以接收对应请求。
+ */
 @WebServlet("/addComplaintsServlet")
 public class AddComplaintsServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免出现乱码问题，使后续获取的参数值能准确使用。
+     * 2. 创建一个新的Complaint对象，用于封装要添加的投诉相关信息，后续会将从请求中获取到的内容以及生成的时间等信息设置到该对象中，以便传递给服务层进行添加操作。
+     * 3. 从请求参数中获取名为"complaint"的参数值，这个值代表用户输入的投诉内容文本，将其赋值给text变量，此处获取到的是Object类型，所以进行了强制类型转换为String类型。
+     * 4. 进行简单的安全校验，检查获取到的投诉内容文本中是否包含"script"以及"/script"字符串，这是为了防止用户输入的内容中包含可能会造成安全隐患的脚本代码（比如JavaScript脚本等），
+     *    如果包含这两个字符串，则通过字符串替换的方式将它们去除，以此来净化输入的投诉内容，提高系统安全性。
+     * 5. 判断经过处理后的投诉内容文本是否不为空，如果不为空，说明有有效的投诉内容需要添加到系统中，此时将文本内容设置到之前创建的complaint对象的content属性中，用于存储投诉的具体内容。
+     * 6. 创建一个Date对象表示当前日期和时间，用于记录投诉的时间，然后通过SimpleDateFormat类按照指定的格式（"yyyy-MM-dd HH:mm:ss"）将日期时间格式化为字符串，
+     *    再将格式化后的时间字符串设置到complaint对象的cdate属性中，这样投诉对象就包含了完整的投诉内容和投诉时间信息。
+     * 7. 创建ComplaintService的实现类对象（ComplaintServiceImpl），通过该对象可以调用与投诉相关业务逻辑的具体实现方法，在这里主要是为了调用添加投诉的方法。
+     * 8. 调用service的addComplaint方法，传入封装好的complaint对象，由具体的服务层实现类根据传入的投诉对象信息去对应的存储介质（比如数据库中存储投诉信息的表等）里添加相应的投诉记录，
+     *    完成投诉信息的添加操作（具体的添加逻辑及涉及的关联数据处理等由服务层实现类内部完成）。
+     * 9. 原本代码中注释掉了通过请求转发器转发到"/complaintListServlet"页面的操作，而采用了response.sendRedirect("complaintServlet")，这是使用重定向的方式将客户端浏览器引导到"complaintServlet"对应的页面，
+     *    通常这个页面是用于展示投诉列表等相关信息的，通过重定向使得在添加完投诉信息后，用户可以看到最新的投诉列表情况，而重定向与转发的区别在于重定向会让浏览器重新发起一次请求，地址栏会显示新的请求地址。
+     *
+     * @param request  HttpServletRequest对象，用于获取前端传来的投诉内容参数、进行请求编码设置以及原本可以用于请求转发操作（注释掉的部分体现了这一点）等，是处理请求相关逻辑的关键对象
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，如重定向到展示投诉列表的页面（通过sendRedirect方法），使客户端浏览器跳转到相应页面查看最新情况，或者原本也可配合请求转发将响应传递给目标页面（注释掉的转发操作体现）
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如获取请求参数异常、重定向或转发配置错误等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出重定向指令失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
 
@@ -25,8 +51,8 @@ public class AddComplaintsServlet extends HttpServlet {
         String text = (String) request.getParameter("complaint");
 
         if (text.contains("script") && text.contains("/script")) {
-            text = text.replace("script","");
-            text = text.replace("/script","");
+            text = text.replace("script", "");
+            text = text.replace("/script", "");
         }
 
         if (!text.equals("")) {
@@ -42,7 +68,17 @@ public class AddComplaintsServlet extends HttpServlet {
 //        request.getRequestDispatcher("/complaintListServlet").forward(request,response);
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证执行获取投诉内容、安全校验、添加投诉以及页面跳转等核心逻辑，
+     * 方便前端可以根据不同的请求方式来添加投诉信息并看到相应的反馈结果（跳转到展示投诉列表的页面）。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/complaints/ComplaintListServlet.java

@@ -3,7 +3,6 @@ package web.servlet.complaints;
 import domain.Complaint;
 import service.ComplaintService;
 import service.impl.ComplaintServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -12,16 +11,47 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
 
+/**
+ * ComplaintListServlet类，继承自HttpServlet，用于处理获取投诉（小吐槽）信息列表的业务逻辑，
+ * 其主要功能是调用服务层方法获取所有投诉信息，将这些信息存入请求属性中，然后把请求转发到用于展示投诉信息列表的JSP页面（/WEB-INF/complaint/complaintsList.jsp），
+ * 该Servlet对GET请求和POST请求进行统一处理，GET请求复用POST请求的逻辑，且被映射到"/complaintListServlet"路径下以接收对应请求。
+ */
 @WebServlet("/complaintListServlet")
 public class ComplaintListServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免出现乱码问题，使后续获取和处理投诉信息能准确进行。
+     * 2. 创建ComplaintService的实现类对象（ComplaintServiceImpl），通过该对象可以调用与投诉相关业务逻辑的具体实现方法，在这里主要是为了获取所有的投诉信息列表。
+     * 3. 调用service的findAll方法，由具体的服务层实现类去对应的存储介质（比如数据库中存储投诉信息的表等）里查询出所有的投诉信息，
+     *    并以List<Complaint>列表形式返回，列表中的每个Complaint对象包含了投诉的详细信息，如投诉内容、投诉时间等，获取到的信息列表后续将用于在页面上展示。
+     * 4. 将获取到的投诉信息列表存入请求的属性中，属性名为"complaints"，这样在转发到相应的JSP页面后，可以在页面中通过获取该属性来展示具体的投诉信息列表内容，方便用户查看所有投诉情况。
+     * 5. 使用request对象的getRequestDispatcher方法获取一个请求转发器，指定要转发的目标页面为"/WEB-INF/complaint/complaintsList.jsp"，
+     *    这个JSP页面通常是用于展示投诉信息列表的界面，页面上会遍历并展示存放在请求属性中的投诉信息列表里的每一条投诉内容、时间等详细信息，以供用户查看投诉相关情况。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的参数（虽然此处未体现使用请求参数的情况，但可用于后续拓展）、设置请求属性（存入投诉信息列表）以及进行请求转发操作等，是处理请求相关逻辑的关键对象
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，如配合请求转发操作将响应传递给目标JSP页面，使其能够正确向客户端返回页面内容，展示投诉信息列表页面让用户查看投诉情况
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如转发异常、从数据库查询投诉信息异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         ComplaintService service = new ComplaintServiceImpl();
         List<Complaint> complaints = service.findAll();
-        request.setAttribute("complaints",complaints);
-        request.getRequestDispatcher("/WEB-INF/complaint/complaintsList.jsp").forward(request,response);
+        request.setAttribute("complaints", complaints);
+        request.getRequestDispatcher("/WEB-INF/complaint/complaintsList.jsp").forward(request, response);
     }
+
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证执行获取投诉信息列表以及转发到展示页面等核心逻辑，
+     * 方便前端可以根据不同的请求方式查看投诉信息列表页面，了解所有投诉相关情况。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/complaints/ComplaintServlet.java

@@ -3,7 +3,6 @@ package web.servlet.complaints;
 import domain.Complaint;
 import service.ComplaintService;
 import service.impl.ComplaintServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -12,17 +11,47 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
 
+/**
+ * ComplaintServlet类，继承自HttpServlet，用于处理展示投诉信息相关的业务逻辑，
+ * 主要功能为从服务层获取所有投诉信息，将其存入请求属性中，随后把请求转发至展示投诉信息列表的JSP页面（/WEB-INF/complaint/complaintsList.jsp），
+ * 以此向用户呈现投诉相关内容，并且对GET请求和POST请求采用统一的处理方式，GET请求复用POST请求的逻辑，该类被映射到"/complaintServlet"路径来接收对应请求。
+ */
 @WebServlet("/complaintServlet")
 public class ComplaintServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，其具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，这样做是为了能正确接收和处理包含中文等特殊字符的请求参数，避免因编码问题导致获取到的参数出现乱码，确保后续业务逻辑能基于准确的数据进行处理。
+     * 2. 创建ComplaintService的实现类对象（ComplaintServiceImpl），这个对象用于调用具体的投诉相关业务逻辑方法，在这里的核心作用是获取所有投诉信息的列表。
+     * 3. 通过调用service的findAll方法，由具体的服务层实现类去对应的存储介质（例如数据库中存储投诉记录的表等）里查询出全部的投诉信息，
+     *    并以List<Complaint>的形式返回，其中列表里的每个Complaint对象都涵盖了投诉的详细信息，像投诉内容、投诉时间等关键内容，这些信息后续将展示在相应页面上供用户查看。
+     * 4. 把获取到的投诉信息列表存入请求的属性中，属性命名为"complaints"，如此一来，当请求被转发到目标JSP页面后，页面代码就能够从请求属性中获取该列表，进而遍历并展示每条投诉的详细信息，方便用户了解所有投诉情况。
+     * 5. 使用request对象的getRequestDispatcher方法获取请求转发器，指定要转发的目标页面为"/WEB-INF/complaint/complaintsList.jsp"，
+     *    该JSP页面是专门用于展示投诉信息列表的界面，它会依据从请求属性中获取到的投诉信息列表进行渲染，将每条投诉的各项信息以合适的方式展示出来，使用户能够清晰查看所有投诉的具体内容。
+     *
+     * @param request  HttpServletRequest对象，在整个处理过程中扮演关键角色，用于设置请求编码格式、获取服务层返回的投诉信息列表并将其存入请求属性，同时利用它进行请求转发操作等
+     * @param response HttpServletResponse对象，主要用于配合请求转发操作，将响应相关信息传递给目标JSP页面，使页面能够正确向客户端返回展示了投诉信息列表的页面内容，让用户看到相关信息
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常情况，例如转发页面时配置出错、获取服务层数据出现异常等，就会抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中产生输入输出相关的异常，比如读取请求参数失败、向客户端输出页面内容失败等情况时，该异常会被抛出
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         ComplaintService service = new ComplaintServiceImpl();
         List<Complaint> complaints = service.findAll();
-        request.setAttribute("complaints",complaints);
-        request.getRequestDispatcher("/WEB-INF/complaint/complaintsList.jsp").forward(request,response);
+        request.setAttribute("complaints", complaints);
+        request.getRequestDispatcher("/WEB-INF/complaint/complaintsList.jsp").forward(request, response);
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也按照与POST请求相同的逻辑进行处理。
+     * 这样设计的好处在于简化了代码结构，无论前端是以GET方式还是POST方式发起请求，都能确保执行获取投诉信息列表、存入请求属性以及转发到展示页面这一系列核心逻辑，
+     * 方便用户通过不同的请求方式都能够顺利查看投诉信息列表页面，了解所有投诉的相关情况。
+     *
+     * @param request  HttpServletRequest对象，和处理POST请求时的作用及含义相同，用于获取、传递相关数据以及进行请求转发等操作
+     * @param response HttpServletResponse对象，同样和处理POST请求时作用一致，配合请求转发使目标页面能正确响应并展示内容给客户端
+     * @throws ServletException 如果在按照POST请求逻辑处理GET请求过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/file/DeleteFileServlet.java

@@ -8,19 +8,28 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.File;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到指定的URL路径"/deleteFileServlet"，表明这是一个Servlet类，用于处理对应的网络请求
 @WebServlet("/deleteFileServlet")
 public class DeleteFileServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数
         request.setCharacterEncoding("utf-8");
+        // 从请求中获取名为"filename"的参数值，这个参数应该是要删除文件的文件名
         String fileName = request.getParameter("filename");
-        File file = new File(this.getServletContext().getRealPath("upload")+File.separator+fileName);
+        // 根据Servlet上下文获取"upload"目录的真实路径，并与文件名拼接起来，构造出要删除文件的完整路径，创建对应的File对象
+        File file = new File(this.getServletContext().getRealPath("upload") + File.separator + fileName);
+        // 判断文件是否存在，如果存在则执行删除操作
         if (file.exists()) {
             file.delete();
         }
-        request.getRequestDispatcher("/fileListServlet").forward(request,response);
+        // 将请求转发到"/fileListServlet"对应的Servlet（应该是用于展示文件列表之类的功能），以更新文件列表等相关显示内容
+        request.getRequestDispatcher("/fileListServlet").forward(request, response);
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/file/DownloadServlet.java

@@ -15,48 +15,79 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.net.URLEncoder;
 
+// 使用WebServlet注解将该类映射到"/downloadServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/downloadServlet")
 public class DownloadServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 从请求中获取名为"filename"的参数，该参数代表要下载的文件的文件名
         String filename = request.getParameter("filename");
+        // 判断文件名是否为"../"或者"/"，如果是则表示可能存在非法的访问路径，将请求转发到"error.jsp"页面进行错误提示
         if (filename.equalsIgnoreCase("../") || filename.equalsIgnoreCase("/")) {
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
+
+        // 设置响应头的Content-Type为"application/octet-stream"，表示这是一个二进制流数据，通常用于文件下载
         response.addHeader("content-Type", "application/octet-stream");
 
+        // 获取请求头中的User-Agent信息，用于判断客户端浏览器类型，不同浏览器对文件名编码处理可能有所不同
         String agent = request.getHeader("User-Agent");
 
+        // 判断User-Agent中是否包含"chrome"（转换为小写后判断），如果是Chrome浏览器
         if (agent.toLowerCase().indexOf("chrome") > 0) {
+            // 对文件名进行编码转换，先将UTF-8编码的字节数组转换为ISO8859-1编码的字符串，用于设置Content-Disposition响应头中的文件名部分，
+            // 这样Chrome浏览器能正确识别并显示下载文件名（处理文件名中的中文等特殊字符情况）
             response.addHeader("content-Disposition", "attachment;filename=" + new String(filename.getBytes("UTF-8"), "ISO8859-1"));
         } else {
+            // 如果不是Chrome浏览器，使用URLEncoder将文件名按照UTF-8编码进行URL编码，同样用于设置Content-Disposition响应头中的文件名部分，
+            // 以保证在其他浏览器中能正确显示下载文件名
             response.addHeader("content-Disposition", "attachment;filename=" + URLEncoder.encode(filename, "UTF-8"));
         }
+
+        // 通过Servlet上下文获取指定文件（位于"/upload/"目录下，文件名由前面获取的filename决定）的输入流，用于读取文件内容
         InputStream in = getServletContext().getResourceAsStream("/upload/" + filename);
+        // 获取ServletResponse的输出流，用于将文件内容写回到客户端，实现文件下载功能
         ServletOutputStream out = response.getOutputStream();
+
+        // 创建一个大小为1024字节的字节数组，用于缓存从文件读取的数据
         byte[] bs = new byte[1024];
         int len = -1;
-        while ((len = in.read(bs)) != -1) {
+        // 通过循环从输入流读取数据到字节数组，每次读取的数据长度存放在len变量中，当读取到文件末尾时len为-1，循环结束
+        while ((len = in.read(bs))!= -1) {
+            // 将读取到的字节数据（长度为len）从字节数组bs中写入到输出流out，实现将文件内容发送给客户端
             out.write(bs, 0, len);
         }
+
+        // 关闭输出流，释放相关资源
         out.close();
+        // 关闭输入流，释放相关资源
         in.close();
 
+        // 获取当前请求的HttpSession对象，用于获取会话中存储的用户相关信息
         HttpSession session = request.getSession();
-        Student student= (Student)session.getAttribute("student");
-        Admin admin= (Admin)session.getAttribute("admin");
-        Teacher teacher= (Teacher)session.getAttribute("teacher");
-        if (student != null && admin == null && teacher == null) {
+        // 从会话中尝试获取Student类型的用户对象，如果存在表示当前登录用户是学生角色
+        Student student = (Student) session.getAttribute("student");
+        // 从会话中尝试获取Admin类型的用户对象，如果存在表示当前登录用户是管理员角色
+        Admin admin = (Admin) session.getAttribute("admin");
+        // 从会话中尝试获取Teacher类型的用户对象，如果存在表示当前登录用户是教师角色
+        Teacher teacher = (Teacher) session.getAttribute("teacher");
+
+        // 判断如果当前登录用户是学生角色，且不是管理员和教师角色，那么请求转发到学生角色对应的文件列表页面（"/WEB-INF/student/sFindFileList.jsp"）
+        if (student!= null && admin == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/student/sFindFileList.jsp").forward(request, response);
-        } else if (admin != null && student == null && teacher == null) {
+        } else if (admin!= null && student == null && teacher == null) {  // 如果是管理员角色，且不是学生和教师角色，转发到管理员对应的文件列表页面
             request.getRequestDispatcher("/WEB-INF/admin/aFindFileList.jsp").forward(request, response);
-        } else if (teacher != null && admin == null && student == null) {
+        } else if (teacher!= null && admin == null && student == null) {  // 如果是教师角色，且不是管理员和学生角色，转发到教师对应的文件列表页面
             request.getRequestDispatcher("/WEB-INF/teacher/tFindFileList.jsp").forward(request, response);
         } else {
+            // 如果不符合以上任何一种角色情况，可能存在异常情况，将请求转发到"error.jsp"页面进行错误提示
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }
-}
+}

src/web/servlet/file/FileListServlet.java

@@ -18,71 +18,104 @@ import java.math.RoundingMode;
 import java.util.ArrayList;
 import java.util.List;
 
+// 使用WebServlet注解将该类映射到"/fileListServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/fileListServlet")
 public class FileListServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数
         request.setCharacterEncoding("utf-8");
+
+        // 根据Servlet上下文获取"upload"目录的真实路径，并创建对应的File对象，用于后续操作该目录下的文件
         File dir = new File(this.getServletContext().getRealPath("upload"));
-        if (!dir.exists() && !dir.isDirectory()) {
+        // 判断该目录是否不存在，并且不是一个目录（可能不存在或者是个文件等不符合预期的情况）
+        if (!dir.exists() &&!dir.isDirectory()) {
+            // 在控制台打印提示信息，说明"upload"目录不存在，需要创建
             System.out.println(this.getServletContext().getRealPath("upload") + "目录不存在，需要创建");
-            // 创建目录
+            // 创建"upload"目录
             dir.mkdir();
         }
+
+        // 获取"upload"目录下的所有文件和子目录，返回一个File数组，方便后续遍历操作这些文件
         File[] arrs = dir.listFiles();
+
+        // 创建一个FileClass类型的列表，用于存储文件相关信息，后续会将"upload"目录下每个文件的信息封装到FileClass对象中，并添加到这个列表里
         List<FileClass> fileLists = new ArrayList<FileClass>();
-        for(File f:arrs){
+
+        // 遍历"upload"目录下的所有文件（通过增强for循环遍历File数组）
+        for (File f : arrs) {
+            // 获取文件的字节长度，即文件大小（单位为字节）
             long l = f.length();
+            // 调用getPrintSize方法将文件大小的字节数转换为合适的带单位的字符串表示形式（如KB、MB、GB等）
             String fileSize = getPrintSize(l);
+            // 创建一个FileClass对象，用于封装单个文件的相关信息
             FileClass file = new FileClass();
+            // 设置文件名，通过调用File对象的getName方法获取文件名
             file.setFileName(f.getName());
+            // 设置文件的绝对路径，通过调用File对象的getAbsolutePath方法获取
             file.setFilePath(f.getAbsolutePath());
+            // 设置文件大小，使用前面转换好的带单位的文件大小字符串
             file.setFileSize(fileSize);
+            // 将封装好文件信息的FileClass对象添加到fileLists列表中
             fileLists.add(file);
         }
-        request.setAttribute("fileLists",fileLists);
 
+        // 将包含所有文件信息的fileLists列表存放到请求的属性中，属性名为"fileLists"，方便在后续转发的页面中获取并展示文件列表信息
+        request.setAttribute("fileLists", fileLists);
+
+        // 获取当前请求的HttpSession对象，用于获取会话中存储的用户相关信息
         HttpSession session = request.getSession();
-        Student student= (Student)session.getAttribute("student");
+        // 从会话中尝试获取Student类型的用户对象，如果存在表示当前登录用户是学生角色
+        Student student = (Student) session.getAttribute("student");
+        // 从会话中尝试获取Admin类型的用户对象，如果存在表示当前登录用户是管理员角色
+        Admin admin = (Admin) session.getAttribute("admin");
+        // 从会话中尝试获取Teacher类型的用户对象，如果存在表示当前登录用户是教师角色
+        Teacher teacher = (Teacher) session.getAttribute("teacher");
 
-        Admin admin= (Admin)session.getAttribute("admin");
-        Teacher teacher= (Teacher)session.getAttribute("teacher");
-        if (student != null && admin == null && teacher == null) {
+        // 判断如果当前登录用户是学生角色，且不是管理员和教师角色，那么请求转发到学生角色对应的文件列表页面（"/WEB-INF/student/sFindFileList.jsp"）
+        if (student!= null && admin == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/student/sFindFileList.jsp").forward(request, response);
-        } else if (admin != null && student == null && teacher == null) {
+        } else if (admin!= null && student == null && teacher == null) {  // 如果是管理员角色，且不是学生和教师角色，转发到管理员对应的文件列表页面
             request.getRequestDispatcher("/WEB-INF/admin/aFindFileList.jsp").forward(request, response);
-        } else if (teacher != null && admin == null && student == null) {
+        } else if (teacher!= null && admin == null && student == null) {  // 如果是教师角色，且不是管理员和学生角色，转发到教师对应的文件列表页面
             request.getRequestDispatcher("/WEB-INF/teacher/tFindFileList.jsp").forward(request, response);
         } else {
+            // 如果不符合以上任何一种角色情况，可能存在异常情况，将请求转发到"error.jsp"页面进行错误提示
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
 
+    // 静态方法，用于将文件大小的字节数转换为合适的带单位的字符串表示形式，方便展示给用户直观了解文件大小
     public static String getPrintSize(long size) {
-        // 如果字节数少于1024，则直接以B为单位，否则先除于1024，后3位因太少无意义
+        // 将传入的文件大小字节数转换为double类型，方便后续进行数值计算和比较
         double value = (double) size;
+        // 如果字节数少于1024，说明文件较小，直接以B（字节）为单位返回，将数值转换为字符串并拼接上单位"B"
         if (value < 1024) {
             return String.valueOf(value) + "B";
         } else {
+            // 如果字节数大于等于1024，先将字节数除以1024，得到以KB为单位的数值（暂时还未处理小数位数等情况），
+            // 使用BigDecimal进行数值处理，设置小数位数为2位，舍入模式为向下取整（ROUND_DOWN），再获取处理后的double类型数值
             value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
         }
-        // 如果原字节数除于1024之后，少于1024，则可以直接以KB作为单位
-        // 因为还没有到达要使用另一个单位的时候
-        // 接下去以此类推
+        // 如果原字节数除于1024之后，少于1024，则可以直接以KB作为单位，将数值转换为字符串并拼接上单位"KB"
         if (value < 1024) {
             return String.valueOf(value) + "KB";
         } else {
+            // 如果数值大于等于1024KB，再将其除以1024，得到以MB为单位的数值（同样先进行数值处理，设置小数位数和舍入模式）
             value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
         }
         if (value < 1024) {
             return String.valueOf(value) + "MB";
         } else {
-            // 否则如果要以GB为单位的，先除于1024再作同样的处理
+            // 否则如果要以GB为单位的，先除于1024再作同样的处理，得到以GB为单位的数值，将其转换为字符串并拼接上单位"GB"后返回
             value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
             return String.valueOf(value) + "GB";
         }
     }
-}
+}

src/web/servlet/file/FileServlet.java

@@ -7,13 +7,21 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/fileServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/fileServlet")
 public class FileServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.getRequestDispatcher("/WEB-INF/admin/uploadFile.jsp").forward(request,response);
+        // 将当前请求转发到"/WEB-INF/admin/uploadFile.jsp"页面。
+        // 通常这样做可能是引导用户进入文件上传的相关页面，
+        // 比如后续在该JSP页面中会提供文件上传的表单等操作界面供用户进行文件上传操作。
+        request.getRequestDispatcher("/WEB-INF/admin/uploadFile.jsp").forward(request, response);
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 也就是当接收到GET请求时，同样会将请求转发到"/WEB-INF/admin/uploadFile.jsp"页面。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/file/ShowPhotoServlet.java

@@ -20,80 +20,123 @@ import java.awt.image.BufferedImage;
 import java.io.*;
 import java.net.ServerSocket;
 
+// 使用WebServlet注解将该类映射到"/showPhotoServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/showPhotoServlet")
 public class ShowPhotoServlet extends HttpServlet {
-    private static final String GIF = "image/gif;charset=GB2312";// 设定输出的类型
-
+    // 定义表示GIF图片的MIME类型及字符编码，用于设置响应头中Content-Type字段，表明输出的内容类型为GIF图片格式
+    private static final String GIF = "image/gif;charset=GB2312";
+    // 定义表示JPEG图片的MIME类型及字符编码，用于设置响应头中Content-Type字段，表明输出的内容类型为JPEG图片格式
     private static final String JPG = "image/jpeg;charset=GB2312";
 
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        String spec = request.getParameter("spec");// 输出图片的类型的标志
+        // 从请求中获取名为"spec"的参数，该参数用于标识要输出图片的类型（可能是用于区分不同格式图片之类的标识）
+        String spec = request.getParameter("spec");
 
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数
         request.setCharacterEncoding("utf-8");
+
+        // 获取当前请求对应的HttpSession对象，用于获取会话中存储的用户相关信息
         HttpSession session = request.getSession();
+        // 从会话中尝试获取Student类型的用户对象，如果存在表示当前登录用户是学生角色
         Student student = (Student) session.getAttribute("student");
+        // 从会话中尝试获取Teacher类型的用户对象，如果存在表示当前登录用户是教师角色
         Teacher teacher = (Teacher) session.getAttribute("teacher");
+
+        // 定义一个Photo对象，用于存储要展示的照片相关信息，后续根据登录用户角色来获取对应的照片信息
         Photo p;
-        if (student != null) {
+        // 如果当前登录用户是学生角色
+        if (student!= null) {
+            // 创建PhotoService的实现类实例，用于调用业务逻辑层方法来获取学生对应的照片信息
             PhotoService service = new PhotoServiceImpl();
+            // 通过业务逻辑层方法，根据学生的ID（student.getS_id()）查找对应的照片信息，并赋值给p对象
             p = service.findPhotoByPhotoId(student.getS_id());
-        }else{
+        } else {
+            // 如果不是学生角色，即当前登录用户是教师角色，同样创建PhotoService的实现类实例
             PhotoService service = new PhotoServiceImpl();
+            // 通过业务逻辑层方法，根据教师的ID（teacher.getT_id()）查找对应的照片信息，并赋值给p对象
             p = service.findPhotoByPhotoId(teacher.getT_id());
         }
+
+        // 初始化要展示照片的文件路径字符串，后续根据实际情况确定具体路径
         String imagePath = "";
+        // 如果通过前面查找没有获取到对应的照片信息（p为null）
         if (p == null) {
+            // 则使用默认的照片路径，构造出默认照片（0.jpg）在服务器端的真实路径，通常用于当没有用户对应照片时展示默认图片
             imagePath = this.getServletContext().getRealPath("/photos/") + "0.jpg";
             System.out.println(imagePath);
         } else {
+            // 如果获取到了对应的照片信息，获取照片的名称（文件名）
             String photoName = p.getPhotoName();
+            // 根据照片名称构造出该照片在服务器端（"/photos/"目录下）的真实路径
             imagePath = this.getServletContext().getRealPath("/photos/") + photoName;
             System.out.println(imagePath);
         }
 
-
+        // 重置响应对象，清除之前可能设置的一些响应头和状态码等信息，确保后续设置是准确有效的
         response.reset();
 
-        OutputStream output = response.getOutputStream();// 得到输出流
-        if (imagePath.toLowerCase().endsWith(".jpg"))// 使用编码处理文件流的情况：
-        {
-            response.setContentType(JPG);// 设定输出的类型
-            // 得到图片的真实路径
+        // 获取ServletResponse的输出流，用于向客户端输出图片数据，实现图片展示功能
+        OutputStream output = response.getOutputStream();
 
-            // 得到图片的文件流
+        // 判断图片文件路径是否以".jpg"结尾，即判断是否为JPEG格式图片，若是则进行以下JPEG图片处理逻辑
+        if (imagePath.toLowerCase().endsWith(".jpg")) {
+            // 设置响应头的Content-Type为JPEG图片对应的MIME类型，告知客户端返回的是JPEG格式的图片数据
+            response.setContentType(JPG);
+
+            // 根据图片的真实路径创建FileInputStream对象，用于读取图片文件的原始数据
             InputStream imageIn = new FileInputStream(new File(imagePath));
-            // 得到输入的编码器，将文件流进行jpg格式编码
+            // 通过JPEGCodec创建JPEGImageDecoder对象，用于对读取到的JPEG格式文件流进行解码操作，将其转换为BufferedImage对象（便于后续处理）
             JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(imageIn);
-            // 得到编码后的图片对象
+            // 使用解码器对图片文件流进行解码，得到BufferedImage类型的图片对象，该对象包含了图片的像素等信息
             BufferedImage image = decoder.decodeAsBufferedImage();
-            // 得到输出的编码器
+            // 通过JPEGCodec创建JPEGImageEncoder对象，用于对处理后的图片进行编码，以便输出到客户端
             JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(output);
-            encoder.encode(image);// 对图片进行输出编码
-            imageIn.close();// 关闭文件流
+            // 使用编码器将BufferedImage类型的图片对象进行编码，并通过输出流输出到客户端，实现JPEG图片的展示
+            encoder.encode(image);
+            // 关闭用于读取图片文件的输入流，释放相关资源
+            imageIn.close();
         }
 
-        if (imagePath.toLowerCase().endsWith(".gif"))// 不使用编码处理文件流的情况：
-        {
+        // 判断图片文件路径是否以".gif"结尾，即判断是否为GIF格式图片，若是则进行以下GIF图片处理逻辑
+        if (imagePath.toLowerCase().endsWith(".gif")) {
+            // 设置响应头的Content-Type为GIF图片对应的MIME类型，告知客户端返回的是GIF格式的图片数据
             response.setContentType(GIF);
-            ServletContext context = getServletContext();// 得到背景对象
-            InputStream imageIn = context.getResourceAsStream(imagePath);// 文件流
-            BufferedInputStream bis = new BufferedInputStream(imageIn);// 输入缓冲流
-            BufferedOutputStream bos = new BufferedOutputStream(output);// 输出缓冲流
-            byte data[] = new byte[4096];// 缓冲字节数
+
+            // 获取Servlet上下文对象，可用于获取服务器端相关资源
+            ServletContext context = getServletContext();
+            // 通过Servlet上下文对象，根据图片文件路径获取对应的输入流，用于读取GIF图片文件的数据
+            InputStream imageIn = context.getResourceAsStream(imagePath);
+            // 使用BufferedInputStream对读取GIF图片文件的输入流进行缓冲包装，提高读取效率
+            BufferedInputStream bis = new BufferedInputStream(imageIn);
+            // 使用BufferedOutputStream对向客户端输出的输出流进行缓冲包装，提高输出效率
+            BufferedOutputStream bos = new BufferedOutputStream(output);
+
+            // 创建一个大小为4096字节的字节数组，用于缓存从文件读取和向客户端输出的数据
+            byte data[] = new byte[4096];
             int size = 0;
+            // 从缓冲输入流中读取数据到字节数组，每次读取的数据长度存放在size变量中，当读取到文件末尾时size为-1
             size = bis.read(data);
-            while (size != -1) {
+            // 通过循环不断读取数据并输出到客户端，直到读取完整个文件（size为-1时结束循环）
+            while (size!= -1) {
                 bos.write(data, 0, size);
                 size = bis.read(data);
             }
+
+            // 关闭缓冲输入流，释放相关资源
             bis.close();
-            bos.flush();// 清空输出缓冲流
+            // 刷新输出缓冲流，确保所有数据都被及时发送到客户端
+            bos.flush();
+            // 关闭输出缓冲流，释放相关资源
             bos.close();
         }
+
+        // 关闭用于向客户端输出的输出流，释放相关资源
         output.close();
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/file/UploadImageServlet.java

@@ -24,83 +24,137 @@ import java.io.InputStream;
 import java.util.Date;
 import java.util.List;
 
+// 使用WebServlet注解将该类映射到"/uploadImageServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/uploadImageServlet")
 public class UploadImageServlet extends HttpServlet {
-    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
+    // 重写doPost方法，用于处理HTTP POST请求
+    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 获取当前请求对应的HttpSession对象，用于获取会话中存储的用户相关信息
         HttpSession session = request.getSession();
+        // 从会话中尝试获取Student类型的用户对象，如果存在表示当前登录用户是学生角色
         Student student = (Student) session.getAttribute("student");
+        // 从会话中尝试获取Teacher类型的用户对象，如果存在表示当前登录用户是教师角色
         Teacher teacher = (Teacher) session.getAttribute("teacher");
+        // 从会话中尝试获取Admin类型的用户对象，如果存在表示当前登录用户是管理员角色
         Admin admin = (Admin) session.getAttribute("admin");
+
+        // 初始化一个字符串变量id，用于存储后续根据登录用户角色确定的唯一标识（如学生的学号、教师的教师编号等），先初始化为空字符串
         String id = "";
-        if (student != null) {
+        // 如果当前登录用户是学生角色，则将学生的学号赋值给id变量，作为后续处理图片相关操作的关联标识
+        if (student!= null) {
             id = student.getS_id();
         }
 
+        // 在请求属性中设置"message"属性为空字符串，可能用于后续传递一些提示信息（目前此处暂未看到实际使用场景）
         request.setAttribute("message", "");
+        // 在请求属性中设置"path"属性为空字符串，可能用于后续传递图片的保存路径等相关信息（目前此处暂未看到实际使用场景）
         request.setAttribute("path", "");
+
+        // 初始化用于存储原始文件名的变量，初始化为null
         String filename = null;
+        // 初始化用于存储处理后的新文件名的变量，初始化为null
         String newFileName = null;
-        // 设置上传图片的保存路径
+
+        // 获取服务器上用于保存上传图片的目录路径，通过Servlet上下文获取"/photos"目录的真实路径
         String savePath = this.getServletContext().getRealPath("/photos");
+        // 根据保存路径创建对应的File对象，用于后续判断目录是否存在等操作
         File file = new File(savePath);
-        // 判断上传文件的保存目录是否存在
-        if (!file.exists() && !file.isDirectory()) {
+
+        // 判断上传图片的保存目录是否存在，如果不存在并且不是一个目录（可能不存在或者是个文件等不符合预期的情况）
+        if (!file.exists() &&!file.isDirectory()) {
+            // 在控制台打印提示信息，说明该目录不存在，需要创建
             System.out.println(savePath + "目录不存在，需要创建");
-            // 创建目录
+            // 创建该目录
             file.mkdir();
         }
+
+        // 1、创建一个DiskFileItemFactory对象，它是Apache Commons FileUpload组件中用于创建文件项的工厂类，
+        // 可以配置一些与文件上传相关的底层参数（如临时文件存储等，此处使用默认配置）
         DiskFileItemFactory factory = new DiskFileItemFactory();
-        // 2、创建一个文件上传解析器
+
+        // 2、创建一个ServletFileUpload对象，它是用于解析上传文件的核心类，通过传入前面创建的工厂对象来进行初始化，
+        // 后续可以使用它来解析HTTP请求中的文件上传相关内容
         ServletFileUpload upload = new ServletFileUpload(factory);
+        // 设置请求头的编码为"UTF-8"，确保能正确解析包含中文等多字节字符的文件名等信息
         upload.setHeaderEncoding("UTF-8");
-        // 3、判断提交上来的数据是否是上传表单的数据
+
+        // 3、判断提交上来的数据是否是符合文件上传表单的数据格式（通过请求的Content-Type等相关信息判断），
+        // 如果不是则说明不是文件上传请求，按照传统方式获取数据（此处直接返回，意味着不处理这种情况）
         if (!ServletFileUpload.isMultipartContent(request)) {
             // 按照传统方式获取数据
             return;
         }
+
         try {
+            // 使用ServletFileUpload对象解析HTTP请求，获取所有的文件项（FileItem）列表，每个FileItem对应一个表单中的文件上传字段或普通表单字段
             List<FileItem> list = upload.parseRequest(request);
-            System.out.println(list.toString());// 文件的路径 以及保存的路径
+            // 打印文件项列表信息（此处可能是用于调试，查看获取到的文件相关信息情况），实际应用中可根据需求决定是否保留
+            System.out.println(list.toString());
+
+            // 遍历文件项列表，对每个文件项进行处理
             for (FileItem item : list) {
-                filename = item.getName();// 获得一个项的文件名称
+                // 获取文件项对应的文件名，这里获取到的文件名包含完整路径（例如在客户端本地的完整路径）
+                filename = item.getName();
+
                 try {
+                    // 根据登录用户的标识（如学生学号等）和原始文件名的后缀（通过截取文件名中最后一个点后面的部分）构建新的文件名，
+                    // 目的可能是保证文件名的唯一性以及与用户关联等，例如将学号和原文件名后缀拼接起来
                     newFileName = id + filename.substring(filename.lastIndexOf("."));
+                    // 同时也对原始文件名做同样的处理，用于后续保存文件等操作（这里可能存在重复代码，可以考虑优化）
                     filename = id + filename.substring(filename.lastIndexOf("."));
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
-                if (filename == null || filename.trim().equals("")) {// 如果為空則跳過
+
+                // 如果文件名是空的（可能是获取文件名出现问题或者该项不是文件上传项等情况），则跳过当前循环，继续处理下一个文件项
+                if (filename == null || filename.trim().equals("")) {
                     continue;
                 }
-                // 報錯 需要過濾文件名稱 java.io.FileNotFoundException:
-                // G:\测试02\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\wtpwebapps\FaceUp\WEB-INF\images\C:\Users\Ray\Pictures\2.jpeg
-                // (文件名、目录名或卷标语法不正确。)
 
+                // 对文件名进行处理，截取文件名中最后一个反斜杠（\）后面的部分，去除路径信息，只保留文件名部分，
+                // 这样在保存文件到服务器指定目录时使用的文件名更符合要求（避免包含客户端本地的完整路径导致保存出错）
                 filename = filename.substring(filename.lastIndexOf("\\") + 1);
-//				System.out.print(filename);
-                if (filename.substring(filename.lastIndexOf(".") + 1).equals("JPG")
-                        || filename.substring(filename.lastIndexOf(".") + 1).equals("JPEG")
-                        || filename.substring(filename.lastIndexOf(".") + 1).equals("gif")
-                        || filename.substring(filename.lastIndexOf(".") + 1).equals("GIF")
-                        || filename.substring(filename.lastIndexOf(".") + 1).equals("jpg")
-                        || filename.substring(filename.lastIndexOf(".") + 1).equals("jpeg")) {
-                    InputStream in = item.getInputStream();// 獲得上傳的輸入流
-                    FileOutputStream out = new FileOutputStream(savePath + "\\" + filename);// 指定web-inf目錄下的images文件
-                    request.setAttribute("path",  "photos"+"\\" + filename);
 
-                    int len = 0;
+                // 判断文件名的后缀（通过截取文件名中最后一个点后面的部分并转换为大写后进行比较）是否是允许上传的图片格式（JPG、JPEG、GIF等），
+                // 如果是则进行文件上传相关操作
+                if (filename.substring(filename.lastIndexOf(".") + 1).equalsIgnoreCase("JPG")
+                        || filename.substring(filename.lastIndexOf(".") + 1).equalsIgnoreCase("JPEG")
+                        || filename.substring(filename.lastIndexOf(".") + 1).equalsIgnoreCase("GIF")
+                        || filename.substring(filename.lastIndexOf(".") + 1).equalsIgnoreCase("jpg")
+                        || filename.substring(filename.lastIndexOf(".") + 1).equalsIgnoreCase("jpeg")) {
+
+                    // 获取文件项对应的输入流，通过该输入流可以读取客户端上传的文件内容
+                    InputStream in = item.getInputStream();
+                    // 创建一个FileOutputStream对象，用于将读取到的文件内容写入到服务器指定的保存目录下，
+                    // 构造的文件路径是在之前确定的保存路径（savePath）基础上加上处理后的文件名（通过"\\"拼接路径和文件名）
+                    FileOutputStream out = new FileOutputStream(savePath + "\\" + filename);
+
+                    // 在请求属性中设置"path"属性，记录图片在服务器端保存后的相对路径（这里记录的路径格式可能需要根据实际前端使用情况进行调整），
+                    // 方便后续页面展示等操作可以获取到图片的位置信息
+                    request.setAttribute("path", "photos" + "\\" + filename);
+
+                    // 创建一个大小为1024字节的字节数组，用于缓存从输入流读取的数据，提高读写效率
                     byte buffer[] = new byte[1024];
-                    while ((len = in.read(buffer)) > 0)// 每次讀取
-                    {
+                    int len = 0;
+                    // 通过循环不断从输入流读取数据到字节数组，每次读取的数据长度存放在len变量中，只要读取到的数据长度大于0就继续循环，
+                    // 并将读取到的数据通过输出流写入到服务器端的文件中，实现文件上传保存的功能
+                    while ((len = in.read(buffer)) > 0) {
                         out.write(buffer, 0, len);
                     }
+
+                    // 关闭用于读取文件的输入流，释放相关资源
                     in.close();
+                    // 关闭用于写入文件的输出流，释放相关资源
                     out.close();
+                    // 删除临时文件（如果有，根据Apache Commons FileUpload的机制，在一些情况下会生成临时文件，此处删除它）
                     item.delete();
-                } else {  //必须是图片才能上传否则失败
-                    request.setAttribute("update_msg", "上传失败，只能上传类型为jpg或GIF的图像文件！"+String.format("%tT",new Date()));
-//        request.getRequestDispatcher("/WEB-INF/index.jsp").forward(request, response);
+                } else {
+                    // 如果文件名后缀不是允许上传的图片格式，则表示上传的文件不符合要求，
+                    // 在请求属性中设置"update_msg"属性，添加提示信息，说明上传失败以及失败原因（只能上传指定类型的图片文件），
+                    // 并带上当前的时间信息（通过String.format("%tT", new Date())格式化时间）
+                    request.setAttribute("update_msg", "上传失败，只能上传类型为jpg或GIF的图像文件！" + String.format("%tT", new Date()));
+                    // 将请求转发到"/WEB-INF/student/studentAddPhoto.jsp"页面，可能该页面用于显示上传结果等相关信息给用户
                     request.getRequestDispatcher("/WEB-INF/student/studentAddPhoto.jsp").forward(request, response);
                     return;
                 }
@@ -109,24 +163,34 @@ public class UploadImageServlet extends HttpServlet {
             e.printStackTrace();
         }
 
+        // 创建一个Photo对象，用于封装要保存或更新到数据库中的照片相关信息，先设置照片的唯一标识（如学生学号等）
         Photo photo = new Photo();
         photo.setPhotoId(id);
+        // 设置照片的名称，使用前面处理后得到的新文件名
         photo.setPhotoName(newFileName);
-        PhotoService service = new PhotoServiceImpl();
 
+        // 创建PhotoService的实现类实例，用于调用业务逻辑层方法来处理照片数据在数据库中的保存或更新操作
+        PhotoService service = new PhotoServiceImpl();
 
-        Photo photo1= service.findPhotoByPhotoId(id);
-        if (photo1==null) {
+        // 通过业务逻辑层方法，根据照片的唯一标识（id）查找数据库中是否已经存在对应的照片记录
+        Photo photo1 = service.findPhotoByPhotoId(id);
+        // 如果查找结果为null，表示数据库中不存在该照片记录，则调用业务逻辑层的添加照片方法，将新的照片信息保存到数据库中
+        if (photo1 == null) {
             service.addPhoto(photo);
-        }else {
+        } else {
+            // 如果数据库中已经存在对应的照片记录，则调用业务逻辑层的更新照片方法，使用新的照片信息更新数据库中的记录
             service.updatePhoto(photo);
         }
-        request.setAttribute("update_msg", "上传成功！"+String.format("%tT",new Date()));
-//        request.getRequestDispatcher("/WEB-INF/index.jsp").forward(request, response);
+
+        // 在请求属性中设置"update_msg"属性，添加提示信息，说明上传成功，并带上当前的时间信息（通过String.format("%tT", new Date())格式化时间）
+        request.setAttribute("update_msg", "上传成功！" + String.format("%tT", new Date()));
+        // 将请求转发到"/WEB-INF/student/studentAddPhoto.jsp"页面，可能该页面用于显示上传结果等相关信息给用户
         request.getRequestDispatcher("/WEB-INF/student/studentAddPhoto.jsp").forward(request, response);
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会将请求转发到"/WEB-INF/student/studentAddPhoto.jsp"页面
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.getRequestDispatcher("/WEB-INF/student/studentAddPhoto.jsp").forward(request, response);
     }
-}
+}

src/web/servlet/file/UploadServlet.java

@@ -16,20 +16,37 @@ import org.apache.commons.fileupload.ProgressListener;
 import org.apache.commons.fileupload.disk.DiskFileItemFactory;
 import org.apache.commons.fileupload.servlet.ServletFileUpload;
 
+// 使用WebServlet注解将该类映射到"/uploadServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/uploadServlet")
 public class UploadServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数
         request.setCharacterEncoding("utf-8");
+        // 设置响应的字符编码为"utf-8"，确保响应内容中的中文等字符能正确显示
         response.setCharacterEncoding("utf-8");
+        // 设置响应的Content-Type为"text/html; charset=utf-8"，表明响应内容是HTML格式且字符编码为utf-8
         response.setContentType("text/html; charset=utf-8");
 
-
-        boolean isMultipart=ServletFileUpload.isMultipartContent(request);
+        // 判断提交上来的数据是否是符合文件上传表单的数据格式（通过请求的Content-Type等相关信息判断），
+        // 如果是则返回true，表示是文件上传请求
+        boolean isMultipart = ServletFileUpload.isMultipartContent(request);
         if (isMultipart) {
+            // 1、创建一个DiskFileItemFactory对象，它是Apache Commons FileUpload组件中用于创建文件项的工厂类，
+            // 可以配置一些与文件上传相关的底层参数（如临时文件存储等，此处使用默认配置）
             FileItemFactory factory = new DiskFileItemFactory();
+
+            // 2、创建一个ServletFileUpload对象，它是用于解析上传文件的核心类，通过传入前面创建的工厂对象来进行初始化，
+            // 后续可以使用它来解析HTTP请求中的文件上传相关内容
             ServletFileUpload upload = new ServletFileUpload(factory);
+            // 设置请求头的编码为"utf-8"，确保能正确解析包含中文等多字节字符的文件名等信息
             upload.setHeaderEncoding("utf-8");
 
+            // 以下代码被注释掉了，原本是用于设置文件上传进度监听器的功能。
+            // 当文件上传过程中，会根据读取的字节数、总字节数以及已处理的文件项数量等信息更新进度相关数据，
+            // 并将这些数据存放在一个自定义的ProcessInfo对象中，然后设置到请求的属性（hs，此处未定义应该是个错误，可能是想使用HttpSession，可根据实际情况修改）里，
+            // 方便前端页面获取并展示文件上传进度情况。
 //            upload.setProgressListener(new ProgressListener(){
 //                public void update(long pBytesRead, long pContentLength, int pItems) {
 //                    ProcessInfo pri = new ProcessInfo();
@@ -43,47 +60,71 @@ public class UploadServlet extends HttpServlet {
 //            });
 
             try {
+                // 使用ServletFileUpload对象解析HTTP请求，获取所有的文件项（FileItem）列表，每个FileItem对应一个表单中的文件上传字段或普通表单字段
                 List<FileItem> items = upload.parseRequest(request);
+                // 获取文件项列表的迭代器，用于遍历列表中的每个文件项
                 Iterator<FileItem> it = items.iterator();
                 while (it.hasNext()) {
+                    // 获取下一个文件项对象
                     FileItem item = it.next();
+                    // 获取文件项对应的表单字段名称
                     String itemname = item.getFieldName();
+                    // 初始化一个表示学号的变量，初始值设为 -1，用于后续根据表单字段判断并赋值
                     int sno = -1;
+                    // 初始化一个表示学生姓名的变量，初始值设为null，用于后续根据表单字段判断并赋值
                     String sname = null;
 
+                    // 判断该文件项是否是普通表单字段（非文件上传字段）
                     if (item.isFormField()) {
+                        // 如果表单字段名称为"sno"，则尝试将该字段的值解析为整数并赋值给sno变量，解析时指定字符编码为"utf-8"
                         if (itemname.equals("sno")) {
                             sno = Integer.parseInt(item.getString("utf-8"));
                         } else if (itemname.equals("sname")) {
+                            // 如果表单字段名称为"sname"，先获取该字段的值（字符编码为"utf-8"）并赋值给sname变量，
+                            // 然后又将文件名（这里可能存在逻辑错误，本意可能不是这样，应该是不需要再次赋值文件名，可根据实际需求确认）赋值给sname变量
                             sname = item.getString("utf-8");
                             sname = item.getName();
                         } else {
+                            // 如果是其他未处理的普通表单字段，则在控制台打印提示信息
                             System.out.println("其他字段");
                         }
                     } else {
+                        // 如果该文件项是文件上传字段，则获取文件名（包含完整路径，例如在客户端本地的完整路径）
                         String filename = item.getName();
-                        //String path=request.getSession().getServletContext().getRealPath("upload");
+                        // 获取服务器上用于保存上传文件的目录路径，通过Servlet上下文获取"upload"目录的真实路径
+                        // （此处注释掉的代码是通过请求的会话获取Servlet上下文再获取路径，可根据实际情况选择合适的方式，当前使用的是直接通过Servlet获取上下文的方式）
+                        // String path=request.getSession().getServletContext().getRealPath("upload");
                         String path = this.getServletContext().getRealPath("upload");
+
+                        // 判断文件名的后缀（通过截取文件名中最后一个点后面的部分并转换为小写后进行比较）是否是特定的网页文件格式（JSP、HTML、HTM等），
+                        // 如果是则表示不允许上传这类文件，将请求转发到"error.jsp"页面进行错误提示
                         if (filename.substring(filename.lastIndexOf(".") + 1).equals("jsp")
                                 || filename.substring(filename.lastIndexOf(".") + 1).equals("htm")
                                 || filename.substring(filename.lastIndexOf(".") + 1).equals("html")) {
                             request.getRequestDispatcher("error.jsp").forward(request, response);
                         } else {
+                            // 打印文件保存目录的路径（可能用于调试，查看路径是否正确）
                             System.out.println(path);
+                            // 根据保存路径创建对应的File对象，用于后续判断目录是否存在等操作
                             File file = new File(path);
-                            if (!file.exists() && !file.isDirectory()) {
+                            // 判断该目录是否不存在并且不是一个目录（可能不存在或者是个文件等不符合预期的情况），如果是则创建该目录
+                            if (!file.exists() &&!file.isDirectory()) {
                                 file.mkdir();
                             }
+                            // 将上传的文件写入到服务器指定的目录下，构造的文件对象是在前面确定的保存目录（path）基础上加上文件名（filename）
                             item.write(new File(path, filename));
+                            // 在请求属性中设置"news"属性，添加提示信息，说明文件上传成功，并带上文件名
                             request.setAttribute("news", filename + "  上传成功!");
+                            // 将请求转发到"/WEB-INF/admin/uploadFile.jsp"页面，可能该页面用于显示上传结果等相关信息给用户
                             request.getRequestDispatcher("/WEB-INF/admin/uploadFile.jsp").forward(request, response);
+                            // 以下代码被注释掉了，原本是用于重定向到另一个Servlet（可能用于跳转到文件上传后的其他操作页面等），
+                            // 重定向和转发的区别在于重定向会重新发起一个请求，而转发是在服务器内部直接跳转，可根据实际需求选择使用哪种方式。
 //                        response.sendRedirect("fileUploadIndexServlet");
+                            // 在控制台打印文件上传成功的提示信息，带上文件名（可能用于调试，查看上传情况）
                             System.out.println(filename + "上传成功!!!");
-
+                            return;
                         }
-                        return;
                     }
-
                 }
             } catch (FileUploadException e) {
                 e.printStackTrace();
@@ -93,7 +134,9 @@ public class UploadServlet extends HttpServlet {
         }
     }
 
-    class ProcessInfo{
+    // 定义一个内部类ProcessInfo，用于封装文件上传进度相关的信息，
+    // 包括总文件大小、已读取的文件大小、显示的进度字符串、已处理的文件项数量以及进度百分比等属性
+    class ProcessInfo {
         public long totalSize = 1;
         public long readSize = 0;
         public String show = "";
@@ -101,7 +144,8 @@ public class UploadServlet extends HttpServlet {
         public int rate = 0;
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }
-}
+}

src/web/servlet/index/AdminIndexServlet.java

@@ -7,12 +7,22 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/adminIndexServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 这里可能主要是针对管理员相关的页面索引请求进行处理的Servlet。
 @WebServlet("/adminIndexServlet")
 public class AdminIndexServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.getRequestDispatcher("/WEB-INF/admin/aIndex.jsp").forward(request,response);
+        // 将当前请求转发到"/WEB-INF/admin/aIndex.jsp"页面。
+        // 通常这个JSP页面可能是管理员功能模块对应的首页或者是一个主要的展示页面，
+        // 通过转发请求，服务器会去查找并渲染这个JSP页面，然后将生成的页面内容返回给客户端展示给用户。
+        request.getRequestDispatcher("/WEB-INF/admin/aIndex.jsp").forward(request, response);
     }
+
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 也就是当接收到GET请求时，同样会将请求转发到"/WEB-INF/admin/aIndex.jsp"页面。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/index/StudentIndexServlet.java

@@ -7,12 +7,22 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/studentIndexServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 大概率是针对学生相关页面索引请求进行处理的Servlet。
 @WebServlet("/studentIndexServlet")
 public class StudentIndexServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request,response);
+        // 将当前请求转发到"/WEB-INF/student/sIndex.jsp"页面。
+        // 一般来说，这个JSP页面是学生功能模块对应的首页或者核心展示页面，
+        // 通过转发请求，服务器会查找并渲染该JSP页面，之后把生成的页面内容返回给客户端，展示给学生用户查看。
+        request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request, response);
     }
+
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+        // 即当接收到GET请求时，同样会把请求转发到"/WEB-INF/student/sIndex.jsp"页面。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/index/TeacherIndexServlet.java

@@ -7,12 +7,22 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+// 使用WebServlet注解将此类映射到"/teacherIndexServlet"这个URL路径，意味着该Servlet类是用来处理与之对应的网络请求的，
+// 通常是针对教师相关页面的访问请求进行相应处理的类。
 @WebServlet("/teacherIndexServlet")
 public class TeacherIndexServlet extends HttpServlet {
+
+    // 重写doPost方法，该方法用于处理HTTP POST请求。
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.getRequestDispatcher("/WEB-INF/teacher/tIndex.jsp").forward(request,response);
+        // 将当前接收到的请求转发到"/WEB-INF/teacher/tIndex.jsp"页面。
+        // 一般来讲，这个JSP页面是教师功能模块对应的首页或者是主要展示页面，
+        // 服务器接收到转发请求后，会去查找并渲染这个JSP页面，随后将渲染好的页面内容返回给客户端，以便展示给教师用户查看。
+        request.getRequestDispatcher("/WEB-INF/teacher/tIndex.jsp").forward(request, response);
     }
+
+    // 重写doGet方法，在此类中，该方法直接调用doPost方法来处理GET请求，这表明GET请求和POST请求在本Servlet中的处理逻辑是完全一致的，
+        // 也就是当接收到GET请求时，同样会把请求转发到"/WEB-INF/teacher/tIndex.jsp"页面。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/login/FindStudentServlet.java

@@ -14,35 +14,65 @@ import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 
+// 使用WebServlet注解将该类映射到"/findStudentServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名推测，可能主要用于查找学生相关信息的功能。
 @WebServlet("/findStudentServlet")
 public class FindStudentServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置响应的Content-Type为"application/json;charset=utf-8"，表明响应内容将以JSON格式返回，并且字符编码为utf-8，
+        // 这样客户端（如前端页面中的JavaScript代码等）就能正确解析接收到的JSON数据。
         response.setContentType("application/json;charset=utf-8");
+
+        // 从请求中获取名为"studentid"的参数值，该参数应该是用于查找学生信息的学生ID，通常由前端页面传递过来。
         String studentId = request.getParameter("studentid");
+
+        // 创建两个Student对象，student对象用于设置要查找的学生ID条件，findStudent对象用于存储后续通过业务逻辑层查找得到的学生信息。
         Student student = new Student();
         Student findStudent = new Student();
+        // 将获取到的学生ID设置到student对象中，作为查找条件传递给业务逻辑层。
         student.setS_id(studentId);
+
+        // 创建StudentService的实现类实例，用于调用业务逻辑层方法来处理与学生相关的业务操作，
+        // 这里是通过学生ID查找对应的学生信息。
         StudentService service = new StudentServiceImpl();
+        // 调用业务逻辑层的findStudentById方法，传入设置好ID的student对象，将查找到的学生信息赋值给findStudent对象。
         findStudent = service.findStudentById(student);
-        Map<String,Object>map = new HashMap<String,Object>();
+
+        // 创建一个HashMap对象，用于存储要返回给客户端的相关信息，以键值对的形式进行存储，方便后续转换为JSON格式数据。
+        Map<String, Object> map = new HashMap<String, Object>();
 
         try {
+            // 判断获取到的学生ID（studentId）与查找到的学生对象（findStudent）中的ID是否相等，以此来判断该学生ID是否已存在对应的学生记录。
             if (studentId.equals(findStudent.getS_id())) {
+                // 如果相等，表示该学生ID已存在，在map中添加键值对，"studentExsit"键对应的值设为true，表示学生存在，
+                // 同时添加"msg"键，对应的值为提示信息"ID已存在"，这些信息将作为响应内容返回给客户端，方便客户端根据此信息进行相应处理（如提示用户等）。
                 map.put("studentExsit", true);
                 map.put("msg", "ID已存在");
             } else {
+                // 如果不相等，表示该学生ID不存在对应的学生记录，即用户名（这里以学生ID作为类似用户名的概念）可用，
+                // 在map中添加相应键值对，"studentExsit"键对应的值设为false，"msg"键对应的值设为"用户名可用"。
                 map.put("studentExsit", false);
                 map.put("msg", "用户名可用");
             }
-            //map转为json传给客户端
+
+            // 创建一个ObjectMapper对象，它是Jackson库中用于将Java对象转换为JSON格式数据的核心类，
+            // 这里将使用它把map对象转换为JSON格式，并写入到响应的输出流中，以便发送给客户端。
             ObjectMapper mapper = new ObjectMapper();
-            mapper.writeValue(response.getWriter(),map);
+            // 通过ObjectMapper的writeValue方法，将map对象转换为JSON格式的数据，并写入到HttpServletResponse的输出流中，
+            // 这样客户端就能接收到对应的JSON数据并进行解析和相应处理了。
+            mapper.writeValue(response.getWriter(), map);
         } catch (Exception e) {
+            // 如果在上述处理过程中出现异常（如JSON转换出错等情况），则打印异常堆栈信息，方便排查问题，
+            // 在实际应用中，可能还需要更完善的异常处理逻辑，比如返回特定的错误信息给客户端等。
             e.printStackTrace();
         }
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的逻辑，进行学生信息查找并返回相应的JSON格式结果给客户端。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/login/LoginServlet.java

@@ -25,109 +25,169 @@ import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 import java.util.Map;
 
+// 使用WebServlet注解将该类映射到"/loginServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名可以看出，主要负责处理用户登录相关的业务逻辑。
 @WebServlet("/loginServlet")
 public class LoginServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 初始化用于存储登录成功后的学生对象，初始值设为null，后续根据登录验证结果进行赋值
         Student loginStudent = null;
+        // 初始化用于存储登录成功后的教师对象，初始值设为null，后续根据登录验证结果进行赋值
         Teacher loginTeacher = null;
+        // 初始化用于存储登录成功后的管理员对象，初始值设为null，后续根据登录验证结果进行赋值
         Admin loginAdmin = null;
 
-        //设置编码
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数
         request.setCharacterEncoding("utf-8");
 
-        //获取数据
+        // 从请求中获取名为"verifycode"的参数值，该参数通常是用户在登录页面输入的验证码，用于后续验证码校验
         String verifycode = request.getParameter("verifycode");
+        // 从请求中获取名为"id"的参数值，该参数一般代表用户输入的登录账号（如学生学号、教师工号、管理员账号等），具体含义根据角色而定
         String loginid = request.getParameter("id");
+        // 从请求中获取名为"password"的参数值，该参数是用户输入的登录密码
         String loginpassword = request.getParameter("password");
 
-        //验证码校验
+        // 验证码校验相关逻辑
+        // 获取当前请求对应的HttpSession对象，用于获取会话中存储的验证码信息（之前生成并存储在会话中的验证码）
         HttpSession session = request.getSession();
+        // 从会话中获取名为"CHECKCODE_SERVER"的属性值，该值就是服务器端生成并存储的验证码，类型转换为String
         String checkcode_server = (String) session.getAttribute("CHECKCODE_SERVER");
-        session.removeAttribute("CHECKCODE_SERVER");//确保验证一次性
-        if (checkcode_server == null || !checkcode_server.equalsIgnoreCase(verifycode)) {
-            //验证码不正确
-            request.setAttribute("login_msg","验证码错误");
-            //跳转页面
-            request.setAttribute("loginid",loginid);
-            request.setAttribute("loginpassword",loginpassword);
-            request.getRequestDispatcher("/login.jsp").forward(request,response);
+        // 移除会话中的"CHECKCODE_SERVER"属性，确保验证码只能使用一次，防止重复利用
+        session.removeAttribute("CHECKCODE_SERVER");
+
+        // 判断服务器端存储的验证码是否为null（可能出现异常情况未生成验证码等），或者与用户输入的验证码不相等（不区分大小写进行比较），
+        // 如果满足此条件，则表示验证码不正确
+        if (checkcode_server == null ||!checkcode_server.equalsIgnoreCase(verifycode)) {
+            // 在请求属性中设置"login_msg"属性，添加提示信息，说明验证码错误，用于后续在页面上展示给用户
+            request.setAttribute("login_msg", "验证码错误");
+            // 在请求属性中设置"loginid"属性，将用户输入的登录账号再次存入请求属性，方便在返回登录页面时可以回显给用户
+            request.setAttribute("loginid", loginid);
+            // 在请求属性中设置"loginpassword"属性，将用户输入的登录密码再次存入请求属性，方便在返回登录页面时可以回显给用户
+            request.setAttribute("loginpassword", loginpassword);
+            // 将请求转发到"/login.jsp"页面，通常这个页面就是登录页面，返回给用户并展示验证码错误的提示信息以及回显账号密码等内容
+            request.getRequestDispatcher("/login.jsp").forward(request, response);
             return;
         }
-        //封装对象
+
+        // 封装对象相关逻辑
+        // 再次从请求中获取名为"id"的参数值，此处代码可能存在重复获取的情况（前面已经获取过loginid，可根据实际情况优化），该值用于构建用户对象的标识属性
         String id = request.getParameter("id");
+        // 再次从请求中获取名为"password"的参数值，此处代码可能存在重复获取的情况（前面已经获取过loginpassword，可根据实际情况优化），该值用于构建用户对象的密码属性
         String password = request.getParameter("password");
+        // 从请求中获取名为"roles"的参数值，该参数用于区分用户的角色（如"student"表示学生、"teacher"表示教师、"admin"表示管理员），以便后续进行不同角色的登录验证逻辑
         String roles = request.getParameter("roles");
 
-        //公告加载
-        NotifyService notifyService= new NotifyServiceImpl();
+        // 公告加载相关逻辑
+        // 创建NotifyService的实现类实例，用于调用业务逻辑层方法来获取公告相关信息，这里应该是获取所有的公告列表
+        NotifyService notifyService = new NotifyServiceImpl();
+        // 调用业务逻辑层的find方法，获取公告列表数据，返回的是Notify类型的列表
         List<Notify> notifys = notifyService.find();
-        session.setAttribute("notifys",notifys);
+        // 将获取到的公告列表存放到HttpSession中，属性名为"notifys"，方便在后续页面中（不同角色登录后的页面）可以获取并展示公告信息
+        session.setAttribute("notifys", notifys);
 
-        //判断roles封装对象、保存session、调用不同Service查询
+        // 根据不同角色进行登录验证、对象封装、会话保存以及页面跳转等逻辑处理
         if ("student".equals(roles)) {
-
+            // 创建一个Student对象，用于封装学生登录相关的信息，作为传递给业务逻辑层进行登录验证的数据对象
             Student student = new Student();
+            // 设置学生对象的学号属性，使用前面获取到的id值
             student.setS_id(id);
+            // 设置学生对象的密码属性，使用前面获取到的password值
             student.setS_password(password);
 
-            StudentService service= new StudentServiceImpl();
+            // 创建StudentService的实现类实例，用于调用业务逻辑层中与学生登录相关的方法
+            StudentService service = new StudentServiceImpl();
+            // 调用业务逻辑层的login方法，传入封装好的学生对象，进行登录验证，将验证通过后返回的学生对象赋值给loginStudent变量（如果验证失败则为null）
             loginStudent = service.login(student);
 
-            if (loginStudent != null) {
+            // 判断登录验证是否成功，即loginStudent不为null，表示找到了对应的学生记录，登录成功
+            if (loginStudent!= null) {
+                // 将登录成功的学生对象存放到HttpSession中，属性名为"student"，方便后续在其他页面判断用户是否登录以及获取学生相关信息
                 session.setAttribute("student", loginStudent);
+                // 在会话中设置"html_title"属性，值为"学生端"，可能用于在页面上显示不同的标题栏等内容，标识当前处于学生端页面
                 session.setAttribute("html_title", "学生端");
-//                request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request,response);
+                // 重定向到"studentIndexServlet"，通常这个Servlet会将请求转发到学生端对应的首页（如"/WEB-INF/student/sIndex.jsp"等页面），实现登录成功后跳转到学生端首页的功能
+                // （此处注释掉了直接转发的代码，选择使用重定向方式，重定向会重新发起一个请求，而转发是在服务器内部直接跳转，两者有不同的应用场景和效果）
+//                request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request, response);
                 response.sendRedirect("studentIndexServlet");
-            }else {
-                //登录失败 提示信息
+            } else {
+                // 如果登录验证失败，即loginStudent为null，表示用户名或密码错误等情况
+                // 在请求属性中设置"login_msg"属性，添加提示信息，说明用户名或密码错误，用于后续在登录页面展示给用户
                 request.setAttribute("login_msg", "用户名或密码错误！");
-                request.setAttribute("loginid",loginid);
-                request.setAttribute("loginpassword",loginpassword);
+                // 在请求属性中设置"loginid"属性，将用户输入的登录账号再次存入请求属性，方便在返回登录页面时可以回显给用户
+                request.setAttribute("loginid", loginid);
+                // 在请求属性中设置"loginpassword"属性，将用户输入的登录密码再次存入请求属性，方便在返回登录页面时可以回显给用户
+                request.setAttribute("loginpassword", loginpassword);
+                // 将请求转发到"/login.jsp"页面，返回登录页面并展示错误提示信息以及回显账号密码等内容
                 request.getRequestDispatcher("/login.jsp").forward(request, response);
             }
-        }else if ("teacher".equals(roles)) {
-
+        } else if ("teacher".equals(roles)) {
+            // 创建一个Teacher对象，用于封装教师登录相关的信息，作为传递给业务逻辑层进行登录验证的数据对象
             Teacher teacher = new Teacher();
+            // 设置教师对象的教师编号属性，使用前面获取到的id值
             teacher.setT_id(id);
+            // 设置教师对象的密码属性，使用前面获取到的password值
             teacher.setT_password(password);
 
+            // 创建TeacherService的实现类实例，用于调用业务逻辑层中与教师登录相关的方法
             TeacherService service = new TeacherServiceImpl();
+            // 调用业务逻辑层的login方法，传入封装好的教师对象，进行登录验证，将验证通过后返回的教师对象赋值给loginTeacher变量（如果验证失败则为null）
             loginTeacher = service.login(teacher);
 
-            if (loginTeacher != null) {
+            // 判断登录验证是否成功，即loginTeacher不为null，表示找到了对应的教师记录，登录成功
+            if (loginTeacher!= null) {
+                // 将登录成功的教师对象存放到HttpSession中，属性名为"teacher"，方便后续在其他页面判断用户是否登录以及获取教师相关信息
                 session.setAttribute("teacher", loginTeacher);
+                // 在会话中设置"html_title"属性，值为"教师端"，可能用于在页面上显示不同的标题栏等内容，标识当前处于教师端页面
                 session.setAttribute("html_title", "教师端");
+                // 重定向到"teacherIndexServlet"，通常这个Servlet会将请求转发到教师端对应的首页（如"/WEB-INF/teacher/tIndex.jsp"等页面），实现登录成功后跳转到教师端首页的功能
+                // （此处注释掉了直接转发的代码，选择使用重定向方式）
 //                request.getRequestDispatcher("/WEB-INF/teacher/tIndex.jsp").forward(request, response);
                 response.sendRedirect("teacherIndexServlet");
-            }else {
-                //登录失败 提示信息
+            } else {
+                // 如果登录验证失败，即loginTeacher为null，表示用户名或密码错误等情况
+                // 在请求属性中设置"login_msg"属性，添加提示信息，说明用户名或密码错误，用于后续在登录页面展示给用户
                 request.setAttribute("login_msg", "用户名或密码错误！");
+                // 将请求转发到"/login.jsp"页面，返回登录页面并展示错误提示信息
                 request.getRequestDispatcher("/login.jsp").forward(request, response);
             }
-
-        }else {
-
+        } else {
+            // 创建一个Admin对象，用于封装管理员登录相关的信息，作为传递给业务逻辑层进行登录验证的数据对象
             Admin admin = new Admin();
+            // 设置管理员对象的管理员编号属性，使用前面获取到的id值
             admin.setA_id(id);
+            // 设置管理员对象的密码属性，使用前面获取到的password值
             admin.setA_password(password);
 
+            // 创建AdminService的实现类实例，用于调用业务逻辑层中与管理员登录相关的方法
             AdminService service = new AdminServiceImpl();
+            // 调用业务逻辑层的login方法，传入封装好的管理员对象，进行登录验证，将验证通过后返回的管理员对象赋值给loginAdmin变量（如果验证失败则为null）
             loginAdmin = service.login(admin);
 
-            if (loginAdmin != null) {
+            // 判断登录验证是否成功，即loginAdmin不为null，表示找到了对应的管理员记录，登录成功
+            if (loginAdmin!= null) {
+                // 将登录成功的管理员对象存放到HttpSession中，属性名为"admin"，方便后续在其他页面判断用户是否登录以及获取管理员相关信息
                 session.setAttribute("admin", loginAdmin);
+                // 在会话中设置"html_title"属性，值为"管理员"，可能用于在页面上显示不同的标题栏等内容，标识当前处于管理员页面
                 session.setAttribute("html_title", "管理员");
-//                request.getRequestDispatcher("/WEB-INF/admin/aIndex.jsp").forward(request,response);
+                // 重定向到"adminIndexServlet"，通常这个Servlet会将请求转发到管理员端对应的首页（如"/WEB-INF/admin/aIndex.jsp"等页面），实现登录成功后跳转到管理员端首页的功能
+                // （此处注释掉了直接转发的代码，选择使用重定向方式）
+//                request.getRequestDispatcher("/WEB-INF/admin/aIndex.jsp").forward(request, response);
                 response.sendRedirect("adminIndexServlet");
-            }else {
-                //登录失败 提示信息
+            } else {
+                // 如果登录验证失败，即loginAdmin为null，表示用户名或密码错误等情况
+                // 在请求属性中设置"login_msg"属性，添加提示信息，说明用户名或密码错误，用于后续在登录页面展示给用户
                 request.setAttribute("login_msg", "用户名或密码错误！");
+                // 将请求转发到"/login.jsp"页面，返回登录页面并展示错误提示信息
                 request.getRequestDispatcher("/login.jsp").forward(request, response);
             }
         }
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的登录验证等相关逻辑
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/login/LogoutServlet.java

@@ -8,19 +8,44 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/logoutServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名可以推断出其主要功能是处理用户注销相关的业务逻辑。
 @WebServlet("/logoutServlet")
 public class LogoutServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"UTF-8"，确保能正确解析包含中文等多字节字符的请求参数（虽然此处可能没有特别涉及中文相关参数，但保持良好的编码设置习惯是必要的）。
         request.setCharacterEncoding("UTF-8");
+
+        // 获取当前请求对应的HttpSession对象，HttpSession用于在多个请求之间保存用户相关的会话信息，
+        // 在这里主要是为了操作会话中存储的用户登录相关的属性信息，以便实现注销功能。
         HttpSession session = request.getSession();
+
+        // 从会话中移除名为"student"的属性，该属性通常在用户（学生角色）登录成功后被设置，用于标识当前登录的学生用户信息，
+        // 移除它意味着清除该用户（学生角色）在会话中的相关登录状态信息。
         session.removeAttribute("student");
+
+        // 从会话中移除名为"teacher"的属性，同理，该属性是在教师角色用户登录成功后设置的，用于保存教师用户的相关信息，
+        // 移除操作清除教师角色用户在会话中的登录状态相关数据。
         session.removeAttribute("teacher");
+
+        // 从会话中移除名为"admin"的属性，这是针对管理员角色用户登录成功后在会话中保存的相关信息，
+        // 通过移除该属性，消除管理员角色用户的会话登录状态记录。
         session.removeAttribute("admin");
+
+        // 使当前会话失效，这一步操作会清除整个会话中的所有属性信息，并且后续该会话相关的请求将无法再获取到之前存储的任何数据，
+        // 相当于彻底结束了当前用户的会话，实现完整的注销效果。
         session.invalidate();
+
+        // 重定向到"index.jsp"页面，通常这个页面是网站的首页或者是一个未登录状态下展示的通用页面，
+        // 在用户注销后将其引导到这个页面，让用户回到初始状态或者未登录时可访问的页面。
         response.sendRedirect("index.jsp");
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的操作，完成用户注销并跳转到相应页面的功能。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/login/RegisterServlet.java

@@ -6,45 +6,87 @@ import service.impl.StudentServiceImpl;
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
-import javax.servlet.http.*;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/registerServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名可推测其主要功能是处理学生用户注册相关的业务逻辑。
 @WebServlet("/registerServlet")
 public class RegisterServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 获取当前请求对应的HttpSession对象，HttpSession用于在多个请求之间保存用户相关的会话信息，
+        // 在这里主要用于获取之前存储在会话中的验证码信息以及后续可能的其他与注册相关的会话操作。
         HttpSession session = request.getSession();
+
+        // 从请求中获取名为"studentid"的参数值，该参数通常代表学生注册时输入的学号，作为学生的唯一标识信息。
         String studentid = request.getParameter("studentid");
+        // 从请求中获取名为"password"的参数值，此参数为学生注册时输入的密码。
         String password = request.getParameter("password");
+        // 从请求中获取名为"repassword"的参数值，一般是用于让学生再次输入密码进行确认，确保两次输入的密码一致。
         String repassword = request.getParameter("repassword");
+        // 从请求中获取名为"verifycode"的参数值，该参数是学生在注册页面输入的验证码，用于后续的验证码校验环节。
         String vcode = request.getParameter("verifycode");
 
+        // 从会话中获取名为"CHECKCODE_SERVER"的属性值，该值就是服务器端生成并存储的验证码，类型转换为String类型，
+        // 用于和用户输入的验证码（vcode）进行对比验证。
         String checkcode_server = (String) session.getAttribute("CHECKCODE_SERVER");
-        session.removeAttribute("CHECKCODE_SERVER");//确保验证一次性
-        if (!vcode.equalsIgnoreCase(checkcode_server)){
-            request.setAttribute("msg","验证码错误");
-            request.setAttribute("studentid",studentid);
-            request.setAttribute("password",password);
-            request.setAttribute("repassword",repassword);
-            request.getRequestDispatcher("register.jsp").forward(request,response);
+        // 移除会话中的"CHECKCODE_SERVER"属性，确保验证码只能使用一次，防止用户重复利用验证码进行多次注册等异常操作，
+        // 保证验证码验证的一次性原则。
+        session.removeAttribute("CHECKCODE_SERVER");
+
+        // 判断用户输入的验证码（vcode）与服务器端存储的验证码（checkcode_server）是否不相等（不区分大小写进行比较），
+        // 如果不相等，则表示验证码错误。
+        if (!vcode.equalsIgnoreCase(checkcode_server)) {
+            // 在请求属性中设置"msg"属性，添加提示信息"验证码错误"，用于后续在注册页面上展示给用户，提示验证码输入有误。
+            request.setAttribute("msg", "验证码错误");
+            // 在请求属性中设置"studentid"属性，将用户输入的学号再次存入请求属性，方便在返回注册页面时可以回显给用户，
+            // 让用户无需重新输入学号，提升用户体验。
+            request.setAttribute("studentid", studentid);
+            // 在请求属性中设置"password"属性，将用户输入的密码再次存入请求属性，同样方便在返回注册页面时回显密码内容给用户。
+            request.setAttribute("password", password);
+            // 在请求属性中设置"repassword"属性，把用户再次输入用于确认的密码也存入请求属性，回显在注册页面上。
+            request.setAttribute("repassword", repassword);
+            // 将请求转发到"register.jsp"页面，通常这个页面就是学生注册页面，返回给用户并展示验证码错误的提示信息以及回显之前输入的相关内容。
+            request.getRequestDispatcher("register.jsp").forward(request, response);
             return;
-        }else {
+        } else {
+            // 如果验证码验证通过，则创建一个Student对象，用于封装要注册的学生相关信息，准备传递给业务逻辑层进行注册操作。
             Student student = new Student();
+            // 设置学生对象的学号属性，使用前面获取到的studentid值。
             student.setS_id(studentid);
+            // 设置学生对象的密码属性，使用前面获取到的password值。
             student.setS_password(password);
+            // 打印学号信息（可能用于调试，查看获取到的学号是否正确等情况），在实际应用中可根据需求决定是否保留此打印语句。
             System.out.println(studentid);
+            // 打印密码信息（同样可能用于调试目的），查看密码获取情况，可按需决定是否保留。
             System.out.println(password);
-            StudentService service= new StudentServiceImpl();
+
+            // 创建StudentService的实现类实例，用于调用业务逻辑层中与学生注册相关的方法，将学生注册信息保存到数据库等相关操作。
+            StudentService service = new StudentServiceImpl();
+            // 调用业务逻辑层的register方法，传入封装好的学生对象，执行学生注册操作。
             service.register(student);
-            request.setAttribute("msg","注册成功");
-            request.setAttribute("studentid","");
-            request.setAttribute("password","");
-            request.setAttribute("repassword","");
-            request.getRequestDispatcher("register.jsp").forward(request,response);
 
+            // 在请求属性中设置"msg"属性，添加提示信息"注册成功"，用于后续在注册页面展示给用户，告知注册操作已成功完成。
+            request.setAttribute("msg", "注册成功");
+            // 在请求属性中设置"studentid"属性为空字符串，清空之前存储的学号信息，可能用于在注册页面上显示相应的提示效果（比如清空输入框等）。
+            request.setAttribute("studentid", "");
+            // 在请求属性中设置"password"属性为空字符串，同样清空之前存储的密码信息，用于页面显示相关的处理。
+            request.setAttribute("password", "");
+            // 在请求属性中设置"repassword"属性为空字符串，清空再次输入确认密码的内容，配合页面显示需求进行处理。
+            request.setAttribute("repassword", "");
+            // 将请求转发到"register.jsp"页面，返回注册页面并展示注册成功的提示信息以及清空相关输入框等操作，方便用户进行后续操作（比如登录等）。
+            request.getRequestDispatcher("register.jsp").forward(request, response);
         }
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的注册相关逻辑操作。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/notify/AddNotifyServlet.java

@@ -17,23 +17,49 @@ import java.util.Date;
 import java.util.List;
 import java.util.Map;
 
+// 使用WebServlet注解将该类映射到"/addNotifyServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名推测其主要功能是处理添加通知相关的业务逻辑。
 @WebServlet("/addNotifyServlet")
 public class AddNotifyServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数，
+        // 这样在获取请求中的通知内容等信息时可以避免出现乱码等问题。
         request.setCharacterEncoding("utf-8");
 
-        //获取参数
+        // 获取参数相关逻辑
+        // 创建一个Notify对象，用于封装要添加的通知相关信息，后续会将其传递给业务逻辑层进行保存到数据库等操作。
         Notify notify = new Notify();
+        // 从请求中获取名为"notifyInfo"的参数值，该参数应该是通知的具体内容信息，将其设置到Notify对象的相应属性中。
         notify.setNotifyInfo((String) request.getParameter("notifyInfo"));
+
+        // 设置通知的发布时间，先获取当前的系统时间，通过创建一个Date对象来表示当前时刻。
         Date d = new Date();
+        // 创建一个SimpleDateFormat对象，用于对日期进行格式化，指定的格式为"yyyy-MM-dd HH:mm:ss"，
+        // 这样可以将日期按照指定的格式转换为字符串，方便存储和展示。
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        // 使用格式化对象将获取到的当前日期（Date类型）格式化为指定格式的字符串，并设置到Notify对象的发布时间属性（notifyDate）中，
+        // 表示该通知的发布时间为当前系统时间。
         notify.setNotifyDate(sdf.format(d));
+
+        // 创建NotifyService的实现类实例，用于调用业务逻辑层中与添加通知相关的方法，
+        // 这里的实现类会负责将封装好的通知对象保存到数据库等具体操作。
         NotifyService service = new NotifyServiceImpl();
+        // 调用业务逻辑层的addNotify方法，传入封装好的Notify对象，执行添加通知的操作，将通知信息保存到数据库中。
         service.addNotify(notify);
-//        response.sendRedirect("/notifyListServlet");
-        request.getRequestDispatcher("/notifyListServlet").forward(request,response);
+
+        // 以下代码被注释掉了，原本是使用重定向的方式跳转到"/notifyListServlet"，重定向会重新发起一个请求，客户端会向新的URL发起请求。
+        // response.sendRedirect("/notifyListServlet");
+
+        // 采用请求转发的方式将当前请求转发到"/notifyListServlet"，请求转发是在服务器内部进行跳转，相对重定向来说更高效，
+        // 转发到的"/notifyListServlet"通常可能是用于展示通知列表的Servlet，这样在添加通知成功后可以直接展示最新的通知列表情况。
+        request.getRequestDispatcher("/notifyListServlet").forward(request, response);
     }
+
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的添加通知相关逻辑操作。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/notify/DeleteNotifyServlet.java

@@ -1,4 +1,4 @@
-package web.servlet.notify;
+、package web.servlet.notify;
 
 import domain.Student;
 import service.NotifyService;
@@ -12,18 +12,39 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/deleteNotifyServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名可以推断出其主要功能是处理删除通知相关的业务逻辑。
 @WebServlet("/deleteNotifyServlet")
 public class DeleteNotifyServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数，
+        // 虽然此处不一定涉及中文参数，但保持良好的编码设置习惯有助于避免潜在的乱码问题。
         request.setCharacterEncoding("utf-8");
+
+        // 获取当前请求对应的HttpSession对象，HttpSession用于在多个请求之间保存用户相关的会话信息，
+        // 不过在这段代码中暂时未看到对会话信息有进一步的操作，可根据实际业务需求后续考虑是否添加相关逻辑。
         HttpSession session = request.getSession();
+
+        // 从请求中获取名为"id"的参数值，该参数应该是用于标识要删除的通知的唯一ID，
+        // 通常在前端页面（如通知列表页面）点击删除操作时会将对应通知的ID传递过来。
         String notifyid = request.getParameter("id");
+
+        // 创建NotifyService的实现类实例，用于调用业务逻辑层中与删除通知相关的方法，
+        // 这个实现类会负责根据传入的通知ID，在数据库等存储介质中执行删除对应通知记录的操作。
         NotifyService service = new NotifyServiceImpl();
+        // 调用业务逻辑层的deleteNotifyById方法，传入获取到的通知ID（notifyid），执行删除通知的操作，将对应的通知记录从数据库中移除。
         service.deleteNotifyById(notifyid);
-        request.getRequestDispatcher("/notifyListServlet").forward(request,response);
+
+        // 将当前请求转发到"/notifyListServlet"，通常这个Servlet是用于展示通知列表的，
+        // 这样在删除通知成功后，可以直接跳转到通知列表页面，展示最新的通知列表情况（已删除指定通知后的列表）。
+        request.getRequestDispatcher("/notifyListServlet").forward(request, response);
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的删除通知相关逻辑操作。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/notify/NotifyListServlet.java

@@ -12,16 +12,36 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
 
+// 使用WebServlet注解将该类映射到"/notifyListServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名可以推测出其主要功能是获取通知列表信息，并将其展示到对应的页面上，用于处理通知列表相关的业务逻辑。
 @WebServlet("/notifyListServlet")
 public class NotifyListServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数，
+        // 例如通知内容等可能包含中文信息，设置编码可以避免出现乱码情况，使后续操作能正常进行。
         request.setCharacterEncoding("utf-8");
+
+        // 创建NotifyService的实现类实例，用于调用业务逻辑层中与获取通知列表相关的方法，
+        // 该实现类具体会去数据库或者其他存储介质中查询并获取所有的通知信息。
         NotifyService service = new NotifyServiceImpl();
+        // 调用业务逻辑层的findAll方法，获取所有通知的列表信息，返回的是一个Notify类型的列表，
+        // 其中每个Notify对象代表一条通知记录，包含通知的各项属性（如通知内容、发布时间等）。
         List<Notify> notifys = service.findAll();
-        request.setAttribute("notifys",notifys);
-        request.getRequestDispatcher("/WEB-INF/notify/notifyList.jsp").forward(request,response);
+
+        // 将获取到的通知列表信息存放到请求的属性中，属性名为"notifys"，这样在后续转发到的JSP页面中，
+        // 就可以通过相应的方式（如EL表达式、JSTL标签等）获取该属性值，进而展示通知列表的具体内容。
+        request.setAttribute("notifys", notifys);
+
+        // 将当前请求转发到"/WEB-INF/notify/notifyList.jsp"页面，通常这个JSP页面就是用于展示通知列表的页面，
+        // 服务器会查找并渲染该JSP页面，然后把生成的页面内容返回给客户端进行展示，用户就能看到通知列表了。
+        request.getRequestDispatcher("/WEB-INF/notify/notifyList.jsp").forward(request, response);
     }
+
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的获取通知列表并展示到对应页面的相关逻辑操作。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/notify/NotifyListToServlet.java

@@ -16,28 +16,57 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
 
+// 使用WebServlet注解将该类映射到"/notifyListToServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名推测其主要功能可能是根据不同用户角色来展示相应的通知列表，处理与通知列表展示定向相关的业务逻辑。
 @WebServlet("/notifyListToServlet")
 public class NotifyListToServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数，
+        // 例如通知的具体内容等可能存在中文信息，设置合适编码可避免出现乱码问题，保障后续操作顺利进行。
         request.setCharacterEncoding("utf-8");
+
+        // 创建NotifyService的实现类实例，用于调用业务逻辑层中与获取通知列表相关的方法，
+        // 该实现类内部通常会去数据库或者其他存储位置查询并获取所有的通知信息记录。
         NotifyService service = new NotifyServiceImpl();
+        // 调用业务逻辑层的findAll方法，获取全部通知的列表数据，返回的是一个Notify类型的列表，
+        // 其中每个Notify对象都包含了一条通知的各项详细信息，比如通知内容、发布时间等。
         List<Notify> notifys = service.findAll();
-        request.setAttribute("notifys",notifys);
+        // 将获取到的通知列表信息存放在请求的属性中，属性名为"notifys"，这样在后续转发请求到相应页面时，
+        // 目标页面（如JSP页面）就可以通过相应的方式（例如EL表达式、JSTL标签等）获取到这个属性值，进而展示具体的通知列表内容。
+        request.setAttribute("notifys", notifys);
 
+        // 获取当前请求对应的HttpSession对象，HttpSession用于在多个请求之间保存用户相关的会话信息，
+        // 这里主要是为了获取会话中存储的用户登录相关信息，以便判断当前登录用户的角色，进而决定通知列表展示的具体页面。
         HttpSession session = request.getSession();
-        Student student= (Student)session.getAttribute("student");
-        Teacher teacher= (Teacher)session.getAttribute("teacher");
-        if (student != null && teacher == null) {
-            request.getRequestDispatcher("/WEB-INF/notify/notifyListToStudent.jsp").forward(request,response);
-        } else if (teacher != null && student == null) {
-            request.getRequestDispatcher("/WEB-INF/notify/notifyListToTeacher.jsp").forward(request,response);
+
+        // 尝试从会话中获取Student类型的用户对象，如果获取到了，表示当前登录用户是学生角色，否则返回null，
+        Student student = (Student) session.getAttribute("student");
+        // 尝试从会话中获取Teacher类型的用户对象，如果获取到了，表示当前登录用户是教师角色，否则返回null，
+        Teacher teacher = (Teacher) session.getAttribute("teacher");
+
+        // 根据获取到的学生和教师对象情况（即判断用户角色）来决定转发请求到不同的页面展示通知列表。
+        if (student!= null && teacher == null) {
+            // 如果学生对象不为null且教师对象为null，说明当前登录用户是学生角色，
+            // 则将请求转发到"/WEB-INF/notify/notifyListToStudent.jsp"页面，通常这个页面是专门为学生定制的通知列表展示页面，
+            // 会根据学生的相关特点和需求展示通知内容等信息。
+            request.getRequestDispatcher("/WEB-INF/notify/notifyListToStudent.jsp").forward(request, response);
+        } else if (teacher!= null && student == null) {
+            // 如果教师对象不为null且学生对象为null，意味着当前登录用户是教师角色，
+            // 此时将请求转发到"/WEB-INF/notify/notifyListToTeacher.jsp"页面，该页面应该是针对教师设计的通知列表展示页面，
+            // 会以适合教师查看的方式呈现通知信息。
+            request.getRequestDispatcher("/WEB-INF/notify/notifyListToTeacher.jsp").forward(request, response);
         } else {
+            // 如果既不是学生角色也不是教师角色（比如可能是管理员角色或者未登录等其他情况），
+            // 则将请求转发到"error.jsp"页面，这个页面一般用于展示错误提示信息，告知用户出现了不符合预期的情况（此处可能是角色不明确无法正确展示通知列表）。
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
-
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的根据用户角色来决定通知列表展示页面的相关逻辑操作。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/notify/NotifyServlet.java

@@ -7,13 +7,22 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/notifyServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名及代码逻辑来看，大概率是用于引导用户进入通知相关操作页面的功能，比如添加通知等页面。
 @WebServlet("/notifyServlet")
 public class NotifyServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.getRequestDispatcher("/WEB-INF/notify/addNotify.jsp").forward(request,response);
+        // 将当前请求转发到"/WEB-INF/notify/addNotify.jsp"页面。
+        // 通常这个JSP页面是用于展示添加通知的表单界面，用户可以在该页面上填写通知的具体内容等相关信息，
+        // 然后通过后续的操作（比如提交表单）来触发添加通知的实际业务逻辑。
+        request.getRequestDispatcher("/WEB-INF/notify/addNotify.jsp").forward(request, response);
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 也就是当接收到GET请求时，同样会将请求转发到"/WEB-INF/notify/addNotify.jsp"页面。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/page/FindStudentByPageServlet.java

@@ -16,46 +16,101 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.Map;
 
+// 使用WebServlet注解将该类映射到"/findStudentByPageServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名推测其主要功能是实现按照分页的方式查找学生信息，并根据不同用户角色将查询结果展示到相应页面的业务逻辑。
 @WebServlet("/findStudentByPageServlet")
 public class FindStudentByPageServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数，
+        // 例如学生相关信息中可能存在中文内容（姓名等），设置编码可避免出现乱码问题，使后续操作能正常进行。
         request.setCharacterEncoding("utf-8");
-        String currentPage = request.getParameter("currentPage");//当前页码
-        String rows = request.getParameter("rows");//每页显示条数
 
+        // 从请求中获取名为"currentPage"的参数值，该参数代表当前页码，用于确定要获取哪一页的数据，
+        // 通常由前端页面（如分页导航栏等）传递过来，告知后端当前用户请求查看的是第几页的学生信息。
+        String currentPage = request.getParameter("currentPage");
+
+        // 从请求中获取名为"rows"的参数值，该参数表示每页显示的记录条数，即每页展示多少条学生信息，
+        // 同样是由前端页面根据用户设置（如每页显示10条、20条等选择）传递给后端的参数。
+        String rows = request.getParameter("rows");
+
+        // 判断当前页码参数是否为null或者是空字符串，如果是，则说明前端没有传递或者传递的值不符合要求，
+        // 此时默认将当前页码设置为"1"，表示展示第一页的数据。
         if (currentPage == null || "".equals(currentPage)) {
             currentPage = "1";
         }
+
+        // 类似地，判断每页显示条数参数是否为null或者是空字符串，若满足此情况，
+        // 则默认将每页显示条数设置为"5"，即每页展示5条学生信息。
         if (rows == null || "".equals(rows)) {
             rows = "5";
         }
 
-        //获取条件查询参数
-        Map<String,String[]> condition = request.getParameterMap();
+        // 获取条件查询参数相关逻辑
+        // 通过调用request.getParameterMap()方法获取请求中所有的参数，以Map的形式返回，
+        // 其中键为参数名，值为对应参数名的所有值（以字符串数组形式存储，因为一个参数名可能对应多个值情况），
+        // 这些参数可用于构建更复杂的条件查询（比如根据学生姓名、学号范围等条件进行筛选查找学生信息）。
+        Map<String, String[]> condition = request.getParameterMap();
 
+        // 创建StudentService的实现类实例，用于调用业务逻辑层中与按页查找学生信息相关的方法，
+        // 该实现类会根据传入的当前页码、每页显示条数以及查询条件等参数，从数据库等存储介质中获取相应的学生信息数据。
         StudentService service = new StudentServiceImpl();
-        PageBean<Student> pb =  service.findStudentByPage(currentPage,rows,condition);
 
-        request.setAttribute("pb",pb);
-        request.setAttribute("condition",condition);//存入查询条件
+        // 调用业务逻辑层的findStudentByPage方法，传入当前页码、每页显示条数以及查询条件参数，
+        // 执行分页查找学生信息的操作，返回的是一个PageBean类型的对象，其中封装了查询到的学生信息列表、总记录数、总页数等分页相关的数据。
+        PageBean<Student> pb = service.findStudentByPage(currentPage, rows, condition);
+
+        // 将获取到的包含学生信息分页数据的PageBean对象存放到请求的属性中，属性名为"pb"，
+        // 这样在后续转发到的相应页面（如JSP页面）中，就可以通过相应方式（如EL表达式、JSTL标签等）获取该属性值，进而展示分页的学生信息列表等内容。
+        request.setAttribute("pb", pb);
+
+        // 将获取到的查询条件参数Map也存放到请求的属性中，属性名为"condition"，
+        // 方便在页面上可以根据之前设置的查询条件进行展示（比如回显用户之前输入的筛选条件等），或者用于后续再次发起查询等操作。
+        request.setAttribute("condition", condition);
+
+        // 再次设置请求的字符编码为"utf-8"，此处可能存在重复设置编码的情况，可根据实际情况确认是否需要保留（一般设置一次即可保证编码正确）。
         request.setCharacterEncoding("utf-8");
+
+        // 获取当前请求对应的HttpSession对象，HttpSession用于在多个请求之间保存用户相关的会话信息，
+        // 这里主要是为了获取会话中存储的用户登录相关信息，以便判断当前登录用户的角色，进而决定将查询结果展示到哪个对应的页面。
         HttpSession session = request.getSession();
-        Student student= (Student)session.getAttribute("student");
 
-        Admin admin= (Admin)session.getAttribute("admin");
-        Teacher teacher= (Teacher)session.getAttribute("teacher");
-        if (student != null && admin == null && teacher == null) {
+        // 尝试从会话中获取Student类型的用户对象，如果获取到了，表示当前登录用户是学生角色，否则返回null，
+        Student student = (Student) session.getAttribute("student");
+
+        // 尝试从会话中获取Admin类型的用户对象，如果获取到了，表示当前登录用户是管理员角色，否则返回null，
+        Admin admin = (Admin) session.getAttribute("admin");
+
+        // 尝试从会话中获取Teacher类型的用户对象，如果获取到了，表示当前登录用户是教师角色，否则返回null，
+        Teacher teacher = (Teacher) session.getAttribute("teacher");
+
+        // 根据获取到的不同用户角色对象情况来决定转发请求到不同的页面展示学生信息分页列表。
+        if (student!= null && admin == null && teacher == null) {
+            // 如果学生对象不为null且管理员对象和教师对象都为null，说明当前登录用户是学生角色，
+            // 则将请求转发到"/WEB-INF/student/sFindStudentList.jsp"页面，通常这个页面是专门为学生定制的查看学生信息分页列表的页面，
+            // 会根据学生的相关特点和需求展示学生信息内容等。
             request.getRequestDispatcher("/WEB-INF/student/sFindStudentList.jsp").forward(request, response);
-        } else if (admin != null && student == null && teacher == null) {
+        } else if (admin!= null && student == null && teacher == null) {
+            // 如果管理员对象不为null且学生对象和教师对象都为null，意味着当前登录用户是管理员角色，
+            // 此时将请求转发到"/WEB-INF/admin/aFindStudentList.jsp"页面，该页面应该是针对管理员设计的查看学生信息分页列表的页面，
+            // 会以适合管理员查看的方式呈现学生信息（比如可能包含更多操作按钮等管理功能）。
             request.getRequestDispatcher("/WEB-INF/admin/aFindStudentList.jsp").forward(request, response);
-        } else if (teacher != null && admin == null && student == null) {
+        } else if (teacher!= null && admin == null && student == null) {
+            // 如果教师对象不为null且管理员对象和学生对象都为null，表明当前登录用户是教师角色，
+            // 则将请求转发到"/WEB-INF/teacher/tFindStudentList.jsp"页面，这个页面是为教师定制的查看学生信息分页列表的页面，
+            // 可能会展示与教师教学相关的学生信息等内容。
             request.getRequestDispatcher("/WEB-INF/teacher/tFindStudentList.jsp").forward(request, response);
         } else {
+            // 如果不符合上述任何一种角色明确的情况（比如可能是未登录或者角色信息异常等其他情况），
+            // 则将请求转发到"error.jsp"页面，该页面一般用于展示错误提示信息，告知用户出现了不符合预期的情况（此处可能是无法正确展示学生信息分页列表）。
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的按照分页查找学生信息并根据用户角色展示到对应页面的相关逻辑操作。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
-}
+}

src/web/servlet/student/DeleteSelectStudentServlet.java

@@ -1,29 +1,62 @@
 package web.servlet.student;
-
+// 包声明，表明该类所属的包名，用于组织和管理Java类，这里表示该Servlet类位于web.servlet.student包下
 import service.StudentService;
+// 导入StudentService接口，用于后续调用该接口定义的相关业务方法（通常是和学生相关的业务逻辑操作）
 import service.impl.StudentServiceImpl;
+// 导入StudentServiceImpl类，它是StudentService接口的具体实现类，用来提供实际的业务逻辑实现
 
 import javax.servlet.ServletException;
+// 导入Servlet异常类，用于捕获和处理Servlet执行过程中出现的异常情况
 import javax.servlet.annotation.WebServlet;
+// 导入WebServlet注解，通过该注解可以方便地将一个普通的Java类声明为一个Servlet，并配置其访问路径等相关信息
 import javax.servlet.http.HttpServlet;
+// 导入HttpServlet类，它是所有基于HTTP协议的Servlet的基类，自定义的Servlet类通常需要继承它来实现相应功能
 import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于获取HTTP请求中的各种信息，比如请求参数、请求头信息等
 import javax.servlet.http.HttpServletResponse;
+// 导入HttpServletResponse类，用于向客户端发送HTTP响应，例如设置响应状态码、响应头以及输出响应内容等
 import java.io.IOException;
+// 导入IOException类，用于处理输入输出相关的异常情况，比如读写文件、网络通信等出现的异常
 
 @WebServlet("/deleteSelectStudentServlet")
+// 使用WebServlet注解声明该类是一个Servlet，并指定其访问路径为 /deleteSelectStudentServlet，
+// 意味着客户端可以通过该路径来访问这个Servlet提供的服务
 public class DeleteSelectStudentServlet extends HttpServlet {
+    // 定义一个类DeleteSelectStudentServlet，它继承自HttpServlet类，表明它是一个处理HTTP请求的Servlet类
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，该方法会在客户端以POST方式发起请求时被调用
+        // request参数用于获取此次HTTP请求的相关信息
+        // response参数用于向客户端返回HTTP响应
+
         String[] sids = request.getParameterValues("sid");
+        // 从HTTP请求中获取名为"sid"的参数值，由于该参数可能有多个值（比如批量删除操作时会选择多个学生的id），
+        // 所以返回的是一个字符串数组，如果没有对应的参数则返回null
+
         StudentService service = new StudentServiceImpl();
+        // 创建一个StudentServiceImpl类的实例，该实例实现了StudentService接口，通过这个实例可以调用具体的业务方法
+        // 这里就是为了调用和学生删除相关的业务逻辑方法
+
         service.deleteSelectStudent(sids);
+        // 调用StudentService接口中定义的deleteSelectStudent方法（由StudentServiceImpl具体实现），
+        // 传入获取到的学生id数组，来执行批量删除选中学生的业务操作
+
         response.sendRedirect(request.getContextPath()+"/findStudentByPageServlet");
+        // 执行完删除操作后，使用重定向的方式将客户端请求重定向到 /findStudentByPageServlet 路径，
+        // 通常是为了让页面刷新显示删除后的学生列表等相关信息，request.getContextPath() 一般获取的是当前Web应用的上下文路径
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，该方法会在客户端以GET方式发起请求时被调用
+        // 这里的实现是直接调用doPost方法，意味着不管是GET请求还是POST请求，都会执行同样的业务逻辑处理
         doPost(request,response);
     }
+<<<<<<< HEAD
 }
 //yuo
 //tu
 //rre
 //s
+=======
+}
+>>>>>>> develop1

src/web/servlet/student/DeleteStudentServlet.java

@@ -1,31 +1,70 @@
 package web.servlet.student;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.student包下，方便在项目中对类进行组织和管理
 
 import service.NotifyService;
+// 导入NotifyService接口，通常该接口定义了与通知相关的业务方法，不过从当前类来看可能暂时未直接使用到相关方法
 import service.StudentService;
+// 导入StudentService接口，用于后续调用和学生相关的业务逻辑操作的方法，是与学生业务处理的抽象定义
 import service.impl.NotifyServiceImpl;
+// 导入NotifyServiceImpl类，它是NotifyService接口的具体实现类，虽然在当前展示的逻辑中可能未实际调用其功能
 import service.impl.StudentServiceImpl;
+// 导入StudentServiceImpl类，它是StudentService接口的具体实现类，用于提供具体的学生业务逻辑实现，比如删除学生等操作
 
 import javax.servlet.ServletException;
+// 导入ServletException类，用于捕获和处理在Servlet执行过程中出现的异常情况，保障程序的健壮性
 import javax.servlet.annotation.WebServlet;
+// 导入WebServlet注解，通过这个注解可以便捷地将一个普通Java类声明为Servlet，并配置其对外访问的路径等信息
 import javax.servlet.http.HttpServlet;
+// 导入HttpServlet类，它是所有基于HTTP协议的Servlet的基础类，自定义的Servlet类一般需要继承它来实现具体功能
 import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于获取HTTP请求中的各类信息，像请求参数、请求头以及请求相关的其他属性等
 import javax.servlet.http.HttpServletResponse;
+// 导入HttpServletResponse类，用于向客户端发送HTTP响应，比如设置响应状态码、响应头以及响应内容等操作
 import javax.servlet.http.HttpSession;
+// 导入HttpSession类，用于在服务器端管理用户的会话信息，能够实现跨多个请求之间的数据共享等功能
 import java.io.IOException;
+// 导入IOException类，用于处理输入输出相关的异常，常见于读写文件、网络通信等场景中出现的异常情况
 
 @WebServlet("/deleteStudentServlet")
+// 使用WebServlet注解声明该类是一个Servlet，并指定其访问路径为 "/deleteStudentServlet"，
+// 意味着客户端可以通过这个路径来访问该Servlet提供的服务
 public class DeleteStudentServlet extends HttpServlet {
+    // 定义DeleteStudentServlet类，它继承自HttpServlet类，表明其是一个处理HTTP请求的Servlet类
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，此方法会在客户端以POST方式发起请求时被调用
+        // request参数用于接收此次HTTP请求相关的所有信息
+        // response参数用于向客户端返回HTTP响应相关的内容，比如页面、数据等
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保能够正确解析包含中文等特殊字符的请求参数，避免出现乱码问题
+
         HttpSession session = request.getSession();
+        // 获取当前请求对应的HttpSession对象，如果不存在则会创建一个新的会话，通过会话可以在多个请求间传递数据等
+
         String studentid = request.getParameter("s_id");
+        // 从HTTP请求中获取名为"s_id"的参数值，该值通常代表要删除的学生的唯一标识（如学生ID），并将其赋值给studentid变量，
+        // 如果请求中不存在该参数，则返回null
+
         StudentService service = new StudentServiceImpl();
+        // 创建一个StudentServiceImpl类的实例，它实现了StudentService接口，通过这个实例可以调用具体的和学生相关的业务方法
+
         service.deleteStudentById(studentid);
+        // 调用StudentService接口中定义的deleteStudentById方法（由StudentServiceImpl类具体实现），
+        // 传入获取到的学生ID（studentid），来执行删除对应学生的业务操作
+
 //        request.getRequestDispatcher("/findStudentByPageServlet").forward(request,response);
+        // 这行代码被注释掉了，原本它的作用是通过请求转发的方式，将请求转发到"/findStudentByPageServlet"对应的资源（一般是另一个Servlet或JSP页面等），
+        // 在转发过程中，请求对象和响应对象会被保留，地址栏不会改变
+
         response.sendRedirect("findStudentByPageServlet");
+        // 使用重定向的方式将客户端的请求重定向到"findStudentByPageServlet"对应的资源，
+        // 重定向后客户端会发起一个新的请求，地址栏会显示新的请求路径，常用于页面跳转等操作，不过这里使用相对路径时，要确保路径解析正确
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，该方法会在客户端以GET方式发起请求时被调用
+        // 此处的实现是直接调用doPost方法，意味着不管客户端是通过GET方式还是POST方式发起请求，都会执行同样的业务逻辑处理
         doPost(request,response);
     }
-}
+}

src/web/servlet/student/DoSelectCourseServlet.java

@@ -1,63 +1,126 @@
 package web.servlet.student;
+// 声明该类所属的包名，说明这个Servlet类位于web.servlet.student包下，便于在项目中对代码进行分类管理和组织
 
 import domain.Course;
+// 导入Course类，通常表示课程相关的领域模型类，可能包含课程的各种属性信息（如课程名称、课程编号等），不过在此处代码中暂时未体现对其具体操作
 import domain.SelectCourse;
+// 导入SelectCourse类，可能代表学生选课相关的领域模型类，用于描述学生选择课程的相关记录（比如包含学生ID、课程ID以及成绩等属性信息）
 import domain.Student;
+// 导入Student类，代表学生相关的领域模型类，包含学生的各种属性信息（如学生ID、姓名等），在这里会用于获取当前操作的学生相关信息
 import service.StudentService;
+// 导入StudentService接口，该接口定义了与学生相关业务操作的方法声明，是对学生业务逻辑的抽象描述
 import service.impl.StudentServiceImpl;
+// 导入StudentServiceImpl类，它是StudentService接口的具体实现类，用于提供具体的学生业务逻辑实现，比如查询学生选课情况、添加选课记录等操作
 
 import javax.servlet.ServletException;
+// 导入ServletException类，用于捕获和处理在Servlet执行过程中出现的异常情况，确保程序在出现异常时能合理应对，增强程序的健壮性
 import javax.servlet.annotation.WebServlet;
+// 导入WebServlet注解，通过这个注解可以方便地将一个普通Java类声明为Servlet，并配置其对外访问的路径等相关信息
 import javax.servlet.http.HttpServlet;
+// 导入HttpServlet类，它是所有基于HTTP协议的Servlet的基类，自定义的Servlet类通常需要继承它来实现相应的功能，以处理HTTP请求和响应
 import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于获取HTTP请求中的各种信息，例如请求参数、请求头以及客户端相关的其他信息等
 import javax.servlet.http.HttpServletResponse;
+// 导入HttpServletResponse类，用于向客户端发送HTTP响应，像设置响应状态码、响应头以及响应内容（如页面、数据等）
 import javax.servlet.http.HttpSession;
+// 导入HttpSession类，用于在服务器端管理用户的会话信息，能够实现跨多个请求之间的数据共享，在这里用于获取登录学生的相关信息
 import java.io.IOException;
+// 导入IOException类，用于处理输入输出相关的异常情况，常见于读写文件、网络通信等操作出现异常时进行捕获和处理
 import java.util.Date;
+// 导入Date类，用于获取当前的日期和时间信息，在这里用于生成提示信息中的时间戳部分
 import java.util.List;
+// 导入List接口，用于处理和操作有序的元素集合，在这里用于存储学生选课的相关记录列表
 
 @WebServlet("/doSelectCourseServlet")
+// 使用WebServlet注解声明该类是一个Servlet，并指定其访问路径为"/doSelectCourseServlet"，
+// 这意味着客户端可以通过这个路径来访问该Servlet所提供的服务
 public class DoSelectCourseServlet extends HttpServlet {
+    // 定义DoSelectCourseServlet类，它继承自HttpServlet类，表明它是一个用于处理HTTP请求的Servlet类
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，该方法会在客户端以POST方式发起请求时被调用
+        // request参数用于接收此次HTTP请求相关的所有信息
+        // response参数用于向客户端返回对应的HTTP响应信息
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，目的是确保能够正确解析包含中文等特殊字符的请求参数，避免出现参数解析乱码的问题
+
         HttpSession session = request.getSession();
-        Student student= (Student)session.getAttribute("student");
+        // 获取当前请求对应的HttpSession对象，如果不存在则会创建一个新的会话。通过会话对象可以获取之前存储在会话中的用户相关信息，
+        // 比如在这里用于获取登录的学生信息
+
+        Student student = (Student) session.getAttribute("student");
+        // 从HttpSession对象中获取名为"student"的属性值，并将其强制转换为Student类型，这个属性值通常是在用户登录等操作时存储进去的，
+        // 代表当前登录的学生对象，通过它可以获取学生的相关标识信息等
+
         String courseid = request.getParameter("id");
-        //存不存在已选该课
+        // 从HTTP请求中获取名为"id"的参数值，该参数通常代表要选择的课程的唯一标识（比如课程编号），并将其赋值给courseid变量，
+        // 如果请求中不存在该参数，则返回null
+
+        // 存不存在已选该课
         boolean flag = false;
+        // 定义一个布尔类型的变量flag，用于标记当前学生是否已经选择了指定的课程，初始值设为false，表示默认还未选该课程
 
-        //判断是否已选
+        // 判断是否已选
         StudentService studentService = new StudentServiceImpl();
+        // 创建一个StudentServiceImpl类的实例，它实现了StudentService接口，通过这个实例可以调用具体的与学生相关的业务方法，
+        // 在这里主要用于查询学生已选课程的情况
+
         List<SelectCourse> selectcourses = studentService.findAllSelectCourse(student.getS_id());
-        for (SelectCourse s:selectcourses) {
+        // 调用StudentService接口中定义的findAllSelectCourse方法（由StudentServiceImpl具体实现），传入当前学生的ID（通过student.getS_id()获取），
+        // 获取该学生已经选择的所有课程记录列表，并将其赋值给selectcourses变量
+
+        for (SelectCourse s : selectcourses) {
+            // 遍历学生已选课程记录列表selectcourses，对每一条选课记录进行检查
             if (s.getC_id().equals(courseid)) {
+                // 如果某条选课记录中的课程ID（通过s.getC_id()获取）与要选择的课程ID（courseid）相等，说明已经选过该课程了
                 flag = true;
+                // 将flag标记设为true，表示已选该课程
                 break;
+                // 一旦发现已选该课程，就跳出循环，不需要再继续遍历列表了
             }
         }
         if (flag == true) {
+            // 如果flag为true，说明当前学生已经选择了指定的课程
 
             request.setAttribute("select_msg", "你已选了该课程！" + String.format("%tT", new Date()));
+            // 在请求对象中设置一个名为"select_msg"的属性，属性值为提示信息字符串，包含已选课程的提示以及当前的时间戳（通过String.format("%tT", new Date())生成时间格式为HH:MM:SS的字符串）
             request.getRequestDispatcher("studentOptionalCourseServlet").forward(request, response);
+            // 使用请求转发的方式将请求转发到"studentOptionalCourseServlet"对应的资源（一般是另一个Servlet或JSP页面等），
+            // 在转发过程中，请求对象和响应对象会被保留，客户端地址栏显示的地址不会改变，常用于在服务器内部进行页面跳转且希望保留请求相关信息的场景
 //            response.sendRedirect("studentOptionalCourseServlet");
+            // 这行代码被注释掉了，它的作用是使用重定向的方式将客户端请求重定向到"studentOptionalCourseServlet"对应的资源。
+            // 重定向会让客户端发起一个新的请求，地址栏会显示新的请求路径，和请求转发有所不同，在这里当前未采用这种方式
         } else {
-            //获取到当前学生id
+            // 如果flag为false，说明当前学生还没有选择指定的课程
+
+            // 获取到当前学生id
             String studentid = student.getS_id();
+            // 通过之前获取到的学生对象student，调用其getS_id()方法获取学生的ID，并赋值给studentid变量，用于后续添加选课记录的操作
 
-            //获取当前行的课程id courseid
+            // 获取当前行的课程id courseid
+            // 这里的courseid在前面已经从请求参数中获取到了，它代表要选择的课程的ID，会用于添加选课记录的操作
 
-            //调用学生添加选课服务s_id c_id score  select_course添加
+            // 调用学生添加选课服务s_id c_id score  select_course添加
             StudentService Service = new StudentServiceImpl();
-            Service.addSelectCourse(studentid,courseid);
+            // 再次创建一个StudentServiceImpl类的实例，用于调用添加选课的业务方法（虽然可以复用前面创建的studentService实例，但这里重新创建了一个）
+            Service.addSelectCourse(studentid, courseid);
+            // 调用StudentService接口中定义的addSelectCourse方法（由StudentServiceImpl具体实现），传入学生ID（studentid）和课程ID（courseid），
+            // 执行添加选课记录的业务操作，一般会在数据库等存储介质中插入一条新的选课记录
 
-            //完成后给提示跳转
+            // 完成后给提示跳转
             request.setAttribute("select_msg", "选课成功！" + String.format("%tT", new Date()));
+            // 在请求对象中设置一个名为"select_msg"的属性，属性值为选课成功的提示信息字符串，同样包含当前的时间戳（通过String.format("%tT", new Date())生成时间格式为HH:MM:SS的字符串）
             request.getRequestDispatcher("studentOptionalCourseServlet").forward(request, response);
+            // 使用请求转发的方式将请求转发到"studentOptionalCourseServlet"对应的资源（一般是另一个Servlet或JSP页面等），
+            // 目的是在选课成功后跳转到相应页面展示相关信息，同时保留请求相关的属性信息（如这里设置的"select_msg"提示信息）
         }
 
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，该方法会在客户端以GET方式发起请求时被调用
+        // 此处的实现是直接调用doPost方法，意味着不管客户端是通过GET方式还是POST方式发起请求，都会执行同样的业务逻辑处理
+        doPost(request, response);
     }
-}
+}

src/web/servlet/student/StudentInfomationServlet.java

@@ -1,29 +1,68 @@
 package web.servlet.student;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.student包下，方便在项目中对类进行组织和管理
 
 import domain.Student;
+// 导入Student类，它代表学生相关的领域模型类，包含学生的各种属性信息（如姓名、学号等），可能会在后续业务逻辑中用于获取、更新或展示学生信息
 import service.StudentService;
+// 导入StudentService接口，该接口定义了与学生相关业务操作的方法，例如根据学号查找学生、更新学生信息等，是对学生业务逻辑的抽象描述
 import service.impl.StudentServiceImpl;
+// 导入StudentServiceImpl类，它是StudentService接口的具体实现类，用于提供具体的学生业务逻辑实现，比如具体的查找学生信息等操作
 
 import javax.servlet.ServletException;
+// 导入ServletException类，用于捕获和处理在Servlet执行过程中出现的异常情况，保障程序在出现异常时能合理应对，增强程序的健壮性
 import javax.servlet.annotation.WebServlet;
+// 导入WebServlet注解，通过这个注解可以方便地将一个普通Java类声明为Servlet，并配置其对外访问的路径等相关信息
 import javax.servlet.http.HttpServlet;
+// 导入HttpServlet类，它是所有基于HTTP协议的Servlet的基类，自定义的Servlet类通常需要继承它来实现相应的功能，以处理HTTP请求和响应
 import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于获取HTTP请求中的各种信息，例如请求参数、请求头以及客户端相关的其他信息等
 import javax.servlet.http.HttpServletResponse;
+// 导入HttpServletResponse类，用于向客户端发送HTTP响应，像设置响应状态码、响应头以及响应内容（如页面、数据等）
 import javax.servlet.http.HttpSession;
+// 导入HttpSession类，用于在服务器端管理用户的会话信息，能够实现跨多个请求之间的数据共享，在这里原本可能用于获取或更新存储在会话中的学生信息
 import java.io.IOException;
+// 导入IOException类，用于处理输入输出相关的异常情况，常见于读写文件、网络通信等操作出现异常时进行捕获和处理
 
 @WebServlet("/studentInfomationServlet")
+// 使用WebServlet注解声明该类是一个Servlet，并指定其访问路径为"/studentInfomationServlet"，
+// 意味着客户端可以通过这个路径来访问该Servlet所提供的服务
 public class StudentInfomationServlet extends HttpServlet {
+    // 定义StudentInfomationServlet类，它继承自HttpServlet类，表明它是一个用于处理HTTP请求的Servlet类
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，该方法会在客户端以POST方式发起请求时被调用
+        // request参数用于接收此次HTTP请求相关的所有信息
+        // response参数用于向客户端返回对应的HTTP响应信息
+
 //        HttpSession session = request.getSession();
+        // 这行代码被注释掉了，它原本的作用是获取当前请求对应的HttpSession对象，如果不存在则会创建一个新的会话。
+        // 通过会话对象可以获取之前存储在会话中的用户相关信息（比如登录的学生信息等），在这里可能是打算获取学生信息，但目前未启用该功能
+
 //        Student s = (Student) session.getAttribute("student");
+        // 这行代码也被注释掉了，它原本是想从HttpSession对象中获取名为"student"的属性值，并将其强制转换为Student类型，
+        // 这个属性值通常是在用户登录等操作时存储进去的，代表当前登录的学生对象，通过它可以获取学生的相关标识信息等，不过目前未执行此操作
+
 //        StudentService service = new StudentServiceImpl();
+        // 同样被注释掉的代码，它的作用是创建一个StudentServiceImpl类的实例，该实例实现了StudentService接口，
+        // 通过这个实例可以调用具体的与学生相关的业务方法，比如根据学生ID查找学生信息等，在这里可能是打算用来查询学生最新信息，但未实际使用
+
 //        Student newStudent = service.findStudentById(s);
-//        session.setAttribute("student",newStudent);
-        request.getRequestDispatcher("/WEB-INF/student/sInformation.jsp").forward(request,response);
+        // 这行注释掉的代码是想调用StudentService接口中定义的findStudentById方法（由StudentServiceImpl具体实现），
+        // 传入前面获取到的学生对象（虽然目前未获取到实际的学生对象），目的可能是根据学生的某个标识去查找最新的学生信息，然后将查询结果赋值给newStudent变量
+
+//        session.setAttribute("student", newStudent);
+        // 此注释掉的代码是打算将前面查询到的最新学生信息（newStudent）重新设置到HttpSession对象中，
+        // 以更新会话中存储的学生信息，不过目前这一系列操作都没有生效
+
+        request.getRequestDispatcher("/WEB-INF/student/sInformation.jsp").forward(request, response);
+        // 使用请求转发的方式将请求转发到"/WEB-INF/student/sInformation.jsp"对应的资源（一般是一个JSP页面），
+        // 在转发过程中，请求对象和响应对象会被保留，客户端地址栏显示的地址不会改变，常用于在服务器内部进行页面跳转且希望保留请求相关信息的场景，
+        // 在这里的目的可能是跳转到展示学生信息的JSP页面
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，该方法会在客户端以GET方式发起请求时被调用
+        // 此处的实现是直接调用doPost方法，意味着不管客户端是通过GET方式还是POST方式发起请求，都会执行同样的业务逻辑处理
+        doPost(request, response);
     }
-}
+}

src/web/servlet/student/StudentInfomationUpdateServlet.java

@@ -1,76 +1,139 @@
 package web.servlet.student;
+// 声明该类所属的包名，表明这个Servlet类位于web.servlet.student包下，便于在项目中对代码进行分类管理和组织
 
 import domain.Student;
+// 导入Student类，它代表学生相关的领域模型类，包含学生的各种属性信息（如学号、姓名、性别等），用于创建学生对象以及传递学生相关数据
 import service.StudentService;
+// 导入StudentService接口，该接口定义了与学生相关业务操作的方法，例如更新学生信息、根据学号查找学生等，是对学生业务逻辑的抽象描述
 import service.impl.StudentServiceImpl;
+// 导入StudentServiceImpl类，它是StudentService接口的具体实现类，用于提供具体的学生业务逻辑实现，比如具体执行更新学生信息、查找学生等操作
 
 import javax.servlet.ServletException;
+// 导入ServletException类，用于捕获和处理在Servlet执行过程中出现的异常情况，确保程序在出现异常时能合理应对，增强程序的健壮性
 import javax.servlet.annotation.WebServlet;
+// 导入WebServlet注解，通过这个注解可以方便地将一个普通Java类声明为Servlet，并配置其对外访问的路径等相关信息
 import javax.servlet.http.HttpServlet;
+// 导入HttpServlet类，它是所有基于HTTP协议的Servlet的基类，自定义的Servlet类通常需要继承它来实现相应的功能，以处理HTTP请求和响应
 import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于获取HTTP请求中的各种信息，例如请求参数、请求头以及客户端相关的其他信息等
 import javax.servlet.http.HttpServletResponse;
+// 导入HttpServletResponse类，用于向客户端发送HTTP响应，像设置响应状态码、响应头以及响应内容（如页面、数据等）
 import javax.servlet.http.HttpSession;
+// 导入HttpSession类，用于在服务器端管理用户的会话信息，能够实现跨多个请求之间的数据共享，在这里用于获取、更新存储在会话中的学生信息
 import java.io.IOException;
+// 导入IOException类，用于处理输入输出相关的异常情况，常见于读写文件、网络通信等操作出现异常时进行捕获和处理
 import java.text.SimpleDateFormat;
+// 导入SimpleDateFormat类，用于格式化日期时间的显示格式，在这里用于将日期时间按照特定格式转换为字符串，便于生成提示信息中的时间戳部分
 import java.util.Date;
+// 导入Date类，用于获取当前的日期和时间信息，配合SimpleDateFormat类来生成格式化后的时间字符串
 
 @WebServlet("/studentInfomationUpdateServlet")
+// 使用WebServlet注解声明该类是一个Servlet，并指定其访问路径为"/studentInfomationUpdateServlet"，
+// 意味着客户端可以通过这个路径来访问该Servlet所提供的服务
 public class StudentInfomationUpdateServlet extends HttpServlet {
+    // 定义StudentInfomationUpdateServlet类，它继承自HttpServlet类，表明它是一个用于处理HTTP请求的Servlet类
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，该方法会在客户端以POST方式发起请求时被调用
+        // request参数用于接收此次HTTP请求相关的所有信息
+        // response参数用于向客户端返回对应的HTTP响应信息
 
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，目的是确保能够正确解析包含中文等特殊字符的请求参数，避免出现参数解析乱码的问题
 
-        //保存输入内容
+        // 保存输入内容
         String sid = request.getParameter("student-id");
+        // 从HTTP请求中获取名为"student-id"的参数值，通常该参数代表学生的学号，并将其赋值给sid变量，若请求中不存在该参数，则返回null
         String name = request.getParameter("student-name");
+        // 获取名为"student-name"的参数值，一般对应学生的姓名，赋值给name变量
         String sex = request.getParameter("student-sex");
+        // 获取名为"student-sex"的参数值，对应学生的性别信息，赋值给sex变量
         String age = request.getParameter("student-age");
+        // 获取名为"student-age"的参数值，代表学生的年龄信息，赋值给age变量
         String phone = request.getParameter("student-phone");
+        // 获取名为"student-phone"的参数值，即学生的电话号码信息，赋值给phone变量
         String email = request.getParameter("student-email");
+        // 获取名为"student-email"的参数值，为学生的电子邮箱地址信息，赋值给email变量
         String address = request.getParameter("student-address");
+        // 获取名为"student-address"的参数值，代表学生的家庭住址等地址信息，赋值给address变量
         String college = request.getParameter("selectCollege");
+        // 获取名为"selectCollege"的参数值，可能是学生所在学院的相关信息，赋值给college变量
         String department = request.getParameter("selectDepartment");
+        // 获取名为"selectDepartment"的参数值，大概是学生所在系部的信息，赋值给department变量
         String cclass = request.getParameter("selectClass");
+        // 获取名为"selectClass"的参数值，应该是学生所在班级的相关信息，赋值给cclass变量
 
         Student updateStudent = new Student();
+        // 创建一个新的Student对象，用于封装要更新的学生信息，后续会将从请求中获取到的各个参数值设置到这个对象的相应属性中
 
-
-        //判断输入位数是否大于数据库位数
-        if (name.length() > 4 || phone.length() > 11 || email.length()>24 || address.length() > 24 || age.length()>2 || name.contains("<") || phone.contains("<") || email.contains("<") || address.contains("<") || age.contains("<")) {
-            request.setAttribute("update_msg","格式错误，请重新提交！"+String.format("%tT",new Date()));
-
+        // 判断输入位数是否大于数据库位数
+        if (name.length() > 4 || phone.length() > 11 || email.length() > 24 || address.length() > 24 || age.length() > 2 || name.contains("<") || phone.contains("<") || email.contains("<") || address.contains("<") || age.contains("<")) {
+            // 检查从请求中获取到的学生信息相关参数的合法性，例如姓名长度是否超过数据库规定的4位、电话号码是否超过11位、邮箱地址是否超过24位等，
+            // 或者是否包含不合法的字符（这里以"<"为例进行简单判断），如果有不符合要求的情况
+            request.setAttribute("update_msg", "格式错误，请重新提交！" + String.format("%tT", new Date()));
+            // 在请求对象中设置一个名为"update_msg"的属性，属性值为提示信息字符串，包含格式错误的提示以及当前的时间戳（通过String.format("%tT", new Date())生成时间格式为HH:MM:SS的字符串）
             request.getRequestDispatcher("/WEB-INF/student/sInformation.jsp").forward(request, response);
+            // 使用请求转发的方式将请求转发到"/WEB-INF/student/sInformation.jsp"对应的资源（一般是一个JSP页面），
+            // 在转发过程中，请求对象和响应对象会被保留，客户端地址栏显示的地址不会改变，常用于在服务器内部进行页面跳转且希望保留请求相关信息的场景，
+            // 这里是当格式错误时跳转到相应页面提示用户重新提交
 //            response.sendRedirect("studentInfomationServlet");
-        }else {
-            //封装学生对象
+            // 这行代码被注释掉了，它的作用是使用重定向的方式将客户端请求重定向到"studentInfomationServlet"对应的资源。
+            // 重定向会让客户端发起一个新的请求，地址栏会显示新的请求路径，和请求转发有所不同，在这里当前未采用这种方式
+        } else {
+            // 封装学生对象
             updateStudent.setS_id(sid);
+            // 将从请求中获取到的学号（sid）设置到updateStudent对象的S_id属性中，完成学生学号信息的封装
             updateStudent.setS_name(name);
+            // 设置学生姓名属性
             updateStudent.setS_sex(sex);
+            // 设置学生性别属性
             updateStudent.setS_age(age);
+            // 设置学生年龄属性
             updateStudent.setS_phone(phone);
+            // 设置学生电话号码属性
             updateStudent.setS_email(email);
+            // 设置学生电子邮箱属性
             updateStudent.setS_address(address);
+            // 设置学生地址属性
             updateStudent.setS_college(college);
+            // 设置学生所在学院属性
             updateStudent.setS_department(department);
+            // 设置学生所在系部属性
             updateStudent.setS_class(cclass);
+            // 设置学生所在班级属性，至此完成了对要更新的学生对象的所有属性封装
 
-            //调用studentUpdata服务
-            StudentService service= new StudentServiceImpl();
+            // 调用studentUpdata服务
+            StudentService service = new StudentServiceImpl();
+            // 创建一个StudentServiceImpl类的实例，它实现了StudentService接口，通过这个实例可以调用具体的与学生相关的业务方法
             service.updateInfo(updateStudent);
+            // 调用StudentService接口中定义的updateInfo方法（由StudentServiceImpl具体实现），传入封装好的要更新信息的学生对象（updateStudent），
+            // 执行更新学生信息的业务操作，一般会将更新后的数据保存到数据库等存储介质中
 
             HttpSession session = request.getSession();
+            // 获取当前请求对应的HttpSession对象，如果不存在则会创建一个新的会话，通过会话可以获取、更新存储在其中的学生信息等
 
             Student s = service.findStudentById(updateStudent);
-            session.setAttribute("student",s);
+            // 调用StudentService接口中定义的findStudentById方法（由StudentServiceImpl具体实现），传入刚刚更新信息的学生对象（updateStudent），
+            // 目的是从数据库等存储介质中重新获取更新后的学生完整信息，并将其赋值给s变量
 
-            //成功则返回并给提示
-            request.setAttribute("update_msg", "修改成功！"+String.format("%tT",new Date()));
-            request.setAttribute("student",updateStudent);
+            session.setAttribute("student", s);
+            // 将重新获取到的更新后的学生信息（s）设置到HttpSession对象中，以更新会话中存储的学生信息，方便后续其他操作能获取到最新的学生数据
+
+            // 成功则返回并给提示
+            request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
+            // 在请求对象中设置一个名为"update_msg"的属性，属性值为修改成功的提示信息字符串，同样包含当前的时间戳（通过String.format("%tT", new Date())生成时间格式为HH:MM:SS的字符串）
+            request.setAttribute("student", updateStudent);
+            // 再次将更新后的学生对象（updateStudent）设置到请求对象中，可能在转发后的页面中会用到该对象展示更新后的详细信息
             request.getRequestDispatcher("/WEB-INF/student/sInformation.jsp").forward(request, response);
+            // 使用请求转发的方式将请求转发到"/WEB-INF/student/sInformation.jsp"对应的资源（一般是一个JSP页面），
+            // 目的是在修改成功后跳转到相应页面展示相关提示信息以及可能的学生详细信息
         }
+
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，该方法会在客户端以GET方式发起请求时被调用
+        // 此处的实现是直接调用doPost方法，意味着不管客户端是通过GET方式还是POST方式发起请求，都会执行同样的业务逻辑处理
+        doPost(request, response);
     }
-}
+}

src/web/servlet/student/StudentListServlet.java

@@ -1,47 +1,100 @@
 package web.servlet.student;
+// 声明该类所属的包名，表明这个Servlet类位于web.servlet.student包下，便于在项目中对代码进行分类管理和组织
 
 import domain.Admin;
+// 导入Admin类，代表管理员相关的领域模型类，包含管理员的各种属性信息，在这里用于判断当前登录用户是否为管理员角色
 import domain.Student;
+// 导入Student类，代表学生相关的领域模型类，包含学生的各种属性信息，既用于查询学生信息列表，也用于判断当前登录用户是否为学生角色
 import domain.Teacher;
+// 导入Teacher类，代表教师相关的领域模型类，包含教师的各种属性信息，用于判断当前登录用户是否为教师角色
 import service.StudentService;
+// 导入StudentService接口，该接口定义了与学生相关业务操作的方法，例如查询所有学生信息等，是对学生业务逻辑的抽象描述
 import service.impl.StudentServiceImpl;
+// 导入StudentServiceImpl类，它是StudentService接口的具体实现类，用于提供具体的学生业务逻辑实现，比如具体执行查询所有学生信息的操作
 
 import javax.servlet.ServletException;
+// 导入ServletException类，用于捕获和处理在Servlet执行过程中出现的异常情况，确保程序在出现异常时能合理应对，增强程序的健壮性
 import javax.servlet.annotation.WebServlet;
+// 导入WebServlet注解，通过这个注解可以方便地将一个普通Java类声明为Servlet，并配置其对外访问的路径等相关信息
 import javax.servlet.http.HttpServlet;
+// 导入HttpServlet类，它是所有基于HTTP协议的Servlet的基类，自定义的Servlet类通常需要继承它来实现相应的功能，以处理HTTP请求和响应
 import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于获取HTTP请求中的各种信息，例如请求参数、请求头以及客户端相关的其他信息等
 import javax.servlet.http.HttpServletResponse;
+// 导入HttpServletResponse类，用于向客户端发送HTTP响应，像设置响应状态码、响应头以及响应内容（如页面、数据等）
 import javax.servlet.http.HttpSession;
+// 导入HttpSession类，用于在服务器端管理用户的会话信息，能够实现跨多个请求之间的数据共享，在这里用于获取当前登录用户的角色信息（学生、管理员、教师）
 import java.io.IOException;
+// 导入IOException类，用于处理输入输出相关的异常情况，常见于读写文件、网络通信等操作出现异常时进行捕获和处理
 import java.util.List;
+// 导入List接口，用于处理和操作有序的元素集合，在这里用于存储查询到的所有学生信息列表
 
 @WebServlet("/studentListServlet")
+// 使用WebServlet注解声明该类是一个Servlet，并指定其访问路径为"/studentListServlet"，
+// 意味着客户端可以通过这个路径来访问该Servlet所提供的服务
 public class StudentListServlet extends HttpServlet {
+    // 定义StudentListServlet类，它继承自HttpServlet类，表明它是一个用于处理HTTP请求的Servlet类
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        //调用StudentService完成查询
+        // 重写HttpServlet类中的doPost方法，该方法会在客户端以POST方式发起请求时被调用
+        // request参数用于接收此次HTTP请求相关的所有信息
+        // response参数用于向客户端返回对应的HTTP响应信息
+
+        // 调用StudentService完成查询
         StudentService studentService = new StudentServiceImpl();
+        // 创建一个StudentServiceImpl类的实例，它实现了StudentService接口，通过这个实例可以调用具体的与学生相关的业务方法
         List<Student> students = studentService.findAll();
-        //将list存入request域
-        request.setAttribute("students",students);
+        // 调用StudentService接口中定义的findAll方法（由StudentServiceImpl具体实现），查询所有学生的信息，
+        // 将查询结果以List<Student>类型返回，即得到一个包含所有学生对象的列表，并赋值给students变量
+
+        // 将list存入request域
+        request.setAttribute("students", students);
+        // 将查询到的学生信息列表（students）设置到请求对象（request）的属性中，属性名为"students"，
+        // 这样在后续转发到的页面（如JSP页面）中就可以通过该属性名获取到学生信息列表进行展示等操作
 
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，目的是确保能够正确解析包含中文等特殊字符的请求参数，避免出现参数解析乱码的问题
 
         HttpSession session = request.getSession();
-        Student student= (Student)session.getAttribute("student");
-        Admin admin= (Admin)session.getAttribute("admin");
-        Teacher teacher= (Teacher)session.getAttribute("teacher");
-        if (student != null && admin == null && teacher == null) {
+        // 获取当前请求对应的HttpSession对象，如果不存在则会创建一个新的会话，通过会话对象可以获取之前存储在会话中的用户相关信息，
+        // 在这里主要用于获取当前登录用户的角色信息（学生、管理员、教师）
+
+        Student student = (Student) session.getAttribute("student");
+        // 从HttpSession对象中获取名为"student"的属性值，并将其强制转换为Student类型，这个属性值如果存在，代表当前登录用户是学生角色，
+        // 若不存在则返回null，通过它来判断当前登录用户是否为学生
+
+        Admin admin = (Admin) session.getAttribute("admin");
+        // 同理，从会话中获取名为"admin"的属性值并转换为Admin类型，用于判断当前登录用户是否为管理员角色，不存在则返回null
+
+        Teacher teacher = (Teacher) session.getAttribute("teacher");
+        // 从会话中获取名为"teacher"的属性值并转换为Teacher类型，用于判断当前登录用户是否为教师角色，不存在则返回null
+
+        if (student!= null && admin == null && teacher == null) {
+            // 如果从会话中获取到的学生对象不为空，且管理员对象和教师对象都为空，说明当前登录用户是学生角色
             request.getRequestDispatcher("/WEB-INF/student/studentList.jsp").forward(request, response);
-        } else if (admin != null && student == null && teacher == null) {
+            // 使用请求转发的方式将请求转发到"/WEB-INF/student/studentList.jsp"对应的资源（一般是一个JSP页面），
+            // 在转发过程中，请求对象和响应对象会被保留，客户端地址栏显示的地址不会改变，常用于在服务器内部进行页面跳转且希望保留请求相关信息的场景，
+            // 这里是将学生角色的用户请求转发到展示学生列表信息的JSP页面
+        } else if (admin!= null && student == null && teacher == null) {
+            // 如果管理员对象不为空，学生对象和教师对象都为空，说明当前登录用户是管理员角色
             request.getRequestDispatcher("/WEB-INF/admin/aFindStudentList.jsp").forward(request, response);
-        } else if (teacher != null && admin == null && student == null) {
+            // 使用请求转发的方式将请求转发到"/WEB-INF/admin/aFindStudentList.jsp"对应的资源（一般是一个JSP页面），
+            // 是将管理员角色的用户请求转发到适合管理员查看学生列表信息的JSP页面
+        } else if (teacher!= null && admin == null && student == null) {
+            // 如果教师对象不为空，管理员对象和学生对象都为空，说明当前登录用户是教师角色
             request.getRequestDispatcher("/WEB-INF/teacher/tFindStudentList.jsp").forward(request, response);
+            // 使用请求转发的方式将请求转发到"/WEB-INF/teacher/tFindStudentList.jsp"对应的资源（一般是一个JSP页面），
+            // 把教师角色的用户请求转发到适合教师查看学生列表信息的JSP页面
         } else {
             request.getRequestDispatcher("error.jsp").forward(request, response);
+            // 如果以上角色判断都不符合，说明可能出现了异常情况或者未预期的登录状态，
+            // 则使用请求转发的方式将请求转发到"error.jsp"对应的资源（一般是一个显示错误信息的JSP页面）
         }
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        this.doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，该方法会在客户端以GET方式发起请求时被调用
+        // 此处的实现是直接调用doPost方法，意味着不管客户端是通过GET方式还是POST方式发起请求，都会执行同样的业务逻辑处理
+        this.doPost(request, response);
     }
-}
+}

src/web/servlet/student/StudentOptionalCourseServlet.java

@@ -1,47 +1,97 @@
 package web.servlet.student;
+// 声明该类所属的包名，表明这个Servlet类位于web.servlet.student包下，便于在项目中对代码进行分类管理和组织
 
 import domain.Admin;
+// 导入Admin类，代表管理员相关的领域模型类，包含管理员的各种属性信息，在这里用于判断当前登录用户的角色是否为管理员
 import domain.Course;
+// 导入Course类，代表课程相关的领域模型类，包含课程的各种属性信息（如课程名称、课程编号等），用于存储查询到的可选课程信息
 import domain.SelectCourse;
+// 导入SelectCourse类，通常表示学生选课相关的领域模型类，不过在当前代码展示的主要逻辑中暂未直接使用它进行核心操作
 import domain.Student;
+// 导入Student类，代表学生相关的领域模型类，包含学生的各种属性信息，用于判断当前登录用户是否为学生角色以及获取学生相关信息
 import service.StudentService;
+// 导入StudentService接口，该接口定义了与学生相关业务操作的方法，例如查询所有可选课程等，是对学生业务逻辑的抽象描述
 import service.impl.StudentServiceImpl;
+// 导入StudentServiceImpl类，它是StudentService接口的具体实现类，用于提供具体的学生业务逻辑实现，比如具体执行查询所有可选课程的操作
 
 import javax.servlet.ServletException;
+// 导入ServletException类，用于捕获和处理在Servlet执行过程中出现的异常情况，确保程序在出现异常时能合理应对，增强程序的健壮性
 import javax.servlet.annotation.WebServlet;
+// 导入WebServlet注解，通过这个注解可以方便地将一个普通Java类声明为Servlet，并配置其对外访问的路径等相关信息
 import javax.servlet.http.HttpServlet;
+// 导入HttpServlet类，它是所有基于HTTP协议的Servlet的基类，自定义的Servlet类通常需要继承它来实现相应的功能，以处理HTTP请求和响应
 import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于获取HTTP请求中的各种信息，例如请求参数、请求头以及客户端相关的其他信息等
 import javax.servlet.http.HttpServletResponse;
+// 导入HttpServletResponse类，用于向客户端发送HTTP响应，像设置响应状态码、响应头以及响应内容（如页面、数据等）
 import javax.servlet.http.HttpSession;
+// 导入HttpSession类，用于在服务器端管理用户的会话信息，能够实现跨多个请求之间的数据共享，在这里用于获取当前登录用户的角色信息（学生或管理员）
 import java.io.IOException;
+// 导入IOException类，用于处理输入输出相关的异常情况，常见于读写文件、网络通信等操作出现异常时进行捕获和处理
 import java.util.List;
+// 导入List接口，用于处理和操作有序的元素集合，在这里用于存储查询到的所有可选课程信息列表
 
 @WebServlet("/studentOptionalCourseServlet")
+// 使用WebServlet注解声明该类是一个Servlet，并指定其访问路径为"/studentOptionalCourseServlet"，
+// 意味着客户端可以通过这个路径来访问该Servlet所提供的服务
 public class StudentOptionalCourseServlet extends HttpServlet {
+    // 定义StudentOptionalCourseServlet类，它继承自HttpServlet类，表明它是一个用于处理HTTP请求的Servlet类
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，该方法会在客户端以POST方式发起请求时被调用
+        // request参数用于接收此次HTTP请求相关的所有信息
+        // response参数用于向客户端返回对应的HTTP响应信息
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，目的是确保能够正确解析包含中文等特殊字符的请求参数，避免出现参数解析乱码的问题
+
         HttpSession session = request.getSession();
-        Student student= (Student)session.getAttribute("student");
-        Admin admin =(Admin)session.getAttribute("admin");
+        // 获取当前请求对应的HttpSession对象，如果不存在则会创建一个新的会话，通过会话对象可以获取之前存储在会话中的用户相关信息，
+        // 在这里主要用于获取当前登录用户的角色信息（学生或管理员）
+
+        Student student = (Student) session.getAttribute("student");
+        // 从HttpSession对象中获取名为"student"的属性值，并将其强制转换为Student类型，这个属性值如果存在，代表当前登录用户是学生角色，
+        // 若不存在则返回null，通过它来判断当前登录用户是否为学生
 
-        //调用StudentService完成查询
+        Admin admin = (Admin) session.getAttribute("admin");
+        // 同理，从会话中获取名为"admin"的属性值并转换为Admin类型，用于判断当前登录用户是否为管理员角色，不存在则返回null
+
+        // 调用StudentService完成查询
         StudentService studentService = new StudentServiceImpl();
+        // 创建一个StudentServiceImpl类的实例，它实现了StudentService接口，通过这个实例可以调用具体的与学生相关的业务方法
+
         List<Course> optionalcourses = studentService.findAllOptionalCourse();
-        //将list存入request域
-        request.setAttribute("optionalcourses",optionalcourses);
-        //转发到list.jsp
+        // 调用StudentService接口中定义的findAllOptionalCourse方法（由StudentServiceImpl具体实现），查询所有可选课程的信息，
+        // 将查询结果以List<Course>类型返回，即得到一个包含所有可选课程对象的列表，并赋值给optionalcourses变量
+
+        // 将list存入request域
+        request.setAttribute("optionalcourses", optionalcourses);
+        // 将查询到的可选课程信息列表（optionalcourses）设置到请求对象（request）的属性中，属性名为"optionalcourses"，
+        // 这样在后续转发到的页面（如JSP页面）中就可以通过该属性名获取到可选课程列表进行展示等操作
 
-        if (student != null && admin == null) {
-            request.getRequestDispatcher("/WEB-INF/student/studentOptionalCourse.jsp").forward(request,response);
-        } else if (admin != null && student == null) {
+        // 转发到list.jsp
+        if (student!= null && admin == null) {
+            // 如果从会话中获取到的学生对象不为空，且管理员对象为空，说明当前登录用户是学生角色
+            request.getRequestDispatcher("/WEB-INF/student/studentOptionalCourse.jsp").forward(request, response);
+            // 使用请求转发的方式将请求转发到"/WEB-INF/student/studentOptionalCourse.jsp"对应的资源（一般是一个JSP页面），
+            // 在转发过程中，请求对象和响应对象会被保留，客户端地址栏显示的地址不会改变，常用于在服务器内部进行页面跳转且希望保留请求相关信息的场景，
+            // 这里是将学生角色的用户请求转发到展示学生可选课程信息的JSP页面
+        } else if (admin!= null && student == null) {
+            // 如果管理员对象不为空，学生对象为空，说明当前登录用户是管理员角色
             request.getRequestDispatcher("/WEB-INF/admin/allStudentOptionalCourse.jsp").forward(request, response);
+            // 使用请求转发的方式将请求转发到"/WEB-INF/admin/allStudentOptionalCourse.jsp"对应的资源（一般是一个JSP页面），
+            // 是将管理员角色的用户请求转发到适合管理员查看所有学生可选课程信息的JSP页面
         } else {
             request.getRequestDispatcher("error.jsp").forward(request, response);
+            // 如果以上角色判断都不符合，说明可能出现了异常情况或者未预期的登录状态，
+            // 则使用请求转发的方式将请求转发到"error.jsp"对应的资源（一般是一个显示错误信息的JSP页面）
         }
 
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        this.doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，该方法会在客户端以GET方式发起请求时被调用
+        // 此处的实现是直接调用doPost方法，意味着不管客户端是通过GET方式还是POST方式发起请求，都会执行同样的业务逻辑处理
+        this.doPost(request, response);
     }
-}
+}

src/web/servlet/student/StudentPasswordIndexServlet.java

@@ -1,19 +1,39 @@
 package web.servlet.student;
+// 声明该类所属的包名，表明这个Servlet类位于web.servlet.student包下，便于在项目中对代码进行分类管理和组织
 
 import javax.servlet.ServletException;
+// 导入ServletException类，用于捕获和处理在Servlet执行过程中出现的异常情况，确保程序在出现异常时能合理应对，增强程序的健壮性
 import javax.servlet.annotation.WebServlet;
+// 导入WebServlet注解，通过这个注解可以方便地将一个普通Java类声明为Servlet，并配置其对外访问的路径等相关信息
 import javax.servlet.http.HttpServlet;
+// 导入HttpServlet类，它是所有基于HTTP协议的Servlet的基类，自定义的Servlet类通常需要继承它来实现相应的功能，以处理HTTP请求和响应
 import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于获取HTTP请求中的各种信息，例如请求参数、请求头以及客户端相关的其他信息等
 import javax.servlet.http.HttpServletResponse;
+// 导入HttpServletResponse类，用于向客户端发送HTTP响应，像设置响应状态码、响应头以及响应内容（如页面、数据等）
 import java.io.IOException;
+// 导入IOException类，用于处理输入输出相关的异常情况，常见于读写文件、网络通信等操作出现异常时进行捕获和处理
 
 @WebServlet("/studentPasswordIndexServlet")
+// 使用WebServlet注解声明该类是一个Servlet，并指定其访问路径为"/studentPasswordIndexServlet"，
+// 意味着客户端可以通过这个路径来访问该Servlet所提供的服务
 public class StudentPasswordIndexServlet extends HttpServlet {
+    // 定义StudentPasswordIndexServlet类，它继承自HttpServlet类，表明它是一个用于处理HTTP请求的Servlet类
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request,response);
+        // 重写HttpServlet类中的doPost方法，该方法会在客户端以POST方式发起请求时被调用
+        // request参数用于接收此次HTTP请求相关的所有信息
+        // response参数用于向客户端返回对应的HTTP响应信息
+
+        request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request, response);
+        // 使用请求转发的方式将请求转发到"/WEB-INF/student/studentUpdatePassword.jsp"对应的资源（一般是一个JSP页面），
+        // 在转发过程中，请求对象和响应对象会被保留，客户端地址栏显示的地址不会改变，常用于在服务器内部进行页面跳转且希望保留请求相关信息的场景，
+        // 在这里的作用是当客户端以POST方式访问该Servlet时，将请求转发到用于学生更新密码的JSP页面
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，该方法会在客户端以GET方式发起请求时被调用
+        // 此处的实现是直接调用doPost方法，意味着不管客户端是通过GET方式还是POST方式发起请求，都会执行同样的业务逻辑处理
+        doPost(request, response);
     }
-}
+}

src/web/servlet/student/StudentPasswordUpdateServlet.java

@@ -1,52 +1,116 @@
 package web.servlet.student;
+// 声明该类所属的包名，表明这个Servlet类位于web.servlet.student包下，便于在项目中对代码进行分类管理和组织
 
 import domain.Student;
+// 导入Student类，它代表学生相关的领域模型类，包含学生的各种属性信息（如学号、姓名等），在这里用于获取学生对象以及更新学生密码相关操作
 import service.StudentService;
+// 导入StudentService接口，该接口定义了与学生相关业务操作的方法，例如更新学生密码、根据学号查找学生等，是对学生业务逻辑的抽象描述
 import service.impl.StudentServiceImpl;
+// 导入StudentServiceImpl类，它是StudentService接口的具体实现类，用于提供具体的学生业务逻辑实现，比如具体执行更新学生密码、查找学生的操作
 
 import javax.servlet.ServletException;
+// 导入ServletException类，用于捕获和处理在Servlet执行过程中出现的异常情况，确保程序在出现异常时能合理应对，增强程序的健壮性
 import javax.servlet.annotation.WebServlet;
+// 导入WebServlet注解，通过这个注解可以方便地将一个普通Java类声明为Servlet，并配置其对外访问的路径等相关信息
 import javax.servlet.http.HttpServlet;
+// 导入HttpServlet类，它是所有基于HTTP协议的Servlet的基类，自定义的Servlet类通常需要继承它来实现相应的功能，以处理HTTP请求和响应
 import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于获取HTTP请求中的各种信息，例如请求参数、请求头以及客户端相关的其他信息等
 import javax.servlet.http.HttpServletResponse;
+// 导入HttpServletResponse类，用于向客户端发送HTTP响应，像设置响应状态码、响应头以及响应内容（如页面、数据等）
 import javax.servlet.http.HttpSession;
+// 导入HttpSession类，用于在服务器端管理用户的会话信息，能够实现跨多个请求之间的数据共享，在这里用于获取当前登录学生的信息以及更新会话中存储的学生信息
 import java.io.IOException;
+// 导入IOException类，用于处理输入输出相关的异常情况，常见于读写文件、网络通信等操作出现异常时进行捕获和处理
 import java.util.Date;
+// 导入Date类，用于获取当前的日期和时间信息，配合格式化字符串用于生成包含时间戳的提示信息
 
 @WebServlet("/studentPasswordUpdateServlet")
+// 使用WebServlet注解声明该类是一个Servlet，并指定其访问路径为"/studentPasswordUpdateServlet"，
+// 意味着客户端可以通过这个路径来访问该Servlet所提供的服务
 public class StudentPasswordUpdateServlet extends HttpServlet {
+    // 定义StudentPasswordUpdateServlet类，它继承自HttpServlet类，表明它是一个用于处理HTTP请求的Servlet类
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，该方法会在客户端以POST方式发起请求时被调用
+        // request参数用于接收此次HTTP请求相关的所有信息
+        // response参数用于向客户端返回对应的HTTP响应信息
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，目的是确保能够正确解析包含中文等特殊字符的请求参数，避免出现参数解析乱码的问题
+
         HttpSession session = request.getSession();
-        Student student= (Student)session.getAttribute("student");
+        // 获取当前请求对应的HttpSession对象，如果不存在则会创建一个新的会话，通过会话对象可以获取之前存储在会话中的用户相关信息，
+        // 在这里主要是获取当前登录的学生信息
+
+        Student student = (Student) session.getAttribute("student");
+        // 从HttpSession对象中获取名为"student"的属性值，并将其强制转换为Student类型，这个属性值代表当前登录的学生对象，
+        // 若不存在则返回null，通过它来获取学生的相关属性等信息
 
         String studentid = student.getS_id();
+        // 通过获取到的学生对象student，调用其getS_id()方法获取学生的学号，并赋值给studentid变量，
+        // 后续会用该学号来标识要更新密码的学生，用于调用服务层方法更新密码
+
         String newpassword = request.getParameter("student-newpassword");
+        // 从HTTP请求中获取名为"student-newpassword"的参数值，该参数代表用户输入的新密码，并将其赋值给newpassword变量，
+        // 如果请求中不存在该参数，则返回null
+
         String ennewpassword = request.getParameter("student-ennewpassword");
+        // 从请求中获取名为"student-ennewpassword"的参数值，通常用于确认新密码输入是否一致，将其赋值给ennewpassword变量
+
         String regex = "^[\\w]{3,12}$";
+        // 定义一个正则表达式字符串regex，用于验证密码格式。这里的正则表达式表示密码必须由3到12位的单词字符（字母、数字、下划线）组成
+
         boolean flag = newpassword.matches(regex);
+        // 使用matches方法，让用户输入的新密码（newpassword）去匹配前面定义的正则表达式（regex），
+        // 如果匹配成功则返回true，表示密码格式正确，否则返回false
+
         if (!flag) {
-            request.setAttribute("update_msg", "密码格式错误，重新提交！"+String.format("%tT",new Date()));
+            // 如果flag为false，即密码格式不符合要求
+            request.setAttribute("update_msg", "密码格式错误，重新提交！" + String.format("%tT", new Date()));
+            // 在请求对象中设置一个名为"update_msg"的属性，属性值为提示信息字符串，包含密码格式错误的提示以及当前的时间戳（通过String.format("%tT", new Date())生成时间格式为HH:MM:SS的字符串）
             request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request, response);
+            // 使用请求转发的方式将请求转发到"/WEB-INF/student/studentUpdatePassword.jsp"对应的资源（一般是一个JSP页面），
+            // 在转发过程中，请求对象和响应对象会被保留，客户端地址栏显示的地址不会改变，常用于在服务器内部进行页面跳转且希望保留请求相关信息的场景，
+            // 这里是当密码格式错误时跳转到密码更新页面提示用户重新提交
         } else if (!newpassword.equals(ennewpassword)) {
+            // 如果密码格式正确，但新密码和确认密码不一致
             request.setAttribute("update_msg", "密码确认错误，请重新提交！" + String.format("%tT", new Date()));
+            // 设置提示信息属性，提示密码确认有误以及当前时间戳
             request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request, response);
+            // 同样转发到密码更新页面，让用户重新提交
         } else {
+            // 如果密码格式正确且新密码和确认密码一致
+
+            StudentService service = new StudentServiceImpl();
+            // 创建一个StudentServiceImpl类的实例，它实现了StudentService接口，通过这个实例可以调用具体的与学生相关的业务方法
 
-            StudentService service= new StudentServiceImpl();
-            service.updatePassword(studentid,newpassword);
+            service.updatePassword(studentid, newpassword);
+            // 调用StudentService接口中定义的updatePassword方法（由StudentServiceImpl具体实现），传入学生学号（studentid）和新密码（newpassword），
+            // 执行更新学生密码的业务操作，一般会将更新后的密码保存到数据库等存储介质中
 
             Student newStudent = service.findStudentById(student);
+            // 调用StudentService接口中定义的findStudentById方法（由StudentServiceImpl具体实现），传入当前学生对象（student），
+            // 目的是从数据库等存储介质中重新获取更新密码后的学生完整信息，并将其赋值给newStudent变量
+
             student = newStudent;
-            session.setAttribute("student",student);
+            // 将更新后的学生对象赋值给原来的student变量，以便后续更新会话中的学生信息
+
+            session.setAttribute("student", student);
+            // 将更新后的学生信息（student）重新设置到HttpSession对象中，以更新会话中存储的学生信息，方便后续其他操作能获取到最新的学生数据
 
             request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
+            // 设置提示信息属性，提示密码修改成功以及当前时间戳
+
             request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request, response);
+            // 转发到密码更新页面，展示修改成功的提示信息给用户
         }
 
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，该方法会在客户端以GET方式发起请求时被调用
+        // 此处的实现是直接调用doPost方法，意味着不管客户端是通过GET方式还是POST方式发起请求，都会执行同样的业务逻辑处理
+        doPost(request, response);
     }
-}
+}

src/web/servlet/student/StudentSelectCourseListServlet.java

@@ -1,50 +1,107 @@
 package web.servlet.student;
+// 声明该类所属的包名，表明这个Servlet类位于web.servlet.student包下，便于在项目中对代码进行分类管理和组织
 
 import domain.Admin;
+// 导入Admin类，代表管理员相关的领域模型类，包含管理员的各种属性信息，用于判断当前登录用户是否为管理员角色
 import domain.SelectCourse;
+// 导入SelectCourse类，通常表示学生选课相关的领域模型类，包含学生选课的相关属性信息（如学生ID、课程ID、成绩等），用于存储查询到的选课信息
 import domain.Student;
+// 导入Student类，代表学生相关的领域模型类，包含学生的各种属性信息，用于判断当前登录用户是否为学生角色以及获取学生相关信息来查询选课情况
 import domain.Teacher;
+// 导入Teacher类，代表教师相关的领域模型类，虽然在当前代码逻辑中暂未直接涉及教师相关判断操作，但属于领域模型类的引入
 import service.StudentService;
+// 导入StudentService接口，该接口定义了与学生相关业务操作的方法，例如查询学生选课信息等，是对学生业务逻辑的抽象描述
 import service.impl.StudentServiceImpl;
+// 导入StudentServiceImpl类，它是StudentService接口的具体实现类，用于提供具体的学生业务逻辑实现，比如具体执行查询不同条件下学生选课信息的操作
 
 import javax.servlet.ServletException;
+// 导入ServletException类，用于捕获和处理在Servlet执行过程中出现的异常情况，确保程序在出现异常时能合理应对，增强程序的健壮性
 import javax.servlet.annotation.WebServlet;
+// 导入WebServlet注解，通过这个注解可以方便地将一个普通Java类声明为Servlet，并配置其对外访问的路径等相关信息
 import javax.servlet.http.HttpServlet;
+// 导入HttpServlet类，它是所有基于HTTP协议的Servlet的基类，自定义的Servlet类通常需要继承它来实现相应的功能，以处理HTTP请求和响应
 import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于获取HTTP请求中的各种信息，例如请求参数、请求头以及客户端相关的其他信息等
 import javax.servlet.http.HttpServletResponse;
+// 导入HttpServletResponse类，用于向客户端发送HTTP响应，像设置响应状态码、响应头以及响应内容（如页面、数据等）
 import javax.servlet.http.HttpSession;
+// 导入HttpSession类，用于在服务器端管理用户的会话信息，能够实现跨多个请求之间的数据共享，在这里用于获取当前登录用户的角色信息（学生或管理员）
 import java.io.IOException;
+// 导入IOException类，用于处理输入输出相关的异常情况，常见于读写文件、网络通信等操作出现异常时进行捕获和处理
 import java.util.List;
+// 导入List接口，用于处理和操作有序的元素集合，在这里用于存储查询到的学生选课信息列表
 
 @WebServlet("/studentSelectCourseListServlet")
+// 使用WebServlet注解声明该类是一个Servlet，并指定其访问路径为"/studentSelectCourseListServlet"，
+// 意味着客户端可以通过这个路径来访问该Servlet所提供的服务
 public class StudentSelectCourseListServlet extends HttpServlet {
+    // 定义StudentSelectCourseListServlet类，它继承自HttpServlet类，表明它是一个用于处理HTTP请求的Servlet类
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，该方法会在客户端以POST方式发起请求时被调用
+        // request参数用于接收此次HTTP请求相关的所有信息
+        // response参数用于向客户端返回对应的HTTP响应信息
 
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，目的是确保能够正确解析包含中文等特殊字符的请求参数，避免出现参数解析乱码的问题
+
         HttpSession session = request.getSession();
-        Student student= (Student)session.getAttribute("student");
-        Admin admin =(Admin)session.getAttribute("admin");
+        // 获取当前请求对应的HttpSession对象，如果不存在则会创建一个新的会话，通过会话对象可以获取之前存储在会话中的用户相关信息，
+        // 在这里主要用于获取当前登录用户的角色信息（学生或管理员）
+
+        Student student = (Student) session.getAttribute("student");
+        // 从HttpSession对象中获取名为"student"的属性值，并将其强制转换为Student类型，这个属性值如果存在，代表当前登录用户是学生角色，
+        // 若不存在则返回null，通过它来判断当前登录用户是否为学生
 
-        //调用StudentService完成查询
+        Admin admin = (Admin) session.getAttribute("admin");
+        // 同理，从会话中获取名为"admin"的属性值并转换为Admin类型，用于判断当前登录用户是否为管理员角色，不存在则返回null
+
+        // 调用StudentService完成查询
         StudentService studentService = new StudentServiceImpl();
-        if (student != null && admin == null) {
+        // 创建一个StudentServiceImpl类的实例，它实现了StudentService接口，通过这个实例可以调用具体的与学生相关的业务方法
+
+        if (student!= null && admin == null) {
+            // 如果从会话中获取到的学生对象不为空，且管理员对象为空，说明当前登录用户是学生角色
+
             List<SelectCourse> selectcourses = studentService.findAllSelectCourse(student.getS_id());
-            //将list存入request域
-            request.setAttribute("selectcourses",selectcourses);
-            //转发到list.jsp
-            request.getRequestDispatcher("/WEB-INF/student/studentSelectCourseList.jsp").forward(request,response);
-        } else if (admin != null && student == null) {
+            // 调用StudentService接口中定义的findAllSelectCourse方法（由StudentServiceImpl具体实现），传入当前学生的ID（通过student.getS_id()获取），
+            // 查询该学生已选的所有课程信息，将查询结果以List<SelectCourse>类型返回，即得到一个包含该学生所有选课记录对象的列表，并赋值给selectcourses变量
+
+            // 将list存入request域
+            request.setAttribute("selectcourses", selectcourses);
+            // 将查询到的学生选课信息列表（selectcourses）设置到请求对象（request）的属性中，属性名为"selectcourses"，
+            // 这样在后续转发到的页面（如JSP页面）中就可以通过该属性名获取到选课列表进行展示等操作
+
+            // 转发到list.jsp
+            request.getRequestDispatcher("/WEB-INF/student/studentSelectCourseList.jsp").forward(request, response);
+            // 使用请求转发的方式将请求转发到"/WEB-INF/student/studentSelectCourseList.jsp"对应的资源（一般是一个JSP页面），
+            // 在转发过程中，请求对象和响应对象会被保留，客户端地址栏显示的地址不会改变，常用于在服务器内部进行页面跳转且希望保留请求相关信息的场景，
+            // 这里是将学生角色的用户请求转发到展示该学生自己选课列表信息的JSP页面
+        } else if (admin!= null && student == null) {
+            // 如果管理员对象不为空，学生对象为空，说明当前登录用户是管理员角色
+
             List<SelectCourse> selectcourses = studentService.findSelectCourseAllStudent();
+            // 调用StudentService接口中定义的findSelectCourseAllStudent方法（由StudentServiceImpl具体实现），
+            // 查询所有学生的选课信息，将查询结果以List<SelectCourse>类型返回，得到一个包含所有学生选课记录对象的列表，并赋值给selectcourses变量
+
             request.setAttribute("selectcourses", selectcourses);
+            // 将查询到的所有学生选课信息列表（selectcourses）设置到请求对象（request）的属性中
+
             request.getRequestDispatcher("/WEB-INF/admin/allStudentSelectCourseList.jsp").forward(request, response);
+            // 使用请求转发的方式将请求转发到"/WEB-INF/admin/allStudentSelectCourseList.jsp"对应的资源（一般是一个JSP页面），
+            // 是将管理员角色的用户请求转发到适合管理员查看所有学生选课列表信息的JSP页面
         } else {
             request.getRequestDispatcher("error.jsp").forward(request, response);
+            // 如果以上角色判断都不符合，说明可能出现了异常情况或者未预期的登录状态，
+            // 则使用请求转发的方式将请求转发到"error.jsp"对应的资源（一般是一个显示错误信息的JSP页面）
         }
 
 
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        this.doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，该方法会在客户端以GET方式发起请求时被调用
+        // 此处的实现是直接调用doPost方法，意味着不管客户端是通过GET方式还是POST方式发起请求，都会执行同样的业务逻辑处理
+        this.doPost(request, response);
     }
-}
+}

src/web/servlet/student/StudentServlet.java

@@ -1,19 +1,39 @@
 package web.servlet.student;
+// 声明该类所属的包名，表明这个Servlet类位于web.servlet.student包下，便于在项目中对代码进行分类管理和组织
 
 import javax.servlet.ServletException;
+// 导入ServletException类，用于捕获和处理在Servlet执行过程中出现的异常情况，确保程序在出现异常时能合理应对，增强程序的健壮性
 import javax.servlet.annotation.WebServlet;
+// 导入WebServlet注解，通过这个注解可以方便地将一个普通Java类声明为Servlet，并配置其对外访问的路径等相关信息
 import javax.servlet.http.HttpServlet;
+// 导入HttpServlet类，它是所有基于HTTP协议的Servlet的基类，自定义的Servlet类通常需要继承它来实现相应的功能，以处理HTTP请求和响应
 import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于获取HTTP请求中的各种信息，例如请求参数、请求头以及客户端相关的其他信息等
 import javax.servlet.http.HttpServletResponse;
+// 导入HttpServletResponse类，用于向客户端发送HTTP响应，像设置响应状态码、响应头以及响应内容（如页面、数据等）
 import java.io.IOException;
+// 导入IOException类，用于处理输入输出相关的异常情况，常见于读写文件、网络通信等操作出现异常时进行捕获和处理
 
 @WebServlet("/studentServlet")
+// 使用WebServlet注解声明该类是一个Servlet，并指定其访问路径为"/studentServlet"，
+// 意味着客户端可以通过这个路径来访问该Servlet所提供的服务
 public class StudentServlet extends HttpServlet {
+    // 定义StudentServlet类，它继承自HttpServlet类，表明它是一个用于处理HTTP请求的Servlet类
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request,response);
+        // 重写HttpServlet类中的doPost方法，该方法会在客户端以POST方式发起请求时被调用
+        // request参数用于接收此次HTTP请求相关的所有信息
+        // response参数用于向客户端返回对应的HTTP响应信息
+
+        request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request, response);
+        // 使用请求转发的方式将请求转发到"/WEB-INF/student/sIndex.jsp"对应的资源（一般是一个JSP页面），
+        // 在转发过程中，请求对象和响应对象会被保留，客户端地址栏显示的地址不会改变，常用于在服务器内部进行页面跳转且希望保留请求相关信息的场景，
+        // 在这里的作用是当客户端以POST方式访问该Servlet时，将请求转发到对应的学生首页（通常是sIndex.jsp这个JSP页面）
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，该方法会在客户端以GET方式发起请求时被调用
+        // 此处的实现是直接调用doPost方法，意味着不管客户端是通过GET方式还是POST方式发起请求，都会执行同样的业务逻辑处理
+        doPost(request, response);
     }
-}
+}

src/web/servlet/teacher/AddOptionalCourseServlet.java

@@ -1,51 +1,85 @@
-package web.servlet.teacher;
+// 包声明，表明该Servlet类所属的包名，用于组织和管理Java类
+package web.servlet.teacher;  
 
 import domain.Course;
 import domain.Teacher;
-import service.CourseService;
-import service.impl.CourseServiceImpl;
+// 导入课程相关的业务逻辑接口，用于后续调用相关业务方法
+import service.CourseService;  
+// 导入课程业务逻辑接口的具体实现类，用于创建具体的业务对象来处理课程相关操作
+import service.impl.CourseServiceImpl;  
 
 import javax.servlet.ServletException;
-import javax.servlet.annotation.WebServlet;
-import javax.servlet.http.HttpServlet;
+// 用于标注该类是一个Servlet，并配置其访问的URL路径
+import javax.servlet.annotation.WebServlet;  
+// 继承自HttpServlet，是Java Web中处理HTTP请求的基础类
+import javax.servlet.http.HttpServlet;  
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpSession;
+// 用于表示HTTP会话，可在其中存储和获取用户相关的会话信息
+import javax.servlet.http.HttpSession;  
 import java.io.IOException;
 import java.util.Date;
 
-@WebServlet("/addOptionalCourseServlet")
+// 使用@WebServlet注解配置该Servlet的访问路径为 "/addOptionalCourseServlet"，
+// 意味着当客户端通过此路径发起请求时，会由该Servlet进行处理
+@WebServlet("/addOptionalCourseServlet")  
 public class AddOptionalCourseServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
+    // 参数request表示客户端发来的请求对象，包含请求的各种信息
+    // 参数response表示要返回给客户端的响应对象，用于设置响应内容等
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数
+        request.setCharacterEncoding("utf-8");  
 
-        HttpSession session = request.getSession();
-        Teacher teacher = (Teacher) session.getAttribute("teacher");
+        // 获取当前请求对应的会话对象，如果不存在则创建一个新的会话
+        HttpSession session = request.getSession();  
+        // 从会话中获取名为"teacher"的属性值，并转换为Teacher类型，
+        // 通常这里存储的是当前登录教师的相关信息
+        Teacher teacher = (Teacher) session.getAttribute("teacher");  
 
-        String cid = request.getParameter("cid");
-        String cname = request.getParameter("course-name");
-        String cinfo = request.getParameter("course-info");
+        // 从请求参数中获取课程ID，对应HTML表单中名为"cid"的输入项
+        String cid = request.getParameter("cid");  
+        // 从请求参数中获取课程名称，对应HTML表单中名为"course-name"的输入项
+        String cname = request.getParameter("course-name");  
+        // 从请求参数中获取课程详细信息，对应HTML表单中名为"course-info"的输入项
+        String cinfo = request.getParameter("course-info");  
 
-        CourseService service = new CourseServiceImpl();
-        Course course =  service.findSelectCourseByCourseId(cid);
-        if (course != null) {
-            request.setAttribute("update_msg","课程ID冲突，请重新添加！"+String.format("%tT",new Date()));
+        // 创建课程业务逻辑层的具体实现类对象，用于调用具体的课程相关业务方法
+        CourseService service = new CourseServiceImpl();  
+        // 通过业务层方法，根据课程ID查找对应的课程对象，查看是否已存在该课程
+        Course course =  service.findSelectCourseByCourseId(cid);  
+        if (course!= null) {
+            // 如果课程已存在（即查找结果不为空），则向请求对象中设置一个属性"update_msg"，
+            // 提示课程ID冲突，并附带当前时间信息，然后将请求转发到指定的JSP页面进行展示
+            request.setAttribute("update_msg","课程ID冲突，请重新添加！" + String.format("%tT",new Date()));
             request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request,response);
-        }else {
-            Course newCourse = new Course();
-            newCourse.setC_id(cid);
-            newCourse.setC_name(cname);
-            newCourse.setC_info(cinfo);
-            newCourse.setT_id(teacher.getT_id());
-            newCourse.setT_name(teacher.getT_name());
-
-            service.addOptionalCourse(newCourse);
-            request.setAttribute("update_msg","课程添加成功！"+String.format("%tT",new Date()));
+        } else {
+            // 如果课程不存在，则创建一个新的Course对象，用于封装要添加的课程信息
+            Course newCourse = new Course();  
+            // 设置新课程的ID
+            newCourse.setC_id(cid);  
+            // 设置新课程的名称
+            newCourse.setC_name(cname);  
+            // 设置新课程的详细信息
+            newCourse.setC_info(cinfo);  
+            // 设置新课程所属教师的ID，从之前从会话中获取的教师对象中获取教师ID
+            newCourse.setT_id(teacher.getT_id());  
+            // 设置新课程所属教师的姓名，从之前从会话中获取的教师对象中获取教师姓名
+            newCourse.setT_name(teacher.getT_name());  
+
+            // 通过业务层对象调用添加可选课程的方法，将新创建的课程信息保存到数据库等存储介质中
+            service.addOptionalCourse(newCourse);  
+            // 向请求对象中设置一个属性"update_msg"，提示课程添加成功，并附带当前时间信息
+            request.setAttribute("update_msg","课程添加成功！" + String.format("%tT",new Date()));
+            // 将请求转发到指定的JSP页面（通常用于展示添加课程后的相关提示信息等）
             request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request,response);
         }
     }
 
+    // 重写doGet方法，在该Servlet中直接调用doPost方法来处理GET请求，
+    // 意味着GET请求的处理逻辑和POST请求一样（实际应用中可根据需求单独定制处理逻辑）
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request,response);
     }
-}
+}

src/web/servlet/teacher/AddSelectCourseServlet.java

@@ -1,4 +1,5 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，用于对类进行合理的组织和管理，方便在项目中区分不同功能模块的类。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -6,15 +7,35 @@ import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
+// 导入必要的Java EE相关的类库。
+// ServletException用于处理Servlet执行过程中出现的异常情况。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，方便容器识别并进行相关配置和管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法。
+// HttpServletRequest用于获取来自客户端的HTTP请求信息，例如请求参数、请求头信息等。
+// HttpServletResponse用于向客户端发送HTTP响应，例如设置响应状态码、响应头以及返回响应内容等。
+// IOException用于处理输入输出相关的异常，比如读写文件、网络传输等出现问题时抛出。
 
 @WebServlet("/addSelectCourseServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定该Servlet对应的访问路径为"/addSelectCourseServlet"。当客户端通过这个路径发起HTTP请求时，容器就会找到并调用这个Servlet来处理请求。
 public class AddSelectCourseServlet extends HttpServlet {
+    // 定义一个名为AddSelectCourseServlet的类，它继承自HttpServlet类，表明这个类是一个用于处理HTTP请求的Servlet，继承HttpServlet可以方便地重写相关方法来处理不同类型的HTTP请求（如GET、POST等）。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的路径时，容器会调用这个方法来处理请求。
+        // 参数request包含了客户端发送过来的请求信息，response用于向客户端返回响应信息。
+
         request.setCharacterEncoding("utf-8");
-        request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request,response);
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够正确地按照UTF-8编码进行解析，避免中文等特殊字符出现乱码问题。
+
+        request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request, response);
+        // 获取一个请求转发器，指定转发的目标页面为"/WEB-INF/teacher/addOptionalCourse.jsp"。
+        // 然后使用forward方法将当前请求转发到指定的JSP页面，这样在处理完Servlet中的业务逻辑后，可以让服务器端渲染并返回对应的JSP页面内容给客户端，整个过程对客户端来说是一次请求响应的过程，地址栏中的URL不会发生变化。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写HttpServlet中的doGet方法，用于处理HTTP GET请求。当客户端通过GET方式访问此Servlet对应的路径时，容器会调用这个方法来处理请求。
+
+        doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即都会将请求转发到"/WEB-INF/teacher/addOptionalCourse.jsp"这个JSP页面进行后续处理。
     }
-}
+}

src/web/servlet/teacher/AddTeacherInfoServlet.java

@@ -1,8 +1,11 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，按照功能模块对类进行分类管理，方便在项目结构中组织代码。
 
 import domain.Teacher;
 import service.TeacherService;
 import service.impl.TeacherServiceImpl;
+// 导入与教师相关的领域模型类（Teacher），教师业务逻辑的服务接口（TeacherService）以及该接口的具体实现类（TeacherServiceImpl）。
+// Teacher类通常用于封装教师相关的属性和业务逻辑，TeacherService定义了教师业务操作的抽象方法，TeacherServiceImpl则是这些方法的具体实现类。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -11,25 +14,63 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.Date;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作和异常。
+// ServletException用于处理Servlet执行过程中出现的异常情况。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，如请求参数等。
+// HttpServletResponse用于向客户端发送HTTP响应，比如设置响应状态码、响应头以及返回响应内容等。
+// IOException用于处理输入输出相关的异常，例如读写文件或者网络传输等出现问题时抛出。
+// Date类用于获取当前的日期和时间信息，在这里可能用于记录操作的时间等用途。
 
 @WebServlet("/addTeacherInfoServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/addTeacherInfoServlet"。当客户端通过这个URL路径发起HTTP请求时，Web容器就会找到并调用这个Servlet来处理请求。
 public class AddTeacherInfoServlet extends HttpServlet {
+    // 定义一个名为AddTeacherInfoServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等）。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的URL路径时，容器会调用这个方法来处理请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则用于向客户端返回响应信息。
+
         request.setCharacterEncoding("utf-8");
-        TeacherService service= new TeacherServiceImpl();
-        //先进行判断是否已存在该教师
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证数据的准确性。
+
+        TeacherService service = new TeacherServiceImpl();
+        // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量service。这样后续就可以调用TeacherService接口中定义的教师业务相关方法，而具体的实现则由TeacherServiceImpl类来完成。
+
+        // 先进行判断是否已存在该教师
         String tid = request.getParameter("teacher-id");
+        // 从客户端发送的HTTP请求中获取名为"teacher-id"的参数值，该参数值通常代表教师的编号，用于后续判断是否已经存在具有该编号的教师记录。
+
         Teacher t = new Teacher();
+        // 创建一个Teacher类的实例t，用于封装教师相关的信息，此处先创建一个空的教师对象，后续会设置相应的属性值。
+
         t.setT_id(tid);
+        // 通过调用Teacher类的setT_id方法，将从请求中获取到的教师编号（tid）设置到教师对象t中，以便后续根据这个编号进行数据库查询等操作来判断教师是否已存在。
+
         Teacher newTeacher = service.findTeacherById(t);
-        if (newTeacher != null) {
-            request.setAttribute("update_msg","已存在该教师，请重新添加！"+String.format("%tT",new Date()));
+        // 调用service（实际是TeacherServiceImpl类的实例）的findTeacherById方法，传入刚才设置好编号的教师对象t，该方法应该是根据教师编号去数据库等存储介质中查询是否存在对应的教师记录，并返回查询到的教师对象（如果存在的话），将查询结果赋值给newTeacher变量。
+
+        if (newTeacher!= null) {
+            // 判断查询到的教师对象newTeacher是否不为空，即是否已经存在具有该编号的教师记录。
+            request.setAttribute("update_msg", "已存在该教师，请重新添加！" + String.format("%tT", new Date()));
+            // 如果教师已存在，使用request对象的setAttribute方法设置一个名为"update_msg"的属性，属性值是提示信息，告知用户该教师已存在，并拼接上当前的时间（通过String.format结合%tT格式化Date对象，得到具体的时间格式字符串），以便用户了解操作的时间情况。
             request.getRequestDispatcher("addTeacherServlet").forward(request, response);
-        }else {
+            // 获取一个请求转发器，将请求转发到名为"addTeacherServlet"的资源（可能是另一个Servlet或者JSP页面等），这样服务器端会接着处理转发后的请求，并向客户端返回相应的响应内容，整个过程对客户端来说是一次完整的请求响应过程，地址栏中的URL不会发生改变。
+        } else {
+            // 如果教师不存在，则执行以下添加教师信息的逻辑。
+
             String name = request.getParameter("teacher-name");
+            // 从客户端请求中获取名为"teacher-name"的参数值，该值代表教师的姓名，用于后续设置到要添加的教师对象中。
+
             String sex = request.getParameter("teacher-sex");
+            // 从请求中获取名为"teacher-sex"的参数值，代表教师的性别，同样用于设置教师对象的属性。
+
             String education = request.getParameter("teacher-education");
+            // 获取"teacher-education"参数值，对应教师的文化程度信息，用于后续操作。
+
             String title = request.getParameter("teacher-title");
+            // 获取"teacher-title"参数值，代表教师的职称信息，准备设置到教师对象里。
 
 //            String college = request.getParameter("selectCollege");
 //            String department = request.getParameter("selectDepartment");
@@ -43,25 +84,46 @@ public class AddTeacherInfoServlet extends HttpServlet {
 //            if ("".equals(cclass)) {
 //                cclass = "待分配";
 //            }
+            // 上述代码段被注释掉了，但原本的意图可能是从请求中获取教师所属的学院、系别、班级信息，如果获取到的值为空字符串，就将其设置为"待分配"，表示该教师在这些方面暂未明确分配相应的归属。
 
             Teacher updateTeacher = new Teacher();
+            // 创建一个新的Teacher类实例updateTeacher，用于封装要添加的教师的完整信息，后续将各项参数值设置到这个对象中。
 
             updateTeacher.setT_id(tid);
+            // 将之前获取到的教师编号设置到updateTeacher对象中，确保添加的教师具有正确的编号信息。
+
             updateTeacher.setT_name(name);
+            // 设置教师的姓名到updateTeacher对象中。
+
             updateTeacher.setT_sex(sex);
+            // 设置教师的性别信息到对象中。
+
             updateTeacher.setT_education(education);
+            // 设置教师的文化程度信息到对象中。
+
             updateTeacher.setT_title(title);
+            // 设置教师的职称信息到对象中。
+
 //            updateTeacher.setT_college(college);
 //            updateTeacher.setT_department(department);
 //            updateTeacher.setT_class(cclass);
+            // 同样，上述被注释掉的代码原本是要设置教师所属的学院、系别、班级信息到updateTeacher对象中。
 
             service.addTeacherAllInfo(updateTeacher);
+            // 调用service（TeacherServiceImpl的实例）的addTeacherAllInfo方法，将封装好教师所有信息的updateTeacher对象传入，该方法应该会将教师信息保存到数据库等存储介质中，完成教师信息的添加操作。
+
             request.setAttribute("update_msg", "添加成功！" + String.format("%tT", new Date()));
+            // 设置名为"update_msg"的属性，属性值为添加成功的提示信息，并拼接当前时间，方便用户知晓操作完成的时间情况。
+
             request.getRequestDispatcher("addTeacherServlet").forward(request, response);
+            // 再次使用请求转发器将请求转发到"addTeacherServlet"资源，进行后续的页面展示或者其他相关业务处理，保持整个请求响应流程的连贯性，客户端看到的URL不变。
         }
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求。
+
+        doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即都会按照doPost方法中的逻辑进行处理，比如判断教师是否存在、添加教师信息等操作。
     }
-}
+}

src/web/servlet/teacher/AddTeacherServlet.java

@@ -1,8 +1,13 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，通过包名对类进行分类管理，有助于在项目中清晰地组织代码结构，方便区分不同功能模块对应的类。
 
 import domain.CDC;
 import service.CDCService;
 import service.impl.CDCServiceImpl;
+// 导入与CDC（可能是某种机构、部门等相关的领域模型类，具体含义取决于业务场景）相关的类和接口。
+// domain.CDC表示CDC类所在的包名和类名，该类通常用于封装CDC相关的属性和业务逻辑。
+// service.CDCService是定义CDC业务操作的服务接口，规定了可以对CDC进行的各种业务方法，比如查询、添加、删除等操作（这里从名字推测可能主要涉及查询相关操作）。
+// service.impl.CDCServiceImpl则是CDCService接口的具体实现类，实现了接口中定义的方法，具体完成与数据库或其他数据源交互来实现业务逻辑的功能。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -12,26 +17,60 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及可能出现的异常情况。
+// ServletException用于处理Servlet执行过程中出现的异常情况，比如配置错误、业务逻辑执行出错等。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器识别和管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，我们可以通过重写它的方法来实现具体的业务逻辑处理。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，例如请求参数、请求头信息等，是处理请求数据的重要入口。
+// HttpServletResponse用于向客户端发送HTTP响应，比如设置响应状态码、响应头以及返回响应内容等，用于构建返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它可以在不同的请求之间共享数据，比如保存用户的登录状态、购物车信息等（这里可能用于保存一些与添加教师页面相关的数据）。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
+// List是Java集合框架中的接口，表示一个有序的、可重复元素的集合，这里用于存放从数据库等数据源查询出来的CDC相关数据列表（例如学院、系别、班级列表等）。
 
 @WebServlet("/addTeacherServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/addTeacherServlet"。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等）就会找到并调用这个Servlet来处理请求。
 public class AddTeacherServlet extends HttpServlet {
+    // 定义一个名为AddTeacherServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的URL路径时，容器会调用这个方法来处理请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则用于向客户端返回响应信息。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性。
+
         HttpSession session = request.getSession();
+        // 获取当前请求对应的HttpSession对象，如果不存在则创建一个新的会话对象。HttpSession可以用于在多个请求之间保存和共享数据，方便实现一些需要跨请求保持状态的功能，比如登录后的用户信息保存等。在这里主要用于存放一些后续要在页面中展示的数据列表。
 
         CDCService service = new CDCServiceImpl();
+        // 创建一个CDCServiceImpl类的实例，通过多态的方式将其赋值给CDCService接口类型的变量service。这样后续就可以调用CDCService接口中定义的与CDC相关的业务方法，而具体的实现则由CDCServiceImpl类来完成，例如查询学院、系别、班级等列表信息的操作。
+
         List<CDC> collegeList = service.findAllCollege();
+        // 调用service（实际是CDCServiceImpl的实例）的findAllCollege方法，该方法应该是从数据库或者其他数据源中查询出所有学院的信息，并以CDC对象的列表形式返回，将查询到的学院信息列表赋值给collegeList变量。
+
         List<CDC> departmentList = service.findAllDepartment();
+        // 同样地，调用findAllDepartment方法，从数据源中获取所有系别的信息，以CDC对象列表形式返回，赋值给departmentList变量，用于后续在页面上展示系别相关的下拉选项等操作。
+
         List<CDC> classList = service.findAllClass();
+        // 调用findAllClass方法，查询并获取所有班级的信息，以CDC对象列表形式返回，赋值给classList变量，方便在页面中展示班级相关的下拉选择内容等。
+
+        session.setAttribute("collegeLists", collegeList);
+        // 使用HttpSession对象的setAttribute方法，将查询到的学院信息列表（collegeList）保存到会话中，设置的属性名为"collegeLists"，这样在后续的请求处理或者页面渲染过程中（只要是同一个会话内），就可以获取到这个学院列表数据进行展示或其他操作。
 
-        session.setAttribute("collegeLists",collegeList);
-        session.setAttribute("departmentLists",departmentList);
-        session.setAttribute("classLists",classList);
+        session.setAttribute("departmentLists", departmentList);
+        // 类似地，将系别信息列表（departmentList）保存到会话中，属性名为"departmentLists"，以便在相关页面中使用这些系别数据，例如构建下拉菜单选项等。
 
-        request.getRequestDispatcher("/WEB-INF/admin/addTeacher.jsp").forward(request,response);
+        session.setAttribute("classLists", classList);
+        // 把班级信息列表（classList）保存到会话中，属性名为"classLists"，便于后续页面展示班级相关的选择内容等操作。
+
+        request.getRequestDispatcher("/WEB-INF/admin/addTeacher.jsp").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到"/WEB-INF/admin/addTeacher.jsp"这个页面（通常是一个JSP页面，用于展示添加教师的表单等相关内容）。这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面渲染后的内容，整个过程对客户端来说是一次完整的请求响应过程，地址栏中的URL不会发生改变。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求。
+
+        doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即都会按照doPost方法中的逻辑进行处理，比如查询相关数据列表、保存到会话中以及转发请求到添加教师的JSP页面等操作。
     }
-}
+}

src/web/servlet/teacher/DeleteOptionalCourseServlet.java

@@ -1,7 +1,11 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，通过包来对类进行分类管理，使项目代码结构更加清晰，便于区分不同功能模块对应的代码。
 
 import service.TeacherService;
 import service.impl.TeacherServiceImpl;
+// 导入教师相关业务逻辑的服务接口（TeacherService）以及该接口的具体实现类（TeacherServiceImpl）。
+// TeacherService接口定义了一系列针对教师业务操作的抽象方法，例如这里可能涉及到对课程相关操作的方法声明等。
+// TeacherServiceImpl类则是对TeacherService接口的具体实现，里面包含了与数据库或其他数据源交互，来实际完成业务逻辑的代码，比如具体的课程删除操作实现等。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -10,18 +14,44 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及可能出现的异常情况。
+// ServletException用于处理Servlet执行过程中出现的异常情况，比如业务逻辑执行出错、配置错误等。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，我们可以通过重写它的方法来实现具体的业务逻辑处理。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，像请求参数、请求头信息等，是后续处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，例如设置响应状态码、响应头以及返回响应内容等，用于构建返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它可以在不同的请求之间共享数据，不过在这段代码里暂时没有明显体现出对会话信息的复杂使用场景。
+// IOException用于处理输入输出相关的异常，例如读写文件、网络传输等出现问题时会抛出该异常。
 
 @WebServlet("/deleteOptionalCourseServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/deleteOptionalCourseServlet"。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等）就会找到并调用这个Servlet来处理请求。
 public class DeleteOptionalCourseServlet extends HttpServlet {
+    // 定义一个名为DeleteOptionalCourseServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑，这里主要是实现删除可选课程的业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的URL路径时，容器会调用这个方法来处理请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则用于向客户端返回响应信息。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性，特别是这里要获取课程编号等信息，防止乱码很重要。
+
         String cid = request.getParameter("cid");
+        // 从客户端发送的HTTP请求中获取名为"cid"的参数值，该参数值通常代表要删除的课程的编号（具体含义取决于业务逻辑中的定义），将获取到的课程编号赋值给cid变量，以便后续根据这个编号进行课程删除操作。
+
         TeacherService service = new TeacherServiceImpl();
+        // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量service。这样后续就可以调用TeacherService接口中定义的业务方法，而具体的删除课程操作的实现则由TeacherServiceImpl类来完成。
+
         service.deleteCourseById(cid);
-        request.getRequestDispatcher("/teacherOptionalCourseServlet").forward(request,response);
+        // 调用service（实际是TeacherServiceImpl的实例）的deleteCourseById方法，传入刚才获取到的课程编号cid，该方法应该是在数据库或其他存储课程信息的数据源中，根据课程编号来删除对应的课程记录，实现课程删除的业务逻辑操作。
+
+        request.getRequestDispatcher("/teacherOptionalCourseServlet").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到"/teacherOptionalCourseServlet"这个资源（可能是另一个Servlet或者JSP页面等）。这样服务器端会接着处理转发后的请求，并向客户端返回相应的响应内容，整个过程对客户端来说是一次完整的请求响应过程，地址栏中的URL不会发生改变，通过转发可以继续后续的页面展示或者其他相关业务处理。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求。
+
+        doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即都会按照doPost方法中的逻辑进行处理，比如获取课程编号、删除课程以及转发请求等操作。
     }
-}
+}

src/web/servlet/teacher/DeleteTeacherServlet.java

@@ -1,7 +1,11 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，利用包来对类进行分类组织，使项目的代码结构更加清晰有条理，便于区分不同功能模块对应的类。
 
 import service.TeacherService;
 import service.impl.TeacherServiceImpl;
+// 导入教师业务相关的服务接口（TeacherService）以及该接口对应的具体实现类（TeacherServiceImpl）。
+// TeacherService接口通常会定义一系列针对教师相关业务操作的抽象方法，比如删除教师、查询教师信息等操作的方法声明。
+// TeacherServiceImpl类则是对TeacherService接口的具体实现，其内部包含了与数据库或者其他数据源进行交互的代码，以此来实际完成相应的业务逻辑，例如这里涉及的根据教师编号删除教师信息的具体实现就在这个类中。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -10,18 +14,44 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及可能出现的异常情况。
+// ServletException用于处理Servlet在执行过程中出现的各种异常，像业务逻辑出错、配置不正确等情况引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并且可以配置这个Servlet对应的访问路径等相关属性，方便Web容器（例如Tomcat等服务器）识别并对其进行管理和调度。
+// HttpServlet是所有基于HTTP协议的Servlet的基础类，它提供了处理HTTP请求的基本结构和相关方法，开发人员可以通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest主要用于获取客户端发送过来的HTTP请求中包含的各种信息，比如请求参数、请求头里的数据等，它是后续在Servlet中处理请求数据的重要入口。
+// HttpServletResponse用于向客户端发送HTTP响应，例如设置响应的状态码、响应头的相关信息以及返回具体的响应内容等，以此构建完整的返回给客户端的信息。
+// HttpSession用于在服务器端管理用户的会话信息，通过它能够实现在不同的请求之间共享数据，不过在当前这段代码里暂时没有复杂的针对会话信息的操作体现。
+// IOException用于处理输入输出相关的异常情况，像读写文件过程中、网络传输数据时等出现问题就会抛出该异常。
 
 @WebServlet("/deleteTeacherServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定这个Servlet对应的访问路径为"/deleteTeacherServlet"。当客户端通过这个特定的URL路径发起HTTP请求时，Web容器就会找到并调用这个Servlet来处理请求。
 public class DeleteTeacherServlet extends HttpServlet {
+    // 定义了一个名为DeleteTeacherServlet的类，它继承自HttpServlet类，这就表明这个类是一个专门用于处理HTTP请求的Servlet，借助继承HttpServlet类的特性，可以方便地重写其中的方法来实现具体的业务逻辑，此处重点在于实现删除教师的相关业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写了HttpServlet类中的doPost方法，该方法主要用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的"/deleteTeacherServlet"这个URL路径时，Web容器会自动调用这个方法来处理相应的请求。
+        // 方法中的参数request包含了客户端发送过来的全部请求信息，而response则是用于向客户端返回响应信息的对象。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，这一步操作很关键，它能确保从客户端接收到的请求参数等各类数据可以按照UTF-8编码格式被准确地解析出来，有效避免中文或者其他特殊字符出现乱码的问题，从而保障后续获取和处理请求数据时的准确性，在这里特别重要的是保证获取教师编号等关键信息不出错。
+
         String teacherid = request.getParameter("tid");
+        // 从客户端发送的HTTP请求中获取名为"tid"的参数值，按照业务逻辑推测，这个参数值通常代表着要删除的教师的编号，然后将获取到的教师编号赋值给teacherid变量，方便后续依据这个编号进行删除教师的具体操作。
+
         TeacherService service = new TeacherServiceImpl();
+        // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量service。如此一来，后续就能调用TeacherService接口里定义的各种业务方法了，而具体的删除教师操作的实际代码实现则是由TeacherServiceImpl类来完成的。
+
         service.deleteTeacherById(teacherid);
-        request.getRequestDispatcher("/teacherListServlet").forward(request,response);
+        // 调用service（实际上就是TeacherServiceImpl的实例）的deleteTeacherById方法，将前面获取到的教师编号teacherid作为参数传入进去。这个方法应该是在数据库或者其他存储教师信息的数据源中，依据传入的教师编号来查找并删除对应的教师记录，以此实现删除教师的业务逻辑操作。
+
+        request.getRequestDispatcher("/teacherListServlet").forward(request, response);
+        // 获取一个请求转发器，把当前的请求转发到"/teacherListServlet"这个资源（它可能是另一个Servlet或者是一个JSP页面等）。通过这样的转发操作，服务器端会接着去处理转发后的请求，并向客户端返回相应的响应内容，而且整个过程对于客户端来说就像是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，转发后可以继续进行后续的页面展示或者其他相关业务处理，例如重新展示教师列表等。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，该方法主要用于处理HTTP GET请求。
+
+        doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，这意味着对于GET请求的处理逻辑和POST请求的处理逻辑是完全一样的，也就是都会按照doPost方法里所定义的逻辑去进行相应的处理，比如获取教师编号、删除教师以及转发请求等操作都会同样执行。
     }
-}
+}

src/web/servlet/teacher/FindStudentCourseScoreServlet.java

@@ -1,8 +1,13 @@
 package web.servlet.teacher;
+// 声明该类所属的包名，表明这个Servlet类位于"web.servlet.teacher"包下，通过包结构对类进行组织管理，有助于清晰地划分项目中的不同功能模块，方便代码的维护与扩展。
 
 import domain.SelectCourse;
 import service.SelectCourseService;
 import service.impl.SelectCourseServiceImpl;
+// 导入相关的类和接口，用于处理选课相关的业务逻辑。
+// "domain.SelectCourse"：通常是一个领域模型类，用于封装与选课相关的各种属性，比如学生所选课程的具体信息（课程编号、学生编号等）以及对应的成绩等内容，代表了业务领域中的选课这一概念实体在代码中的体现。
+// "service.SelectCourseService"：这是定义了选课业务操作的服务接口，规定了可以在选课业务方面进行的各种操作方法，例如查询学生选课信息、更新选课记录等，是对选课业务逻辑抽象出来的统一操作入口。
+// "service.impl.SelectCourseServiceImpl"：是"SelectCourseService"接口的具体实现类，里面包含了实际与数据库或其他数据源进行交互的代码，以此来真正完成接口中定义的那些选课业务操作，比如按照特定条件查询数据库获取选课信息等具体实现细节就在这个类中。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -11,26 +16,55 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
+// 导入Java EE中Servlet相关的基础类和接口以及处理输入输出异常、使用集合框架所需的类。
+// "ServletException"：用于处理Servlet在执行过程中出现的各种异常情况，比如配置错误、业务逻辑执行出错、请求处理过程中遇到不符合预期的情况等，都可以通过抛出这个异常来进行相应的处理。
+// "WebServlet"：是一个注解类，用于将一个普通的Java类标注为Servlet，并可以通过它配置该Servlet对应的访问路径等相关属性，方便Web容器（像Tomcat等应用服务器）识别并对其进行管理和调度，决定何时以及如何调用这个Servlet来处理客户端的请求。
+// "HttpServlet"：是所有基于HTTP协议的Servlet的基类，它提供了处理HTTP请求的基础架构和一系列默认方法，开发人员通过重写它里面的特定方法（如doGet、doPost等）来实现具体的业务逻辑，以应对不同类型的HTTP请求。
+// "HttpServletRequest"：主要用于获取客户端发送过来的HTTP请求中包含的各种详细信息，例如请求参数（通过类似getParameter方法获取表单提交的数据等）、请求头信息（如浏览器相关的一些标识信息等）以及其他和请求相关的内容，是在Servlet中处理请求数据的关键入口。
+// "HttpServletResponse"：负责向客户端发送HTTP响应，包括设置响应的状态码（比如200表示成功、404表示未找到资源等）、响应头（设置如内容类型、缓存控制等相关的头部信息）以及返回具体的响应内容（如HTML页面、JSON数据等），用于构建完整的返回给客户端的信息。
+// "IOException"：用于处理输入输出相关的异常情况，例如在读取或写入文件、进行网络传输（像从数据库获取数据或者向客户端发送响应数据等涉及到数据传输的操作）等过程中如果出现问题，就会抛出这个异常，方便进行相应的错误处理。
+// "List"：是Java集合框架中的接口，表示一个有序的、可包含重复元素的集合，在这里用于存放查询出来的多个选课相关信息（以SelectCourse对象的形式），方便后续对这些数据进行遍历、处理以及传递给其他组件（如JSP页面用于展示等）。
 
 @WebServlet("/findStudentCourseScoreServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定这个Servlet对应的访问路径为"/findStudentCourseScoreServlet"。意味着当客户端通过浏览器等工具，向服务器发起的HTTP请求的URL路径为该指定路径时，Web容器（服务器端负责管理Servlet的环境，如Tomcat）就会找到并调用这个Servlet类来处理相应的请求。
 public class FindStudentCourseScoreServlet extends HttpServlet {
+    // 定义了一个名为"FindStudentCourseScoreServlet"的类，它继承自"HttpServlet"类，这表明该类是一个专门用于处理HTTP请求的Servlet，借助继承"HttpServlet"类的机制，可以方便地重写其中相应的方法（比如doGet、doPost等）来实现具体的、与业务相关的请求处理逻辑，在这个类中主要是实现查询学生课程成绩相关的业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写了"HttpServlet"类中的"doPost"方法，此方法专门用于处理HTTP POST请求。当客户端通过POST方式（例如表单提交等情况常用POST方式向服务器发送数据）访问此Servlet对应的"/findStudentCourseScoreServlet"这个URL路径时，Web容器会自动调用这个重写后的方法来处理相应的请求。
+        // 方法中的两个参数"request"和"response"分别代表客户端发送过来的请求信息以及用于向客户端返回响应信息的对象，它们在整个请求处理过程中起着关键作用，通过它们可以获取请求数据、设置响应内容等。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，这一步非常重要，因为客户端发送过来的数据可能包含各种字符（特别是如果有中文等非ASCII字符时），如果不设置正确的编码，在获取请求参数等数据时可能会出现乱码问题，无法正确解析数据内容。通过设置为"utf-8"编码格式，能确保后续从请求中获取到的参数等数据可以按照正确的编码规范进行解析，保障数据的准确性和完整性，在这里对于获取要查询成绩的课程编号等关键信息尤为重要。
+
         String cid = request.getParameter("cid");
+        // 从客户端发送的HTTP请求中获取名为"cid"的参数值，按照业务逻辑推测，这个参数值通常代表要查询成绩的课程的编号，它是后续进行查询学生该课程成绩相关操作的重要依据，将获取到的课程编号赋值给"cid"变量，方便后续在代码中使用这个变量来调用相应的业务方法进行查询操作。
+
         System.out.println(cid);
+        // 将获取到的课程编号（cid）输出打印到控制台，这一般是出于调试目的，方便开发人员在运行程序时查看实际接收到的课程编号是否符合预期，比如检查前端页面传递过来的参数是否正确，或者在排查程序出现问题（例如查询不到数据等情况）时，通过查看这个参数值来确认是否是传入参数的问题，有助于快速定位和解决问题。
 
         SelectCourseService service = new SelectCourseServiceImpl();
+        // 创建一个"SelectCourseServiceImpl"类的实例，通过多态的方式将其赋值给"SelectCourseService"接口类型的变量"service"。这样做的好处是，代码后续调用"SelectCourseService"接口中定义的方法时，实际上执行的是"SelectCourseServiceImpl"类中对这些方法的具体实现代码，使得代码的结构更加灵活，便于替换不同的实现方式或者进行单元测试等操作，在这里就是为了调用选课业务相关的方法来查询学生选课及成绩信息。
+
         List<SelectCourse> scs =  service.findStudentSelectedCourseByCourseId(cid);
+        // 调用"service"（实际上就是"SelectCourseServiceImpl"的实例）的"findStudentSelectedCourseByCourseId"方法，将前面获取到的课程编号"cid"作为参数传入进去。这个方法应该是在数据库或者其他存储选课信息的数据源中，依据传入的课程编号来查询出选修该课程的所有学生的选课信息（这些信息会被封装到"SelectCourse"对象中，可能包含学生的学号、所选课程的具体信息以及对应的成绩等内容），并以"SelectCourse"对象组成的列表形式返回，然后将查询到的学生选课信息列表赋值给"scs"变量，方便后续对这些查询结果进行进一步的处理和展示。
+
         for (int i = 0; i < scs.size(); i++) {
             System.out.println(scs.get(i));
         }
+        // 使用循环遍历查询到的学生选课信息列表（scs），通过调用"scs.get(i)"方法获取列表中的每一个"SelectCourse"对象，并将其输出打印到控制台。同样，这一步大概率也是出于调试目的，方便开发人员查看查询出来的每一条选课信息是否准确完整，例如查看学生的信息、课程信息以及成绩等是否符合预期，有助于在出现数据问题时排查是查询逻辑错误还是数据源本身数据有误等情况，进一步辅助定位和解决问题。
 
-        request.setAttribute("scs",scs);
-        request.getRequestDispatcher("/WEB-INF/teacher/findSelectCourseListByCourseId.jsp").forward(request,response);
+        request.setAttribute("scs", scs);
+        // 使用"request"对象的"setAttribute"方法，将查询到的学生选课信息列表（scs）保存到请求对象中，设置的属性名为"scs"，这样在后续将请求转发到JSP页面等操作时，在目标JSP页面中就可以通过这个属性名（"scs"）来获取到该选课信息列表，进而可以在页面中进行数据展示等相关操作，例如通过JSP的标签或者脚本语言将这些选课信息以表格等形式展示给用户查看。
 
+        request.getRequestDispatcher("/WEB-INF/teacher/findSelectCourseListByCourseId.jsp").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到"/WEB-INF/teacher/findSelectCourseListByCourseId.jsp"这个JSP页面（通常该JSP页面会用于展示查询到的学生选课及成绩信息等相关内容，可能会通过循环遍历获取到的选课信息列表，然后将学生的学号、课程名、成绩等信息以合适的HTML元素展示出来）。这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对于客户端来说就像是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，通过这种转发机制可以顺利地进行后续的页面展示操作，将查询到的学生课程成绩等信息呈现给用户查看。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写了"HttpServlet"类中的"doGet"方法，此方法主要用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（通常这些情况会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
+        doPost(request, response);
+        // 在"doGet"方法中直接调用了"doPost"方法，这意味着对于GET请求的处理逻辑和POST请求的处理逻辑是完全一样的，也就是不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照"doPost"方法里所定义的逻辑去进行相应的处理，比如获取课程编号、查询选课信息、输出调试信息以及转发请求到JSP页面等操作都会同样执行，这样做可能是在业务逻辑上对于这两种请求方式获取和展示学生课程成绩信息的要求是一致的，所以进行了这样的复用处理。
     }
-}
+}

src/web/servlet/teacher/TeacherInfomationServlet.java

@@ -1,6 +1,8 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，利用包结构来对类进行分类组织，使项目代码结构更清晰，便于区分不同功能模块对应的代码。
 
 import domain.Teacher;
+// 导入领域模型类Teacher，这个类通常用于封装教师相关的各种属性（比如教师编号、姓名、所属院系等信息）以及可能的业务逻辑方法（如果有定义的话），在这里虽然暂时看不出具体使用情况，但可能后续会涉及到和教师信息相关的操作。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -9,14 +11,32 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及应对可能出现的异常情况。
+// ServletException用于处理Servlet执行过程中出现的异常，像业务逻辑执行出错、配置错误等引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并且可以配置这个Servlet对应的访问路径等属性，方便Web容器（如Tomcat等服务器）识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，开发人员可以通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，例如请求参数、请求头信息等，是后续在Servlet中处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，比如设置响应状态码、响应头以及返回响应内容等，以此构建完整的返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它能够实现在不同请求之间共享数据，不过在这段代码里暂时没有明显体现出对会话信息的使用场景。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
 
 @WebServlet("/teacherInfomationServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/teacherInfomationServlet"。当客户端通过这个特定的URL路径发起HTTP请求时，Web容器（如Tomcat服务器）就会找到并调用这个Servlet来处理请求。
 public class TeacherInfomationServlet extends HttpServlet {
+    // 定义了一个名为TeacherInfomationServlet的类，它继承自HttpServlet类，这意味着这个类是一个用于处理HTTP请求的Servlet，借助继承HttpServlet类的特性，可以方便地重写其中的方法来实现具体的业务逻辑，在这里主要用于实现和教师信息相关的某种业务逻辑（从转发的JSP页面推测可能是展示教师信息之类的功能）。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.getRequestDispatcher("/WEB-INF/teacher/tInformation.jsp").forward(request,response);
+        // 重写HttpServlet类中的doPost方法，该方法主要用于处理HTTP POST请求。当客户端通过POST方式（比如表单提交等情况常用POST方式向服务器发送数据）访问此Servlet对应的"/teacherInfomationServlet"这个URL路径时，Web容器会自动调用这个方法来处理相应的请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则是用于向客户端返回响应信息的对象。
+
+        request.getRequestDispatcher("/WEB-INF/teacher/tInformation.jsp").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到"/WEB-INF/teacher/tInformation.jsp"这个JSP页面。通常这个JSP页面会用于展示教师相关的信息（比如教师的个人基本信息、授课情况等，具体取决于页面的实现）。这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对客户端来说就像是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，通过转发请求可以进行后续的页面展示等业务操作，实现向用户展示教师信息的功能。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，该方法主要用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（这些情况通常会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
+        doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，这意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照doPost方法里所定义的逻辑去进行相应的处理，也就是都会将请求转发到"/WEB-INF/teacher/tInformation.jsp"这个JSP页面进行后续处理，可能是因为在业务逻辑上对于这两种请求方式展示教师信息的操作是相同的，所以进行了这样的复用处理。
     }
-}
+}

src/web/servlet/teacher/TeacherListServlet.java

@@ -1,4 +1,5 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，通过包名对类进行分类管理，有助于在项目中清晰地组织代码结构，方便区分不同功能模块对应的类。
 
 import domain.Admin;
 import domain.Student;
@@ -7,6 +8,14 @@ import service.StudentService;
 import service.TeacherService;
 import service.impl.StudentServiceImpl;
 import service.impl.TeacherServiceImpl;
+// 导入不同领域模型类以及相关的服务接口和实现类。
+// domain.Admin：通常用于封装管理员相关的属性和业务逻辑，代表了系统中管理员这一角色对应的实体信息。
+// domain.Student：用于封装学生相关的属性和业务逻辑，包含学生的学号、姓名等各种信息，是对学生这一业务实体在代码中的体现。
+// domain.Teacher：类似地，用于封装教师相关的属性和业务逻辑，比如教师的工号、姓名、授课信息等内容，代表教师这一业务实体。
+// service.StudentService：定义了针对学生业务操作的服务接口，规定了可以进行的各种学生相关业务方法，例如查询学生信息、添加学生等操作的抽象方法声明。
+// service.TeacherService：是针对教师业务操作的服务接口，明确了如查询教师信息、更新教师资料等相关业务操作的接口方法。
+// service.impl.StudentServiceImpl：是StudentService接口的具体实现类，里面包含了与数据库或其他数据源交互来实际完成学生业务逻辑的代码，比如具体的查询所有学生信息、根据学号查询某个学生等操作的实现就在这个类里。
+// service.impl.TeacherServiceImpl：同样，是TeacherService接口的具体实现类，负责实现教师业务相关操作的具体代码逻辑，像这里要调用的查询所有教师信息的方法就在这个类中实现。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -16,33 +25,73 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及可能出现的异常情况，同时导入用于处理集合数据和会话相关操作的类。
+// ServletException用于处理Servlet执行过程中出现的异常情况，例如业务逻辑执行出错、配置错误等引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器（如Tomcat等服务器）识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，开发人员可以通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，像请求参数、请求头信息等，是后续处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，例如设置响应状态码、响应头以及返回响应内容等，用于构建返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它可以在不同的请求之间共享数据，比如保存用户的登录状态、用户相关的一些临时数据等，在这里用于判断当前登录用户的角色类型。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
+// List是Java集合框架中的接口，表示一个有序的、可重复元素的集合，这里用于存放查询出来的教师信息列表（多个Teacher对象组成的列表）。
 
 @WebServlet("/teacherListServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/teacherListServlet"。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等）就会找到并调用这个Servlet来处理请求。
 public class TeacherListServlet extends HttpServlet {
+    // 定义一个名为TeacherListServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑，这里主要是实现查询教师列表并根据不同用户角色进行页面转发的业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        //调用TeacherService完成查询
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的URL路径时，容器会调用这个方法来处理请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则用于向客户端返回响应信息。
+
+        // 调用TeacherService完成查询
         TeacherService teacherService = new TeacherServiceImpl();
+        // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量teacherService。这样后续就可以调用TeacherService接口中定义的业务方法，而具体的查询所有教师信息的操作实现则由TeacherServiceImpl类来完成。
+
         List<Teacher> teachers = teacherService.findAll();
-        //将list存入request域
-        request.setAttribute("teachers",teachers);
+        // 调用teacherService（实际是TeacherServiceImpl的实例）的findAll方法，该方法应该是从数据库或其他存储教师信息的数据源中，查询出所有教师的信息，并以Teacher对象的列表形式返回，将查询到的教师信息列表赋值给teachers变量，以便后续使用这些数据进行页面展示等操作。
+
+        // 将list存入request域
+        request.setAttribute("teachers", teachers);
+        // 使用request对象的setAttribute方法，将查询到的教师信息列表（teachers）保存到请求对象中，设置的属性名为"teachers"，这样在后续转发请求到JSP页面等操作时，在目标页面中就可以通过这个属性名获取到该教师信息列表，用于展示教师信息的相关操作，比如在JSP页面中通过循环遍历列表展示每个教师的具体信息。
 
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性，虽然在这里暂时没有明显体现出获取参数的操作，但这是一个良好的编码习惯，防止后续可能的扩展或者其他地方出现乱码情况。
+
         HttpSession session = request.getSession();
-        Student student= (Student)session.getAttribute("student");
-        Admin admin= (Admin)session.getAttribute("admin");
-        Teacher teacher= (Teacher)session.getAttribute("teacher");
-        if (student != null && admin == null && teacher == null) {
+        // 获取当前请求对应的HttpSession对象，如果不存在则创建一个新的会话对象。HttpSession用于在服务器端管理用户的会话信息，在这里主要是为了获取会话中保存的当前登录用户的相关信息，以此来判断用户的角色类型，进而决定转发到哪个合适的页面进行教师列表展示。
+
+        Student student = (Student) session.getAttribute("student");
+        // 从HttpSession对象中尝试获取名为"student"的属性值，并将其强制转换为Student类型，该属性值通常是在用户登录成功后（如果是学生角色登录）保存到会话中的学生对象，通过这样的获取操作可以判断当前登录用户是否是学生角色。
+
+        Admin admin = (Admin) session.getAttribute("admin");
+        // 类似地，从会话中获取名为"admin"的属性值并转换为Admin类型，用于判断当前登录用户是否是管理员角色，若获取到的admin对象不为null，则表示当前是管理员登录状态。
+
+        Teacher teacher = (Teacher) session.getAttribute("teacher");
+        // 同样，从会话中获取名为"teacher"的属性值并转换为Teacher类型，用于判断当前登录用户是否是教师角色，若获取到的teacher对象不为null，则说明当前是教师登录状态。
+
+        if (student!= null && admin == null && teacher == null) {
+            // 判断如果从会话中获取到的学生对象不为null，同时管理员对象和教师对象都为null，即当前登录用户是学生角色，那么执行以下逻辑。
             request.getRequestDispatcher("/WEB-INF/student/sFindTeacherList.jsp").forward(request, response);
-        } else if (admin != null && student == null && teacher == null) {
+            // 获取一个请求转发器，将当前请求转发到"/WEB-INF/student/sFindTeacherList.jsp"这个JSP页面，该页面应该是专门为学生角色设计的用于展示教师列表信息的页面，服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对客户端来说是一次完整的请求响应过程，客户端浏览器地址栏中的URL不会发生改变。
+        } else if (admin!= null && student == null && teacher == null) {
+            // 如果管理员对象不为null，而学生对象和教师对象都为null，即当前登录用户是管理员角色，则执行以下转发操作。
             request.getRequestDispatcher("/WEB-INF/admin/aFindTeacherList.jsp").forward(request, response);
-        } else if (teacher != null && admin == null && student == null) {
+            // 将请求转发到"/WEB-INF/admin/aFindTeacherList.jsp"这个JSP页面，这大概率是为管理员设计的用于展示教师列表的页面，方便管理员进行相应的管理操作等查看教师信息。
+        } else if (teacher!= null && admin == null && student == null) {
+            // 若教师对象不为null，管理员对象和学生对象都为null，也就是当前登录用户是教师角色，执行如下转发操作。
             request.getRequestDispatcher("/WEB-INF/teacher/tFindTeacherList.jsp").forward(request, response);
+            // 把请求转发到"/WEB-INF/teacher/tFindTeacherList.jsp"这个JSP页面，此页面应该是适合教师查看教师列表信息的页面，可能会展示一些与教师自身相关视角下的教师信息内容。
         } else {
             request.getRequestDispatcher("error.jsp").forward(request, response);
+            // 如果以上几种判断条件都不满足，说明可能出现了不符合预期的会话状态或者用户角色情况，此时将请求转发到"error.jsp"页面，该页面通常用于展示错误信息，提示用户出现了未知的系统状态等问题。
         }
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        this.doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求。
+
+        this.doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即都会按照doPost方法中的逻辑进行处理，比如查询教师列表、判断用户角色以及根据角色转发请求到相应的JSP页面等操作。
     }
-}
+}

src/web/servlet/teacher/TeacherOptionalCourseServlet.java

@@ -1,4 +1,5 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于“web.servlet.teacher”包下，通过包结构对类进行分类管理，使项目代码的组织结构更加清晰，便于区分不同功能模块对应的代码所在位置。
 
 import domain.Course;
 import domain.Student;
@@ -7,6 +8,14 @@ import service.StudentService;
 import service.TeacherService;
 import service.impl.StudentServiceImpl;
 import service.impl.TeacherServiceImpl;
+// 导入不同的领域模型类以及相关的服务接口与实现类，用于处理业务逻辑中涉及到的数据和操作。
+// domain.Course：通常用于封装课程相关的各种属性（例如课程编号、课程名称、课程学分等信息）以及可能的业务逻辑方法（如果有针对课程对象自身的操作需求），代表了业务领域里课程这一实体在代码中的体现。
+// domain.Student：用于封装学生相关的各种属性（如学号、姓名、班级等）以及对应的业务逻辑，是对学生这个业务实体在代码层面的抽象表示，不过在当前这个Servlet中，从代码逻辑来看对学生相关操作体现并不明显，可能只是整体项目结构中涉及到的相关领域类导入。
+// domain.Teacher：类似地，用于封装教师相关的所有属性（像教师编号、姓名、所在院系等信息）和业务逻辑，在这个Servlet里会用于获取当前登录教师的信息以及后续和教师相关的业务操作关联。
+// service.StudentService：定义了针对学生业务操作的服务接口，规定了可以进行的各种学生相关业务操作的抽象方法，例如查询学生信息、添加学生、修改学生资料等方法声明，虽然此处不一定直接使用，但可能是项目中整体服务层接口的一部分被引入进来。
+// service.TeacherService：是专门针对教师业务操作所定义的服务接口，明确了像查询教师授课课程、更新教师信息等与教师业务相关的各种操作方法，为后续调用具体业务逻辑提供统一的接口规范。
+// service.impl.StudentServiceImpl：是StudentService接口的具体实现类，里面包含了与数据库或其他数据源进行实际交互的代码，以此来真正完成StudentService接口中定义的那些学生业务逻辑操作，比如具体的从数据库查询学生信息、往数据库插入新学生记录等实现细节都在这个类里，不过在此Servlet中暂时未直接调用其方法。
+// service.impl.TeacherServiceImpl：同样，它是TeacherService接口的具体实现类，负责实现教师业务相关操作的具体代码逻辑，例如这里要调用的根据教师编号查询该教师可选课程的方法就在这个类中进行具体实现。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -16,25 +25,58 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及应对可能出现的异常情况，同时导入用于处理集合数据类型和会话相关操作的类。
+// ServletException：用于处理Servlet在执行过程中出现的各种异常情况，比如业务逻辑执行出错、配置错误、请求处理不符合预期等情况引发的异常都会通过这个类来处理，方便进行统一的异常管理和错误提示。
+// WebServlet：是一个注解类，通过它可以将一个普通的Java类标注为Servlet，并配置该Servlet对应的访问路径等相关属性，方便Web容器（像Tomcat等应用服务器）能够识别并对其进行合适的管理与调度，决定何时以及如何调用这个Servlet来处理客户端的请求。
+// HttpServlet：是所有基于HTTP协议的Servlet的基类，它提供了处理HTTP请求的基础架构和一系列默认的方法，开发人员通过重写它里面特定的方法（如doGet、doPost等）来实现具体的业务逻辑，以应对不同类型的HTTP请求。
+// HttpServletRequest：主要用于获取客户端发送过来的HTTP请求中包含的各种详细信息，例如通过相关方法获取请求参数（像表单提交的数据等）、请求头信息（如浏览器相关的一些标识、请求的一些元数据等）以及其他和请求相关的内容，是在Servlet中处理请求数据的关键入口。
+// HttpServletResponse：负责向客户端发送HTTP响应，包括设置响应的状态码（比如常见的200表示成功、404表示未找到资源等）、响应头（例如设置响应内容的类型、缓存控制相关的信息等）以及返回具体的响应内容（像HTML页面、JSON数据等），以此构建完整的返回给客户端的信息。
+// HttpSession：用于在服务器端管理用户的会话信息，通过它可以实现在不同的请求之间共享数据，比如保存用户的登录状态、用户相关的一些临时数据等，在这个Servlet里主要用于获取当前登录教师的对象信息，以判断登录状态以及后续基于教师身份进行相关业务操作。
+// IOException：用于处理输入输出相关的异常情况，例如在读取或写入文件、进行网络传输（像从数据库获取数据或者向客户端发送响应数据等涉及到数据传输的操作过程中）如果出现问题，就会抛出这个异常，方便进行相应的错误处理和恢复机制实现。
+// List：是Java集合框架中的接口，表示一个有序的、可包含重复元素的集合，在这里用于存放查询出来的课程相关信息（以Course对象的形式），方便后续对这些数据进行遍历、展示或者其他相关的业务处理操作。
 
 @WebServlet("/teacherOptionalCourseServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定这个Servlet对应的访问路径为“/teacherOptionalCourseServlet”。这意味着当客户端通过浏览器等工具向服务器发起的HTTP请求的URL路径为该指定路径时，Web容器（服务器端负责管理Servlet的环境，如Tomcat）就会找到并调用这个Servlet类来处理相应的请求。
 public class TeacherOptionalCourseServlet extends HttpServlet {
+    // 定义了一个名为TeacherOptionalCourseServlet的类，它继承自HttpServlet类，这表明该类是一个专门用于处理HTTP请求的Servlet，借助继承HttpServlet类的机制，可以方便地重写其中相应的方法（比如doGet、doPost等）来实现具体的、与业务相关的请求处理逻辑，在这个类中主要是实现与教师可选课程相关的业务逻辑，例如查询并展示教师能够选择教授的课程信息等。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写了HttpServlet类中的doPost方法，此方法专门用于处理HTTP POST请求。当客户端通过POST方式（例如表单提交等情况常用POST方式向服务器发送数据）访问此Servlet对应的“/teacherOptionalCourseServlet”这个URL路径时，Web容器会自动调用这个重写后的方法来处理相应的请求。
+        // 方法中的两个参数“request”和“response”分别代表客户端发送过来的请求信息以及用于向客户端返回响应信息的对象，它们在整个请求处理过程中起着关键作用，通过它们可以获取请求数据、设置响应内容等。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为“utf-8”，这是非常重要的一步操作，因为客户端发送过来的数据可能包含各种字符（特别是如果存在中文等非ASCII字符时），若不设置正确的编码，在获取请求参数等数据时可能会出现乱码问题，导致无法正确解析数据内容。通过将编码格式设置为“utf-8”，能确保后续从请求中获取到的参数等数据可以按照正确的编码规范进行解析，保障数据的准确性和完整性，在这里对于后续可能涉及到的各种参数获取以及业务操作都有重要意义。
+
         HttpSession session = request.getSession();
+        // 获取当前请求对应的HttpSession对象，如果不存在则创建一个新的会话对象。HttpSession在服务器端用于管理用户的会话信息，在这里主要是为了从会话中获取当前登录教师的相关信息，以此来确定登录状态以及进行后续基于教师身份的业务操作，例如获取教师编号来查询其可选课程等。
+
         Teacher t = (Teacher) session.getAttribute("teacher");
-        if (t != null) {
-            //调用StudentService完成查询
+        // 从HttpSession对象中尝试获取名为“teacher”的属性值，并将其强制转换为Teacher类型。通常情况下，在用户（这里指教师）登录成功后，会将教师对象保存到会话中，对应的属性名为“teacher”，通过这样的获取操作可以得到当前登录教师的对象信息，后续就能基于这个对象进行相关业务逻辑操作，比如获取教师编号去查询该教师可教授的课程等。
+
+        if (t!= null) {
+            // 判断获取到的教师对象t是否不为null，即判断当前是否有教师登录，如果有教师登录，才执行下面的业务逻辑操作，若为null则可能表示没有合法登录的教师，就不会进行后续的课程查询和页面展示等操作。
+
+            // 调用StudentService完成查询
             TeacherService service = new TeacherServiceImpl();
+            // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量“service”。这样做的好处是，代码后续调用TeacherService接口中定义的方法时，实际上执行的是TeacherServiceImpl类中对这些方法的具体实现代码，使得代码结构更加灵活，便于替换不同的实现方式或者进行单元测试等操作，在这里就是为了调用教师业务相关的方法来查询教师可选课程信息。
+
             List<Course> optionalcourses = service.findMySelfOptionalCourse(t.getT_id());
-            //将list存入request域
-            request.setAttribute("optionalcourses",optionalcourses);
-            //转发到list.jsp
-            request.getRequestDispatcher("/WEB-INF/teacher/teacherOptionalCourse.jsp").forward(request,response);
+            // 调用“service”（实际上就是TeacherServiceImpl的实例）的“findMySelfOptionalCourse”方法，将前面获取到的教师对象t的教师编号（通过t.getT_id()方法获取）作为参数传入进去。这个方法应该是在数据库或者其他存储课程信息的数据源中，依据传入的教师编号来查询出该教师能够选择教授的所有课程信息，并以Course对象组成的列表形式返回，然后将查询到的可选课程信息列表赋值给“optionalcourses”变量，方便后续对这些查询结果进行进一步的处理和展示操作，比如在页面上展示课程列表供教师查看选择等。
+
+            // 将list存入request域
+            request.setAttribute("optionalcourses", optionalcourses);
+            // 使用“request”对象的“setAttribute”方法，将查询到的可选课程信息列表（optionalcourses）保存到请求对象中，设置的属性名为“optionalcourses”，这样在后续将请求转发到JSP页面等操作时，在目标JSP页面中就可以通过这个属性名（“optionalcourses”）来获取到该课程列表信息，进而可以在页面中进行数据展示等相关操作，例如通过循环遍历课程列表，将每个课程的名称、编号等信息以合适的HTML元素展示出来给教师查看。
+
+            // 转发到list.jsp
+            request.getRequestDispatcher("/WEB-INF/teacher/teacherOptionalCourse.jsp").forward(request, response);
+            // 获取一个请求转发器，将当前请求转发到“/WEB-INF/teacher/teacherOptionalCourse.jsp”这个JSP页面（通常该JSP页面会用于展示教师可选课程的相关信息，可能会通过循环遍历获取到的课程列表，然后将课程名、课程编号、课程学分等信息以合适的方式展示出来，方便教师进行查看和后续操作）。这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对于客户端来说就像是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，通过这种转发机制可以顺利地进行后续的页面展示操作，将教师可选课程信息呈现给教师查看。
         }
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        this.doPost(request,response);
+        // 重写了HttpServlet类中的doGet方法，此方法主要用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（通常这些情况会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
+        this.doPost(request, response);
+        // 在“doGet”方法中直接调用了“doPost”方法，这意味着对于GET请求的处理逻辑和POST请求的处理逻辑是完全一样的，也就是不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照“doPost”方法里所定义的逻辑去进行相应的处理，比如设置请求编码、获取教师登录信息、查询教师可选课程、将课程列表保存到请求对象以及转发请求到JSP页面等操作都会同样执行，这样做可能是在业务逻辑上对于这两种请求方式获取和展示教师可选课程信息的要求是一致的，所以进行了这样的复用处理。
     }
-}
+}