src/dao/AdminDao.java

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

src/dao/CDCDao.java

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

src/dao/ComplaintDao.java

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

src/dao/CourseDao.java

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

src/dao/NotifyDao.java

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

src/dao/PhotoDao.java

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

src/dao/SelectCourseDao.java

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

src/dao/StudentDao.java

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

src/dao/TeacherDao.java

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

src/dao/impl/AdminDaoImpl.java

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

src/dao/impl/CDCDaoImpl.java

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

src/dao/impl/ComplaintDaoImpl.java

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

src/dao/impl/CourseDaoImpl.java

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

src/dao/impl/NotifyDaoImpl.java

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

src/dao/impl/PhotoDaoImpl.java

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

src/dao/impl/SelectCourseDaoImpl.java

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

src/dao/impl/StudentDaoImpl.java

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

src/dao/impl/TeacherDaoImpl.java

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

src/domain/Admin.java

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

src/domain/CDC.java

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

src/domain/Complaint.java

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

src/domain/Course.java

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

src/domain/FileClass.java

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

src/domain/Notify.java

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

src/domain/PageBean.java

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

src/domain/Photo.java

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

src/domain/SelectCourse.java

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

src/domain/Student.java

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

src/domain/Teacher.java

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

src/service/AdminService.java

@@ -4,11 +4,11 @@ package service;
 import domain.Admin;
 
 /**
- * 管理员的业务接口
+ * 管理员业务接口
  */
 public interface AdminService {
     /**
-     * 管理员登录
+     * 管理员的登录
      */
     Admin login(Admin admin);
 

src/service/CDCService.java

@@ -7,7 +7,7 @@ import domain.CDC;
 import java.util.List;
 
 /**
- * 学院专业班级的业务接口
+ * 学院专业班级的业务接口-
  */
 public interface CDCService {
     List<CDC> findAllCollege();

src/service/ComplaintService.java

@@ -5,7 +5,7 @@ import domain.Complaint;
 import java.util.List;
 
 /**
- * 小吐槽的业务接口
+ * 小吐槽的业务接口-
  */
 public interface ComplaintService {
     List<Complaint> findAll();

src/service/CourseService.java

@@ -1,7 +1,9 @@
 package service;
 
 import domain.Course;
-
+/**
+ * 课程管理服务接口
+ */
 public interface CourseService {
     void addOptionalCourse(Course course);
 

src/service/NotifyService.java

@@ -5,11 +5,11 @@ import domain.Notify;
 import java.util.List;
 
 /**
- * 公告的业务接口
+ * 公告的业务接口-
  */
 public interface NotifyService {
     /**
-     * 公告发布
+     * 公告发布-
      */
     void addNotify(Notify notify);
 

src/service/PhotoService.java

@@ -1,7 +1,9 @@
 package service;
 
 import domain.Photo;
-
+/**
+ * 照片管理服务接口
+ */
 public interface PhotoService {
     void addPhoto(Photo photo);
 

src/service/SelectCourseService.java

@@ -3,7 +3,9 @@ package service;
 import domain.SelectCourse;
 
 import java.util.List;
-
+/**
+ * 选课服务接口
+ */
 public interface SelectCourseService {
     List<SelectCourse> findStudentSelectedCourseByCourseId(String cid);
 

src/service/StudentService.java

@@ -8,11 +8,11 @@ import java.util.List;
 import java.util.Map;
 
 /**
- * 学生管理的业务接口
+ * 学生管理的业务接口-
  */
 public interface StudentService {
     /**
-     * 分页条件查询
+     * 分页条件查询-
      * @param currentPage
      * @param rows
      * @param condition
@@ -21,7 +21,7 @@ public interface StudentService {
     PageBean<Student> findStudentByPage(String currentPage, String rows, Map<String, String[]> condition);
 
     /**
-     * 查询所有学生信息
+     * 查询所有学生信息-
      */
     List<Student> findAll();
 
@@ -49,3 +49,42 @@ public interface StudentService {
 
     List<SelectCourse> findSelectCourseAllStudent();
 }
+//public interface StudentService {
+//    /**
+//     * 分页条件查询-
+//     * @param currentPage
+//     * @param rows
+//     * @param condition
+//     * @return
+//     */
+//    PageBean<Student> findStudentByPage(String currentPage, String rows, Map<String, String[]> condition);
+//
+//    /**
+//     * 查询所有学生信息-
+//     */
+//    List<Student> findAll();
+//
+//    Student login(Student student);
+//
+//    Student findStudentById(Student student);
+//
+//    void register(Student student);
+//
+//    void updateInfo(Student student);
+//
+//    void updatePassword(String studentid, String newpassword);
+//
+//    List<SelectCourse> findAllSelectCourse(String studentid);
+//
+//    List<Course> findAllOptionalCourse();
+//
+//    void addSelectCourse(String studentid, String courseid);
+//
+//    void deleteStudentById(String studentid);
+//
+//    void deleteSelectStudent(String[] sids);
+//
+//    void addStudentAllInfo(Student updateStudent);
+//
+//    List<SelectCourse> findSelectCourseAllStudent();
+//}

src/service/TeacherService.java

@@ -6,11 +6,11 @@ import domain.Teacher;
 import java.util.List;
 
 /**
- * 教师管理的业务接口
+ * 教师管理的业务接口-
  */
 public interface TeacherService {
     /**
-     * 教师登录
+     * 教师登录-
      */
     Teacher login(Teacher teacher);
 
@@ -33,4 +33,30 @@ public interface TeacherService {
     void deleteTeacherById(String teacherid);
 
     void updateInfo(Teacher updateTeacher);
-}
+}
+//public interface TeacherService {
+//    /**
+//     * 教师登录-
+//     */
+//    Teacher login(Teacher teacher);
+//
+//    List<Teacher> findAll();
+//
+//    List<Course> findMySelfOptionalCourse(String T_id);
+//
+//    Course findOptionalCourseByCourseId(String cid);
+//
+//    void updateCourseInfo(Course updateCourse);
+//
+//    void deleteCourseById(String cid);
+//
+//    void updatePassword(String teacherid, String newpassword);
+//
+//    Teacher findTeacherById(Teacher teacher);
+//
+//    void addTeacherAllInfo(Teacher updateTeacher);
+//
+//    void deleteTeacherById(String teacherid);
+//
+//    void updateInfo(Teacher updateTeacher);
+//}

src/service/impl/AdminServiceImpl.java

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

src/service/impl/CDCServiceImpl.java

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

src/service/impl/ComplaintServiceImpl.java

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

src/service/impl/CourseServiceImpl.java

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

src/service/impl/NotifyServiceImpl.java

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

src/service/impl/PhotoServiceImpl.java

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

src/service/impl/SelectCourseServiceImpl.java

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

src/service/impl/StudentServiceImpl.java

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

src/service/impl/TeacherServiceImpl.java

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

src/utils/JDBCUtils.java

@@ -10,7 +10,7 @@ import java.sql.Statement;
 import java.util.Properties;
 
 /**
- * Druid连接池工具类,将来dao层调用
+ * Druid连接池工具类,将来dao层调用-
  */
 public class JDBCUtils {
     private static DataSource dataSource;   //定义成员变量DataSource
@@ -28,14 +28,14 @@ public class JDBCUtils {
     }
 
     /**
-     * 获取连接
+     * 获取连接-
      */
     public static Connection getConnection() throws SQLException {
         return dataSource.getConnection();
     }
 
     /**
-     * 释放资源
+     * 释放资源-
      */
     public static void close(Statement statement,Connection connection) {
         close(null,statement,connection);
@@ -68,9 +68,71 @@ public class JDBCUtils {
     }
 
     /**
-     * 获取连接池方法
+     * 获取连接池方法-
      */
     public static DataSource getDataSource() {
         return dataSource;
     }
 }
+//public class JDBCUtils {
+//    private static DataSource dataSource;   //定义成员变量DataSource
+//    static {
+//        try {
+//            //加载配置文件
+//            Properties properties = new Properties();
+//            properties.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
+//
+//            //获取DataSource
+//            dataSource = DruidDataSourceFactory.createDataSource(properties);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//        }
+//    }
+//
+//    /**
+//     * 获取连接-
+//     */
+//    public static Connection getConnection() throws SQLException {
+//        return dataSource.getConnection();
+//    }
+//
+//    /**
+//     * 释放资源-
+//     */
+//    public static void close(Statement statement,Connection connection) {
+//        close(null,statement,connection);
+//    }
+//
+//    public static void close(ResultSet resultSet, Statement statement, Connection connection) {
+//        if (resultSet != null) {
+//            try {
+//                resultSet.close();
+//            } catch (SQLException e) {
+//                e.printStackTrace();
+//            }
+//        }
+//
+//        if (statement != null) {
+//            try {
+//                statement.close();
+//            } catch (SQLException e) {
+//                e.printStackTrace();
+//            }
+//        }
+//
+//        if (connection != null) {
+//            try {
+//                connection.close();//归还连接
+//            }catch (SQLException e) {
+//                e.printStackTrace();
+//            }
+//        }
+//    }
+//
+//    /**
+//     * 获取连接池方法-
+//     */
+//    public static DataSource getDataSource() {
+//        return dataSource;
+//    }
+//}

src/web/servlet/admin/AddStudentInfoServlet.java

@@ -17,7 +17,7 @@ public class AddStudentInfoServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         StudentService service= new StudentServiceImpl();
-        //先进行判断是否已存在该学生
+        //先进行判断是否已存在该学生-
         String sid = request.getParameter("student-id");
         Student s = new Student();
         s.setS_id(sid);
@@ -59,7 +59,7 @@ 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);
 
         }

src/web/servlet/admin/AddStudentServlet.java

@@ -16,12 +16,17 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
 
+/**
+ * 添加学生的Servlet处理类
+ */
 @WebServlet("/addStudentServlet")
 public class AddStudentServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求编码为UTF-8，以支持中文字符的正确处理
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
 
+        // 创建CDCService的实例，通常用于处理与学院、系、班级相关的业务逻辑
         CDCService service2 = new CDCServiceImpl();
         List<CDC> collegeList = service2.findAllCollege();
         List<CDC> departmentList = service2.findAllDepartment();

src/web/servlet/admin/AdminPasswordIndexServlet.java

@@ -8,7 +8,11 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
 @WebServlet("/adminPasswordIndexServlet")
+/*
+  管理员密码更新界面的Servlet处理类
+ */
 public class AdminPasswordIndexServlet extends HttpServlet {
+    // 将请求转发到管理员密码更新界面
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.getRequestDispatcher("/WEB-INF/admin/adminUpdatePassword.jsp").forward(request,response);
     }

src/web/servlet/admin/AdminPasswordUpdateServlet.java

@@ -15,7 +15,9 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.Date;
-
+/**
+ * 管理员密码更新的Servlet处理类
+ */
 @WebServlet("/adminPasswordUpdateServlet")
 public class AdminPasswordUpdateServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

src/web/servlet/admin/DoDeleteSelectCourseServlet.java

@@ -13,9 +13,18 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
-
+/**
+ * 处理学生选课删除请求的Servlet
+ */
 @WebServlet("/doDeleteSelectCourseServlet")
 public class DoDeleteSelectCourseServlet extends HttpServlet {
+    /**
+     * 处理POST请求，执行选课删除操作。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();

src/web/servlet/admin/UpdateStudentInfoServlet.java

@@ -46,12 +46,12 @@ 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 {
-            //封装学生对象
+            //封装学生对象-
             updateStudent.setS_id(sid);
             updateStudent.setS_name(name);
             updateStudent.setS_sex(sex);
@@ -63,7 +63,7 @@ public class UpdateStudentInfoServlet extends HttpServlet {
             updateStudent.setS_department(department);
             updateStudent.setS_class(cclass);
 
-            //调用studentUpdata服务
+            //调用studentUpdata服务-
             StudentService service= new StudentServiceImpl();
             service.updateInfo(updateStudent);
 

src/web/servlet/admin/UpdateStudentServlet.java

@@ -26,10 +26,12 @@ public class UpdateStudentServlet extends HttpServlet {
 
         Student student = new Student();
         student.setS_id(studentid);
+        // 创建学生服务的实现类实例，用于处理与学生相关的业务逻辑
         StudentService service = new StudentServiceImpl();
         Student newStudent = service.findStudentById(student);
         request.setAttribute("student",newStudent);
 
+        // 创建 CDCService 的实现类实例，用于处理与院系、系别和班级相关的业务逻辑
         CDCService service2 = new CDCServiceImpl();
         List<CDC> collegeList = service2.findAllCollege();
         List<CDC> departmentList = service2.findAllDepartment();

src/web/servlet/cdc/CDCListServlet.java

@@ -22,10 +22,10 @@ import java.util.List;
 public class CDCListServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
-        //调用StudentService完成查询
+        //调用StudentService完成查询-
         CDCService service = new CDCServiceImpl();
         List<CDC> cdcs = service.findAll();
-        //将list存入request域
+        //将list存入request域-
         request.setAttribute("cdcs",cdcs);
 
         HttpSession session = request.getSession();

src/web/servlet/complaints/AddComplaintsServlet.java

@@ -19,7 +19,7 @@ public class AddComplaintsServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
 
-        //获取参数
+        //获取参数-
         Complaint complaint = new Complaint();
 
         String text = (String) request.getParameter("complaint");

src/web/servlet/complaints/ComplaintListServlet.java

@@ -11,13 +11,16 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
-
+/**
+        * 投诉列表处理的Servlet
+ */
 @WebServlet("/complaintListServlet")
 public class ComplaintListServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         ComplaintService service = new ComplaintServiceImpl();
         List<Complaint> complaints = service.findAll();
+        // 将查询到的投诉信息存入请求属性，以便在后续的 JSP 页面中使用
         request.setAttribute("complaints",complaints);
         request.getRequestDispatcher("/WEB-INF/complaint/complaintsList.jsp").forward(request,response);
     }

src/web/servlet/complaints/ComplaintServlet.java

@@ -11,16 +11,26 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
-
+/**
+ * 投诉处理的Servlet
+ */
 @WebServlet("/complaintServlet")
 public class ComplaintServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求编码为UTF-8，以支持中文字符的正确处理
         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);
     }
+    /**
+     * 处理GET请求，调用POST请求处理方法。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws IOException      如果输入或输出异常发生。
+     */
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request,response);

src/web/servlet/file/DeleteFileServlet.java

@@ -7,9 +7,20 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.File;
 import java.io.IOException;
-
+/**
+ * 删除文件的Servlet
+ */
 @WebServlet("/deleteFileServlet")
 public class DeleteFileServlet extends HttpServlet {
+
+    /**
+     * 处理POST请求，执行文件删除操作。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         String fileName = request.getParameter("filename");

src/web/servlet/file/DownloadServlet.java

@@ -14,9 +14,19 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URLEncoder;
-
+/**
+ * 文件下载的Servlet
+ */
 @WebServlet("/downloadServlet")
 public class DownloadServlet extends HttpServlet {
+    /**
+     * 处理POST请求，执行文件下载操作。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         String filename = request.getParameter("filename");
         if (filename.equalsIgnoreCase("../") || filename.equalsIgnoreCase("/")) {

src/web/servlet/file/FileListServlet.java

@@ -25,7 +25,7 @@ public class FileListServlet extends HttpServlet {
         File dir = new File(this.getServletContext().getRealPath("upload"));
         if (!dir.exists() && !dir.isDirectory()) {
             System.out.println(this.getServletContext().getRealPath("upload") + "目录不存在，需要创建");
-            // 创建目录
+            // 创建目录-
             dir.mkdir();
         }
         File[] arrs = dir.listFiles();
@@ -62,14 +62,14 @@ public class FileListServlet extends HttpServlet {
     }
 
     public static String getPrintSize(long size) {
-        // 如果字节数少于1024，则直接以B为单位，否则先除于1024，后3位因太少无意义
+        // 如果字节数少于1024，则直接以B为单位，否则先除于1024，后3位因太少无意义-
         double value = (double) size;
         if (value < 1024) {
             return String.valueOf(value) + "B";
         } else {
             value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
         }
-        // 如果原字节数除于1024之后，少于1024，则可以直接以KB作为单位
+        // 如果原字节数除于1024之后，少于1024，则可以直接以KB作为单位-
         // 因为还没有到达要使用另一个单位的时候
         // 接下去以此类推
         if (value < 1024) {

src/web/servlet/file/FileServlet.java

@@ -6,13 +6,31 @@ import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
-
+/**
+ * 文件处理的Servlet，用于转发到文件上传页面
+ */
 @WebServlet("/fileServlet")
 public class FileServlet extends HttpServlet {
+    /**
+     * 处理POST请求，转发到文件上传页面。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.getRequestDispatcher("/WEB-INF/admin/uploadFile.jsp").forward(request,response);
     }
 
+    /**
+     * 处理GET请求，直接调用POST请求处理方法。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request,response);
     }

src/web/servlet/file/ShowPhotoServlet.java

@@ -58,13 +58,13 @@ public class ShowPhotoServlet extends HttpServlet {
         if (imagePath.toLowerCase().endsWith(".jpg"))// 使用编码处理文件流的情况：
         {
             response.setContentType(JPG);// 设定输出的类型
-            // 得到图片的真实路径
+            // 得到图片的真实路径-
 
-            // 得到图片的文件流
+            // 得到图片的文件流-
             InputStream imageIn = new FileInputStream(new File(imagePath));
-            // 得到输入的编码器，将文件流进行jpg格式编码
+            // 得到输入的编码器，将文件流进行jpg格式编码-
             JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(imageIn);
-            // 得到编码后的图片对象
+            // 得到编码后的图片对象-
             BufferedImage image = decoder.decodeAsBufferedImage();
             // 得到输出的编码器
             JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(output);

src/web/servlet/file/UploadImageServlet.java

@@ -41,29 +41,29 @@ public class UploadImageServlet extends HttpServlet {
         request.setAttribute("path", "");
         String filename = null;
         String newFileName = null;
-        // 设置上传图片的保存路径
+        // 设置上传图片的保存路径-
         String savePath = this.getServletContext().getRealPath("/photos");
         File file = new File(savePath);
-        // 判断上传文件的保存目录是否存在
+        // 判断上传文件的保存目录是否存在-
         if (!file.exists() && !file.isDirectory()) {
             System.out.println(savePath + "目录不存在，需要创建");
             // 创建目录
             file.mkdir();
         }
         DiskFileItemFactory factory = new DiskFileItemFactory();
-        // 2、创建一个文件上传解析器
+        // 2、创建一个文件上传解析器-
         ServletFileUpload upload = new ServletFileUpload(factory);
         upload.setHeaderEncoding("UTF-8");
-        // 3、判断提交上来的数据是否是上传表单的数据
+        // 3、判断提交上来的数据是否是上传表单的数据-
         if (!ServletFileUpload.isMultipartContent(request)) {
-            // 按照传统方式获取数据
+            // 按照传统方式获取数据-
             return;
         }
         try {
             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("."));

src/web/servlet/file/UploadServlet.java

@@ -15,9 +15,20 @@ import org.apache.commons.fileupload.FileUploadException;
 import org.apache.commons.fileupload.ProgressListener;
 import org.apache.commons.fileupload.disk.DiskFileItemFactory;
 import org.apache.commons.fileupload.servlet.ServletFileUpload;
-
+/**
+ * 文件上传的Servlet
+ */
 @WebServlet("/uploadServlet")
 public class UploadServlet extends HttpServlet {
+
+    /**
+     * 处理POST请求，用于执行文件上传操作。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         response.setCharacterEncoding("utf-8");
@@ -93,6 +104,9 @@ public class UploadServlet extends HttpServlet {
         }
     }
 
+    /**
+     * 表示文件上传或下载过程中的信息类
+     */
     class ProcessInfo{
         public long totalSize = 1;
         public long readSize = 0;

src/web/servlet/index/AdminIndexServlet.java

@@ -6,9 +6,19 @@ import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
-
+/**
+ * 管理员首页的Servlet，用于处理对管理员主页的请求
+ */
 @WebServlet("/adminIndexServlet")
 public class AdminIndexServlet extends HttpServlet {
+    /**
+     * 处理POST请求，转发到管理员首页的JSP页面。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.getRequestDispatcher("/WEB-INF/admin/aIndex.jsp").forward(request,response);
     }

src/web/servlet/index/StudentIndexServlet.java

@@ -6,9 +6,19 @@ import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
-
+/**
+ * 学生首页的Servlet，用于处理学生主页的请求
+ */
 @WebServlet("/studentIndexServlet")
 public class StudentIndexServlet extends HttpServlet {
+    /**
+     * 处理POST请求，转发到学生首页的JSP页面。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request,response);
     }

src/web/servlet/index/TeacherIndexServlet.java

@@ -7,8 +7,19 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+/**
+ * 教师首页的Servlet，用于处理教师主页的请求
+ */
 @WebServlet("/teacherIndexServlet")
 public class TeacherIndexServlet extends HttpServlet {
+    /**
+     * 处理POST请求，转发到教师首页的JSP页面。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.getRequestDispatcher("/WEB-INF/teacher/tIndex.jsp").forward(request,response);
     }

src/web/servlet/login/FindStudentServlet.java

@@ -13,9 +13,19 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
-
+/**
+ * 查找学生信息的Servlet
+ */
 @WebServlet("/findStudentServlet")
 public class FindStudentServlet extends HttpServlet {
+    /**
+     * 处理POST请求，根据学生ID查找学生信息。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         response.setContentType("application/json;charset=utf-8");
         String studentId = request.getParameter("studentid");
@@ -34,7 +44,7 @@ public class FindStudentServlet extends HttpServlet {
                 map.put("studentExsit", false);
                 map.put("msg", "用户名可用");
             }
-            //map转为json传给客户端
+            //map转为json传给客户端-
             ObjectMapper mapper = new ObjectMapper();
             mapper.writeValue(response.getWriter(),map);
         } catch (Exception e) {

src/web/servlet/login/LoginServlet.java

@@ -32,38 +32,38 @@ public class LoginServlet extends HttpServlet {
         Teacher loginTeacher = null;
         Admin loginAdmin = null;
 
-        //设置编码
+        //设置编码-
         request.setCharacterEncoding("utf-8");
 
-        //获取数据
+        //获取数据-
         String verifycode = request.getParameter("verifycode");
         String loginid = request.getParameter("id");
         String loginpassword = request.getParameter("password");
 
-        //验证码校验
+        //验证码校验-
         HttpSession session = request.getSession();
         String checkcode_server = (String) session.getAttribute("CHECKCODE_SERVER");
         session.removeAttribute("CHECKCODE_SERVER");//确保验证一次性
         if (checkcode_server == null || !checkcode_server.equalsIgnoreCase(verifycode)) {
-            //验证码不正确
+            //验证码不正确-
             request.setAttribute("login_msg","验证码错误");
-            //跳转页面
+            //跳转页面-
             request.setAttribute("loginid",loginid);
             request.setAttribute("loginpassword",loginpassword);
             request.getRequestDispatcher("/login.jsp").forward(request,response);
             return;
         }
-        //封装对象
+        //封装对象-
         String id = request.getParameter("id");
         String password = request.getParameter("password");
         String roles = request.getParameter("roles");
 
-        //公告加载
+        //公告加载-
         NotifyService notifyService= new NotifyServiceImpl();
         List<Notify> notifys = notifyService.find();
         session.setAttribute("notifys",notifys);
 
-        //判断roles封装对象、保存session、调用不同Service查询
+        //判断roles封装对象、保存session、调用不同Service查询-
         if ("student".equals(roles)) {
 
             Student student = new Student();
@@ -79,7 +79,7 @@ public class LoginServlet extends HttpServlet {
 //                request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request,response);
                 response.sendRedirect("studentIndexServlet");
             }else {
-                //登录失败 提示信息
+                //登录失败 提示信息-
                 request.setAttribute("login_msg", "用户名或密码错误！");
                 request.setAttribute("loginid",loginid);
                 request.setAttribute("loginpassword",loginpassword);
@@ -100,7 +100,7 @@ public class LoginServlet extends HttpServlet {
 //                request.getRequestDispatcher("/WEB-INF/teacher/tIndex.jsp").forward(request, response);
                 response.sendRedirect("teacherIndexServlet");
             }else {
-                //登录失败 提示信息
+                //登录失败 提示信息-
                 request.setAttribute("login_msg", "用户名或密码错误！");
                 request.getRequestDispatcher("/login.jsp").forward(request, response);
             }
@@ -120,7 +120,7 @@ public class LoginServlet extends HttpServlet {
 //                request.getRequestDispatcher("/WEB-INF/admin/aIndex.jsp").forward(request,response);
                 response.sendRedirect("adminIndexServlet");
             }else {
-                //登录失败 提示信息
+                //登录失败 提示信息-
                 request.setAttribute("login_msg", "用户名或密码错误！");
                 request.getRequestDispatcher("/login.jsp").forward(request, response);
             }

src/web/servlet/login/LogoutServlet.java

@@ -7,9 +7,19 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
-
+/**
+ * 处理用户注销的Servlet
+ */
 @WebServlet("/logoutServlet")
 public class LogoutServlet extends HttpServlet {
+    /**
+     * 处理POST请求，实现用户注销功能。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("UTF-8");
         HttpSession session = request.getSession();

src/web/servlet/login/RegisterServlet.java

@@ -8,10 +8,21 @@ import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.*;
 import java.io.IOException;
-
+/**
+ * 用户注册的Servlet
+ */
 @WebServlet("/registerServlet")
 public class RegisterServlet extends HttpServlet {
+    /**
+     * 处理POST请求，实现用户注册功能。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 获取当前用户的会话
         HttpSession session = request.getSession();
         String studentid = request.getParameter("studentid");
         String password = request.getParameter("password");

src/web/servlet/notify/AddNotifyServlet.java

@@ -22,7 +22,7 @@ public class AddNotifyServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
 
-        //获取参数
+        //获取参数-
         Notify notify = new Notify();
         notify.setNotifyInfo((String) request.getParameter("notifyInfo"));
         Date d = new Date();

src/web/servlet/notify/DeleteNotifyServlet.java

@@ -11,10 +11,21 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
-
+/**
+ * 删除通知的Servlet
+ */
 @WebServlet("/deleteNotifyServlet")
 public class DeleteNotifyServlet extends HttpServlet {
+    /**
+     * 处理POST请求，删除指定ID的通知。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为UTF-8，以支持中文字符的正确处理
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
         String notifyid = request.getParameter("id");

src/web/servlet/notify/NotifyListServlet.java

@@ -11,11 +11,23 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
-
+/**
+ * 显示通知列表的Servlet
+ */
 @WebServlet("/notifyListServlet")
 public class NotifyListServlet extends HttpServlet {
+    /**
+     * 处理POST请求，获取所有通知并转发到通知列表页面。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为UTF-8，以支持中文字符的正确处理
         request.setCharacterEncoding("utf-8");
+        // 创建通知服务的实例，以便获取通知数据
         NotifyService service = new NotifyServiceImpl();
         List<Notify> notifys = service.findAll();
         request.setAttribute("notifys",notifys);

src/web/servlet/notify/NotifyListToServlet.java

@@ -15,11 +15,23 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
-
+/**
+ * 转发到通知列表的Servlet
+ */
 @WebServlet("/notifyListToServlet")
 public class NotifyListToServlet extends HttpServlet {
+    /**
+     * 处理POST请求，获取所有通知并转发到通知列表页面。
+     *
+     * @param request  HTTP请求对象，包含客户端发送的数据。
+     * @param response HTTP响应对象，用于生成返回给客户端的响应。
+     * @throws ServletException 如果处理请求时发生错误。
+     * @throws IOException      如果输入或输出异常发生。
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为UTF-8，以支持中文字符的正确处理
         request.setCharacterEncoding("utf-8");
+        // 创建通知服务的实例，以便获取通知数据
         NotifyService service = new NotifyServiceImpl();
         List<Notify> notifys = service.findAll();
         request.setAttribute("notifys",notifys);

src/web/servlet/notify/NotifyServlet.java

@@ -9,11 +9,16 @@ import java.io.IOException;
 
 @WebServlet("/notifyServlet")
 public class NotifyServlet extends HttpServlet {
+
+    // 处理POST请求的方法
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.getRequestDispatcher("/WEB-INF/notify/addNotify.jsp").forward(request,response);
+        // 将请求转发到指定的JSP页面
+        request.getRequestDispatcher("/WEB-INF/notify/addNotify.jsp").forward(request, response);
     }
 
+    // 处理GET请求的方法
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 将GET请求转发到doPost方法进行处理
+        doPost(request, response);
     }
 }

src/web/servlet/page/FindStudentByPageServlet.java

@@ -18,7 +18,9 @@ import java.util.Map;
 
 @WebServlet("/findStudentByPageServlet")
 public class FindStudentByPageServlet extends HttpServlet {
+    // 处理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");//每页显示条数
@@ -30,14 +32,14 @@ public class FindStudentByPageServlet extends HttpServlet {
             rows = "5";
         }
 
-        //获取条件查询参数
+        //获取条件查询参数-
         Map<String,String[]> condition = request.getParameterMap();
 
         StudentService service = new StudentServiceImpl();
         PageBean<Student> pb =  service.findStudentByPage(currentPage,rows,condition);
 
         request.setAttribute("pb",pb);
-        request.setAttribute("condition",condition);//存入查询条件
+        request.setAttribute("condition",condition);//存入查询条件-
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
         Student student= (Student)session.getAttribute("student");

src/web/servlet/student/DeleteSelectStudentServlet.java

@@ -11,15 +11,26 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
 @WebServlet("/deleteSelectStudentServlet")
+// 删除选定学生的Servlet
 public class DeleteSelectStudentServlet extends HttpServlet {
+
+    // 处理POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 获取选定学生的ID数组
         String[] sids = request.getParameterValues("sid");
+
+        // 创建学生服务的实例
         StudentService service = new StudentServiceImpl();
+
+        // 调用服务方法删除选定的学生
         service.deleteSelectStudent(sids);
-        response.sendRedirect(request.getContextPath()+"/findStudentByPageServlet");
+
+        // 重定向到查找学生的页面
+        response.sendRedirect(request.getContextPath() + "/findStudentByPageServlet");
     }
 
+    // 处理GET请求，直接调用doPost方法
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
 }

src/web/servlet/student/DeleteStudentServlet.java

@@ -14,18 +14,34 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 
 @WebServlet("/deleteStudentServlet")
+// 删除学生的Servlet
 public class DeleteStudentServlet extends HttpServlet {
+
+    // 处理POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为UTF-8
         request.setCharacterEncoding("utf-8");
+
+        // 获取当前会话
         HttpSession session = request.getSession();
+
+        // 获取要删除的学生ID
         String studentid = request.getParameter("s_id");
+
+        // 创建学生服务的实例
         StudentService service = new StudentServiceImpl();
+
+        // 调用服务方法通过学生ID删除学生
         service.deleteStudentById(studentid);
-//        request.getRequestDispatcher("/findStudentByPageServlet").forward(request,response);
+
+        // 重定向到查找学生的页面
         response.sendRedirect("findStudentByPageServlet");
+        // 如果需要使用转发，可以使用下面的代码
+        // request.getRequestDispatcher("/findStudentByPageServlet").forward(request, response);
     }
 
+    // 处理GET请求，直接调用doPost方法
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
 }

src/web/servlet/student/DoSelectCourseServlet.java

@@ -24,6 +24,16 @@ public class DoSelectCourseServlet extends HttpServlet {
         Student student= (Student)session.getAttribute("student");
         String courseid = request.getParameter("id");
         //存不存在已选该课
+        //1
+        //2
+        //3
+        //4
+        //5
+        //6
+        //7
+        //8
+        //9
+        //0
         boolean flag = false;
 
         //判断是否已选

src/web/servlet/student/StudentInfomationServlet.java

@@ -27,3 +27,17 @@ public class StudentInfomationServlet extends HttpServlet {
         doPost(request,response);
     }
 }
+//public class StudentInfomationServlet extends HttpServlet {
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+////        HttpSession session = request.getSession();
+////        Student s = (Student) session.getAttribute("student");
+////        StudentService service = new StudentServiceImpl();
+////        Student newStudent = service.findStudentById(s);
+////        session.setAttribute("student",newStudent);
+//        request.getRequestDispatcher("/WEB-INF/student/sInformation.jsp").forward(request,response);
+//    }
+//
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        doPost(request,response);
+//    }
+//}

src/web/servlet/student/StudentInfomationUpdateServlet.java

@@ -20,7 +20,7 @@ public class StudentInfomationUpdateServlet extends HttpServlet {
 
         request.setCharacterEncoding("utf-8");
 
-        //保存输入内容
+        //保存输入内容-
         String sid = request.getParameter("student-id");
         String name = request.getParameter("student-name");
         String sex = request.getParameter("student-sex");
@@ -31,18 +31,28 @@ public class StudentInfomationUpdateServlet extends HttpServlet {
         String college = request.getParameter("selectCollege");
         String department = request.getParameter("selectDepartment");
         String cclass = request.getParameter("selectClass");
+        //String sid = request.getParameter("student-id");
+        //        String name = request.getParameter("student-name");
+        //        String sex = request.getParameter("student-sex");
+        //        String age = request.getParameter("student-age");
+        //        String phone = request.getParameter("student-phone");
+        //        String email = request.getParameter("student-email");
+        //        String address = request.getParameter("student-address");
+        //        String college = request.getParameter("selectCollege");
+        //        String department = request.getParameter("selectDepartment");
+        //        String cclass = request.getParameter("selectClass");
 
         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("/WEB-INF/student/sInformation.jsp").forward(request, response);
 //            response.sendRedirect("studentInfomationServlet");
         }else {
-            //封装学生对象
+            //封装学生对象-
             updateStudent.setS_id(sid);
             updateStudent.setS_name(name);
             updateStudent.setS_sex(sex);
@@ -53,8 +63,18 @@ public class StudentInfomationUpdateServlet extends HttpServlet {
             updateStudent.setS_college(college);
             updateStudent.setS_department(department);
             updateStudent.setS_class(cclass);
+            //updateStudent.setS_id(sid);
+            //            updateStudent.setS_name(name);
+            //            updateStudent.setS_sex(sex);
+            //            updateStudent.setS_age(age);
+            //            updateStudent.setS_phone(phone);
+            //            updateStudent.setS_email(email);
+            //            updateStudent.setS_address(address);
+            //            updateStudent.setS_college(college);
+            //            updateStudent.setS_department(department);
+            //            updateStudent.setS_class(cclass);
 
-            //调用studentUpdata服务
+            //调用studentUpdata服务-
             StudentService service= new StudentServiceImpl();
             service.updateInfo(updateStudent);
 
@@ -63,7 +83,7 @@ public class StudentInfomationUpdateServlet extends HttpServlet {
             Student s = service.findStudentById(updateStudent);
             session.setAttribute("student",s);
 
-            //成功则返回并给提示
+            //成功则返回并给提示-
             request.setAttribute("update_msg", "修改成功！"+String.format("%tT",new Date()));
             request.setAttribute("student",updateStudent);
             request.getRequestDispatcher("/WEB-INF/student/sInformation.jsp").forward(request, response);

src/web/servlet/student/StudentListServlet.java

@@ -18,10 +18,10 @@ import java.util.List;
 @WebServlet("/studentListServlet")
 public class StudentListServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        //调用StudentService完成查询
+        //调用StudentService完成查询-
         StudentService studentService = new StudentServiceImpl();
         List<Student> students = studentService.findAll();
-        //将list存入request域
+        //将list存入request域-
         request.setAttribute("students",students);
 
         request.setCharacterEncoding("utf-8");
@@ -40,6 +40,19 @@ public class StudentListServlet extends HttpServlet {
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
     }
+    //   HttpSession session = request.getSession();
+    //        Student student= (Student)session.getAttribute("student");
+    //        Admin admin= (Admin)session.getAttribute("admin");
+    //        Teacher teacher= (Teacher)session.getAttribute("teacher");
+    //        if (student != null && admin == null && teacher == null) {
+    //            request.getRequestDispatcher("/WEB-INF/student/studentList.jsp").forward(request, response);
+    //        } 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) {
+    //            request.getRequestDispatcher("/WEB-INF/teacher/tFindStudentList.jsp").forward(request, response);
+    //        } else {
+    //            request.getRequestDispatcher("error.jsp").forward(request, response);
+    //        }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         this.doPost(request,response);

src/web/servlet/student/StudentOptionalCourseServlet.java

@@ -24,12 +24,12 @@ public class StudentOptionalCourseServlet extends HttpServlet {
         Student student= (Student)session.getAttribute("student");
         Admin admin =(Admin)session.getAttribute("admin");
 
-        //调用StudentService完成查询
+        //调用StudentService完成查询-
         StudentService studentService = new StudentServiceImpl();
         List<Course> optionalcourses = studentService.findAllOptionalCourse();
-        //将list存入request域
+        //将list存入request域-
         request.setAttribute("optionalcourses",optionalcourses);
-        //转发到list.jsp
+        //转发到list.jsp-
 
         if (student != null && admin == null) {
             request.getRequestDispatcher("/WEB-INF/student/studentOptionalCourse.jsp").forward(request,response);
@@ -38,6 +38,13 @@ public class StudentOptionalCourseServlet extends HttpServlet {
         } else {
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
+        //if (student != null && admin == null) {
+        //            request.getRequestDispatcher("/WEB-INF/student/studentOptionalCourse.jsp").forward(request,response);
+        //        } else if (admin != null && student == null) {
+        //            request.getRequestDispatcher("/WEB-INF/admin/allStudentOptionalCourse.jsp").forward(request, response);
+        //        } else {
+        //            request.getRequestDispatcher("error.jsp").forward(request, response);
+        //        }
 
     }
 

src/web/servlet/student/StudentPasswordIndexServlet.java

@@ -8,12 +8,26 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
 @WebServlet("/studentPasswordIndexServlet")
+// 学生密码修改索引Servlet
 public class StudentPasswordIndexServlet extends HttpServlet {
+
+    // 处理POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request,response);
+        // 转发请求到学生密码修改页面
+        request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request, response);
     }
 
+    // 处理GET请求，直接调用doPost方法
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
 }
+//public class StudentPasswordIndexServlet extends HttpServlet {
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request,response);
+//    }
+//
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        doPost(request,response);
+//    }
+//}

src/web/servlet/student/StudentPasswordUpdateServlet.java

@@ -14,8 +14,11 @@ import java.io.IOException;
 import java.util.Date;
 
 @WebServlet("/studentPasswordUpdateServlet")
+// 学生密码更新Servlet
 public class StudentPasswordUpdateServlet extends HttpServlet {
+    // 处理POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为UTF-8，以支持中文
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
         Student student= (Student)session.getAttribute("student");
@@ -45,6 +48,35 @@ public class StudentPasswordUpdateServlet extends HttpServlet {
         }
 
     }
+    //  request.setCharacterEncoding("utf-8");
+    //        HttpSession session = request.getSession();
+    //        Student student= (Student)session.getAttribute("student");
+    //
+    //        String studentid = student.getS_id();
+    //        String newpassword = request.getParameter("student-newpassword");
+    //        String ennewpassword = request.getParameter("student-ennewpassword");
+    //        String regex = "^[\\w]{3,12}$";
+    //        boolean flag = newpassword.matches(regex);
+    //        if (!flag) {
+    //            request.setAttribute("update_msg", "密码格式错误，重新提交！"+String.format("%tT",new Date()));
+    //            request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request, response);
+    //        } else if (!newpassword.equals(ennewpassword)) {
+    //            request.setAttribute("update_msg", "密码确认错误，请重新提交！" + String.format("%tT", new Date()));
+    //            request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request, response);
+    //        } else {
+    //
+    //            StudentService service= new StudentServiceImpl();
+    //            service.updatePassword(studentid,newpassword);
+    //
+    //            Student newStudent = service.findStudentById(student);
+    //            student = newStudent;
+    //            session.setAttribute("student",student);
+    //
+    //            request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
+    //            request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request, response);
+    //        }
+    //
+    //    }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request,response);

src/web/servlet/student/StudentSelectCourseListServlet.java

@@ -25,13 +25,13 @@ public class StudentSelectCourseListServlet extends HttpServlet {
         Student student= (Student)session.getAttribute("student");
         Admin admin =(Admin)session.getAttribute("admin");
 
-        //调用StudentService完成查询
+        //调用StudentService完成查询-
         StudentService studentService = new StudentServiceImpl();
         if (student != null && admin == null) {
             List<SelectCourse> selectcourses = studentService.findAllSelectCourse(student.getS_id());
-            //将list存入request域
+            //将list存入request域-
             request.setAttribute("selectcourses",selectcourses);
-            //转发到list.jsp
+            //转发到list.jsp-
             request.getRequestDispatcher("/WEB-INF/student/studentSelectCourseList.jsp").forward(request,response);
         } else if (admin != null && student == null) {
             List<SelectCourse> selectcourses = studentService.findSelectCourseAllStudent();
@@ -48,3 +48,34 @@ public class StudentSelectCourseListServlet extends HttpServlet {
         this.doPost(request,response);
     }
 }
+//public class StudentSelectCourseListServlet extends HttpServlet {
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//
+//        request.setCharacterEncoding("utf-8");
+//        HttpSession session = request.getSession();
+//        Student student= (Student)session.getAttribute("student");
+//        Admin admin =(Admin)session.getAttribute("admin");
+//
+//        //调用StudentService完成查询-
+//        StudentService studentService = new StudentServiceImpl();
+//        if (student != null && admin == null) {
+//            List<SelectCourse> selectcourses = studentService.findAllSelectCourse(student.getS_id());
+//            //将list存入request域-
+//            request.setAttribute("selectcourses",selectcourses);
+//            //转发到list.jsp-
+//            request.getRequestDispatcher("/WEB-INF/student/studentSelectCourseList.jsp").forward(request,response);
+//        } else if (admin != null && student == null) {
+//            List<SelectCourse> selectcourses = studentService.findSelectCourseAllStudent();
+//            request.setAttribute("selectcourses", selectcourses);
+//            request.getRequestDispatcher("/WEB-INF/admin/allStudentSelectCourseList.jsp").forward(request, response);
+//        } else {
+//            request.getRequestDispatcher("error.jsp").forward(request, response);
+//        }
+//
+//
+//    }
+//
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        this.doPost(request,response);
+//    }
+//}

src/web/servlet/student/StudentServlet.java

@@ -8,12 +8,30 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
 @WebServlet("/studentServlet")
+// 学生相关操作的Servlet
 public class StudentServlet extends HttpServlet {
+
+    // 处理POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request,response);
+        // 转发请求到学生首页
+        request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request, response);
     }
 
+    // 处理GET请求，直接调用doPost方法
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        doPost(request, response);
     }
 }
+//public class StudentServlet extends HttpServlet {
+//
+//    // 处理POST请求
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        // 转发请求到学生首页
+//        request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request, response);
+//    }
+//
+//    // 处理GET请求，直接调用doPost方法
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        doPost(request, response);
+//    }
+//}

src/web/servlet/teacher/AddOptionalCourseServlet.java

@@ -15,11 +15,16 @@ import java.io.IOException;
 import java.util.Date;
 
 @WebServlet("/addOptionalCourseServlet")
+// 添加选修课程的Servlet
 public class AddOptionalCourseServlet extends HttpServlet {
+    // 处理POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为UTF-8，以支持中文
         request.setCharacterEncoding("utf-8");
+        // 获取当前会话
 
         HttpSession session = request.getSession();
+
         Teacher teacher = (Teacher) session.getAttribute("teacher");
 
         String cid = request.getParameter("cid");
@@ -49,3 +54,41 @@ public class AddOptionalCourseServlet extends HttpServlet {
         doPost(request,response);
     }
 }
+//public class AddOptionalCourseServlet extends HttpServlet {
+//    // 处理POST请求
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        // 设置请求的字符编码为UTF-8，以支持中文
+//        request.setCharacterEncoding("utf-8");
+//        // 获取当前会话
+//
+//        HttpSession session = request.getSession();
+//
+//        Teacher teacher = (Teacher) session.getAttribute("teacher");
+//
+//        String cid = request.getParameter("cid");
+//        String cname = request.getParameter("course-name");
+//        String cinfo = request.getParameter("course-info");
+//
+//        CourseService service = new CourseServiceImpl();
+//        Course course =  service.findSelectCourseByCourseId(cid);
+//        if (course != null) {
+//            request.setAttribute("update_msg","课程ID冲突，请重新添加！"+String.format("%tT",new Date()));
+//            request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request,response);
+//        }else {
+//            Course newCourse = new Course();
+//            newCourse.setC_id(cid);
+//            newCourse.setC_name(cname);
+//            newCourse.setC_info(cinfo);
+//            newCourse.setT_id(teacher.getT_id());
+//            newCourse.setT_name(teacher.getT_name());
+//
+//            service.addOptionalCourse(newCourse);
+//            request.setAttribute("update_msg","课程添加成功！"+String.format("%tT",new Date()));
+//            request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request,response);
+//        }
+//    }
+//
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        doPost(request,response);
+//    }
+//}

src/web/servlet/teacher/AddSelectCourseServlet.java

@@ -9,12 +9,38 @@ import java.io.IOException;
 
 @WebServlet("/addSelectCourseServlet")
 public class AddSelectCourseServlet extends HttpServlet {
+
+    // 处理POST请求的方法
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求字符编码为UTF-8，以支持中文字符
         request.setCharacterEncoding("utf-8");
-        request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request,response);
+
+        // 将请求转发到指定的JSP页面
+        // "/WEB-INF/teacher/addOptionalCourse.jsp" 是要转发到的JSP页面路径
+        request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request, response);
     }
 
+    // 处理GET请求的方法
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 对于GET请求，调用doPost方法进行处理
+        doPost(request, response);
     }
 }
+//public class AddSelectCourseServlet extends HttpServlet {
+//
+//    // 处理POST请求的方法
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        // 设置请求字符编码为UTF-8，以支持中文字符
+//        request.setCharacterEncoding("utf-8");
+//
+//        // 将请求转发到指定的JSP页面
+//        // "/WEB-INF/teacher/addOptionalCourse.jsp" 是要转发到的JSP页面路径
+//        request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request, response);
+//    }
+//
+//    // 处理GET请求的方法
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        // 对于GET请求，调用doPost方法进行处理
+//        doPost(request, response);
+//    }
+//}

src/web/servlet/teacher/AddTeacherInfoServlet.java

@@ -17,7 +17,7 @@ public class AddTeacherInfoServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         TeacherService service= new TeacherServiceImpl();
-        //先进行判断是否已存在该教师
+        //先进行判断是否已存在该教师-
         String tid = request.getParameter("teacher-id");
         Teacher t = new Teacher();
         t.setT_id(tid);
@@ -31,18 +31,18 @@ public class AddTeacherInfoServlet extends HttpServlet {
             String education = request.getParameter("teacher-education");
             String title = request.getParameter("teacher-title");
 
-//            String college = request.getParameter("selectCollege");
-//            String department = request.getParameter("selectDepartment");
-//            String cclass = request.getParameter("selectClass");
-//            if ("".equals(college)) {
-//                college = "待分配";
-//            }
-//            if ("".equals(department)) {
-//                department = "待分配";
-//            }
-//            if ("".equals(cclass)) {
-//                cclass = "待分配";
-//            }
+//            String college = request.getParameter("selectCollege");-
+//            String department = request.getParameter("selectDepartment");-
+//            String cclass = request.getParameter("selectClass");-
+//            if ("".equals(college)) {-
+//                college = "待分配";-
+//            }-
+//            if ("".equals(department)) {-
+//                department = "待分配";-
+//            }-
+//            if ("".equals(cclass)) {-
+//                cclass = "待分配";-
+//            }-
 
             Teacher updateTeacher = new Teacher();
 
@@ -51,9 +51,9 @@ public class AddTeacherInfoServlet extends HttpServlet {
             updateTeacher.setT_sex(sex);
             updateTeacher.setT_education(education);
             updateTeacher.setT_title(title);
-//            updateTeacher.setT_college(college);
-//            updateTeacher.setT_department(department);
-//            updateTeacher.setT_class(cclass);
+//            updateTeacher.setT_college(college);-
+//            updateTeacher.setT_department(department);-
+//            updateTeacher.setT_class(cclass);-
 
             service.addTeacherAllInfo(updateTeacher);
             request.setAttribute("update_msg", "添加成功！" + String.format("%tT", new Date()));
@@ -65,3 +65,55 @@ public class AddTeacherInfoServlet extends HttpServlet {
         doPost(request,response);
     }
 }
+//public class AddTeacherInfoServlet extends HttpServlet {
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        request.setCharacterEncoding("utf-8");
+//        TeacherService service= new TeacherServiceImpl();
+//        //先进行判断是否已存在该教师-
+//        String tid = request.getParameter("teacher-id");
+//        Teacher t = new Teacher();
+//        t.setT_id(tid);
+//        Teacher newTeacher = service.findTeacherById(t);
+//        if (newTeacher != null) {
+//            request.setAttribute("update_msg","已存在该教师，请重新添加！"+String.format("%tT",new Date()));
+//            request.getRequestDispatcher("addTeacherServlet").forward(request, response);
+//        }else {
+//            String name = request.getParameter("teacher-name");
+//            String sex = request.getParameter("teacher-sex");
+//            String education = request.getParameter("teacher-education");
+//            String title = request.getParameter("teacher-title");
+//
+////            String college = request.getParameter("selectCollege");-
+////            String department = request.getParameter("selectDepartment");-
+////            String cclass = request.getParameter("selectClass");-
+////            if ("".equals(college)) {-
+////                college = "待分配";-
+////            }-
+////            if ("".equals(department)) {-
+////                department = "待分配";-
+////            }-
+////            if ("".equals(cclass)) {-
+////                cclass = "待分配";-
+////            }-
+//
+//            Teacher updateTeacher = new Teacher();
+//
+//            updateTeacher.setT_id(tid);
+//            updateTeacher.setT_name(name);
+//            updateTeacher.setT_sex(sex);
+//            updateTeacher.setT_education(education);
+//            updateTeacher.setT_title(title);
+////            updateTeacher.setT_college(college);-
+////            updateTeacher.setT_department(department);-
+////            updateTeacher.setT_class(cclass);-
+//
+//            service.addTeacherAllInfo(updateTeacher);
+//            request.setAttribute("update_msg", "添加成功！" + String.format("%tT", new Date()));
+//            request.getRequestDispatcher("addTeacherServlet").forward(request, response);
+//        }
+//    }
+//
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        doPost(request,response);
+//    }
+//}

src/web/servlet/teacher/AddTeacherServlet.java

@@ -15,6 +15,7 @@ import java.util.List;
 
 @WebServlet("/addTeacherServlet")
 public class AddTeacherServlet extends HttpServlet {
+    //注册
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
@@ -35,3 +36,25 @@ public class AddTeacherServlet extends HttpServlet {
         doPost(request,response);
     }
 }
+//public class AddTeacherServlet extends HttpServlet {
+//    //注册
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        request.setCharacterEncoding("utf-8");
+//        HttpSession session = request.getSession();
+//
+//        CDCService service = new CDCServiceImpl();
+//        List<CDC> collegeList = service.findAllCollege();
+//        List<CDC> departmentList = service.findAllDepartment();
+//        List<CDC> classList = service.findAllClass();
+//
+//        session.setAttribute("collegeLists",collegeList);
+//        session.setAttribute("departmentLists",departmentList);
+//        session.setAttribute("classLists",classList);
+//
+//        request.getRequestDispatcher("/WEB-INF/admin/addTeacher.jsp").forward(request,response);
+//    }
+//
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        doPost(request,response);
+//    }
+//}

src/web/servlet/teacher/DeleteOptionalCourseServlet.java

@@ -13,15 +13,54 @@ import java.io.IOException;
 
 @WebServlet("/deleteOptionalCourseServlet")
 public class DeleteOptionalCourseServlet extends HttpServlet {
+
+    // 处理POST请求的方法
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求字符编码为UTF-8，以支持中文字符
         request.setCharacterEncoding("utf-8");
+
+        // 获取请求 "cid"，表示要删除的课程ID
         String cid = request.getParameter("cid");
+
+        // 创建教师服务的实现类实例
         TeacherService service = new TeacherServiceImpl();
+
+        // 调用服务层方法，根据课程ID删除课程
         service.deleteCourseById(cid);
-        request.getRequestDispatcher("/teacherOptionalCourseServlet").forward(request,response);
+
+        // 请求转发到教师可选课程的Servlet，以更新课程列表
+        request.getRequestDispatcher("/teacherOptionalCourseServlet").forward(request, response);
     }
 
+    // 处理GET请求的方法
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 对于GET请求，调用doPost方法进行处理
+        doPost(request, response);
     }
 }
+//public class DeleteOptionalCourseServlet extends HttpServlet {
+//
+//    // 处理POST请求的方法
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        // 设置请求字符编码为UTF-8，以支持中文字符
+//        request.setCharacterEncoding("utf-8");
+//
+//        // 获取请求 "cid"，表示要删除的课程ID
+//        String cid = request.getParameter("cid");
+//
+//        // 创建教师服务的实现类实例
+//        TeacherService service = new TeacherServiceImpl();
+//
+//        // 调用服务层方法，根据课程ID删除课程
+//        service.deleteCourseById(cid);
+//
+//        // 请求转发到教师可选课程的Servlet，以更新课程列表
+//        request.getRequestDispatcher("/teacherOptionalCourseServlet").forward(request, response);
+//    }
+//
+//    // 处理GET请求的方法
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        // 对于GET请求，调用doPost方法进行处理
+//        doPost(request, response);
+//    }
+//}

src/web/servlet/teacher/DeleteTeacherServlet.java

@@ -12,6 +12,7 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 
 @WebServlet("/deleteTeacherServlet")
+//教师服务页面
 public class DeleteTeacherServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
@@ -25,3 +26,16 @@ public class DeleteTeacherServlet extends HttpServlet {
         doPost(request,response);
     }
 }
+//public class DeleteTeacherServlet extends HttpServlet {
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        request.setCharacterEncoding("utf-8");
+//        String teacherid = request.getParameter("tid");
+//        TeacherService service = new TeacherServiceImpl();
+//        service.deleteTeacherById(teacherid);
+//        request.getRequestDispatcher("/teacherListServlet").forward(request,response);
+//    }
+//
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        doPost(request,response);
+//    }
+//}

src/web/servlet/teacher/FindStudentCourseScoreServlet.java

@@ -13,8 +13,10 @@ import java.io.IOException;
 import java.util.List;
 
 @WebServlet("/findStudentCourseScoreServlet")
+//不清楚什么作用
 public class FindStudentCourseScoreServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        //中文
         request.setCharacterEncoding("utf-8");
         String cid = request.getParameter("cid");
         System.out.println(cid);
@@ -34,3 +36,25 @@ public class FindStudentCourseScoreServlet extends HttpServlet {
         doPost(request,response);
     }
 }
+//public class FindStudentCourseScoreServlet extends HttpServlet {
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        //中文
+//        request.setCharacterEncoding("utf-8");
+//        String cid = request.getParameter("cid");
+//        System.out.println(cid);
+//
+//        SelectCourseService service = new SelectCourseServiceImpl();
+//        List<SelectCourse> scs =  service.findStudentSelectedCourseByCourseId(cid);
+//        for (int i = 0; i < scs.size(); i++) {
+//            System.out.println(scs.get(i));
+//        }
+//
+//        request.setAttribute("scs",scs);
+//        request.getRequestDispatcher("/WEB-INF/teacher/findSelectCourseListByCourseId.jsp").forward(request,response);
+//
+//    }
+//
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        doPost(request,response);
+//    }
+//}

src/web/servlet/teacher/TeacherInfomationServlet.java

@@ -11,6 +11,7 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 
 @WebServlet("/teacherInfomationServlet")
+//网络页面
 public class TeacherInfomationServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.getRequestDispatcher("/WEB-INF/teacher/tInformation.jsp").forward(request,response);
@@ -20,3 +21,12 @@ public class TeacherInfomationServlet extends HttpServlet {
         doPost(request,response);
     }
 }
+//public class TeacherInfomationServlet extends HttpServlet {
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        request.getRequestDispatcher("/WEB-INF/teacher/tInformation.jsp").forward(request,response);
+//    }
+//
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        doPost(request,response);
+//    }
+//}

src/web/servlet/teacher/TeacherListServlet.java

@@ -20,10 +20,10 @@ import java.util.List;
 @WebServlet("/teacherListServlet")
 public class TeacherListServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        //调用TeacherService完成查询
+        //调用TeacherService完成查询-
         TeacherService teacherService = new TeacherServiceImpl();
         List<Teacher> teachers = teacherService.findAll();
-        //将list存入request域
+        //将list存入request域-
         request.setAttribute("teachers",teachers);
 
         request.setCharacterEncoding("utf-8");
@@ -46,3 +46,31 @@ public class TeacherListServlet extends HttpServlet {
         this.doPost(request,response);
     }
 }
+//public class TeacherListServlet extends HttpServlet {
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        //调用TeacherService完成查询-
+//        TeacherService teacherService = new TeacherServiceImpl();
+//        List<Teacher> teachers = teacherService.findAll();
+//        //将list存入request域-
+//        request.setAttribute("teachers",teachers);
+//
+//        request.setCharacterEncoding("utf-8");
+//        HttpSession session = request.getSession();
+//        Student student= (Student)session.getAttribute("student");
+//        Admin admin= (Admin)session.getAttribute("admin");
+//        Teacher teacher= (Teacher)session.getAttribute("teacher");
+//        if (student != null && admin == null && teacher == null) {
+//            request.getRequestDispatcher("/WEB-INF/student/sFindTeacherList.jsp").forward(request, response);
+//        } else if (admin != null && student == null && teacher == null) {
+//            request.getRequestDispatcher("/WEB-INF/admin/aFindTeacherList.jsp").forward(request, response);
+//        } else if (teacher != null && admin == null && student == null) {
+//            request.getRequestDispatcher("/WEB-INF/teacher/tFindTeacherList.jsp").forward(request, response);
+//        } else {
+//            request.getRequestDispatcher("error.jsp").forward(request, response);
+//        }
+//    }
+//
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        this.doPost(request,response);
+//    }
+//}

src/web/servlet/teacher/TeacherOptionalCourseServlet.java

@@ -24,12 +24,12 @@ public class TeacherOptionalCourseServlet extends HttpServlet {
         HttpSession session = request.getSession();
         Teacher t = (Teacher) session.getAttribute("teacher");
         if (t != null) {
-            //调用StudentService完成查询
+            //调用StudentService完成查询-
             TeacherService service = new TeacherServiceImpl();
             List<Course> optionalcourses = service.findMySelfOptionalCourse(t.getT_id());
-            //将list存入request域
+            //将list存入request域-
             request.setAttribute("optionalcourses",optionalcourses);
-            //转发到list.jsp
+            //转发到list.jsp-
             request.getRequestDispatcher("/WEB-INF/teacher/teacherOptionalCourse.jsp").forward(request,response);
         }
     }
@@ -38,3 +38,23 @@ public class TeacherOptionalCourseServlet extends HttpServlet {
         this.doPost(request,response);
     }
 }
+//public class TeacherOptionalCourseServlet extends HttpServlet {
+//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        request.setCharacterEncoding("utf-8");
+//        HttpSession session = request.getSession();
+//        Teacher t = (Teacher) session.getAttribute("teacher");
+//        if (t != null) {
+//            //调用StudentService完成查询-
+//            TeacherService service = new TeacherServiceImpl();
+//            List<Course> optionalcourses = service.findMySelfOptionalCourse(t.getT_id());
+//            //将list存入request域-
+//            request.setAttribute("optionalcourses",optionalcourses);
+//            //转发到list.jsp-
+//            request.getRequestDispatcher("/WEB-INF/teacher/teacherOptionalCourse.jsp").forward(request,response);
+//        }
+//    }
+//
+//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+//        this.doPost(request,response);
+//    }
+//}