src/service/AdminService.java

@@ -1,43 +1,18 @@
-以下是添加注释后的代码：
-
-```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,47 +1,20 @@
 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,28 +1,14 @@
 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,36 +2,10 @@ 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,47 +1,23 @@
 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,36 +2,10 @@ 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,44 +1,13 @@
 package service;
 
 import domain.SelectCourse;
+
 import java.util.List;
 
-/**
- * 选课相关业务的接口，定义了针对学生选课情况以及课程成绩等相关操作的抽象方法，
- * 具体的业务逻辑将由实现该接口的类来完成，为处理选课及成绩相关事务提供统一的规范和调用入口。
- */
 public interface SelectCourseService {
-    /**
-     * 根据课程编号查找学生已选该课程情况的方法。
-     * 通过传入课程的唯一标识符（课程编号cid），从相关存储（例如数据库中选课记录等）里查询出选修了该课程的所有学生的选课信息，
-     * 并以SelectCourse对象列表的形式返回，列表中的每个SelectCourse对象代表一名学生关于该课程的选课相关信息（如选课时间、是否退选等情况），
-     * 如果没有学生选修该课程，则返回一个空列表。
-     *
-     * @param cid 课程的唯一编号，用于定位要查找学生选课情况的课程
-     * @return 包含选修该课程的学生选课信息的SelectCourse对象列表，若没有学生选修则返回空列表
-     */
     List<SelectCourse> findStudentSelectedCourseByCourseId(String cid);
 
-    /**
-     * 根据课程编号和学生编号查找学生该课程成绩的方法。
-     * 传入课程的唯一编号（cid）以及学生的唯一编号（sid），在存储成绩信息的相关数据结构（比如数据库成绩表等）中查找对应的学生在该课程上的成绩记录，
-     * 如果找到，则返回对应的SelectCourse对象（该对象包含成绩等相关选课信息），若未找到相应成绩记录则可能返回null（具体取决于实现类的处理方式）。
-     *
-     * @param cid 课程的唯一编号，用于定位要查找成绩的课程
-     * @param sid 学生的唯一编号，用于定位要查找成绩的学生
-     * @return 查找到的包含学生该课程成绩的SelectCourse对象，如果未找到则返回情况依具体实现而定
-     */
-    SelectCourse findScoreByCourseIdAndStudentId(String cid, String sid);
+    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,146 +8,44 @@ import java.util.List;
 import java.util.Map;
 
 /**
- * 学生管理的业务接口，定义了一系列与学生相关业务操作的抽象方法，
- * 这些方法涵盖了学生信息查询、登录、注册、信息更新、选课操作以及学生相关数据删除等多方面内容，
- * 具体的业务逻辑将由实现该接口的类来完成，方便对学生管理相关业务进行统一规范和拓展。
+ * 学生管理的业务接口
  */
 public interface StudentService {
     /**
-     * 分页条件查询方法。
-     * 根据传入的当前页码（currentPage）、每页显示行数（rows）以及查询条件（condition，以Map形式存储，键为查询条件字段名，值为对应字段值的数组），
-     * 从数据源（如数据库等）中按照分页和给定条件筛选出相应的学生信息，返回一个PageBean对象，该对象中包含了符合条件的学生信息列表以及分页相关的元数据（如总页数、总记录数等）。
-     *
-     * @param currentPage 当前页码，用于确定要获取哪一页的数据
-     * @param rows 每页显示的行数，用于控制每页展示的学生信息数量
-     * @param condition 包含查询条件的Map对象，用于筛选出符合特定条件的学生信息
-     * @return 包含符合条件学生信息及分页相关元数据的PageBean<Student>对象
+     * 分页条件查询
+     * @param currentPage
+     * @param rows
+     * @param condition
+     * @return
      */
     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,107 +2,35 @@ 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);
 
-    /**
-     * 根据课程编号删除课程信息的方法。
-     * 传入课程的唯一编号（cid），由实现该接口的类负责从相应的存储（比如数据库中的课程记录等）中删除该编号对应的课程信息，
-     * 具体的删除逻辑及涉及的相关操作（如关联数据的处理等）由实现该接口的类依据业务需求去完成。
-     *
-     * @param cid 课程的唯一编号，用于定位要删除的课程信息
-     */
+    void deleteCourseById(String 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/utils/JDBCUtils.java

@@ -1,6 +1,7 @@
 package utils;
 
 import com.alibaba.druid.pool.DruidDataSourceFactory;
+
 import javax.sql.DataSource;
 import java.sql.Connection;
 import java.sql.ResultSet;
@@ -9,22 +10,17 @@ import java.sql.Statement;
 import java.util.Properties;
 
 /**
- * Druid连接池工具类，主要用于管理数据库连接相关操作，方便将来dao层调用，
- * 通过该工具类可以获取数据库连接、释放相关资源（如关闭结果集、语句对象、连接等）以及获取连接池对象等，有助于更规范、高效地进行数据库交互操作。
+ * Druid连接池工具类,将来dao层调用
  */
 public class JDBCUtils {
-    // 定义成员变量DataSource，用于存储通过Druid连接池工厂创建的数据源对象，后续通过该数据源获取数据库连接
-    private static DataSource dataSource;  
-
+    private static DataSource dataSource;   //定义成员变量DataSource
     static {
         try {
-            // 加载配置文件，此处通过类加载器获取类路径下名为"druid.properties"的配置文件，并将其加载到Properties对象中，
-            // 配置文件中通常包含了连接数据库所需的各种参数，如数据库驱动、连接地址、用户名、密码等信息。
+            //加载配置文件
             Properties properties = new Properties();
             properties.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
 
-            // 获取DataSource，利用Druid提供的DruidDataSourceFactory工厂类，根据加载的配置文件属性创建数据源对象，
-            // 如果创建过程出现异常（如配置文件格式错误、缺少关键配置项等），则会打印异常堆栈信息。
+            //获取DataSource
             dataSource = DruidDataSourceFactory.createDataSource(properties);
         } catch (Exception e) {
             e.printStackTrace();
@@ -32,38 +28,21 @@ 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) {
@@ -71,7 +50,7 @@ public class JDBCUtils {
             }
         }
 
-        if (statement!= null) {
+        if (statement != null) {
             try {
                 statement.close();
             } catch (SQLException e) {
@@ -79,25 +58,19 @@ 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,6 +3,7 @@ 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;
@@ -11,40 +12,20 @@ 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");
@@ -78,24 +59,13 @@ 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,6 +6,7 @@ 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;
@@ -15,28 +16,8 @@ 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();
@@ -46,23 +27,14 @@ 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,40 +7,13 @@ 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,6 +6,7 @@ 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;
@@ -15,39 +16,12 @@ 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");
@@ -55,19 +29,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);
@@ -75,17 +49,7 @@ 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,6 +5,7 @@ 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;
@@ -13,49 +14,18 @@ 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,11 +1,14 @@
 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;
@@ -17,50 +20,21 @@ 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");
@@ -73,10 +47,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);
@@ -90,26 +64,16 @@ 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,6 +6,7 @@ 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;
@@ -15,36 +16,8 @@ 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();
@@ -55,31 +28,21 @@ 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,6 +8,7 @@ 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;
@@ -17,69 +18,33 @@ 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,6 +4,7 @@ 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;
@@ -13,35 +14,8 @@ 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");
 
@@ -51,8 +25,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("")) {
@@ -68,17 +42,7 @@ 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,6 +3,7 @@ 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;
@@ -11,47 +12,16 @@ 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,6 +3,7 @@ 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;
@@ -11,47 +12,17 @@ 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,28 +8,19 @@ 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");
-        // 根据Servlet上下文获取"upload"目录的真实路径，并与文件名拼接起来，构造出要删除文件的完整路径，创建对应的File对象
-        File file = new File(this.getServletContext().getRealPath("upload") + File.separator + fileName);
-        // 判断文件是否存在，如果存在则执行删除操作
+        File file = new File(this.getServletContext().getRealPath("upload")+File.separator+fileName);
         if (file.exists()) {
             file.delete();
         }
-        // 将请求转发到"/fileListServlet"对应的Servlet（应该是用于展示文件列表之类的功能），以更新文件列表等相关显示内容
-        request.getRequestDispatcher("/fileListServlet").forward(request, response);
+        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,79 +15,48 @@ 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;
-        // 通过循环从输入流读取数据到字节数组，每次读取的数据长度存放在len变量中，当读取到文件末尾时len为-1，循环结束
-        while ((len = in.read(bs))!= -1) {
-            // 将读取到的字节数据（长度为len）从字节数组bs中写入到输出流out，实现将文件内容发送给客户端
+        while ((len = in.read(bs)) != -1) {
             out.write(bs, 0, len);
         }
-
-        // 关闭输出流，释放相关资源
         out.close();
-        // 关闭输入流，释放相关资源
         in.close();
 
-        // 获取当前请求的HttpSession对象，用于获取会话中存储的用户相关信息
         HttpSession session = request.getSession();
-        // 从会话中尝试获取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) {
+        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) {
             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,104 +18,71 @@ 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()) {
-            // 在控制台打印提示信息，说明"upload"目录不存在，需要创建
+        if (!dir.exists() && !dir.isDirectory()) {
             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>();
-
-        // 遍历"upload"目录下的所有文件（通过增强for循环遍历File数组）
-        for (File f : arrs) {
-            // 获取文件的字节长度，即文件大小（单位为字节）
+        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 = (Student) session.getAttribute("student");
-        // 从会话中尝试获取Admin类型的用户对象，如果存在表示当前登录用户是管理员角色
-        Admin admin = (Admin) session.getAttribute("admin");
-        // 从会话中尝试获取Teacher类型的用户对象，如果存在表示当前登录用户是教师角色
-        Teacher teacher = (Teacher) session.getAttribute("teacher");
+        Student student= (Student)session.getAttribute("student");
 
-        // 判断如果当前登录用户是学生角色，且不是管理员和教师角色，那么请求转发到学生角色对应的文件列表页面（"/WEB-INF/student/sFindFileList.jsp"）
-        if (student!= null && admin == null && teacher == null) {
+        Admin admin= (Admin)session.getAttribute("admin");
+        Teacher teacher= (Teacher)session.getAttribute("teacher");
+        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) {
-        // 将传入的文件大小字节数转换为double类型，方便后续进行数值计算和比较
+        // 如果字节数少于1024，则直接以B为单位，否则先除于1024，后3位因太少无意义
         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作为单位，将数值转换为字符串并拼接上单位"KB"
+        // 如果原字节数除于1024之后，少于1024，则可以直接以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为单位的数值，将其转换为字符串并拼接上单位"GB"后返回
+            // 否则如果要以GB为单位的，先除于1024再作同样的处理
             value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
             return String.valueOf(value) + "GB";
         }
     }
-}
+}

src/web/servlet/file/FileServlet.java

@@ -7,21 +7,13 @@ 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 {
-        // 将当前请求转发到"/WEB-INF/admin/uploadFile.jsp"页面。
-        // 通常这样做可能是引导用户进入文件上传的相关页面，
-        // 比如后续在该JSP页面中会提供文件上传的表单等操作界面供用户进行文件上传操作。
-        request.getRequestDispatcher("/WEB-INF/admin/uploadFile.jsp").forward(request, response);
+        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,123 +20,80 @@ import java.awt.image.BufferedImage;
 import java.io.*;
 import java.net.ServerSocket;
 
-// 使用WebServlet注解将该类映射到"/showPhotoServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/showPhotoServlet")
 public class ShowPhotoServlet extends HttpServlet {
-    // 定义表示GIF图片的MIME类型及字符编码，用于设置响应头中Content-Type字段，表明输出的内容类型为GIF图片格式
-    private static final String GIF = "image/gif;charset=GB2312";
-    // 定义表示JPEG图片的MIME类型及字符编码，用于设置响应头中Content-Type字段，表明输出的内容类型为JPEG图片格式
+    private static final String GIF = "image/gif;charset=GB2312";// 设定输出的类型
+
     private static final String JPG = "image/jpeg;charset=GB2312";
 
-    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        // 从请求中获取名为"spec"的参数，该参数用于标识要输出图片的类型（可能是用于区分不同格式图片之类的标识）
-        String spec = request.getParameter("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) {
-            // 创建PhotoService的实现类实例，用于调用业务逻辑层方法来获取学生对应的照片信息
+        if (student != null) {
             PhotoService service = new PhotoServiceImpl();
-            // 通过业务逻辑层方法，根据学生的ID（student.getS_id()）查找对应的照片信息，并赋值给p对象
             p = service.findPhotoByPhotoId(student.getS_id());
-        } else {
-            // 如果不是学生角色，即当前登录用户是教师角色，同样创建PhotoService的实现类实例
+        }else{
             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();
 
-        // 获取ServletResponse的输出流，用于向客户端输出图片数据，实现图片展示功能
-        OutputStream output = response.getOutputStream();
+        response.reset();
 
-        // 判断图片文件路径是否以".jpg"结尾，即判断是否为JPEG格式图片，若是则进行以下JPEG图片处理逻辑
-        if (imagePath.toLowerCase().endsWith(".jpg")) {
-            // 设置响应头的Content-Type为JPEG图片对应的MIME类型，告知客户端返回的是JPEG格式的图片数据
-            response.setContentType(JPG);
+        OutputStream output = response.getOutputStream();// 得到输出流
+        if (imagePath.toLowerCase().endsWith(".jpg"))// 使用编码处理文件流的情况：
+        {
+            response.setContentType(JPG);// 设定输出的类型
+            // 得到图片的真实路径
 
-            // 根据图片的真实路径创建FileInputStream对象，用于读取图片文件的原始数据
+            // 得到图片的文件流
             InputStream imageIn = new FileInputStream(new File(imagePath));
-            // 通过JPEGCodec创建JPEGImageDecoder对象，用于对读取到的JPEG格式文件流进行解码操作，将其转换为BufferedImage对象（便于后续处理）
+            // 得到输入的编码器，将文件流进行jpg格式编码
             JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(imageIn);
-            // 使用解码器对图片文件流进行解码，得到BufferedImage类型的图片对象，该对象包含了图片的像素等信息
+            // 得到编码后的图片对象
             BufferedImage image = decoder.decodeAsBufferedImage();
-            // 通过JPEGCodec创建JPEGImageEncoder对象，用于对处理后的图片进行编码，以便输出到客户端
+            // 得到输出的编码器
             JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(output);
-            // 使用编码器将BufferedImage类型的图片对象进行编码，并通过输出流输出到客户端，实现JPEG图片的展示
-            encoder.encode(image);
-            // 关闭用于读取图片文件的输入流，释放相关资源
-            imageIn.close();
+            encoder.encode(image);// 对图片进行输出编码
+            imageIn.close();// 关闭文件流
         }
 
-        // 判断图片文件路径是否以".gif"结尾，即判断是否为GIF格式图片，若是则进行以下GIF图片处理逻辑
-        if (imagePath.toLowerCase().endsWith(".gif")) {
-            // 设置响应头的Content-Type为GIF图片对应的MIME类型，告知客户端返回的是GIF格式的图片数据
+        if (imagePath.toLowerCase().endsWith(".gif"))// 不使用编码处理文件流的情况：
+        {
             response.setContentType(GIF);
-
-            // 获取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];
+            ServletContext context = getServletContext();// 得到背景对象
+            InputStream imageIn = context.getResourceAsStream(imagePath);// 文件流
+            BufferedInputStream bis = new BufferedInputStream(imageIn);// 输入缓冲流
+            BufferedOutputStream bos = new BufferedOutputStream(output);// 输出缓冲流
+            byte data[] = new byte[4096];// 缓冲字节数
             int size = 0;
-            // 从缓冲输入流中读取数据到字节数组，每次读取的数据长度存放在size变量中，当读取到文件末尾时size为-1
             size = bis.read(data);
-            // 通过循环不断读取数据并输出到客户端，直到读取完整个文件（size为-1时结束循环）
-            while (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,137 +24,83 @@ import java.io.InputStream;
 import java.util.Date;
 import java.util.List;
 
-// 使用WebServlet注解将该类映射到"/uploadImageServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/uploadImageServlet")
 public class UploadImageServlet extends HttpServlet {
-
-    // 重写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 = "";
-        // 如果当前登录用户是学生角色，则将学生的学号赋值给id变量，作为后续处理图片相关操作的关联标识
-        if (student!= null) {
+        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、创建一个ServletFileUpload对象，它是用于解析上传文件的核心类，通过传入前面创建的工厂对象来进行初始化，
-        // 后续可以使用它来解析HTTP请求中的文件上传相关内容
+        // 2、创建一个文件上传解析器
         ServletFileUpload upload = new ServletFileUpload(factory);
-        // 设置请求头的编码为"UTF-8"，确保能正确解析包含中文等多字节字符的文件名等信息
         upload.setHeaderEncoding("UTF-8");
-
-        // 3、判断提交上来的数据是否是符合文件上传表单的数据格式（通过请求的Content-Type等相关信息判断），
-        // 如果不是则说明不是文件上传请求，按照传统方式获取数据（此处直接返回，意味着不处理这种情况）
+        // 3、判断提交上来的数据是否是上传表单的数据
         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);
 
-                // 判断文件名的后缀（通过截取文件名中最后一个点后面的部分并转换为大写后进行比较）是否是允许上传的图片格式（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];
                     int len = 0;
-                    // 通过循环不断从输入流读取数据到字节数组，每次读取的数据长度存放在len变量中，只要读取到的数据长度大于0就继续循环，
-                    // 并将读取到的数据通过输出流写入到服务器端的文件中，实现文件上传保存的功能
-                    while ((len = in.read(buffer)) > 0) {
+                    byte buffer[] = new byte[1024];
+                    while ((len = in.read(buffer)) > 0)// 每次讀取
+                    {
                         out.write(buffer, 0, len);
                     }
-
-                    // 关闭用于读取文件的输入流，释放相关资源
                     in.close();
-                    // 关闭用于写入文件的输出流，释放相关资源
                     out.close();
-                    // 删除临时文件（如果有，根据Apache Commons FileUpload的机制，在一些情况下会生成临时文件，此处删除它）
                     item.delete();
-                } else {
-                    // 如果文件名后缀不是允许上传的图片格式，则表示上传的文件不符合要求，
-                    // 在请求属性中设置"update_msg"属性，添加提示信息，说明上传失败以及失败原因（只能上传指定类型的图片文件），
-                    // 并带上当前的时间信息（通过String.format("%tT", new Date())格式化时间）
-                    request.setAttribute("update_msg", "上传失败，只能上传类型为jpg或GIF的图像文件！" + String.format("%tT", new Date()));
-                    // 将请求转发到"/WEB-INF/student/studentAddPhoto.jsp"页面，可能该页面用于显示上传结果等相关信息给用户
+                } else {  //必须是图片才能上传否则失败
+                    request.setAttribute("update_msg", "上传失败，只能上传类型为jpg或GIF的图像文件！"+String.format("%tT",new Date()));
+//        request.getRequestDispatcher("/WEB-INF/index.jsp").forward(request, response);
                     request.getRequestDispatcher("/WEB-INF/student/studentAddPhoto.jsp").forward(request, response);
                     return;
                 }
@@ -163,34 +109,24 @@ public class UploadImageServlet extends HttpServlet {
             e.printStackTrace();
         }
 
-        // 创建一个Photo对象，用于封装要保存或更新到数据库中的照片相关信息，先设置照片的唯一标识（如学生学号等）
         Photo photo = new Photo();
         photo.setPhotoId(id);
-        // 设置照片的名称，使用前面处理后得到的新文件名
         photo.setPhotoName(newFileName);
-
-        // 创建PhotoService的实现类实例，用于调用业务逻辑层方法来处理照片数据在数据库中的保存或更新操作
         PhotoService service = new PhotoServiceImpl();
 
-        // 通过业务逻辑层方法，根据照片的唯一标识（id）查找数据库中是否已经存在对应的照片记录
-        Photo photo1 = service.findPhotoByPhotoId(id);
-        // 如果查找结果为null，表示数据库中不存在该照片记录，则调用业务逻辑层的添加照片方法，将新的照片信息保存到数据库中
-        if (photo1 == null) {
+
+        Photo photo1= service.findPhotoByPhotoId(id);
+        if (photo1==null) {
             service.addPhoto(photo);
-        } else {
-            // 如果数据库中已经存在对应的照片记录，则调用业务逻辑层的更新照片方法，使用新的照片信息更新数据库中的记录
+        }else {
             service.updatePhoto(photo);
         }
-
-        // 在请求属性中设置"update_msg"属性，添加提示信息，说明上传成功，并带上当前的时间信息（通过String.format("%tT", new Date())格式化时间）
-        request.setAttribute("update_msg", "上传成功！" + String.format("%tT", new Date()));
-        // 将请求转发到"/WEB-INF/student/studentAddPhoto.jsp"页面，可能该页面用于显示上传结果等相关信息给用户
+        request.setAttribute("update_msg", "上传成功！"+String.format("%tT",new Date()));
+//        request.getRequestDispatcher("/WEB-INF/index.jsp").forward(request, response);
         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,37 +16,20 @@ 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");
 
-        // 判断提交上来的数据是否是符合文件上传表单的数据格式（通过请求的Content-Type等相关信息判断），
-        // 如果是则返回true，表示是文件上传请求
-        boolean isMultipart = ServletFileUpload.isMultipartContent(request);
+
+        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();
@@ -60,71 +43,47 @@ 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();
-                        // 获取服务器上用于保存上传文件的目录路径，通过Servlet上下文获取"upload"目录的真实路径
-                        // （此处注释掉的代码是通过请求的会话获取Servlet上下文再获取路径，可根据实际情况选择合适的方式，当前使用的是直接通过Servlet获取上下文的方式）
-                        // String path=request.getSession().getServletContext().getRealPath("upload");
+                        //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();
@@ -134,9 +93,7 @@ public class UploadServlet extends HttpServlet {
         }
     }
 
-    // 定义一个内部类ProcessInfo，用于封装文件上传进度相关的信息，
-    // 包括总文件大小、已读取的文件大小、显示的进度字符串、已处理的文件项数量以及进度百分比等属性
-    class ProcessInfo {
+    class ProcessInfo{
         public long totalSize = 1;
         public long readSize = 0;
         public String show = "";
@@ -144,8 +101,7 @@ 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,22 +7,12 @@ 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 {
-        // 将当前请求转发到"/WEB-INF/admin/aIndex.jsp"页面。
-        // 通常这个JSP页面可能是管理员功能模块对应的首页或者是一个主要的展示页面，
-        // 通过转发请求，服务器会去查找并渲染这个JSP页面，然后将生成的页面内容返回给客户端展示给用户。
-        request.getRequestDispatcher("/WEB-INF/admin/aIndex.jsp").forward(request, response);
+        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,22 +7,12 @@ 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 {
-        // 将当前请求转发到"/WEB-INF/student/sIndex.jsp"页面。
-        // 一般来说，这个JSP页面是学生功能模块对应的首页或者核心展示页面，
-        // 通过转发请求，服务器会查找并渲染该JSP页面，之后把生成的页面内容返回给客户端，展示给学生用户查看。
-        request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request, response);
+        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,22 +7,12 @@ 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 {
-        // 将当前接收到的请求转发到"/WEB-INF/teacher/tIndex.jsp"页面。
-        // 一般来讲，这个JSP页面是教师功能模块对应的首页或者是主要展示页面，
-        // 服务器接收到转发请求后，会去查找并渲染这个JSP页面，随后将渲染好的页面内容返回给客户端，以便展示给教师用户查看。
-        request.getRequestDispatcher("/WEB-INF/teacher/tIndex.jsp").forward(request, response);
+        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,65 +14,35 @@ 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);
-
-        // 创建一个HashMap对象，用于存储要返回给客户端的相关信息，以键值对的形式进行存储，方便后续转换为JSON格式数据。
-        Map<String, Object> map = new HashMap<String, Object>();
+        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", "用户名可用");
             }
-
-            // 创建一个ObjectMapper对象，它是Jackson库中用于将Java对象转换为JSON格式数据的核心类，
-            // 这里将使用它把map对象转换为JSON格式，并写入到响应的输出流中，以便发送给客户端。
+            //map转为json传给客户端
             ObjectMapper mapper = new ObjectMapper();
-            // 通过ObjectMapper的writeValue方法，将map对象转换为JSON格式的数据，并写入到HttpServletResponse的输出流中，
-            // 这样客户端就能接收到对应的JSON数据并进行解析和相应处理了。
-            mapper.writeValue(response.getWriter(), map);
+            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,169 +25,109 @@ 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");
-        // 移除会话中的"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);
+        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);
             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 notifyService = new NotifyServiceImpl();
-        // 调用业务逻辑层的find方法，获取公告列表数据，返回的是Notify类型的列表
+        //公告加载
+        NotifyService notifyService= new NotifyServiceImpl();
         List<Notify> notifys = notifyService.find();
-        // 将获取到的公告列表存放到HttpSession中，属性名为"notifys"，方便在后续页面中（不同角色登录后的页面）可以获取并展示公告信息
-        session.setAttribute("notifys", 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的实现类实例，用于调用业务逻辑层中与学生登录相关的方法
-            StudentService service = new StudentServiceImpl();
-            // 调用业务逻辑层的login方法，传入封装好的学生对象，进行登录验证，将验证通过后返回的学生对象赋值给loginStudent变量（如果验证失败则为null）
+            StudentService service= new StudentServiceImpl();
             loginStudent = service.login(student);
 
-            // 判断登录验证是否成功，即loginStudent不为null，表示找到了对应的学生记录，登录成功
-            if (loginStudent!= null) {
-                // 将登录成功的学生对象存放到HttpSession中，属性名为"student"，方便后续在其他页面判断用户是否登录以及获取学生相关信息
+            if (loginStudent != null) {
                 session.setAttribute("student", loginStudent);
-                // 在会话中设置"html_title"属性，值为"学生端"，可能用于在页面上显示不同的标题栏等内容，标识当前处于学生端页面
                 session.setAttribute("html_title", "学生端");
-                // 重定向到"studentIndexServlet"，通常这个Servlet会将请求转发到学生端对应的首页（如"/WEB-INF/student/sIndex.jsp"等页面），实现登录成功后跳转到学生端首页的功能
-                // （此处注释掉了直接转发的代码，选择使用重定向方式，重定向会重新发起一个请求，而转发是在服务器内部直接跳转，两者有不同的应用场景和效果）
-//                request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request, response);
+//                request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request,response);
                 response.sendRedirect("studentIndexServlet");
-            } else {
-                // 如果登录验证失败，即loginStudent为null，表示用户名或密码错误等情况
-                // 在请求属性中设置"login_msg"属性，添加提示信息，说明用户名或密码错误，用于后续在登录页面展示给用户
+            }else {
+                //登录失败 提示信息
                 request.setAttribute("login_msg", "用户名或密码错误！");
-                // 在请求属性中设置"loginid"属性，将用户输入的登录账号再次存入请求属性，方便在返回登录页面时可以回显给用户
-                request.setAttribute("loginid", loginid);
-                // 在请求属性中设置"loginpassword"属性，将用户输入的登录密码再次存入请求属性，方便在返回登录页面时可以回显给用户
-                request.setAttribute("loginpassword", loginpassword);
-                // 将请求转发到"/login.jsp"页面，返回登录页面并展示错误提示信息以及回显账号密码等内容
+                request.setAttribute("loginid",loginid);
+                request.setAttribute("loginpassword",loginpassword);
                 request.getRequestDispatcher("/login.jsp").forward(request, response);
             }
-        } else if ("teacher".equals(roles)) {
-            // 创建一个Teacher对象，用于封装教师登录相关的信息，作为传递给业务逻辑层进行登录验证的数据对象
+        }else if ("teacher".equals(roles)) {
+
             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);
 
-            // 判断登录验证是否成功，即loginTeacher不为null，表示找到了对应的教师记录，登录成功
-            if (loginTeacher!= null) {
-                // 将登录成功的教师对象存放到HttpSession中，属性名为"teacher"，方便后续在其他页面判断用户是否登录以及获取教师相关信息
+            if (loginTeacher != null) {
                 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 {
-                // 如果登录验证失败，即loginTeacher为null，表示用户名或密码错误等情况
-                // 在请求属性中设置"login_msg"属性，添加提示信息，说明用户名或密码错误，用于后续在登录页面展示给用户
+            }else {
+                //登录失败 提示信息
                 request.setAttribute("login_msg", "用户名或密码错误！");
-                // 将请求转发到"/login.jsp"页面，返回登录页面并展示错误提示信息
                 request.getRequestDispatcher("/login.jsp").forward(request, response);
             }
-        } else {
-            // 创建一个Admin对象，用于封装管理员登录相关的信息，作为传递给业务逻辑层进行登录验证的数据对象
+
+        }else {
+
             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);
 
-            // 判断登录验证是否成功，即loginAdmin不为null，表示找到了对应的管理员记录，登录成功
-            if (loginAdmin!= null) {
-                // 将登录成功的管理员对象存放到HttpSession中，属性名为"admin"，方便后续在其他页面判断用户是否登录以及获取管理员相关信息
+            if (loginAdmin != null) {
                 session.setAttribute("admin", loginAdmin);
-                // 在会话中设置"html_title"属性，值为"管理员"，可能用于在页面上显示不同的标题栏等内容，标识当前处于管理员页面
                 session.setAttribute("html_title", "管理员");
-                // 重定向到"adminIndexServlet"，通常这个Servlet会将请求转发到管理员端对应的首页（如"/WEB-INF/admin/aIndex.jsp"等页面），实现登录成功后跳转到管理员端首页的功能
-                // （此处注释掉了直接转发的代码，选择使用重定向方式）
-//                request.getRequestDispatcher("/WEB-INF/admin/aIndex.jsp").forward(request, response);
+//                request.getRequestDispatcher("/WEB-INF/admin/aIndex.jsp").forward(request,response);
                 response.sendRedirect("adminIndexServlet");
-            } else {
-                // 如果登录验证失败，即loginAdmin为null，表示用户名或密码错误等情况
-                // 在请求属性中设置"login_msg"属性，添加提示信息，说明用户名或密码错误，用于后续在登录页面展示给用户
+            }else {
+                //登录失败 提示信息
                 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,44 +8,19 @@ 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,87 +6,45 @@ import service.impl.StudentServiceImpl;
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
-import javax.servlet.http.HttpServlet;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpSession;
+import javax.servlet.http.*;
 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");
-        // 移除会话中的"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);
+        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);
             return;
-        } else {
-            // 如果验证码验证通过，则创建一个Student对象，用于封装要注册的学生相关信息，准备传递给业务逻辑层进行注册操作。
+        }else {
             Student student = new Student();
-            // 设置学生对象的学号属性，使用前面获取到的studentid值。
             student.setS_id(studentid);
-            // 设置学生对象的密码属性，使用前面获取到的password值。
             student.setS_password(password);
-            // 打印学号信息（可能用于调试，查看获取到的学号是否正确等情况），在实际应用中可根据需求决定是否保留此打印语句。
             System.out.println(studentid);
-            // 打印密码信息（同样可能用于调试目的），查看密码获取情况，可按需决定是否保留。
             System.out.println(password);
-
-            // 创建StudentService的实现类实例，用于调用业务逻辑层中与学生注册相关的方法，将学生注册信息保存到数据库等相关操作。
-            StudentService service = new StudentServiceImpl();
-            // 调用业务逻辑层的register方法，传入封装好的学生对象，执行学生注册操作。
+            StudentService service= new StudentServiceImpl();
             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,49 +17,23 @@ 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);
-
-        // 以下代码被注释掉了，原本是使用重定向的方式跳转到"/notifyListServlet"，重定向会重新发起一个请求，客户端会向新的URL发起请求。
-        // response.sendRedirect("/notifyListServlet");
-
-        // 采用请求转发的方式将当前请求转发到"/notifyListServlet"，请求转发是在服务器内部进行跳转，相对重定向来说更高效，
-        // 转发到的"/notifyListServlet"通常可能是用于展示通知列表的Servlet，这样在添加通知成功后可以直接展示最新的通知列表情况。
-        request.getRequestDispatcher("/notifyListServlet").forward(request, response);
+//        response.sendRedirect("/notifyListServlet");
+        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,39 +12,18 @@ 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);
-
-        // 将当前请求转发到"/notifyListServlet"，通常这个Servlet是用于展示通知列表的，
-        // 这样在删除通知成功后，可以直接跳转到通知列表页面，展示最新的通知列表情况（已删除指定通知后的列表）。
-        request.getRequestDispatcher("/notifyListServlet").forward(request, response);
+        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,36 +12,16 @@ 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();
-
-        // 将获取到的通知列表信息存放到请求的属性中，属性名为"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);
+        request.setAttribute("notifys",notifys);
+        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,57 +16,28 @@ 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();
-        // 将获取到的通知列表信息存放在请求的属性中，属性名为"notifys"，这样在后续转发请求到相应页面时，
-        // 目标页面（如JSP页面）就可以通过相应的方式（例如EL表达式、JSTL标签等）获取到这个属性值，进而展示具体的通知列表内容。
-        request.setAttribute("notifys", notifys);
+        request.setAttribute("notifys",notifys);
 
-        // 获取当前请求对应的HttpSession对象，HttpSession用于在多个请求之间保存用户相关的会话信息，
-        // 这里主要是为了获取会话中存储的用户登录相关信息，以便判断当前登录用户的角色，进而决定通知列表展示的具体页面。
         HttpSession session = request.getSession();
-
-        // 尝试从会话中获取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);
+        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);
         } 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,22 +7,13 @@ 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 {
-        // 将当前请求转发到"/WEB-INF/notify/addNotify.jsp"页面。
-        // 通常这个JSP页面是用于展示添加通知的表单界面，用户可以在该页面上填写通知的具体内容等相关信息，
-        // 然后通过后续的操作（比如提交表单）来触发添加通知的实际业务逻辑。
-        request.getRequestDispatcher("/WEB-INF/notify/addNotify.jsp").forward(request, response);
+        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,101 +16,46 @@ 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";
         }
 
-        // 获取条件查询参数相关逻辑
-        // 通过调用request.getParameterMap()方法获取请求中所有的参数，以Map的形式返回，
-        // 其中键为参数名，值为对应参数名的所有值（以字符串数组形式存储，因为一个参数名可能对应多个值情况），
-        // 这些参数可用于构建更复杂的条件查询（比如根据学生姓名、学号范围等条件进行筛选查找学生信息）。
-        Map<String, String[]> condition = request.getParameterMap();
+        //获取条件查询参数
+        Map<String,String[]> condition = request.getParameterMap();
 
-        // 创建StudentService的实现类实例，用于调用业务逻辑层中与按页查找学生信息相关的方法，
-        // 该实现类会根据传入的当前页码、每页显示条数以及查询条件等参数，从数据库等存储介质中获取相应的学生信息数据。
         StudentService service = new StudentServiceImpl();
+        PageBean<Student> pb =  service.findStudentByPage(currentPage,rows,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.setAttribute("pb",pb);
+        request.setAttribute("condition",condition);//存入查询条件
         request.setCharacterEncoding("utf-8");
-
-        // 获取当前请求对应的HttpSession对象，HttpSession用于在多个请求之间保存用户相关的会话信息，
-        // 这里主要是为了获取会话中存储的用户登录相关信息，以便判断当前登录用户的角色，进而决定将查询结果展示到哪个对应的页面。
         HttpSession session = request.getSession();
+        Student student= (Student)session.getAttribute("student");
 
-        // 尝试从会话中获取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"页面，通常这个页面是专门为学生定制的查看学生信息分页列表的页面，
-            // 会根据学生的相关特点和需求展示学生信息内容等。
+        Admin admin= (Admin)session.getAttribute("admin");
+        Teacher teacher= (Teacher)session.getAttribute("teacher");
+        if (student != null && admin == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/student/sFindStudentList.jsp").forward(request, response);
-        } else if (admin!= null && student == null && teacher == null) {
-            // 如果管理员对象不为null且学生对象和教师对象都为null，意味着当前登录用户是管理员角色，
-            // 此时将请求转发到"/WEB-INF/admin/aFindStudentList.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) {
-            // 如果教师对象不为null且管理员对象和学生对象都为null，表明当前登录用户是教师角色，
-            // 则将请求转发到"/WEB-INF/teacher/tFindStudentList.jsp"页面，这个页面是为教师定制的查看学生信息分页列表的页面，
-            // 可能会展示与教师教学相关的学生信息等内容。
+        } else if (teacher != null && admin == null && student == null) {
             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

@@ -51,12 +51,4 @@ public class DeleteSelectStudentServlet extends HttpServlet {
         // 这里的实现是直接调用doPost方法，意味着不管是GET请求还是POST请求，都会执行同样的业务逻辑处理
         doPost(request,response);
     }
-<<<<<<< HEAD
-}
-//yuo
-//tu
-//rre
-//s
-=======
-}
->>>>>>> develop1
+}

src/web/servlet/verifycode/CheckCodeServlet.java

@@ -1,7 +1,9 @@
 package web.servlet.verifycode;
 
+
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.util.JSONPObject;
+
 import java.awt.Color;
 import java.awt.Font;
 import java.awt.Graphics;
@@ -19,24 +21,43 @@ import javax.servlet.http.HttpServletResponse;
 
 /**
  * 验证码
- * 该类主要用于生成验证码图片，并将对应的验证码字符串存储在 HttpSession 中，同时把验证码图片响应给客户端浏览器，
- * 在整个应用中通常用于用户登录、注册等需要验证身份的场景，防止机器自动操作等情况。
  */
 @WebServlet("/checkCodeServlet")
 public class CheckCodeServlet extends HttpServlet {
+	public void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
+		
+		//服务器通知浏览器不要缓存
+		response.setHeader("pragma","no-cache");
+		response.setHeader("cache-control","no-cache");
+		response.setHeader("expires","0");
+		
+		//在内存中创建一个长80，宽30的图片，默认黑色背景
+		//参数一：长
+		//参数二：宽
+		//参数三：颜色
+		int width = 136;
+		int height = 38;
+		BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
+		
+		//获取画笔
+		Graphics g = image.getGraphics();
+		//设置画笔颜色为灰色
+		g.setColor(Color.GRAY);
+		//填充图片
+		g.fillRect(0,0, width,height);
+		
+		//产生4个随机验证码，12Ey
+		String checkCode = getCheckCode();
+		//将验证码放入HttpSession中
+		request.getSession().setAttribute("CHECKCODE_SERVER",checkCode);
 
-    /**
-     * 处理 HTTP GET 请求的方法
-     * 在此方法中完成生成验证码图片、设置相关响应头、将验证码存入会话以及输出图片到浏览器等操作。
-     *
-     * @param request  HttpServletRequest 对象，用于获取请求相关信息，如会话等
-     * @param response HttpServletResponse 对象，用于设置响应相关的内容，如响应头、输出流等
-     * @throws ServletException 如果在 Servlet 处理过程中出现异常
-     * @throws IOException      如果在输入输出操作（如写入响应流）过程中出现异常
-     */
-    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+		//设置画笔颜色为黄色
+		g.setColor(Color.YELLOW);
+		//设置字体的小大
+		g.setFont(new Font("黑体",Font.BOLD,30));
+		//向图片上写入验证码
+		g.drawString(checkCode,36,28);
 
-<<<<<<< HEAD
 		//将内存中的图片输出到浏览器
 		//参数一：图片对象
 		//参数二：图片的格式，如PNG,JPG,GIF
@@ -65,91 +86,6 @@ public class CheckCodeServlet extends HttpServlet {
 		this.doGet(request,response);
 	}
 }
-//.......
-=======
-        // 服务器通知浏览器不要缓存验证码图片相关逻辑
-        // 设置响应头 "pragma" 为 "no-cache"，这是一种 HTTP 1.0 的缓存控制方式，告诉浏览器不要缓存页面
-        response.setHeader("pragma", "no-cache");
-        // 设置响应头 "cache-control" 为 "no-cache"，这是 HTTP 1.1 中常用的缓存控制方式，明确指示浏览器不进行缓存
-        response.setHeader("cache-control", "no-cache");
-        // 设置响应头 "expires" 为 "0"，指定缓存过期时间为过去的某个时间，也是一种强制浏览器不缓存的手段
-        response.setHeader("expires", "0");
-
-        // 在内存中创建一个指定尺寸的图片对象相关逻辑
-        // 定义图片的宽度，单位为像素，这里设置为 136 像素，可根据实际需求调整尺寸大小
-        int width = 136;
-        // 定义图片的高度，单位为像素，此处设置为 38 像素，同样可按需改变尺寸
-        int height = 38;
-        // 创建一个 BufferedImage 对象，用于在内存中表示图片，其参数依次为宽度、高度以及图像类型（这里使用 TYPE_INT_RGB 表示 24 位真彩色图像）
-        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
-
-        // 获取用于在图片上绘制内容的画笔对象
-        Graphics g = image.getGraphics();
-        // 设置画笔的颜色为灰色，用于填充图片背景，使背景呈现灰色
-        g.setColor(Color.GRAY);
-        // 使用设置好颜色的画笔填充整个图片区域，坐标 (0, 0) 表示从图片左上角开始，填充的宽度和高度分别为前面定义的图片宽度和高度
-        g.fillRect(0, 0, width, height);
->>>>>>> develop1
-
-        // 产生 4 个随机验证码的逻辑
-        // 调用 getCheckCode 方法生成一个由随机字符组成的 4 位验证码字符串，例如 "12Ey" 这种形式
-        String checkCode = getCheckCode();
-        // 将生成的验证码字符串存入 HttpSession 中，属性名为 "CHECKCODE_SERVER"，方便后续在其他地方（如登录验证等环节）取出进行比对验证
-        request.getSession().setAttribute("CHECKCODE_SERVER", checkCode);
-
-        // 设置画笔颜色为黄色，以便后续用黄色画笔在图片上绘制验证码字符，使其更清晰可见（颜色可根据实际美观等需求调整）
-        g.setColor(Color.YELLOW);
-        // 设置绘制文字时使用的字体，这里选择 "黑体"，字体样式为加粗（Font.BOLD），字号大小为 30 像素，可根据验证码图片整体布局和显示效果调整字体相关参数
-        g.setFont(new Font("黑体", Font.BOLD, 30));
-        // 使用设置好的字体和颜色，将验证码字符串绘制到图片上指定的位置，坐标 (36, 28) 表示从图片上距离左边 36 像素、距离上边 28 像素的位置开始绘制，
-        // 具体坐标值可根据验证码在图片中的排版效果进行微调
-        g.drawString(checkCode, 36, 28);
 
-        // 将内存中生成好的图片输出到浏览器的逻辑
-        // 使用 ImageIO 类的 write 方法将图片对象输出到浏览器，参数依次为：要输出的图片对象、图片的格式（这里指定为 "PNG"，也可以是其他常见格式如 JPG、GIF 等）、
-        // 输出的目标流（这里使用 response.getOutputStream() 获取 HttpServletResponse 的输出流，将图片内容直接写入响应流，发送给浏览器）
-        ImageIO.write(image, "PNG", response.getOutputStream());
-    }
 
-    /**
-     * 产生 4 位随机字符串的方法
-     * 从给定的字符集合中随机选取字符组成一个长度为 4 的字符串，作为验证码字符串返回。
-     *
-     * @return 生成的 4 位随机验证码字符串
-     */
-    private String getCheckCode() {
-        // 定义一个包含所有可用字符的字符串，用于从中随机选取字符生成验证码，这里排除了容易混淆的数字 0、1 和字母 l、o、O 等，减少用户识别验证码时的混淆情况
-        String base = "23456789ABCDEFGHJKMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz";
-        // 获取可用字符集合的长度，用于后续生成随机索引来选取字符
-        int size = base.length();
-        // 创建一个 Random 对象，用于生成随机数，它依据系统当前时间作为随机数生成器的种子，产生伪随机数序列
-        Random r = new Random();
-        // 创建一个 StringBuffer 对象，用于高效地拼接字符，最终组成验证码字符串
-        StringBuffer sb = new StringBuffer();
-        // 通过循环 4 次，每次生成一个随机字符并添加到 StringBuffer 中，最终组成 4 位的验证码字符串
-        for (int i = 1; i <= 4; i++) {
-            // 生成一个介于 0（包含）到 size - 1（包含）之间的随机整数索引，用于从 base 字符串中选取字符
-            int index = r.nextInt(size);
-            // 根据生成的随机索引，从 base 字符串中获取对应的字符
-            char c = base.charAt(index);
-            // 将获取到的字符添加到 StringBuffer 中，逐步构建验证码字符串
-            sb.append(c);
-        }
-        // 将 StringBuffer 转换为字符串并返回，得到最终的 4 位验证码字符串
-        return sb.toString();
-    }
 
-    /**
-     * 处理 HTTP POST 请求的方法
-     * 在此类中直接调用 doGet 方法来处理 POST 请求，意味着 GET 请求和 POST 请求在本 Servlet 中的处理逻辑是一样的，
-     * 即当接收到 POST 请求时，同样会执行生成验证码图片等相关操作，并响应给客户端。
-     *
-     * @param request  HttpServletRequest 对象，用于获取请求相关信息
-     * @param response HttpServletResponse 对象，用于设置响应相关内容
-     * @throws ServletException 如果在 Servlet 处理过程中出现异常
-     * @throws IOException      如果在输入输出操作过程中出现异常
-     */
-    public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        this.doGet(request, response);
-    }
-}

web/WEB-INF/admin/aCDCList.jsp

@@ -1,90 +1,83 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
-<!-- 以上两行是JSP页面的指令声明部分：
-第一行用于设置该JSP页面输出的内容类型为HTML格式（text/html），并指定字符编码为UTF-8，同时表明此页面使用Java语言来编写相应的逻辑代码；
-第二行引入了JSTL（JavaServer Pages Standard Tag Library）的核心标签库，通过定义前缀“c”，后续可以方便地使用该标签库所提供的各种标签进行诸如数据遍历、条件判断等操作 -->
 <html>
 <head>
-    <!-- 设置页面标题为“学院专业查询”，此标题会显示在浏览器的标题栏位置，让用户直观知晓当前页面的主要功能 -->
+    <!-- 设置页面标题为“学院专业查询” -->
     <title>学院专业查询</title>
-    <!-- 引入layui的样式文件，layui.css中包含了众多预先定义好的样式规则，用于实现页面的布局、组件样式等方面的美化效果，能帮助快速搭建出具有一定风格的页面 -->
+    <!-- 引入layui的样式文件，用于页面的样式布局等美化 -->
     <link rel="stylesheet" href="./css/layui.css">
-    <!-- 引入自定义的样式文件，style.css文件可以由开发者根据本页面的特定需求来编写样式规则，用于对layui框架默认样式进行补充或者覆盖，以实现更符合业务需求的页面外观展示 -->
+    <!-- 引入自定义的样式文件，可能包含针对本页面特定的样式设置 -->
     <link rel="stylesheet" href="./css/style.css">
-    <!-- 引入layui的JavaScript文件，layui.js包含了丰富的代码逻辑，实现了诸多交互组件（如表单、表格、菜单等）以及相应的交互功能，是页面实现动态效果的重要依赖 -->
+    <!-- 引入layui的JavaScript文件，layui是一个前端UI框架，提供了很多交互组件等功能 -->
     <script src="./layui.js"></script>
-    <!-- 引入jQuery库的.min压缩版本，jQuery是一个广受欢迎的JavaScript库，它提供了简洁易用的方法来操作DOM元素（例如查找、修改、删除页面元素等）、处理页面事件（如点击、鼠标移动等事件）以及实现动画效果等，极大地方便了前端开发工作 -->
+    <!-- 引入jQuery库的.min压缩版本，jQuery是常用的JavaScript库，方便进行DOM操作、事件处理等 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
-    <!-- 设置页面主体的类名为“layui-layout-body”，同时指定背景颜色为#F2F2F2（一种淡灰色），这通常是依据layui框架的布局样式规范来设定的，使得页面呈现出相应的视觉风格 -->
+    <!-- 包含用于过滤登录状态的JSP页面，可能用于判断用户是否登录等相关逻辑处理 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
-    <!-- 通过JSP的include指令引入“filterLogin.jsp”页面，该页面一般用于执行用户登录验证相关的逻辑操作，只有当用户成功登录后，才允许访问当前页面展示的内容，起到安全控制的作用 -->
+    <!-- 包含管理员头部页面，通常包含页面头部的一些通用元素，比如页面标题、导航栏等 -->
     <jsp:include page="/WEB-INF/admin/aHeader.jsp"></jsp:include>
-    <!-- 引入“/WEB-INF/admin/aHeader.jsp”页面，通常这个页面用于构建管理员端页面的头部区域，比如展示系统名称、管理员相关的功能菜单、用户信息等通用元素 -->
+    <!-- 包含管理员导航栏页面，用于展示管理员操作相关的导航菜单等 -->
     <jsp:include page="/WEB-INF/admin/adminNav.jsp"></jsp:include>
-    <!-- 引入“/WEB-INF/admin/adminNav.jsp”页面，其主要功能是生成管理员端的导航栏，通过该导航栏可以方便管理员在不同的功能模块、业务页面之间进行切换操作 -->
     <div class="layui-layout layui-layout-admin">
         <div class="layui-body">
-            <!-- 这是layui框架中定义的用于承载页面主要内容的部分，也就是所谓的内容主体区域，各类核心业务数据展示以及相关操作功能都会放置在此处 -->
+            <!-- 内容主体区域 -->
             <div style="padding: 15px;">
-                <!-- 使用layui的面包屑组件，通过面包屑可以清晰地向用户展示当前页面在整个系统层级结构中的位置，方便用户了解自己所在的页面路径以及页面之间的关联关系 -->
+                <!-- 使用layui的面包屑组件，展示当前页面的层级导航路径 -->
                 <span class="layui-breadcrumb">
-                    <!-- 面包屑的一级导航，此处设置了一个超链接（href属性虽为空，但可能根据实际情况绑定相应的点击事件或指向根路径相关功能），显示文本为“管理员”，代表当前用户所处的角色层级 -->
+                    <!-- 面包屑的一级导航，链接指向根路径（此处可能根据实际情况有对应功能） -->
                     <a href="">管理员</a>
-                    <!-- 面包屑的二级导航，同样设置了超链接（可能有对应指向学院专业管理相关页面的功能），显示文本为“学院专业管理”，进一步细化用户所在的业务模块层级 -->
+                    <!-- 面包屑的二级导航，链接指向学院专业管理相关页面（同样可能有对应功能） -->
                     <a href="">学院专业管理</a>
-                    <!-- 面包屑的三级导航，这里没有设置超链接，直接通过<cite>标签显示当前页面的具体名称“学院专业查询”，明确当前所处的具体页面 -->
+                    <!-- 面包屑的三级导航，显示当前页面的具体名称 -->
                     <a><cite>学院专业查询</cite></a>
                 </span>
-                <!-- 使用layui的表格组件来展示学院专业相关的数据，layui-table是layui框架中预定义好样式和交互功能的表格样式类，lay-filter属性通常用于为表格绑定一些特定的筛选、排序等交互功能（此处定义为“test”，后续可能需要相应的JavaScript代码来实现具体交互） -->
+                <!-- 使用layui的表格组件，用于展示学院专业相关的数据 -->
                 <table class="layui-table" lay-filter="test">
                     <thead>
                     <tr>
-                        <!-- 定义表格表头的第一列标题为“ID”，用于展示每条学院专业相关记录的唯一标识符 -->
+                        <!-- 表格表头，定义第一列的标题为“ID” -->
                         <th>ID</th>
-                        <!-- 定义表格表头的第二列标题为“学院”，用于展示对应的学院名称信息 -->
+                        <!-- 表格表头，定义第二列的标题为“学院” -->
                         <th>学院</th>
-                        <!-- 定义表格表头的第三列标题为“专业”，用于展示所属的专业名称信息 -->
+                        <!-- 表格表头，定义第三列的标题为“专业” -->
                         <th>专业</th>
-                        <!-- 定义表格表头的第四列标题为“班级”，用于展示具体的班级名称信息 -->
+                        <!-- 表格表头，定义第四列的标题为“班级” -->
                         <th>班级</th>
-                        <!-- 定义表格表头的第五列标题为“操作”，这一列通常用于放置对表格中每一条数据记录进行操作的按钮等交互元素，比如删除、编辑等操作按钮 -->
+                        <!-- 表格表头，定义第五列的标题为“操作”，通常用于放置对数据进行操作的按钮等 -->
                         <th>操作</th>
                     </tr>
                     </thead>
-                    <!-- 使用JSTL的forEach标签对名为“cdcs”的集合进行循环遍历，这个集合通常是由后端程序传递过来的、包含学院专业相关数据的集合，每一个元素代表一条具体的学院专业记录 -->
+                    <!-- 使用JSTL的forEach标签循环遍历名为“cdcs”的集合（应该是在后台传递过来的学院专业相关数据集合） -->
                     <c:forEach items="${cdcs}" var="cdc" varStatus="c">
                         <tr>
-                            <!-- 在表格行的第一列单元格中显示当前循环的序号，通过varStatus对象的count属性来实现计数功能，序号从1开始，方便用户查看数据的顺序 -->
+                            <!-- 在表格行中显示当前循环的序号（从1开始计数） -->
                             <td>${c.count}</td>
-                            <!-- 在表格行的第二列单元格中显示当前循环对象（cdc）中的学院名称属性值，该属性值应该是从后端传递过来的数据对象中提取出来的，用于展示具体的学院名称信息 -->
+                            <!-- 在表格行中显示当前循环对象（cdc）中的学院名称属性值 -->
                             <td>${cdc.college}</td>
-                            <!-- 在表格行的第三列单元格中显示当前循环对象（cdc）中的专业名称属性值，同样是从后端数据对象中获取对应属性值来展示具体的专业名称 -->
+                            <!-- 在表格行中显示当前循环对象（cdc）中的专业名称属性值 -->
                             <td>${cdc.department}</td>
-                            <!-- 在表格行的第四列单元格中显示当前循环对象（cdc）中的班级名称属性值，用于展示具体的班级名称情况 -->
+                            <!-- 在表格行中显示当前循环对象（cdc）中的班级名称属性值 -->
                             <td>${cdc.cclass}</td>
-                            <!-- 在表格行的第五列（操作列）单元格中添加一个删除按钮，按钮应用了layui的危险按钮样式（layui-btn-danger），使其在视觉上更醒目地提示用户操作的危险性；
-                            点击该按钮时会调用JavaScript中的deleteCDC函数（目前函数未定义完整，后续需要补充具体的删除逻辑，比如向服务器发送删除请求等相关操作） -->
+                            <!-- 在表格行的操作列中添加一个删除按钮，按钮样式为layui的危险按钮样式，点击时调用JavaScript中的deleteCDC函数（目前函数未定义完整，可能需要补充具体删除逻辑） -->
                             <td><a class="layui-btn layui-btn-danger" href="javascript:deleteCDC();">删除</a></td>
                         </tr>
                     </c:forEach>
                 </table>
-                <!-- 引入“/footer.jsp”页面，通常这个页面用于展示页面底部的相关信息，例如版权声明、联系方式、网站相关的友情链接等通用的底部元素 -->
+                <!-- 包含页面底部相关内容的JSP页面，可能包含版权信息、联系方式等通用的底部元素 -->
                 <jsp:include page="/footer.jsp"></jsp:include>
             </div>
         </div>
     </div>
 
 
-    <!-- 使用jQuery选择器（通过特定的选择表达式）选择导航栏中特定的DOM元素（此处是第4个li元素下的第一个dl元素下的第一个dd元素），并为其添加类名“layui-this”，
-    一般来说，添加这个类名是为了通过CSS样式来改变该元素的外观，使其呈现出与其他导航项不同的样式效果，用于标识当前选中的导航项或者处于特定状态的导航项（具体样式效果取决于对应的CSS定义） -->
+    <!-- 使用jQuery选择器选择特定的DOM元素（此处可能是导航栏中的某个元素）并添加类名“layui-this”，用于设置样式等相关操作（具体功能取决于对应的CSS样式定义） -->
     <script type="text/javascript">
         $("#nav li:nth-child(4) dl dd:nth-child(1)").addClass("layui-this");
         $("#nav li:nth-child(4)").addClass("layui-nav-itemed");
     </script>
-    <!-- 使用layui框架提供的use方法来加载“element”模块，在加载完成后的回调函数里获取该模块的实例（将其赋值给变量“element”），然后调用实例的“init”方法进行初始化操作。
-    “element”模块在layui框架中主要负责处理页面元素相关的交互逻辑，例如菜单的展开与收起、选项卡的切换等功能的初始化工作，确保这些交互元素能正常展示和使用 -->
+    <!-- 使用layui框架的element模块，进行相关初始化操作，element模块通常用于实现页面的交互元素（如折叠面板、导航栏等）的功能 -->
     <script>
         //JavaScript代码区域
         layui.use('element', function(){

web/WEB-INF/admin/adminNav.jsp

@@ -1,92 +1,90 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
-    <!-- 设置页面的字符编码为UTF-8，确保页面能正确显示各种字符，包括中文、特殊符号等不同语言的字符内容 -->
+    <!-- 设置页面的字符编码为UTF-8，确保页面能正确显示各种字符 -->
     <meta charset="utf-8">
-    <!-- 设置页面的视口（viewport）相关属性，让页面在不同设备（如手机、平板、电脑等）上能自适应显示，具体含义如下：
-         width=device-width表示页面宽度与设备屏幕宽度相同，使得页面能根据设备屏幕大小进行自适应调整宽度；
-         initial-scale=1表示初始缩放比例为1，即页面初始显示时按照原始设计大小呈现，不进行缩放；
-         maximum-scale=1表示最大缩放比例为1，意味着限制用户不能对页面进行缩放操作，保持页面布局的稳定性 -->
+    <!-- 设置页面的视口（viewport）相关属性，让页面在不同设备上能自适应显示。
+         width=device-width表示页面宽度与设备屏幕宽度相同，
+         initial-scale=1表示初始缩放比例为1，
+         maximum-scale=1表示最大缩放比例为1，即限制用户不能对页面进行缩放操作 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
 </head>
 <body class="layui-layout-body">
-    <!-- 创建一个layui布局的容器，layui是一个前端UI框架，通过使用其特定的布局类和样式，能够方便地构建出具有一定规范和交互功能的页面整体布局结构 -->
+    <!-- 创建一个layui布局的容器，用于构建页面的整体布局结构，layui是一个前端UI框架 -->
     <div class="layui-layout layui-layout-admin">
-        <!-- 创建页面左侧的侧边栏区域，应用layui的背景颜色样式类layui-bg-black，将侧边栏背景设置为黑色，用于视觉上区分不同的页面区域 -->
+        <!-- 创建页面左侧的侧边栏区域，设置背景颜色为黑色（layui-bg-black） -->
         <div class="layui-side layui-bg-black">
-            <!-- 创建一个可滚动的区域，当侧边栏内的内容超出侧边栏本身的高度时，用户可以通过滚动条来查看全部内容，提升页面的可浏览性和用户体验 -->
+            <!-- 创建一个可滚动的区域，用于放置侧边栏内容，当内容超出侧边栏高度时可以滚动查看 -->
             <div class="layui-side-scroll">
-                <!-- 左侧导航区域，使用layui的导航组件（layui-nav），以树形结构展示（layui-nav-tree），这种结构便于展示具有层级关系的菜单选项；
-                同时设置了过滤器（lay-filter="test"），用于后续与JavaScript等脚本语言配合实现一些交互操作，比如菜单点击事件的处理等；
-                并且设置了id为“nav”，方便通过JavaScript代码根据这个id来精准地获取和操作该导航元素 -->
+                <!-- 左侧导航区域，使用layui的导航组件（layui-nav），以树形结构展示（layui-nav-tree），并设置了过滤器（lay-filter="test"）用于后续交互操作，同时设置了id为“nav”方便通过JavaScript等进行操作 -->
                 <ul class="layui-nav layui-nav-tree"  lay-filter="test" id="nav">
-                    <!-- 一个导航菜单项，代表一级菜单，应用layui-nav-item类来添加相应的样式，使其在视觉上呈现出符合layui框架风格的菜单样式 -->
+                    <!-- 一个导航菜单项，代表一级菜单，使用layui-nav-item类来应用相应的样式 -->
                     <li class="layui-nav-item">
-                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空，即点击时不会跳转到其他页面），显示文本为“选课信息管理”，用于提示用户该菜单所代表的功能板块 -->
+                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“选课信息管理” -->
                         <a class="" href="javascript:;">选课信息管理</a>
-                        <!-- 一级菜单下的子菜单列表，使用dl标签配合layui的样式来展示子菜单，符合HTML语义化和layui框架对于菜单结构的规范 -->
+                        <!-- 一级菜单下的子菜单列表，使用dl标签配合layui的样式来展示子菜单 -->
                         <dl class="layui-nav-child">
-                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/studentSelectCourseListServlet）跳转到选课列表页面，这里利用了服务器端的请求路径配置来实现页面导航功能 -->
+                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/studentSelectCourseListServlet）跳转到选课列表页面 -->
                             <dd><a href="${pageContext.request.contextPath}/studentSelectCourseListServlet">选课列表</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/studentOptionalCourseServlet）跳转到可选课程页面，同样借助服务器端配置的路径来实现页面跳转 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/studentOptionalCourseServlet）跳转到可选课程页面 -->
                             <dd><a href="${pageContext.request.contextPath}/studentOptionalCourseServlet">可选课程</a></dd>
                         </dl>
                     </li>
-                    <!-- 一个导航菜单项，代表一级菜单，应用layui-nav-item类来添加相应的样式 -->
+                    <!-- 一个导航菜单项，代表一级菜单，使用layui-nav-item类来应用相应的样式 -->
                     <li class="layui-nav-item">
-                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“学生管理”，用于标识该菜单对应的功能分类 -->
+                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“学生管理” -->
                         <a class="" href="javascript:;">学生管理</a>
                         <!-- 一级菜单下的子菜单列表，使用dl标签配合layui的样式来展示子菜单 -->
                         <dl class="layui-nav-child">
-                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/findStudentByPageServlet）跳转到查询学生页面，通过服务器端配置的请求路径实现页面跳转 -->
+                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/findStudentByPageServlet）跳转到查询学生页面 -->
                             <dd><a href="${pageContext.request.contextPath}/findStudentByPageServlet">查询学生</a></dd>
-                            <!-- 一个隐藏的子菜单选项（通过hidden属性隐藏），设置了id为“hidden-update”，点击后暂时无实际跳转动作（href="#"表示链接到当前页面顶部），显示文本为“修改学生信息”，可能后续通过JavaScript等操作来显示并赋予实际功能，比如在满足某些条件下将其显示出来供用户点击操作 -->
+                            <!-- 一个隐藏的子菜单选项（通过hidden属性隐藏），id为“hidden-update”，点击后暂时无实际跳转动作（href="#"表示链接到当前页面顶部），显示文本为“修改学生信息”，可能后续通过JavaScript等操作来显示并赋予实际功能 -->
                             <dd hidden id="hidden-update"><a href="#">修改学生信息</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/addStudentServlet）跳转到增加学生页面，依靠服务器端配置的请求路径来实现页面导航 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/addStudentServlet）跳转到增加学生页面 -->
                             <dd><a href="${pageContext.request.contextPath}/addStudentServlet">增加学生</a></dd>
                         </dl>
                     </li>
-                    <!-- 一个导航菜单项，代表一级菜单，应用layui-nav-item类来添加相应的样式 -->
+                    <!-- 一个导航菜单项，代表一级菜单，使用layui-nav-item类来应用相应的样式 -->
                     <li class="layui-nav-item">
-                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“教师管理”，用于表明该菜单对应的管理功能范围 -->
+                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“教师管理” -->
                         <a class="" href="javascript:;">教师管理</a>
                         <!-- 一级菜单下的子菜单列表，使用dl标签配合layui的样式来展示子菜单 -->
                         <dl class="layui-nav-child">
-                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/teacherListServlet）跳转到查询教师页面，借助服务器端配置的请求路径实现页面跳转 -->
+                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/teacherListServlet）跳转到查询教师页面 -->
                             <dd><a href="${pageContext.request.contextPath}/teacherListServlet">查询教师</a></dd>
-                            <!-- 一个隐藏的子菜单选项（通过hidden属性隐藏），设置了id为“hidden-update2”，点击后暂时无实际跳转动作（href="#"表示链接到当前页面顶部），显示文本为“修改教师信息”，可能后续通过JavaScript等操作来显示并赋予实际功能 -->
+                            <!-- 一个隐藏的子菜单选项（通过hidden属性隐藏），id为“hidden-update2”，点击后暂时无实际跳转动作（href="#"表示链接到当前页面顶部），显示文本为“修改教师信息”，可能后续通过JavaScript等操作来显示并赋予实际功能 -->
                             <dd hidden id="hidden-update2"><a href="#">修改教师信息</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/addTeacherServlet）跳转到增加教师页面，依靠服务器端配置的请求路径来实现页面导航 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/addTeacherServlet）跳转到增加教师页面 -->
                             <dd><a href="${pageContext.request.contextPath}/addTeacherServlet">增加教师</a></dd>
                         </dl>
                     </li>
-                    <!-- 一个导航菜单项，代表一级菜单，应用layui-nav-item类来添加相应的样式 -->
+                    <!-- 一个导航菜单项，代表一级菜单，使用layui-nav-item类来应用相应的样式 -->
                     <li class="layui-nav-item">
-                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“学院专业管理”，用于提示该菜单对应的功能板块 -->
+                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“学院专业管理” -->
                         <a class="" href="javascript:;">学院专业管理</a>
                         <!-- 一级菜单下的子菜单列表，使用dl标签配合layui的样式来展示子菜单 -->
                         <dl class="layui-nav-child">
-                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/cdcListServlet）跳转到学院专业查询页面，通过服务器端配置的请求路径实现页面跳转 -->
+                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/cdcListServlet）跳转到学院专业查询页面 -->
                             <dd><a href="${pageContext.request.contextPath}/cdcListServlet">学院专业查询</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后暂时无实际跳转动作（href="#"表示链接到当前页面顶部），显示文本为“学院专业增加”，可能后续通过JavaScript等操作来赋予实际功能，比如在合适的时机触发相应的业务逻辑实现增加学院专业的功能 -->
+                            <!-- 子菜单中的另一个选项，点击后暂时无实际跳转动作（href="#"表示链接到当前页面顶部），显示文本为“学院专业增加”，可能后续通过JavaScript等操作来赋予实际功能 -->
                             <dd><a href="#">学院专业增加</a></dd>
                         </dl>
                     </li>
-                    <!-- 一个导航菜单项，代表一级菜单，应用layui-nav-item类来添加相应的样式 -->
+                    <!-- 一个导航菜单项，代表一级菜单，使用layui-nav-item类来应用相应的样式 -->
                     <li class="layui-nav-item">
-                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“系统管理”，用于标识该菜单对应的功能分类 -->
+                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“系统管理” -->
                         <a class="" href="javascript:;">系统管理</a>
                         <!-- 一级菜单下的子菜单列表，使用dl标签配合layui的样式来展示子菜单 -->
                         <dl class="layui-nav-child">
-                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/notifyServlet）跳转到公告发布页面，借助服务器端配置的请求路径实现页面跳转 -->
+                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/notifyServlet）跳转到公告发布页面 -->
                             <dd><a href="${pageContext.request.contextPath}/notifyServlet">公告发布</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/notifyListServlet）跳转到公告列表页面，依靠服务器端配置的请求路径来实现页面导航 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/notifyListServlet）跳转到公告列表页面 -->
                             <dd><a href="${pageContext.request.contextPath}/notifyListServlet">公告列表</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/fileServlet）跳转到文件发布页面，通过服务器端配置的请求路径实现页面跳转 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/fileServlet）跳转到文件发布页面 -->
                             <dd><a href="${pageContext.request.contextPath}/fileServlet">文件发布</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/fileListServlet）跳转到文件列表页面，依靠服务器端配置的请求路径来实现页面导航 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/fileListServlet）跳转到文件列表页面 -->
                             <dd><a href="${pageContext.request.contextPath}/fileListServlet">文件列表</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/adminPasswordIndexServlet）跳转到修改密码页面，借助服务器端配置的请求路径实现页面跳转 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/adminPasswordIndexServlet）跳转到修改密码页面 -->
                             <dd><a href="${pageContext.request.contextPath}/adminPasswordIndexServlet">修改密码</a></dd>
                         </dl>
                     </li>

web/WEB-INF/notify/addNotify.jsp

@@ -1,113 +1,88 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
-<!-- 以上两行是JSP页面的指令，第一行设置页面内容类型为HTML且编码为UTF-8，语言为Java；
-第二行引入JSTL核心标签库，方便在页面中进行逻辑处理等操作 -->
 <html>
 <head>
     <title>公告发布</title>
-    <!-- 设置页面标题为“公告发布” -->
     <link rel="stylesheet" href="./css/layui.css">
-    <!-- 引入layui的样式文件，用于页面布局和样式美化 -->
     <link rel="stylesheet" href="./css/style.css">
-    <!-- 引入自定义的style.css样式文件，可能包含针对该页面的特定样式 -->
     <script src="./layui.js"></script>
-    <!-- 引入layui的JavaScript脚本文件，提供各种交互功能等 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
-    <!-- 引入jQuery库，方便进行DOM操作、事件处理等 -->
     <style type="text/css">
-       .input-block {
+        .input-block {
             margin-left: 0px;
             min-height: 36px;
         }
-        /* 定义类名为.input-block的样式，设置左边距为0像素，最小高度为36像素 */
         #addnotifybutton {
             text-align: center;
         }
-        /* 定义id为addnotifybutton的元素样式，使其内部文本居中对齐 */
-       .layui-btn {
+        .layui-btn {
             width: 30%;
         }
-        /* 定义类名为layui-btn的按钮样式，设置宽度为30% */
     </style>
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
-    <!-- 设置页面主体的类名和背景颜色，可能与layui的布局样式相关 -->
-    <jsp:include page="/filterLogin.jsp"></jsp:include>
-    <!-- 包含filterLogin.jsp页面，可能用于登录验证等相关功能 -->
-    <jsp:include page="/WEB-INF/admin/aHeader.jsp"></jsp:include>
-    <!-- 包含aHeader.jsp页面，通常用于页面头部布局等内容 -->
-    <jsp:include page="/WEB-INF/admin/adminNav.jsp"></jsp:include>
-    <!-- 包含adminNav.jsp页面，一般用于展示页面导航栏相关内容 -->
-    <div class="layui-layout layui-layout-admin">
-        <div class="layui-body">
-            <!-- 内容主体区域 -->
-            <div style="padding: 15px;">
-                <span class="layui-breadcrumb">
-                    <a>管理员</a>
-                    <a>系统管理</a>
-                    <a><cite>公告发布</cite></a>
-                </span>
-                <!-- 展示面包屑导航，显示当前页面在系统中的层级位置 -->
-                <p> &nbsp;</p>
-                <form action="${pageContext.request.contextPath}/addNotifyServlet" method="post">
-                    <!-- 创建一个表单，表单提交的目标地址是addNotifyServlet，提交方式为POST -->
-                    <div class="input-block">
-                        <textarea name="notifyInfo" placeholder="请输入内容" class="layui-textarea" required lay-verify="required"></textarea>
-                        <!-- 创建一个文本域，用于输入公告内容，设置了名称、占位提示文本、样式类以及必填验证等属性 -->
-                        <p>
-                    </div>
-                    <%--    <input type="text" name="notifyInfo" />--%>
-                    <div id="addnotifybutton">
-                        <button type="submit" class="layui-btn">发布</button>
-                    </div>
-                    <!-- 创建一个按钮，类型为提交按钮，样式类为layui-btn，点击时会提交表单 -->
-                </form>
+<jsp:include page="/filterLogin.jsp"></jsp:include>
+<jsp:include page="/WEB-INF/admin/aHeader.jsp"></jsp:include>
+<jsp:include page="/WEB-INF/admin/adminNav.jsp"></jsp:include>
+<div class="layui-layout layui-layout-admin">
+    <div class="layui-body">
+        <!-- 内容主体区域 -->
+        <div style="padding: 15px;">
+            <span class="layui-breadcrumb">
+                <a>管理员</a>
+                <a>系统管理</a>
+                <a><cite>公告发布</cite></a>
+            </span>
+            <p> &nbsp;</p>
+            <form action="${pageContext.request.contextPath}/addNotifyServlet" method="post">
+                <div class="input-block">
+                    <textarea name="notifyInfo" placeholder="请输入内容" class="layui-textarea" required lay-verify="required"></textarea>
+                    <p>
+                </div>
+                <%--    <input type="text" name="notifyInfo" />--%>
+                <div id="addnotifybutton">
+                    <button type="submit" class="layui-btn">发布</button>
+                </div>
+            </form>
 
-                <table class="layui-table" lay-filter="test">
-                    <thead>
-                    <tr>
-                        <th>公告ID</th>
-                        <th>公告日期</th>
-                        <th>公告内容</th>
-                        <th>操作</th>
-                    </tr>
-                    </thead>
-                    <!-- 定义表格的表头，包含公告ID、日期、内容和操作列 -->
-                    <c:forEach items="${notifys}" var="notify">
-                    <tr>
-                        <td>${notify.id}</td>
-                        <td>${notify.notifyDate}</td>
-                        <td>${notify.notifyInfo}</td>
-                        <td><button class="layui-btn layui-btn-normal">修改</button><button class="layui-btn layui-btn-danger">删除</button></td>
-                    </tr>
-                    </c:forEach>
-                    <!-- 使用JSTL的forEach标签循环遍历notifys集合，将每个元素（这里假设是公告对象）的数据展示在表格行中，
-                    每行包含公告的相关信息以及修改和删除按钮 -->
-                </table>
+            <table class="layui-table" lay-filter="test">
+                <thead>
+                <tr>
+                    <th>公告ID</th>
+                    <th>公告日期</th>
+                    <th>公告内容</th>
+                    <th>操作</th>
+                </tr>
+                </thead>
 
-                <jsp:include page="/footer.jsp"></jsp:include>
-                <!-- 包含footer.jsp页面，通常用于页面底部相关内容展示，比如版权信息等 -->
-            </div>
+                <c:forEach items="${notifys}" var="notify">
+                <tr>
+                    <td>${notify.id}</td>
+                    <td>${notify.notifyDate}</td>
+                    <td>${notify.notifyInfo}</td>
+                    <td><button class="layui-btn layui-btn-normal">修改</button><button class="layui-btn layui-btn-danger">删除</button></td>
+                </tr>
+            </c:forEach>
+            </table>
+
+            <jsp:include page="/footer.jsp"></jsp:include>
         </div>
     </div>
+</div>
 
 
-    <script type="text/javascript">
-        $("#nav li:nth-child(5) dl dd:nth-child(1)").addClass("layui-this");
-        // 使用jQuery选择器选中特定的导航栏元素（第5个li下的第一个dl下的第一个dd），并添加类名layui-this，
-        // 可能用于标记当前选中的导航项样式
-        $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
-        // 使用jQuery选择器选中特定的导航栏元素（第5个li），并添加类名layui-nav-itemed，
-        // 可能用于展开或标记特定导航栏的展开状态相关样式
-    </script>
-    <script>
-        //JavaScript代码区域
-        layui.use('element', function(){
-            var element = layui.element;
-            element.init();
-        });
-        // 使用layui框架的element模块，调用init方法进行初始化，可能用于初始化页面的一些交互元素等功能
-    </script>
+<script type="text/javascript">
+    $("#nav li:nth-child(5) dl dd:nth-child(1)").addClass("layui-this");
+    $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
+</script>
+<script>
+    //JavaScript代码区域
+    layui.use('element', function(){
+        var element = layui.element;
+        element.init();
+    });
+</script>
 
 </body>
-</html>
+</html>
+

web/WEB-INF/notify/notifyList.jsp

@@ -1,55 +1,40 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
-<!-- 上述两行是JSP页面的指令：
-第一行设置页面内容类型为HTML，编码格式为UTF-8，并且指定使用Java语言；
-第二行引入JSTL（JavaServer Pages Standard Tag Library）的核心标签库，方便在页面中进行一些逻辑处理、数据遍历等操作 -->
 <html>
 <head>
     <title>公告列表</title>
-    <!-- 设置页面的标题为“公告列表”，该标题会显示在浏览器的标题栏 -->
     <link rel="stylesheet" href="./css/layui.css">
-    <!-- 引入layui框架的样式文件，layui.css用于实现页面的布局、样式美化等功能 -->
     <link rel="stylesheet" href="./css/style.css">
-    <!-- 引入自定义的style.css样式文件，可能包含针对本页面特有的样式规则，用于进一步定制页面外观 -->
     <script src="./layui.js"></script>
-    <!-- 引入layui框架的JavaScript脚本文件，提供了众多交互功能、组件等相关的代码逻辑 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
-    <!-- 引入jQuery库，它是一个广泛使用的JavaScript库，便于进行DOM操作、事件处理、动画效果等各种前端开发任务 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
-    <!-- 设置页面主体的类名为layui-layout-body，并指定背景颜色为浅灰色（#F2F2F2），可能是基于layui框架的布局样式规范 -->
-    <jsp:include page="/filterLogin.jsp"></jsp:include>
-    <!-- 通过JSP的include指令包含filterLogin.jsp页面，通常用于处理用户登录验证等相关逻辑，保证只有登录后的用户能访问本页面 -->
-    <jsp:include page="/WEB-INF/admin/aHeader.jsp"></jsp:include>
-    <!-- 包含aHeader.jsp页面，一般用于构建页面的头部区域，比如展示网站名称、导航栏等内容 -->
-    <jsp:include page="/WEB-INF/admin/adminNav.jsp"></jsp:include>
-    <!-- 包含adminNav.jsp页面，大概率是用于展示页面的导航菜单，方便用户在不同功能页面之间进行切换 -->
-    <div class="layui-layout layui-layout-admin">
-        <div class="layui-body">
-            <!-- 内容主体区域，layui框架中用于承载页面主要内容的部分 -->
-            <div style="padding: 15px;">
-                <span class="layui-breadcrumb">
-                    <a>管理员</a>
-                    <a>系统管理</a>
-                    <a><cite>公告列表</cite></a>
-                </span>
-                <!-- 展示面包屑导航，清晰地呈现当前页面在整个系统层级结构中的位置，方便用户知晓所在路径 -->
-                <p> &nbsp;</p>
+<jsp:include page="/filterLogin.jsp"></jsp:include>
+<jsp:include page="/WEB-INF/admin/aHeader.jsp"></jsp:include>
+<jsp:include page="/WEB-INF/admin/adminNav.jsp"></jsp:include>
+<div class="layui-layout layui-layout-admin">
+    <div class="layui-body">
+        <!-- 内容主体区域 -->
+        <div style="padding: 15px;">
+            <span class="layui-breadcrumb">
+                <a>管理员</a>
+                <a>系统管理</a>
+                <a><cite>公告列表</cite></a>
+            </span>
+            <p> &nbsp;</p>
 
-                <table class="layui-table" lay-filter="test">
-                    <thead>
-                    <tr>
-                        <th><input type="checkbox" class="my-checkbox" name="" title="" lay-skin="primary"></th>
-                        <th>公告ID</th>
-                        <th>公告日期</th>
-                        <th>公告内容</th>
-                        <th>操作</th>
-                    </tr>
-                    </thead>
-                    <!-- 定义表格的表头部分：
-                    第一个<th>中创建了一个带有layui样式的复选框，可能用于批量操作（如批量删除等）；
-                    后续的<th>分别定义了公告ID、公告日期、公告内容和操作列的表头名称 -->
-                    <c:forEach items="${notifys}" var="notify" varStatus="n">
+            <table class="layui-table" lay-filter="test">
+                <thead>
+                <tr>
+                    <th><input type="checkbox" class="my-checkbox" name="" title="" lay-skin="primary"></th>
+                    <th>公告ID</th>
+                    <th>公告日期</th>
+                    <th>公告内容</th>
+                    <th>操作</th>
+                </tr>
+                </thead>
+
+                <c:forEach items="${notifys}" var="notify" varStatus="n">
                     <tr>
                         <th><input type="checkbox" class="my-checkbox" name="" title="" lay-skin="primary"></th>
                         <td>${n.count}</td>
@@ -57,51 +42,34 @@
                         <td>${notify.notifyInfo}</td>
                         <td><a class="layui-btn layui-btn-danger" href="javascript:deleteNotify(${notify.id});">删除</a></td>
                     </tr>
-                    </c:forEach>
-                    <!-- 使用JSTL的forEach标签循环遍历名为notifys的集合（通常是从后端传递过来的公告数据列表）：
-                    对于每个公告元素（用notify变量表示），创建表格的一行<tr>：
-                    第一个<td>同样创建一个复选框；
-                    第二个<td>使用varStatus属性的count属性展示序号（从1开始计数）；
-                    第三个<td>展示公告的日期；
-                    第四个<td>展示公告的内容；
-                    第五个<td>创建一个带有layui样式的删除按钮，点击按钮会调用JavaScript函数deleteNotify，并传递当前公告的ID作为参数 -->
-                </table>
+                </c:forEach>
+            </table>
 
-                <jsp:include page="/footer.jsp"></jsp:include>
-                <!-- 包含footer.jsp页面，通常用于展示页面底部的相关信息，比如版权声明、联系方式等内容 -->
-            </div>
+            <jsp:include page="/footer.jsp"></jsp:include>
         </div>
     </div>
+</div>
 
 
-    <script type="text/javascript">
-        $("#nav li:nth-child(5) dl dd:nth-child(2)").addClass("layui-this");
-        // 使用jQuery选择器选中特定的导航栏元素（第5个li下的第二个dl下的第二个dd），并添加类名layui-this，
-        // 可能用于标记当前选中的导航项样式，使其呈现出与其他导航项不同的视觉效果，表明当前所在页面为“公告列表”相关页面
-        $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
-        // 使用jQuery选择器选中特定的导航栏元素（第5个li），并添加类名layui-nav-itemed，
-        // 可能用于展开或标记特定导航栏的展开状态相关样式，以展示对应的二级导航等内容
-    </script>
-    <script>
-        //JavaScript代码区域
-        layui.use('element', function(){
-            var element = layui.element;
-            element.init();
-        });
-        // 使用layui框架的element模块，调用init方法进行初始化，可能用于初始化页面的一些交互元素、组件等功能，
-        // 比如菜单的展开收起、选项卡切换等交互效果的初始化
-    </script>
+<script type="text/javascript">
+    $("#nav li:nth-child(5) dl dd:nth-child(2)").addClass("layui-this");
+    $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
+</script>
+<script>
+    //JavaScript代码区域
+    layui.use('element', function(){
+        var element = layui.element;
+        element.init();
+    });
+</script>
 
-    <script>
-        function deleteNotify(n_id) {
-            if (confirm("你确定删除该通知吗？")) {
-                location.href = "${pageContext.request.contextPath}/deleteNotifyServlet?id=" + n_id;
-            }
+<script>
+    function deleteNotify(n_id) {
+        if (confirm("你确定删除该通知吗？")) {
+            location.href = "${pageContext.request.contextPath}/deleteNotifyServlet?id=" + n_id;
         }
-        // 定义名为deleteNotify的JavaScript函数，接收一个参数n_id（公告的ID）：
-        // 首先通过confirm函数弹出一个确认框，询问用户是否确定删除该通知；
-        // 如果用户点击确认（点击“确定”按钮），则将页面重定向到后端的deleteNotifyServlet，并通过URL参数传递要删除的公告ID，
-        // 由后端的这个Servlet来处理实际的删除逻辑
-    </script>
+    }
+</script>
 </body>
-</html>
+</html>
+

web/WEB-INF/notify/notifyListToStudent.jsp

@@ -1,79 +1,59 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
-<!-- 以上两行是JSP页面的相关指令：
-第一行用于设置该JSP页面输出的内容类型为text/html（即HTML格式），字符编码采用UTF-8，同时指定页面使用的编程语言为Java；
-第二行引入了JSTL（JavaServer Pages Standard Tag Library）核心标签库，通过指定的前缀“c”，后续就能在页面中方便地使用该库提供的各种标签进行逻辑处理、数据展示等操作 -->
 <html>
 <head>
     <title>公告列表</title>
-    <!-- 设置当前HTML页面的标题为“公告列表”，这个标题通常会显示在浏览器的标题栏位置 -->
     <link rel="stylesheet" href="./css/layui.css">
-    <!-- 引入layui框架的样式表文件，layui.css中定义了诸多用于页面布局、组件样式等方面的样式规则，能帮助快速搭建出具有一定风格的页面 -->
     <link rel="stylesheet" href="./css/style.css">
-    <!-- 引入自定义的style.css样式文件，这里面可以包含针对当前页面特殊需求所定制的一些样式，用于覆盖或补充layui框架样式的不足 -->
     <script src="./layui.js"></script>
-    <!-- 引入layui框架对应的JavaScript脚本文件，layui.js包含了实现各种交互功能、组件逻辑等的代码，是页面实现动态效果的重要依赖 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
-    <!-- 引入jQuery库，jQuery是一个非常流行的JavaScript库，它提供了简洁易用的方法来操作DOM元素、处理事件、实现动画效果等，方便前端开发 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
-    <!-- 设置页面主体的类名为“layui-layout-body”，同时指定背景颜色为#F2F2F2（一种淡灰色），这可能是基于layui框架的布局样式要求，使页面呈现出相应的外观效果 -->
-    <jsp:include page="/filterLogin.jsp"></jsp:include>
-    <!-- 通过JSP的include指令包含名为“filterLogin.jsp”的页面，通常这个页面用于处理用户登录验证相关的逻辑，确保只有合法登录的用户才能访问当前页面的内容 -->
-    <jsp:include page="/WEB-INF/student/sHeader.jsp"></jsp:include>
-    <!-- 包含“/WEB-INF/student/sHeader.jsp”页面，一般来说，这个页面用于构建学生端页面的头部区域，比如展示学校标识、学生相关的功能菜单等 -->
-    <jsp:include page="/WEB-INF/student/studentNav.jsp"></jsp:include>
-    <!-- 包含“/WEB-INF/student/studentNav.jsp”页面，大概率是用于生成学生端的导航栏，方便学生在不同的功能模块或页面之间进行切换 -->
-    <div class="layui-layout layui-layout-admin">
-        <div class="layui-body">
-            <!-- 这里是layui框架中用于承载页面主要内容的部分，也就是内容主体区域 -->
-            <div style="padding: 15px;">
-                <span class="layui-breadcrumb">
-                    <a>学生端</a>
-                    <a><cite>公告列表</cite></a>
-                </span>
-                <!-- 展示面包屑导航，通过这种方式可以清晰地向学生展示当前页面在整个学生端系统层级结构中的位置，便于他们了解所处的页面路径 -->
-                <p> &nbsp;</p>
+<jsp:include page="/filterLogin.jsp"></jsp:include>
+<jsp:include page="/WEB-INF/student/sHeader.jsp"></jsp:include>
+<jsp:include page="/WEB-INF/student/studentNav.jsp"></jsp:include>
+<div class="layui-layout layui-layout-admin">
+    <div class="layui-body">
+        <!-- 内容主体区域 -->
+        <div style="padding: 15px;">
+            <span class="layui-breadcrumb">
+                <a>学生端</a>
+                <a><cite>公告列表</cite></a>
+            </span>
+            <p> &nbsp;</p>
 
-                <table class="layui-table" lay-filter="test">
-                    <thead>
-                    <tr>
-                        <th>公告ID</th>
-                        <th>公告日期</th>
-                        <th>公告内容</th>
-                    </tr>
-                    </thead>
-                    <!-- 定义表格的表头部分，分别创建了三个列标题，用于表示公告的ID、发布日期以及具体的内容，后续数据会按照这个表头结构进行展示 -->
-                    <c:forEach items="${notifys}" var="notify" varStatus="n">
+            <table class="layui-table" lay-filter="test">
+                <thead>
+                <tr>
+                    <th>公告ID</th>
+                    <th>公告日期</th>
+                    <th>公告内容</th>
+                </tr>
+                </thead>
+
+                <c:forEach items="${notifys}" var="notify" varStatus="n">
                     <tr>
                         <td>${n.count}</td>
                         <td>${notify.notifyDate}</td>
                         <td>${notify.notifyInfo}</td>
                     </tr>
-                    </c:forEach>
-                    <!-- 使用JSTL的forEach标签对名为“notifys”的集合进行循环遍历，这个集合通常是从后端传递过来的公告数据列表。
-                    对于列表中的每一个公告元素（用“notify”变量表示），创建表格中的一行（<tr>标签）来展示对应公告的数据：
-                    第一个<td>单元格展示序号（通过varStatus的count属性实现，从1开始计数）；
-                    第二个<td>单元格展示公告的发布日期；
-                    第三个<td>单元格展示公告的具体内容 -->
-                </table>
+                </c:forEach>
+            </table>
 
-                <jsp:include page="/footer.jsp"></jsp:include>
-                <!-- 包含“/footer.jsp”页面，通常这个页面用于展示页面底部的相关信息，比如版权声明、联系方式、页面底部的导航链接等内容 -->
-            </div>
+            <jsp:include page="/footer.jsp"></jsp:include>
         </div>
     </div>
+</div>
 
 
 
-    <script>
-        //JavaScript代码区域，以下代码用于初始化layui框架的相关功能模块
-        layui.use('element', function(){
-            var element = layui.element;
-            element.init();
-        });
-        // 通过layui.use方法调用“element”模块，并在回调函数中获取该模块的实例（赋值给“element”变量），然后调用其“init”方法进行初始化操作。
-        // “element”模块通常用于处理页面元素相关的交互逻辑，例如菜单的展开与收起、选项卡的切换等功能的初始化
-    </script>
+<script>
+    //JavaScript代码区域
+    layui.use('element', function(){
+        var element = layui.element;
+        element.init();
+    });
+</script>
 </body>
-</html>
+</html>
+

web/WEB-INF/notify/notifyListToTeacher.jsp

@@ -1,79 +1,59 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
-<!-- 以上两行是JSP页面的指令声明：
-第一行设置此JSP页面输出内容的类型为HTML格式（text/html），并且指定字符编码为UTF-8，同时表明该页面使用Java语言来编写相关逻辑代码；
-第二行引入了JSTL（JavaServer Pages Standard Tag Library）的核心标签库，定义了前缀“c”，后续就能利用这个标签库提供的标签在页面里进行诸如数据遍历、条件判断等操作 -->
 <html>
 <head>
     <title>公告列表</title>
-    <!-- 设置HTML页面的标题为“公告列表”，这个标题会显示在浏览器的标题栏上，让用户直观知晓当前页面的主要内容 -->
     <link rel="stylesheet" href="./css/layui.css">
-    <!-- 引入layui框架的样式表文件，layui.css里面包含了众多用于页面布局设计、各种组件样式定义等的样式规则，借助它可以快速搭建出风格统一的页面外观 -->
     <link rel="stylesheet" href="./css/style.css">
-    <!-- 引入自定义的style.css样式文件，通常是开发者根据页面的特定需求编写的，用于对layui框架的默认样式进行补充或者覆盖，实现更个性化的页面展示效果 -->
     <script src="./layui.js"></script>
-    <!-- 引入layui框架对应的JavaScript文件，layui.js包含了大量实现页面交互功能、各种组件业务逻辑等的代码，是让页面具备动态交互能力的关键所在 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
-    <!-- 引入jQuery库，jQuery是一个广泛应用的JavaScript库，它提供了简洁且方便的方法来操作DOM元素、处理页面事件、实现动画效果等，能极大地简化前端开发工作 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
-    <!-- 设置页面主体的类名为“layui-layout-body”，并指定背景颜色为#F2F2F2（一种淡灰色），这大概率是依据layui框架的布局样式规范来设定的，以此营造出特定的页面视觉风格 -->
-    <jsp:include page="/filterLogin.jsp"></jsp:include>
-    <!-- 通过JSP的include指令引入“filterLogin.jsp”页面，一般情况下，这个页面用于执行用户登录验证相关的逻辑操作，只有当用户成功登录后，才能继续访问当前页面展示的内容 -->
-    <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
-    <!-- 引入“/WEB-INF/teacher/tHeader.jsp”页面，通常该页面用于构建教师端页面的头部区域，例如展示学校名称、教师相关的功能菜单、个人信息等内容 -->
-    <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
-    <!-- 引入“/WEB-INF/teacher/teacherNav.jsp”页面，其主要作用是生成教师端的导航栏，方便教师在不同的功能模块、业务页面之间进行切换操作 -->
-    <div class="layui-layout layui-layout-admin">
-        <div class="layui-body">
-            <!-- 这是layui框架中定义的用于承载页面主要内容的部分，也就是所谓的内容主体区域，各种核心业务数据、功能展示都会放置在此处 -->
-            <div style="padding: 15px;">
-                <span class="layui-breadcrumb">
-                    <a>教师端</a>
-                    <a><cite>公告列表</cite></a>
-                </span>
-                <!-- 展示面包屑导航，通过这种方式可以清晰地向教师展示当前页面在整个教师端系统的层级结构中所处的位置，方便教师了解自己当前所在的页面路径 -->
-                <p> &nbsp;</p>
+<jsp:include page="/filterLogin.jsp"></jsp:include>
+<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+<jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+<div class="layui-layout layui-layout-admin">
+    <div class="layui-body">
+        <!-- 内容主体区域 -->
+        <div style="padding: 15px;">
+            <span class="layui-breadcrumb">
+                <a>教师端</a>
+                <a><cite>公告列表</cite></a>
+            </span>
+            <p> &nbsp;</p>
 
-                <table class="layui-table" lay-filter="test">
-                    <thead>
-                    <tr>
-                        <th>公告ID</th>
-                        <th>公告日期</th>
-                        <th>公告内容</th>
-                    </tr>
-                    </thead>
-                    <!-- 定义表格的表头部分，这里创建了三个列标题，分别用于展示公告的唯一标识符（公告ID）、公告发布的具体日期以及公告包含的详细内容，后续表格行的数据会按照这个表头结构来依次填充 -->
-                    <c:forEach items="${notifys}" var="notify" varStatus="n">
+            <table class="layui-table" lay-filter="test">
+                <thead>
+                <tr>
+                    <th>公告ID</th>
+                    <th>公告日期</th>
+                    <th>公告内容</th>
+                </tr>
+                </thead>
+
+                <c:forEach items="${notifys}" var="notify" varStatus="n">
                     <tr>
                         <td>${n.count}</td>
                         <td>${notify.notifyDate}</td>
                         <td>${notify.notifyInfo}</td>
                     </tr>
-                    </c:forEach>
-                    <!-- 使用JSTL的forEach标签对名为“notifys”的集合进行循环遍历，这个集合通常是由后端程序传递过来的公告数据列表。
-                    针对列表里的每一条公告数据（用变量“notify”表示），都会创建一个表格行（<tr>标签）来展示对应公告的相关信息：
-                    第一个<td>单元格展示的是序号，通过varStatus对象的count属性来实现计数功能，序号从1开始；
-                    第二个<td>单元格展示的是该公告的发布日期；
-                    第三个<td>单元格展示的是该公告包含的具体内容 -->
-                </table>
+                </c:forEach>
+            </table>
 
-                <jsp:include page="/footer.jsp"></jsp:include>
-                <!-- 引入“/footer.jsp”页面，一般来说，这个页面用于展示页面底部的相关信息，像版权声明、联系方式、网站相关的友情链接等内容 -->
-            </div>
+            <jsp:include page="/footer.jsp"></jsp:include>
         </div>
     </div>
+</div>
 
 
 
-    <script>
-        //JavaScript代码区域，以下代码的目的是初始化layui框架的相关功能模块，使其能正常工作并提供相应的交互功能
-        layui.use('element', function(){
-            var element = layui.element;
-            element.init();
-        });
-        // 通过layui框架提供的use方法来加载“element”模块，在加载完成后的回调函数里获取该模块的实例（将其赋值给变量“element”），然后调用实例的“init”方法进行初始化操作。
-        // “element”模块在layui框架中主要负责处理页面元素相关的交互逻辑，例如菜单的展开与收起、选项卡的切换等功能的初始化工作
-    </script>
+<script>
+    //JavaScript代码区域
+    layui.use('element', function(){
+        var element = layui.element;
+        element.init();
+    });
+</script>
 </body>
-</html>
+</html>
+