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/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,15 +10,7 @@ import java.sql.Statement;
 import java.util.Properties;
 
 /**
-<<<<<<< HEAD
-<<<<<<< HEAD
  * Druid连接池工具类,将来dao层调用
-=======
- * Druid连接池工具类,将来dao层调用--
->>>>>>> remotes/origin/develop
-=======
- * Druid连接池工具类,将来dao层调用--
->>>>>>> remotes/origin/develop
  */
 public class JDBCUtils {
     private static DataSource dataSource;   //定义成员变量DataSource

src/web/servlet/admin/AddStudentInfoServlet.java

@@ -15,218 +15,57 @@ import java.util.Date;
 @WebServlet("/addStudentInfoServlet")
 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对象
         Student s = new Student();
-        // 设置学生ID
         s.setS_id(sid);
-        // 根据学生ID查找学生
         Student newStudent = service.findStudentById(s);
-        // 如果找到了该学生
         if (newStudent != null) {
-            // 设置更新消息
             request.setAttribute("update_msg","已存在该学生，请重新添加！"+String.format("%tT",new Date()));
-            // 转发到addStudentServlet
             request.getRequestDispatcher("addStudentServlet").forward(request, response);
         }else {
-            // 获取学生姓名
             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");
-            // 获取学生所在班级
-            // 获取请求参数selectClass的值
             String cclass = request.getParameter("selectClass");
-            // 如果college参数为空，则将其赋值为"待分配"
             if ("".equals(college)) {
                 college = "待分配";
             }
-            // 如果department参数为空，则将其赋值为"待分配"
             if ("".equals(department)) {
                 department = "待分配";
             }
-            // 如果cclass参数为空，则将其赋值为"待分配"
-            // 如果cclass为空，则将其设置为"待分配"
             if ("".equals(cclass)) {
                 cclass = "待分配";
             }
 
-            // 创建一个Student对象
             Student updateStudent = new Student();
 
-            // 设置Student对象的属性
-            // 设置学生ID
             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);
 
-//protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-            //调用service层的方法，添加学生信息
             service.addStudentAllInfo(updateStudent);
-<<<<<<< HEAD
-<<<<<<< HEAD
             request.setAttribute("update_msg","添加成功！"+String.format("%tT",new Date()));
-=======
-            //将添加信息返回给客户端
-            request.setAttribute("update_msg","添加成功！"+String.format("%tT",new Date()));//返回添加信息
-            //将请求转发到addStudentServlet
->>>>>>> remotes/origin/develop
-=======
-            //将添加信息返回给客户端
-            request.setAttribute("update_msg","添加成功！"+String.format("%tT",new Date()));//返回添加信息
-            //将请求转发到addStudentServlet
->>>>>>> remotes/origin/develop
             request.getRequestDispatcher("addStudentServlet").forward(request, response);
 
         }
     }
 
-    //处理get请求
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        //调用doPost方法
         doPost(request,response);
     }
 }
-//package web.servlet.admin;
-//
-//import domain.Student;
-//import service.StudentService;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import java.io.IOException;
-//import java.util.Date;
-//
-//@WebServlet("/addStudentInfoServlet")
-//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对象
-//        Student s = new Student();
-//        // 设置学生ID
-//        s.setS_id(sid);
-//        // 根据学生ID查找学生
-//        Student newStudent = service.findStudentById(s);
-//        // 如果找到了该学生
-//        if (newStudent != null) {
-//            // 设置更新消息
-//            request.setAttribute("update_msg","已存在该学生，请重新添加！"+String.format("%tT",new Date()));
-//            // 转发到addStudentServlet
-//            request.getRequestDispatcher("addStudentServlet").forward(request, response);
-//        }else {
-//            // 获取学生姓名
-//            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");
-//            // 获取学生所在班级
-//            // 获取请求参数selectClass的值
-//            String cclass = request.getParameter("selectClass");
-//            // 如果college参数为空，则将其赋值为"待分配"
-//            if ("".equals(college)) {
-//                college = "待分配";
-//            }
-//            // 如果department参数为空，则将其赋值为"待分配"
-//            if ("".equals(department)) {
-//                department = "待分配";
-//            }
-//            // 如果cclass参数为空，则将其赋值为"待分配"
-//            // 如果cclass为空，则将其设置为"待分配"
-//            if ("".equals(cclass)) {
-//                cclass = "待分配";
-//            }
-//
-//            // 创建一个Student对象
-//            Student updateStudent = new Student();
-//
-//            // 设置Student对象的属性
-//            // 设置学生ID
-//            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);
-//
-////protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//            //调用service层的方法，添加学生信息
-//            service.addStudentAllInfo(updateStudent);
-//            //将添加信息返回给客户端
-//            request.setAttribute("update_msg","添加成功！"+String.format("%tT",new Date()));//返回添加信息
-//            //将请求转发到addStudentServlet
-//            request.getRequestDispatcher("addStudentServlet").forward(request, response);
-//
-//        }
-//    }
-//
-//    //处理get请求
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        //调用doPost方法
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/admin/AddStudentServlet.java

@@ -22,29 +22,15 @@ public class AddStudentServlet extends HttpServlet {
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
 
-<<<<<<< HEAD
-=======
-        // 创建CDCService的实例，通常用于处理与学院、系、班级相关的业务逻辑
-        // 创建CDCService的实现类
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
         CDCService service2 = new CDCServiceImpl();
-        // 调用findAllCollege方法，获取所有学院列表
         List<CDC> collegeList = service2.findAllCollege();
-        // 调用findAllDepartment方法，获取所有部门列表
         List<CDC> departmentList = service2.findAllDepartment();
-        // 调用findAllClass方法，获取所有班级列表
-        // 获取所有班级信息
         List<CDC> classList = service2.findAllClass();
 
-        // 将学院列表、系列表、班级列表存入session中
         session.setAttribute("collegeLists",collegeList);
         session.setAttribute("departmentLists",departmentList);
         session.setAttribute("classLists",classList);
 
-        // 转发到添加学生页面
         request.getRequestDispatcher("/WEB-INF/admin/addStudent.jsp").forward(request,response);
     }
 
@@ -52,55 +38,3 @@ public class AddStudentServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.admin;
-//
-//import domain.CDC;
-//import domain.Student;
-//import service.CDCService;
-//import service.StudentService;
-//import service.impl.CDCServiceImpl;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//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的实现类
-//        CDCService service2 = new CDCServiceImpl();
-//        // 调用findAllCollege方法，获取所有学院列表
-//        List<CDC> collegeList = service2.findAllCollege();
-//        // 调用findAllDepartment方法，获取所有部门列表
-//        List<CDC> departmentList = service2.findAllDepartment();
-//        // 调用findAllClass方法，获取所有班级列表
-//        // 获取所有班级信息
-//        List<CDC> classList = service2.findAllClass();
-//
-//        // 将学院列表、系列表、班级列表存入session中
-//        session.setAttribute("collegeLists",collegeList);
-//        session.setAttribute("departmentLists",departmentList);
-//        session.setAttribute("classLists",classList);
-//
-//        // 转发到添加学生页面
-//        request.getRequestDispatcher("/WEB-INF/admin/addStudent.jsp").forward(request,response);
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/admin/AdminPasswordIndexServlet.java

@@ -17,26 +17,3 @@ public class AdminPasswordIndexServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.admin;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import 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);
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/admin/AdminPasswordUpdateServlet.java

@@ -18,51 +18,32 @@ import java.util.Date;
 
 @WebServlet("/adminPasswordUpdateServlet")
 public class AdminPasswordUpdateServlet extends HttpServlet {
-    // 处理POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        // 设置请求编码为utf-8
         request.setCharacterEncoding("utf-8");
-        // 获取当前会话
         HttpSession session = request.getSession();
-        // 从会话中获取管理员对象
         Admin admin= (Admin) session.getAttribute("admin");
 
-        // 获取管理员ID
         String adminid = admin.getA_id();
-        // 获取新密码
         String newpassword = request.getParameter("admin-newpassword");
-        // 获取确认新密码
         String ennewpassword = request.getParameter("admin-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/admin/adminUpdatePassword.jsp").forward(request, response);
-        // 如果新密码和确认密码不一致，则设置错误信息，并跳转到更新密码页面
         } else if (!newpassword.equals(ennewpassword)) {
             request.setAttribute("update_msg", "密码确认错误，请重新提交！" + String.format("%tT", new Date()));
             request.getRequestDispatcher("/WEB-INF/admin/adminUpdatePassword.jsp").forward(request, response);
-        // 如果新密码和确认密码一致，则继续执行
         } else {
 
-            // 创建AdminService实例
             AdminService service= new AdminServiceImpl();
-            // 调用updatePassword方法，更新密码
             service.updatePassword(adminid,newpassword);
 
-            // 调用findAdminById方法，根据adminid查找管理员信息
             Admin newAdmin = service.findAdminById(admin);
-            // 将新的管理员信息赋值给admin
             admin = newAdmin;
-            // 将新的管理员信息存入session中
             session.setAttribute("admin",admin);
 
-            // 设置更新成功的信息
             request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
-            // 转发到adminUpdatePassword.jsp页面
             request.getRequestDispatcher("/WEB-INF/admin/adminUpdatePassword.jsp").forward(request, response);
         }
 
@@ -72,79 +53,3 @@ public class AdminPasswordUpdateServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.admin;
-//
-//import domain.Admin;
-//import domain.Student;
-//import service.AdminService;
-//import service.StudentService;
-//import service.impl.AdminServiceImpl;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//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 {
-//    // 处理POST请求
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        // 设置请求编码为utf-8
-//        request.setCharacterEncoding("utf-8");
-//        // 获取当前会话
-//        HttpSession session = request.getSession();
-//        // 从会话中获取管理员对象
-//        Admin admin= (Admin) session.getAttribute("admin");
-//
-//        // 获取管理员ID
-//        String adminid = admin.getA_id();
-//        // 获取新密码
-//        String newpassword = request.getParameter("admin-newpassword");
-//        // 获取确认新密码
-//        String ennewpassword = request.getParameter("admin-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/admin/adminUpdatePassword.jsp").forward(request, response);
-//        // 如果新密码和确认密码不一致，则设置错误信息，并跳转到更新密码页面
-//        } else if (!newpassword.equals(ennewpassword)) {
-//            request.setAttribute("update_msg", "密码确认错误，请重新提交！" + String.format("%tT", new Date()));
-//            request.getRequestDispatcher("/WEB-INF/admin/adminUpdatePassword.jsp").forward(request, response);
-//        // 如果新密码和确认密码一致，则继续执行
-//        } else {
-//
-//            // 创建AdminService实例
-//            AdminService service= new AdminServiceImpl();
-//            // 调用updatePassword方法，更新密码
-//            service.updatePassword(adminid,newpassword);
-//
-//            // 调用findAdminById方法，根据adminid查找管理员信息
-//            Admin newAdmin = service.findAdminById(admin);
-//            // 将新的管理员信息赋值给admin
-//            admin = newAdmin;
-//            // 将新的管理员信息存入session中
-//            session.setAttribute("admin",admin);
-//
-//            // 设置更新成功的信息
-//            request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
-//            // 转发到adminUpdatePassword.jsp页面
-//            request.getRequestDispatcher("/WEB-INF/admin/adminUpdatePassword.jsp").forward(request, response);
-//        }
-//
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/admin/DoDeleteSelectCourseServlet.java

@@ -16,32 +16,12 @@ import java.io.IOException;
 
 @WebServlet("/doDeleteSelectCourseServlet")
 public class DoDeleteSelectCourseServlet extends HttpServlet {
-<<<<<<< HEAD
-=======
-    /**
-     * 处理POST请求，执行选课删除操作。
-     *
-     * @param request  HTTP请求对象，包含客户端发送的数据。
-     * @param response HTTP响应对象，用于生成返回给客户端的响应。
-     * @throws IOException      如果输入或输出异常发生。
-     */
-    // 处理POST请求
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        // 设置请求编码为utf-8
         request.setCharacterEncoding("utf-8");
-        // 获取当前会话
         HttpSession session = request.getSession();
-        // 获取请求参数cid
         String cid = request.getParameter("cid");
-        // 创建CourseService实例
         CourseService service = new CourseServiceImpl();
-        // 根据cid删除课程
         service.deleteServiceById(cid);
-        // 转发到studentOptionalCourseServlet
         request.getRequestDispatcher("/studentOptionalCourseServlet").forward(request,response);
     }
 
@@ -49,50 +29,3 @@ public class DoDeleteSelectCourseServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.admin;
-//
-//import domain.Course;
-//import service.CourseService;
-//import service.StudentService;
-//import service.impl.CourseServiceImpl;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//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      如果输入或输出异常发生。
-//     */
-//    // 处理POST请求
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        // 设置请求编码为utf-8
-//        request.setCharacterEncoding("utf-8");
-//        // 获取当前会话
-//        HttpSession session = request.getSession();
-//        // 获取请求参数cid
-//        String cid = request.getParameter("cid");
-//        // 创建CourseService实例
-//        CourseService service = new CourseServiceImpl();
-//        // 根据cid删除课程
-//        service.deleteServiceById(cid);
-//        // 转发到studentOptionalCourseServlet
-//        request.getRequestDispatcher("/studentOptionalCourseServlet").forward(request,response);
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/admin/UpdateStudentInfoServlet.java

@@ -31,29 +31,19 @@ public class UpdateStudentInfoServlet extends HttpServlet {
 
 
         //保存输入内容
-        // 获取请求参数中的学生姓名
         String name = request.getParameter("student-name");
-        // 输出学生姓名
         System.out.println("sname:"+name);
-        // 获取请求参数中的学生性别
         String sex = request.getParameter("student-sex");
-        // 输出学生性别
         System.out.println("ssex:"+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();
 
         //判断输入位数是否大于数据库位数
@@ -61,33 +51,16 @@ public class UpdateStudentInfoServlet extends HttpServlet {
             request.setAttribute("update_msg","格式错误，请重新提交！"+String.format("%tT",new Date()));
             request.getRequestDispatcher("updateStudentServlet?sid="+sid).forward(request, response);
         }else {
-<<<<<<< HEAD
             //封装学生对象
-=======
-            //封装学生对象-
-            // 设置学生ID
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
             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服务
@@ -104,102 +77,3 @@ public class UpdateStudentInfoServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.admin;
-//
-//
-//
-//import domain.CDC;
-//import domain.Student;
-//import service.CDCService;
-//import service.StudentService;
-//import service.impl.CDCServiceImpl;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import java.io.IOException;
-//import java.text.SimpleDateFormat;
-//import java.util.Date;
-//import java.util.List;
-//
-//@WebServlet("/updateStudentInfoServlet")
-//public class UpdateStudentInfoServlet extends HttpServlet {
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//
-//        request.setCharacterEncoding("utf-8");
-////        HttpSession session = request.getSession();
-//        String sid = request.getParameter("student-id");
-//        System.out.println("sid:"+sid);
-//
-//
-//        //保存输入内容
-//        // 获取请求参数中的学生姓名
-//        String name = request.getParameter("student-name");
-//        // 输出学生姓名
-//        System.out.println("sname:"+name);
-//        // 获取请求参数中的学生性别
-//        String sex = request.getParameter("student-sex");
-//        // 输出学生性别
-//        System.out.println("ssex:"+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("updateStudentServlet?sid="+sid).forward(request, response);
-//        }else {
-//            //封装学生对象-
-//            // 设置学生ID
-//            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服务-
-//            StudentService service= new StudentServiceImpl();
-//            service.updateInfo(updateStudent);
-//
-//            //成功则返回并给提示
-//            request.setAttribute("update_msg", "修改成功！"+String.format("%tT",new Date()));
-//            request.getRequestDispatcher("updateStudentServlet?sid="+sid).forward(request, response);
-//        }
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/admin/UpdateStudentServlet.java

@@ -30,27 +30,13 @@ public class UpdateStudentServlet extends HttpServlet {
         Student newStudent = service.findStudentById(student);
         request.setAttribute("student",newStudent);
 
-<<<<<<< HEAD
-=======
-        // 创建 CDCService 的实现类实例，用于处理与院系、系别和班级相关的业务逻辑
-        // 创建CDCService实例
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
         CDCService service2 = new CDCServiceImpl();
-        // 调用findAllCollege方法获取所有学院列表
         List<CDC> collegeList = service2.findAllCollege();
-        // 调用findAllDepartment方法获取所有部门列表
         List<CDC> departmentList = service2.findAllDepartment();
-        // 调用findAllClass方法获取所有班级列表
         List<CDC> classList = service2.findAllClass();
 
-        // 将学院列表存入session中
         session.setAttribute("collegeLists",collegeList);
-        // 将部门列表存入session中
         session.setAttribute("departmentLists",departmentList);
-        // 将班级列表存入session中
         session.setAttribute("classLists",classList);
 
         request.getRequestDispatcher("/WEB-INF/admin/updateStudent.jsp").forward(request,response);
@@ -60,60 +46,3 @@ public class UpdateStudentServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.admin;
-//
-//import domain.CDC;
-//import domain.Student;
-//import service.CDCService;
-//import service.StudentService;
-//import service.impl.CDCServiceImpl;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import java.io.IOException;
-//import java.util.List;
-//
-//@WebServlet("/updateStudentServlet")
-//public class UpdateStudentServlet extends HttpServlet {
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        request.setCharacterEncoding("utf-8");
-//        HttpSession session = request.getSession();
-//        String studentid = request.getParameter("sid");
-////        session.setAttribute("sid",studentid);
-//
-//        Student student = new Student();
-//        student.setS_id(studentid);
-//        // 创建学生服务的实现类实例，用于处理与学生相关的业务逻辑
-//        StudentService service = new StudentServiceImpl();
-//        Student newStudent = service.findStudentById(student);
-//        request.setAttribute("student",newStudent);
-//
-//        // 创建 CDCService 的实现类实例，用于处理与院系、系别和班级相关的业务逻辑
-//        // 创建CDCService实例
-//        CDCService service2 = new CDCServiceImpl();
-//        // 调用findAllCollege方法获取所有学院列表
-//        List<CDC> collegeList = service2.findAllCollege();
-//        // 调用findAllDepartment方法获取所有部门列表
-//        List<CDC> departmentList = service2.findAllDepartment();
-//        // 调用findAllClass方法获取所有班级列表
-//        List<CDC> classList = service2.findAllClass();
-//
-//        // 将学院列表存入session中
-//        session.setAttribute("collegeLists",collegeList);
-//        // 将部门列表存入session中
-//        session.setAttribute("departmentLists",departmentList);
-//        // 将班级列表存入session中
-//        session.setAttribute("classLists",classList);
-//
-//        request.getRequestDispatcher("/WEB-INF/admin/updateStudent.jsp").forward(request,response);
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/cdc/CDCListServlet.java

@@ -28,25 +28,17 @@ public class CDCListServlet extends HttpServlet {
         //将list存入request域
         request.setAttribute("cdcs",cdcs);
 
-        // 获取当前会话
         HttpSession session = request.getSession();
-        // 从会话中获取学生对象
         Student student= (Student)session.getAttribute("student");
-        // 从会话中获取管理员对象
         Admin admin= (Admin)session.getAttribute("admin");
-        // 从会话中获取教师对象
         Teacher teacher= (Teacher)session.getAttribute("teacher");
 
-        // 如果会话中存在学生对象，且不存在管理员对象和教师对象，则跳转到学生CDC列表页面
         if (student != null && admin == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/student/sCDCList.jsp").forward(request, response);
-        // 如果会话中存在管理员对象，且不存在学生对象和教师对象，则跳转到管理员CDC列表页面
         } else if (admin != null && student == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/admin/aCDCList.jsp").forward(request, response);
-        // 如果会话中存在教师对象，且不存在学生对象和管理员对象，则跳转到教师CDC列表页面
         } else if (teacher != null && admin == null && student == null) {
             request.getRequestDispatcher("/WEB-INF/teacher/tCDCList.jsp").forward(request, response);
-        // 如果会话中不存在学生对象、管理员对象和教师对象，则跳转到错误页面
         } else {
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
@@ -56,61 +48,3 @@ public class CDCListServlet extends HttpServlet {
         this.doPost(request,response);
     }
 }
-//package web.servlet.cdc;
-//
-//import domain.Admin;
-//import domain.CDC;
-//import domain.Student;
-//import domain.Teacher;
-//import service.CDCService;
-//import service.StudentService;
-//import service.impl.CDCServiceImpl;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import java.io.IOException;
-//import java.util.List;
-//
-//@WebServlet("/cdcListServlet")
-//public class CDCListServlet extends HttpServlet {
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        request.setCharacterEncoding("utf-8");
-//        //调用StudentService完成查询-
-//        CDCService service = new CDCServiceImpl();
-//        List<CDC> cdcs = service.findAll();
-//        //将list存入request域-
-//        request.setAttribute("cdcs",cdcs);
-//
-//        // 获取当前会话
-//        HttpSession session = request.getSession();
-//        // 从会话中获取学生对象
-//        Student student= (Student)session.getAttribute("student");
-//        // 从会话中获取管理员对象
-//        Admin admin= (Admin)session.getAttribute("admin");
-//        // 从会话中获取教师对象
-//        Teacher teacher= (Teacher)session.getAttribute("teacher");
-//
-//        // 如果会话中存在学生对象，且不存在管理员对象和教师对象，则跳转到学生CDC列表页面
-//        if (student != null && admin == null && teacher == null) {
-//            request.getRequestDispatcher("/WEB-INF/student/sCDCList.jsp").forward(request, response);
-//        // 如果会话中存在管理员对象，且不存在学生对象和教师对象，则跳转到管理员CDC列表页面
-//        } else if (admin != null && student == null && teacher == null) {
-//            request.getRequestDispatcher("/WEB-INF/admin/aCDCList.jsp").forward(request, response);
-//        // 如果会话中存在教师对象，且不存在学生对象和管理员对象，则跳转到教师CDC列表页面
-//        } else if (teacher != null && admin == null && student == null) {
-//            request.getRequestDispatcher("/WEB-INF/teacher/tCDCList.jsp").forward(request, response);
-//        // 如果会话中不存在学生对象、管理员对象和教师对象，则跳转到错误页面
-//        } else {
-//            request.getRequestDispatcher("error.jsp").forward(request, response);
-//        }
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        this.doPost(request,response);
-//    }
-//}

src/web/servlet/complaints/AddComplaintsServlet.java

@@ -29,19 +29,12 @@ public class AddComplaintsServlet extends HttpServlet {
             text = text.replace("/script","");
         }
 
-        // 判断文本是否为空
         if (!text.equals("")) {
-            // 设置投诉内容
             complaint.setContent(text);
-            // 获取当前时间
             Date d = new Date();
-            // 设置时间格式
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-            // 设置投诉日期
             complaint.setCdate(sdf.format(d));
-            // 创建投诉服务对象
             ComplaintService service = new ComplaintServiceImpl();
-            // 添加投诉
             service.addComplaint(complaint);
         }
 
@@ -53,58 +46,3 @@ public class AddComplaintsServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.complaints;
-//
-//import domain.Complaint;
-//import service.ComplaintService;
-//import service.NotifyService;
-//import service.impl.ComplaintServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import java.io.IOException;
-//import java.text.SimpleDateFormat;
-//import java.util.Date;
-//
-//@WebServlet("/addComplaintsServlet")
-//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");
-//
-//        if (text.contains("script") && text.contains("/script")) {
-//            text = text.replace("script","");
-//            text = text.replace("/script","");
-//        }
-//
-//        // 判断文本是否为空
-//        if (!text.equals("")) {
-//            // 设置投诉内容
-//            complaint.setContent(text);
-//            // 获取当前时间
-//            Date d = new Date();
-//            // 设置时间格式
-//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-//            // 设置投诉日期
-//            complaint.setCdate(sdf.format(d));
-//            // 创建投诉服务对象
-//            ComplaintService service = new ComplaintServiceImpl();
-//            // 添加投诉
-//            service.addComplaint(complaint);
-//        }
-//
-//        response.sendRedirect("complaintServlet");
-////        request.getRequestDispatcher("/complaintListServlet").forward(request,response);
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/complaints/ComplaintListServlet.java

@@ -14,54 +14,14 @@ import java.util.List;
 
 @WebServlet("/complaintListServlet")
 public class ComplaintListServlet extends HttpServlet {
-    // 处理 POST 请求
     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);
-        // 转发请求到 JSP 页面
         request.getRequestDispatcher("/WEB-INF/complaint/complaintsList.jsp").forward(request,response);
     }
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request,response);
     }
 }
-//package web.servlet.complaints;
-//
-//import domain.Complaint;
-//import service.ComplaintService;
-//import service.impl.ComplaintServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//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 {
-//    // 处理 POST 请求
-//    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();
-//        // 将查询到的投诉信息存入请求属性，以便在后续的 JSP 页面中使用
-//        request.setAttribute("complaints",complaints);
-//        // 转发请求到 JSP 页面
-//        request.getRequestDispatcher("/WEB-INF/complaint/complaintsList.jsp").forward(request,response);
-//    }
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/complaints/ComplaintServlet.java

@@ -15,22 +15,10 @@ import java.util.List;
 @WebServlet("/complaintServlet")
 public class ComplaintServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-<<<<<<< HEAD
-=======
-        // 设置请求编码为UTF-8，以支持中文字符的正确处理
-        // 设置请求的字符编码为utf-8
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
         request.setCharacterEncoding("utf-8");
-        // 创建ComplaintService实例
         ComplaintService service = new ComplaintServiceImpl();
-        // 调用findAll方法获取所有投诉信息
         List<Complaint> complaints = service.findAll();
-        // 将投诉信息存入request对象中
         request.setAttribute("complaints",complaints);
-        // 将请求转发到complaintsList.jsp页面
         request.getRequestDispatcher("/WEB-INF/complaint/complaintsList.jsp").forward(request,response);
     }
 
