package com.controller.schoadmin; // 包声明，指定该 Java 类所属的包为 com.controller.schoadmin import com.dao.DeptAdminDao; // 导入自定义的数据访问对象类 DeptAdminDao，用于执行数据库操作 import javax.servlet.ServletException; // 导入 Servlet 异常类，用于处理 Servlet 相关的异常 import javax.servlet.annotation.WebServlet; // 导入用于声明 Servlet 的注解类 import javax.servlet.http.HttpServlet; // 导入 HttpServlet 类，这是所有 HTTP Servlet 的基类 import javax.servlet.http.HttpServletRequest; // 导入用于处理 HTTP 请求的类 import javax.servlet.http.HttpServletResponse; // 导入用于处理 HTTP 响应的类 import java.io.IOException; // 导入用于处理输入输出异常的类 @WebServlet("/SchoDeleteStuServlet") // 使用注解声明该 Servlet 的访问路径为 /SchoDeleteStuServlet public class SchoDeleteStuServlet extends HttpServlet { // 定义一个名为 SchoDeleteStuServlet 的公共类，继承自 HttpServlet @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 重写父类 HttpServlet 的 doGet 方法，处理 HTTP GET 请求，可能会抛出 ServletException 和 IOException 异常 req.setCharacterEncoding("utf-8"); // 设置请求的字符编码为 UTF-8 resp.setCharacterEncoding("utf-8"); // 设置响应的字符编码为 UTF-8 resp.setContentType("text/html;charset=utf-8"); // 设置响应的内容类型为 HTML，字符编码为 UTF-8 String sno = req.getParameter("sno"); // 从请求中获取名为 "sno" 的参数值，并赋值给字符串变量 sno System.out.println(sno); // 在控制台打印输出 sno 的值 String sql = null; // 声明一个字符串变量 sql 并初始化为 null，用于存储 SQL 语句 Object[] objects = {sno}; // 创建一个 Object 类型的数组 objects，包含一个元素 sno //查询是否存在此人 // 注释，说明下面 SQL 语句的作用是查询是否存在该学生 sql = "select count(*) as num from student where sno = ?"; // 构建 SQL 语句，用于统计 student 表中 sno 等于指定值的记录数量，将结果别名为 num int count = DeptAdminDao.findTotalCount(sql, objects); // 调用 DeptAdminDao 类的 findTotalCount 方法执行 SQL 查询，传入 SQL 语句和参数数组，将返回的记录数量赋值给变量 count if (count > 0) { //有则继续操作 // 如果 count 大于 0，说明存在该学生，执行下面的操作 //删除stupunchin中的该导游信息 // 注释，说明下面 SQL 语句的作用是删除 stupunchin 表中该学生的信息 sql = "delete from stupunchin where sno = ?"; // 构建 SQL 语句，用于从 stupunchin 表中删除 sno 等于指定值的记录 int num1 = DeptAdminDao.executeUpdate(sql, objects); // 调用 DeptAdminDao 类的 executeUpdate 方法执行 SQL 删除操作，传入 SQL 语句和参数数组，将受影响的行数赋值给变量 num1 System.out.println(num1); // 在控制台打印输出 num1 的值 //删除student表中该导游信息 // 注释，说明下面 SQL 语句的作用是删除 student 表中该学生的信息 sql = "delete from student where sno = ?"; // 构建 SQL 语句，用于从 student 表中删除 sno 等于指定值的记录 int num2 = DeptAdminDao.executeUpdate(sql, objects); // 调用 DeptAdminDao 类的 executeUpdate 方法执行 SQL 删除操作，传入 SQL 语句和参数数组，将受影响的行数赋值给变量 num2 System.out.println(num2); // 在控制台打印输出 num2 的值 req.getRequestDispatcher("/SchoQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=").forward(req, resp); // 创建请求转发器，将请求转发到 /SchoQueryStuByPageServlet，并附带一些查询参数，然后将请求和响应对象传递给转发器进行转发 }else { // 如果 count 不大于 0，即不存在该学生 req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); // 创建请求转发器，将请求转发到 /view/alluse/noexistdataofdelete.jsp 页面，并将请求和响应对象传递给转发器进行转发 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 重写父类 HttpServlet 的 doPost 方法，处理 HTTP POST 请求，可能会抛出 ServletException 和 IOException 异常 doGet(req, resp); // 调用 doGet 方法来处理 POST 请求，即让 POST 请求的处理逻辑和 GET 请求一致 } } // 声明该类所在的包为 com.controller.schoadmin package com.controller.schoadmin; // 导入 DeptAdminDao 类，该类可能封装了与部门管理员相关的数据库操作方法 import com.dao.DeptAdminDao; // 导入 Servlet 异常类，用于处理 Servlet 操作过程中可能出现的异常 import javax.servlet.ServletException; // 导入 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径 import javax.servlet.annotation.WebServlet; // 导入 HttpServlet 类，这是所有 Servlet 类的基类 import javax.servlet.http.HttpServlet; // 导入 HttpServletRequest 类，用于获取客户端的请求信息 import javax.servlet.http.HttpServletRequest; // 导入 HttpServletResponse 类，用于向客户端发送响应信息 import javax.servlet.http.HttpServletResponse; // 导入输入输出异常类，用于处理输入输出操作中可能出现的异常 import java.io.IOException; // 使用 WebServlet 注解将该类映射到 /SchoDeleteTeaPunchServlet 路径，客户端可通过此路径访问该 Servlet @WebServlet("/SchoDeleteTeaPunchServlet") // 定义 SchoDeleteTeaPunchServlet 类，继承自 HttpServlet，表明这是一个处理 HTTP 请求的 Servlet public class SchoDeleteTeaPunchServlet extends HttpServlet { // 重写 doGet 方法，用于处理客户端的 GET 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 设置请求的字符编码为 UTF-8，防止中文乱码 req.setCharacterEncoding("utf-8"); // 设置响应的字符编码为 UTF-8，防止中文乱码 resp.setCharacterEncoding("utf-8"); // 设置响应的内容类型为 HTML，字符编码为 UTF-8 resp.setContentType("text/html;charset=utf-8"); // 从请求中获取名为 tnodate 的参数，该参数可能包含教师编号和打卡日期 String tnodate = req.getParameter("tnodate"); // 将获取到的 tnodate 参数打印到控制台，用于调试 System.out.println(tnodate); // 使用逗号作为分隔符，将 tnodate 字符串拆分成一个字符串数组 String[] params = tnodate.split(","); // 数组的第一个元素赋值给 tno 变量，代表教师编号 String tno = params[0]; // 数组的第二个元素赋值给 tpunchdate 变量，代表打卡日期 String tpunchdate = params[1]; // 将教师编号打印到控制台，用于调试 System.out.println(tno); // 将打卡日期打印到控制台，用于调试 System.out.println(tpunchdate); // 以下两行代码被注释掉，原计划将字符串类型的日期转换为 Date 类型，但未实际使用 // Date spunchdate1 = new Date(spunchdate); // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); // Date spunchdate1 = ft.format(spunchdate); // 声明一个 SQL 语句变量，用于后续存储 SQL 语句 String sql = null; // 创建一个 Object 数组，用于存储 SQL 查询或更新语句中的参数 Object[] objects = {tno, tpunchdate}; // 构建 SQL 查询语句，用于查询在 teapunchin 表中，指定教师编号和打卡日期的记录数量 sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?"; // 调用 DeptAdminDao 类的 findTotalCount 方法执行查询，返回符合条件的记录数量 int count = DeptAdminDao.findTotalCount(sql, objects); // 如果查询到的记录数量大于 0，说明存在该教师在指定日期的打卡记录 if (count > 0) { // 构建 SQL 删除语句，用于删除 teapunchin 表中指定教师编号和打卡日期的记录 sql = "delete from teapunchin where tno = ? and tpunchdate = ?"; // 调用 DeptAdminDao 类的 executeUpdate 方法执行删除操作，返回受影响的行数 int num1 = DeptAdminDao.executeUpdate(sql, objects); // 将受影响的行数打印到控制台，用于调试 System.out.println(num1); // 将请求转发到 SchoQueryTeaPunchByPageServlet，并传递分页和查询参数，刷新教师打卡记录页面 req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp); } else { // 如果查询到的记录数量为 0，说明不存在该教师在指定日期的打卡记录 // 将请求转发到 noexistdataofdelete.jsp 页面，提示用户要删除的数据不存在 req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); } } // 重写 doPost 方法，用于处理客户端的 POST 请求 @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 调用 doGet 方法处理 POST 请求，实现 GET 和 POST 请求的统一处理 doGet(req, resp); } } // 声明该类所属的包为com.controller.schoadmin，通常用于存放与学校管理员相关的控制器类 package com.controller.schoadmin; // 导入数据访问对象类，用于执行与部门管理员操作相关的数据访问，如数据库查询和更新 import com.dao.DeptAdminDao; // 导入处理Servlet异常的类，当Servlet执行过程中出现异常时会抛出该异常 import javax.servlet.ServletException; // 导入用于将Servlet映射到特定URL的注解 import javax.servlet.annotation.WebServlet; // 导入所有HTTP Servlet的基类 import javax.servlet.http.HttpServlet; // 导入用于封装HTTP请求信息的类 import javax.servlet.http.HttpServletRequest; // 导入用于封装HTTP响应信息的类 import javax.servlet.http.HttpServletResponse; // 导入用于管理用户会话的类，可获取和设置会话中的属性 import javax.servlet.http.HttpSession; // 导入处理输入输出异常的类，当在输入输出操作中发生错误时会抛出该异常 import java.io.IOException; // 使用WebServlet注解将该Servlet映射到/SchoDeleteTeaPunchServlet1路径 @WebServlet("/SchoDeleteTeaPunchServlet1") // 定义一个名为SchoDeleteTeaPunchServlet1的类，继承自HttpServlet，用于处理学校管理员删除教师打卡信息的请求 public class SchoDeleteTeaPunchServlet1 extends HttpServlet { // 重写doGet方法，用于处理HTTP GET请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 设置请求的字符编码为UTF - 8，确保能正确处理包含中文字符等的请求参数 req.setCharacterEncoding("utf-8"); // 设置响应的字符编码为UTF - 8，保证响应内容中的中文字符能正确显示 resp.setCharacterEncoding("utf-8"); // 设置响应的内容类型为HTML，字符编码为UTF - 8，告知客户端返回的是HTML格式的数据 resp.setContentType("text/html;charset=utf-8"); // 从请求中获取名为tno的参数，代表教师编号 String tno = req.getParameter("tno"); // 从请求中获取名为tpunchdate的参数，代表打卡日期 String tpunchdate = req.getParameter("tpunchdate"); // 在控制台打印获取到的教师编号，用于调试，查看是否正确获取参数 System.out.println(tno); // 在控制台打印获取到的打卡日期，用于调试 System.out.println(tpunchdate); // 获取当前请求对应的会话对象 HttpSession session = req.getSession(); // 以下两行代码被注释掉，原本用于从会话中获取用户名和学号，这里未使用 // String userName = (String) session.getAttribute("userName"); // String sno = (String) session.getAttribute("sno"); // 从会话中获取名为belong的属性值，可能代表教师所属部门 String belong = (String) session.getAttribute("belong"); // 以下注释掉的代码原本用于将字符串类型的日期转换为日期类型，但存在错误，转换方式不正确 // 字符串转为日期类型 // Date spunchdate1 = new Date(spunchdate); // 或 // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); // Date spunchdate1 = ft.format(spunchdate); // 声明一个用于存储SQL语句的变量，初始值为null String sql = null; // 创建一个Object数组，用于存储SQL语句中的参数值，包含教师编号和打卡日期 Object[] objects = {tno, tpunchdate}; // 构建SQL查询语句，用于查询数据库中是否存在指定教师编号和打卡日期的记录，count(*) as num用于统计符合条件的记录数 sql = "select count(*) as num from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ?"; // 调用DeptAdminDao类的findTotalCount方法执行SQL查询，获取符合条件的记录数 int count = DeptAdminDao.findTotalCount(sql, objects); // 如果count大于0，说明存在该教师编号和打卡日期对应的记录，可以继续进行删除操作 if (count > 0) { // 构建SQL删除语句，用于从teapunchin表中删除指定教师编号和打卡日期的记录 sql = "delete from teapunchin where tno = ? and tpunchdate = ?"; // 调用DeptAdminDao类的executeUpdate方法执行SQL删除操作，并返回受影响的行数 int num1 = DeptAdminDao.executeUpdate(sql, objects); // 在控制台打印受影响的行数，用于调试，查看删除操作是否成功 System.out.println(num1); // 将请求转发到/SchoQueryTeaPunchByPageServlet，并传递一些参数，可能用于重新查询教师打卡信息列表，当前页码为1，每页显示7条记录，其他查询参数为空 req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp); } else { // 如果count不大于0，说明不存在该教师编号和打卡日期对应的记录，将请求转发到提示不存在要删除数据的页面 req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); } } // 重写doPost方法，用于处理HTTP POST请求，这里直接调用doGet方法，即POST请求的处理逻辑与GET请求相同 @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); } } // 声明该类所在的包名为 com.controller.schoadmin package com.controller.schoadmin; // 导入 DeptAdminDao 类，该类可能包含了与部门管理相关的数据库操作方法 import com.dao.DeptAdminDao; // 导入 Servlet 异常类，用于处理 Servlet 执行过程中可能出现的异常 import javax.servlet.ServletException; // 导入 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径 import javax.servlet.annotation.WebServlet; // 导入 HttpServlet 类，这是所有 Servlet 类的基类 import javax.servlet.http.HttpServlet; // 导入 HttpServletRequest 类，用于获取客户端发送的请求信息 import javax.servlet.http.HttpServletRequest; // 导入 HttpServletResponse 类，用于向客户端发送响应信息 import javax.servlet.http.HttpServletResponse; // 导入输入输出异常类，用于处理输入输出操作可能产生的异常 import java.io.IOException; // 使用 WebServlet 注解将该类映射到 /SchoDeleteTeaServlet 路径，客户端可通过此路径访问该 Servlet @WebServlet("/SchoDeleteTeaServlet") // 定义 SchoDeleteTeaServlet 类，继承自 HttpServlet，表明这是一个处理 HTTP 请求的 Servlet public class SchoDeleteTeaServlet extends HttpServlet { // 重写 doGet 方法，用于处理客户端发送的 HTTP GET 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 设置请求的字符编码为 UTF-8，防止中文等字符出现乱码 req.setCharacterEncoding("utf-8"); // 设置响应的字符编码为 UTF-8，防止响应信息出现乱码 resp.setCharacterEncoding("utf-8"); // 设置响应的内容类型为 HTML，并且字符编码为 UTF-8 resp.setContentType("text/html;charset=utf-8"); // 从请求参数中获取教师编号 tno String tno = req.getParameter("tno"); // 将获取到的教师编号打印到控制台，方便调试 System.out.println(tno); // 声明一个字符串变量 sql，用于存储 SQL 语句 String sql = null; // 创建一个 Object 类型的数组 objects，用于存储 SQL 语句中的参数 Object[] objects = {tno}; // 构建一个 SQL 查询语句，用于查询 teacher 表中是否存在指定教师编号的记录 sql = "select count(*) as num from teacher where tno = ?"; // 调用 DeptAdminDao 类的 findTotalCount 方法执行上述 SQL 查询，返回符合条件的记录数量 int count = DeptAdminDao.findTotalCount(sql, objects); // 如果查询到的记录数量大于 0，说明该教师记录存在 if (count > 0) { // 构建 SQL 删除语句，用于删除 teapunchin 表中该教师的打卡信息 sql = "delete from teapunchin where tno = ?"; // 调用 DeptAdminDao 类的 executeUpdate 方法执行删除操作，返回受影响的行数 int num1 = DeptAdminDao.executeUpdate(sql, objects); // 将受影响的行数打印到控制台，方便调试 System.out.println(num1); // 构建 SQL 删除语句，用于删除 teacher 表中该教师的信息 sql = "delete from teacher where tno = ?"; // 调用 DeptAdminDao 类的 executeUpdate 方法执行删除操作，返回受影响的行数 int num2 = DeptAdminDao.executeUpdate(sql, objects); // 将受影响的行数打印到控制台，方便调试 System.out.println(num2); // 将请求转发到 SchoQueryTeaByPageServlet 并携带分页和查询参数，刷新教师列表页面 req.getRequestDispatcher("/SchoQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=").forward(req, resp); } else { // 如果查询到的记录数量为 0，说明该教师记录不存在 // 将请求转发到 noexistdataofdelete.jsp 页面，提示用户要删除的数据不存在 req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); } } // 重写 doPost 方法，用于处理客户端发送的 HTTP POST 请求 @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 调用 doGet 方法处理 POST 请求，实现 GET 和 POST 请求的统一处理 doGet(req, resp); } } package com.controller.schoadmin; // 声明该类所在的包为 com.controller.schoadmin import com.dao.DeptAdminDao; // 导入自定义的数据访问对象类 DeptAdminDao，用于与数据库进行交互 import javax.servlet.ServletException; // 导入 Servlet 异常类，用于处理 Servlet 操作中可能出现的异常 import javax.servlet.annotation.WebServlet; // 导入用于标注 Servlet 映射路径的注解类 import javax.servlet.http.HttpServlet; // 导入 HttpServlet 类，是所有 HTTP Servlet 的基类 import javax.servlet.http.HttpServletRequest; // 导入用于处理 HTTP 请求的类 import javax.servlet.http.HttpServletResponse; // 导入用于处理 HTTP 响应的类 import java.io.IOException; // 导入输入输出异常类，用于处理输入输出操作时可能出现的异常 @WebServlet("/SchoDelSelectedStuPunchServlet") // 使用注解指定该 Servlet 的访问路径为 /SchoDelSelectedStuPunchServlet public class SchoDelSelectedStuPunchServlet extends HttpServlet { // 定义一个名为 SchoDelSelectedStuPunchServlet 的公共类，继承自 HttpServlet @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 重写 HttpServlet 类的 doGet 方法，用于处理 HTTP GET 请求，可能会抛出 ServletException 和 IOException 异常 req.setCharacterEncoding("utf-8"); // 设置请求的字符编码为 UTF-8，以正确处理中文字符等 resp.setCharacterEncoding("utf-8"); // 设置响应的字符编码为 UTF-8 resp.setContentType("text/html;charset=utf-8"); // 设置响应的内容类型为 HTML，字符编码为 UTF-8 //获取请求时复选框有选中的状态参数 String[] snodates = req.getParameterValues("snodates"); // 从请求中获取名为 "snodates" 的多个参数值，存储在字符串数组 snodates 中 System.out.println(snodates); // 在控制台打印 snodates 数组的引用信息 if(snodates.length > 0 && snodates != null){ // 检查 snodates 数组不为空且有元素 //遍历并删除选中的sno,y一个一个删除 for (String snodate: snodates) { // 遍历 snodates 数组中的每个元素 //分离两个参数 String[] params = snodate.split(","); // 将每个 snodate 字符串按逗号分隔成字符串数组 params String sno = params[0]; // 取出分隔后的第一个元素作为学生编号 sno String spunchdate = params[1]; // 取出分隔后的第二个元素作为打卡日期 spunchdate System.out.println(sno); // 在控制台打印学生编号 sno System.out.println(spunchdate); // 在控制台打印打卡日期 spunchdate //字符串转为日期类型 // Date spunchdate1 = new Date(spunchdate); // 注释掉的代码，尝试将字符串 spunchdate 转换为 Date 类型 //或 // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); // Date spunchdate1 = ft.format(spunchdate); // 注释掉的代码，使用 SimpleDateFormat 将字符串 spunchdate 格式化为日期类型 String sql = null; // 声明一个字符串变量 sql 并初始化为 null，用于存储 SQL 语句 Object[] objects = {sno, spunchdate}; // 创建一个 Object 类型的数组 objects，包含学生编号和打卡日期 //删除stupunchin中的该导游信息 sql = "delete from stupunchin where sno = ? and spunchdate = ?"; // 构建 SQL 语句，用于从 stupunchin 表中删除指定学生编号和打卡日期的记录 int num1 = DeptAdminDao.executeUpdate(sql, objects); // 调用 DeptAdminDao 类的 executeUpdate 方法执行 SQL 删除操作，传入 SQL 语句和参数数组，返回受影响的行数并存储在 num1 中 System.out.println(num1); // 在控制台打印受影响的行数 } req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp); // 创建请求转发器，将请求转发到 /SchoQueryStuPunchByPageServlet 并附带一些查询参数，然后将请求和响应对象传递给转发器进行转发 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 重写 HttpServlet 类的 doPost 方法，用于处理 HTTP POST 请求，可能会抛出 ServletException 和 IOException 异常 doGet(req, resp); // 调用 doGet 方法处理 POST 请求，即让 POST 请求的处理逻辑和 GET 请求相同 } } package com.controller.schoadmin; // 声明该类所在的包为 com.controller.schoadmin import com.dao.DeptAdminDao; // 导入自定义的数据访问对象类 DeptAdminDao，用于与数据库进行交互 import javax.servlet.ServletException; // 导入 Servlet 异常类，用于处理 Servlet 操作中可能出现的异常 import javax.servlet.annotation.WebServlet; // 导入用于标注 Servlet 映射路径的注解类 import javax.servlet.http.HttpServlet; // 导入 HttpServlet 类，是所有 HTTP Servlet 的基类 import javax.servlet.http.HttpServletRequest; // 导入用于处理 HTTP 请求的类 import javax.servlet.http.HttpServletResponse; // 导入用于处理 HTTP 响应的类 import java.io.IOException; // 导入输入输出异常类，用于处理输入输出操作时可能出现的异常 @WebServlet("/SchoDelSelectedStuPunchServlet") // 使用注解指定该 Servlet 的访问路径为 /SchoDelSelectedStuPunchServlet public class SchoDelSelectedStuPunchServlet extends HttpServlet { // 定义一个名为 SchoDelSelectedStuPunchServlet 的公共类，继承自 HttpServlet @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 重写 HttpServlet 类的 doGet 方法，用于处理 HTTP GET 请求，可能会抛出 ServletException 和 IOException 异常 req.setCharacterEncoding("utf-8"); // 设置请求的字符编码为 UTF-8，以正确处理中文字符等 resp.setCharacterEncoding("utf-8"); // 设置响应的字符编码为 UTF-8 resp.setContentType("text/html;charset=utf-8"); // 设置响应的内容类型为 HTML，字符编码为 UTF-8 //获取请求时复选框有选中的状态参数 String[] snodates = req.getParameterValues("snodates"); // 从请求中获取名为 "snodates" 的多个参数值，存储在字符串数组 snodates 中 System.out.println(snodates); // 在控制台打印 snodates 数组的引用信息 if(snodates.length > 0 && snodates != null){ // 检查 snodates 数组不为空且有元素 //遍历并删除选中的sno,y一个一个删除 for (String snodate: snodates) { // 遍历 snodates 数组中的每个元素 //分离两个参数 String[] params = snodate.split(","); // 将每个 snodate 字符串按逗号分隔成字符串数组 params String sno = params[0]; // 取出分隔后的第一个元素作为学生编号 sno String spunchdate = params[1]; // 取出分隔后的第二个元素作为打卡日期 spunchdate System.out.println(sno); // 在控制台打印学生编号 sno System.out.println(spunchdate); // 在控制台打印打卡日期 spunchdate //字符串转为日期类型 // Date spunchdate1 = new Date(spunchdate); // 注释掉的代码，尝试将字符串 spunchdate 转换为 Date 类型 //或 // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); // Date spunchdate1 = ft.format(spunchdate); // 注释掉的代码，使用 SimpleDateFormat 将字符串 spunchdate 格式化为日期类型 String sql = null; // 声明一个字符串变量 sql 并初始化为 null，用于存储 SQL 语句 Object[] objects = {sno, spunchdate}; // 创建一个 Object 类型的数组 objects，包含学生编号和打卡日期 //删除stupunchin中的该导游信息 sql = "delete from stupunchin where sno = ? and spunchdate = ?"; // 构建 SQL 语句，用于从 stupunchin 表中删除指定学生编号和打卡日期的记录 int num1 = DeptAdminDao.executeUpdate(sql, objects); // 调用 DeptAdminDao 类的 executeUpdate 方法执行 SQL 删除操作，传入 SQL 语句和参数数组，返回受影响的行数并存储在 num1 中 System.out.println(num1); // 在控制台打印受影响的行数 } req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp); // 创建请求转发器，将请求转发到 /SchoQueryStuPunchByPageServlet 并附带一些查询参数，然后将请求和响应对象传递给转发器进行转发 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 重写 HttpServlet 类的 doPost 方法，用于处理 HTTP POST 请求，可能会抛出 ServletException 和 IOException 异常 doGet(req, resp); // 调用 doGet 方法处理 POST 请求，即让 POST 请求的处理逻辑和 GET 请求相同 } } package com.controller.schoadmin; import com.dao.DeptAdminDao; 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("/SchoDelSelectedTeaPunchServlet") public class SchoDelSelectedTeaPunchServlet extends HttpServlet { // 声明该类所属的包，表明该类用于处理学校管理员相关的控制器逻辑 package com.controller.schoadmin; // 导入部门管理员数据访问对象类，用于执行数据库操作 import com.dao.DeptAdminDao; // 导入Servlet异常类，用于处理Servlet执行过程中可能出现的异常 import javax.servlet.ServletException; // 导入Servlet注解，用于将该Servlet映射到指定的URL路径 import javax.servlet.annotation.WebServlet; // 导入HttpServlet基类，该类继承自它以处理HTTP请求 import javax.servlet.http.HttpServlet; // 导入HTTP请求对象类，用于获取请求中的参数、属性等信息 import javax.servlet.http.HttpServletRequest; // 导入HTTP响应对象类，用于设置响应的内容、状态码等信息 import javax.servlet.http.HttpServletResponse; // 导入输入输出异常类，用于处理输入输出操作中可能出现的异常 import java.io.IOException; // 使用注解将该Servlet映射到指定的URL路径，客户端通过此路径访问该Servlet @WebServlet("/SchoDelSelectedTeaPunchServlet") // 定义一个继承自HttpServlet的类，用于处理学校管理员删除选中教师打卡信息的请求 public class SchoDelSelectedTeaPunchServlet extends HttpServlet { // 重写doGet方法，用于处理HTTP GET请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 设置请求的字符编码为UTF-8，确保能正确处理包含中文等特殊字符的请求参数 req.setCharacterEncoding("utf-8"); // 设置响应的字符编码为UTF-8，保证响应内容中的特殊字符能正确显示 resp.setCharacterEncoding("utf-8"); // 设置响应的内容类型为HTML，字符编码为UTF-8，告知客户端返回的是HTML格式的数据 resp.setContentType("text/html;charset=utf-8"); // 从请求中获取名为tnodates的参数数组，该数组包含了用户在复选框中选中的教师编号和打卡日期组合 String[] tnodates = req.getParameterValues("tnodates"); // 在控制台打印获取到的参数数组，用于调试 System.out.println(tnodates); // 判断参数数组是否不为空且长度大于0，即是否有选中的记录 if (tnodates.length > 0 && tnodates != null) { // 遍历参数数组，对每个选中的记录进行处理 for (String tnodate : tnodates) { // 将每个组合字符串按逗号分隔成教师编号和打卡日期两个参数 String[] params = tnodate.split(","); // 获取教师编号 String tno = params[0]; // 获取打卡日期 String tpunchdate = params[1]; // 在控制台打印教师编号，用于调试 System.out.println(tno); // 在控制台打印打卡日期，用于调试 System.out.println(tpunchdate); // 以下注释掉的代码原本用于将字符串类型的日期转换为日期类型，但存在错误，转换方式不正确 // 字符串转为日期类型 // Date spunchdate1 = new Date(spunchdate); // 或 // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); // Date spunchdate1 = ft.format(spunchdate); // 声明一个用于存储SQL语句的变量 String sql = null; // 创建一个包含SQL语句参数的对象数组，分别为教师编号和打卡日期 Object[] objects = {tno, tpunchdate}; // 构建SQL删除语句，用于删除教师打卡信息表中指定教师编号和打卡日期的记录 sql = "delete from teapunchin where tno = ? and tpunchdate = ?"; // 调用部门管理员数据访问对象的方法，执行SQL删除操作，并返回受影响的行数 int num1 = DeptAdminDao.executeUpdate(sql, objects); // 在控制台打印受影响的行数，用于调试 System.out.println(num1); } // 将请求转发到分页查询教师打卡信息的Servlet，同时传递一些默认的查询参数，如当前页码为1，每页显示7条记录等 req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp); } } // 重写doPost方法，用于处理HTTP POST请求，这里直接调用doGet方法，即POST请求的处理逻辑与GET请求相同 @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); } } @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { req.setCharacterEncoding("utf-8"); resp.setCharacterEncoding("utf-8"); resp.setContentType("text/html;charset=utf-8"); //获取请求时复选框有选中的状态参数 String[] tnodates = req.getParameterValues("tnodates"); System.out.println(tnodates); if(tnodates.length > 0 && tnodates != null){ //遍历并删除选中的sno,y一个一个删除 for (String tnodate: tnodates) { //分离两个参数 String[] params = tnodate.split(","); String tno = params[0]; String tpunchdate = params[1]; System.out.println(tno); System.out.println(tpunchdate); //字符串转为日期类型 // Date spunchdate1 = new Date(spunchdate); //或 // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); // Date spunchdate1 = ft.format(spunchdate); String sql = null; Object[] objects = {tno, tpunchdate}; //删除stupunchin中的该信息 sql = "delete from teapunchin where tno = ? and tpunchdate = ?"; int num1 = DeptAdminDao.executeUpdate(sql, objects); System.out.println(num1); } req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp); } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); } } // 声明该类所在的包为 com.controller.schoadmin package com.controller.schoadmin; // 导入 com.dao 包下的 DeptAdminDao 类，用于数据访问操作 import com.dao.DeptAdminDao; // 导入 com.entity 包下的 Student 类，用于表示学生实体 import com.entity.Student; // 导入 com.utils 包下的 JDBCUtils 类，用于处理 JDBC 相关操作，如关闭资源等 import com.utils.JDBCUtils; // 导入 Servlet 相关的异常类，用于处理 Servlet 操作中可能出现的异常 import javax.servlet.ServletException; // 导入用于将 Servlet 映射到特定 URL 模式的注解 import javax.servlet.annotation.WebServlet; // 导入 HttpServlet 类，这是所有 Servlet 类的基类 import javax.servlet.http.HttpServlet; // 导入 HttpServletRequest 类，用于处理 HTTP 请求 import javax.servlet.http.HttpServletRequest; // 导入 HttpServletResponse 类，用于处理 HTTP 响应 import javax.servlet.http.HttpServletResponse; // 导入 IOException 类，用于处理输入输出异常 import java.io.IOException; // 导入 ResultSet 类，用于处理 SQL 查询结果集 import java.sql.ResultSet; // 使用 WebServlet 注解将该 Servlet 映射到 "/SchoQueryStuByIdServlet" 路径， // 当客户端请求访问该路径时，该 Servlet 会被触发执行 @WebServlet("/SchoQueryStuByIdServlet") // 定义 SchoQueryStuByIdServlet 类，继承自 HttpServlet 类，表明这是一个 Servlet 类 public class SchoQueryStuByIdServlet extends HttpServlet { // 重写 doGet 方法，用于处理 HTTP GET 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 设置请求的字符编码为 UTF-8，以正确处理中文等字符 req.setCharacterEncoding("utf-8"); // 设置响应的字符编码为 UTF-8，以正确返回中文等字符 resp.setCharacterEncoding("utf-8");//ugu // 设置响应的内容类型为 HTML，字符编码为 UTF-8 resp.setContentType("text/html;charset=utf-8"); // 从请求参数中获取名为 "sno" 的参数值，该值代表学生的学号 String sno = req.getParameter("sno"); // 声明一个 SQL 语句变量，初始化为 null String sql = null; // 创建一个对象数组，用于存储 SQL 查询中的参数，这里存储了学号 Object[] objects = {sno}; // 查询是否存在该学号对应的学生 // 构造 SQL 语句，使用 count(*) 统计满足条件的记录数量，并将结果命名为 num sql = "select count(*) as num from student where sno = ?"; // 调用 DeptAdminDao 类的 findTotalCount 方法，执行 SQL 查询并返回记录数量 int count = DeptAdminDao.findTotalCount(sql, objects); // 如果查询到的记录数量大于 0，说明存在该学生 if (count > 0){ // 构造 SQL 语句，查询该学号对应的学生的所有信息 sql = "select * from student where sno = ?"; // 调用 DeptAdminDao 类的 qureyInfo 方法，执行 SQL 查询并返回结果集 ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); // 创建一个 Student 对象，用于存储查询到的学生信息 Student student = new Student(); try { // 遍历结果集 while (resultSet.next()){ // 从结果集中获取学生的学号，并设置到 Student 对象中 student.setSno(resultSet.getString("sno")); // 从结果集中获取学生的姓名，并设置到 Student 对象中 student.setSname(resultSet.getString("sname")); // 从结果集中获取学生的性别，并设置到 Student 对象中 student.setSsex(resultSet.getString("ssex")); // 从结果集中获取学生的年龄，并设置到 Student 对象中 student.setSage(resultSet.getInt("sage")); // 从结果集中获取学生的班级，并设置到 Student 对象中 student.setSclass(resultSet.getString("sclass")); // 从结果集中获取学生的专业，并设置到 Student 对象中 student.setSpecialty(resultSet.getString("specialty")); // 从结果集中获取学生的系别，并设置到 Student 对象中 student.setSdept(resultSet.getString("sdept")); // 从结果集中获取学生的电话号码，并设置到 Student 对象中 student.setSphone(resultSet.getString("sphone")); // 从结果集中获取学生的密码，并设置到 Student 对象中 student.setSpsw(resultSet.getString("spsw")); } } catch (Exception e) { // 捕获并打印异常堆栈信息 e.printStackTrace(); } finally { // 无论是否发生异常，都关闭结果集以释放资源 JDBCUtils.close(resultSet); } // 打印学生的性别信息，用于调试 System.out.println(student.getSsex()); // 将 Student 对象存储到请求属性中，以便在后续页面中使用 req.setAttribute("student", student); // 使用请求转发将请求转发到 "/view/schoadmin/alterstu.jsp" 页面， // 并携带请求和响应对象，用于修改学生信息 req.getRequestDispatcher("/view/schoadmin/alterstu.jsp").forward(req, resp); } else { // 如果查询到的记录数量为 0，说明不存在该学生 // 使用请求转发将请求转发到 "/view/alluse/noexistdataofalter.jsp" 页面， // 提示用户要修改的数据不存在 req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp); } } // 重写 doPost 方法，用于处理 HTTP POST 请求 @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 对于 POST 请求，直接调用 doGet 方法进行处理，实现请求方法的统一处理 doGet(req, resp); } } package com.controller.schoadmin; // 声明该类所属的包为 com.controller.schoadmin，用于组织和管理学校管理员相关的控制器类 import com.dao.DeptAdminDao; // 导入 com.dao 包下的 DeptAdminDao 类，该类可能包含与部门管理相关的数据访问方法 import com.entity.Student; // 导入 com.entity 包下的 Student 类，该类是学生实体类，用于封装学生的相关信息 import com.utils.JDBCUtils; // 导入 com.utils 包下的 JDBCUtils 类，该类可能包含与 JDBC 操作相关的工具方法，如关闭数据库连接等 import javax.servlet.ServletException; // 导入 javax.servlet 包下的 ServletException 类，用于处理 Servlet 操作中可能出现的异常 import javax.servlet.annotation.WebServlet; // 导入 javax.servlet.annotation 包下的 WebServlet 注解，用于将 Servlet 映射到指定的 URL 路径 import javax.servlet.http.HttpServlet; // 导入 javax.servlet.http 包下的 HttpServlet 类，该类是所有 HTTP Servlet 的基类 import javax.servlet.http.HttpServletRequest; // 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于封装客户端的 HTTP 请求信息 import javax.servlet.http.HttpServletResponse; // 导入 javax.servlet.http 包下的 HttpServletResponse 类，用于封装服务器对客户端的 HTTP 响应信息 import java.io.IOException; // 导入 java.io 包下的 IOException 类，用于处理输入输出操作中可能出现的异常 import java.sql.ResultSet; // 导入 java.sql 包下的 ResultSet 类，用于表示数据库查询的结果集 @WebServlet("/SchoQueryStuByIdServlet") // 使用 WebServlet 注解将该 Servlet 映射到 /SchoQueryStuByIdServlet 路径，当客户端访问该路径时，会调用该 Servlet 的相应方法 public class SchoQueryStuByIdServlet extends HttpServlet { // 继承自 HttpServlet 类，并重写 doGet 和 doPost 方法来处理 HTTP 的 GET 和 POST 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 重写 doGet 方法，用于处理 HTTP GET 请求 req.setCharacterEncoding("utf-8"); // 设置请求的字符编码为 UTF-8，以正确处理中文等字符 resp.setCharacterEncoding("utf-8"); // 设置响应的字符编码为 UTF-8，确保响应内容能正确显示中文等字符 resp.setContentType("text/html;charset=utf-8"); // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8 String sno = req.getParameter("sno"); // 从请求参数中获取名为 sno 的值，该值可能是要查询的学生的学号 String sql = null; // 声明一个字符串类型的变量 sql，用于存储 SQL 语句，初始化为 null Object[] objects = {sno}; // 创建一个包含学号的对象数组，用于作为 SQL 查询的参数 // 查询是否存在此人 sql = "select count(*) as num from student where sno = ?"; // 构造一个 SQL 查询语句，用于统计 student 表中学号等于传入学号的记录数量 int count = DeptAdminDao.findTotalCount(sql, objects); // 调用 DeptAdminDao 类的 findTotalCount 方法执行 SQL 查询，并将结果存储在 count 变量中 if (count > 0) { // 有则继续操作 // 如果查询结果大于 0，说明存在该学号的学生 sql = "select * from student where sno = ?"; // 构造一个 SQL 查询语句，用于查询 student 表中学号等于传入学号的所有记录 ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); // 调用 DeptAdminDao 类的 qureyInfo 方法执行 SQL 查询，并将结果集存储在 resultSet 变量中 Student student = new Student(); // 创建一个 Student 对象，用于存储查询到的学生信息 try { while (resultSet.next()) { // 遍历结果集 student.setSno(resultSet.getString("sno")); // 从结果集中获取学号，并设置到 Student 对象中 student.setSname(resultSet.getString("sname")); // 从结果集中获取姓名，并设置到 Student 对象中 student.setSsex(resultSet.getString("ssex")); // 从结果集中获取性别，并设置到 Student 对象中 student.setSage(resultSet.getInt("sage")); // 从结果集中获取年龄，并设置到 Student 对象中 student.setSclass(resultSet.getString("sclass")); // 从结果集中获取班级，并设置到 Student 对象中 student.setSpecialty(resultSet.getString("specialty")); // 从结果集中获取专业，并设置到 Student 对象中 student.setSdept(resultSet.getString("sdept")); // 从结果集中获取系部，并设置到 Student 对象中 student.setSphone(resultSet.getString("sphone")); // 从结果集中获取电话号码，并设置到 Student 对象中 student.setSpsw(resultSet.getString("spsw")); // 从结果集中获取密码，并设置到 Student 对象中 } } catch (Exception e) { e.printStackTrace(); // 捕获异常并打印异常堆栈信息 } finally { JDBCUtils.close(resultSet); // 无论是否发生异常，都关闭结果集，释放资源 } System.out.println(student.getSsex()); // 打印查询到的学生的性别信息 req.setAttribute("student", student); // 将查询到的 Student 对象存储在请求属性中，以便在后续的 JSP 页面中使用 req.getRequestDispatcher("/view/schoadmin/alterstu.jsp").forward(req, resp); // 将请求转发到 /view/schoadmin/alterstu.jsp 页面，将查询到的学生信息传递给该页面 } else { req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp); // 如果查询结果为 0，说明不存在该学号的学生，将请求转发到 /view/alluse/noexistdataofalter.jsp 页面，提示用户数据不存在 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 重写 doPost 方法，用于处理 HTTP POST 请求 doGet(req, resp); // 调用 doGet 方法处理 POST 请求，即对 POST 请求的处理逻辑与 GET 请求相同 } } // 声明该类所属的包为 com.controller.tea，通常用于存放与教师相关的控制器类 package com.controller.tea; // 导入 com.dao 包下的 StuDao 类，可能用于处理学生相关的数据访问操作，不过在本类中未使用 import com.dao.StuDao; // 导入 com.dao 包下的 TeaDao 类，用于处理教师相关的数据访问操作，如查询教师信息 import com.dao.TeaDao; // 导入 com.entity 包下的 Student 类，代表学生实体，在本类中未使用 import com.entity.Student; // 导入 com.entity 包下的 Teacher 类，代表教师实体，用于封装教师的各种属性 import com.entity.Teacher; // 导入 com.utils 包下的 JDBCUtils 类，通常用于处理 JDBC 操作的工具类，如关闭数据库连接、结果集等 import com.utils.JDBCUtils; // 导入 javax.servlet 包下的 ServletException 类，用于处理 Servlet 操作过程中可能出现的异常 import javax.servlet.ServletException; // 导入 javax.servlet.annotation 包下的 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径 import javax.servlet.annotation.WebServlet; // 导入 javax.servlet.http 包下的 HttpServlet 类，这是所有 HTTP Servlet 的基类，该类继承自它以处理 HTTP 请求 import javax.servlet.http.HttpServlet; // 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息 import javax.servlet.http.HttpServletRequest; // 导入 javax.servlet.http 包下的 HttpServletResponse 类，用于封装服务器发送给客户端的 HTTP 响应信息 import javax.servlet.http.HttpServletResponse; // 导入 javax.servlet.http 包下的 HttpSession 类，用于管理用户会话，存储用户的会话信息 import javax.servlet.http.HttpSession; // 导入 java.io 包下的 IOException 类，用于处理输入输出操作中可能出现的异常 import java.io.IOException; // 导入 java.sql 包下的 ResultSet 类，用于存储数据库查询操作返回的结果集 import java.sql.ResultSet; // 导入 java.util 包下的 ArrayList 类，这是一个动态数组，用于存储 Teacher 对象 import java.util.ArrayList; // 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /TeaQueryInfoServlet @WebServlet("/TeaQueryInfoServlet") // 定义一个名为 TeaQueryInfoServlet 的类，继承自 HttpServlet，用于处理教师信息查询的请求 public class TeaQueryInfoServlet extends HttpServlet { // 重写 doGet 方法，用于处理 HTTP GET 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 设置请求对象的字符编码为 UTF-8，确保能正确处理中文字符等 req.setCharacterEncoding("utf-8"); // 设置响应对象的字符编码为 UTF-8，确保返回给客户端的内容能正确显示中文字符等 resp.setCharacterEncoding("utf-8"); // 设置响应的内容类型为 text/html，字符编码为 UTF-8，告知客户端返回的是 HTML 内容且使用 UTF-8 编码 resp.setContentType("text/html;charset=utf-8"); // 从请求对象中获取当前的会话对象 HttpSession session = req.getSession(); // 从会话对象中获取名为 userName 的属性值，并将其转换为 String 类型 String userName = (String) session.getAttribute("userName"); // 从会话对象中获取名为 tno 的属性值，并将其转换为 String 类型，tno 代表教师编号 String tno = (String) session.getAttribute("tno"); // 在控制台打印用户名 System.out.println(userName); // 在控制台打印教师编号 System.out.println(tno); // 在控制台打印一段调试信息 System.out.println("hdghghjg"); // 定义一个 SQL 查询语句，用于从 teacher 表中查询教师编号等于指定值的所有记录 String sql = "select * from teacher where tno = ?"; // 定义一个 Object 类型的数组，用于存储 SQL 查询语句中的参数值，这里存储的是教师编号 Object[] objects = {tno}; // 调用 TeaDao 类的 qureyInfo 方法执行 SQL 查询，并将查询结果存储在 ResultSet 对象中 ResultSet resultSet = TeaDao.qureyInfo(sql, objects); // 创建一个 ArrayList 对象，用于存储查询到的 Teacher 对象 ArrayList teaArrayList = new ArrayList(); try { // 遍历结果集，判断是否还有下一条记录 while (resultSet.next()){ // 创建一个新的 Teacher 对象 Teacher teacher = new Teacher(); // 从结果集中获取教师编号，并设置到 Teacher 对象中 teacher.setTno(resultSet.getString("tno")); // 从结果集中获取教师姓名，并设置到 Teacher 对象中 teacher.setTname(resultSet.getString("tname")); // 从结果集中获取教师性别，并设置到 Teacher 对象中 teacher.setTsex(resultSet.getString("tsex")); // 从结果集中获取教师年龄，并设置到 Teacher 对象中 teacher.setTage(resultSet.getInt("tage")); // 从结果集中获取教师所在部门，并设置到 Teacher 对象中 teacher.setTdept(resultSet.getString("tdept")); // 从结果集中获取教师电话号码，并设置到 Teacher 对象中 teacher.setTphone(resultSet.getString("tphone")); // 从结果集中获取教师密码，并设置到 Teacher 对象中 teacher.setTpsw(resultSet.getString("tpsw")); // 将填充好信息的 Teacher 对象添加到 ArrayList 中 teaArrayList.add(teacher); } } catch (Exception e) { // 若在遍历结果集过程中出现异常，打印异常堆栈信息 e.printStackTrace(); } finally { // 无论是否出现异常，最后都调用 JDBCUtils 类的 close 方法关闭结果集 JDBCUtils.close(resultSet); } // 在控制台打印存储教师信息的 ArrayList System.out.println(teaArrayList); // 将存储教师信息的 ArrayList 作为属性添加到请求对象中，以便在后续的 JSP 页面中使用 req.setAttribute("teaArrayList", teaArrayList); // 调用请求对象的 getRequestDispatcher 方法获取请求转发器，将请求转发到 /view/tea/teainfo.jsp 页面 req.getRequestDispatcher("/view/tea/teainfo.jsp").forward(req, resp); } // 重写 doPost 方法，用于处理 HTTP POST 请求，这里直接调用 doGet 方法，即 POST 请求的处理逻辑与 GET 请求相同 @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); } } // 声明该类所属的包为 com.controller.tea，通常用于存放与教师相关的控制器类 package com.controller.tea; // 导入 com.dao 包下的 StuDao 类，不过在当前代码中未使用该类，可能后续有扩展需求 import com.dao.StuDao; // 导入 com.dao 包下的 TeaDao 类，该类用于处理与教师相关的数据访问操作，如查询、统计等 import com.dao.TeaDao; // 导入 com.entity 包下的 PageBean 类，用于封装分页信息，辅助实现分页查询功能 import com.entity.PageBean; // 导入 com.entity 包下的 StuPunch 类，代表学生打卡信息实体，此处虽使用但类型可能有误，实际应是 TeaPunch 类型 import com.entity.StuPunch; // 导入 com.entity 包下的 TeaPunch 类，代表教师打卡信息实体，用于封装教师打卡的各项属性 import com.entity.TeaPunch; // 导入 com.utils 包下的 JDBCUtils 类，这是一个工具类，通常用于处理 JDBC 操作，如关闭数据库连接、结果集等 import com.utils.JDBCUtils; // 导入 javax.servlet 包下的 ServletException 类，用于处理 Servlet 操作过程中可能出现的异常 import javax.servlet.ServletException; // 导入 javax.servlet.annotation 包下的 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径 import javax.servlet.annotation.WebServlet; // 导入 javax.servlet.http 包下的 HttpServlet 类，这是所有 HTTP Servlet 的基类，该类继承自它以处理 HTTP 请求 import javax.servlet.http.HttpServlet; // 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息 import javax.servlet.http.HttpServletRequest; // 导入 javax.servlet.http 包下的 HttpServletResponse 类，用于封装服务器发送给客户端的 HTTP 响应信息 import javax.servlet.http.HttpServletResponse; // 导入 javax.servlet.http 包下的 HttpSession 类，用于管理用户会话，存储用户的会话信息 import javax.servlet.http.HttpSession; // 导入 java.io 包下的 IOException 类，用于处理输入输出操作中可能出现的异常 import java.io.IOException; // 导入 java.sql 包下的 ResultSet 类，用于存储数据库查询操作返回的结果集 import java.sql.ResultSet; // 导入 java.util 包下的 ArrayList 类，这是一个动态数组，用于存储 TeaPunch 对象 import java.util.ArrayList; // 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /TeaQueryPunchByPageServlet @WebServlet("/TeaQueryPunchByPageServlet") // 定义一个名为 TeaQueryPunchByPageServlet 的类，继承自 HttpServlet，用于处理教师分页查询打卡信息的请求 public class TeaQueryPunchByPageServlet extends HttpServlet { // 重写 doGet 方法，用于处理 HTTP GET 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 设置请求对象的字符编码为 UTF-8，确保能正确处理中文字符等 req.setCharacterEncoding("utf-8"); // 设置响应对象的字符编码为 UTF-8，确保返回给客户端的内容能正确显示中文字符等 resp.setCharacterEncoding("utf-8"); // 设置响应的内容类型为 text/html，字符编码为 UTF-8，告知客户端返回的是 HTML 内容且使用 UTF-8 编码 resp.setContentType("text/html;charset=utf-8"); // 从请求对象中获取名为 tpunchdate 的参数，该参数用于作为查询教师打卡日期的条件 String tpunchdate = req.getParameter("tpunchdate"); // 如果获取到的 tpunchdate 为 null，则将其赋值为空字符串 if (tpunchdate == null) { tpunchdate = ""; } // 在 tpunchdate 前后添加 % 通配符，用于模糊查询 String tpunchdate1 = "%" + tpunchdate + "%"; // 在控制台打印处理后的 tpunchdate1 System.out.println(tpunchdate1); // 将 tpunchdate 参数添加到请求对象的属性中，以便后续页面使用 req.setAttribute("tpunchdate", tpunchdate); // 从请求对象中获取当前的会话对象 HttpSession session = req.getSession(); // 从会话对象中获取名为 userName 的属性值，并将其转换为 String 类型 String userName = (String) session.getAttribute("userName"); // 从会话对象中获取名为 tno 的属性值，并将其转换为 String 类型，tno 代表教师编号 String tno = (String) session.getAttribute("tno"); // 声明一个 String 类型的变量 sql，用于存储 SQL 查询语句 String sql = null; // 在控制台打印用户名 System.out.println(userName); // 在控制台打印教师编号 System.out.println(tno); // 在控制台打印一段调试信息 System.out.println("hdghghjg"); // 从请求对象中获取名为 currentPage 的参数，该参数表示当前页码 String currentPage = req.getParameter("currentPage"); // 从请求对象中获取名为 rows 的参数，该参数表示每页显示的记录数 String rows = req.getParameter("rows"); // 如果当前页码参数为空或者为空字符串，则将当前页码设置为 1 if (currentPage == null || "".equals(currentPage)) { currentPage = "1"; } // 如果每页显示记录数参数为空或者为空字符串，则将每页显示记录数设置为 8 if (rows == null || "".equals(rows)) { rows = "8"; } // 将当前页码的字符串类型转换为整数类型 int currentPage1 = Integer.parseInt(currentPage); // 将每页显示记录数的字符串类型转换为整数类型 int rows1 = Integer.parseInt(rows); // 如果当前页码小于等于 0，则将当前页码设置为 1 if (currentPage1 <= 0) { currentPage1 = 1; } // 创建一个 PageBean 类型的对象，泛型为 StuPunch（此处类型可能有误，应是 TeaPunch），用于封装分页信息和教师打卡信息 PageBean pageBean = new PageBean(); // 设置 PageBean 对象的当前页码属性 pageBean.setCurrentPage(currentPage1); // 设置 PageBean 对象的每页记录数属性 pageBean.setRows(rows1); // 定义一个 SQL 查询语句，用于查询满足条件的记录总数 sql = " select count(*) as num from teacher t,teapunchin tp where t.tno = tp.tno and tp.tpunchdate like ? and t.tno = ?"; // 定义一个 Object 类型的数组，用于存储 SQL 查询语句中的参数值 Object[] objects = {tpunchdate1, tno}; // 调用 TeaDao 类的 findTotalCount 方法，根据 SQL 语句和参数计算满足条件的总记录数 int totalCount = TeaDao.findTotalCount(sql, objects); // 在控制台打印总记录数 System.out.println(totalCount); // 设置 PageBean 对象的总记录数属性 pageBean.setTotalCount(totalCount); // 如果总记录数大于 0，说明有符合条件的记录 if (totalCount > 0) { // 计算总页数，如果总记录数能被每页记录数整除，则总页数为总记录数除以每页记录数，否则总页数为总记录数除以每页记录数再加 1 int totalPage = (totalCount % rows1) == 0 ? totalCount / rows1 : (totalCount / rows1 + 1); // 设置 PageBean 对象的总页数属性 pageBean.setTotalPage(totalPage); // 如果当前页码大于总页数，则将当前页码设置为总页数 if (currentPage1 > pageBean.getTotalPage()) { currentPage1 = pageBean.getTotalPage(); // 重新设置 PageBean 对象的当前页码属性 pageBean.setCurrentPage(currentPage1); } // 计算当前页开始的记录索引 int start = (currentPage1 - 1) * rows1; // 定义一个 SQL 查询语句，用于查询当前页的教师打卡信息 sql = "select t.tname,tp.* from teacher t,teapunchin tp where t.tno = tp.tno and tp.tpunchdate like ? and tp.tno = ? limit ?, ?"; // 定义一个 Object 类型的数组，用于存储 SQL 查询语句中的参数值 Object[] objects1 = {tpunchdate1, tno, start, rows1}; // 调用 TeaDao 类的 QureyInfoByPage 方法，根据 SQL 语句和参数查询当前页的教师打卡信息，并将结果存储在 ResultSet 对象中 ResultSet resultSet = TeaDao.QureyInfoByPage(sql, objects1); // 创建一个 ArrayList 对象，用于存储查询到的教师打卡信息 ArrayList teaPunchArrayList = new ArrayList(); try { // 遍历结果集，判断是否还有下一条记录 while (resultSet.next()) { // 创建一个新的 TeaPunch 对象 TeaPunch teaPunch = new TeaPunch(); // 从结果集中获取教师姓名，并设置到 TeaPunch 对象中 teaPunch.setTname(resultSet.getString("tname")); // 从结果集中获取是否打卡的信息，并设置到 TeaPunch 对象中 teaPunch.setTispunch(resultSet.getString("tispunch")); // 从结果集中获取打卡日期，并设置到 TeaPunch 对象中 teaPunch.setTpunchdate(resultSet.getDate("tpunchdate")); // 从结果集中获取打卡时间，并设置到 TeaPunch 对象中 teaPunch.setTpunchtime(resultSet.getString("tpunchtime")); // 从结果集中获取是否发热的信息，并设置到 TeaPunch 对象中 teaPunch.setTishot(resultSet.getString("tishot")); // 从结果集中获取是否咳嗽的信息，并设置到 TeaPunch 对象中 teaPunch.setTiscough(resultSet.getString("tiscough")); // 从结果集中获取是否有症状的信息，并设置到 TeaPunch 对象中 teaPunch.setTisseem(resultSet.getString("tisseem")); // 从结果集中获取是否确诊的信息，并设置到 TeaPunch 对象中 teaPunch.setTisdiagnose(resultSet.getString("tisdiagnose")); // 从结果集中获取打卡状态的信息，并设置到 TeaPunch 对象中 teaPunch.setTstatus(resultSet.getString("tstatus")); // 将填充好信息的 TeaPunch 对象添加到 ArrayList 中 teaPunchArrayList.add(teaPunch); } } catch (Exception e) { // 若在遍历结果集过程中出现异常，打印异常堆栈信息 e.printStackTrace(); } finally { // 无论是否出现异常，最后都调用 JDBCUtils 类的 close 方法关闭结果集 JDBCUtils.close(resultSet); } // 将存储教师打卡信息的 ArrayList 设置到 PageBean 对象中 pageBean.setArrayList(teaPunchArrayList); // 在控制台打印存储教师打卡信息的 ArrayList System.out.println(teaPunchArrayList); // 在控制台打印 PageBean 对象 System.out.println(pageBean); // 将 PageBean 对象作为属性添加到请求对象中，以便在后续的 JSP 页面中使用 req.setAttribute("pageBean", pageBean); // 调用请求对象的 getRequestDispatcher 方法获取请求转发器，将请求转发到 /view/tea/teapunchinfo.jsp 页面 req.getRequestDispatcher("/view/tea/teapunchinfo.jsp").forward(req, resp); } else { // 如果总记录数为 0，说明没有符合条件的记录，将请求转发到 /view/alluse/nodata.jsp 页面 req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp); } } // 重写 doPost 方法，用于处理 HTTP POST 请求，这里直接调用 doGet 方法，即 POST 请求的处理逻辑与 GET 请求相同 @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); } } package com.dao; // 声明该类所属的包为 com.dao，包用于组织和管理 Java 类 import com.utils.JDBCUtils; // 导入 com.utils 包下的 JDBCUtils 类，这个类可能包含了一些与 JDBC 操作相关的工具方法， // 例如获取数据库连接、关闭连接等 import java.sql.Connection; // 导入 java.sql 包下的 Connection 类，用于表示与数据库的连接 import java.sql.PreparedStatement; // 导入 java.sql 包下的 PreparedStatement 类，用于执行预编译的 SQL 语句，提高性能和安全性 import java.sql.ResultSet; // 导入 java.sql 包下的 ResultSet 类，用于处理数据库查询返回的结果集 public class DeptAdminDao { // 定义一个静态的 Connection 类型变量，用于存储数据库连接对象，初始化为 null private static Connection connection = null; // 定义一个静态的 PreparedStatement 类型变量，用于存储预编译的 SQL 语句对象，初始化为 null private static PreparedStatement preparedStatement = null; // 定义一个静态的 ResultSet 类型变量，用于存储数据库查询的结果集对象，初始化为 null private static ResultSet resultSet = null; // 用于登录查找的方法，接收 SQL 语句和一个包含查询参数的对象数组作为参数，返回查询结果集 public static ResultSet login(String sql, Object[] objects) { try { // 通过 JDBCUtils 类的 getConnection 方法获取数据库连接，并将其赋值给 connection 变量 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，预编译传入的 SQL 语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将每个参数设置到 PreparedStatement 对象的相应位置（索引从 1 开始） for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行预编译的 SQL 查询语句，并将查询结果存储在 resultSet 变量中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 如果在上述操作中发生异常，打印异常的堆栈跟踪信息，方便调试 e.printStackTrace(); } // 返回查询结果集 return resultSet; } // 用于查询所有表（带限制条件或无限制条件）的数据的方法，接收 SQL 语句和参数数组，返回结果集 public static ResultSet qureyInfo(String sql, Object[] objects){ try { // 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译的 SQL 语句对象 preparedStatement = connection.prepareStatement(sql); // 设置查询参数 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行查询并获取结果集 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 捕获并打印异常信息 e.printStackTrace(); } // 返回查询结果集 return resultSet; } // 查询总记录数的方法，接收 SQL 语句和参数数组，返回查询到的总记录数 public static int findTotalCount(String sql, Object[] objects){ // 定义一个整型变量 num 用于存储总记录数，初始值为 0 int num = 0; try { // 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译的 SQL 语句对象 preparedStatement = connection.prepareStatement(sql); // 设置查询参数 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行查询并获取结果集 resultSet = preparedStatement.executeQuery(); // 将结果集的指针移动到第一行（因为查询的是总记录数，一般只有一行结果） resultSet.next(); // 从结果集中获取名为 "num" 的列的值，并赋值给 num 变量 num = resultSet.getInt("num"); // 打印总记录数（可能用于调试或查看中间结果） System.out.println(num); } catch (Exception e) { // 捕获并打印异常信息 e.printStackTrace(); } finally { // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭结果集、预编译语句对象和数据库连接，释放资源 JDBCUtils.close(resultSet, preparedStatement, connection); } // 返回总记录数 return num; } // 查询每页内容的方法，接收 SQL 语句和参数数组，返回查询结果集 public static ResultSet QureyInfoByPage(String sql, Object[] objects){ try { // 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译的 SQL 语句对象 preparedStatement = connection.prepareStatement(sql); // 设置查询参数 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行查询并获取结果集 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 捕获并打印异常信息 e.printStackTrace(); } // 返回查询结果集 return resultSet; } // 执行更新语句（包括增、删、改操作）的方法，接收 SQL 语句和参数数组，返回受影响的行数 public static int executeUpdate(String sql, Object[] objects){ // 定义一个整型变量 num 用于存储受影响的行数，初始值为 0 int num = 0; try { // 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译的 SQL 语句对象 preparedStatement = connection.prepareStatement(sql); // 设置查询参数 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行更新操作，并将受影响的行数赋值给 num 变量 num = preparedStatement.executeUpdate(); } catch (Exception e) { // 捕获并打印异常信息 e.printStackTrace(); } finally { // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭预编译语句对象和数据库连接，释放资源 JDBCUtils.close(preparedStatement, connection); } // 返回受影响的行数 return num; } } package com.dao; // 声明该类所属的包为 com.dao，包用于组织和管理 Java 类 import com.utils.JDBCUtils; // 导入 com.utils 包下的 JDBCUtils 类，这个类可能包含了一些与 JDBC 操作相关的工具方法， // 例如获取数据库连接、关闭连接等 import java.sql.Connection; // 导入 java.sql 包下的 Connection 类，用于表示与数据库的连接 import java.sql.PreparedStatement; // 导入 java.sql 包下的 PreparedStatement 类，用于执行预编译的 SQL 语句，提高性能和安全性 import java.sql.ResultSet; // 导入 java.sql 包下的 ResultSet 类，用于处理数据库查询返回的结果集 public class DeptAdminDao { // 定义一个静态的 Connection 类型变量，用于存储数据库连接对象，初始化为 null private static Connection connection = null; // 定义一个静态的 PreparedStatement 类型变量，用于存储预编译的 SQL 语句对象，初始化为 null private static PreparedStatement preparedStatement = null; // 定义一个静态的 ResultSet 类型变量，用于存储数据库查询的结果集对象，初始化为 null private static ResultSet resultSet = null; // 用于登录查找的方法，接收 SQL 语句和一个包含查询参数的对象数组作为参数，返回查询结果集 public static ResultSet login(String sql, Object[] objects) { try { // 通过 JDBCUtils 类的 getConnection 方法获取数据库连接，并将其赋值给 connection 变量 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，预编译传入的 SQL 语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将每个参数设置到 PreparedStatement 对象的相应位置（索引从 1 开始） for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行预编译的 SQL 查询语句，并将查询结果存储在 resultSet 变量中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 如果在上述操作中发生异常，打印异常的堆栈跟踪信息，方便调试 e.printStackTrace(); } // 返回查询结果集 return resultSet; } // 用于查询所有表（带限制条件或无限制条件）的数据的方法，接收 SQL 语句和参数数组，返回结果集 public static ResultSet qureyInfo(String sql, Object[] objects){ try { // 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译的 SQL 语句对象 preparedStatement = connection.prepareStatement(sql); // 设置查询参数 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行查询并获取结果集 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 捕获并打印异常信息 e.printStackTrace(); } // 返回查询结果集 return resultSet; } // 查询总记录数的方法，接收 SQL 语句和参数数组，返回查询到的总记录数 public static int findTotalCount(String sql, Object[] objects){ // 定义一个整型变量 num 用于存储总记录数，初始值为 0 int num = 0; try { // 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译的 SQL 语句对象 preparedStatement = connection.prepareStatement(sql); // 设置查询参数 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行查询并获取结果集 resultSet = preparedStatement.executeQuery(); // 将结果集的指针移动到第一行（因为查询的是总记录数，一般只有一行结果） resultSet.next(); // 从结果集中获取名为 "num" 的列的值，并赋值给 num 变量 num = resultSet.getInt("num"); // 打印总记录数（可能用于调试或查看中间结果） System.out.println(num); } catch (Exception e) { // 捕获并打印异常信息 e.printStackTrace(); } finally { // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭结果集、预编译语句对象和数据库连接，释放资源 JDBCUtils.close(resultSet, preparedStatement, connection); } // 返回总记录数 return num; } // 查询每页内容的方法，接收 SQL 语句和参数数组，返回查询结果集 public static ResultSet QureyInfoByPage(String sql, Object[] objects){ try { // 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译的 SQL 语句对象 preparedStatement = connection.prepareStatement(sql); // 设置查询参数 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行查询并获取结果集 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 捕获并打印异常信息 e.printStackTrace(); } // 返回查询结果集 return resultSet; } // 执行更新语句（包括增、删、改操作）的方法，接收 SQL 语句和参数数组，返回受影响的行数 public static int executeUpdate(String sql, Object[] objects){ // 定义一个整型变量 num 用于存储受影响的行数，初始值为 0 int num = 0; try { // 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译的 SQL 语句对象 preparedStatement = connection.prepareStatement(sql); // 设置查询参数 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行更新操作，并将受影响的行数赋值给 num 变量 num = preparedStatement.executeUpdate(); } catch (Exception e) { // 捕获并打印异常信息 e.printStackTrace(); } finally { // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭预编译语句对象和数据库连接，释放资源 JDBCUtils.close(preparedStatement, connection); } // 返回受影响的行数 return num; } } // 声明该类所在的包名为 com.dao package com.dao; // 导入自定义的 JDBC 工具类，该类应该包含了获取数据库连接、关闭资源等操作的方法 import com.utils.JDBCUtils; // 导入 java.sql 包下的 Connection 类，用于表示与数据库的连接 import java.sql.Connection; // 导入 java.sql 包下的 PreparedStatement 类，用于执行预编译的 SQL 语句 import java.sql.PreparedStatement; // 导入 java.sql 包下的 ResultSet 类，用于存储 SQL 查询的结果集 import java.sql.ResultSet; // 定义一个名为 SchoAdminDao 的公共类，用于封装与数据库交互的操作 public class SchoAdminDao { // 声明一个静态的 Connection 类型变量，用于存储数据库连接对象，初始化为 null private static Connection connection = null; // 声明一个静态的 PreparedStatement 类型变量，用于执行预编译的 SQL 语句，初始化为 null private static PreparedStatement preparedStatement = null; // 声明一个静态的 ResultSet 类型变量，用于存储 SQL 查询的结果集，初始化为 null private static ResultSet resultSet = null; /** * 用于登录查找的方法 * @param sql 要执行的 SQL 查询语句 * @param objects SQL 查询语句中的参数数组 * @return 包含查询结果的 ResultSet 对象 */ public static ResultSet login(String sql, Object[] objects) { try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 若发生异常，打印异常堆栈信息 e.printStackTrace(); } // 返回包含查询结果的 ResultSet 对象 return resultSet; } /** * 用于查询所有表（带限制条件或无限制条件）的数据，返回结果集 * @param sql 要执行的 SQL 查询语句 * @param objects SQL 查询语句中的参数数组 * @return 包含查询结果的 ResultSet 对象 */ public static ResultSet qureyInfo(String sql, Object[] objects){ try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 若发生异常，打印异常堆栈信息 e.printStackTrace(); } // 返回包含查询结果的 ResultSet 对象 return resultSet; } /** * 查询总记录数，返回总记录数 * @param sql 要执行的 SQL 查询语句 * @param objects SQL 查询语句中的参数数组 * @return 总记录数 */ public static int findTotalCount(String sql, Object[] objects){ // 声明一个整型变量 num，用于存储总记录数，初始值为 0 int num = 0; try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中 resultSet = preparedStatement.executeQuery(); // 将 ResultSet 的指针移动到下一行（通常查询总记录数的结果只有一行） resultSet.next(); // 从 ResultSet 中获取名为 "num" 的列的值，并赋值给 num 变量 num = resultSet.getInt("num"); // 打印总记录数 System.out.println(num); } catch (Exception e) { // 若发生异常，打印异常堆栈信息 e.printStackTrace(); } finally { // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 ResultSet、PreparedStatement 和 Connection 对象 JDBCUtils.close(resultSet, preparedStatement, connection); } // 返回总记录数 return num; } /** * 查询每页的内容 * @param sql 要执行的 SQL 查询语句 * @param objects SQL 查询语句中的参数数组 * @return 包含查询结果的 ResultSet 对象 */ public static ResultSet QureyInfoByPage(String sql, Object[] objects){ try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 若发生异常，打印异常堆栈信息 e.printStackTrace(); } // 返回包含查询结果的 ResultSet 对象 return resultSet; } /** * 执行更新语句，包括增、删、改操作 * @param sql 要执行的 SQL 更新语句 * @param objects SQL 更新语句中的参数数组 * @return 受影响的行数 */ public static int executeUpdate(String sql, Object[] objects){ // 声明一个整型变量 num，用于存储受影响的行数，初始值为 0 int num = 0; try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 更新语句，并将受影响的行数赋值给 num 变量 num = preparedStatement.executeUpdate(); } catch (Exception e) { // 若发生异常，打印异常堆栈信息 e.printStackTrace(); } finally { // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 PreparedStatement 和 Connection 对象 JDBCUtils.close(preparedStatement, connection); } // 返回受影响的行数 return num; } } // 声明该类所属的包为 com.dao，包用于组织和管理 Java 类，避免命名冲突 package com.dao; // 导入自定义的 JDBC 工具类，该工具类应该封装了获取数据库连接、关闭连接等操作 import com.utils.JDBCUtils; // 导入 java.sql 包中的 Connection 类，用于表示与数据库的连接 import java.sql.Connection; // 导入 java.sql 包中的 PreparedStatement 类，用于执行预编译的 SQL 语句，可防止 SQL 注入 import java.sql.PreparedStatement; // 导入 java.sql 包中的 ResultSet 类，用于存储 SQL 查询操作返回的结果集 import java.sql.ResultSet; // 定义一个公共类 StuDao，该类可能用于处理与学生相关的数据库操作 public class StuDao { // 声明一个静态的 Connection 类型变量，用于存储数据库连接对象，初始值为 null private static Connection connection = null; // 声明一个静态的 PreparedStatement 类型变量，用于执行预编译的 SQL 语句，初始值为 null private static PreparedStatement preparedStatement = null; // 声明一个静态的 ResultSet 类型变量，用于存储 SQL 查询结果集，初始值为 null private static ResultSet resultSet = null; /** * 用于登录查找的方法 * @param sql 要执行的 SQL 查询语句，通常用于验证用户登录信息 * @param objects SQL 查询语句中的参数数组，用于填充 SQL 语句中的占位符 * @return 包含查询结果的 ResultSet 对象 */ public static ResultSet login(String sql, Object[] objects) { try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 若发生异常，打印异常堆栈信息，方便调试 e.printStackTrace(); } // 返回包含查询结果的 ResultSet 对象 return resultSet; } /** * 用于查询所有表（带限制条件或无限制条件）的数据，返回结果集 * @param sql 要执行的 SQL 查询语句 * @param objects SQL 查询语句中的参数数组 * @return 包含查询结果的 ResultSet 对象 */ public static ResultSet qureyInfo(String sql, Object[] objects){ try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 若发生异常，打印异常堆栈信息，方便调试 e.printStackTrace(); } // 返回包含查询结果的 ResultSet 对象 return resultSet; } /** * 查询总记录数，返回总记录数 * @param sql 要执行的 SQL 查询语句，通常用于统计记录数量 * @param objects SQL 查询语句中的参数数组 * @return 总记录数 */ public static int findTotalCount(String sql, Object[] objects){ // 声明一个整型变量 num，用于存储总记录数，初始值为 0 int num = 0; try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中 resultSet = preparedStatement.executeQuery(); // 将 ResultSet 的指针移动到下一行（通常查询总记录数的结果只有一行） resultSet.next(); // 从 ResultSet 中获取名为 "num" 的列的值，并赋值给 num 变量 num = resultSet.getInt("num"); // 打印总记录数，方便调试 System.out.println(num); } catch (Exception e) { // 若发生异常，打印异常堆栈信息，方便调试 e.printStackTrace(); } finally { // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 ResultSet、PreparedStatement 和 Connection 对象 JDBCUtils.close(resultSet, preparedStatement, connection); } // 返回总记录数 return num; } /** * 查询每页的内容 * @param sql 要执行的 SQL 查询语句，通常用于分页查询 * @param objects SQL 查询语句中的参数数组 * @return 包含查询结果的 ResultSet 对象 */ public static ResultSet QureyInfoByPage(String sql, Object[] objects){ try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 若发生异常，打印异常堆栈信息，方便调试 e.printStackTrace(); } // 返回包含查询结果的 ResultSet 对象 return resultSet; } /** * 执行更新语句，包括增、删、改操作 * @param sql 要执行的 SQL 更新语句 * @param objects SQL 更新语句中的参数数组 * @return 受影响的行数 */ public static int executeUpdate(String sql, Object[] objects){ // 声明一个整型变量 num，用于存储受影响的行数，初始值为 0 int num = 0; try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 更新语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 更新语句，并将受影响的行数赋值给 num 变量 num = preparedStatement.executeUpdate(); } catch (Exception e) { // 若发生异常，打印异常堆栈信息，方便调试 e.printStackTrace(); } finally { // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 PreparedStatement 和 Connection 对象 JDBCUtils.close(preparedStatement, connection); } // 返回受影响的行数 return num; } } // 声明该类所属的包为 com.dao，包用于组织和管理 Java 类，避免命名冲突 package com.dao; // 导入自定义的 JDBC 工具类，该工具类应该封装了获取数据库连接、关闭连接等操作 import com.utils.JDBCUtils; // 导入 java.sql 包中的 Connection 类，用于表示与数据库的连接 import java.sql.Connection; // 导入 java.sql 包中的 PreparedStatement 类，用于执行预编译的 SQL 语句，可防止 SQL 注入 import java.sql.PreparedStatement; // 导入 java.sql 包中的 ResultSet 类，用于存储 SQL 查询操作返回的结果集 import java.sql.ResultSet; // 定义一个公共类 StuDao，该类可能用于处理与学生相关的数据库操作 public class StuDao { // 声明一个静态的 Connection 类型变量，用于存储数据库连接对象，初始值为 null private static Connection connection = null; // 声明一个静态的 PreparedStatement 类型变量，用于执行预编译的 SQL 语句，初始值为 null private static PreparedStatement preparedStatement = null; // 声明一个静态的 ResultSet 类型变量，用于存储 SQL 查询结果集，初始值为 null private static ResultSet resultSet = null; /** * 用于登录查找的方法 * @param sql 要执行的 SQL 查询语句，通常用于验证用户登录信息 * @param objects SQL 查询语句中的参数数组，用于填充 SQL 语句中的占位符 * @return 包含查询结果的 ResultSet 对象 */ public static ResultSet login(String sql, Object[] objects) { try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 若发生异常，打印异常堆栈信息，方便调试 e.printStackTrace(); } // 返回包含查询结果的 ResultSet 对象 return resultSet; } /** * 用于查询所有表（带限制条件或无限制条件）的数据，返回结果集 * @param sql 要执行的 SQL 查询语句 * @param objects SQL 查询语句中的参数数组 * @return 包含查询结果的 ResultSet 对象 */ public static ResultSet qureyInfo(String sql, Object[] objects){ try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 若发生异常，打印异常堆栈信息，方便调试 e.printStackTrace(); } // 返回包含查询结果的 ResultSet 对象 return resultSet; } /** * 查询总记录数，返回总记录数 * @param sql 要执行的 SQL 查询语句，通常用于统计记录数量 * @param objects SQL 查询语句中的参数数组 * @return 总记录数 */ public static int findTotalCount(String sql, Object[] objects){ // 声明一个整型变量 num，用于存储总记录数，初始值为 0 int num = 0; try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中 resultSet = preparedStatement.executeQuery(); // 将 ResultSet 的指针移动到下一行（通常查询总记录数的结果只有一行） resultSet.next(); // 从 ResultSet 中获取名为 "num" 的列的值，并赋值给 num 变量 num = resultSet.getInt("num"); // 打印总记录数，方便调试 System.out.println(num); } catch (Exception e) { // 若发生异常，打印异常堆栈信息，方便调试 e.printStackTrace(); } finally { // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 ResultSet、PreparedStatement 和 Connection 对象 JDBCUtils.close(resultSet, preparedStatement, connection); } // 返回总记录数 return num; } /** * 查询每页的内容 * @param sql 要执行的 SQL 查询语句，通常用于分页查询 * @param objects SQL 查询语句中的参数数组 * @return 包含查询结果的 ResultSet 对象 */ public static ResultSet QureyInfoByPage(String sql, Object[] objects){ try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 若发生异常，打印异常堆栈信息，方便调试 e.printStackTrace(); } // 返回包含查询结果的 ResultSet 对象 return resultSet; } /** * 执行更新语句，包括增、删、改操作 * @param sql 要执行的 SQL 更新语句 * @param objects SQL 更新语句中的参数数组 * @return 受影响的行数 */ public static int executeUpdate(String sql, Object[] objects){ // 声明一个整型变量 num，用于存储受影响的行数，初始值为 0 int num = 0; try { // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接 connection = JDBCUtils.getConnection(); // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 更新语句 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中 for (int i = 0; i < objects.length; i++) { // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1 preparedStatement.setObject(i + 1, objects[i]); } // 执行 SQL 更新语句，并将受影响的行数赋值给 num 变量 num = preparedStatement.executeUpdate(); } catch (Exception e) { // 若发生异常，打印异常堆栈信息，方便调试 e.printStackTrace(); } finally { // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 PreparedStatement 和 Connection 对象 JDBCUtils.close(preparedStatement, connection); } // 返回受影响的行数 return num; } } // 声明该类所在的包为 com.dao package com.dao; // 导入 JDBCUtils 工具类，该类用于管理 JDBC 连接等操作 import com.utils.JDBCUtils; // 导入 Java 数据库连接相关的类，用于操作数据库 import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; // 定义 TeaDao 类，该类可能用于对教师相关数据进行数据库操作 public class TeaDao { // 声明静态的数据库连接对象，用于保持与数据库的连接 private static Connection connection = null; // 声明静态的预编译语句对象，用于执行 SQL 语句 private static PreparedStatement preparedStatement = null; // 声明静态的结果集对象，用于存储数据库查询结果 private static ResultSet resultSet = null; // 定义 login 方法，用于执行登录相关的数据库查询操作，返回结果集 // sql 参数表示要执行的 SQL 查询语句 // objects 参数是一个包含查询参数的数组 public static ResultSet login(String sql, Object[] objects) { try { // 通过 JDBCUtils 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译语句对象，将 SQL 语句传入 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到预编译语句中 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行查询操作，并将结果存储到结果集对象中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 如果在执行过程中出现异常，打印异常堆栈信息 e.printStackTrace(); } // 返回查询结果集 return resultSet; } // 定义 qureyInfo 方法，用于执行带条件或不带条件的数据库查询操作，返回结果集 // sql 参数表示要执行的 SQL 查询语句 // objects 参数是一个包含查询参数的数组 public static ResultSet qureyInfo(String sql, Object[] objects){ try { // 通过 JDBCUtils 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译语句对象，将 SQL 语句传入 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到预编译语句中 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行查询操作，并将结果存储到结果集对象中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 如果在执行过程中出现异常，打印异常堆栈信息 e.printStackTrace(); } // 返回查询结果集 return resultSet; } // 定义 findTotalCount 方法，用于查询符合条件的总记录数，返回总记录数 // sql 参数表示要执行的 SQL 查询语句，用于统计记录数 // objects 参数是一个包含查询参数的数组 public static int findTotalCount(String sql, Object[] objects){ // 初始化记录数变量为 0 int num = 0; try { // 通过 JDBCUtils 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译语句对象，将 SQL 语句传入 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到预编译语句中 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行查询操作，并将结果存储到结果集对象中 resultSet = preparedStatement.executeQuery(); // 将结果集指针移动到第一行（因为结果集中只有一行记录，即统计的总记录数） resultSet.next(); // 从结果集中获取名为 "num" 的列的值，即总记录数 num = resultSet.getInt("num"); // 打印总记录数到控制台，用于调试 System.out.println(num); } catch (Exception e) { // 如果在执行过程中出现异常，打印异常堆栈信息 e.printStackTrace(); } finally { // 调用 JDBCUtils 的方法关闭结果集、预编译语句和数据库连接，释放资源 JDBCUtils.close(resultSet, preparedStatement, connection); } // 返回总记录数 return num; } // 定义 QureyInfoByPage 方法，用于查询每页的内容，返回结果集 // sql 参数表示要执行的 SQL 查询语句，用于获取指定页的数据 // objects 参数是一个包含查询参数的数组 public static ResultSet QureyInfoByPage(String sql, Object[] objects){ try { // 通过 JDBCUtils 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译语句对象，将 SQL 语句传入 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到预编译语句中 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行查询操作，并将结果存储到结果集对象中 resultSet = preparedStatement.executeQuery(); } catch (Exception e) { // 如果在执行过程中出现异常，打印异常堆栈信息 e.printStackTrace(); } // 返回查询结果集 return resultSet; } // 定义 executeUpdate 方法，用于执行数据库的增、删、改操作，返回受影响的行数 // sql 参数表示要执行的 SQL 语句，如插入、删除、更新语句 // objects 参数是一个包含操作参数的数组 public static int executeUpdate(String sql, Object[] objects){ // 初始化受影响的行数变量为 0 int num = 0; try { // 通过 JDBCUtils 获取数据库连接 connection = JDBCUtils.getConnection(); // 创建预编译语句对象，将 SQL 语句传入 preparedStatement = connection.prepareStatement(sql); // 遍历参数数组，将参数依次设置到预编译语句中 for (int i = 0; i < objects.length; i++) { preparedStatement.setObject(i + 1, objects[i]); } // 执行更新操作，并返回受影响的行数 num = preparedStatement.executeUpdate(); } catch (Exception e) { // 如果在执行过程中出现异常，打印异常堆栈信息 e.printStackTrace(); } finally { // 调用 JDBCUtils 的方法关闭预编译语句和数据库连接，释放资源 JDBCUtils.close(preparedStatement, connection); } // 返回受影响的行数 return num; } } package com.entity; // 声明该类所属的包为 com.entity，包用于对类进行组织和管理，方便代码的维护和复用 import java.util.Date; // 导入 java.util 包下的 Date 类，用于表示日期和时间 public class News { // 定义一个私有字符串类型的变量 title，用于存储新闻的标题 private String title; // 定义一个私有字符串类型的变量 url，用于存储新闻的链接地址 private String url; // 定义一个私有 Date 类型的变量 pubdate，用于存储新闻的发布日期 private Date pubdate; // 这是一个设置新闻标题的方法，接收一个字符串类型的参数 title public void setTitle(String title) { // 将传入的参数值赋给当前类的成员变量 title this.title = title; } // 这是一个设置新闻链接的方法，接收一个字符串类型的参数 url public void setUrl(String url) { // 将传入的参数值赋给当前类的成员变量 url this.url = url; } // 这是一个设置新闻发布日期的方法，接收一个 Date 类型的参数 pubdate public void setPubdate(Date pubdate) { // 将传入的参数值赋给当前类的成员变量 pubdate this.pubdate = pubdate; } // 这是一个获取新闻标题的方法，返回值类型为字符串 public String getTitle() { // 返回当前类的成员变量 title 的值 return title; } // 这是一个获取新闻链接的方法，返回值类型为字符串 public String getUrl() { // 返回当前类的成员变量 url 的值 return url; } // 这是一个获取新闻发布日期的方法，返回值类型为 Date public Date getPubdate() { // 返回当前类的成员变量 pubdate 的值 return pubdate; } // 重写了父类 Object 的 toString 方法，用于将 News 对象以字符串的形式表示 @Override public String toString() { // 返回一个包含新闻标题、链接和发布日期的字符串，格式为 "News{title='xxx', url='xxx', pubdate=xxx}" return "News{" + "title='" + title + '\'' + ", url='" + url + '\'' + ", pubdate=" + pubdate + '}'; } } // 声明该类所属的包为 com.entity，包用于组织和管理 Java 类，避免命名冲突 package com.entity; // 导入 java.util 包中的 ArrayList 类，用于存储每页的数据 import java.util.ArrayList; /** * 泛型类 PageBean，用于封装分页信息 * @param 泛型类型，表示每页数据的类型 */ public class PageBean { // 定义一个整型变量 totalCount，用于存储总记录数 private int totalCount; // 定义一个整型变量 totalPage，用于存储总页码数 private int totalPage; // 定义一个泛型类型的 ArrayList 变量 arrayList，用于存储每页的数据 private ArrayList arrayList; // 定义一个整型变量 currentPage，用于存储当前页码 private int currentPage; // 定义一个整型变量 rows，用于存储每页显示的记录数 private int rows; /** * 设置总记录数的方法 * @param totalCount 要设置的总记录数 */ public void setTotalCount(int totalCount) { // 将传入的总记录数赋值给类的成员变量 totalCount this.totalCount = totalCount; } /** * 设置总页码数的方法 * @param totalPage 要设置的总页码数 */ public void setTotalPage(int totalPage) { // 将传入的总页码数赋值给类的成员变量 totalPage this.totalPage = totalPage; } /** * 设置每页数据的方法 * @param arrayList 要设置的每页数据的 ArrayList */ public void setArrayList(ArrayList arrayList) { // 将传入的 ArrayList 赋值给类的成员变量 arrayList this.arrayList = arrayList; } /** * 设置当前页码的方法 * @param currentPage 要设置的当前页码 */ public void setCurrentPage(int currentPage) { // 将传入的当前页码赋值给类的成员变量 currentPage this.currentPage = currentPage; } /** * 设置每页记录数的方法 * @param rows 要设置的每页记录数 */ public void setRows(int rows) { // 将传入的每页记录数赋值给类的成员变量 rows this.rows = rows; } /** * 获取总记录数的方法 * @return 总记录数 */ public int getTotalCount() { // 返回类的成员变量 totalCount 的值 return totalCount; } /** * 获取总页码数的方法 * @return 总页码数 */ public int getTotalPage() { // 返回类的成员变量 totalPage 的值 return totalPage; } /** * 获取每页数据的方法 * @return 存储每页数据的 ArrayList */ public ArrayList getArrayList() { // 返回类的成员变量 arrayList 的值 return arrayList; } /** * 获取当前页码的方法 * @return 当前页码 */ public int getCurrentPage() { // 返回类的成员变量 currentPage 的值 return currentPage; } /** * 获取每页记录数的方法 * @return 每页记录数 */ public int getRows() { // 返回类的成员变量 rows 的值 return rows; } /** * 重写 toString 方法，用于将对象的信息以字符串形式输出 * @return 包含对象属性信息的字符串 */ @Override public String toString() { return "PageBean1{" + // 拼接总记录数 "totalCount=" + totalCount + // 拼接总页码数 ", totalPage=" + totalPage + // 拼接每页数据的 ArrayList ", arrayList=" + arrayList + // 拼接当前页码 ", currentPage=" + currentPage + // 拼接每页记录数 ", rows=" + rows + '}'; } } package com.entity; // 声明该类所属的包为 com.entity，包用于对类进行组织和管理，方便在项目中找到和使用相关的类 public class Student { // 定义一个私有字符串类型的变量 sno，用于存储学生的学号 private String sno; // 定义一个私有字符串类型的变量 sname，用于存储学生的姓名 private String sname; // 定义一个私有字符串类型的变量 ssex，用于存储学生的性别 private String ssex; // 定义一个私有整数类型的变量 sage，用于存储学生的年龄 private int sage; // 定义一个私有字符串类型的变量 sclass，用于存储学生的班级 private String sclass; // 定义一个私有字符串类型的变量 specialty，用于存储学生的专业 private String specialty; // 定义一个私有字符串类型的变量 sdept，用于存储学生的所在系部 private String sdept; // 定义一个私有字符串类型的变量 sphone，用于存储学生的电话号码 private String sphone; // 定义一个私有字符串类型的变量 spsw，用于存储学生的密码 private String spsw; // 这是一个设置学生学号的方法，接收一个字符串类型的参数 sno public void setSno(String sno) { // 将传入的参数值赋给当前类的成员变量 sno this.sno = sno; } // 这是一个设置学生姓名的方法，接收一个字符串类型的参数 sname public void setSname(String sname) { // 将传入的参数值赋给当前类的成员变量 sname this.sname = sname; } // 这是一个设置学生性别的方法，接收一个字符串类型的参数 ssex public void setSsex(String ssex) { // 将传入的参数值赋给当前类的成员变量 ssex this.ssex = ssex; } // 这是一个设置学生年龄的方法，接收一个整数类型的参数 sage public void setSage(int sage) { // 将传入的参数值赋给当前类的成员变量 sage this.sage = sage; } // 这是一个设置学生班级的方法，接收一个字符串类型的参数 sclass public void setSclass(String sclass) { // 将传入的参数值赋给当前类的成员变量 sclass this.sclass = sclass; } // 这是一个设置学生专业的方法，接收一个字符串类型的参数 specialty public void setSpecialty(String specialty) { // 将传入的参数值赋给当前类的成员变量 specialty this.specialty = specialty; } // 这是一个设置学生所在系部的方法，接收一个字符串类型的参数 sdept public void setSdept(String sdept) { // 将传入的参数值赋给当前类的成员变量 sdept this.sdept = sdept; } // 这是一个设置学生电话号码的方法，接收一个字符串类型的参数 sphone public void setSphone(String sphone) { // 将传入的参数值赋给当前类的成员变量 sphone this.sphone = sphone; } // 这是一个设置学生密码的方法，接收一个字符串类型的参数 spsw public void setSpsw(String spsw) { // 将传入的参数值赋给当前类的成员变量 spsw this.spsw = spsw; } // 这是一个获取学生学号的方法，返回值类型为字符串 public String getSno() { // 返回当前类的成员变量 sno 的值 return sno; } // 这是一个获取学生姓名的方法，返回值类型为字符串 public String getSname() { // 返回当前类的成员变量 sname 的值 return sname; } // 这是一个获取学生性别的方法，返回值类型为字符串 public String getSsex() { // 返回当前类的成员变量 ssex 的值 return ssex; } // 这是一个获取学生年龄的方法，返回值类型为整数 public int getSage() { // 返回当前类的成员变量 sage 的值 return sage; } // 这是一个获取学生班级的方法，返回值类型为字符串 public String getSclass() { // 返回当前类的成员变量 sclass 的值 return sclass; } // 这是一个获取学生专业的方法，返回值类型为字符串 public String getSpecialty() { // 返回当前类的成员变量 specialty 的值 return specialty; } // 这是一个获取学生所在系部的方法，返回值类型为字符串 public String getSdept() { // 返回当前类的成员变量 sdept 的值 return sdept; } // 这是一个获取学生电话号码的方法，返回值类型为字符串 public String getSphone() { // 返回当前类的成员变量 sphone 的值 return sphone; } // 这是一个获取学生密码的方法，返回值类型为字符串 public String getSpsw() { // 返回当前类的成员变量 spsw 的值 return spsw; } // 重写了父类 Object 的 toString 方法，用于将 Student 对象以字符串的形式表示 @Override public String toString() { // 返回一个包含学生各项信息的字符串，格式为 "Student{sno='xxx', sname='xxx', ssex='xxx', sage=xxx, sclass='xxx', specialty='xxx', sdept='xxx', sphone='xxx', spsw='xxx'}" return "Student{" + "sno='" + sno + '\'' + ", sname='" + sname + '\'' + ", ssex='" + ssex + '\'' + ", sage=" + sage + ", sclass='" + sclass + '\'' + ", specialty='" + specialty + '\'' + ", sdept='" + sdept + '\'' + ", sphone='" + sphone + '\'' + ", spsw='" + spsw + '\'' + '}'; } } // 声明该类所属的包为 com.entity，包用于组织和管理 Java 类，避免命名冲突 package com.entity; // 导入 java.sql 包中的 Date 类，用于表示日期 import java.sql.Date; // 导入 java.sql 包中的 Timestamp 类，用于表示包含日期和时间的时间戳（这里未使用到） import java.sql.Timestamp; // 导入 java.text 包中的 SimpleDateFormat 类，用于格式化日期和时间（这里未使用到） import java.text.SimpleDateFormat; /** * 定义一个名为 StuPunch 的类，用于表示学生打卡相关信息的实体类 */ public class StuPunch { // 学生学号，字符串类型 private String sno; // 学生姓名，字符串类型 private String sname; // 学生所在班级，字符串类型 private String sclass; // 学生专业，字符串类型 private String specialty; // 学生所在系部，字符串类型 private String sdept; // 学生是否打卡的标识，字符串类型（例如 "是" 或 "否" 等） private String sispunch; // 学生打卡日期，Date 类型 private Date spunchdate; // 学生打卡时间，字符串类型 private String spunchtime; // 学生是否发热的标识，字符串类型（例如 "是" 或 "否" 等） private String sishot; // 学生是否咳嗽的标识，字符串类型（例如 "是" 或 "否" 等） private String siscough; // 学生的表观症状描述，字符串类型 private String sisseem; // 学生的诊断结果，字符串类型 private String sisdiagnose; // 学生的状态，字符串类型 private String sstatus; /** * 设置学生学号的方法 * @param sno 要设置的学生学号 */ public void setSno(String sno) { // 将传入的学号赋值给类的成员变量 sno this.sno = sno; } /** * 设置学生姓名的方法 * @param sname 要设置的学生姓名 */ public void setSname(String sname) { // 将传入的姓名赋值给类的成员变量 sname this.sname = sname; } /** * 设置学生所在班级的方法 * @param sclass 要设置的学生所在班级 */ public void setSclass(String sclass) { // 将传入的班级赋值给类的成员变量 sclass this.sclass = sclass; } /** * 设置学生所在系部的方法 * @param sdept 要设置的学生所在系部 */ public void setSdept(String sdept) { // 将传入的系部赋值给类的成员变量 sdept this.sdept = sdept; } /** * 设置学生专业的方法 * @param specialty 要设置的学生专业 */ public void setSpecialty(String specialty) { // 将传入的专业赋值给类的成员变量 specialty this.specialty = specialty; } /** * 设置学生是否打卡标识的方法 * @param sispunch 要设置的学生是否打卡标识 */ public void setSispunch(String sispunch) { // 将传入的是否打卡标识赋值给类的成员变量 sispunch this.sispunch = sispunch; } /** * 设置学生打卡日期的方法 * @param spunchdate 要设置的学生打卡日期 */ public void setSpunchdate(Date spunchdate) { // 将传入的打卡日期赋值给类的成员变量 spunchdate this.spunchdate = spunchdate; } /** * 设置学生打卡时间的方法 * @param spunchtime 要设置的学生打卡时间 */ public void setSpunchtime(String spunchtime) { // 将传入的打卡时间赋值给类的成员变量 spunchtime this.spunchtime = spunchtime; } /** * 设置学生是否发热标识的方法 * @param sishot 要设置的学生是否发热标识 */ public void setSishot(String sishot) { // 将传入的是否发热标识赋值给类的成员变量 sishot this.sishot = sishot; } /** * 设置学生是否咳嗽标识的方法 * @param siscough 要设置的学生是否咳嗽标识 */ public void setSiscough(String siscough) { // 将传入的是否咳嗽标识赋值给类的成员变量 siscough this.siscough = siscough; } /** * 设置学生表观症状描述的方法 * @param sisseem 要设置的学生表观症状描述 */ public void setSisseem(String sisseem) { // 将传入的表观症状描述赋值给类的成员变量 sisseem this.sisseem = sisseem; } /** * 设置学生诊断结果的方法 * @param sisdiagnose 要设置的学生诊断结果 */ public void setSisdiagnose(String sisdiagnose) { // 将传入的诊断结果赋值给类的成员变量 sisdiagnose this.sisdiagnose = sisdiagnose; } /** * 设置学生状态的方法 * @param sstatus 要设置的学生状态 */ public void setSstatus(String sstatus) { // 将传入的学生状态赋值给类的成员变量 sstatus this.sstatus = sstatus; } /** * 获取学生学号的方法 * @return 学生学号 */ public String getSno() { // 返回类的成员变量 sno 的值 return sno; } /** * 获取学生姓名的方法 * @return 学生姓名 */ public String getSname() { // 返回类的成员变量 sname 的值 return sname; } /** * 获取学生所在班级的方法 * @return 学生所在班级 */ public String getSclass() { // 返回类的成员变量 sclass 的值 return sclass; } /** * 获取学生专业的方法 * @return 学生专业 */ public String getSpecialty() { // 返回类的成员变量 specialty 的值 return specialty; } /** * 获取学生所在系部的方法 * @return 学生所在系部 */ public String getSdept() { // 返回类的成员变量 sdept 的值 return sdept; } /** * 获取学生是否打卡标识的方法 * @return 学生是否打卡标识 */ public String getSispunch() { // 返回类的成员变量 sispunch 的值 return sispunch; } /** * 获取学生打卡日期的方法 * @return 学生打卡日期 */ public Date getSpunchdate() { // 返回类的成员变量 spunchdate 的值 return spunchdate; } /** * 获取学生打卡时间的方法 * @return 学生打卡时间 */ public String getSpunchtime() { // 返回类的成员变量 spunchtime 的值 return spunchtime; } /** * 获取学生是否发热标识的方法 * @return 学生是否发热标识 */ public String getSishot() { // 返回类的成员变量 sishot 的值 return sishot; } /** * 获取学生是否咳嗽标识的方法 * @return 学生是否咳嗽标识 */ public String getSiscough() { // 返回类的成员变量 siscough 的值 return siscough; } /** * 获取学生表观症状描述的方法 * @return 学生表观症状描述 */ public String getSisseem() { // 返回类的成员变量 sisseem 的值 return sisseem; } /** * 获取学生诊断结果的方法 * @return 学生诊断结果 */ public String getSisdiagnose() { // 返回类的成员变量 sisdiagnose 的值 return sisdiagnose; } /** * 获取学生状态的方法 * @return 学生状态 */ public String getSstatus() { // 返回类的成员变量 sstatus 的值 return sstatus; } /** * 重写 toString 方法，用于将对象的信息以字符串形式输出 * @return 包含对象属性信息的字符串 */ @Override public String toString() { return "StuPunch{" + // 拼接学生学号 "sno='" + sno + '\'' + // 拼接学生姓名 ", sname='" + sname + '\'' + // 拼接学生所在班级 ", sclass='" + sclass + '\'' + // 拼接学生专业 ", specialty='" + specialty + '\'' + // 拼接学生所在系部 ", sdept='" + sdept + '\'' + // 拼接学生是否打卡标识 ", sispunch='" + sispunch + '\'' + // 拼接学生打卡日期 ", spunchdate=" + spunchdate + // 拼接学生打卡时间 ", spunchtime='" + spunchtime + '\'' + // 拼接学生是否发热标识 ", sishot='" + sishot + '\'' + // 拼接学生是否咳嗽标识 ", siscough='" + siscough + '\'' + // 拼接学生表观症状描述 ", sisseem='" + sisseem + '\'' + // 拼接学生诊断结果 ", sisdiagnose='" + sisdiagnose + '\'' + // 拼接学生状态 ", sstatus='" + sstatus + '\'' + '}'; } } // 声明该类所属的包，通常用于存放实体类 package com.entity; // 定义一个名为Teacher的类，用于表示教师实体 public class Teacher { // 定义私有属性tno，用于存储教师编号 private String tno; // 定义私有属性tname，用于存储教师姓名 private String tname; // 定义私有属性tsex，用于存储教师性别 private String tsex; // 定义私有属性tage，用于存储教师年龄 private int tage; // 定义私有属性tdept，用于存储教师所属部门 private String tdept; // 定义私有属性tphone，用于存储教师联系电话 private String tphone; // 定义私有属性tpsw，用于存储教师密码 private String tpsw; // 定义setTno方法，用于设置教师编号 public void setTno(String tno) { // 将传入的参数tno赋值给类的私有属性tno this.tno = tno; } // 定义setTname方法，用于设置教师姓名 public void setTname(String tname) { // 将传入的参数tname赋值给类的私有属性tname this.tname = tname; } // 定义setTsex方法，用于设置教师性别 public void setTsex(String tsex) { // 将传入的参数tsex赋值给类的私有属性tsex this.tsex = tsex; } // 定义setTage方法，用于设置教师年龄 public void setTage(int tage) { // 将传入的参数tage赋值给类的私有属性tage this.tage = tage; } // 定义setTdept方法，用于设置教师所属部门 public void setTdept(String tdept) { // 将传入的参数tdept赋值给类的私有属性tdept this.tdept = tdept; } // 定义setTphone方法，用于设置教师联系电话 public void setTphone(String tphone) { // 将传入的参数tphone赋值给类的私有属性tphone this.tphone = tphone; } // 定义setTpsw方法，用于设置教师密码 public void setTpsw(String tpsw) { // 将传入的参数tpsw赋值给类的私有属性tpsw this.tpsw = tpsw; } // 定义getTno方法，用于获取教师编号 public String getTno() { // 返回类的私有属性tno的值 return tno; } // 定义getTname方法，用于获取教师姓名 public String getTname() { // 返回类的私有属性tname的值 return tname; } // 定义getTsex方法，用于获取教师性别 public String getTsex() { // 返回类的私有属性tsex的值 return tsex; } // 定义getTage方法，用于获取教师年龄 public int getTage() { // 返回类的私有属性tage的值 return tage; } // 定义getTdept方法，用于获取教师所属部门 public String getTdept() { // 返回类的私有属性tdept的值 return tdept; } // 定义getTphone方法，用于获取教师联系电话 public String getTphone() { // 返回类的私有属性tphone的值 return tphone; } // 定义getTpsw方法，用于获取教师密码 public String getTpsw() { // 返回类的私有属性tpsw的值 return tpsw; } // 重写toString方法，用于将教师对象的属性信息以字符串形式输出 @Override public String toString() { return "Teacher{" + // 输出教师编号 "tno='" + tno + '\'' + // 输出教师姓名 ", tname='" + tname + '\'' + // 输出教师性别 ", tsex='" + tsex + '\'' + // 输出教师年龄 ", tage=" + tage + // 输出教师所属部门 ", tdept='" + tdept + '\'' + // 输出教师联系电话 ", tphone='" + tphone + '\'' + // 输出教师密码 ", tpsw='" + tpsw + '\'' + '}'; } } // 声明该类所属的包为 com.entity package com.entity; // 导入 java.sql.Date 类，用于表示日期（只包含年、月、日） import java.sql.Date; // 导入 java.sql.Timestamp 类，用于表示包含日期和时间（精确到纳秒）的数据类型（虽然在当前代码中未使用到该类，但导入了） import java.sql.Timestamp; // 定义 TeaPunch 类，该类用于封装教师打卡信息 public class TeaPunch { // 定义私有属性 tno，表示教师编号 private String tno; // 定义私有属性 tname，表示教师姓名 private String tname; // 定义私有属性 tdept，表示教师所在部门 private String tdept; // 定义私有属性 tispunch，表示教师是否打卡（可能是“是”或“否”等） private String tispunch; // 定义私有属性 tpunchdate，表示教师打卡日期 private Date tpunchdate; // 定义私有属性 tpunchtime，表示教师打卡时间 private String tpunchtime; // 定义私有属性 tishot，表示教师是否发热（可能是“是”或“否”等） private String tishot; // 定义私有属性 tiscough，表示教师是否咳嗽（可能是“是”或“否”等） private String tiscough; // 定义私有属性 tisseem，表示教师是否有疑似症状（可能是“是”或“否”等） private String tisseem; // 定义私有属性 tisdiagnose，表示教师是否确诊（可能是“是”或“否”等） private String tisdiagnose; // 定义私有属性 tstatus，表示教师的状态（可能包含其他相关状态信息） private String tstatus; // 定义 tno 属性的 setter 方法，用于设置教师编号 public void setTno(String tno) { this.tno = tno; } // 定义 tname 属性的 setter 方法，用于设置教师姓名 public void setTname(String tname) { this.tname = tname; } // 定义 tdept 属性的 setter 方法，用于设置教师所在部门 public void setTdept(String tdept) { this.tdept = tdept; } // 定义 tispunch 属性的 setter 方法，用于设置教师是否打卡 public void setTispunch(String tispunch) { this.tispunch = tispunch; } // 定义 tpunchdate 属性的 setter 方法，用于设置教师打卡日期 public void setTpunchdate(Date tpunchdate) { this.tpunchdate = tpunchdate; } // 定义 tpunchtime 属性的 setter 方法，用于设置教师打卡时间 public void setTpunchtime(String tpunchtime) { this.tpunchtime = tpunchtime; } // 定义 tishot 属性的 setter 方法，用于设置教师是否发热 public void setTishot(String tishot) { this.tishot = tishot; } // 定义 tiscough 属性的 setter 方法，用于设置教师是否咳嗽 public void setTiscough(String tiscough) { this.tiscough = tiscough; } // 定义 tisseem 属性的 setter 方法，用于设置教师是否有疑似症状 public void setTisseem(String tisseem) { this.tisseem = tisseem; } // 定义 tisdiagnose 属性的 setter 方法，用于设置教师是否确诊 public void setTisdiagnose(String tisdiagnose) { this.tisdiagnose = tisdiagnose; } // 定义 tstatus 属性的 setter 方法，用于设置教师的状态 public void setTstatus(String tstatus) { this.tstatus = tstatus; } // 定义 tno 属性的 getter 方法，用于获取教师编号 public String getTno() { return tno; } // 定义 tname 属性的 getter 方法，用于获取教师姓名 public String getTname() { return tname; } // 定义 tdept 属性的 getter 方法，用于获取教师所在部门 public String getTdept() { return tdept; } // 定义 tispunch 属性的 getter 方法，用于获取教师是否打卡 public String getTispunch() { return tispunch; } // 定义 tpunchdate 属性的 getter 方法，用于获取教师打卡日期 public Date getTpunchdate() { return tpunchdate; } // 定义 tpunchtime 属性的 getter 方法，用于获取教师打卡时间 public String getTpunchtime() { return tpunchtime; } // 定义 tishot 属性的 getter 方法，用于获取教师是否发热 public String getTishot() { return tishot; } // 定义 tiscough 属性的 getter 方法，用于获取教师是否咳嗽 public String getTiscough() { return tiscough; } // 定义 tisseem 属性的 getter 方法，用于获取教师是否有疑似症状 public String getTisseem() { return tisseem; } // 定义 tisdiagnose 属性的 getter 方法，用于获取教师是否确诊 public String getTisdiagnose() { return tisdiagnose; } // 定义 tstatus 属性的 getter 方法，用于获取教师的状态 public String getTstatus() { return tstatus; } // 重写 toString 方法，返回该对象的字符串表示形式，方便输出和调试 @Override public String toString() { return "TeaPunch{" + "tno='" + tno + '\'' + ", tname='" + tname + '\'' + ", tdept='" + tdept + '\'' + ", tispunch='" + tispunch + '\'' + ", tpunchdate=" + tpunchdate + ", tpunchtime='" + tpunchtime + '\'' + ", tishot='" + tishot + '\'' + ", tiscough='" + tiscough + '\'' + ", tisseem='" + tisseem + '\'' + ", tisdiagnose='" + tisdiagnose + '\'' + ", tstatus='" + tstatus + '\'' + '}'; } } package com.entity; // 声明该类所属的包为 com.entity，用于对相关实体类进行组织和管理，便于代码的模块化和维护 public class WebStu { // 定义一个私有字符串类型的变量 sdept，用于存储系部名称 private String sdept; // 定义一个私有整型变量 sishotNum，用于存储与发热相关的数量（可能是发热学生的数量等） private int sishotNum; // 定义一个私有整型变量 siscoughNum，用于存储与咳嗽相关的数量（可能是咳嗽学生的数量等） private int siscoughNum; // 定义一个私有整型变量 sstatusNum，用于存储与某种状态相关的数量（具体状态需根据上下文确定） private int sstatusNum; // 定义一个私有整型变量 sisseemNum，用于存储与某种表现相关的数量（可能是有特定症状表现的学生数量等） private int sisseemNum; // 定义一个私有整型变量 sisdiagnoseNum，用于存储与诊断结果相关的数量（可能是已诊断学生的数量等） private int sisdiagnoseNum; // 这是一个设置系部名称的方法，接收一个字符串类型的参数 sdept public void setSdept(String sdept) { // 将传入的参数值赋给当前类的成员变量 sdept this.sdept = sdept; } // 这是一个设置与发热相关数量的方法，接收一个整型参数 sishotNum public void setSishotNum(int sishotNum) { // 将传入的参数值赋给当前类的成员变量 sishotNum this.sishotNum = sishotNum; } // 这是一个设置与咳嗽相关数量的方法，接收一个整型参数 siscoughNum public void setSiscoughNum(int siscoughNum) { // 将传入的参数值赋给当前类的成员变量 siscoughNum this.siscoughNum = siscoughNum; } // 这是一个设置与某种状态相关数量的方法，接收一个整型参数 sstatusNum public void setSstatusNum(int sstatusNum) { // 将传入的参数值赋给当前类的成员变量 sstatusNum this.sstatusNum = sstatusNum; } // 这是一个设置与某种表现相关数量的方法，接收一个整型参数 sisseemNum public void setSisseemNum(int sisseemNum) { // 将传入的参数值赋给当前类的成员变量 sisseemNum this.sisseemNum = sisseemNum; } // 这是一个设置与诊断结果相关数量的方法，接收一个整型参数 sisdiagnoseNum public void setSisdiagnoseNum(int sisdiagnoseNum) { // 将传入的参数值赋给当前类的成员变量 sisdiagnoseNum this.sisdiagnoseNum = sisdiagnoseNum; } // 这是一个获取系部名称的方法，返回值类型为字符串 public String getSdept() { // 返回当前类的成员变量 sdept 的值 return sdept; } // 这是一个获取与发热相关数量的方法，返回值类型为整型 public int getSishotNum() { // 返回当前类的成员变量 sishotNum 的值 return sishotNum; } // 这是一个获取与咳嗽相关数量的方法，返回值类型为整型 public int getSiscoughNum() { // 返回当前类的成员变量 siscoughNum 的值 return siscoughNum; } // 这是一个获取与某种状态相关数量的方法，返回值类型为整型 public int getSstatusNum() { // 返回当前类的成员变量 sstatusNum 的值 return sstatusNum; } // 这是一个获取与某种表现相关数量的方法，返回值类型为整型 public int getSisseemNum() { // 返回当前类的成员变量 sisseemNum 的值 return sisseemNum; } // 这是一个获取与诊断结果相关数量的方法，返回值类型为整型 public int getSisdiagnoseNum() { // 返回当前类的成员变量 sisdiagnoseNum 的值 return sisdiagnoseNum; } // 重写了父类 Object 的 toString 方法，用于将 WebStu 对象以字符串的形式表示 @Override public String toString() { // 返回一个包含系部名称以及各类数量信息的字符串，格式为 "WebStu{sdept='xxx', sishotNum=xxx, siscoughNum=xxx, sstatusNum=xxx, sisseemNum=xxx, sisdiagnoseNum=xxx}" return "WebStu{" + "sdept='" + sdept + '\'' + ", sishotNum=" + sishotNum + ", siscoughNum=" + siscoughNum + ", sstatusNum=" + sstatusNum + ", sisseemNum=" + sisseemNum + ", sisdiagnoseNum=" + sisdiagnoseNum + '}'; } } package com.entity; // 声明该类所属的包为 com.entity，通常用于存放实体类，方便代码的组织和管理 public class WebTea { // 定义一个私有字符串类型的变量 tdept，用于存储教师所在的系部 private String tdept; // 定义一个私有整型变量 tishotNum，用于存储教师中发热的人数 private int tishotNum; // 定义一个私有整型变量 tiscoughNum，用于存储教师中咳嗽的人数 private int tiscoughNum; // 定义一个私有整型变量 tstatusNum，用于存储处于某种特定状态的教师人数 private int tstatusNum; // 定义一个私有整型变量 tisseemNum，用于存储有某种特定表现的教师人数 private int tisseemNum; // 定义一个私有整型变量 tisdiagnoseNum，用于存储已被诊断的教师人数 private int tisdiagnoseNum; // 设置教师所在系部的方法，接收一个字符串类型的参数 tdept public void setTdept(String tdept) { // 将传入的参数值赋给当前对象的 tdept 成员变量 this.tdept = tdept; } // 设置教师中发热人数的方法，接收一个整型参数 tishotNum public void setTishotNum(int tishotNum) { // 将传入的参数值赋给当前对象的 tishotNum 成员变量 this.tishotNum = tishotNum; } // 设置教师中咳嗽人数的方法，接收一个整型参数 tiscoughNum public void setTiscoughNum(int tiscoughNum) { // 将传入的参数值赋给当前对象的 tiscoughNum 成员变量 this.tiscoughNum = tiscoughNum; } // 设置处于特定状态的教师人数的方法，接收一个整型参数 tstatusNum public void setTstatusNum(int tstatusNum) { // 将传入的参数值赋给当前对象的 tstatusNum 成员变量 this.tstatusNum = tstatusNum; } // 设置有特定表现的教师人数的方法，接收一个整型参数 tisseemNum public void setTisseemNum(int tisseemNum) { // 将传入的参数值赋给当前对象的 tisseemNum 成员变量 this.tisseemNum = tisseemNum; } // 设置已被诊断的教师人数的方法，接收一个整型参数 tisdiagnoseNum public void setTisdiagnoseNum(int tisdiagnoseNum) { // 将传入的参数值赋给当前对象的 tisdiagnoseNum 成员变量 this.tisdiagnoseNum = tisdiagnoseNum; } // 获取教师所在系部的方法，返回值类型为字符串 public String getTdept() { // 返回当前对象的 tdept 成员变量的值 return tdept; } // 获取教师中发热人数的方法，返回值类型为整型 public int getTishotNum() { // 返回当前对象的 tishotNum 成员变量的值 return tishotNum; } // 获取教师中咳嗽人数的方法，返回值类型为整型 public int getTiscoughNum() { // 返回当前对象的 tiscoughNum 成员变量的值 return tiscoughNum; } // 获取处于特定状态的教师人数的方法，返回值类型为整型 public int getTstatusNum() { // 返回当前对象的 tstatusNum 成员变量的值 return tstatusNum; } // 获取有特定表现的教师人数的方法，返回值类型为整型 public int getTisseemNum() { // 返回当前对象的 tisseemNum 成员变量的值 return tisseemNum; } // 获取已被诊断的教师人数的方法，返回值类型为整型 public int getTisdiagnoseNum() { // 返回当前对象的 tisdiagnoseNum 成员变量的值 return tisdiagnoseNum; } // 重写 Object 类的 toString 方法，用于将对象的信息以字符串形式输出 @Override public String toString() { // 构建并返回包含对象各成员变量信息的字符串 return "WebTea{" + "tdept='" + tdept + '\'' + ", tishotNum=" + tishotNum + ", tiscoughNum=" + tiscoughNum + ", tstatusNum=" + tstatusNum + ", tisseemNum=" + tisseemNum + ", tisdiagnoseNum=" + tisdiagnoseNum + '}'; } } // 声明该类所属的包为 com.filter，包用于组织和管理 Java 类，避免命名冲突 package com.filter; // 导入 javax.servlet 包下的 Servlet、ServletRequest、ServletResponse、FilterChain 等接口，用于创建和处理 Servlet 相关操作 import javax.servlet.*; // 导入 javax.servlet.annotation 包下的 WebFilter 注解，用于将该类标记为一个 Servlet 过滤器，并指定过滤的 URL 模式 import javax.servlet.annotation.WebFilter; // 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于处理 HTTP 请求 import javax.servlet.http.HttpServletRequest; // 导入 java.io 包下的 IOException 类，用于处理输入输出相关的异常 import java.io.IOException; // 使用 WebFilter 注解将该类标记为一个 Servlet 过滤器，指定过滤的 URL 模式为 "/view/deptadmin/deptmainview.jsp" @WebFilter("/view/deptadmin/deptmainview.jsp") // 定义一个名为 DeptAdmLoginFilter 的类，实现 Filter 接口，用于实现部门管理员登录过滤功能 public class DeptAdmLoginFilter implements Filter { /** * 过滤器的初始化方法，在过滤器实例化后被调用，用于初始化过滤器的配置信息 * @param filterConfig 包含过滤器配置信息的 FilterConfig 对象 * @throws ServletException 当初始化过程中发生错误时抛出 */ @Override public void init(FilterConfig filterConfig) throws ServletException { // 目前该方法为空，可在需要时添加初始化相关的代码 } /** * 过滤器的核心方法，用于对请求进行过滤处理 * @param servletRequest 表示客户端的请求 * @param servletResponse 表示对客户端的响应 * @param filterChain 用于调用过滤器链中的下一个过滤器或目标资源 * @throws IOException 当处理输入输出操作发生错误时抛出 * @throws ServletException 当处理 Servlet 相关操作发生错误时抛出 */ @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { // 将 ServletRequest 强制转换为 HttpServletRequest，以便使用 HTTP 相关的方法 HttpServletRequest request = (HttpServletRequest) servletRequest; // 3. 从获取的 session 中获取名为 "deptadno" 的属性值，该属性可能用于标识部门管理员是否已登录 Object deptadno = request.getSession().getAttribute("deptadno"); // 打印获取到的 "deptadno" 属性值，用于调试和查看信息 System.out.println(deptadno); // 判断获取到的 "deptadno" 属性值是否不为空 if (deptadno != null){ // 用户已登录，将请求和响应传递给过滤器链中的下一个过滤器或目标资源，即放行请求 filterChain.doFilter(servletRequest, servletResponse); }else { // 用户没有登录，通过 RequestDispatcher 将请求转发到 "/view/frontweb/deptadmlogin.jsp" 页面，即跳转到登录页面 request.getRequestDispatcher("/view/frontweb/deptadmlogin.jsp").forward(servletRequest, servletResponse); } } /** * 过滤器的销毁方法，在过滤器实例被销毁前调用，用于释放过滤器占用的资源 */ @Override public void destroy() { // 目前该方法为空，可在需要时添加释放资源相关的代码 } } // 声明该类所属的包为 com.filter，用于组织和管理过滤器相关的类 package com.filter; // 导入 javax.servlet 包下的 Servlet、ServletRequest、ServletResponse、FilterChain 等接口， // 这些接口是创建和使用 Servlet 过滤器所必需的基础接口 import javax.servlet.*; // 导入 javax.servlet.annotation 包下的 WebFilter 注解， // 该注解用于将一个类标记为 Servlet 过滤器，并指定过滤器所应用的 URL 模式 import javax.servlet.annotation.WebFilter; // 导入 javax.servlet.http 包下的 HttpServletRequest 类， // 用于处理 HTTP 请求相关的操作，这里主要用于获取 HTTP 请求中的会话信息 import javax.servlet.http.HttpServletRequest; // 导入 java.io 包下的 IOException 类，用于处理输入输出相关的异常 import java.io.IOException; // 使用 WebFilter 注解将该类标记为一个 Servlet 过滤器， // 并指定该过滤器应用于 "/view/schoadmin/schomainview.jsp" 这个 URL 模式 @WebFilter("/view/schoadmin/schomainview.jsp") // 定义一个名为 SchoAdmLoginFilter 的类，实现 Filter 接口， // 用于实现学校管理员登录状态的过滤功能 public class SchoAdmLoginFilter implements Filter { /** * 过滤器的初始化方法，在过滤器实例化时被调用， * 用于初始化过滤器的配置信息等资源。 * 这里目前为空实现，后续如有需要可以添加初始化相关的代码逻辑。 * @param filterConfig 包含过滤器配置信息的 FilterConfig 对象 * @throws ServletException 当初始化过程中发生异常时抛出 */ @Override public void init(FilterConfig filterConfig) throws ServletException { } /** * 过滤器的核心方法，用于对请求进行过滤处理。 * 该方法会在每次请求经过该过滤器时被调用。 * @param servletRequest 表示客户端发送的请求对象 * @param servletResponse 表示服务器对客户端请求的响应对象 * @param filterChain 用于调用过滤器链中的下一个过滤器或目标资源 * @throws IOException 当在处理请求或响应过程中发生输入输出异常时抛出 * @throws ServletException 当在处理 Servlet 相关操作时发生异常时抛出 */ @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { // 将 ServletRequest 类型的对象强制转换为 HttpServletRequest 类型， // 以便使用 HttpServletRequest 中特有的方法，如获取会话（session）信息等。 HttpServletRequest request = (HttpServletRequest) servletRequest; // 从当前请求的会话（session）中获取名为 "schoadno" 的属性值， // 这里的 "schoadno" 可能是用于标识学校管理员登录状态的一个属性。 Object schoadno = request.getSession().getAttribute("schoadno"); // 打印获取到的 "schoadno" 属性值，主要用于调试，方便查看该属性是否正确获取。 System.out.println(schoadno); // 判断获取到的 "schoadno" 属性值是否不为空， // 如果不为空，则认为用户已经登录。 if (schoadno != null){ // 用户已登录，将请求和响应传递给过滤器链中的下一个过滤器或目标资源， // 即放行该请求，让其继续处理。 filterChain.doFilter(servletRequest, servletResponse); }else { // 用户未登录，通过 RequestDispatcher 将请求转发到 "/view/frontweb/schoadmlogin.jsp" 页面， // 从而实现将未登录用户重定向到学校管理员登录页面的功能。 request.getRequestDispatcher("/view/frontweb/schoadmlogin.jsp").forward(servletRequest, servletResponse); } } /** * 过滤器的销毁方法，在过滤器实例被销毁之前调用， * 用于释放过滤器所占用的资源，如关闭数据库连接、释放文件句柄等。 * 这里目前为空实现，后续如有需要可以添加资源释放相关的代码逻辑。 */ @Override public void destroy() { } } package com.filter; // 声明该类所属的包为 com.filter，用于组织和管理过滤器相关的类 import javax.servlet.*; // 导入 javax.servlet 包下的 Servlet 相关接口和类，用于创建和处理 Servlet 相关操作 import javax.servlet.annotation.WebFilter; // 导入用于将 Servlet 过滤器映射到特定 URL 模式的注解 import javax.servlet.http.HttpServletRequest; // 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于处理 HTTP 请求 import java.io.IOException; // 导入用于处理输入输出异常的类 @WebFilter("/view/frontweb/stuinfo.jsp") // 使用 WebFilter 注解将该过滤器映射到 "/view/frontweb/stuinfo.jsp" 这个 URL 路径上， // 当客户端请求访问该路径时，此过滤器会被触发执行 public class StuLoginFilter implements Filter { // 实现 Filter 接口的 init 方法，该方法在过滤器初始化时被调用， // 用于执行一些初始化操作，这里为空实现 @Override public void init(FilterConfig filterConfig) throws ServletException { } // 实现 Filter 接口的 doFilter 方法，该方法是过滤器的核心方法， // 用于对请求和响应进行过滤处理 @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { // 将 ServletRequest 强转为 HttpServletRequest，以便使用 HTTP 相关的方法 HttpServletRequest request = (HttpServletRequest) servletRequest; // 从当前请求的 session 中获取名为 "sno" 的属性值，这里假设 "sno" 是用于标识用户登录状态的信息 Object sno = request.getSession().getAttribute("sno"); // 打印获取到的 "sno" 属性值，主要用于调试，查看是否获取到了正确的信息 System.out.println(sno); // 判断获取到的 "sno" 属性值是否不为 null if (sno != null){ // 如果不为 null，说明用户已经登录，调用 filterChain 的 doFilter 方法放行请求， // 让请求继续传递到后续的过滤器或目标资源（如 JSP 页面） filterChain.doFilter(servletRequest, servletResponse); }else { // 如果为 null，说明用户没有登录，使用 request 的 getRequestDispatcher 方法获取一个请求转发器， // 将请求转发到 "/view/frontweb/stulogin.jsp" 页面，即跳转到登录页面 request.getRequestDispatcher("/view/frontweb/stulogin.jsp").forward(servletRequest, servletResponse); } } // 实现 Filter 接口的 destroy 方法，该方法在过滤器销毁时被调用， // 用于执行一些清理资源等操作，这里为空实现 @Override public void destroy() { } } // 声明该类所属的包，表明该类是用于过滤相关功能的类，属于com.filter包 package com.filter; // 导入Servlet相关的接口和类，用于实现过滤器的功能 import javax.servlet.*; // 导入Servlet注解，用于将过滤器映射到特定的URL路径 import javax.servlet.annotation.WebFilter; // 导入HTTP请求相关的类，用于处理HTTP请求相关操作 import javax.servlet.http.HttpServletRequest; // 导入处理输入输出异常的类，当在过滤器执行过程中出现输入输出相关错误时会抛出该异常 import java.io.IOException; // 使用注解将该过滤器映射到/StuInfoServlet路径，对访问该路径的请求进行过滤操作 @WebFilter("/StuInfoServlet") // 定义一个名为StuLoginFilter1的类，实现Filter接口，用于实现学生登录相关的过滤逻辑 public class StuLoginFilter1 implements Filter { // 重写init方法，在过滤器初始化时调用，这里为空实现，目前没有在初始化时需要执行的操作 @Override public void init(FilterConfig filterConfig) throws ServletException { } // 重写doFilter方法，这是过滤器的核心方法，用于处理请求和响应 @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { // 将ServletRequest类型的请求对象强转为HttpServletRequest类型，以便使用HTTP相关的方法和属性 HttpServletRequest request = (HttpServletRequest) servletRequest; // 从当前请求的会话（session）中获取名为sno的属性值，sno可能代表学生学号，用于判断学生是否登录 Object sno = request.getSession().getAttribute("sno"); // 在控制台打印获取到的sno属性值，用于调试，查看是否成功获取该属性 System.out.println(sno); // 判断获取到的sno属性值是否不为空，若不为空则表示学生已登录 if (sno != null) { // 如果学生已登录，调用过滤器链的doFilter方法，将请求和响应传递给下一个过滤器或目标资源，即放行请求 filterChain.doFilter(servletRequest, servletResponse); } else { // 如果学生未登录，使用请求的getRequestDispatcher方法获取一个请求转发器 // 将请求转发到/view/frontweb/stulogin.jsp页面，即跳转到学生登录页面 request.getRequestDispatcher("/view/frontweb/stulogin.jsp").forward(servletRequest, servletResponse); } } // 重写destroy方法，在过滤器销毁时调用，这里为空实现，目前没有在过滤器销毁时需要执行的清理操作 @Override public void destroy() { } } // 声明该类所属的包，表明该类是一个过滤器类，通常用于处理请求和响应的过滤逻辑 package com.filter; // 导入Servlet相关的接口和类，用于处理Servlet请求和响应 import javax.servlet.*; // 导入Servlet注解，用于将过滤器映射到指定的URL路径 import javax.servlet.annotation.WebFilter; // 导入HTTP请求相关的类，用于处理HTTP请求 import javax.servlet.http.HttpServletRequest; // 导入处理输入输出异常的类，当进行输入输出操作时可能会抛出该异常 import java.io.IOException; // 使用注解将该过滤器映射到/view/frontweb/teainfo.jsp路径，对访问该路径的请求进行过滤 @WebFilter("/view/frontweb/teainfo.jsp") // 定义一个名为TeacherLoginFilter的类，实现Filter接口，用于过滤教师登录相关的请求 public class TeacherLoginFilter implements Filter { // 重写init方法，在过滤器初始化时调用，这里为空实现，未做任何初始化操作 @Override public void init(FilterConfig filterConfig) throws ServletException { } // 重写doFilter方法，这是过滤器的核心方法，用于处理请求和响应 @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { // 将ServletRequest强制转换为HttpServletRequest，以便使用HTTP相关的方法 HttpServletRequest request = (HttpServletRequest) servletRequest; // 从当前请求的会话（session）中获取名为tno的属性值，tno可能代表教师编号，用于判断用户是否登录 Object tno = request.getSession().getAttribute("tno"); // 在控制台打印获取到的tno属性值，用于调试 System.out.println(tno); // 判断获取到的tno属性值是否不为空，若不为空则表示用户已登录 if (tno != null) { // 如果用户已登录，调用过滤器链的doFilter方法，将请求和响应传递给下一个过滤器或目标资源，即放行请求 filterChain.doFilter(servletRequest, servletResponse); } else { // 如果用户未登录，使用请求的getRequestDispatcher方法获取一个请求转发器 // 将请求转发到/view/frontweb/tealogin.jsp页面，即跳转到教师登录页面 request.getRequestDispatcher("/view/frontweb/tealogin.jsp").forward(servletRequest, servletResponse); } } // 重写destroy方法，在过滤器销毁时调用，这里为空实现，未做任何清理操作 @Override public void destroy() { } } // 声明该类所在的包为 com.filter package com.filter; // 导入 Servlet 相关的接口和类，用于创建过滤器和处理 Servlet 请求/响应 import javax.servlet.*; // 导入用于将过滤器映射到特定 URL 模式的注解 import javax.servlet.annotation.WebFilter; // 导入 HttpServletRequest 类，用于处理 HTTP 请求 import javax.servlet.http.HttpServletRequest; // 导入 IOException 类，用于处理输入输出异常 import java.io.IOException; // 使用 WebFilter 注解将该过滤器映射到 "/TeaInfoServlet" 路径， // 当客户端请求访问该路径时，该过滤器会被触发执行 @WebFilter("/TeaInfoServlet") // 定义 TeacherLoginFilter1 类，实现 Filter 接口，表明这是一个过滤器类 public class TeacherLoginFilter1 implements Filter { // 重写 init 方法，该方法在过滤器初始化时被调用， // 通常用于初始化一些资源或配置信息。 // 这里为空实现，可能不需要在初始化时进行特殊操作 @Override public void init(FilterConfig filterConfig) throws ServletException { } // 重写 doFilter 方法，这是过滤器的核心方法， // 每次请求经过该过滤器时都会调用此方法来处理请求和响应。 @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { // 将 ServletRequest 强转为 HttpServletRequest，以便使用 HTTP 相关的方法 HttpServletRequest request = (HttpServletRequest) servletRequest; // 从当前请求的会话（session）中获取名为 "tno" 的属性值， // 这里假设 "tno" 是用于标识教师登录状态的属性 Object tno = request.getSession().getAttribute("tno"); // 将获取到的 "tno" 属性值打印到控制台，用于调试 System.out.println(tno); // 判断获取到的 "tno" 属性值是否不为 null， // 如果不为 null 则表示用户已登录 if (tno != null){ // 用户已登录，调用 filterChain 的 doFilter 方法放行请求， // 让请求继续传递到后续的 Servlet 或过滤器进行处理 filterChain.doFilter(servletRequest, servletResponse); } else { // 用户未登录，使用请求转发将请求转发到 "/view/frontweb/tealogin.jsp" 页面， // 即跳转到教师登录页面，让用户进行登录操作 request.getRequestDispatcher("/view/frontweb/tealogin.jsp").forward(servletRequest, servletResponse); } } // 重写 destroy 方法，该方法在过滤器销毁时被调用， // 通常用于释放初始化时创建的资源。 // 这里为空实现，可能不需要在销毁时进行特殊操作 @Override public void destroy() { } }