@@ -38,46 +26,3 @@ public class ComplaintServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.complaints;
-//
-//import domain.Complaint;
-//import service.ComplaintService;
-//import service.impl.ComplaintServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//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，以支持中文字符的正确处理
-//        // 设置请求的字符编码为utf-8
-//        request.setCharacterEncoding("utf-8");
-//        // 创建ComplaintService实例
-//        ComplaintService service = new ComplaintServiceImpl();
-//        // 调用findAll方法获取所有投诉信息
-//        List<Complaint> complaints = service.findAll();
-//        // 将投诉信息存入request对象中
-//        request.setAttribute("complaints",complaints);
-//        // 将请求转发到complaintsList.jsp页面
-//        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

@@ -10,30 +10,10 @@ import java.io.IOException;
 
 @WebServlet("/deleteFileServlet")
 public class DeleteFileServlet extends HttpServlet {
-<<<<<<< HEAD
-=======
-
-    /**
-     * 处理POST请求，执行文件删除操作。
-     *
-     * @param request  HTTP请求对象，包含客户端发送的数据。
-     * @param response HTTP响应对象，用于生成返回给客户端的响应。
-     * @throws ServletException 如果处理请求时发生错误。
-     * @throws IOException      如果输入或输出异常发生。
-     */
-    // 处理POST请求
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        // 设置请求编码为utf-8
         request.setCharacterEncoding("utf-8");
-        // 获取请求参数filename
         String fileName = request.getParameter("filename");
-        // 获取上传文件的路径
         File file = new File(this.getServletContext().getRealPath("upload")+File.separator+fileName);
-        // 如果文件存在，则删除
         if (file.exists()) {
             file.delete();
         }
@@ -44,45 +24,3 @@ public class DeleteFileServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.file;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import 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      如果输入或输出异常发生。
-//     */
-//    // 处理POST请求
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        // 设置请求编码为utf-8
-//        request.setCharacterEncoding("utf-8");
-//        // 获取请求参数filename
-//        String fileName = request.getParameter("filename");
-//        // 获取上传文件的路径
-//        File file = new File(this.getServletContext().getRealPath("upload")+File.separator+fileName);
-//        // 如果文件存在，则删除
-//        if (file.exists()) {
-//            file.delete();
-//        }
-//        request.getRequestDispatcher("/fileListServlet").forward(request,response);
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/file/DownloadServlet.java

@@ -17,41 +17,18 @@ import java.net.URLEncoder;
 
 @WebServlet("/downloadServlet")
 public class DownloadServlet extends HttpServlet {
-<<<<<<< HEAD
-=======
-    /**
-     * 处理POST请求，执行文件下载操作。
-     *
-     * @param request  HTTP请求对象，包含客户端发送的数据。
-     * @param response HTTP响应对象，用于生成返回给客户端的响应。
-     * @throws ServletException 如果处理请求时发生错误。
-     * @throws IOException      如果输入或输出异常发生。
-     */
-    // 处理POST请求
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        // 获取请求参数filename
         String filename = request.getParameter("filename");
-        // 判断filename是否为../或/
         if (filename.equalsIgnoreCase("../") || filename.equalsIgnoreCase("/")) {
-            // 如果是，则转发到error.jsp页面
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
-        // 设置响应头content-Type为application/octet-stream
         response.addHeader("content-Type", "application/octet-stream");
 
-        // 获取请求头User-Agent
         String agent = request.getHeader("User-Agent");
 
-        // 判断User-Agent是否包含chrome
         if (agent.toLowerCase().indexOf("chrome") > 0) {
-            // 如果包含，则设置响应头content-Disposition为attachment;filename，并将filename进行UTF-8和ISO8859-1编码
             response.addHeader("content-Disposition", "attachment;filename=" + new String(filename.getBytes("UTF-8"), "ISO8859-1"));
         } else {
-            // 如果不包含，则设置响应头content-Disposition为attachment;filename，并将filename进行UTF-8编码
             response.addHeader("content-Disposition", "attachment;filename=" + URLEncoder.encode(filename, "UTF-8"));
         }
         InputStream in = getServletContext().getResourceAsStream("/upload/" + filename);
@@ -64,24 +41,16 @@ public class DownloadServlet extends HttpServlet {
         out.close();
         in.close();
 
-        // 获取当前会话
         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/sFindFileList.jsp").forward(request, response);
-        // 如果会话中存在管理员对象，且不存在学生对象和教师对象，则跳转到管理员查找文件列表页面
         } else if (admin != null && student == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/admin/aFindFileList.jsp").forward(request, response);
-        // 如果会话中存在教师对象，且不存在学生对象和管理员对象，则跳转到教师查找文件列表页面
         } else if (teacher != null && admin == null && student == null) {
             request.getRequestDispatcher("/WEB-INF/teacher/tFindFileList.jsp").forward(request, response);
-        // 如果会话中不存在学生对象、管理员对象和教师对象，则跳转到错误页面
         } else {
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
@@ -91,92 +60,3 @@ public class DownloadServlet extends HttpServlet {
         doPost(request, response);
     }
 }
-//package web.servlet.file;
-//
-//import domain.Admin;
-//import domain.Student;
-//import domain.Teacher;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.ServletOutputStream;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import 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      如果输入或输出异常发生。
-//     */
-//    // 处理POST请求
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        // 获取请求参数filename
-//        String filename = request.getParameter("filename");
-//        // 判断filename是否为../或/
-//        if (filename.equalsIgnoreCase("../") || filename.equalsIgnoreCase("/")) {
-//            // 如果是，则转发到error.jsp页面
-//            request.getRequestDispatcher("error.jsp").forward(request, response);
-//        }
-//        // 设置响应头content-Type为application/octet-stream
-//        response.addHeader("content-Type", "application/octet-stream");
-//
-//        // 获取请求头User-Agent
-//        String agent = request.getHeader("User-Agent");
-//
-//        // 判断User-Agent是否包含chrome
-//        if (agent.toLowerCase().indexOf("chrome") > 0) {
-//            // 如果包含，则设置响应头content-Disposition为attachment;filename，并将filename进行UTF-8和ISO8859-1编码
-//            response.addHeader("content-Disposition", "attachment;filename=" + new String(filename.getBytes("UTF-8"), "ISO8859-1"));
-//        } else {
-//            // 如果不包含，则设置响应头content-Disposition为attachment;filename，并将filename进行UTF-8编码
-//            response.addHeader("content-Disposition", "attachment;filename=" + URLEncoder.encode(filename, "UTF-8"));
-//        }
-//        InputStream in = getServletContext().getResourceAsStream("/upload/" + filename);
-//        ServletOutputStream out = response.getOutputStream();
-//        byte[] bs = new byte[1024];
-//        int len = -1;
-//        while ((len = in.read(bs)) != -1) {
-//            out.write(bs, 0, len);
-//        }
-//        out.close();
-//        in.close();
-//
-//        // 获取当前会话
-//        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/sFindFileList.jsp").forward(request, response);
-//        // 如果会话中存在管理员对象，且不存在学生对象和教师对象，则跳转到管理员查找文件列表页面
-//        } else if (admin != null && student == null && teacher == null) {
-//            request.getRequestDispatcher("/WEB-INF/admin/aFindFileList.jsp").forward(request, response);
-//        // 如果会话中存在教师对象，且不存在学生对象和管理员对象，则跳转到教师查找文件列表页面
-//        } else if (teacher != null && admin == null && student == null) {
-//            request.getRequestDispatcher("/WEB-INF/teacher/tFindFileList.jsp").forward(request, response);
-//        // 如果会话中不存在学生对象、管理员对象和教师对象，则跳转到错误页面
-//        } else {
-//            request.getRequestDispatcher("error.jsp").forward(request, response);
-//        }
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request, response);
-//    }
-//}

src/web/servlet/file/FileListServlet.java

@@ -20,38 +20,23 @@ import java.util.List;
 
 @WebServlet("/fileListServlet")
 public class FileListServlet extends HttpServlet {
-    // 处理POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        // 设置请求编码为utf-8
         request.setCharacterEncoding("utf-8");
-        // 获取上传文件的目录
         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();
-        // 创建一个List来存储文件信息
         List<FileClass> fileLists = new ArrayList<FileClass>();
-        // 遍历所有文件
         for(File f:arrs){
-            // 获取文件大小
             long l = f.length();
-            // 将文件大小转换为可读的格式
             String fileSize = getPrintSize(l);
-            // 创建一个FileClass对象
             FileClass file = new FileClass();
-            // 设置文件名
             file.setFileName(f.getName());
-            // 设置文件路径
             file.setFilePath(f.getAbsolutePath());
-            // 设置文件大小
             file.setFileSize(fileSize);
-            // 将文件信息添加到List中
             fileLists.add(file);
         }
         request.setAttribute("fileLists",fileLists);
@@ -59,20 +44,14 @@ public class FileListServlet extends HttpServlet {
         HttpSession session = request.getSession();
         Student student= (Student)session.getAttribute("student");
 
-        // 从session中获取admin对象
         Admin admin= (Admin)session.getAttribute("admin");
-        // 从session中获取teacher对象
         Teacher teacher= (Teacher)session.getAttribute("teacher");
-        // 如果student对象不为空，admin对象为空，teacher对象为空，则跳转到student的文件列表页面
         if (student != null && admin == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/student/sFindFileList.jsp").forward(request, response);
-        // 如果admin对象不为空，student对象为空，teacher对象为空，则跳转到admin的文件列表页面
         } else if (admin != null && student == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/admin/aFindFileList.jsp").forward(request, response);
-        // 如果teacher对象不为空，admin对象为空，student对象为空，则跳转到teacher的文件列表页面
         } else if (teacher != null && admin == null && student == null) {
             request.getRequestDispatcher("/WEB-INF/teacher/tFindFileList.jsp").forward(request, response);
-        // 否则跳转到错误页面
         } else {
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
@@ -107,112 +86,3 @@ public class FileListServlet extends HttpServlet {
         }
     }
 }
-//package web.servlet.file;
-//
-//import domain.Admin;
-//import domain.FileClass;
-//import domain.Student;
-//import domain.Teacher;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import java.io.File;
-//import java.io.IOException;
-//import java.math.BigDecimal;
-//import java.math.RoundingMode;
-//import java.util.ArrayList;
-//import java.util.List;
-//
-//@WebServlet("/fileListServlet")
-//public class FileListServlet extends HttpServlet {
-//    // 处理POST请求
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        // 设置请求编码为utf-8
-//        request.setCharacterEncoding("utf-8");
-//        // 获取上传文件的目录
-//        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();
-//        // 创建一个List来存储文件信息
-//        List<FileClass> fileLists = new ArrayList<FileClass>();
-//        // 遍历所有文件
-//        for(File f:arrs){
-//            // 获取文件大小
-//            long l = f.length();
-//            // 将文件大小转换为可读的格式
-//            String fileSize = getPrintSize(l);
-//            // 创建一个FileClass对象
-//            FileClass file = new FileClass();
-//            // 设置文件名
-//            file.setFileName(f.getName());
-//            // 设置文件路径
-//            file.setFilePath(f.getAbsolutePath());
-//            // 设置文件大小
-//            file.setFileSize(fileSize);
-//            // 将文件信息添加到List中
-//            fileLists.add(file);
-//        }
-//        request.setAttribute("fileLists",fileLists);
-//
-//        HttpSession session = request.getSession();
-//        Student student= (Student)session.getAttribute("student");
-//
-//        // 从session中获取admin对象
-//        Admin admin= (Admin)session.getAttribute("admin");
-//        // 从session中获取teacher对象
-//        Teacher teacher= (Teacher)session.getAttribute("teacher");
-//        // 如果student对象不为空，admin对象为空，teacher对象为空，则跳转到student的文件列表页面
-//        if (student != null && admin == null && teacher == null) {
-//            request.getRequestDispatcher("/WEB-INF/student/sFindFileList.jsp").forward(request, response);
-//        // 如果admin对象不为空，student对象为空，teacher对象为空，则跳转到admin的文件列表页面
-//        } else if (admin != null && student == null && teacher == null) {
-//            request.getRequestDispatcher("/WEB-INF/admin/aFindFileList.jsp").forward(request, response);
-//        // 如果teacher对象不为空，admin对象为空，student对象为空，则跳转到teacher的文件列表页面
-//        } else if (teacher != null && admin == null && student == null) {
-//            request.getRequestDispatcher("/WEB-INF/teacher/tFindFileList.jsp").forward(request, response);
-//        // 否则跳转到错误页面
-//        } else {
-//            request.getRequestDispatcher("error.jsp").forward(request, response);
-//        }
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//
-//    public static String getPrintSize(long size) {
-//        // 如果字节数少于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作为单位-
-//        // 因为还没有到达要使用另一个单位的时候
-//        // 接下去以此类推
-//        if (value < 1024) {
-//            return String.valueOf(value) + "KB";
-//        } else {
-//            value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
-//        }
-//        if (value < 1024) {
-//            return String.valueOf(value) + "MB";
-//        } else {
-//            // 否则如果要以GB为单位的，先除于1024再作同样的处理
-//            value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
-//            return String.valueOf(value) + "GB";
-//        }
-//    }
-//}

src/web/servlet/file/FileServlet.java

@@ -17,40 +17,3 @@ public class FileServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.file;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import 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

@@ -34,23 +34,18 @@ public class ShowPhotoServlet extends HttpServlet {
         Student student = (Student) session.getAttribute("student");
         Teacher teacher = (Teacher) session.getAttribute("teacher");
         Photo p;
-        // 判断当前用户是学生还是教师
         if (student != null) {
-            // 如果是学生，则根据学生id查询照片
             PhotoService service = new PhotoServiceImpl();
             p = service.findPhotoByPhotoId(student.getS_id());
         }else{
-            // 如果是教师，则根据教师id查询照片
             PhotoService service = new PhotoServiceImpl();
             p = service.findPhotoByPhotoId(teacher.getT_id());
         }
         String imagePath = "";
-        // 如果没有查询到照片，则使用默认照片
         if (p == null) {
             imagePath = this.getServletContext().getRealPath("/photos/") + "0.jpg";
             System.out.println(imagePath);
         } else {
-            // 如果查询到照片，则使用查询到的照片
             String photoName = p.getPhotoName();
             imagePath = this.getServletContext().getRealPath("/photos/") + photoName;
             System.out.println(imagePath);
@@ -77,20 +72,14 @@ public class ShowPhotoServlet extends HttpServlet {
             imageIn.close();// 关闭文件流
         }
 
-        if (imagePath.toLowerCase().endsWith(".gif"))
-            // 不使用编码处理文件流的情况：
+        if (imagePath.toLowerCase().endsWith(".gif"))// 不使用编码处理文件流的情况：
         {
             response.setContentType(GIF);
-            ServletContext context = getServletContext();
-            // 得到背景对象
-            InputStream imageIn = context.getResourceAsStream(imagePath);
-            // 文件流
-            BufferedInputStream bis = new BufferedInputStream(imageIn);
-            // 输入缓冲流
-            BufferedOutputStream bos = new BufferedOutputStream(output);
-            // 输出缓冲流
-            byte data[] = new byte[4096];
-            // 缓冲字节数
+            ServletContext context = getServletContext();// 得到背景对象
+            InputStream imageIn = context.getResourceAsStream(imagePath);// 文件流
+            BufferedInputStream bis = new BufferedInputStream(imageIn);// 输入缓冲流
+            BufferedOutputStream bos = new BufferedOutputStream(output);// 输出缓冲流
+            byte data[] = new byte[4096];// 缓冲字节数
             int size = 0;
             size = bis.read(data);
             while (size != -1) {
@@ -108,113 +97,3 @@ public class ShowPhotoServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.file;
-//
-//import com.sun.image.codec.jpeg.JPEGCodec;
-//import com.sun.image.codec.jpeg.JPEGImageDecoder;
-//import com.sun.image.codec.jpeg.JPEGImageEncoder;
-//import domain.Photo;
-//import domain.Student;
-//import domain.Teacher;
-//import service.PhotoService;
-//import service.impl.PhotoServiceImpl;
-//
-//import javax.servlet.ServletContext;
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import java.awt.image.BufferedImage;
-//import java.io.*;
-//import java.net.ServerSocket;
-//
-//@WebServlet("/showPhotoServlet")
-//public class ShowPhotoServlet extends HttpServlet {
-//    private static final String GIF = "image/gif;charset=GB2312";// 设定输出的类型
-//
-//    private static final String JPG = "image/jpeg;charset=GB2312";
-//
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        String spec = request.getParameter("spec");// 输出图片的类型的标志
-//
-//        request.setCharacterEncoding("utf-8");
-//        HttpSession session = request.getSession();
-//        Student student = (Student) session.getAttribute("student");
-//        Teacher teacher = (Teacher) session.getAttribute("teacher");
-//        Photo p;
-//        // 判断当前用户是学生还是教师
-//        if (student != null) {
-//            // 如果是学生，则根据学生id查询照片
-//            PhotoService service = new PhotoServiceImpl();
-//            p = service.findPhotoByPhotoId(student.getS_id());
-//        }else{
-//            // 如果是教师，则根据教师id查询照片
-//            PhotoService service = new PhotoServiceImpl();
-//            p = service.findPhotoByPhotoId(teacher.getT_id());
-//        }
-//        String imagePath = "";
-//        // 如果没有查询到照片，则使用默认照片
-//        if (p == null) {
-//            imagePath = this.getServletContext().getRealPath("/photos/") + "0.jpg";
-//            System.out.println(imagePath);
-//        } else {
-//            // 如果查询到照片，则使用查询到的照片
-//            String photoName = p.getPhotoName();
-//            imagePath = this.getServletContext().getRealPath("/photos/") + photoName;
-//            System.out.println(imagePath);
-//        }
-//
-//
-//        response.reset();
-//
-//        OutputStream output = response.getOutputStream();// 得到输出流
-//        if (imagePath.toLowerCase().endsWith(".jpg"))// 使用编码处理文件流的情况：
-//        {
-//            response.setContentType(JPG);// 设定输出的类型
-//            // 得到图片的真实路径-
-//
-//            // 得到图片的文件流-
-//            InputStream imageIn = new FileInputStream(new File(imagePath));
-//            // 得到输入的编码器，将文件流进行jpg格式编码-
-//            JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(imageIn);
-//            // 得到编码后的图片对象-
-//            BufferedImage image = decoder.decodeAsBufferedImage();
-//            // 得到输出的编码器
-//            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(output);
-//            encoder.encode(image);// 对图片进行输出编码
-//            imageIn.close();// 关闭文件流
-//        }
-//
-//        if (imagePath.toLowerCase().endsWith(".gif"))
-//            // 不使用编码处理文件流的情况：
-//        {
-//            response.setContentType(GIF);
-//            ServletContext context = getServletContext();
-//            // 得到背景对象
-//            InputStream imageIn = context.getResourceAsStream(imagePath);
-//            // 文件流
-//            BufferedInputStream bis = new BufferedInputStream(imageIn);
-//            // 输入缓冲流
-//            BufferedOutputStream bos = new BufferedOutputStream(output);
-//            // 输出缓冲流
-//            byte data[] = new byte[4096];
-//            // 缓冲字节数
-//            int size = 0;
-//            size = bis.read(data);
-//            while (size != -1) {
-//                bos.write(data, 0, size);
-//                size = bis.read(data);
-//            }
-//            bis.close();
-//            bos.flush();// 清空输出缓冲流
-//            bos.close();
-//        }
-//        output.close();
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/file/UploadImageServlet.java

@@ -26,22 +26,14 @@ import java.util.List;
 
 @WebServlet("/uploadImageServlet")
 public class UploadImageServlet extends HttpServlet {
-    // 处理POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
-        // 获取当前会话
         HttpSession session = request.getSession();
-        // 获取当前会话中的学生对象
         Student student = (Student) session.getAttribute("student");
-        // 获取当前会话中的教师对象
         Teacher teacher = (Teacher) session.getAttribute("teacher");
-        // 获取当前会话中的管理员对象
         Admin admin = (Admin) session.getAttribute("admin");
-        // 定义一个字符串变量，用于存储用户ID
         String id = "";
-        // 如果当前会话中有学生对象
         if (student != null) {
-            // 将学生ID赋值给id变量
             id = student.getS_id();
         }
 
@@ -87,7 +79,6 @@ public class UploadImageServlet extends HttpServlet {
 
                 filename = filename.substring(filename.lastIndexOf("\\") + 1);
 //				System.out.print(filename);
-                // 判断文件名后缀是否为JPG、JPEG、gif、GIF、jpg、jpeg
                 if (filename.substring(filename.lastIndexOf(".") + 1).equals("JPG")
                         || filename.substring(filename.lastIndexOf(".") + 1).equals("JPEG")
                         || filename.substring(filename.lastIndexOf(".") + 1).equals("gif")
@@ -110,7 +101,6 @@ public class UploadImageServlet extends HttpServlet {
                 } else {  //必须是图片才能上传否则失败
                     request.setAttribute("update_msg", "上传失败，只能上传类型为jpg或GIF的图像文件！"+String.format("%tT",new Date()));
 //        request.getRequestDispatcher("/WEB-INF/index.jsp").forward(request, response);
-                    // 转发到studentAddPhoto.jsp页面
                     request.getRequestDispatcher("/WEB-INF/student/studentAddPhoto.jsp").forward(request, response);
                     return;
                 }
@@ -119,13 +109,9 @@ public class UploadImageServlet extends HttpServlet {
             e.printStackTrace();
         }
 
-        // 创建Photo对象
         Photo photo = new Photo();
-        // 设置photoId
         photo.setPhotoId(id);
-        // 设置photoName
         photo.setPhotoName(newFileName);
-        // 创建PhotoService对象
         PhotoService service = new PhotoServiceImpl();
 
 
@@ -144,149 +130,3 @@ public class UploadImageServlet extends HttpServlet {
         request.getRequestDispatcher("/WEB-INF/student/studentAddPhoto.jsp").forward(request, response);
     }
 }
-//package web.servlet.file;
-//
-//import domain.Admin;
-//import domain.Photo;
-//import domain.Student;
-//import domain.Teacher;
-//import org.apache.commons.fileupload.FileItem;
-//import org.apache.commons.fileupload.FileUploadException;
-//import org.apache.commons.fileupload.disk.DiskFileItemFactory;
-//import org.apache.commons.fileupload.servlet.ServletFileUpload;
-//import service.PhotoService;
-//import service.impl.PhotoServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import java.io.File;
-//import java.io.FileOutputStream;
-//import java.io.IOException;
-//import java.io.InputStream;
-//import java.util.Date;
-//import java.util.List;
-//
-//@WebServlet("/uploadImageServlet")
-//public class UploadImageServlet extends HttpServlet {
-//    // 处理POST请求
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//
-//        // 获取当前会话
-//        HttpSession session = request.getSession();
-//        // 获取当前会话中的学生对象
-//        Student student = (Student) session.getAttribute("student");
-//        // 获取当前会话中的教师对象
-//        Teacher teacher = (Teacher) session.getAttribute("teacher");
-//        // 获取当前会话中的管理员对象
-//        Admin admin = (Admin) session.getAttribute("admin");
-//        // 定义一个字符串变量，用于存储用户ID
-//        String id = "";
-//        // 如果当前会话中有学生对象
-//        if (student != null) {
-//            // 将学生ID赋值给id变量
-//            id = student.getS_id();
-//        }
-//
-//        request.setAttribute("message", "");
-//        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、创建一个文件上传解析器-
-//        ServletFileUpload upload = new ServletFileUpload(factory);
-//        upload.setHeaderEncoding("UTF-8");
-//        // 3、判断提交上来的数据是否是上传表单的数据-
-//        if (!ServletFileUpload.isMultipartContent(request)) {
-//            // 按照传统方式获取数据-
-//            return;
-//        }
-//        try {
-//            List<FileItem> list = upload.parseRequest(request);
-//            System.out.println(list.toString());// 文件的路径 以及保存的路径-
-//            for (FileItem item : list) {
-//                filename = item.getName();// 获得一个项的文件名称-
-//                try {
-//                    newFileName = id + filename.substring(filename.lastIndexOf("."));
-//                    filename = id + filename.substring(filename.lastIndexOf("."));
-//                } catch (Exception e) {
-//                    e.printStackTrace();
-//                }
-//                if (filename == null || filename.trim().equals("")) {// 如果為空則跳過
-//                    continue;
-//                }
-//                // 報錯 需要過濾文件名稱 java.io.FileNotFoundException:
-//                // G:\测试02\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\wtpwebapps\FaceUp\WEB-INF\images\C:\Users\Ray\Pictures\2.jpeg
-//                // (文件名、目录名或卷标语法不正确。)
-//
-//                filename = filename.substring(filename.lastIndexOf("\\") + 1);
-////				System.out.print(filename);
-//                // 判断文件名后缀是否为JPG、JPEG、gif、GIF、jpg、jpeg
-//                if (filename.substring(filename.lastIndexOf(".") + 1).equals("JPG")
-//                        || filename.substring(filename.lastIndexOf(".") + 1).equals("JPEG")
-//                        || filename.substring(filename.lastIndexOf(".") + 1).equals("gif")
-//                        || filename.substring(filename.lastIndexOf(".") + 1).equals("GIF")
-//                        || filename.substring(filename.lastIndexOf(".") + 1).equals("jpg")
-//                        || filename.substring(filename.lastIndexOf(".") + 1).equals("jpeg")) {
-//                    InputStream in = item.getInputStream();// 獲得上傳的輸入流
-//                    FileOutputStream out = new FileOutputStream(savePath + "\\" + filename);// 指定web-inf目錄下的images文件
-//                    request.setAttribute("path",  "photos"+"\\" + filename);
-//
-//                    int len = 0;
-//                    byte buffer[] = new byte[1024];
-//                    while ((len = in.read(buffer)) > 0)// 每次讀取
-//                    {
-//                        out.write(buffer, 0, len);
-//                    }
-//                    in.close();
-//                    out.close();
-//                    item.delete();
-//                } else {  //必须是图片才能上传否则失败
-//                    request.setAttribute("update_msg", "上传失败，只能上传类型为jpg或GIF的图像文件！"+String.format("%tT",new Date()));
-////        request.getRequestDispatcher("/WEB-INF/index.jsp").forward(request, response);
-//                    // 转发到studentAddPhoto.jsp页面
-//                    request.getRequestDispatcher("/WEB-INF/student/studentAddPhoto.jsp").forward(request, response);
-//                    return;
-//                }
-//            }
-//        } catch (FileUploadException e) {
-//            e.printStackTrace();
-//        }
-//
-//        // 创建Photo对象
-//        Photo photo = new Photo();
-//        // 设置photoId
-//        photo.setPhotoId(id);
-//        // 设置photoName
-//        photo.setPhotoName(newFileName);
-//        // 创建PhotoService对象
-//        PhotoService service = new PhotoServiceImpl();
-//
-//
-//        Photo photo1= service.findPhotoByPhotoId(id);
-//        if (photo1==null) {
-//            service.addPhoto(photo);
-//        }else {
-//            service.updatePhoto(photo);
-//        }
-//        request.setAttribute("update_msg", "上传成功！"+String.format("%tT",new Date()));
-////        request.getRequestDispatcher("/WEB-INF/index.jsp").forward(request, response);
-//        request.getRequestDispatcher("/WEB-INF/student/studentAddPhoto.jsp").forward(request, response);
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        request.getRequestDispatcher("/WEB-INF/student/studentAddPhoto.jsp").forward(request, response);
-//    }
-//}

src/web/servlet/file/UploadServlet.java

@@ -18,40 +18,16 @@ import org.apache.commons.fileupload.servlet.ServletFileUpload;
 
 @WebServlet("/uploadServlet")
 public class UploadServlet extends HttpServlet {
-<<<<<<< HEAD
-=======
-
-    /**
-     * 处理POST请求，用于执行文件上传操作。
-     *
-     * @param request  HTTP请求对象，包含客户端发送的数据。
-     * @param response HTTP响应对象，用于生成返回给客户端的响应。
-     * @throws ServletException 如果处理请求时发生错误。
-     * @throws IOException      如果输入或输出异常发生。
-     */
-    // 处理POST请求
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        // 设置请求编码为utf-8
         request.setCharacterEncoding("utf-8");
-        // 设置响应编码为utf-8
         response.setCharacterEncoding("utf-8");
-        // 设置响应内容类型为text/html，编码为utf-8
         response.setContentType("text/html; charset=utf-8");
 
 
-        // 判断请求是否为文件上传
         boolean isMultipart=ServletFileUpload.isMultipartContent(request);
-        // 如果是文件上传
         if (isMultipart) {
-            // 创建一个文件项工厂
             FileItemFactory factory = new DiskFileItemFactory();
-            // 创建一个文件上传对象
             ServletFileUpload upload = new ServletFileUpload(factory);
-            // 设置文件上传对象的编码为utf-8
             upload.setHeaderEncoding("utf-8");
 
 //            upload.setProgressListener(new ProgressListener(){
@@ -67,17 +43,11 @@ public class UploadServlet extends HttpServlet {
 //            });
 
             try {
-                // 解析请求，获取上传的文件项
                 List<FileItem> items = upload.parseRequest(request);
-                // 获取文件项的迭代器
                 Iterator<FileItem> it = items.iterator();
-                // 遍历文件项
                 while (it.hasNext()) {
-                    // 获取下一个文件项
                     FileItem item = it.next();
-                    // 获取文件项的名称
                     String itemname = item.getFieldName();
-                    // 初始化学号和姓名
                     int sno = -1;
                     String sname = null;
 
@@ -93,31 +63,21 @@ public class UploadServlet extends HttpServlet {
                     } else {
                         String filename = item.getName();
                         //String path=request.getSession().getServletContext().getRealPath("upload");
-                        // 获取上传文件的路径
                         String path = this.getServletContext().getRealPath("upload");
-                        // 判断上传文件的扩展名是否为jsp、htm或html
                         if (filename.substring(filename.lastIndexOf(".") + 1).equals("jsp")
                                 || filename.substring(filename.lastIndexOf(".") + 1).equals("htm")
                                 || filename.substring(filename.lastIndexOf(".") + 1).equals("html")) {
-                            // 如果是，则转发到错误页面
                             request.getRequestDispatcher("error.jsp").forward(request, response);
                         } else {
-                            // 如果不是，则打印上传文件的路径
                             System.out.println(path);
-                            // 创建文件对象
                             File file = new File(path);
-                            // 如果文件不存在且不是目录，则创建目录
                             if (!file.exists() && !file.isDirectory()) {
                                 file.mkdir();
                             }
-                            // 将上传的文件写入到指定路径
                             item.write(new File(path, filename));
-                            // 设置上传成功的属性
                             request.setAttribute("news", filename + "  上传成功!");
-                            // 转发到上传成功页面
                             request.getRequestDispatcher("/WEB-INF/admin/uploadFile.jsp").forward(request, response);
 //                        response.sendRedirect("fileUploadIndexServlet");
-                            // 打印上传成功的消息
                             System.out.println(filename + "上传成功!!!");
 
                         }
@@ -133,26 +93,11 @@ public class UploadServlet extends HttpServlet {
         }
     }
 
-<<<<<<< HEAD
-=======
-    /**
-     * 表示文件上传或下载过程中的信息类
-     */
-    // 定义一个ProcessInfo类，用于存储进程信息
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
     class ProcessInfo{
-        // 总大小
         public long totalSize = 1;
-        // 已读大小
         public long readSize = 0;
-        // 显示信息
         public String show = "";
-        // 项目数量
         public int itemNum = 0;
-        // 速率
         public int rate = 0;
     }
 
@@ -160,155 +105,3 @@ public class UploadServlet extends HttpServlet {
         doPost(request, response);
     }
 }
-//package web.servlet.file;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import java.io.IOException;
-//import java.io.File;
-//import java.util.Iterator;
-//import java.util.List;
-//import org.apache.commons.fileupload.FileItem;
-//import org.apache.commons.fileupload.FileItemFactory;
-//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      如果输入或输出异常发生。
-//     */
-//    // 处理POST请求
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        // 设置请求编码为utf-8
-//        request.setCharacterEncoding("utf-8");
-//        // 设置响应编码为utf-8
-//        response.setCharacterEncoding("utf-8");
-//        // 设置响应内容类型为text/html，编码为utf-8
-//        response.setContentType("text/html; charset=utf-8");
-//
-//
-//        // 判断请求是否为文件上传
-//        boolean isMultipart=ServletFileUpload.isMultipartContent(request);
-//        // 如果是文件上传
-//        if (isMultipart) {
-//            // 创建一个文件项工厂
-//            FileItemFactory factory = new DiskFileItemFactory();
-//            // 创建一个文件上传对象
-//            ServletFileUpload upload = new ServletFileUpload(factory);
-//            // 设置文件上传对象的编码为utf-8
-//            upload.setHeaderEncoding("utf-8");
-//
-////            upload.setProgressListener(new ProgressListener(){
-////                public void update(long pBytesRead, long pContentLength, int pItems) {
-////                    ProcessInfo pri = new ProcessInfo();
-////                    pri.itemNum = pItems;
-////                    pri.readSize = pBytesRead;
-////                    pri.totalSize = pContentLength;
-////                    pri.show = pBytesRead+"/"+pContentLength+" byte";
-////                    pri.rate = Math.round(new Float(pBytesRead) / new Float(pContentLength)*100);
-////                    hs.setAttribute("proInfo", pri);
-////                }
-////            });
-//
-//            try {
-//                // 解析请求，获取上传的文件项
-//                List<FileItem> items = upload.parseRequest(request);
-//                // 获取文件项的迭代器
-//                Iterator<FileItem> it = items.iterator();
-//                // 遍历文件项
-//                while (it.hasNext()) {
-//                    // 获取下一个文件项
-//                    FileItem item = it.next();
-//                    // 获取文件项的名称
-//                    String itemname = item.getFieldName();
-//                    // 初始化学号和姓名
-//                    int sno = -1;
-//                    String sname = null;
-//
-//                    if (item.isFormField()) {
-//                        if (itemname.equals("sno")) {
-//                            sno = Integer.parseInt(item.getString("utf-8"));
-//                        } else if (itemname.equals("sname")) {
-//                            sname = item.getString("utf-8");
-//                            sname = item.getName();
-//                        } else {
-//                            System.out.println("其他字段");
-//                        }
-//                    } else {
-//                        String filename = item.getName();
-//                        //String path=request.getSession().getServletContext().getRealPath("upload");
-//                        // 获取上传文件的路径
-//                        String path = this.getServletContext().getRealPath("upload");
-//                        // 判断上传文件的扩展名是否为jsp、htm或html
-//                        if (filename.substring(filename.lastIndexOf(".") + 1).equals("jsp")
-//                                || filename.substring(filename.lastIndexOf(".") + 1).equals("htm")
-//                                || filename.substring(filename.lastIndexOf(".") + 1).equals("html")) {
-//                            // 如果是，则转发到错误页面
-//                            request.getRequestDispatcher("error.jsp").forward(request, response);
-//                        } else {
-//                            // 如果不是，则打印上传文件的路径
-//                            System.out.println(path);
-//                            // 创建文件对象
-//                            File file = new File(path);
-//                            // 如果文件不存在且不是目录，则创建目录
-//                            if (!file.exists() && !file.isDirectory()) {
-//                                file.mkdir();
-//                            }
-//                            // 将上传的文件写入到指定路径
-//                            item.write(new File(path, filename));
-//                            // 设置上传成功的属性
-//                            request.setAttribute("news", filename + "  上传成功!");
-//                            // 转发到上传成功页面
-//                            request.getRequestDispatcher("/WEB-INF/admin/uploadFile.jsp").forward(request, response);
-////                        response.sendRedirect("fileUploadIndexServlet");
-//                            // 打印上传成功的消息
-//                            System.out.println(filename + "上传成功!!!");
-//
-//                        }
-//                        return;
-//                    }
-//
-//                }
-//            } catch (FileUploadException e) {
-//                e.printStackTrace();
-//            } catch (Exception e) {
-//                e.printStackTrace();
-//            }
-//        }
-//    }
-//
-//    /**
-//     * 表示文件上传或下载过程中的信息类
-//     */
-//    // 定义一个ProcessInfo类，用于存储进程信息
-//    class ProcessInfo{
-//        // 总大小
-//        public long totalSize = 1;
-//        // 已读大小
-//        public long readSize = 0;
-//        // 显示信息
-//        public String show = "";
-//        // 项目数量
-//        public int itemNum = 0;
-//        // 速率
-//        public int rate = 0;
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request, response);
-//    }
-//}

src/web/servlet/login/LogoutServlet.java

@@ -10,35 +10,13 @@ import java.io.IOException;
 
 @WebServlet("/logoutServlet")
 public class LogoutServlet extends HttpServlet {
-<<<<<<< HEAD
-=======
-    /**
-     * 处理POST请求，实现用户注销功能。
-     *
-     * @param request  HTTP请求对象，包含客户端发送的数据。
-     * @param response HTTP响应对象，用于生成返回给客户端的响应。
-     * @throws ServletException 如果处理请求时发生错误。
-     * @throws IOException      如果输入或输出异常发生。
-     */
-    // 处理POST请求
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        // 设置请求编码为UTF-8
         request.setCharacterEncoding("UTF-8");
-        // 获取当前会话
         HttpSession session = request.getSession();
-        // 移除会话中的student属性
         session.removeAttribute("student");
-        // 移除会话中的teacher属性
         session.removeAttribute("teacher");
-        // 移除会话中的admin属性
         session.removeAttribute("admin");
-        // 使会话失效
         session.invalidate();
-        // 重定向到index.jsp页面
         response.sendRedirect("index.jsp");
     }
 

src/web/servlet/login/RegisterServlet.java

@@ -13,56 +13,32 @@ import java.io.IOException;
 public class RegisterServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         HttpSession session = request.getSession();
-        // 获取用户输入的学生ID
         String studentid = request.getParameter("studentid");
-        // 获取用户输入的密码
         String password = request.getParameter("password");
-        // 获取用户输入的确认密码
         String repassword = request.getParameter("repassword");
-        // 获取用户输入的验证码
         String vcode = request.getParameter("verifycode");
 
-        //从session中获取服务器生成的验证码
         String checkcode_server = (String) session.getAttribute("CHECKCODE_SERVER");
-        session.removeAttribute("CHECKCODE_SERVER");
-        //确保验证一次性
-        // 判断验证码是否正确
+        session.removeAttribute("CHECKCODE_SERVER");//确保验证一次性
         if (!vcode.equalsIgnoreCase(checkcode_server)){
-            // 如果验证码错误，将错误信息、用户输入的信息存入request中
             request.setAttribute("msg","验证码错误");
-            // 将用户输入的学号存入request中
             request.setAttribute("studentid",studentid);
-            // 将用户输入的密码存入request中
             request.setAttribute("password",password);
-            // 将用户输入的确认密码存入request中
             request.setAttribute("repassword",repassword);
-            // 将请求转发到register.jsp页面
             request.getRequestDispatcher("register.jsp").forward(request,response);
-            // 返回
             return;
         }else {
             Student student = new Student();
-            // 设置学生id
             student.setS_id(studentid);
-            // 设置学生密码
             student.setS_password(password);
-            // 打印学生id
             System.out.println(studentid);
-            // 打印学生密码
             System.out.println(password);
-            // 创建学生服务对象
             StudentService service= new StudentServiceImpl();
-            // 调用注册方法
             service.register(student);
-            // 设置注册成功信息
             request.setAttribute("msg","注册成功");
-            // 清空学生id
             request.setAttribute("studentid","");
-            // 清空学生密码
             request.setAttribute("password","");
-            // 清空确认密码
             request.setAttribute("repassword","");
-            // 转发到注册页面
             request.getRequestDispatcher("register.jsp").forward(request,response);
 
         }
@@ -72,88 +48,3 @@ public class RegisterServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.login;
-//
-//import domain.Student;
-//import service.StudentService;
-//import service.impl.StudentServiceImpl;
-//
-//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();
-//        // 获取用户输入的学生ID
-//        String studentid = request.getParameter("studentid");
-//        // 获取用户输入的密码
-//        String password = request.getParameter("password");
-//        // 获取用户输入的确认密码
-//        String repassword = request.getParameter("repassword");
-//        // 获取用户输入的验证码
-//        String vcode = request.getParameter("verifycode");
-//
-//        //从session中获取服务器生成的验证码
-//        String checkcode_server = (String) session.getAttribute("CHECKCODE_SERVER");
-//        session.removeAttribute("CHECKCODE_SERVER");
-//        //确保验证一次性
-//        // 判断验证码是否正确
-//        if (!vcode.equalsIgnoreCase(checkcode_server)){
-//            // 如果验证码错误，将错误信息、用户输入的信息存入request中
-//            request.setAttribute("msg","验证码错误");
-//            // 将用户输入的学号存入request中
-//            request.setAttribute("studentid",studentid);
-//            // 将用户输入的密码存入request中
-//            request.setAttribute("password",password);
-//            // 将用户输入的确认密码存入request中
-//            request.setAttribute("repassword",repassword);
-//            // 将请求转发到register.jsp页面
-//            request.getRequestDispatcher("register.jsp").forward(request,response);
-//            // 返回
-//            return;
-//        }else {
-//            Student student = new Student();
-//            // 设置学生id
-//            student.setS_id(studentid);
-//            // 设置学生密码
-//            student.setS_password(password);
-//            // 打印学生id
-//            System.out.println(studentid);
-//            // 打印学生密码
-//            System.out.println(password);
-//            // 创建学生服务对象
-//            StudentService service= new StudentServiceImpl();
-//            // 调用注册方法
-//            service.register(student);
-//            // 设置注册成功信息
-//            request.setAttribute("msg","注册成功");
-//            // 清空学生id
-//            request.setAttribute("studentid","");
-//            // 清空学生密码
-//            request.setAttribute("password","");
-//            // 清空确认密码
-//            request.setAttribute("repassword","");
-//            // 转发到注册页面
-//            request.getRequestDispatcher("register.jsp").forward(request,response);
-//
-//        }
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/notify/AddNotifyServlet.java

@@ -37,42 +37,3 @@ public class AddNotifyServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.notify;
-//
-//import domain.Notify;
-//import org.apache.commons.beanutils.BeanUtils;
-//import service.NotifyService;
-//import service.impl.NotifyServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import java.io.IOException;
-//import java.lang.reflect.InvocationTargetException;
-//import java.text.SimpleDateFormat;
-//import java.util.Date;
-//import java.util.List;
-//import java.util.Map;
-//
-//@WebServlet("/addNotifyServlet")
-//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();
-//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-//        notify.setNotifyDate(sdf.format(d));
-//        NotifyService service = new NotifyServiceImpl();
-//        service.addNotify(notify);
-////        response.sendRedirect("/notifyListServlet");
-//        request.getRequestDispatcher("/notifyListServlet").forward(request,response);
-//    }
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/notify/DeleteNotifyServlet.java

@@ -27,43 +27,3 @@ public class DeleteNotifyServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.notify;
-//
-//import domain.Student;
-//import service.NotifyService;
-//import service.impl.NotifyServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import 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");
-//        NotifyService service = new NotifyServiceImpl();
-//        service.deleteNotifyById(notifyid);
-//        request.getRequestDispatcher("/notifyListServlet").forward(request,response);
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/notify/NotifyListServlet.java

@@ -25,42 +25,3 @@ public class NotifyListServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.notify;
-//
-//import domain.Notify;
-//import service.NotifyService;
-//import service.impl.NotifyServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import 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);
-//        request.getRequestDispatcher("/WEB-INF/notify/notifyList.jsp").forward(request,response);
-//    }
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/notify/NotifyListToServlet.java

@@ -24,19 +24,13 @@ public class NotifyListToServlet extends HttpServlet {
         List<Notify> notifys = service.findAll();
         request.setAttribute("notifys",notifys);
 
-        // 获取当前会话
         HttpSession session = request.getSession();
-        // 从会话中获取学生对象
         Student student= (Student)session.getAttribute("student");
-        // 从会话中获取教师对象
         Teacher teacher= (Teacher)session.getAttribute("teacher");
-        // 如果会话中存在学生对象且不存在教师对象，则转发到学生通知列表页面
         if (student != null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/notify/notifyListToStudent.jsp").forward(request,response);
-        // 如果会话中存在教师对象且不存在学生对象，则转发到教师通知列表页面
         } else if (teacher != null && student == null) {
             request.getRequestDispatcher("/WEB-INF/notify/notifyListToTeacher.jsp").forward(request,response);
-        // 如果会话中既不存在学生对象也不存在教师对象，则转发到错误页面
         } else {
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
@@ -47,64 +41,3 @@ public class NotifyListToServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.notify;
-//
-//import domain.Admin;
-//import domain.Notify;
-//import domain.Student;
-//import domain.Teacher;
-//import service.NotifyService;
-//import service.impl.NotifyServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import 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);
-//
-//        // 获取当前会话
-//        HttpSession session = request.getSession();
-//        // 从会话中获取学生对象
-//        Student student= (Student)session.getAttribute("student");
-//        // 从会话中获取教师对象
-//        Teacher teacher= (Teacher)session.getAttribute("teacher");
-//        // 如果会话中存在学生对象且不存在教师对象，则转发到学生通知列表页面
-//        if (student != null && teacher == null) {
-//            request.getRequestDispatcher("/WEB-INF/notify/notifyListToStudent.jsp").forward(request,response);
-//        // 如果会话中存在教师对象且不存在学生对象，则转发到教师通知列表页面
-//        } else if (teacher != null && student == null) {
-//            request.getRequestDispatcher("/WEB-INF/notify/notifyListToTeacher.jsp").forward(request,response);
-//        // 如果会话中既不存在学生对象也不存在教师对象，则转发到错误页面
-//        } else {
-//            request.getRequestDispatcher("error.jsp").forward(request, response);
-//        }
-//
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/notify/NotifyServlet.java

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

src/web/servlet/page/FindStudentByPageServlet.java

@@ -33,46 +33,23 @@ public class FindStudentByPageServlet extends HttpServlet {
         //获取条件查询参数
         Map<String,String[]> condition = request.getParameterMap();
 
-        //创建StudentService对象
         StudentService service = new StudentServiceImpl();
-        //调用findStudentByPage方法，传入当前页码、每页显示的行数和查询条件，返回PageBean<Student>对象
         PageBean<Student> pb =  service.findStudentByPage(currentPage,rows,condition);
 
-        //将PageBean<Student>对象存入request域中
         request.setAttribute("pb",pb);
-<<<<<<< HEAD
-<<<<<<< HEAD
         request.setAttribute("condition",condition);//存入查询条件
-=======
-        //将查询条件存入request域中
-        request.setAttribute("condition",condition);//存入查询条件-
-        //设置request的字符编码为utf-8
->>>>>>> remotes/origin/develop
-=======
-        //将查询条件存入request域中
-        request.setAttribute("condition",condition);//存入查询条件-
-        //设置request的字符编码为utf-8
->>>>>>> remotes/origin/develop
         request.setCharacterEncoding("utf-8");
-        //获取session对象
         HttpSession session = request.getSession();
-        //从session中获取Student对象
         Student student= (Student)session.getAttribute("student");
 
-        // 从session中获取admin对象
         Admin admin= (Admin)session.getAttribute("admin");
-        // 从session中获取teacher对象
         Teacher teacher= (Teacher)session.getAttribute("teacher");
-        // 如果student对象不为空，admin对象为空，teacher对象为空，则跳转到student的查找学生列表页面
         if (student != null && admin == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/student/sFindStudentList.jsp").forward(request, response);
-        // 如果admin对象不为空，student对象为空，teacher对象为空，则跳转到admin的查找学生列表页面
         } else if (admin != null && student == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/admin/aFindStudentList.jsp").forward(request, response);
-        // 如果teacher对象不为空，admin对象为空，student对象为空，则跳转到teacher的查找学生列表页面
         } 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);
         }
@@ -82,79 +59,3 @@ public class FindStudentByPageServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.page;
-//
-//import domain.Admin;
-//import domain.PageBean;
-//import domain.Student;
-//import domain.Teacher;
-//import service.StudentService;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import java.io.IOException;
-//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");//每页显示条数
-//
-//        if (currentPage == null || "".equals(currentPage)) {
-//            currentPage = "1";
-//        }
-//        if (rows == null || "".equals(rows)) {
-//            rows = "5";
-//        }
-//
-//        //获取条件查询参数-
-//        Map<String,String[]> condition = request.getParameterMap();
-//
-//        //创建StudentService对象
-//        StudentService service = new StudentServiceImpl();
-//        //调用findStudentByPage方法，传入当前页码、每页显示的行数和查询条件，返回PageBean<Student>对象
-//        PageBean<Student> pb =  service.findStudentByPage(currentPage,rows,condition);
-//
-//        //将PageBean<Student>对象存入request域中
-//        request.setAttribute("pb",pb);
-//        //将查询条件存入request域中
-//        request.setAttribute("condition",condition);//存入查询条件-
-//        //设置request的字符编码为utf-8
-//        request.setCharacterEncoding("utf-8");
-//        //获取session对象
-//        HttpSession session = request.getSession();
-//        //从session中获取Student对象
-//        Student student= (Student)session.getAttribute("student");
-//
-//        // 从session中获取admin对象
-//        Admin admin= (Admin)session.getAttribute("admin");
-//        // 从session中获取teacher对象
-//        Teacher teacher= (Teacher)session.getAttribute("teacher");
-//        // 如果student对象不为空，admin对象为空，teacher对象为空，则跳转到student的查找学生列表页面
-//        if (student != null && admin == null && teacher == null) {
-//            request.getRequestDispatcher("/WEB-INF/student/sFindStudentList.jsp").forward(request, response);
-//        // 如果admin对象不为空，student对象为空，teacher对象为空，则跳转到admin的查找学生列表页面
-//        } else if (admin != null && student == null && teacher == null) {
-//            request.getRequestDispatcher("/WEB-INF/admin/aFindStudentList.jsp").forward(request, response);
-//        // 如果teacher对象不为空，admin对象为空，student对象为空，则跳转到teacher的查找学生列表页面
-//        } 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 {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/student/DeleteSelectStudentServlet.java

@@ -23,39 +23,3 @@ public class DeleteSelectStudentServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.student;
-//
-//import service.StudentService;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import 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");
-//    }
-//
-//    // 处理GET请求，直接调用doPost方法
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request, response);
-//    }
-//}

src/web/servlet/student/DeleteStudentServlet.java

@@ -29,50 +29,3 @@ public class DeleteStudentServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.student;
-//
-//import service.NotifyService;
-//import service.StudentService;
-//import service.impl.NotifyServiceImpl;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import 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);
-//
-//        // 重定向到查找学生的页面
-//        response.sendRedirect("findStudentByPageServlet");
-//        // 如果需要使用转发，可以使用下面的代码
-//        // request.getRequestDispatcher("/findStudentByPageServlet").forward(request, response);
-//    }
-//
-//    // 处理GET请求，直接调用doPost方法
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request, response);
-//    }
-//}

src/web/servlet/student/DoSelectCourseServlet.java

@@ -61,76 +61,3 @@ public class DoSelectCourseServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.student;
-//
-//import domain.Course;
-//import domain.SelectCourse;
-//import domain.Student;
-//import service.StudentService;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import java.io.IOException;
-//import java.util.Date;
-//import java.util.List;
-//
-//@WebServlet("/doSelectCourseServlet")
-//public class DoSelectCourseServlet 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");
-//        String courseid = request.getParameter("id");
-//        //存不存在已选该课
-//        //1
-//        //2
-//        //3
-//        //4
-//        //5
-//        //6
-//        //7
-//        //8
-//        //9
-//        //0
-//        boolean flag = false;
-//
-//        //判断是否已选
-//        StudentService studentService = new StudentServiceImpl();
-//        List<SelectCourse> selectcourses = studentService.findAllSelectCourse(student.getS_id());
-//        for (SelectCourse s:selectcourses) {
-//            if (s.getC_id().equals(courseid)) {
-//                flag = true;
-//                break;
-//            }
-//        }
-//        if (flag == true) {
-//
-//            request.setAttribute("select_msg", "你已选了该课程！" + String.format("%tT", new Date()));
-//            request.getRequestDispatcher("studentOptionalCourseServlet").forward(request, response);
-////            response.sendRedirect("studentOptionalCourseServlet");
-//        } else {
-//            //获取到当前学生id
-//            String studentid = student.getS_id();
-//
-//            //获取当前行的课程id courseid
-//
-//            //调用学生添加选课服务s_id c_id score  select_course添加
-//            StudentService Service = new StudentServiceImpl();
-//            Service.addSelectCourse(studentid,courseid);
-//
-//            //完成后给提示跳转
-//            request.setAttribute("select_msg", "选课成功！" + String.format("%tT", new Date()));
-//            request.getRequestDispatcher("studentOptionalCourseServlet").forward(request, response);
-//        }
-//
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/student/StudentInfomationUpdateServlet.java

@@ -20,33 +20,16 @@ public class StudentInfomationUpdateServlet extends HttpServlet {
 
         request.setCharacterEncoding("utf-8");
 
-<<<<<<< HEAD
         //保存输入内容
-=======
-        //保存输入内容-
-        // 获取学生ID
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
         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();
@@ -59,33 +42,16 @@ public class StudentInfomationUpdateServlet extends HttpServlet {
             request.getRequestDispatcher("/WEB-INF/student/sInformation.jsp").forward(request, response);
 //            response.sendRedirect("studentInfomationServlet");
         }else {
-<<<<<<< HEAD
             //封装学生对象
-=======
-            //封装学生对象-
-            // 设置学生ID
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
             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服务
@@ -108,119 +74,3 @@ public class StudentInfomationUpdateServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.student;
-//
-//import domain.Student;
-//import service.StudentService;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import java.io.IOException;
-//import java.text.SimpleDateFormat;
-//import java.util.Date;
-//
-//@WebServlet("/studentInfomationUpdateServlet")
-//public class StudentInfomationUpdateServlet extends HttpServlet {
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//
-//        request.setCharacterEncoding("utf-8");
-//
-//        //保存输入内容-
-//        // 获取学生ID
-//        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");
-//        //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 {
-//            //封装学生对象-
-//            // 设置学生ID
-//            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);
-//            //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服务-
-//            StudentService service= new StudentServiceImpl();
-//            service.updateInfo(updateStudent);
-//
-//            HttpSession session = request.getSession();
-//
-//            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);
-//        }
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        doPost(request,response);
-//    }
-//}

src/web/servlet/student/StudentListServlet.java

@@ -26,24 +26,16 @@ public class StudentListServlet extends HttpServlet {
 
         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/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);
         }
@@ -53,71 +45,3 @@ public class StudentListServlet extends HttpServlet {
         this.doPost(request,response);
     }
 }
-//package web.servlet.student;
-//
-//import domain.Admin;
-//import domain.Student;
-//import domain.Teacher;
-//import service.StudentService;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import java.io.IOException;
-//import java.util.List;
-//
-//@WebServlet("/studentListServlet")
-//public class StudentListServlet extends HttpServlet {
-//    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        //调用StudentService完成查询-
-//        StudentService studentService = new StudentServiceImpl();
-//        List<Student> students = studentService.findAll();
-//        //将list存入request域-
-//        request.setAttribute("students",students);
-//
-//        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/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);
-//        }
-//    }
-//    //   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

@@ -18,15 +18,10 @@ import java.util.List;
 
 @WebServlet("/studentOptionalCourseServlet")
 public class StudentOptionalCourseServlet 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");
-        // 从会话中获取管理员对象
         Admin admin =(Admin)session.getAttribute("admin");
 
         //调用StudentService完成查询
@@ -36,13 +31,10 @@ public class StudentOptionalCourseServlet extends HttpServlet {
         request.setAttribute("optionalcourses",optionalcourses);
         //转发到list.jsp
 
-        // 如果student不为空且admin为空，则跳转到studentOptionalCourse.jsp页面
         if (student != null && admin == null) {
             request.getRequestDispatcher("/WEB-INF/student/studentOptionalCourse.jsp").forward(request,response);
-        // 如果admin不为空且student为空，则跳转到allStudentOptionalCourse.jsp页面
         } else if (admin != null && student == null) {
             request.getRequestDispatcher("/WEB-INF/admin/allStudentOptionalCourse.jsp").forward(request, response);
-        // 否则跳转到error.jsp页面
         } else {
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
@@ -53,65 +45,3 @@ public class StudentOptionalCourseServlet extends HttpServlet {
         this.doPost(request,response);
     }
 }
-//package web.servlet.student;
-//
-//import domain.Admin;
-//import domain.Course;
-//import domain.SelectCourse;
-//import domain.Student;
-//import service.StudentService;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import java.io.IOException;
-//import java.util.List;
-//
-//@WebServlet("/studentOptionalCourseServlet")
-//public class StudentOptionalCourseServlet 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");
-//        // 从会话中获取管理员对象
-//        Admin admin =(Admin)session.getAttribute("admin");
-//
-//        //调用StudentService完成查询-
-//        StudentService studentService = new StudentServiceImpl();
-//        List<Course> optionalcourses = studentService.findAllOptionalCourse();
-//        //将list存入request域-
-//        request.setAttribute("optionalcourses",optionalcourses);
-//        //转发到list.jsp-
-//
-//        // 如果student不为空且admin为空，则跳转到studentOptionalCourse.jsp页面
-//        if (student != null && admin == null) {
-//            request.getRequestDispatcher("/WEB-INF/student/studentOptionalCourse.jsp").forward(request,response);
-//        // 如果admin不为空且student为空，则跳转到allStudentOptionalCourse.jsp页面
-//        } else if (admin != null && student == null) {
-//            request.getRequestDispatcher("/WEB-INF/admin/allStudentOptionalCourse.jsp").forward(request, response);
-//        // 否则跳转到error.jsp页面
-//        } 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);
-//        //        }
-//
-//    }
-//
-//    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-//        this.doPost(request,response);
-//    }
-//}

src/web/servlet/student/StudentPasswordUpdateServlet.java

@@ -16,53 +16,30 @@ import java.util.Date;
 @WebServlet("/studentPasswordUpdateServlet")
 public class StudentPasswordUpdateServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-<<<<<<< HEAD
-=======
-        // 设置请求的字符编码为UTF-8，以支持中文
-        // 设置请求的字符编码为utf-8
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
         request.setCharacterEncoding("utf-8");
-        // 获取当前会话
         HttpSession session = request.getSession();
-        // 从会话中获取学生对象
         Student student= (Student)session.getAttribute("student");
 
-        // 获取学生id
         String studentid = student.getS_id();
-        // 获取新密码
         String newpassword = request.getParameter("student-newpassword");
-        // 获取确认新密码
         String ennewpassword = request.getParameter("student-ennewpassword");
-        // 定义正则表达式，匹配3-12位字母、数字、下划线
         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
             session.setAttribute("student",student);
 
-            // 设置成功信息，并跳转到修改密码页面
             request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
             request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request, response);
         }
@@ -73,103 +50,3 @@ public class StudentPasswordUpdateServlet extends HttpServlet {
         doPost(request,response);
     }
 }
-//package web.servlet.student;
-//
-//import domain.Student;
-//import service.StudentService;
-//import service.impl.StudentServiceImpl;
-//
-//import javax.servlet.ServletException;
-//import javax.servlet.annotation.WebServlet;
-//import javax.servlet.http.HttpServlet;
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//import javax.servlet.http.HttpSession;
-//import 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，以支持中文
-//        // 设置请求的字符编码为utf-8
-//        request.setCharacterEncoding("utf-8");
-//        // 获取当前会话
-//        HttpSession session = request.getSession();
-//        // 从会话中获取学生对象
-//        Student student= (Student)session.getAttribute("student");
-//
-//        // 获取学生id
-//        String studentid = student.getS_id();
-//        // 获取新密码
-//        String newpassword = request.getParameter("student-newpassword");
-//        // 获取确认新密码
-//        String ennewpassword = request.getParameter("student-ennewpassword");
-//        // 定义正则表达式，匹配3-12位字母、数字、下划线
-//        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
-//            session.setAttribute("student",student);
-//
-//            // 设置成功信息，并跳转到修改密码页面
-//            request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
-//            request.getRequestDispatcher("/WEB-INF/student/studentUpdatePassword.jsp").forward(request, response);
-//        }
-//
-//    }
-//    //  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

@@ -18,16 +18,11 @@ import java.util.List;
 
 @WebServlet("/studentSelectCourseListServlet")
 public class StudentSelectCourseListServlet 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");
-        // 从会话中获取管理员对象
         Admin admin =(Admin)session.getAttribute("admin");
 
         //调用StudentService完成查询
@@ -36,23 +31,13 @@ public class StudentSelectCourseListServlet extends HttpServlet {
             List<SelectCourse> selectcourses = studentService.findAllSelectCourse(student.getS_id());
             //将list存入request域
             request.setAttribute("selectcourses",selectcourses);
-<<<<<<< HEAD
             //转发到list.jsp
-=======
-            //转发到list.jsp-
-            // 如果学生不为空，则跳转到学生选课列表页面
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
             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);
         }
 

src/web/servlet/teacher/AddOptionalCourseServlet.java

@@ -28,24 +28,15 @@ public class AddOptionalCourseServlet extends HttpServlet {
 
         CourseService service = new CourseServiceImpl();
         Course course =  service.findSelectCourseByCourseId(cid);
-        // 判断课程是否为空
         if (course != null) {
-            // 设置请求属性，提示课程ID冲突
             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();
-            // 设置课程ID
             newCourse.setC_id(cid);
-            // 设置课程名称
             newCourse.setC_name(cname);
-            // 设置课程信息
             newCourse.setC_info(cinfo);
-            // 设置教师ID
             newCourse.setT_id(teacher.getT_id());
-            // 设置教师名称
             newCourse.setT_name(teacher.getT_name());
 
             service.addOptionalCourse(newCourse);

src/web/servlet/teacher/TeacherListServlet.java

@@ -26,26 +26,17 @@ public class TeacherListServlet extends HttpServlet {
         //将list存入request域
         request.setAttribute("teachers",teachers);
 
-        // 设置请求的字符编码为utf-8
         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);
         }

src/web/servlet/teacher/TeacherOptionalCourseServlet.java

@@ -19,15 +19,10 @@ import java.util.List;
 
 @WebServlet("/teacherOptionalCourseServlet")
 public class TeacherOptionalCourseServlet extends HttpServlet {
-    // 处理POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        // 设置请求编码为utf-8
         request.setCharacterEncoding("utf-8");
-        // 获取当前会话
         HttpSession session = request.getSession();
-        // 从会话中获取教师对象
         Teacher t = (Teacher) session.getAttribute("teacher");
-        // 如果教师对象不为空
         if (t != null) {
             //调用StudentService完成查询
             TeacherService service = new TeacherServiceImpl();

src/web/servlet/teacher/TeacherPasswordUpdateServlet.java

@@ -19,60 +19,31 @@ import java.util.Date;
 @WebServlet("/teacherPasswordUpdateServlet")
 public class TeacherPasswordUpdateServlet extends HttpServlet {
     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");
 
-        // 获取教师ID
         String teacherid = teacher.getT_id();
-<<<<<<< HEAD
-=======
-        //3
-        // 获取新密码
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
         String newpassword = request.getParameter("teacher-newpassword");
-        // 获取确认新密码
         String ennewpassword = request.getParameter("teacher-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/teacher/teacherUpdatePassword.jsp").forward(request, response);
-        // 如果新密码和确认新密码不一致
         } else if (!newpassword.equals(ennewpassword)) {
-            // 设置错误信息
             request.setAttribute("update_msg", "密码确认错误，请重新提交！" + String.format("%tT", new Date()));
-            // 转发到修改密码页面
             request.getRequestDispatcher("/WEB-INF/teacher/teacherUpdatePassword.jsp").forward(request, response);
-        // 如果新密码和确认新密码一致
         } else {
 
-            // 创建TeacherService对象
             TeacherService service= new TeacherServiceImpl();
-            // 调用updatePassword方法，更新密码
             service.updatePassword(teacherid,newpassword);
 
-            // 根据teacherid查找新的Teacher对象
             Teacher newTeacher = service.findTeacherById(teacher);
-            // 将新的Teacher对象赋值给teacher
             teacher = newTeacher;
-            // 将teacher对象存入session中
             session.setAttribute("teacher",teacher);
 
-            // 设置update_msg属性，提示修改成功
             request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
-            // 转发到teacherUpdatePassword.jsp页面
             request.getRequestDispatcher("/WEB-INF/teacher/teacherUpdatePassword.jsp").forward(request, response);
         }
 

src/web/servlet/teacher/UpdateOptionalCourseScoreServlet.java

@@ -23,42 +23,28 @@ import java.util.Date;
 @WebServlet("/updateOptionalCourseScoreServlet")
 public class UpdateOptionalCourseScoreServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        // 设置请求编码为utf-8
         request.setCharacterEncoding("utf-8");
 
-        // 获取请求参数
         String cid = request.getParameter("cid");
         String sid = request.getParameter("sid");
         String sScore = request.getParameter("student-score");
-        // 创建学生服务对象
         StudentService service = new StudentServiceImpl();
-        // 创建课程服务对象
         CourseService service1 = new CourseServiceImpl();
-        // 创建选课服务对象
         SelectCourseService service2 = new SelectCourseServiceImpl();
 
-        // 根据课程id和学生id更新学生成绩
         service2.upDateScoreByCidAndSid(cid,sid,sScore);
 
-        //创建一个Student对象
         Student student = new Student();
-        //设置Student对象的id
         student.setS_id(sid);
 
-        //根据Student对象的id查找学生信息
         Student s = service.findStudentById(student);
-        //根据课程id查找选课信息
         Course c = service1.findSelectCourseByCourseId(cid);
-        //根据课程id和学生id查找成绩信息
         SelectCourse sc = service2.findScoreByCourseIdAndStudentId(cid,sid);
 
-        //将学生信息、选课信息和成绩信息存入request对象中
         request.setAttribute("s",s);
         request.setAttribute("c",c);
         request.setAttribute("sc",sc);
-        //设置修改分数成功的提示信息
         request.setAttribute("update_msg","修改分数成功！"+String.format("%tT",new Date()));
-        //转发到updateOptionalCourseScore.jsp页面
         request.getRequestDispatcher("/WEB-INF/teacher/updateOptionalCourseScore.jsp").forward(request,response);
     }
 

src/web/servlet/teacher/UpdateScoreServlet.java

@@ -20,45 +20,24 @@ import java.io.IOException;
 @WebServlet("/updateScoreServlet")
 public class UpdateScoreServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-<<<<<<< HEAD
-=======
-        //中文
-        // 设置请求的字符编码为utf-8
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
         request.setCharacterEncoding("utf-8");
-        // 获取请求参数cid
         String cid = request.getParameter("cid");
-        // 获取请求参数sid
         String sid = request.getParameter("sid");
 
-        // 创建StudentService对象
         StudentService service = new StudentServiceImpl();
-        // 创建Student对象
         Student student = new Student();
-        // 设置Student对象的s_id属性
         student.setS_id(sid);
-        // 根据Student对象的s_id属性查找学生信息
-        // 根据学生id查找学生信息
         Student s = service.findStudentById(student);
 
-        // 创建CourseServiceImpl对象
         CourseService service1 = new CourseServiceImpl();
-        // 根据课程id查找选课信息
         Course c = service1.findSelectCourseByCourseId(cid);
 
-        // 创建SelectCourseServiceImpl对象
         SelectCourseService service2 = new SelectCourseServiceImpl();
-        // 根据课程id和学生id查找成绩信息
         SelectCourse sc = service2.findScoreByCourseIdAndStudentId(cid,sid);
 
-        // 将学生信息、选课信息和成绩信息存入request对象中
         request.setAttribute("s",s);
         request.setAttribute("c",c);
         request.setAttribute("sc",sc);
-        // 转发到updateOptionalCourseScore.jsp页面
         request.getRequestDispatcher("/WEB-INF/teacher/updateOptionalCourseScore.jsp").forward(request,response);
     }
 

src/web/servlet/teacher/UpdateTeacherInfoServlet.java

@@ -16,36 +16,19 @@ import java.util.Date;
 
 @WebServlet("/updateTeacherInfoServlet")
 public class UpdateTeacherInfoServlet extends HttpServlet {
-    // 处理POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        // 设置请求编码为utf-8
         request.setCharacterEncoding("utf-8");
-        // 获取教师ID
         String tid = request.getParameter("teacher-id");
 
-        // 获取教师姓名
         String name = request.getParameter("teacher-name");
-        // 获取教师性别
         String sex = request.getParameter("teacher-sex");
-        // 获取教师学历
         String education = request.getParameter("teacher-education");
-        // 获取教师职称
         String title = request.getParameter("teacher-title");
 
         Teacher updateTeacher = new Teacher();
-<<<<<<< HEAD
         //判断输入位数是否大于数据库位数
-=======
-        //判断输入位数是否大于数据库位数-
-        //判断输入的姓名、学历、职称是否合法
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
         if (name.length() > 4 || education.length() > 20 || title.length()>24 || name.contains("<") || education.contains("<") || title.contains("<")) {
-            //将错误信息存入request对象中
             request.setAttribute("update_msg","格式错误，请重新提交！"+String.format("%tT",new Date()));
-            //转发到updateTeacherServlet页面
             request.getRequestDispatcher("updateTeacherServlet?tid="+tid).forward(request, response);
         }else {
             //封装教师对象

src/web/servlet/teacher/UpdateTeacherOptionalCourseServlet.java

@@ -17,27 +17,13 @@ import java.util.List;
 public class UpdateTeacherOptionalCourseServlet extends HttpServlet {
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
-<<<<<<< HEAD
 //        HttpSession session = request.getSession();
-=======
-//        HttpSession session = request.getSession();-
-        // 获取请求参数中的课程ID
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
         String cid = (String)request.getParameter("cid");
-        // 创建TeacherService对象
         TeacherService service = new TeacherServiceImpl();
-        // 根据课程ID查找可选课程
         Course c = service.findOptionalCourseByCourseId(cid);
-        // 将课程对象存入请求属性中
         request.setAttribute("course",c);
-        // 输出课程ID
         System.out.println(c.getC_id());
-        // 输出课程名称
         System.out.println(c.getC_name());
-        // 输出课程信息
         System.out.println(c.getC_info());
 
         request.getRequestDispatcher("/WEB-INF/teacher/updateTeacherOptionalCourseInfo.jsp").forward(request,response);

src/web/servlet/teacher/UpdateTeacherServlet.java

@@ -22,24 +22,15 @@ import java.util.List;
 
 @WebServlet("/updateTeacherServlet")
 public class UpdateTeacherServlet 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 teacherid = request.getParameter("tid");
 
-        // 创建教师对象
         Teacher teacher = new Teacher();
-        // 设置教师id
         teacher.setT_id(teacherid);
-        // 创建教师服务对象
         TeacherService service = new TeacherServiceImpl();
-        // 根据教师id查找教师信息
         Teacher newTeacher = service.findTeacherById(teacher);
-        // 将教师信息存入请求属性中
         request.setAttribute("teacher",newTeacher);
 
         CDCService service2 = new CDCServiceImpl();
@@ -47,7 +38,6 @@ public class UpdateTeacherServlet extends HttpServlet {
         List<CDC> departmentList = service2.findAllDepartment();
         List<CDC> classList = service2.findAllClass();
 
-        //将collegeList、departmentList、classList放入session中
         session.setAttribute("collegeLists",collegeList);
         session.setAttribute("departmentLists",departmentList);
         session.setAttribute("classLists",classList);

text.iml

@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-<<<<<<< HEAD
-<<<<<<< HEAD
-=======
-=======
->>>>>>> remotes/origin/develop
-  <component name="FacetManager">
-    <facet type="web" name="Web">
-      <configuration>
-        <descriptors>
-          <deploymentDescriptor name="web.xml" url="file://$MODULE_DIR$/web/WEB-INF/web.xml" />
-        </descriptors>
-        <webroots>
-          <root url="file://$MODULE_DIR$/web" relative="/" />
-        </webroots>
-      </configuration>
-    </facet>
-  </component>
-<<<<<<< HEAD
->>>>>>> remotes/origin/develop
-=======
->>>>>>> remotes/origin/develop
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="lib" level="project" />
-  </component>
-</module>

web/css/file.css

@@ -1,198 +1,54 @@
-/*
-.progress类用于定义一个具有特定样式的进度条容器元素。以下是对该类中各个样式属性的详细注释：
-*/
-.progress {
-    /*
-    设置元素的上外边距为2像素，使该元素与上方元素在垂直方向上保持一定的间隔距离，增加页面布局的层次感。
-    */
-    margin-top: 2px;
-    /*
-    定义元素的宽度为200像素，确定了进度条在水平方向上所占据的空间大小。
-    */
+.progress{
+    margin-top:2px;
     width: 200px;
-    /*
-    设置元素的高度为14像素，规定了进度条在垂直方向上的尺寸。
-    */
     height: 14px;
-    /*
-    设置元素的下外边距为10像素，让该元素与下方元素在垂直方向上隔开一定距离，避免布局显得过于紧凑。
-    */
     margin-bottom: 10px;
-    /*
-    将溢出的内容隐藏起来，防止内部元素超出该容器的范围而显示异常，确保进度条的外观整洁、规范。
-    */
     overflow: hidden;
-    /*
-    设置元素的背景颜色为#f5f5f5，这是一种浅灰色，通常用于给元素提供一个较为柔和、中性的背景色调，符合常见的页面设计风格。
-    */
     background-color: #f5f5f5;
-    /*
-    给元素添加圆角效果，这里将四个角的半径都设置为4像素，使元素看起来更加圆润、美观，避免生硬的直角边框，提升视觉效果。
-    */
     border-radius: 4px;
-    /*
-    以下是针对WebKit浏览器（如Chrome、Safari等）添加的内部阴影效果，用于在元素内部营造出一种立体感。
-    inset关键字表示这是内部阴影，0 1px 2px表示阴影在水平方向不偏移、垂直方向偏移1像素、模糊半径为2像素，rgba(0,0,0,.1)表示阴影的颜色为黑色且透明度为0.1，整体效果是给元素内部添加一个淡淡的阴影，增强层次感。
-    */
-    -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0,.1);
-    /*
-    与上面的-webkit-box-shadow类似，这是标准的CSS盒阴影属性，用于在不支持WebKit前缀的浏览器中也能实现相同的内部阴影效果，确保在不同浏览器下的视觉一致性。
-    */
-    box-shadow: inset 0 1px 2px rgba(0, 0, 0,.1);
+    -webkit-box-shadow: inset 0 1px 2px rgba(0,0,0,.1);
+    box-shadow: inset 0 1px 2px rgba(0,0,0,.1);
 }
-
-/*
-.progress-bar类用于定义进度条内部的填充部分（表示进度的可视化部分）的样式，以下是对该类各样式属性的详细解释：
-*/
-.progress-bar {
-    /*
-    设置进度条填充部分的背景颜色为rgb(92, 184, 92)，这是一种绿色调，通常用于表示进度的增长、完成等积极的含义，符合常见的进度条颜色使用习惯。
-    */
+.progress-bar{
     background-color: rgb(92, 184, 92);
-    /*
-    使用线性渐变来为背景添加一种纹理效果，使进度条看起来更有质感。
-    linear-gradient函数用于创建线性渐变，45deg表示渐变的方向是从左下角到右上角呈45度角，后面跟着一系列的颜色停止点及透明度设置。
-    例如rgba(255, 255, 255, 0.14902) 25%, transparent 25%表示在渐变的25%位置处使用具有一定透明度的白色，然后在25%位置切换到透明色，以此类推，通过这样的设置形成一种斜向的条纹纹理效果，增强视觉上的丰富度。
-    */
     background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.14902) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.14902) 50%, rgba(255, 255, 255, 0.14902) 75%, transparent 75%, transparent);
-    /*
-    定义背景图像（这里就是上面设置的线性渐变纹理）的尺寸大小为40px 40px，即宽度和高度都为40像素，控制纹理的疏密程度等外观效果。
-    */
     background-size: 40px 40px;
-    /*
-    给进度条填充部分添加一个下边框的内部阴影效果，使进度条看起来有一定的凹陷感，增强立体感。
-    rgba(0, 0, 0, 0.14902)表示阴影颜色为黑色且具有一定透明度，0px -1px 0px 0px表示阴影在水平方向不偏移、垂直方向向上偏移1px、模糊半径为0px、扩展半径为0px，inset表示这是内部阴影，整体效果是在进度条填充部分的底部添加一条很细的阴影线。
-    */
     box-shadow: rgba(0, 0, 0, 0.14902) 0px -1px 0px 0px inset;
-    /*
-    设置元素的盒模型计算方式为 border-box，意味着元素的宽度和高度包含了边框（border）和内边距（padding）的尺寸，这样在设置元素的尺寸以及添加边框、内边距时，不会导致元素整体尺寸超出预期，方便进行布局控制。
-    */
     box-sizing: border-box;
-    /*
-    设置元素内文本的颜色为白色（rgb(255, 255, 255)），通常进度条填充部分上可能会显示进度相关的文字信息（比如百分比等），这里将文字颜色设置为白色，使其在背景颜色上能够清晰显示。
-    */
     color: rgb(255, 255, 255);
-    /*
-    将元素设置为块级元素，使其在页面布局中独占一行，并且可以设置宽度、高度、内外边距等属性，像一个独立的矩形区域一样进行布局排版，符合进度条填充部分作为一个独立的可视化组件的布局需求。
-    */
     display: block;
-    /*
-    使元素向左浮动，让多个进度条（如果存在多个的情况）可以在同一行内水平排列，实现多个进度条并列展示的布局效果，常用于同时展示多个任务或阶段的进度情况。
-    */
     float: left;
-    /*
-    设置元素内文本的字体大小为12像素，控制进度条上显示文字的大小，确保文字在进度条填充部分内的显示比例合适，清晰可读。
-    */
     font-size: 12px;
-    /*
-    设置元素的行高为20像素，行高通常会影响文本在垂直方向上的对齐方式以及元素的整体高度感受，这里设置合适的行高可以让文本在进度条填充部分内垂直居中显示，视觉效果更美观。
-    */
+    height: 20px;
     line-height: 20px;
-    /*
-    设置文本在元素内的水平对齐方式为居中对齐，使得进度条上显示的文字（如进度百分比等）能够在水平方向上处于进度条填充部分的中间位置，看起来更加整齐、规范。
-    */
     text-align: center;
-    /*
-    设置过渡效果的延迟时间为0秒，即当触发过渡相关的变化（比如进度条宽度改变等情况）时，立即开始过渡动画，没有延迟。
-    */
     transition-delay: 0s;
-    /*
-    设置过渡效果的持续时间为0.6秒，规定了从初始状态到目标状态（比如进度条宽度变化等过渡情况）整个过渡动画所花费的时间长度，通过合适的时长设置可以让过渡效果看起来更加自然流畅。
-    */
     transition-duration: 0.6s;
-    /*
-    指定过渡效果应用的CSS属性为宽度（width），意味着只有当元素的宽度发生变化时，才会触发设置好的过渡动画效果，比如进度条宽度随进度增加而增长时会有平滑的过渡动画展示。
-    */
     transition-property: width;
-    /*
-    设置过渡效果的时间函数为ease，这是一种常见的缓动函数，它使得过渡动画在开始时较慢，中间加速，结尾时再变慢，让过渡效果更加自然、柔和，符合人眼观察物体运动变化的习惯，提升视觉体验。
-    */
     transition-timing-function: ease;
-    /*
-    设置元素的初始宽度为266.188像素，这个宽度值可能是根据具体的页面布局需求或者默认进度情况来设定的，后续可以通过JavaScript等方式根据实际进度动态改变该宽度值来展示进度变化效果。
-    */
     width: 266.188px;
 }
 
-/*
-.file类用于定义一个类似文件上传按钮或链接的样式，具有特定的外观和交互效果，以下是对该类各属性的注释：
-*/
 .file {
-    /*
-    将元素设置为相对定位，相对定位的元素会相对于其原本在文档流中的位置进行定位调整，方便后续通过top、right、bottom、left等属性对其内部绝对定位的子元素（如下面的input元素）进行精准定位，同时又不会脱离文档流影响整体布局。
-    */
     position: relative;
-    /*
-    将元素设置为内联块级元素，它既有内联元素的特点（可以与其他内联元素在同一行显示），又具备块级元素的一些特性（可以设置宽度、高度、内外边距等属性），这样可以方便地在文本流中按照需求排列，并且呈现出类似按钮或链接的外观样式。
-    */
     display: inline-block;
-    /*
-    设置元素的背景颜色为#337ab7，这是一种蓝色调，常用于表示可操作、交互的元素背景色，给用户传达一种可以点击、进行操作的视觉暗示。
-    */
     background-color: #337ab7;
-    /*
-    给元素添加圆角效果，将四个角的半径都设置为4像素，使其外观更加圆润、美观，符合现代网页设计中对于按钮等元素的常见样式风格，避免生硬的直角边框。
-    */
     border-radius: 4px;
-    /*
-    设置元素的内边距，上下内边距为8像素，左右内边距为12像素，通过合适的内边距设置可以让元素内部的文本（如按钮上的文字说明等）与边框之间有一定的空白空间，看起来更加舒适、美观，也便于用户点击操作。
-    */
     padding: 8px 12px;
-    /*
-    将溢出的内容隐藏起来，防止内部元素（比如可能存在的一些特殊样式的子元素等）超出该元素的范围而显示异常，确保元素外观的完整性和规范性。
-    */
     overflow: hidden;
-    /*
-    设置元素内文本的颜色为白色（#FFFFFF），使得文本在背景颜色上能够清晰显示，提高可读性，符合常见的按钮或链接文本颜色与背景色搭配习惯，让用户能够轻易识别元素上的文字内容。
-    */
     color: #FFFFFF;
-    /*
-    清除元素的文本装饰（比如默认的下划线等），如果该元素用于模拟按钮等交互功能，通常不需要文本有下划线等装饰，使其外观更简洁、干净，符合操作按钮的视觉风格。
-    */
     text-decoration: none;
-    /*
-    设置文本的缩进为0，确保文本在元素内按照正常的对齐方式从左边开始显示，没有额外的缩进效果，保持文本显示的规范性。
-    */
     text-indent: 0;
-    /*
-    设置元素的行高为20像素，与上面类似，合适的行高可以让文本在垂直方向上处于合适的位置，视觉效果更美观，并且方便用户查看和点击操作。
-    */
     line-height: 20px;
 }
-
-/*
-.file类下的input子元素的样式定义，通常用于隐藏实际的文件选择输入框，通过其他样式和交互设计来模拟一个更美观、易用的文件上传操作界面，以下是对该子元素样式属性的注释：
-*/
 .file input {
-    /*
-    将元素设置为绝对定位，绝对定位的元素会脱离文档流，根据最近的已定位祖先元素（这里就是上面设置为相对定位的.file元素）来进行定位，通过下面设置的right和top属性，可以将其精准定位到.file元素的右上角位置，方便实现隐藏式的文件选择功能（因为它覆盖在可视区域之外）。
-    */
     position: absolute;
-    /*
-    设置元素的字体大小为100px，这个较大的字体大小可能是为了确保在某些特殊情况下（比如不同浏览器对文件选择输入框默认样式的处理差异等）能够完全覆盖住原有的输入框外观，实现更好的隐藏效果，具体使用场景和原因可能因整体页面设计需求而定。
-    */
     font-size: 100px;
-    /*
-    将元素定位到其相对定位的父元素（.file元素）的右上角，right: 0表示距离父元素右侧边界为0像素，top: 0表示距离父元素顶部边界为0像素，这样就将其放置在了父元素的右上角位置，超出了可视范围，达到隐藏的目的。
-    */
     right: 0;
     top: 0;
-    /*
-    设置元素的透明度为0，使其完全透明不可见，进一步隐藏实际的文件选择输入框，让用户只能通过模拟的按钮或链接外观（即.file元素呈现的样式）来触发文件选择操作，提升用户体验和页面美观度。
-    */
     opacity: 0;
 }
-
-/*
-.file类元素在鼠标悬停时的样式变化，通过改变背景颜色来提供一种交互反馈效果，让用户知道该元素是可以进行操作的，以下是对应的注释：
-*/
 .file:hover {
-    /*
-    当鼠标悬停在.file元素上时，改变其背景颜色为#598FBE，这是一种比原来稍深一点的蓝色调，通过这种颜色变化给用户一个视觉提示，表明该元素处于可交互状态，增强用户操作的直观性和交互性。
-    */
     background: #598FBE;
-    /*
-    再次强调清除文本装饰（比如悬停时也不出现下划线等），保持元素外观的简洁性和一致性，符合操作按钮在不同状态下的视觉规范。
-    */
     text-decoration: none;
 }

web/css/login.css

@@ -1,19 +1,11 @@
-/*
- * @charset "utf-8";
- * 声明该CSS文件使用的字符编码为utf-8，确保能正确解析文件中的各种字符，包括中文等特殊字符。
- */
+@charset "utf-8";
 
 body {
     background: url("../images/bg.jpg");
-    /* 设置页面背景图片的路径，这里图片位于相对于当前CSS文件的images文件夹下，文件名为bg.jpg */
     background-position: center;
-    /* 让背景图片在水平和垂直方向都居中显示 */
     background-size: cover;
-    /* 使背景图片自适应铺满整个页面可视区域，可能会根据页面尺寸拉伸或缩放图片以完全覆盖 */
     padding-bottom: 0px;
-    /* 将body元素底部的内边距设置为0像素，控制页面底部空白区域大小等布局效果 */
 }
-
 .layadmin-user-login-icon {
     position: absolute;
     left: 1px;
@@ -22,22 +14,7 @@ body {
     line-height: 36px;
     text-align: center;
     color: #d2d2d2;
-    /*
-     * 以下是对该类选择器样式的详细解释：
-     * position: absolute; 将元素设置为绝对定位，它会相对于最近的已定位祖先元素（如果没有则相对于html元素）来确定位置。
-     * left: 1px; 元素距离左侧边界1像素的距离。
-     * top: 1px; 元素距离顶部边界1像素的距离。
-     * width: 38px; 设置元素的宽度为38像素。
-     * line-height: 36px; 定义行高为36像素，影响文本在垂直方向上的排版。
-     * text-align: center; 让元素内部的文本在水平方向居中对齐。
-     * color: #d2d2d2; 设置文本的颜色为指定的灰色（十六进制颜色值表示）。
-     */
 }
-
-.login-main.layui-input {
+.login-main .layui-input {
     padding-left: 38px;
-    /*
-     * 选择类名为login-main下的所有拥有layui-input类的元素，给它们设置左侧内边距为38像素，
-     * 可能是为了给这些输入框等元素预留一定的空间，比如放置图标之类的元素。
-     */
 }

web/css/style.css

@@ -1,10 +1,6 @@
-/*
- * @charset "utf-8";
- * 声明该CSS文件使用的字符编码为utf-8，确保文件中的各种字符（如中文等）能被正确解析和显示。
- */
+@charset "utf-8";
 
-/* 针对layui布局下的自定义头部样式 */
-.layui-layout-admin.my-header {
+.layui-layout-admin .my-header {
     position: fixed;
     top: 0;
     left: 0;
@@ -12,19 +8,9 @@
     height: 60px;
     background: #393D49;
     z-index: 2;
-    /*
-     * position: fixed; 将元素固定定位，使其相对于浏览器窗口固定位置，不会随页面滚动而移动。
-     * top: 0; 距离浏览器窗口顶部0像素，即紧贴顶部显示。
-     * left: 0; 距离浏览器窗口左侧0像素，即从最左边开始显示。
-     * width: 100%; 占据整个浏览器窗口的宽度。
-     * height: 60px; 设置头部高度为60像素。
-     * background: #393D49; 定义头部的背景颜色为指定的深灰色（十六进制颜色值表示）。
-     * z-index: 2; 设置元素的堆叠顺序，值越大越在上面，这里确保头部在一些其他元素之上显示。
-     */
-}
-
-/* layui布局下头部中自定义的logo样式 */
-.layui-layout-admin.my-header.my-header-logo {
+}
+
+.layui-layout-admin .my-header .my-header-logo {
     display: inline-block;
     width: auto;
     height: 30px;
@@ -33,60 +19,31 @@
     line-height: 30px;
     padding: 15px;
     vertical-align: top;
-    /*
-     * display: inline-block; 让元素以行内块级元素显示，既能像行内元素一样在一行排列，又能设置宽高。
-     * width: auto; 宽度自动适应内容宽度。
-     * height: 30px; 设置元素高度为30像素。
-     * color: white; 设置文本颜色为白色，与深色背景形成对比。
-     * font-size: 18px; 定义文本字号为18像素。
-     * line-height: 30px; 行高与元素高度一致，使文本垂直居中。
-     * padding: 15px; 在元素四周添加内边距，增加元素内部空间感。
-     * vertical-align: top; 设置元素垂直对齐方式为顶部对齐，常用于行内块元素的垂直对齐调整。
-     */
-}
-
-/* layui布局下头部中作为图片的logo样式 */
-.layui-layout-admin.my-header img.my-header-logo {
+}
+
+.layui-layout-admin .my-header img.my-header-logo {
     width: 150px;
     height: 40px;
     text-align: center;
     line-height: 40px;
     padding: 10px;
     border: none;
-    /*
-     * 针对类名为my-header-logo的图片元素进行样式设置：
-     * width: 150px; 定义图片宽度为150像素。
-     * height: 40px; 设置图片高度为40像素。
-     * text-align: center; 让图片内如果有文本（通常这种情况较少）在水平方向居中对齐，这里更多是一种统一的样式设置习惯。
-     * line-height: 40px; 使图片在垂直方向上文本（同样通常较少）能有合适的排版，这里也是一种样式规范设定。
-     * padding: 10px; 在图片四周添加内边距，影响图片在布局中的占位空间。
-     * border: none; 去除图片默认的边框（如果有的话）。
-     */
-}
-
-/* 以下是名为my-header-btn的类选择器样式，可能用于头部的按钮相关元素 */
+}
+
 /* index */
 .my-header-btn {
     display: inline-block;
     width: auto;
     height: 100%;
     line-height: 60px;
-    /*
-     * display: inline-block; 以行内块方式显示元素，方便布局。
-     * width: auto; 宽度自动根据内容自适应。
-     * height: 100%; 高度与父元素（可能是头部元素）高度一致，这里应该是占满整个头部高度的垂直空间。
-     * line-height: 60px; 行高与元素高度相同，便于内部文本垂直居中对齐，使按钮等内容在垂直方向上看起来更规整。
-     */
 }
 
-.my-header-btn.layui-btn.layui-icon {
+.my-header-btn .layui-btn .layui-icon {
     margin-right: 0;
-    /* 针对同时具有layui-btn和layui-icon类的元素（可能是layui框架中的按钮图标元素），将其右侧外边距设置为0，调整图标与其他元素的间距 */
 }
 
 .my-header-user-nav {
     float: right;
-    /* 让该元素（可能是包含用户相关操作的导航元素）向右浮动，使其在头部靠右排列，常用于页面头部的用户信息、操作按钮等布局 */
 }
 
 .my-header-user-nav img {
@@ -96,40 +53,22 @@
     line-height: 40px;
     border: none;
     border-radius: 5px;
-    /*
-     * 对用户导航中的图片元素进行样式设置：
-     * width: 40px; 设置图片宽度为40像素。
-     * height: 40px; 定义图片高度为40像素，使其呈现正方形。
-     * text-align: center; 水平方向文本居中对齐（通常图片内无文本，但保持样式统一）。
-     * line-height: 40px; 垂直方向文本排版（同样一般无文本，但规范样式）。
-     * border: none; 去除图片边框。
-     * border-radius: 5px; 给图片设置圆角，使其外观更圆润，常用于头像等图片展示，增加美观度。
-     */
 }
 
-.my-header-user-nav.layui-nav-item a.name {
-    padding-left: 5px!important;
-    /* 针对用户导航中类名为layui-nav-item下的a元素且类名为name的元素（可能是显示用户名之类的文本元素），强制设置左侧内边距为5像素，调整文本与其他元素的间距 */
+.my-header-user-nav .layui-nav-item a.name {
+    padding-left: 5px !important;
 }
 
 .my-header ul.layui-nav {
     display: inline-block;
     vertical-align: top;
     border-radius: 0;
-    /*
-     * 针对头部中具有layui-nav类的ul列表元素进行样式设置：
-     * display: inline-block; 以行内块方式显示列表，便于与其他元素在同一行排列布局。
-     * vertical-align: top; 垂直对齐方式为顶部对齐，调整列表与其他行内块元素在垂直方向上的对齐情况。
-     * border-radius: 0; 去除列表默认的边框圆角效果（如果有），使其外观更规整。
-     */
 }
 
 .my-header ul.layui-nav li a {
     max-height: 60px;
-    /* 限制头部导航列表中每个列表项（li）内链接（a）元素的最大高度为60像素，可能是为了保证整体头部布局的一致性和美观性 */
 }
 
-/* 侧边栏样式 */
 .my-side {
     position: fixed;
     top: 60px;
@@ -137,35 +76,21 @@
     width: 200px;
     z-index: 2;
     overflow-x: hidden;
-    /*
-     * position: fixed; 固定定位侧边栏，使其在页面滚动时位置固定。
-     * top: 60px; 距离浏览器窗口顶部60像素，刚好在头部下方显示。
-     * bottom: 0; 距离浏览器窗口底部0像素，使其占满页面垂直方向剩余空间。
-     * width: 200px; 设置侧边栏宽度为200像素。
-     * z-index: 2; 定义堆叠顺序，确保在合适的层级显示，可能在主体内容之上等情况。
-     * overflow-x: hidden; 隐藏水平方向的溢出内容，防止侧边栏内容超出宽度时出现滚动条等情况。
-     */
 }
 
-.my-side.layui-nav {
+.my-side .layui-nav {
     border-radius: 0;
     min-height: 100%;
-    /*
-     * 针对侧边栏内的layui-nav类元素（通常是导航相关），去除边框圆角效果，并设置最小高度为100%，使其占满侧边栏的垂直空间，保证内容完整显示。
-     */
 }
 
-.my-side ul.layui-nav li a i,.layui-nav.layui-nav-child a i,.layui-nav.layui-nav-item a i,.layui-tab-card >.layui-tab-title li span i {
+.my-side ul.layui-nav li a i, .layui-nav .layui-nav-child a i, .layui-nav .layui-nav-item a i, .layui-tab-card > .layui-tab-title li span i {
     margin-right: 5px;
-    /* 对侧边栏导航、子导航、普通导航项以及选项卡标题中的图标元素（i标签）统一设置右侧外边距为5像素，调整图标与文本的间距，使布局更美观 */
 }
 
 .my-side ul.layui-nav li dl dd a i {
     margin-left: 15px;
-    /* 针对侧边栏导航中dl列表下dd元素内的图标元素（i标签），设置左侧外边距为15像素，调整图标在这些特定元素内的位置布局 */
 }
 
-/* 页面主体内容区域样式 */
 .my-body {
     position: fixed;
     top: 60px;
@@ -174,20 +99,10 @@
     right: 0;
     z-index: 1;
     overflow: hidden;
-    /*
-     * position: fixed; 固定定位主体内容区域，使其位置固定。
-     * top: 60px; 位于头部下方60像素处开始显示。
-     * bottom: 0; 占满页面底部剩余垂直空间。
-     * left: 200px; 距离浏览器窗口左侧200像素，即从侧边栏右侧开始显示。
-     * right: 0; 占满页面右侧剩余水平空间。
-     * z-index: 1; 设置堆叠顺序，通常在头部、侧边栏等元素之后显示。
-     * overflow: hidden; 隐藏超出该区域的内容，避免出现滚动条等情况，可能后续会通过内部元素的滚动设置来处理内容过多的情况。
-     */
 }
 
 .body {
     padding: 10px;
-    /* 给类名为body的元素设置内边距为10像素，在元素内部四周增加一定空间，方便内容排版，避免内容紧贴边界 */
 }
 
 .frame-main {
@@ -197,30 +112,19 @@
     height: 433px;
     background-color: #edededbf;
     backdrop-filter: blur(20px);
-    /*
-     * margin-top: -210px; 将元素向上移动一定距离，这里结合top: 50%可以使其在垂直方向上居中显示（具体根据父元素等情况综合来看）。
-     * top: 50%; 垂直方向上位于父元素（或相对定位的参考元素）的中间位置。
-     * position: relative; 设置相对定位，方便基于自身原本位置进行一些偏移等布局调整。
-     * height: 433px; 定义元素高度为433像素。
-     * background-color: #edededbf; 设置背景颜色为带一定透明度的灰色（通过rgba形式表示颜色和透明度）。
-     * backdrop-filter: blur(20px); 给元素添加背景模糊效果，模糊程度为20像素，常用于营造出一种毛玻璃等特殊视觉效果。
-     */
 }
 
-.my-body.layui-tab,.my-body.layui-tab.layui-tab-content {
+.my-body .layui-tab, .my-body .layui-tab .layui-tab-content {
     margin: 0;
     padding: 0;
-    /* 去除主体内容区域内选项卡（layui-tab）及其内容区域（layui-tab-content）的默认外边距和内边距，方便进行自定义的布局和样式调整 */
 }
 
-.my-body.layui-tab.layui-tab-title li:first-child > i {
+.my-body .layui-tab .layui-tab-title li:first-child > i {
     display: none;
-    /* 隐藏主体内容区域内选项卡标题（layui-tab-title）中第一个列表项（li）内的图标元素（i标签），可能是根据设计需求对首个选项卡的图标进行特殊处理 */
 }
 
-.my-body.layui-tab,.my-body.layui-tab.layui-tab-content,.my-body.layui-tab.layui-tab-item {
+.my-body .layui-tab, .my-body .layui-tab .layui-tab-content, .my-body .layui-tab .layui-tab-item {
     height: 100%;
-    /* 让主体内容区域内的选项卡、选项卡内容以及每个选项卡对应的具体内容项（layui-tab-item）都占满所在父元素的垂直空间，保证内容完整显示且布局合理 */
 }
 
 .my-body iframe {
@@ -228,94 +132,447 @@
     height: 100%;
     border: none;
     outline: none;
-    /*
-     * 针对主体内容区域内的iframe元素（通常用于嵌入其他页面等），设置宽度和高度都为100%，使其占满父元素空间，并且去除边框和默认的轮廓线，使其外观更简洁，无缝融入页面布局。
-     */
 }
 
-/* 页面底部样式 */
-.layui-layout-admin.my-footer {
+.layui-layout-admin .my-footer {
     height: 40px;
     padding: 2px 0;
-    /* 设置底部元素的高度为40像素，并在垂直方向上添加2像素的内边距（上下内边距），用于放置底部相关的版权信息、提示文字等内容 */
 }
 
-.layui-layout-admin.my-footer p {
+.layui-layout-admin .my-footer p {
     height: 20px;
     line-height: 20px;
     font-size: 12px;
     text-align: center;
-    /*
-     * 针对底部元素内的p段落元素进行样式设置：
-     * height: 20px; 定义段落高度为20像素。
-     * line-height: 20px; 行高与段落高度一致，使文本垂直居中对齐。
-     * font-size: 12px; 设置文本字号为12像素，通常用于显示较小的版权、说明等文字信息。
-     * text-align: center; 让文本在水平方向居中对齐，使底部内容排版更整齐美观。
-     */
 }
 
 .my-btn-box {
     height: 38px;
     margin-bottom: 10px;
-    /* 定义一个类名为my-btn-box的元素样式，设置高度为38像素，并在底部添加10像素的外边距，可能用于按钮组等元素的整体样式控制，方便布局和外观调整 */
 }
 
 .my-pay-box > div p {
     text-align: center;
     margin-bottom: 10px;
-    /* 针对类名为my-pay-box下的div元素内的p元素，设置文本水平居中对齐，并在底部添加10像素的外边距，常用于支付相关信息、提示等文本的排版布局 */
 }
 
-/* welcome页面相关样式 */
+/* welcome */
 .my-index-main button.layui-icon {
     width: 100%;
     font-size: 20px;
-    /* 针对类名为my-index-main下的button元素且具有layui-icon类（可能是layui框架中的图标按钮元素），设置宽度为100%占满父元素宽度，字号为20像素，用于调整按钮图标大小和外观显示效果 */
 }
 
-.my-index-main.my-nav-btn {
+.my-index-main .my-nav-btn {
     background: #efefef;
     cursor: pointer;
     border-radius: 2px;
     overflow: hidden;
-    /*
-     * 对类名为my-index-main下的my-nav-btn类元素（可能是导航相关按钮元素）进行样式设置：
-     * background: #efefef; 设置背景颜色为浅灰色（十六进制颜色值表示）。
-     * cursor: pointer; 当鼠标悬停在元素上时，鼠标指针变为手型，提示用户可点击操作。
-     * border-radius: 2px; 给按钮添加2像素的圆角效果，使其外观更圆润。
-     * overflow: hidden; 隐藏超出元素范围的内容，防止因内容过多等情况出现显示异常。
-     */
 }
 
-.my-index-main.my-nav-text:first-child {
+.my-index-main .my-nav-text:first-child {
     height: 24px;
     line-height: 25px;
     font-size: 16px;
     font-weight: bold;
-    /* 针对类名为my-index-main下的my-nav-text类的第一个元素（可能是导航相关文本元素）进行样式设置：
-     * height: 24px; 定义元素高度为24像素。
-     * line-height: 25px; 行高稍大于元素高度，使文本垂直方向有合适的排版效果。
-     * font-size: 16px; 设置文本字号为16像素。
-     * font-weight: bold; 将文本加粗显示，突出重要性，常用于导航栏标题等文本。
-     */
 }
 
-.my-index-main.my-nav-text:last-child {
+.my-index-main .my-nav-text:last-child {
     height: 20px;
     line-height: 20px;
     font-size: 12px;
-    /* 针对类名为my-index-main下的my-nav-text类的最后一个元素（可能是导航相关的辅助说明文本元素）进行样式设置：
-     * height: 20px; 定义元素高度为20像素。
-     * line-height: 20px; 行高与元素高度一致，使文本垂直居中对齐。
-     * font-size: 12px; 设置文本字号为12像素，用于显示较小的辅助说明文字。
-     */
 }
 
-/* 登录页面相关样式 */
+/* login */
+
+
 .login-box {
     position: fixed;
     top: 0;
     bottom: 0;
     left: 0;
-    right:0;
-}
+    right: 0;
+    margin: auto;
+    width: 320px;
+    height: 241px;
+    max-height: 300px;
+}
+
+.login-body .login-box h3 {
+    color: #444;
+    font-size: 22px;
+    font-weight: 100;
+    text-align: center;
+}
+
+.login-box .layui-input[type='number'] {
+    display: inline-block;
+    width: 50%;
+    vertical-align: top;
+}
+
+.login-box img {
+    display: inline-block;
+    width: 46%;
+    height: 38px;
+    border: none;
+    vertical-align: top;
+    cursor: pointer;
+    margin-left: 4%;
+}
+
+.login-box button.btn-reset {
+    width: 95px;
+}
+
+.login-box button.btn-submit {
+    width: 190px;
+}
+
+.login-main {
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    width: 350px;
+    margin: 0 auto;
+}
+
+.login-main header {
+
+    height: 35px;
+    line-height: 35px;
+    font-size: 30px;
+    font-weight: 100;
+    text-align: center;
+    padding-top: 58px;
+}
+
+.login-main header, .login-main form, .login-main form .layui-input-inline {
+    margin-bottom: 15px;
+}
+
+.login-main form .layui-input-inline, .login-main form .layui-input-inline input, .login-main form .layui-input-inline button {
+    width: 100%;
+}
+
+.login-main form .login-btn {
+    margin-bottom: 5px;
+}
+
+/* demo */
+.site-demo-button div {
+    margin: 20px 30px 10px;
+}
+
+.site-demo-button .layui-btn {
+    margin: 0 7px 10px 0;
+}
+
+/* check */
+input[type='checkbox'] {
+    vertical-align: middle;
+}
+
+.my-checkbox {
+    -webkit-appearance: none;
+    position: relative;
+    width: 20px;
+    height: 20px;
+    background-color: #FFFFFF;
+    border: solid 2px #28B779;
+    border-radius: 2px;
+    background-clip: padding-box;
+    display: inline-block;
+    cursor: pointer;
+}
+
+.my-checkbox:checked {
+    background-color: #28B779;
+    border: solid 0 #28B779;
+}
+
+.my-checkbox:checked:before {
+    position: absolute;
+    display: inline-block;
+    right: 50%;
+    bottom: 50%;
+    -webkit-transform: translate(50%, 50%);
+    -ms-transform: translate(50%, 50%);
+    transform: translate(50%, 50%);
+    font-family: "Microsoft Yahei";
+    content: "√";
+    color: #FFFFFF;
+    font-size: 16px;
+    font-weight: 600;
+}
+
+/* dblclick css */
+.dblclick-tab tr td {
+    height: 30px;
+    line-height: 30px;
+    padding: 0 6px;
+    border-radius: 2px;
+    cursor: pointer;
+}
+
+.dblclick-tab tr td:hover {
+    color: black;
+    background: white;
+}
+
+.dblclick-tab tr td i {
+    position: relative;
+    top: 2px;
+    display: inline-block;
+    margin-right: 5px;
+}
+
+/* tips 404 */
+.my-page-box {
+    font-family: "Segoe UI", "Lucida Grande", Helvetica, Arial, "Microsoft YaHei", FreeSans, Arimo, "Droid Sans", "wenquanyi micro hei", "Hiragino Sans GB", "Hiragino Sans GB W3", FontAwesome, sans-serif;
+    text-align: center;
+    padding: 20px;
+    background-color: white;
+}
+
+.my-page-box i {
+    font-size: 100px;
+}
+
+.my-page-box h2, .my-page-box h3, .my-page-box h4, .my-page-box h5 {
+    font-size: 80px;
+}
+
+.my-page-box p.msg {
+    color: #dce2ec;
+    font-size: 20px;
+    margin-top: 20px;
+}
+
+.my-page-box p.text {
+    color: #666;
+    font-size: 16px;
+    margin-top: 20px;
+}
+
+.my-page-box .my-btn-box {
+    margin-top: 20px;
+    margin-bottom: 20px;
+}
+
+/* tree table */
+.my-tree-table-box .tree-table-tree-box {
+    width: 20%;
+    min-height: 200px;
+    display: inline-block;
+    vertical-align: top;
+    overflow-y: auto;
+    overflow-x: auto;
+}
+
+.my-tree-table-box .tree-table-table-box {
+    display: inline-block;
+    vertical-align: top;
+    width: 79%;
+    margin-left: 1%;
+}
+
+/* skin0 */
+html .skin-0 .dblclick-tips-box .layui-layer-content {
+    background-color: #009688;
+}
+
+html .skin-0 .dblclick-tips-box i.layui-layer-TipsB {
+    border-right-color: #009688;
+}
+
+/* skin1 */
+html .skin-1 .my-header .my-header-logo,
+html .skin-1 .layui-nav .layui-nav-item a,
+html .skin-1 .layui-nav .layui-nav-item a:hover {
+    color: #444;
+}
+
+html .skin-1 .my-header,
+html .skin-1 .layui-nav,
+html .skin-1 .layui-nav-child {
+    background: white;
+}
+
+html .skin-1 .layui-nav .layui-nav-item .layui-nav-child dd.layui-this a {
+    color: white;
+}
+
+html .skin-1 .layui-nav .layui-nav-item .layui-nav-child dd.layui-this,
+html .skin-1 .layui-nav .layui-nav-item .layui-nav-child dd.layui-this > a,
+html .skin-1 .layui-nav-tree .layui-nav-item > a:hover,
+html .skin-1 .layui-nav .layui-nav-item .layui-nav-child dd:hover > a,
+html .skin-1 .layui-tab-title li .layui-tab-close:hover,
+html .skin-1 .dblclick-tips-box .layui-layer-content {
+    color: white !important;
+    background-color: #666 !important;
+}
+
+html .skin-1 .dblclick-tips-box i.layui-layer-TipsB {
+    border-right-color: #666;
+}
+
+html .skin-1 .layui-nav .layui-nav-itemed > a {
+    background: #444 !important;
+}
+
+html .skin-1 .layui-nav .layui-nav-more {
+    border-color: #444 transparent transparent;
+}
+
+html .skin-1 .layui-nav .layui-nav-mored {
+    border-color: transparent transparent #444;
+}
+
+/* skin2 */
+html .skin-2 .my-header .my-header-logo,
+html .skin-2 .layui-nav .layui-nav-item a,
+html .skin-2 .layui-nav .layui-nav-item a:hover {
+    color: white;
+}
+
+html .skin-2 .my-header,
+html .skin-2 .layui-nav,
+html .skin-2 .layui-nav-child {
+    background-color: #01AAED;
+}
+
+html .skin-2 .layui-nav .layui-nav-item .layui-nav-child dd.layui-this a {
+    color: white;
+}
+
+html .skin-2 .layui-nav .layui-nav-item .layui-nav-child dd.layui-this,
+html .skin-2 .layui-nav .layui-nav-item .layui-nav-child dd.layui-this > a,
+html .skin-2 .layui-nav-tree .layui-nav-item > a:hover,
+html .skin-2 .layui-nav .layui-nav-item .layui-nav-child dd:hover > a,
+html .skin-2 .layui-tab-title li .layui-tab-close:hover,
+html .skin-2 .dblclick-tips-box .layui-layer-content {
+    color: white !important;
+    background-color: #00C0F7 !important;
+}
+
+html .skin-2 .dblclick-tips-box i.layui-layer-TipsB {
+    border-right-color: #00C0F7;
+}
+
+html .skin-2 .layui-nav .layui-nav-itemed > a {
+    background-color: #1684af !important;
+}
+
+/* skin0-2 */
+html .skin-2 .layui-nav .layui-nav-more,
+html .skin-1 .layui-nav-tree .layui-nav-more,
+html .skin-2 .layui-nav-tree .layui-nav-more {
+    border-color: white transparent transparent;
+}
+
+html .skin-2 .layui-nav .layui-nav-mored,
+html .skin-1 .layui-nav-itemed .layui-nav-more,
+html .skin-2 .layui-nav-itemed .layui-nav-more {
+    border-color: transparent transparent white;
+}
+
+/* tools */
+.fl {
+    float: left;
+}
+
+.fr {
+    float: right;
+}
+
+.none {
+    display: none;
+}
+
+.block {
+    display: block;
+}
+
+.tc {
+    text-align: center;
+}
+
+.max-auto {
+    max-height: 450px;
+    overflow-y: auto;
+}
+
+/* layui css cover */
+html body .layui-nav .layui-nav-bar {
+    opacity: 0 !important;
+    overflow: hidden !important;
+}
+
+.layui-nav .layui-this:after, .layui-nav-bar, .layui-nav-tree .layui-nav-itemed:after {
+    background-color: transparent;
+}
+
+.my-body .layui-tab-card > .layui-tab-title li {
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
+
+.layui-layer-tips .layui-layer-content {
+    padding: 5px;
+}
+
+.tooltip {
+    position: relative;
+    display: inline-block;
+    border-bottom: 1px dotted black;
+    position: relative;
+    left: 12%;
+    top: -10px;
+}
+
+.tooltip .tooltiptext {
+    width: 138px;
+    background-color: #dad5d545;
+    color: #ff4545;
+    text-align: center;
+    border-radius: 6px;
+    padding: 5px 0;
+    position: absolute;
+    z-index: 1;
+}
+
+.page-active-li {
+    background-color: #00FF00;
+}
+
+.page-li {
+     float: left;
+     border: 1px solid #e2e2e2;
+     display: inline-block;
+     vertical-align: middle;
+     padding: 0 15px;
+     height: 28px;
+     line-height: 28px;
+     margin: 0px 2px 5px -3px;
+     background-color: #fff;
+     color: #333;
+     font-size: 12px;
+ }
+
+.page-li:hover {
+    color: #009688;
+}
+
+
+/* media */
+
+
+@media screen and ( max-width: 450px) {
+    .my-header ul.my-header-user-nav li a.pay {
+        display: none;
+    }
+}
+

web/error.jsp

@@ -1,19 +1,11 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<!-- 这是JSP页面的指令，用于设置页面的内容类型为HTML，字符编码为UTF-8，并且指定使用的语言是Java -->
 <html>
-
 <head>
-    <!-- 设置页面的字符编码，不过这里的写法不太常规，<?php...?>这种语法一般是用在PHP中，在这里可能是一种错误的混用，正常在HTML中可以直接写固定值如<meta charset="UTF-8"> -->
-    <meta charset="<?php $this->options->charset();?>">
-    <!-- 指示浏览器以IE的最高版本或者Chrome 1的模式来渲染页面，用于解决不同浏览器的兼容性问题 -->
+    <meta charset="<?php $this->options->charset(); ?>">
     <meta http-equiv="X-UA-Compatible" content="IE=edge, chrome=1">
-    <!-- 指示浏览器使用WebKit内核来渲染页面 -->
     <meta name="renderer" content="webkit">
-    <!-- 设置视口相关属性，规定页面宽度等于设备宽度，初始缩放比例、最小缩放比例、最大缩放比例都为1.0，禁止用户手动缩放页面 -->
     <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no">
-    <!-- 指示浏览器不要对页面进行缓存转换，保持获取到的原始内容 -->
     <meta http-equiv="Cache-Control" content="no-transform"/>
-    <!-- 定义页面的图标链接 -->
     <link rel="icon" href="https://yoyling.com/favicon.ico">
 
     <title>ERROR</title>
@@ -21,20 +13,17 @@
         body{
             margin:0;padding:0;
             font-family: PingFang SC,Microsoft YaHei,WenQuanYi Micro Hei,sans-serif;
-            /* 设置页面主体的外边距和内边距为0，定义字体族，优先使用苹方字体，其次是微软雅黑、文泉驿微米黑等无衬线字体 */
         }
         a, button.submit {
             color:#6E7173;
             text-decoration:none;
-            -webkit-transition:all.1s ease-in;
-            -moz-transition:all.1s ease-in;
-            -o-transition:all.1s ease-in;
-            transition:all.1s ease-in;
-            /* 设置链接和特定按钮的文本颜色为灰色，去除下划线，并且定义了在不同浏览器下过渡效果的属性，当元素状态改变时（如鼠标悬停等）会在0.1秒内平滑过渡样式变化 */
+            -webkit-transition:all .1s ease-in;
+            -moz-transition:all .1s ease-in;
+            -o-transition:all .1s ease-in;
+            transition:all .1s ease-in;
         }
         a:hover, a:active {
             color:#6E7173;
-            /* 当鼠标悬停或者激活（比如点击按住时）链接元素时，保持文本颜色为灰色 */
         }
         .body404{
             position: absolute;
@@ -42,11 +31,9 @@
             width: 100%;
             background:#fff;
             background-size: auto 100%;
-            /* 定义一个类名为body404的元素，设置其绝对定位，占满整个页面的高度和宽度，背景颜色为白色，背景图片尺寸自适应高度为100%（这里没看到背景图片相关设置，可能后续会添加或者有遗漏情况） */
         }
-        .body-about.body404{
+        .body-about .body404{
             background:#fff;
-            /* 当父元素有body-about类时，其内部的body404元素背景颜色设置为白色，可能用于特定页面布局区分样式 */
         }
         .site-name404 {
             margin: 0 auto;
@@ -60,25 +47,21 @@
             -webkit-background-clip: text;
             -webkit-text-fill-color: transparent;
             -webkit-animation: hue 60s infinite linear;
-            /* 定义一个类名为site-name404的元素，使其水平居中，文本居中对齐，设置字间距、字体大小、行高、字体粗细等样式属性，文本颜色通过渐变背景和裁剪、填充等设置来实现渐变文字效果，并且添加了一个名为hue的动画，持续60秒，无限循环，线性播放 */
         }
         .site-name404 h1{
             margin: 0 0 10px;
             font-size:50px;
             line-height:1.2;
-            /* 针对site-name404内部的h1元素设置外边距、字体大小和行高样式 */
         }
         .title404 span{
             font-size: 15px;
             width: 2px;
-            /* 设置类名为title404内部的span元素的字体大小和宽度样式 */
         }
         .title404 p{
             font-size: 20px;
             line-height:1.5;
             margin:0;
             color:#7b8993;
-            /* 设置类名为title404内部的p元素的字体大小、行高、外边距和文本颜色样式 */
         }
         .info404{
             position: absolute;
@@ -86,16 +69,13 @@
             text-align: center;
             width: 100%;
             margin-top: -160px;
-            /* 定义一个类名为info404的元素，绝对定位在页面垂直居中的位置（通过top: 50%和负的外边距来实现精准居中），文本居中对齐，宽度占满整个页面 */
         }
-        .body-about.info404{
+        .body-about .info404{
             margin-top: -180px;
-            /* 当父元素有body-about类时，其内部的info404元素调整上边距，用于特定页面布局下的垂直位置微调 */
         }
         #footer404{
             margin-top:30px;
             font-size:10px;
-            /* 设置id为footer404的元素，距离上方元素有30px的外边距，字体大小为10px */
         }
         .index404 {
             margin-top: 24px;
@@ -118,11 +98,9 @@
             border-radius: 25px;
             background-color: #fff;
             color: #7b8993;
-            /* 定义类名为index404的元素样式，设置上边距、显示为行内块元素、禁止文本换行、鼠标指针变为手型、字间距、字体大小等诸多样式属性，包括边框、行高、文本对齐、高度、内边距、圆角、背景颜色和文本颜色等，用于呈现一个特定外观和交互效果的按钮样式 */
         }
         .icon-about{
             padding: 10px 0 25px;
-            /* 定义类名为icon-about的元素的内边距样式，用于布局调整 */
         }
         .icon-about a{
             font-size: 20px;
@@ -131,7 +109,6 @@
             background-color: #000;
             border-radius: 100%;
             padding: 6px;
-            /* 定义类名为icon-about内部的链接元素样式，设置字体大小、外边距、文本颜色、背景颜色、边框圆角和内边距，用于呈现特定外观的图标样式（可能是社交媒体图标之类的元素） */
         }
         @-webkit-keyframes hue {
             from {
@@ -141,27 +118,21 @@
             to {
                 -webkit-filter: hue-rotate(-360deg);
             }
-            /* 定义名为hue的动画关键帧，从初始状态（色相旋转0度）到结束状态（色相旋转-360度），用于实现文本颜色渐变的动画效果 */
         }
     </style>
 </head>
-
 <body>
 <div class="body404">
     <div class="info404">
         <header id="header404" class="clearfix">
             <div class="site-name404">Time Out</div>
-            <!-- 创建一个id为header404的头部元素，应用clearfix类（可能用于清除浮动相关布局，不过没看到具体的clearfix样式定义），内部包含一个类名为site-name404的元素，显示文本"Time Out" -->
         </header>
         <section>
             <div class="title404">
                 <p>I have no secret of success but hard work.</p>
-                <!-- 在section元素内，有一个类名为title404的div元素，内部包含一个段落元素显示相应的文本内容 -->
             </div><a href="javascript:history.back()" class="index404">Go back</a>
-            <!-- 创建一个链接元素，点击时通过JavaScript的history.back()方法实现返回上一页的功能，应用index404类来呈现相应的样式 -->
         </section>
     </div>
 </div>
 </body>
-
-</html>
+</html>

web/filterLogin.jsp

@@ -1,28 +1,16 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<!-- 这是JSP页面的指令，作用如下：
-- contentType="text/html;charset=UTF-8"：设置该JSP页面响应的内容类型为HTML格式，并且指定字符编码为UTF-8，确保页面中的中文等特殊字符能正确显示与传输。
-- language="java"：明确该页面中使用的脚本语言是Java，意味着可以在页面中嵌入Java代码片段来实现业务逻辑等功能。 -->
 <html>
 <head>
     <title>TITLE</title>
-    <!-- 设置HTML页面的标题，在浏览器标签页等地方会显示该标题内容 -->
 </head>
 <body>
 <%
-    // 以下是一段嵌入在JSP页面中的Java代码片段，用于判断当前会话（session）中是否存在某些特定属性。
-    // session.getAttribute("student")==null：检查名为"student"的会话属性是否不存在（值为null）。
-    // session.getAttribute("teacher")==null：检查名为"teacher"的会话属性是否不存在（值为null）。
-    // session.getAttribute("admin")==null：检查名为"admin"的会话属性是否不存在（值为null）。
-    // 整体逻辑是，只有当这三个属性在会话中都不存在时，才会执行后续的转发操作。
-    if (session.getAttribute("student") == null && session.getAttribute("teacher") == null && session.getAttribute("admin") == null) {
+    if (session.getAttribute("student")==null && session.getAttribute("teacher")==null && session.getAttribute("admin")==null) {
 %>
-<jsp:forward page = "login.jsp"/>
-<!-- 这是JSP的一个动作标签（<jsp:forward>），用于将请求转发到指定的页面（这里是"login.jsp"页面）。
-             意味着当满足上述Java代码中判断条件时，当前请求会被直接转发到"login.jsp"页面，浏览器地址栏的URL可能不会发生改变（取决于服务器的具体配置和实现），
-             并且后续当前JSP页面中未执行的部分代码将不会再执行，控制权交给了被转发到的"login.jsp"页面。 -->
+        <jsp:forward page = "login.jsp"/>
 <%
     }
 %>
 
 </body>
-</html>
+</html>

web/footer.jsp

@@ -1,10 +1,7 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<!-- 这是JSP（Java Server Pages）页面的指令标签。
-- contentType="text/html;charset=UTF-8"：用于设定此页面响应内容的类型为HTML格式，同时指定字符编码为UTF-8，这样可以保证页面能够正确地显示和处理各种字符，比如中文等特殊字符不会出现乱码情况。
-- language="java"：明确表明在这个JSP页面中所使用的脚本语言是Java，意味着后续可以在页面中嵌入Java代码片段来实现诸如业务逻辑处理、数据交互等功能。 -->
 
 <div class="layui-footer">
-    <!-- 这是一个HTML的<div>标签，使用了名为"layui-footer"的类名。通常在前端框架（如Layui框架）中，这样带有特定类名的元素会被赋予相应的样式，此处大概率是用于构建页面底部的布局结构，从注释“底部固定区域”可以推测，它可能是用来创建页面底部的固定显示区域，比如放置版权信息、相关链接等内容。 -->
+    <!-- 底部固定区域 -->
     © yoyling.com - 学生信息管理系统
-    <!-- 此处显示的是版权声明相关的文本内容，表明该学生信息管理系统的版权归属网站为“yoyling.com”，是页面底部常见的用于标识版权所有者及系统名称的展示信息。 -->
-</div>
+</div>
+

web/forget.jsp

@@ -1,116 +1,65 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<!-- 这是JSP（Java Server Pages）页面的指令标签，具体作用如下：
-- contentType="text/html;charset=UTF-8"：指定该页面响应内容的类型为HTML格式，同时将字符编码设置为UTF-8，确保页面能正确处理和显示各种字符，像中文等特殊字符不会出现乱码现象。
-- language="java"：表明在这个JSP页面中使用的脚本语言是Java，后续可以在页面里嵌入Java代码片段来实现诸如与服务器端交互、业务逻辑处理等功能。不过从当前整个页面来看，主要还是以HTML、CSS和JavaScript实现前端相关功能为主 -->
-
 <html lang="en">
 <head>
     <meta charset="UTF-8">
-    <!-- 设置HTML页面的字符编码为UTF-8，与上面JSP指令中的字符编码设置相呼应，保证页面内容能正确解析和显示 -->
     <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
-    <!-- 指示浏览器以IE的最高版本或者Chrome 1的模式来渲染页面，用于解决不同浏览器之间的兼容性问题，尽量保证页面在不同浏览器下呈现的效果相对一致 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 设置视口相关属性，让页面宽度等于设备宽度，初始缩放比例为1，最大缩放比例也为1，意味着页面在移动端等设备上初始显示时按设备宽度自适应，并且用户不能进行缩放操作 -->
     <title>忘记密码</title>
-    <!-- 设置HTML页面的标题，这个标题会显示在浏览器的标签栏上，让用户清楚当前页面的主要功能是用于“忘记密码”相关操作 -->
     <link rel="stylesheet" href="./css/layui.css">
-    <!-- 引入外部样式表文件layui.css，通常这是Layui前端框架的核心样式文件，用于应用该框架预定义的各种UI组件、布局等样式 -->
     <link rel="stylesheet" href="./css/style.css">
-    <!-- 引入自定义的style.css样式文件，可能用于覆盖Layui框架的部分默认样式或者添加页面特定的样式规则 -->
     <link rel="stylesheet" href="./css/login.css">
-    <!-- 引入专门针对登录相关功能（此处是忘记密码功能，可能和登录共用部分样式逻辑）的login.css样式文件，进一步定制页面的外观样式 -->
     <script src="layui.js"></script>
-    <!-- 引入Layui框架的JavaScript核心文件，通过这个文件可以使用Layui框架提供的各种JavaScript组件和功能，比如表单验证、弹出层等功能 -->
+
 </head>
 <body>
 <div class="frame-main">
-    <!-- 这可能是整个页面主体内容的一个外层框架容器，用于整体布局，通过类名"frame-main"可以在CSS样式表中对其设置宽度、高度、边距等布局相关的样式属性 -->
     <div class="login-main">
-        <!-- 可能是专门用于放置登录相关内容（此处是忘记密码相关元素）的容器，通过类名"login-main"可以进一步定制其内部元素的排列、样式等 -->
         <header class="layui-elip">找回密码</header>
-        <!-- 使用了layui-elip类的<header>元素，可能是应用了Layui框架中特定的样式类来实现文本的某种排版效果（比如省略显示等，不过具体要看对应样式定义），用于显示页面的主要标题“找回密码” -->
         <form class="layui-form">
-            <!-- 创建一个表单元素，并且应用了layui-form类，表明这个表单会应用Layui框架提供的表单相关的样式和验证等功能 -->
             <div class="layui-input-inline">
-                <!-- 创建一个行内块级的<div>元素，用于在表单内布局输入框等元素，使得它们可以在同一行显示（具体布局还取决于样式设置） -->
                 <label class="layadmin-user-login-icon layui-icon layui-icon-username"></label>
-                <!-- 创建一个<label>标签，应用了多个类名，其中layui-icon类表明它是Layui框架中的图标元素，layui-icon-username类指定了具体的图标样式（这里推测是代表用户名相关的图标），用于在输入框前面显示一个特定的图标作为提示 -->
                 <input type="text" name="account" required lay-verify="required" placeholder="请输入注册时的ID" autocomplete="off"
                        class="layui-input">
-                <!-- 创建一个文本输入框，设置了以下属性：
-                     - type="text"：表明是文本类型的输入框，用于用户输入文本信息。
-                     - name="account"：为输入框设置一个名称，方便后续在表单提交等操作中识别和获取该输入框的值。
-                     - required：HTML5的属性，表明这个输入框是必填项，浏览器会进行相应的验证提示。
-                     - lay-verify="required"：Layui框架的验证属性，再次强调这个输入框是必填的，当用户提交表单时，如果该输入框为空会触发验证提示。
-                     - placeholder="请输入注册时的ID"：在输入框为空时显示的提示文本，提示用户应该输入的内容。
-                     - autocomplete="off"：关闭浏览器的自动填充功能，避免浏览器自动填充一些不合适的信息到该输入框。
-                     - class="layui-input"：应用Layui框架中针对输入框的样式类，使输入框呈现出相应的外观样式。 -->
             </div>
             <div class="layui-input-inline">
                 <label class="layadmin-user-login-icon layui-icon layui-icon-email"></label>
                 <input type="password" name="password" required lay-verify="required" placeholder="用于找回的邮箱" autocomplete="off"
                        class="layui-input">
-                <!-- 与上面的输入框类似，不过这里是一个密码类型的输入框（type="password"），用于用户输入找回密码所需要的邮箱地址，同样设置了必填、验证、提示文本等相关属性 -->
             </div>
             <div class="layui-input-inline login-btn">
-                <!-- 又是一个行内块级的<div>元素，用于放置提交按钮，并且应用了login-btn类，可能用于对按钮设置特定的样式，比如大小、颜色等 -->
                 <button lay-submit lay-filter="login" class="layui-btn">找回</button>
-                <!-- 创建一个按钮元素，应用了layui-btn类使其呈现Layui框架中按钮的默认样式，lay-submit属性表示这个按钮可以触发表单提交操作，lay-filter="login"属性用于为按钮绑定一个特定的事件过滤器，方便后续在JavaScript代码中对按钮的点击事件进行监听和处理 -->
             </div>
             <hr/>
-            <!-- 创建一个水平分割线元素，用于在页面上划分不同的区域，起到视觉上的分隔作用 -->
             <p><a href="login.jsp" class="fl">登录&emsp;&emsp;&emsp;&emsp;</a><a href="https://yoyling.com" class="fl">如果你未绑定邮箱请联系我</a><a href="register.jsp" class="fr">注册</a></p>
-            <!-- 创建一个段落元素，里面包含了三个链接元素：
-                 - 第一个链接（href="login.jsp"）指向登录页面（login.jsp），并应用了fl类（可能用于设置左浮动等样式布局相关操作），显示文本“登录”，方便用户在忘记密码页面可以直接跳转到登录页面。
-                 - 第二个链接（href="https://yoyling.com"）指向一个外部网站（yoyling.com），同样应用了fl类，显示文本“如果你未绑定邮箱请联系我”，用于提示用户在未绑定邮箱的情况下如何寻求帮助。
-                 - 第三个链接（href="register.jsp"）指向注册页面（register.jsp），应用了fr类（可能用于设置右浮动等样式布局相关操作），显示文本“注册”，方便用户进行注册相关操作。 -->
         </form>
     </div>
 </div>
 <footer style="position:absolute;bottom:0;width:100%;height:30px; text-align: center;">© 2018-2019.YOYLING.COM</footer>
-<!-- 创建一个<footer>元素，通过内联样式设置其绝对定位在页面底部（bottom:0），宽度占满整个页面（width:100%），高度为30px，并且文本居中对齐（text-align: center），用于显示版权相关的声明信息“© 2018-2019.YOYLING.COM” -->
 
 
 
 <script type="text/javascript">
     layui.use(['form','layer','jquery'], function () {
-        // 使用Layui框架的模块加载机制，加载名为'form'（用于表单操作和验证等功能）、'layer'（用于弹出层提示等功能）、'jquery'（虽然这里写的是加载，但实际上可能是Layui内部已经集成了jQuery或者对其进行了适配，用于进行DOM操作、AJAX请求等常见的JavaScript操作）的模块，加载完成后执行回调函数。
 
         // 操作对象
         var form = layui.form;
-        // 获取Layui框架中表单模块的实例对象，后续可以通过这个对象调用表单相关的方法，比如进行表单验证、监听表单提交事件等操作。
         var $ = layui.jquery;
-        // 获取Layui框架中经过适配后的jQuery对象（或者就是原生的jQuery对象，如果Layui是基于它来集成的），方便后续进行各种DOM操作和AJAX请求等操作。
-
         form.on('submit(login)',function (data) {
-            // 使用表单模块的on方法来监听表单提交事件，这里监听的是lay-filter="login"的按钮点击提交表单时触发的事件。当事件触发时，会传入一个包含表单数据等信息的参数data，执行回调函数内的代码。
-
             // console.log(data.field);
-            // 这行代码如果取消注释，可以在控制台打印出表单中各个输入框等元素提交的数据，用于调试查看用户输入的内容是否正确获取到了，此处是获取到以对象形式存储的表单数据（字段名为键，用户输入的值为对应的值）。
-
             $.ajax({
                 url:'login.php',
-                // 设置AJAX请求的目标URL地址，这里是向名为login.php的服务器端脚本文件发送请求，通常这个文件会用于处理登录相关的业务逻辑（此处是忘记密码的验证逻辑，可能存在复用情况），比如验证用户输入的账号和邮箱是否匹配等操作。
                 data:data.field,
-                // 将获取到的表单数据（前面提到的data.field）作为请求的数据发送给服务器端，服务器端可以根据这些数据进行相应的处理。
                 dataType:'text',
-                // 设置期望从服务器端返回的数据类型为文本类型，意味着服务器端返回的内容会被当作普通文本进行处理。
                 type:'post',
-                // 设置AJAX请求的方式为POST方式，相比于GET方式，POST方式更适合用于提交表单数据等需要传递较多数据或者敏感数据的情况，数据会放在请求体中发送给服务器端。
                 success:function (data) {
-                    // 这是AJAX请求成功后的回调函数，当服务器端正确响应并返回数据后，会执行这个函数，参数data就是服务器端返回的数据内容。
-
                     if (data == '1'){
                         location.href = "../index.php";
-                        // 如果服务器端返回的数据内容是'1'，则认为验证通过，通过修改浏览器的地址栏，将页面重定向到上级目录下的index.php页面，这里推测index.php可能是系统的主页面或者登录成功后的欢迎页面等。
                     }else{
                         layer.msg('登录名或密码错误');
-                        // 如果服务器端返回的数据不是'1'，则认为验证失败，使用Layui框架的layer模块弹出一个提示消息框，显示“登录名或密码错误”的提示信息，告知用户验证未通过的原因。
                     }
                 }
             })
             return false;
-            // 返回false阻止表单的默认提交行为，因为这里已经通过AJAX方式手动向服务器端发送了请求，不需要浏览器再进行默认的表单提交操作了，避免页面刷新等不必要的情况发生。
         })
 
     });

web/index.jsp

@@ -1,42 +1,28 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<!-- 页面指令：
-contentType="text/html;charset=UTF-8"：指定了该JSP页面返回给客户端的内容类型是HTML格式，并且字符编码采用UTF-8，这样可以确保页面能够正确显示包含各种语言文字（尤其是中文等非ASCII字符）的内容，避免出现乱码情况。
-language="java"：表明该JSP页面使用Java语言来编写脚本代码，JSP本质上最终会被服务器编译成Servlet（Java类）来执行，这里明确了其脚本所基于的编程语言。
--->
 <html>
 <head>
     <title>TITLE</title>
 </head>
 <body>
+
 <%
-    // 以下这段代码基于服务器端的会话（session）对象来判断用户的角色，并根据不同的角色进行页面转发操作。
-    // 它通过检查session对象中存储的特定属性（student、teacher、admin）是否存在来确定用户身份，然后将请求转发到相应的初始页面，
-    // 如果这些属性都不存在，意味着用户未登录或者登录状态失效等情况，就将请求转发到login.jsp页面让用户进行登录操作。
-    if (session.getAttribute("student")!= null) {
-        // 使用session.getAttribute("student")尝试从当前会话中获取名为student的属性值，
-        // 如果获取到的值不为null，表示当前用户的角色是学生，此时执行下面的转发操作，
-        // 利用JSP的转发标签<jsp:forward>将请求转发到WEB-INF/student/sIndex.jsp页面。
-        // WEB-INF目录下的资源通常是受保护的，不能直接通过浏览器URL访问，需要通过服务器端的转发等内部机制来访问，这样可以提高页面的安全性，避免用户直接绕过权限检查去访问一些应该有权限限制的页面。
+    if (session.getAttribute("student")!=null) {
 %>
-<jsp:forward page="/WEB-INF/student/sIndex.jsp" />
+        <jsp:forward page = "/WEB-INF/student/sIndex.jsp"/>
 <%
-} else if (session.getAttribute("teacher")!= null) {
-    // 类似地，如果student属性不存在，但是teacher属性存在于会话中，说明用户角色是教师，就会把请求转发到WEB-INF/teacher/tIndex.jsp页面。
+    }else if (session.getAttribute("teacher")!=null) {
 %>
-<jsp:forward page="/WEB-INF/teacher/tIndex.jsp" />
+        <jsp:forward page = "/WEB-INF/teacher/tIndex.jsp"/>
 <%
-} else if (session.getAttribute("admin")!= null) {
-    // 若student和teacher属性都不存在，而admin属性存在，表明用户是管理员角色，会将请求转发到WEB-INF/admin/aIndex.jsp页面。
+    }else if (session.getAttribute("admin")!=null) {
 %>
-<jsp:forward page="/WEB-INF/admin/aIndex.jsp" />
+        <jsp:forward page = "/WEB-INF/admin/aIndex.jsp"/>
 <%
-} else {
-    // 前面几个条件都不满足，也就是上述代表不同角色的属性在会话中都不存在时，会将请求转发到login.jsp页面，引导用户进行登录，
-    // 建立相应的会话属性来标识其角色，后续再次访问时就能根据角色转发到对应的页面了。
+    }else {
 %>
-<jsp:forward page="login.jsp" />
+        <jsp:forward page = "login.jsp" />
 <%
     }
 %>
 </body>
-</html>
+</html>

web/lay/modules/carousel.js

@@ -1,157 +1,2 @@
 /** layui-v2.5.6 MIT License By https://www.layui.com */
-;layui.define("jquery",function(e){"use strict";
-    // 引入 layui 的 $（jQuery）模块
-    var i=layui.$,
-        // 初始化配置对象
-        n=(layui.hint(),layui.device(),{config:{},set:function(e){
-                var n=this;
-                // 设置配置
-                return n.config=i.extend({},n.config,e),n},
-            on:function(e,i){
-                return layui.onevent.call(this,t,e,i)}}),
-
-        // 定义常量
-        t="carousel",  // 轮播图的名称
-        a="layui-this",  // 当前活动的元素
-        l=">*[carousel-item]>*",  // 选择轮播图的每一个项目
-        o="layui-carousel-left",  // 左箭头
-        r="layui-carousel-right",  // 右箭头
-        d="layui-carousel-prev",  // 上一项按钮
-        s="layui-carousel-next",  // 下一项按钮
-        u="layui-carousel-arrow",  // 箭头
-        c="layui-carousel-ind",  // 指示器（小圆点）
-
-        // 定义轮播图的核心功能
-        m=function(e){
-            var t=this;
-            t.config=i.extend({},t.config,n.config,e),t.render()
-        };
-
-    // 轮播图的默认配置
-    m.prototype.config={
-        width:"600px",  // 默认宽度
-        height:"280px",  // 默认高度
-        full:!1,  // 是否全屏
-        arrow:"hover",  // 箭头显示方式：hover即鼠标悬浮时显示
-        indicator:"inside",  // 指示器的位置：inside表示在轮播图内
-        autoplay:!0,  // 是否自动播放
-        interval:3e3,  // 自动播放的间隔时间，单位是毫秒
-        anim:"",  // 动画效果
-        trigger:"click",  // 触发方式：点击
-        index:0  // 默认显示第0项
-    },
-
-        // 渲染轮播图
-        m.prototype.render=function(){
-            var e=this,n=e.config;
-            n.elem=i(n.elem),
-            n.elem[0]&&(e.elemItem=n.elem.find(l),n.index<0&&(n.index=0),n.index>=e.elemItem.length&&(n.index=e.elemItem.length-1),n.interval<800&&(n.interval=800),n.full?n.elem.css({position:"fixed",width:"100%",height:"100%",zIndex:9999}):n.elem.css({width:n.width,height:n.height}),n.elem.attr("lay-anim",n.anim),e.elemItem.eq(n.index).addClass(a),e.elemItem.length<=1||(e.indicator(),e.arrow(),e.autoplay(),e.events()))
-        },
-
-        // 重新加载轮播图
-        m.prototype.reload=function(e){
-            var n=this;
-            clearInterval(n.timer),
-                n.config=i.extend({},n.config,e),
-                n.render()
-        },
-
-        // 获取上一项的索引
-        m.prototype.prevIndex=function(){
-            var e=this,i=e.config,n=i.index-1;
-            return n<0&&(n=e.elemItem.length-1),n
-        },
-
-        // 获取下一项的索引
-        m.prototype.nextIndex=function(){
-            var e=this,i=e.config,n=i.index+1;
-            return n>=e.elemItem.length&&(n=0),n
-        },
-
-        // 增加索引
-        m.prototype.addIndex=function(e){
-            var i=this,n=i.config;
-            e=e||1,n.index=n.index+e,n.index>=i.elemItem.length&&(n.index=0)
-        },
-
-        // 减少索引
-        m.prototype.subIndex=function(e){
-            var i=this,n=i.config;
-            e=e||1,n.index=n.index-e,n.index<0&&(n.index=i.elemItem.length-1)
-        },
-
-        // 自动播放
-        m.prototype.autoplay=function(){
-            var e=this,i=e.config;
-            i.autoplay&&(clearInterval(e.timer),e.timer=setInterval(function(){
-                e.slide()
-            },i.interval))
-        },
-
-        // 箭头按钮
-        m.prototype.arrow=function(){
-            var e=this,n=e.config,t=i(['<button class="layui-icon '+u+'" lay-type="sub">'+("updown"===n.anim?"&#xe619;":"&#xe603;")+"</button>",
-                '<button class="layui-icon '+u+'" lay-type="add">'+("updown"===n.anim?"&#xe61a;":"&#xe602;")+"</button>"].join(""));
-
-            // 设置箭头的显示方式
-            n.elem.attr("lay-arrow",n.arrow),
-            n.elem.find("."+u)[0]&&n.elem.find("."+u).remove(),
-                n.elem.append(t),
-                t.on("click",function(){
-                    var n=i(this),t=n.attr("lay-type");
-                    e.slide(t)
-                })
-        },
-
-        // 指示器
-        m.prototype.indicator=function(){
-            var e=this,n=e.config,t=e.elemInd=i(['<div class="'+c+'"><ul>',function(){
-                var i=[];
-                return layui.each(e.elemItem,function(e){
-                    i.push("<li"+(n.index===e?' class="layui-this"':"")+"></li>")
-                }),i.join("")
-            }(),"</ul></div>"].join(""));
-
-            // 设置指示器的显示方式
-            n.elem.attr("lay-indicator",n.indicator),
-            n.elem.find("."+c)[0]&&n.elem.find("."+c).remove(),
-                n.elem.append(t),"updown"===n.anim&&t.css("margin-top",-(t.height()/2)),
-                t.find("li").on("hover"===n.trigger?"mouseover":n.trigger,function(){
-                    var t=i(this),a=t.index();
-                    a>n.index?e.slide("add",a-n.index):a<n.index&&e.slide("sub",n.index-a)
-                })
-        },
-
-        // 切换轮播图
-        m.prototype.slide=function(e,i){
-            var n=this,l=n.elemItem,u=n.config,c=u.index,m=u.elem.attr("lay-filter");
-            n.haveSlide||("sub"===e?(n.subIndex(i),l.eq(u.index).addClass(d),setTimeout(function(){
-                l.eq(c).addClass(r),l.eq(u.index).addClass(r)
-            },50)):(n.addIndex(i),l.eq(u.index).addClass(s),setTimeout(function(){
-                l.eq(c).addClass(o),l.eq(u.index).addClass(o)
-            },50)),setTimeout(function(){
-                l.removeClass(a+" "+d+" "+s+" "+o+" "+r),l.eq(u.index).addClass(a),
-                    n.haveSlide=!1
-            },300),n.elemInd.find("li").eq(u.index).addClass(a).siblings().removeClass(a),
-                n.haveSlide=!0,layui.event.call(this,t,"change("+m+")",{index:u.index,prevIndex:c,item:l.eq(u.index)}))
-        },
-
-        // 事件绑定
-        m.prototype.events=function(){
-            var e=this,i=e.config;
-            i.elem.data("haveEvents")||(i.elem.on("mouseenter",function(){
-                clearInterval(e.timer)
-            }).on("mouseleave",function(){
-                e.autoplay()
-            }),i.elem.data("haveEvents",!0))
-        },
-
-        // 初始化轮播图
-        n.render=function(e){
-            var i=new m(e);
-            return i
-        },
-
-        // 触发layui事件
-        e(t,n)
-});
+ ;layui.define("jquery",function(e){"use strict";var i=layui.$,n=(layui.hint(),layui.device(),{config:{},set:function(e){var n=this;return n.config=i.extend({},n.config,e),n},on:function(e,i){return layui.onevent.call(this,t,e,i)}}),t="carousel",a="layui-this",l=">*[carousel-item]>*",o="layui-carousel-left",r="layui-carousel-right",d="layui-carousel-prev",s="layui-carousel-next",u="layui-carousel-arrow",c="layui-carousel-ind",m=function(e){var t=this;t.config=i.extend({},t.config,n.config,e),t.render()};m.prototype.config={width:"600px",height:"280px",full:!1,arrow:"hover",indicator:"inside",autoplay:!0,interval:3e3,anim:"",trigger:"click",index:0},m.prototype.render=function(){var e=this,n=e.config;n.elem=i(n.elem),n.elem[0]&&(e.elemItem=n.elem.find(l),n.index<0&&(n.index=0),n.index>=e.elemItem.length&&(n.index=e.elemItem.length-1),n.interval<800&&(n.interval=800),n.full?n.elem.css({position:"fixed",width:"100%",height:"100%",zIndex:9999}):n.elem.css({width:n.width,height:n.height}),n.elem.attr("lay-anim",n.anim),e.elemItem.eq(n.index).addClass(a),e.elemItem.length<=1||(e.indicator(),e.arrow(),e.autoplay(),e.events()))},m.prototype.reload=function(e){var n=this;clearInterval(n.timer),n.config=i.extend({},n.config,e),n.render()},m.prototype.prevIndex=function(){var e=this,i=e.config,n=i.index-1;return n<0&&(n=e.elemItem.length-1),n},m.prototype.nextIndex=function(){var e=this,i=e.config,n=i.index+1;return n>=e.elemItem.length&&(n=0),n},m.prototype.addIndex=function(e){var i=this,n=i.config;e=e||1,n.index=n.index+e,n.index>=i.elemItem.length&&(n.index=0)},m.prototype.subIndex=function(e){var i=this,n=i.config;e=e||1,n.index=n.index-e,n.index<0&&(n.index=i.elemItem.length-1)},m.prototype.autoplay=function(){var e=this,i=e.config;i.autoplay&&(clearInterval(e.timer),e.timer=setInterval(function(){e.slide()},i.interval))},m.prototype.arrow=function(){var e=this,n=e.config,t=i(['<button class="layui-icon '+u+'" lay-type="sub">'+("updown"===n.anim?"&#xe619;":"&#xe603;")+"</button>",'<button class="layui-icon '+u+'" lay-type="add">'+("updown"===n.anim?"&#xe61a;":"&#xe602;")+"</button>"].join(""));n.elem.attr("lay-arrow",n.arrow),n.elem.find("."+u)[0]&&n.elem.find("."+u).remove(),n.elem.append(t),t.on("click",function(){var n=i(this),t=n.attr("lay-type");e.slide(t)})},m.prototype.indicator=function(){var e=this,n=e.config,t=e.elemInd=i(['<div class="'+c+'"><ul>',function(){var i=[];return layui.each(e.elemItem,function(e){i.push("<li"+(n.index===e?' class="layui-this"':"")+"></li>")}),i.join("")}(),"</ul></div>"].join(""));n.elem.attr("lay-indicator",n.indicator),n.elem.find("."+c)[0]&&n.elem.find("."+c).remove(),n.elem.append(t),"updown"===n.anim&&t.css("margin-top",-(t.height()/2)),t.find("li").on("hover"===n.trigger?"mouseover":n.trigger,function(){var t=i(this),a=t.index();a>n.index?e.slide("add",a-n.index):a<n.index&&e.slide("sub",n.index-a)})},m.prototype.slide=function(e,i){var n=this,l=n.elemItem,u=n.config,c=u.index,m=u.elem.attr("lay-filter");n.haveSlide||("sub"===e?(n.subIndex(i),l.eq(u.index).addClass(d),setTimeout(function(){l.eq(c).addClass(r),l.eq(u.index).addClass(r)},50)):(n.addIndex(i),l.eq(u.index).addClass(s),setTimeout(function(){l.eq(c).addClass(o),l.eq(u.index).addClass(o)},50)),setTimeout(function(){l.removeClass(a+" "+d+" "+s+" "+o+" "+r),l.eq(u.index).addClass(a),n.haveSlide=!1},300),n.elemInd.find("li").eq(u.index).addClass(a).siblings().removeClass(a),n.haveSlide=!0,layui.event.call(this,t,"change("+m+")",{index:u.index,prevIndex:c,item:l.eq(u.index)}))},m.prototype.events=function(){var e=this,i=e.config;i.elem.data("haveEvents")||(i.elem.on("mouseenter",function(){clearInterval(e.timer)}).on("mouseleave",function(){e.autoplay()}),i.elem.data("haveEvents",!0))},n.render=function(e){var i=new m(e);return i},e(t,n)});

web/lay/modules/code.js

@@ -1,58 +1,2 @@
 /** layui-v2.5.6 MIT License By https://www.layui.com */
-;layui.define("jquery",function(e){"use strict";
-
-    // 引入 layui 的 $（jQuery）模块
-    var a=layui.$,
-        // layui 文档模块的 URL 地址
-        l="http://www.layui.com/doc/modules/code.html";
-
-    // 定义模块 "code"，并执行传入的函数
-    e("code",function(e){
-        var t=[]; // 初始化一个空数组，用于存储每个代码块元素
-        // 如果 e 参数未定义，则默认为空对象
-        e=e||{},
-            // 如果 e 中没有指定 about，则默认为 true
-            e.about=!("about"in e)||e.about,
-            // 获取所有指定的代码块元素，默认为 .layui-code
-            e.elem=a(e.elem||".layui-code"),
-            // 遍历所有代码块元素
-            e.elem.each(function(){
-                t.push(this);  // 将每个代码块元素添加到数组 t 中
-            }),
-
-            // 倒序遍历每个代码块元素
-            layui.each(t.reverse(),function(t,i){
-                var c=a(i), // 获取当前代码块元素
-                    o=c.html(); // 获取当前代码块的 HTML 内容
-
-                // 如果代码块元素有 lay-encode 属性或者传入参数 e.encode 为真，进行 HTML 转义
-                (c.attr("lay-encode")||e.encode)&&(o=o.replace(/&(?!#?[a-zA-Z0-9]+;)/g,"&")
-                    .replace(/</g,"&lt;")
-                    .replace(/>/g,"&gt;")
-                    .replace(/'/g,"&#39;")
-                    .replace(/"/g,"&quot;"));
-
-                // 将转义后的 HTML 内容分行显示，每行一个 <li> 元素
-                c.html('<ol class="layui-code-ol"><li>'+o.replace(/[\r\t\n]+/g,"</li><li>")+"</li></ol>");
-
-                // 如果没有标题，插入一个标题（h3），标题内容可以通过 lay-title 来指定
-                c.find(">.layui-code-h3")[0] || c.prepend('<h3 class="layui-code-h3">'+(c.attr("lay-title")||e.title||"code")+(e.about?'<a href="'+l+'" target="_blank">layui.code</a>':"")+"</h3>");
-
-                // 获取代码块中的 <ol> 元素
-                var d=c.find(">.layui-code-ol");
-
-                // 为代码块添加类名，设置样式
-                c.addClass("layui-box layui-code-view"),
-
-                    // 如果有指定 skin 或 lay-skin，给代码块添加相应的样式
-                (c.attr("lay-skin")||e.skin) && c.addClass("layui-code-"+(c.attr("lay-skin")||e.skin)),
-
-                    // 如果代码行数超过100行，设置左边距，使其有缩进效果
-                (d.find("li").length/100|0)>0 && d.css("margin-left",(d.find("li").length/100|0)+"px"),
-
-                    // 如果指定了 lay-height 或者传入的参数 e.height，设置最大高度
-                (c.attr("lay-height")||e.height) && d.css("max-height",c.attr("lay-height")||e.height)
-            })
-    })})
-    // 引入代码块的 CSS 样式
-    .addcss("modules/code.css","skincodecss");
+ ;layui.define("jquery",function(e){"use strict";var a=layui.$,l="http://www.layui.com/doc/modules/code.html";e("code",function(e){var t=[];e=e||{},e.elem=a(e.elem||".layui-code"),e.about=!("about"in e)||e.about,e.elem.each(function(){t.push(this)}),layui.each(t.reverse(),function(t,i){var c=a(i),o=c.html();(c.attr("lay-encode")||e.encode)&&(o=o.replace(/&(?!#?[a-zA-Z0-9]+;)/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/'/g,"&#39;").replace(/"/g,"&quot;")),c.html('<ol class="layui-code-ol"><li>'+o.replace(/[\r\t\n]+/g,"</li><li>")+"</li></ol>"),c.find(">.layui-code-h3")[0]||c.prepend('<h3 class="layui-code-h3">'+(c.attr("lay-title")||e.title||"code")+(e.about?'<a href="'+l+'" target="_blank">layui.code</a>':"")+"</h3>");var d=c.find(">.layui-code-ol");c.addClass("layui-box layui-code-view"),(c.attr("lay-skin")||e.skin)&&c.addClass("layui-code-"+(c.attr("lay-skin")||e.skin)),(d.find("li").length/100|0)>0&&d.css("margin-left",(d.find("li").length/100|0)+"px"),(c.attr("lay-height")||e.height)&&d.css("max-height",c.attr("lay-height")||e.height)})})}).addcss("modules/code.css","skincodecss");

web/lay/modules/flow.js

@@ -1,118 +1,2 @@
 /** layui-v2.5.6 MIT License By https://www.layui.com */
-;layui.define("jquery", function(e) {
-    "use strict";
-    var l = layui.$, o = function(e) {}, t = '<i class="layui-anim layui-anim-rotate layui-anim-loop layui-icon ">&#xe63e;</i>';
-
-    // 定义 load 方法，用于加载更多内容
-    o.prototype.load = function(e) {
-        var o, i, n, r, a = this, c = 0;
-        e = e || {};
-        var f = l(e.elem); // 获取加载更多按钮所在的元素
-        if (f[0]) { // 如果该元素存在
-            var m = l(e.scrollElem || document), // 获取滚动容器元素，默认为 document
-                u = e.mb || 50, // 滚动到距离底部多少距离时触发加载更多
-                s = !("isAuto" in e) || e.isAuto, // 是否自动加载
-                v = e.end || "没有更多了", // 加载完成后的提示
-                y = e.scrollElem && e.scrollElem !== document, // 判断是否是自定义滚动区域
-                d = "<cite>加载更多</cite>", // 默认的加载更多文本
-                h = l('<div class="layui-flow-more"><a href="javascript:;">' + d + "</a></div>");
-
-            f.find(".layui-flow-more")[0] || f.append(h); // 如果没有加载更多的按钮，则追加
-            var p = function(e, t) {
-                e = l(e);
-                h.before(e); // 将新内容插入到加载更多按钮之前
-                t = 0 == t || null;
-                t ? h.html(v) : h.find("a").html(d); // 如果已加载完毕，显示“没有更多了”
-                i = t;
-                o = null;
-                n && n();
-            };
-
-            // 加载更多逻辑
-            var g = function() {
-                o = !0;
-                h.find("a").html(t); // 显示加载动画
-                "function" == typeof e.done && e.done(++c, p); // 如果有 done 方法，调用它
-            };
-
-            // 初始化加载
-            g();
-            // 点击加载更多时，触发加载操作
-            h.find("a").on("click", function() {
-                l(this);
-                i || o || g();
-            });
-
-            // 如果启用了懒加载
-            if (e.isLazyimg) var n = a.lazyimg({ elem: e.elem + " img", scrollElem: e.scrollElem });
-
-            return s ? (m.on("scroll", function() {
-                var e = l(this), t = e.scrollTop();
-                r && clearTimeout(r);
-                !i && f.width() && (r = setTimeout(function() {
-                    var i = y ? e.height() : l(window).height(),
-                        n = y ? e.prop("scrollHeight") : document.documentElement.scrollHeight;
-                    // 滚动到底部时加载更多
-                    n - t - i <= u && (o || g());
-                }, 100));
-            }), a) : a;
-        }
-    };
-
-    // 懒加载方法
-    o.prototype.lazyimg = function(e) {
-        var o, t = this, i = 0;
-        e = e || {};
-        var n = l(e.scrollElem || document), r = e.elem || "img", a = e.scrollElem && e.scrollElem !== document;
-
-        // 图片加载检查和设置
-        var c = function(e, l) {
-            var o = n.scrollTop(), r = o + l, c = a ? function() {
-                return e.offset().top - n.offset().top + o;
-            }() : e.offset().top;
-            if (c >= o && c <= r && !e.attr("src")) {
-                var m = e.attr("lay-src");
-                layui.img(m, function() {
-                    var l = t.lazyimg.elem.eq(i);
-                    e.attr("src", m).removeAttr("lay-src");
-                    l[0] && f(l);
-                    i++;
-                });
-            }
-        };
-
-        // 触发懒加载
-        var f = function(e, o) {
-            var f = a ? (o || n).height() : l(window).height(), m = n.scrollTop(), u = m + f;
-            t.lazyimg.elem = l(r);
-            if (e) c(e, f);
-            else {
-                for (var s = 0; s < t.lazyimg.elem.length; s++) {
-                    var v = t.lazyimg.elem.eq(s),
-                        y = a ? function() {
-                            return v.offset().top - n.offset().top + m;
-                        }() : v.offset().top;
-                    if (c(v, f), i = s, y > u) break;
-                }
-            }
-        };
-
-        // 初次加载图片
-        f();
-        if (!o) {
-            var m;
-            n.on("scroll", function() {
-                var e = l(this);
-                m && clearTimeout(m);
-                m = setTimeout(function() {
-                    f(null, e);
-                }, 50);
-            });
-            o = !0;
-        }
-        return f;
-    };
-
-    // 定义模块接口
-    e("flow", new o);
-});
+ ;layui.define("jquery",function(e){"use strict";var l=layui.$,o=function(e){},t='<i class="layui-anim layui-anim-rotate layui-anim-loop layui-icon ">&#xe63e;</i>';o.prototype.load=function(e){var o,i,n,r,a=this,c=0;e=e||{};var f=l(e.elem);if(f[0]){var m=l(e.scrollElem||document),u=e.mb||50,s=!("isAuto"in e)||e.isAuto,v=e.end||"没有更多了",y=e.scrollElem&&e.scrollElem!==document,d="<cite>加载更多</cite>",h=l('<div class="layui-flow-more"><a href="javascript:;">'+d+"</a></div>");f.find(".layui-flow-more")[0]||f.append(h);var p=function(e,t){e=l(e),h.before(e),t=0==t||null,t?h.html(v):h.find("a").html(d),i=t,o=null,n&&n()},g=function(){o=!0,h.find("a").html(t),"function"==typeof e.done&&e.done(++c,p)};if(g(),h.find("a").on("click",function(){l(this);i||o||g()}),e.isLazyimg)var n=a.lazyimg({elem:e.elem+" img",scrollElem:e.scrollElem});return s?(m.on("scroll",function(){var e=l(this),t=e.scrollTop();r&&clearTimeout(r),!i&&f.width()&&(r=setTimeout(function(){var i=y?e.height():l(window).height(),n=y?e.prop("scrollHeight"):document.documentElement.scrollHeight;n-t-i<=u&&(o||g())},100))}),a):a}},o.prototype.lazyimg=function(e){var o,t=this,i=0;e=e||{};var n=l(e.scrollElem||document),r=e.elem||"img",a=e.scrollElem&&e.scrollElem!==document,c=function(e,l){var o=n.scrollTop(),r=o+l,c=a?function(){return e.offset().top-n.offset().top+o}():e.offset().top;if(c>=o&&c<=r&&!e.attr("src")){var m=e.attr("lay-src");layui.img(m,function(){var l=t.lazyimg.elem.eq(i);e.attr("src",m).removeAttr("lay-src"),l[0]&&f(l),i++})}},f=function(e,o){var f=a?(o||n).height():l(window).height(),m=n.scrollTop(),u=m+f;if(t.lazyimg.elem=l(r),e)c(e,f);else for(var s=0;s<t.lazyimg.elem.length;s++){var v=t.lazyimg.elem.eq(s),y=a?function(){return v.offset().top-n.offset().top+m}():v.offset().top;if(c(v,f),i=s,y>u)break}};if(f(),!o){var m;n.on("scroll",function(){var e=l(this);m&&clearTimeout(m),m=setTimeout(function(){f(null,e)},50)}),o=!0}return f},e("flow",new o)});