diff --git a/.idea/misc.xml b/.idea/misc.xml index 0548357..2b708dc 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,6 +1,6 @@ - + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..35eb1dd --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/workspace.xml b/.idea/workspace.xml index e3c9483..0b09772 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -5,8 +5,13 @@ + + - + + + + + + + + + + + + + @@ -328,116 +352,40 @@ + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + \ No newline at end of file diff --git a/ljc.txt b/ljc.txt new file mode 100644 index 0000000..59c2f68 --- /dev/null +++ b/ljc.txt @@ -0,0 +1,4336 @@ +package com.controller.alluse; + +import com.alibaba.druid.util.JdbcUtils; +import com.dao.SchoAdminDao; +import com.dao.StuDao; +import com.dao.TeaDao; + +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; +import java.io.IOException; +import java.sql.ResultSet; + +/** + * 处理用户登录请求的Servlet + * 根据用户选择的身份(学生/教师/管理员)进行不同的验证逻辑 + */ +@WebServlet("/LoginServlet") +public class LoginServlet extends HttpServlet { + + @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 userName = req.getParameter("userName"); + String psw = req.getParameter("psw"); + String identity = req.getParameter("identity1"); + // 打印日志用于调试 + System.out.println(userName); + System.out.println(psw); + System.out.println(identity); + + // 根据用户选择的身份进行不同的验证逻辑 + if (identity.equals("学生")){//学生身份 + boolean flag = false; // 标记是否验证成功 + String sql = "select * from student where sname = ? and spsw = ?"; // SQL查询语句 + Object[] objects = {userName, psw}; // SQL查询参数 + ResultSet resultSet = StuDao.login(sql, objects); // 执行数据库查询 + String sno = null; // 学生学号 + try { + if (resultSet.next()){ // 如果查询结果不为空 + flag = true; // 验证成功 + sno = resultSet.getString("sno"); // 获取学生学号 + } + } catch (Exception e) { + e.printStackTrace(); // 打印异常堆栈信息 + }finally { + JdbcUtils.close(resultSet); // 关闭结果集，释放资源 + } + if (flag){ // 验证成功 + System.out.println("登录成功!"); + // 创建会话，存储用户信息 + HttpSession session = req.getSession(); + session.setAttribute("userName", userName); // 存储用户名 + session.setAttribute("sno", sno); // 存储学号 + System.out.println(sno); + + // 设置跳转信息并转发到提示页面 + req.setAttribute("httpUrl","/view/stu/stumainview.jsp"); + req.setAttribute("info", "登录成功!即将跳转至后台首页!"); + req.setAttribute("title","登录成功"); + req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp); +// resp.sendRedirect(req.getContextPath() + "/view/stu/stumainview.jsp"); + }else { // 验证失败 + System.out.println("用户名或密码错误!请重新登录!"); + // 设置错误信息并转发到提示页面 + req.setAttribute("httpUrl","/view/login/login.jsp"); + req.setAttribute("info", "登录失败!用户名或密码错误!即将跳转至登录页面!"); + req.setAttribute("title","登录失败"); + req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp); + } + }else if (identity.equals("教师")){//教师身份 + boolean flag = false; + String sql = "select * from teacher where tname = ? and tpsw = ?"; + Object[] objects = {userName, psw}; + ResultSet resultSet = TeaDao.login(sql, objects); + String tno = null; + try { + if (resultSet.next()){ + flag = true; + tno = resultSet.getString("tno"); + } + } catch (Exception e) { + e.printStackTrace(); + }finally { + JdbcUtils.close(resultSet); + } + if (flag){ + System.out.println("登录成功!"); + // 创建会话，存储用户信息 + HttpSession session = req.getSession(); + session.setAttribute("userName", userName); + session.setAttribute("tno", tno); + System.out.println(tno); + + // 设置跳转信息并转发到提示页面 + req.setAttribute("httpUrl","/view/tea/teamainview.jsp"); + req.setAttribute("info", "登录成功!即将跳转至后台首页!"); + req.setAttribute("title","登录成功"); + req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp); +// resp.sendRedirect(req.getContextPath() + "/view/guide/mainview_guide.jsp"); + }else { + System.out.println("用户名或密码错误!请重新登录!"); + // 设置错误信息并转发到提示页面 + req.setAttribute("httpUrl","/view/login/login.jsp"); + req.setAttribute("info", "登录失败!用户名或密码错误!即将跳转至登录页面!"); + req.setAttribute("title","登录失败"); + req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp); + } + }else {//如果是管理员 + boolean flag = false; + String sql = "select * from admin where adname = ? and adpsw = ? and belong = ?"; + Object[] objects = {userName, psw, identity}; + ResultSet resultSet = SchoAdminDao.login(sql, objects); + try { + if (resultSet.next()){ + flag = true; + } + } catch (Exception e) { + e.printStackTrace(); + }finally { + JdbcUtils.close(resultSet); + } + + if (flag){ // 管理员验证成功 + + if (identity.equals("学校")){//学校管理员 + System.out.println("登录成功!"); + HttpSession session = req.getSession(); + session.setAttribute("belong", identity); // 存储管理员所属单位 + System.out.println(identity); + + // 设置跳转信息并转发到提示页面 + req.setAttribute("httpUrl","/view/schoadmin/schomainview.jsp"); + req.setAttribute("info", "登录成功!即将跳转至后台首页!"); + req.setAttribute("title","登录成功"); + req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp); + }else {//二级学院管理员 + System.out.println("登录成功!"); + // 创建会话，存储用户信息 + HttpSession session = req.getSession(); + session.setAttribute("belong", identity); + System.out.println(identity); + + // 设置跳转信息并转发到提示页面 + req.setAttribute("httpUrl","/view/deptadmin/deptmainview.jsp"); + req.setAttribute("info", "登录成功!即将跳转至后台首页!"); + req.setAttribute("title","登录成功"); + req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp); +// resp.sendRedirect(req.getContextPath() + "/view/guide/mainview_guide.jsp"); + } + + }else { + System.out.println("用户名或密码错误!请重新登录!"); + // 设置错误信息并转发到提示页面 + req.setAttribute("httpUrl","/view/login/login.jsp"); + req.setAttribute("info", "登录失败!用户名或密码错误!即将跳转至登录页面!"); + req.setAttribute("title","登录失败"); + req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp); + } + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + doGet(req, resp); // 对于POST请求，直接调用doGet方法处理 + } +} +package com.controller.frontweb; + +import com.dao.FrontWebDao; + +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.text.SimpleDateFormat; +import java.util.Date; + +/** + * 处理新闻删除请求的Servlet + * 根据新闻ID删除对应新闻记录 + */ +@WebServlet("/DelNewsServlet") +public class DelNewsServlet extends HttpServlet { + + @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"); + + // 从请求参数中获取要删除的新闻ID + String nid = req.getParameter("nid"); + int nid1 = Integer.parseInt(nid); // 将字符串类型的ID转换为整数 + + // 打印日志用于调试 + System.out.println(nid1); + + String sql = null; // SQL语句变量 + + // 第一步：检查新闻是否存在 + sql = "select count(*) as num from news where nid = ?"; + Object[] objects = {nid1}; // SQL查询参数 + int num = FrontWebDao.findTotalCount(sql, objects); // 执行查询，获取新闻数量 + System.out.println(num); + + if (num > 0){ // 如果新闻存在，则执行删除操作 + sql = "delete from news where nid = ?"; + Object[] objects1 = {nid1}; + int num1 = FrontWebDao.executeUpdate(sql, objects1); // 执行删除操作 + + if (num1 > 0){ // 删除成功 + // 通过JavaScript弹出提示框并关闭当前窗口 + resp.getWriter().write(""); + }else { // 删除失败（可能是数据库操作异常） + resp.getWriter().write(""); + } + }else { // 新闻不存在，不能删除 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + this.doGet(req, resp); // 对于POST请求，直接调用doGet方法处理 + } +} +package com.controller.frontweb; + +import com.dao.FrontWebDao; + +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; +import java.io.IOException; + +/** + * 处理部门管理员密码修改请求的Servlet + * 验证两次输入的新密码是否一致并更新数据库 + */ +@WebServlet("/DeptAdmAlterPswServlet") +public class DeptAdmAlterPswServlet extends HttpServlet { + @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"); + + // 从会话中获取管理员编号（标识当前登录用户） + HttpSession session = req.getSession(); + String adno = (String) session.getAttribute("adno"); + + // 从请求参数中获取用户输入的新密码和确认密码 + String adpsw = req.getParameter("adpsw"); + String adpsw1 = req.getParameter("adpsw1"); + + // 判断两次输入的密码是否相同 + if (adpsw.equals(adpsw1)){// 相同则进行修改操作 + String sql = "update admin set adpsw = ? where adno = ?"; // SQL更新语句 + Object[] objects = {adpsw, adno}; // SQL参数：新密码和管理员编号 + int num = FrontWebDao.executeUpdate(sql, objects); // 执行数据库更新操作 + + if (num > 0){ // 更新成功 + // 提示用户修改成功并要求重新登录 + resp.getWriter().write(""); + }else { // 更新失败（可能是数据库操作异常） + resp.getWriter().write(""); + } + }else {// 两次密码不同，提示用户重新输入 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + this.doGet(req, resp); // 对于POST请求，直接调用doGet方法处理 + } +} +package com.controller.frontweb; + +import com.dao.FrontWebDao; + +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; + +/** + * 处理部门管理员忘记密码重置请求的Servlet + * 验证两次输入的新密码是否一致并更新数据库 + */ +@WebServlet("/DeptAdmForgetPswServlet") +public class DeptAdmForgetPswServlet extends HttpServlet { + @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 adno = req.getParameter("adno"); + + // 从请求参数中获取用户输入的新密码和确认密码 + String adpsw = req.getParameter("adpsw"); + String adpsw1 = req.getParameter("adpsw1"); + + // 判断两次输入的密码是否相同 + if (adpsw.equals(adpsw1)){// 相同则进行修改操作 + String sql = "update admin set adpsw = ? where adno = ?"; // SQL更新语句 + Object[] objects = {adpsw, adno}; // SQL参数：新密码和管理员编号 + int num = FrontWebDao.executeUpdate(sql, objects); // 执行数据库更新操作 + + if (num > 0){ // 更新成功 + // 提示用户修改成功并跳转到登录页面 + resp.getWriter().write(""); + }else { // 更新失败（可能是管理员编号不存在或数据库操作异常） + resp.getWriter().write(""); + } + }else {// 两次密码不同，提示用户重新输入 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + this.doGet(req, resp); // 对于POST请求，直接调用doGet方法处理 + } +}package com.controller.frontweb; + +import com.dao.FrontWebDao; + +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; + +/** + * 处理部门管理员忘记密码重置请求的Servlet + * 验证两次输入的新密码是否一致并更新数据库 + */ +@WebServlet("/DeptAdmForgetPswServlet") +public class DeptAdmForgetPswServlet extends HttpServlet { + @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 adno = req.getParameter("adno"); + + // 从请求参数中获取用户输入的新密码和确认密码 + String adpsw = req.getParameter("adpsw"); + String adpsw1 = req.getParameter("adpsw1"); + + // 输入验证：检查参数是否为空 + if (adno == null || adpsw == null || adpsw1 == null) { + resp.getWriter().write(""); + return; + } + + // 判断两次输入的密码是否相同 + if (adpsw.equals(adpsw1)){// 相同则进行修改操作 + // 验证密码强度（示例：至少8位，包含字母和数字） + if (!isPasswordValid(adpsw)) { + resp.getWriter().write(""); + return; + } + + String sql = "update admin set adpsw = ? where adno = ?"; // SQL更新语句 + Object[] objects = {adpsw, adno}; // SQL参数：新密码和管理员编号 + + // 验证管理员是否存在 + if (!isAdminExists(adno)) { + resp.getWriter().write(""); + return; + } + + int num = FrontWebDao.executeUpdate(sql, objects); // 执行数据库更新操作 + + if (num > 0){ // 更新成功 + // 提示用户修改成功并跳转到登录页面 + resp.getWriter().write(""); + }else { // 更新失败 + resp.getWriter().write(""); + } + }else {// 两次密码不同，提示用户重新输入 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + this.doGet(req, resp); // 对于POST请求，直接调用doGet方法处理 + } + + // 验证管理员是否存在 + private boolean isAdminExists(String adno) { + String sql = "select count(*) as num from admin where adno = ?"; + Object[] params = {adno}; + int count = FrontWebDao.findTotalCount(sql, params); + return count > 0; + } + + // 验证密码强度 + private boolean isPasswordValid(String password) { + // 至少8位，包含字母和数字 + return password.matches("^(?=.*[A-Za-z])(?=.*\\d).{8,}$"); + } +} +package com.controller.frontweb; + +import com.dao.FrontWebDao; + +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; + +/** + * 处理部门管理员忘记密码重置请求的Servlet + * 验证两次输入的新密码是否一致并更新数据库 + */ +@WebServlet("/DeptAdmForgetPswServlet") +public class DeptAdmForgetPswServlet extends HttpServlet { + @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"); + + // 从请求参数中获取管理员编号（用户输入的需要重置密码的账号） + String adno = req.getParameter("adno"); + + // 从请求参数中获取用户输入的新密码 + String adpsw = req.getParameter("adpsw"); + // 从请求参数中获取用户输入的确认密码 + String adpsw1 = req.getParameter("adpsw1"); + + // 输入验证：检查获取到的管理员编号、新密码、确认密码参数是否为空 + if (adno == null || adpsw == null || adpsw1 == null) { + // 如果参数为空，通过响应输出一段JavaScript代码，弹出提示框显示“参数不能为空！” + // 并将页面重定向到密码重置页面（/view/frontweb/deptadmforgetpsw.jsp） + resp.getWriter().write(""); + // 终止当前方法的执行 + return; + } + + // 判断两次输入的密码是否相同 + if (adpsw.equals(adpsw1)){// 相同则进行修改操作 + // 调用isPasswordValid方法验证密码强度（示例：至少8位，包含字母和数字） + if (!isPasswordValid(adpsw)) { + // 如果密码强度不足，通过响应输出一段JavaScript代码，弹出提示框显示“密码强度不足！至少8位，包含字母和数字” + // 并将页面重定向到密码重置页面（/view/frontweb/deptadmforgetpsw.jsp） + resp.getWriter().write(""); + // 终止当前方法的执行 + return; + } + + // 构造SQL更新语句，用于更新管理员表中指定管理员编号的密码 + String sql = "update admin set adpsw = ? where adno = ?"; + // 设置SQL语句的参数，第一个参数为新密码，第二个参数为管理员编号 + Object[] objects = {adpsw, adno}; + + // 调用isAdminExists方法验证管理员是否存在 + if (!isAdminExists(adno)) { + // 如果管理员账号不存在，通过响应输出一段JavaScript代码，弹出提示框显示“管理员账号不存在！” + // 并将页面重定向到密码重置页面（/view/frontweb/deptadmforgetpsw.jsp） + resp.getWriter().write(""); + // 终止当前方法的执行 + return; + } + + // 调用FrontWebDao的executeUpdate方法执行SQL更新语句，返回受影响的行数 + int num = FrontWebDao.executeUpdate(sql, objects); + + // 如果受影响的行数大于0，说明更新成功 + if (num > 0){ + // 通过响应输出一段JavaScript代码，弹出提示框显示“修改密码成功！请登录！” + // 并将页面重定向到部门管理员登录页面（/view/frontweb/deptadmlogin.jsp），同时关闭当前窗口 + resp.getWriter().write(""); + }else { // 如果受影响的行数不大于0，说明更新失败 + // 通过响应输出一段JavaScript代码，弹出提示框显示“修改密码失败！请联系管理员” + // 并将页面重定向到密码重置页面（/view/frontweb/deptadmforgetpsw.jsp） + resp.getWriter().write(""); + } + }else {// 如果两次密码不同 + // 通过响应输出一段JavaScript代码，弹出提示框显示“两次密码不一样!请重新输入密码！” + // 并将页面重定向到密码重置页面（/view/frontweb/deptadmforgetpsw.jsp），同时关闭当前窗口 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 对于POST请求，直接调用doGet方法进行处理 + this.doGet(req, resp); + } + + // 验证管理员是否存在的私有方法 + private boolean isAdminExists(String adno) { + // 构造SQL查询语句，统计管理员表中指定管理员编号的记录数量 + String sql = "select count(*) as num from admin where adno = ?"; + // 设置SQL语句的参数为管理员编号 + Object[] params = {adno}; + // 调用FrontWebDao的findTotalCount方法执行SQL查询语句，获取记录数量 + int count = FrontWebDao.findTotalCount(sql, params); + // 如果记录数量大于0，返回true，否则返回false + return count > 0; + } + + // 验证密码强度的私有方法 + private boolean isPasswordValid(String password) { + // 使用正则表达式判断密码是否至少8位，并且包含字母和数字 + return password.matches("^(?=.*[A-Za-z])(?=.*\\d).{8,}$"); + } +} +package com.controller.frontweb; + +import com.dao.FrontWebDao; + +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; + +/** + * 处理部门管理员忘记密码重置请求的Servlet + * 验证两次输入的新密码是否一致并更新数据库 + */ +@WebServlet("/DeptAdmForgetPswServlet") +public class DeptAdmForgetPswServlet extends HttpServlet { + @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"); + + // 从HTTP请求的参数中获取名为"adno"的参数值，该值代表管理员编号（用户输入的需要重置密码的账号） + String adno = req.getParameter("adno"); + + // 从HTTP请求的参数中获取名为"adpsw"的参数值，该值代表用户输入的新密码 + String adpsw = req.getParameter("adpsw"); + // 从HTTP请求的参数中获取名为"adpsw1"的参数值，该值代表用户输入的用于确认的新密码 + String adpsw1 = req.getParameter("adpsw1"); + + // 进行输入验证，检查获取到的管理员编号、新密码、确认密码这三个参数是否有任何一个为null + if (adno == null || adpsw == null || adpsw1 == null) { + // 如果存在参数为null的情况，通过响应向客户端发送一段JavaScript代码 + // 该代码会弹出一个提示框，显示“参数不能为空！” + // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp） + resp.getWriter().write(""); + // 终止当前doGet方法的执行，不再继续后续操作 + return; + } + + // 判断用户输入的新密码和确认密码是否相等 + if (adpsw.equals(adpsw1)){ + // 如果相等，则进行密码强度验证，调用isPasswordValid方法来检查密码是否符合要求 + if (!isPasswordValid(adpsw)) { + // 如果密码强度不符合要求（例如长度不足8位或不包含字母和数字） + // 通过响应向客户端发送一段JavaScript代码 + // 该代码会弹出一个提示框，显示“密码强度不足！至少8位，包含字母和数字” + // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp） + resp.getWriter().write(""); + // 终止当前doGet方法的执行，不再继续后续操作 + return; + } + + // 构造一条SQL更新语句，用于更新数据库中admin表的记录 + // 将指定管理员编号（adno）对应的密码（adpsw）进行更新 + String sql = "update admin set adpsw = ? where adno = ?"; + // 创建一个包含SQL语句参数的对象数组，第一个参数是新密码，第二个参数是管理员编号 + Object[] objects = {adpsw, adno}; + + // 调用isAdminExists方法来验证要重置密码的管理员账号是否存在于数据库中 + if (!isAdminExists(adno)) { + // 如果管理员账号不存在，通过响应向客户端发送一段JavaScript代码 + // 该代码会弹出一个提示框，显示“管理员账号不存在！” + // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp） + resp.getWriter().write(""); + // 终止当前doGet方法的执行，不再继续后续操作 + return; + } + + // 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句 + // 该方法会返回受影响的行数，即成功更新的记录数量，将其存储在num变量中 + int num = FrontWebDao.executeUpdate(sql, objects); + + // 判断受影响的行数是否大于0，若大于0表示密码更新操作成功 + if (num > 0){ + // 如果更新成功，通过响应向客户端发送一段JavaScript代码 + // 该代码会弹出一个提示框，显示“修改密码成功！请登录！” + // 并将页面重定向到部门管理员登录页面（路径为/view/frontweb/deptadmlogin.jsp），同时关闭当前窗口 + resp.getWriter().write(""); + }else { + // 如果受影响的行数不大于0，说明密码更新操作失败 + // 通过响应向客户端发送一段JavaScript代码 + // 该代码会弹出一个提示框，显示“修改密码失败！请联系管理员” + // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp） + resp.getWriter().write(""); + } + }else { + // 如果用户输入的新密码和确认密码不相等 + // 通过响应向客户端发送一段JavaScript代码 + // 该代码会弹出一个提示框，显示“两次密码不一样!请重新输入密码！” + // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp），同时关闭当前窗口 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 对于接收到的POST请求，直接调用doGet方法来处理，复用doGet方法中的业务逻辑 + this.doGet(req, resp); + } + + // 私有方法，用于验证管理员账号是否存在于数据库中 + private boolean isAdminExists(String adno) { + // 构造一条SQL查询语句，用于统计admin表中指定管理员编号（adno）的记录数量 + String sql = "select count(*) as num from admin where adno = ?"; + // 创建一个包含SQL语句参数的对象数组，参数为管理员编号 + Object[] params = {adno}; + // 调用FrontWebDao类中的findTotalCount方法执行SQL查询语句 + // 该方法会返回查询结果中记录的数量，将其存储在count变量中 + int count = FrontWebDao.findTotalCount(sql, params); + // 如果记录数量大于0，说明管理员账号存在，返回true；否则返回false + return count > 0; + } + + // 私有方法，用于验证密码强度是否符合要求 + private boolean isPasswordValid(String password) { + // 使用正则表达式进行匹配，判断密码是否至少8位，并且同时包含字母和数字 + // 如果匹配成功，说明密码强度符合要求，返回true；否则返回false + return password.matches("^(?=.*[A-Za-z])(?=.*\\d).{8,}$"); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包名为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于执行数据库相关操作 + +import javax.servlet.ServletException; +// 导入处理Servlet异常的类ServletException +import javax.servlet.annotation.WebServlet; +// 导入用于将Servlet映射到URL的注解WebServlet +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，是所有基于HTTP协议的Servlet的基类 +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类HttpServletRequest +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类HttpServletResponse +import java.io.IOException; +// 导入处理I/O异常的类IOException + +/** + * 处理部门管理员忘记密码重置请求的Servlet + * 验证两次输入的新密码是否一致并更新数据库 + */ +@WebServlet("/DeptAdmForgetPswServlet") +// 使用WebServlet注解将该Servlet映射到URL路径"/DeptAdmForgetPswServlet" +public class DeptAdmForgetPswServlet extends HttpServlet { + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，处理HTTP GET请求 + // 设置请求的字符编码为UTF-8，确保能正确处理请求中的中文字符等，防止乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，保证响应内容在传输过程中字符的正确性，防止乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 从HTTP请求的参数中获取名为"adno"的参数值，该值代表管理员编号（用户输入的需要重置密码的账号） + String adno = req.getParameter("adno"); + + // 从HTTP请求的参数中获取名为"adpsw"的参数值，该值代表用户输入的新密码 + String adpsw = req.getParameter("adpsw"); + // 从HTTP请求的参数中获取名为"adpsw1"的参数值，该值代表用户输入的用于确认的新密码 + String adpsw1 = req.getParameter("adpsw1"); + + // 进行输入验证，检查获取到的管理员编号、新密码、确认密码这三个参数是否有任何一个为null + if (adno == null || adpsw == null || adpsw1 == null) { + // 如果存在参数为null的情况，通过响应向客户端发送一段JavaScript代码 + // 该代码会弹出一个提示框，显示“参数不能为空！” + // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp） + resp.getWriter().write(""); + // 终止当前doGet方法的执行，不再继续后续操作 + return; + } + + // 判断用户输入的新密码和确认密码是否相等 + if (adpsw.equals(adpsw1)){ + // 如果相等，则进行密码强度验证，调用isPasswordValid方法来检查密码是否符合要求 + if (!isPasswordValid(adpsw)) { + // 如果密码强度不符合要求（例如长度不足8位或不包含字母和数字） + // 通过响应向客户端发送一段JavaScript代码 + // 该代码会弹出一个提示框，显示“密码强度不足！至少8位，包含字母和数字” + // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp） + resp.getWriter().write(""); + // 终止当前doGet方法的执行，不再继续后续操作 + return; + } + + // 构造一条SQL更新语句，用于更新数据库中admin表的记录 + // 将指定管理员编号（adno）对应的密码（adpsw）进行更新 + String sql = "update admin set adpsw = ? where adno = ?"; + // 创建一个包含SQL语句参数的对象数组，第一个参数是新密码，第二个参数是管理员编号 + Object[] objects = {adpsw, adno}; + + // 调用isAdminExists方法来验证要重置密码的管理员账号是否存在于数据库中 + if (!isAdminExists(adno)) { + // 如果管理员账号不存在，通过响应向客户端发送一段JavaScript代码 + // 该代码会弹出一个提示框，显示“管理员账号不存在！” + // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp） + resp.getWriter().write(""); + // 终止当前doGet方法的执行，不再继续后续操作 + return; + } + + // 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句 + // 该方法会返回受影响的行数，即成功更新的记录数量，将其存储在num变量中 + int num = FrontWebDao.executeUpdate(sql, objects); + + // 判断受影响的行数是否大于0，若大于0表示密码更新操作成功 + if (num > 0){ + // 如果更新成功，通过响应向客户端发送一段JavaScript代码 + // 该代码会弹出一个提示框，显示“修改密码成功！请登录！” + // 并将页面重定向到部门管理员登录页面（路径为/view/frontweb/deptadmlogin.jsp），同时关闭当前窗口 + resp.getWriter().write(""); + }else { + // 如果受影响的行数不大于0，说明密码更新操作失败 + // 通过响应向客户端发送一段JavaScript代码 + // 该代码会弹出一个提示框，显示“修改密码失败！请联系管理员” + // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp） + resp.getWriter().write(""); + } + }else { + // 如果用户输入的新密码和确认密码不相等 + // 通过响应向客户端发送一段JavaScript代码 + // 该代码会弹出一个提示框，显示“两次密码不一样!请重新输入密码！” + // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp），同时关闭当前窗口 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，处理HTTP POST请求 + // 对于接收到的POST请求，直接调用doGet方法来处理，复用doGet方法中的业务逻辑 + this.doGet(req, resp); + } + + // 私有方法，用于验证管理员账号是否存在于数据库中 + private boolean isAdminExists(String adno) { + // 构造一条SQL查询语句，用于统计admin表中指定管理员编号（adno）的记录数量 + String sql = "select count(*) as num from admin where adno = ?"; + // 创建一个包含SQL语句参数的对象数组，参数为管理员编号 + Object[] params = {adno}; + // 调用FrontWebDao类中的findTotalCount方法执行SQL查询语句 + // 该方法会返回查询结果中记录的数量，将其存储在count变量中 + int count = FrontWebDao.findTotalCount(sql, params); + // 如果记录数量大于0，说明管理员账号存在，返回true；否则返回false + return count > 0; + } + + // 私有方法，用于验证密码强度是否符合要求 + private boolean isPasswordValid(String password) { + // 使用正则表达式进行匹配，判断密码是否至少8位，并且同时包含字母和数字 + // 如果匹配成功，说明密码强度符合要求，返回true；否则返回false + return password.matches("^(?=.*[A-Za-z])(?=.*\\d).{8,}$"); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于执行数据库相关操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet相关的异常情况 + +import javax.servlet.annotation.WebServlet; +// 导入用于将Servlet映射到URL的注解 + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，这是所有基于HTTP协议的Servlet的基类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话 + +import java.io.IOException; +// 导入用于处理I/O异常的类 + +@WebServlet("/SchoAdmAlterPswServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoAdmAlterPswServlet" +public class SchoAdmAlterPswServlet extends HttpServlet { + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML，字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取当前请求的会话对象 + HttpSession session = req.getSession(); + // 从会话中获取名为"adno"的属性值，并将其转换为String类型，该值表示管理员编号 + String adno = (String) session.getAttribute("adno"); + + // 从请求参数中获取名为"adpsw"的参数值，该值表示用户输入的新密码 + String adpsw = req.getParameter("adpsw"); + // 从请求参数中获取名为"adpsw1"的参数值，该值表示用户再次输入的新密码用于确认 + String adpsw1 = req.getParameter("adpsw1"); + + // 判断两次输入的密码是否相同 + if (adpsw.equals(adpsw1)){ + // 如果相同，则进行密码修改操作 + // 构造SQL更新语句，用于更新admin表中指定adno的管理员的密码 + String sql = "update admin set adpsw = ? where adno = ?"; + // 创建包含SQL语句参数的对象数组，第一个参数是新密码，第二个参数是管理员编号 + Object[] objects = {adpsw, adno}; + // 调用FrontWebDao的executeUpdate方法执行SQL更新语句，并获取受影响的行数 + int num = FrontWebDao.executeUpdate(sql, objects); + if (num > 0){ + // 如果受影响的行数大于0，说明密码修改成功 + // 通过响应输出一段JavaScript代码，弹出提示框提示修改密码成功，并要求用户重新登录 + // 同时将页面重定向到学校管理员登录页面，并关闭当前窗口 + resp.getWriter().write(""); + }else { + // 如果受影响的行数不大于0，说明密码修改失败 + // 通过响应输出一段JavaScript代码，弹出提示框提示修改密码失败，并让用户重新输入密码 + // 同时将页面重定向到学校管理员修改密码页面，并关闭当前窗口 + resp.getWriter().write(""); + } + }else { + // 如果两次输入的密码不同 + // 通过响应输出一段JavaScript代码，弹出提示框提示两次密码不一样，并让用户重新输入密码 + // 同时将页面重定向到学校管理员修改密码页面，并关闭当前窗口 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的逻辑 + this.doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所属的包为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于后续执行数据库操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet运行时可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，这是编写Servlet时的基础类，用于处理HTTP请求和响应 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，通过它可以获取请求参数等信息 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，通过它可以设置响应内容、状态码等 + +import java.io.IOException; +// 导入用于处理I/O异常的类，例如在读写数据时可能出现的异常 + +@WebServlet("/SchoAdmForgetPswServlet") +// 使用@WebServlet注解将当前Servlet映射到URL路径为"/SchoAdmForgetPswServlet" +public class SchoAdmForgetPswServlet extends HttpServlet { + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中出现中文乱码问题 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中出现中文乱码问题 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，并且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 从HTTP请求的参数中获取名为"adno"的参数值，该值代表管理员编号 + String adno = req.getParameter("adno"); + + // 从HTTP请求的参数中获取名为"adpsw"的参数值，该值代表用户输入的新密码 + String adpsw = req.getParameter("adpsw"); + // 从HTTP请求的参数中获取名为"adpsw1"的参数值，该值代表用户再次输入的用于确认的新密码 + String adpsw1 = req.getParameter("adpsw1"); + + // 判断用户输入的新密码和确认密码是否相等 + if (adpsw.equals(adpsw1)){ + // 如果相等，则进行密码修改操作 + // 构造SQL更新语句，用于更新数据库中admin表的记录，将指定管理员编号（adno）对应的密码（adpsw）进行更新 + String sql = "update admin set adpsw = ? where adno = ?"; + // 创建一个包含SQL语句参数的对象数组，第一个参数是新密码，第二个参数是管理员编号 + Object[] objects = {adpsw, adno}; + // 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句，并获取受影响的行数 + int num = FrontWebDao.executeUpdate(sql, objects); + if (num > 0){ + // 如果受影响的行数大于0，说明密码更新操作成功 + // 通过响应输出一段JavaScript代码，弹出提示框显示“修改密码成功！请登录！” + // 并将页面重定向到学校管理员登录页面，同时关闭当前窗口 + resp.getWriter().write(""); + }else { + // 如果受影响的行数不大于0，说明密码更新操作失败 + // 通过响应输出一段JavaScript代码，弹出提示框显示“修改密码失败！请重新输入密码！” + // 并将页面重定向到学校管理员忘记密码重置页面，同时关闭当前窗口 + resp.getWriter().write(""); + } + }else { + // 如果用户输入的新密码和确认密码不相等 + // 通过响应输出一段JavaScript代码，弹出提示框显示“两次密码不一样!请重新输入密码！” + // 并将页面重定向到学校管理员忘记密码重置页面，同时关闭当前窗口 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + this.doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包名为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于执行数据库相关操作，如查询等 + +import javax.servlet.ServletException; +// 导入处理Servlet异常的类，在Servlet处理请求过程中发生异常时使用 + +import javax.servlet.annotation.WebServlet; +// 导入用于将Servlet映射到URL的注解 + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，通过它可以获取请求参数、请求头信息等 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，通过它可以设置响应内容、响应头信息等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关信息 + +import javax.sql.rowset.serial.SerialStruct; +// 导入SerialStruct类，这里未使用到，属于无用导入（可删除） + +import java.io.IOException; +// 导入处理I/O异常的类，如在读取或写入数据时可能发生的异常 + +import java.sql.ResultSet; +// 导入用于处理数据库查询结果的类，用于获取查询到的数据 + +@WebServlet("/SchoAdmLoginServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoAdmLoginServlet" +public class SchoAdmLoginServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML，字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取表单请求中的参数，这里获取管理员编号 + String adno = req.getParameter("adno"); + // 获取表单请求中的参数，这里获取管理员密码 + String adpsw = req.getParameter("adpsw"); + // 固定设置所属单位为"学校"，表示学校管理员 + String belong = "学校"; + + // 构造SQL查询语句，用于从admin表中查询匹配的管理员记录 + String sql = "select * from admin where adno = ? and adpsw = ? and belong = ?"; + // 创建包含SQL语句参数的对象数组，依次为管理员编号、密码、所属单位 + Object[] objects = {adno, adpsw, belong}; + // 调用FrontWebDao的login方法执行SQL查询，并获取结果集 + ResultSet resultSet = FrontWebDao.login(sql, objects); + + // 判断密码和账号是否正确 + try { + // 如果结果集有下一条记录，说明查询到了匹配的管理员记录 + if (resultSet.next()){ + // 创建会话对象，用于存储用户会话信息 + HttpSession session = req.getSession(); + // 在会话中存储管理员编号 + session.setAttribute("adno", adno); + // 在会话中存储所属单位（这里是"学校"） + session.setAttribute("belong", belong); + // 在会话中存储学校管理员编号（与adno相同，这里可能存在命名重复问题） + session.setAttribute("schoadno", adno); + + // 打印登录成功信息到控制台，用于调试 + System.out.println("登陆成功!"); + // 设置请求属性，指定跳转的URL路径 + req.setAttribute("httpUrl","/view/schoadmin/schomainview.jsp"); + // 设置请求属性，指定提示信息 + req.setAttribute("info", "登录成功!即将跳转至学校管理员后台首页!"); + // 设置请求属性，指定页面标题 + req.setAttribute("title","登录成功"); + // 转发请求到指定的页面（/view/frontweb/info.jsp），并传递请求和响应对象 + req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp); + + }else { + // 如果结果集没有下一条记录，说明账号或密码错误 + System.out.println("用户名或密码错误!请重新登录!"); + // 设置请求属性，指定跳转回登录页面的URL路径 + req.setAttribute("httpUrl","/view/frontweb/schoadmlogin.jsp"); + // 设置请求属性，指定错误提示信息 + req.setAttribute("info", "登录失败!管理员账号或密码错误!即将跳转至登录页面!"); + // 设置请求属性，指定页面标题 + req.setAttribute("title","登录失败"); + // 转发请求到指定的页面（/view/frontweb/info.jsp），并传递请求和响应对象 + req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp); + } + } catch (Exception e) { + // 捕获异常并打印异常堆栈信息，用于调试和错误排查 + e.printStackTrace(); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + this.doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于执行数据库相关操作，如更新操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet在运行过程中可能出现的异常情况 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，这是编写Servlet时继承的基础类，用于处理HTTP请求和响应 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，通过它可以获取请求参数、请求头信息等 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，通过它可以设置响应内容、状态码等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关的信息 + +import java.io.IOException; +// 导入用于处理I/O异常的类，例如在读写数据时可能出现的异常 + +@WebServlet("/StuAlterPswServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuAlterPswServlet" +public class StuAlterPswServlet extends HttpServlet { + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，并且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取当前请求的会话对象 + HttpSession session = req.getSession(); + // 从会话中获取名为"sno"的属性值，并将其转换为String类型，该值表示学生编号 + String sno = (String) session.getAttribute("sno"); + + // 从请求参数中获取名为"spsw"的参数值，该值表示学生输入的新密码 + String spsw = req.getParameter("spsw"); + // 从请求参数中获取名为"spsw1"的参数值，该值表示学生再次输入的新密码用于确认 + String spsw1 = req.getParameter("spsw1"); + + // 判断两次输入的密码是否相同 + if (spsw.equals(spsw1)){ + // 如果相同，则进行密码修改操作 + // 构造SQL更新语句，用于更新student表中指定sno的学生的密码 + String sql = "update student set spsw = ? where sno = ?"; + // 创建包含SQL语句参数的对象数组，第一个参数是新密码，第二个参数是学生编号 + Object[] objects = {spsw, sno}; + // 调用FrontWebDao的executeUpdate方法执行SQL更新语句，并获取受影响的行数 + int num = FrontWebDao.executeUpdate(sql, objects); + if (num > 0){ + // 如果受影响的行数大于0，说明密码修改成功 + // 通过响应输出一段JavaScript代码，弹出提示框提示修改密码成功，并要求学生重新登录 + // 同时将页面重定向到学生登录页面，并关闭当前窗口 + resp.getWriter().write(""); + }else { + // 如果受影响的行数不大于0，说明密码修改失败 + // 通过响应输出一段JavaScript代码，弹出提示框提示修改密码失败，并让学生重新输入密码 + // 同时将页面重定向到学生修改密码页面，并关闭当前窗口 + resp.getWriter().write(""); + } + }else { + // 如果两次输入的密码不同 + // 通过响应输出一段JavaScript代码，弹出提示框提示两次密码不一样，并让学生重新输入密码 + // 同时将页面重定向到学生修改密码页面，并关闭当前窗口 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的逻辑 + this.doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包名为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于执行数据库操作，如更新密码的SQL语句 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet在运行过程中可能抛出的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，这是编写Servlet时的基类，用于处理HTTP请求和响应 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，可获取请求参数等信息 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，可设置响应内容、状态码等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关信息（虽然此处未使用会话存储相关信息，但导入了该类） + +import java.io.IOException; +// 导入用于处理I/O异常的类，例如在读写数据时可能出现的异常 + +@WebServlet("/StuForgetPswServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuForgetPswServlet" +public class StuForgetPswServlet extends HttpServlet { + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 从HTTP请求的参数中获取名为"sno"的参数值，该值代表学生编号 + String sno = req.getParameter("sno"); + + // 从HTTP请求的参数中获取名为"spsw"的参数值，该值代表学生输入的新密码 + String spsw = req.getParameter("spsw"); + // 从HTTP请求的参数中获取名为"spsw1"的参数值，该值代表学生再次输入的用于确认的新密码 + String spsw1 = req.getParameter("spsw1"); + + // 判断用户输入的新密码和确认密码是否相等 + if (spsw.equals(spsw1)){ + // 如果相等，则进行密码修改操作 + // 构造SQL更新语句，用于更新student表中指定学生编号（sno）对应的密码（spsw） + String sql = "update student set spsw = ? where sno = ?"; + // 创建一个包含SQL语句参数的对象数组，第一个参数是新密码，第二个参数是学生编号 + Object[] objects = {spsw, sno}; + // 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句，并获取受影响的行数 + int num = FrontWebDao.executeUpdate(sql, objects); + if (num > 0){ + // 如果受影响的行数大于0，说明密码更新操作成功 + // 通过响应输出一段JavaScript代码，弹出提示框显示“修改密码成功！请登录！” + // 并将页面重定向到学生登录页面，同时关闭当前窗口 + resp.getWriter().write(""); + }else { + // 如果受影响的行数不大于0，说明密码更新操作失败 + // 通过响应输出一段JavaScript代码，弹出提示框显示“修改密码失败！请重新输入密码！” + // 并将页面重定向到学生忘记密码重置页面，同时关闭当前窗口 + resp.getWriter().write(""); + } + }else { + // 如果用户输入的新密码和确认密码不相等 + // 通过响应输出一段JavaScript代码，弹出提示框显示“两次密码不一样!请重新输入密码！” + // 并将页面重定向到学生忘记密码重置页面，同时关闭当前窗口 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + this.doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包名为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于执行数据库查询操作 + +import com.dao.StuDao; +// 导入StuDao类，这里未使用到，属于无用导入（可删除） + +import com.entity.Student; +// 导入Student实体类，用于封装学生相关信息 + +import com.utils.JDBCUtils; +// 导入JDBC工具类，用于数据库连接的管理和资源关闭等操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet运行时可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，通过它可以获取请求参数、请求头信息等 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，通过它可以设置响应内容、响应头信息等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关信息 + +import java.io.IOException; +// 导入用于处理I/O异常的类，如在读取或写入数据时可能发生的异常 + +import java.sql.ResultSet; +// 导入用于处理数据库查询结果的类，用于获取查询到的数据 + +import java.util.ArrayList; +// 导入ArrayList类，这里未使用到，属于无用导入（可删除） + +@WebServlet("/StuInfoServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuInfoServlet" +public class StuInfoServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML，字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取当前请求的会话对象 + HttpSession session = req.getSession(); + // 从会话中获取名为"sno"的属性值，并将其转换为String类型，该值表示学生编号 + String sno = (String) session.getAttribute("sno"); + + // 构造SQL查询语句，用于从student表中查询指定学生编号（sno）的学生信息 + String sql = "select * from student where sno = ?"; + // 创建包含SQL语句参数的对象数组，参数为学生编号 + Object[] objects = {sno}; + // 调用FrontWebDao的qureyInfo方法执行SQL查询，并获取结果集 + ResultSet resultSet = FrontWebDao.qureyInfo(sql, objects); + // 创建一个Student对象，用于存储查询到的学生信息 + Student student = new Student(); + + try { + // 遍历结果集，将每一行数据封装到Student对象中 + while (resultSet.next()){ + // 设置学生编号 + student.setSno(resultSet.getString("sno")); + // 设置学生姓名 + student.setSname(resultSet.getString("sname")); + // 设置学生性别 + student.setSsex(resultSet.getString("ssex")); + // 设置学生年龄，将数据库中的整数类型值转换为int类型 + student.setSage(resultSet.getInt("sage")); + // 设置学生班级 + student.setSclass(resultSet.getString("sclass")); + // 设置学生专业 + student.setSpecialty(resultSet.getString("specialty")); + // 设置学生所在系部 + student.setSdept(resultSet.getString("sdept")); + // 设置学生电话号码 + student.setSphone(resultSet.getString("sphone")); + } + } catch (Exception e) { + // 捕获异常并打印异常堆栈信息，用于调试和错误排查 + e.printStackTrace(); + } finally { + // 无论是否发生异常，都调用JDBCUtils的close方法关闭结果集，释放资源 + JDBCUtils.close(resultSet); + } + + // 将封装好的学生信息对象（student）设置为请求属性，以便在后续页面中使用 + req.setAttribute("student", student); + + // 转发请求到指定的页面（/view/frontweb/stuinfo.jsp），并传递请求和响应对象 + req.getRequestDispatcher("/view/frontweb/stuinfo.jsp").forward(req, resp); + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + this.doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包名为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于执行数据库查询操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet运行时可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，通过它可以获取请求参数等信息 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，通过它可以设置响应内容、状态码等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关信息 + +import java.io.IOException; +// 导入用于处理I/O异常的类，如在读写数据时可能发生的异常 + +import java.sql.ResultSet; +// 导入用于处理数据库查询结果的类 + +import java.sql.SQLException; +// 导入用于处理SQL异常的类 + +@WebServlet("/StuLoginServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuLoginServlet" +public class StuLoginServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，并且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 从HTTP请求的参数中获取名为"sno"的参数值，该值代表学生编号 + String sno = req.getParameter("sno"); + // 从HTTP请求的参数中获取名为"spsw"的参数值，该值代表学生密码 + String spsw = req.getParameter("spsw"); + // 将获取到的学生编号打印到控制台，用于调试 + System.out.println(sno); + // 将获取到的学生密码打印到控制台，用于调试 + System.out.println(spsw); + + // 获取当前请求的会话对象，如果不存在则创建一个新的会话 + HttpSession session = req.getSession(); + // 将学生编号存储到会话中，以便在后续请求中可以获取该信息 + session.setAttribute("sno", sno); + + // 构造SQL查询语句，用于从student表中查询匹配的学生记录 + String sql = "select * from student where sno = ? and spsw = ?"; + // 创建包含SQL语句参数的对象数组，依次为学生编号、学生密码 + Object[] objects = {sno, spsw}; + // 调用FrontWebDao的login方法执行SQL查询，并获取结果集 + ResultSet resultSet = FrontWebDao.login(sql, objects); + + try { + // 如果结果集有下一条记录，说明查询到了匹配的学生记录 + if (resultSet.next()){ + // 设置请求属性，指定跳转的URL路径为"/StuInfoServlet"，即学生信息Servlet + req.setAttribute("httpUrl","/StuInfoServlet"); + // 设置请求属性，指定提示信息 + req.setAttribute("info", "登录成功!即将跳转至学生信息页面!"); + // 设置请求属性，指定页面标题 + req.setAttribute("title","登录成功"); + // 转发请求到指定的页面（/view/frontweb/info.jsp），并传递请求和响应对象 + req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp); + }else { + // 如果结果集没有下一条记录，说明学号或密码错误 + // 设置请求属性，指定跳转回登录页面的URL路径 + req.setAttribute("httpUrl","/view/frontweb/stulogin.jsp"); + // 设置请求属性，指定错误提示信息 + req.setAttribute("info", "登录失败!学号或密码错误!即将跳转至登录页面!"); + // 设置请求属性，指定页面标题 + req.setAttribute("title","登录失败"); + // 转发请求到指定的页面（/view/frontweb/info.jsp），并传递请求和响应对象 + req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp); + } + } catch (SQLException e) { + // 捕获SQL异常并打印异常堆栈信息，用于调试和错误排查 + e.printStackTrace(); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + this.doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包为com.controller.frontweb + +import com.dao.DeptAdminDao; +// 导入部门管理员数据访问对象类，但在本Servlet中未使用 + +import com.dao.FrontWebDao; +// 导入前端数据访问对象类，用于执行数据库操作 + +import com.mysql.fabric.Response; +// 导入MySQL Fabric响应类，但在本Servlet中未使用 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet运行时可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，通过它可以获取请求参数等信息 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，通过它可以设置响应内容、状态码等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关信息 + +import javax.swing.*; +// 导入Swing组件类，但在本Servlet中未使用 + +import java.io.IOException; +// 导入用于处理I/O异常的类，如在读写数据时可能发生的异常 + +import java.io.PrintWriter; +// 导入用于输出响应内容的类，但在本Servlet中未直接使用 + +import java.sql.ResultSet; +// 导入用于处理数据库查询结果的类 + +import java.sql.SQLException; +// 导入用于处理SQL异常的类 + +import java.text.SimpleDateFormat; +// 导入用于格式化日期的类 + +import java.util.Date; +// 导入日期类，用于获取当前日期和时间 + +@WebServlet("/StuPunchServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuPunchServlet" +public class StuPunchServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，并且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取当前请求的会话对象 + HttpSession session = req.getSession(); + // 从会话中获取名为"sno"的属性值，并将其转换为String类型，该值表示学生编号 + String sno = (String) session.getAttribute("sno"); + // 打印学生编号到控制台，用于调试 + System.out.println(sno); + + // 从HTTP请求的参数中获取名为"sishot"的参数值，该值表示学生是否发热 + String sishot = req.getParameter("sishot"); + // 从HTTP请求的参数中获取名为"siscough"的参数值，该值表示学生是否咳嗽 + String siscough = req.getParameter("siscough"); + // 从HTTP请求的参数中获取名为"sisseem"的参数值，该值表示学生是否有其他症状 + String sisseem = req.getParameter("sisseem"); + // 从HTTP请求的参数中获取名为"sisdiagnose"的参数值，该值表示学生是否被诊断 + String sisdiagnose = req.getParameter("sisdiagnose"); + // 从HTTP请求的参数中获取名为"sstatus"的参数值，该值表示学生当前状态 + String sstatus = req.getParameter("sstatus"); + + // 设置学生打卡状态为"是"，表示已打卡 + String sispunch = "是"; + // 创建Date对象，获取当前时间 + Date date = new Date(); + + // 创建SimpleDateFormat对象，用于将日期格式化为"yyyy-MM-dd"的字符串 + SimpleDateFormat sf1 = new SimpleDateFormat("yyyy-MM-dd"); + // 格式化当前日期 + String spunchdate = sf1.format(date); + // 打印当前日期到控制台，用于调试 + System.out.println(spunchdate); + + // 创建SimpleDateFormat对象，用于将时间格式化为"HH:mm"的字符串 + SimpleDateFormat sf2 = new SimpleDateFormat("HH:mm"); + // 格式化当前时间 + String spunchtime = sf2.format(date); + // 打印当前时间到控制台，用于调试 + System.out.println(spunchtime); + + // 声明SQL语句变量，初始化为null + String sql = null; + + // 构造SQL查询语句，用于查询该学生今天是否已经打卡 + sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?"; + // 创建包含SQL语句参数的对象数组，依次为学生编号、打卡日期 + Object[] objects1 = {sno, spunchdate}; + // 调用FrontWebDao的findTotalCount方法执行SQL查询，获取查询结果的数量 + int count = FrontWebDao.findTotalCount(sql, objects1); + + if (count == 0){ + // 如果查询结果数量为0，表示该学生今天还未打卡，则执行插入操作 + sql = "insert into stupunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)"; + // 创建包含SQL语句参数的对象数组，依次为学生编号、是否打卡、打卡日期、打卡时间、是否发热、是否咳嗽、是否有其他症状、是否被诊断、当前状态 + Object[] objects2 = {sno, sispunch, spunchdate, spunchtime, sishot, siscough, sisseem, sisdiagnose, sstatus}; + + // 调用FrontWebDao的executeUpdate方法执行SQL插入语句，并获取受影响的行数 + int num = FrontWebDao.executeUpdate(sql, objects2); + + // 打印受影响的行数到控制台，用于调试 + System.out.println(num); + + // 通过响应输出一段JavaScript代码，弹出提示框提示打卡成功 + // 并将页面重定向到学生信息页面，同时关闭当前窗口 + resp.getWriter().write(""); + + }else { + // 如果查询结果数量不为0，表示该学生今天已经打卡 + // 通过响应输出一段JavaScript代码，弹出提示框提示今天已打卡，不能再次打卡 + // 并将页面重定向到学生信息页面，同时关闭当前窗口 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包名为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于执行数据库相关操作，如更新操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet运行时可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，这是编写Servlet时继承的基础类，用于处理HTTP请求和响应 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，通过它可以获取请求参数、请求头信息等 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，通过它可以设置响应内容、状态码等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关信息 + +import java.io.IOException; +// 导入用于处理I/O异常的类，例如在读写数据时可能出现的异常 + +@WebServlet("/TeaAlterPswServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaAlterPswServlet" +public class TeaAlterPswServlet extends HttpServlet { + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，并且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取当前请求的会话对象 + HttpSession session = req.getSession(); + // 从会话中获取名为"tno"的属性值，并将其转换为String类型，该值表示教师编号 + String tno = (String) session.getAttribute("tno"); + + // 从请求参数中获取名为"tpsw"的参数值，该值表示教师输入的新密码 + String tpsw = req.getParameter("tpsw"); + // 从请求参数中获取名为"tpsw1"的参数值，该值表示教师再次输入的新密码用于确认 + String tpsw1 = req.getParameter("tpsw1"); + + // 判断两次输入的密码是否相同 + if (tpsw.equals(tpsw1)){ + // 如果相同，则进行密码修改操作 + // 构造SQL更新语句，用于更新teacher表中指定tno的教师的密码 + String sql = "update teacher set tpsw = ? where tno = ?"; + // 创建包含SQL语句参数的对象数组，第一个参数是新密码，第二个参数是教师编号 + Object[] objects = {tpsw, tno}; + // 调用FrontWebDao的executeUpdate方法执行SQL更新语句，并获取受影响的行数 + int num = FrontWebDao.executeUpdate(sql, objects); + if (num > 0){ + // 如果受影响的行数大于0，说明密码修改成功 + // 通过响应输出一段JavaScript代码，弹出提示框提示修改密码成功，并要求教师重新登录 + // 同时将页面重定向到教师登录页面，并关闭当前窗口 + resp.getWriter().write(""); + }else { + // 如果受影响的行数不大于0，说明密码修改失败 + // 通过响应输出一段JavaScript代码，弹出提示框提示修改密码失败，并让教师重新输入密码 + // 同时将页面重定向到教师修改密码页面，并关闭当前窗口 + resp.getWriter().write(""); + } + }else { + // 如果两次输入的密码不同 + // 通过响应输出一段JavaScript代码，弹出提示框提示两次密码不一样，并让教师重新输入密码 + // 同时将页面重定向到教师修改密码页面，并关闭当前窗口 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的逻辑 + this.doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包名为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于执行数据库操作，如更新密码相关的SQL操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet在运行过程中可能出现的异常情况 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类，用于处理HTTP请求和响应 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，通过它可以获取请求参数等信息 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，通过它可以设置响应内容、状态码等 + +import java.io.IOException; +// 导入用于处理I/O异常的类，例如在读写数据时可能出现的异常 + +@WebServlet("/TeaForgetPswServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaForgetPswServlet" +public class TeaForgetPswServlet extends HttpServlet { + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，并且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 从HTTP请求的参数中获取名为"tno"的参数值，该值代表教师编号 + String tno = req.getParameter("tno"); + + // 从HTTP请求的参数中获取名为"tpsw"的参数值，该值代表教师输入的新密码 + String tpsw = req.getParameter("tpsw"); + // 从HTTP请求的参数中获取名为"tpsw1"的参数值，该值代表教师再次输入的用于确认的新密码 + String tpsw1 = req.getParameter("tpsw1"); + + // 判断教师输入的新密码和确认密码是否相等 + if (tpsw.equals(tpsw1)){ + // 如果相等，则进行密码修改操作 + // 构造SQL更新语句，用于更新teacher表中指定教师编号（tno）对应的密码（tpsw） + String sql = "update teacher set tpsw = ? where tno = ?"; + // 创建一个包含SQL语句参数的对象数组，第一个参数是新密码，第二个参数是教师编号 + Object[] objects = {tpsw, tno}; + // 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句，并获取受影响的行数 + int num = FrontWebDao.executeUpdate(sql, objects); + if (num > 0){ + // 如果受影响的行数大于0，说明密码更新操作成功 + // 通过响应输出一段JavaScript代码，弹出提示框显示“修改密码成功！请登录！” + // 并将页面重定向到教师登录页面，同时关闭当前窗口 + resp.getWriter().write(""); + }else { + // 如果受影响的行数不大于0，说明密码更新操作失败 + // 通过响应输出一段JavaScript代码，弹出提示框显示“修改密码失败！请重新输入密码！” + // 并将页面重定向到教师忘记密码重置页面，同时关闭当前窗口 + resp.getWriter().write(""); + } + }else { + // 如果教师输入的新密码和确认密码不相等 + // 通过响应输出一段JavaScript代码，弹出提示框显示“两次密码不一样!请重新输入密码！” + // 并将页面重定向到教师忘记密码重置页面，同时关闭当前窗口 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + this.doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包名为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于执行数据库查询操作 + +import com.entity.Student; +// 导入Student实体类，这里未使用到，属于无用导入（可删除） + +import com.entity.Teacher; +// 导入Teacher实体类，用于封装教师相关信息 + +import com.utils.JDBCUtils; +// 导入JDBC工具类，用于数据库连接的管理和资源关闭等操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet运行时可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，通过它可以获取请求参数、请求头信息等 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，通过它可以设置响应内容、响应头信息等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关信息 + +import java.io.IOException; +// 导入用于处理I/O异常的类，如在读取或写入数据时可能发生的异常 + +import java.sql.ResultSet; +// 导入用于处理数据库查询结果的类，用于获取查询到的数据 + +@WebServlet("/TeaInfoServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaInfoServlet" +public class TeaInfoServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML，字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取当前请求的会话对象 + HttpSession session = req.getSession(); + // 从会话中获取名为"tno"的属性值，并将其转换为String类型，该值表示教师编号 + String tno = (String) session.getAttribute("tno"); + + // 构造SQL查询语句，用于从teacher表中查询指定教师编号（tno）的教师信息 + String sql = "select * from teacher where tno = ?"; + // 创建包含SQL语句参数的对象数组，参数为教师编号 + Object[] objects = {tno}; + // 调用FrontWebDao的qureyInfo方法执行SQL查询，并获取结果集 + ResultSet resultSet = FrontWebDao.qureyInfo(sql, objects); + // 创建一个Teacher对象，用于存储查询到的教师信息 + Teacher teacher = new Teacher(); + + try { + // 遍历结果集，将每一行数据封装到Teacher对象中 + while (resultSet.next()){ + // 设置教师编号 + teacher.setTno(resultSet.getString("tno")); + // 设置教师姓名 + teacher.setTname(resultSet.getString("tname")); + // 设置教师性别 + teacher.setTsex(resultSet.getString("tsex")); + // 设置教师年龄，将数据库中的整数类型值转换为int类型 + teacher.setTage(resultSet.getInt("tage")); + // 设置教师所在系部 + teacher.setTdept(resultSet.getString("tdept")); + // 设置教师电话号码 + teacher.setTphone(resultSet.getString("tphone")); + } + } catch (Exception e) { + // 捕获异常并打印异常堆栈信息，用于调试和错误排查 + e.printStackTrace(); + } finally { + // 无论是否发生异常，都调用JDBCUtils的close方法关闭结果集，释放资源 + JDBCUtils.close(resultSet); + } + + // 将封装好的教师信息对象（teacher）设置为请求属性，以便在后续页面中使用 + req.setAttribute("teacher", teacher); + + // 转发请求到指定的页面（/view/frontweb/teainfo.jsp），并传递请求和响应对象 + req.getRequestDispatcher("/view/frontweb/teainfo.jsp").forward(req, resp); + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + this.doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包名为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于执行数据库查询操作 + +import com.entity.Student; +// 导入Student实体类，这里未使用到，属于无用导入（可删除） + +import com.entity.Teacher; +// 导入Teacher实体类，用于封装教师相关信息 + +import com.utils.JDBCUtils; +// 导入JDBC工具类，用于数据库连接的管理和资源关闭等操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet运行时可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，通过它可以获取请求参数、请求头信息等 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，通过它可以设置响应内容、响应头信息等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关信息 + +import java.io.IOException; +// 导入用于处理I/O异常的类，如在读取或写入数据时可能发生的异常 + +import java.sql.ResultSet; +// 导入用于处理数据库查询结果的类，用于获取查询到的数据 + +@WebServlet("/TeaInfoServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaInfoServlet" +public class TeaInfoServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML，字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取当前请求的会话对象 + HttpSession session = req.getSession(); + // 从会话中获取名为"tno"的属性值，并将其转换为String类型，该值表示教师编号 + String tno = (String) session.getAttribute("tno"); + + // 构造SQL查询语句，用于从teacher表中查询指定教师编号（tno）的教师信息 + String sql = "select * from teacher where tno = ?"; + // 创建包含SQL语句参数的对象数组，参数为教师编号 + Object[] objects = {tno}; + // 调用FrontWebDao的qureyInfo方法执行SQL查询，并获取结果集 + ResultSet resultSet = FrontWebDao.qureyInfo(sql, objects); + // 创建一个Teacher对象，用于存储查询到的教师信息 + Teacher teacher = new Teacher(); + + try { + // 遍历结果集，将每一行数据封装到Teacher对象中 + while (resultSet.next()){ + // 设置教师编号 + teacher.setTno(resultSet.getString("tno")); + // 设置教师姓名 + teacher.setTname(resultSet.getString("tname")); + // 设置教师性别 + teacher.setTsex(resultSet.getString("tsex")); + // 设置教师年龄，将数据库中的整数类型值转换为int类型 + teacher.setTage(resultSet.getInt("tage")); + // 设置教师所在系部 + teacher.setTdept(resultSet.getString("tdept")); + // 设置教师电话号码 + teacher.setTphone(resultSet.getString("tphone")); + } + } catch (Exception e) { + // 捕获异常并打印异常堆栈信息，用于调试和错误排查 + e.printStackTrace(); + } finally { + // 无论是否发生异常，都调用JDBCUtils的close方法关闭结果集，释放资源 + JDBCUtils.close(resultSet); + } + + // 将封装好的教师信息对象（teacher）设置为请求属性，以便在后续页面中使用 + req.setAttribute("teacher", teacher); + + // 转发请求到指定的页面（/view/frontweb/teainfo.jsp），并传递请求和响应对象 + req.getRequestDispatcher("/view/frontweb/teainfo.jsp").forward(req, resp); + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + this.doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包名为com.controller.frontweb + +import com.dao.FrontWebDao; +// 导入数据访问对象类FrontWebDao，用于执行数据库查询操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet运行时可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，通过它可以获取请求参数等信息 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，通过它可以设置响应内容、状态码等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关信息 + +import java.io.IOException; +// 导入用于处理I/O异常的类，如在读写数据时可能发生的异常 + +import java.sql.ResultSet; +// 导入用于处理数据库查询结果的类 + +import java.sql.SQLException; +// 导入用于处理SQL异常的类 + +@WebServlet("/TeaLoginServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaLoginServlet" +public class TeaLoginServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，并且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 从HTTP请求的参数中获取名为"tno"的参数值，该值代表教师编号 + String tno = req.getParameter("tno"); + // 从HTTP请求的参数中获取名为"tpsw"的参数值，该值代表教师密码 + String tpsw = req.getParameter("tpsw"); + // 将获取到的教师编号打印到控制台，用于调试 + System.out.println(tno); + // 将获取到的教师密码打印到控制台，用于调试 + System.out.println(tpsw); + + // 获取当前请求的会话对象，如果不存在则创建一个新的会话 + HttpSession session = req.getSession(); + // 将教师编号存储到会话中，以便在后续请求中可以获取该信息 + session.setAttribute("tno", tno); + + // 构造SQL查询语句，用于从teacher表中查询匹配的教师记录 + String sql = "select * from teacher where tno = ? and tpsw = ?"; + // 创建包含SQL语句参数的对象数组，依次为教师编号、教师密码 + Object[] objects = {tno, tpsw}; + // 调用FrontWebDao的login方法执行SQL查询，并获取结果集 + ResultSet resultSet = FrontWebDao.login(sql, objects); + + try { + // 如果结果集有下一条记录，说明查询到了匹配的教师记录 + if (resultSet.next()){ + // 设置请求属性，指定跳转的URL路径为"/TeaInfoServlet"，即教师信息Servlet + req.setAttribute("httpUrl","/TeaInfoServlet"); + // 设置请求属性，指定提示信息 + req.setAttribute("info", "登录成功!即将跳转至教师信息页面!"); + // 设置请求属性，指定页面标题 + req.setAttribute("title","登录成功"); + // 转发请求到指定的页面（/view/frontweb/info.jsp），并传递请求和响应对象 + req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp); + }else { + // 如果结果集没有下一条记录，说明教工号或密码错误 + // 设置请求属性，指定跳转回登录页面的URL路径 + req.setAttribute("httpUrl","/view/frontweb/tealogin.jsp"); + // 设置请求属性，指定错误提示信息 + req.setAttribute("info", "登录失败!教工号或密码错误!即将跳转至登录页面!"); + // 设置请求属性，指定页面标题 + req.setAttribute("title","登录失败"); + // 转发请求到指定的页面（/view/frontweb/info.jsp），并传递请求和响应对象 + req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp); + } + } catch (SQLException e) { + // 捕获SQL异常并打印异常堆栈信息，用于调试和错误排查 + e.printStackTrace(); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + this.doGet(req, resp); + } +} +package com.controller.frontweb; +// 声明该Servlet所在的包名为com.controller.frontweb + +import com.dao.DeptAdminDao; +// 导入部门管理员数据访问对象类，在本类中未使用 + +import com.dao.FrontWebDao; +// 导入前端数据访问对象类，用于执行数据库操作，如查询、插入等 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet运行时可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，可获取请求参数等信息 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，可设置响应内容、状态码等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关信息 + +import java.io.IOException; +// 导入用于处理I/O异常的类，如在读写数据时可能发生的异常 + +import java.sql.ResultSet; +// 导入用于处理数据库查询结果的类 + +import java.text.SimpleDateFormat; +// 导入用于格式化日期和时间的类 + +import java.util.Date; +// 导入日期类，用于获取当前日期和时间 + +@WebServlet("/TeaPunchServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaPunchServlet" +public class TeaPunchServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，并且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取当前请求的会话对象 + HttpSession session = req.getSession(); + // 从会话中获取名为"tno"的属性值，并将其转换为String类型，该值表示教师编号 + String tno = (String) session.getAttribute("tno"); + // 将教师编号打印到控制台，用于调试 + System.out.println(tno); + + // 从HTTP请求的参数中获取名为"tishot"的参数值，该值表示教师是否发热 + String tishot = req.getParameter("tishot"); + // 从HTTP请求的参数中获取名为"tiscough"的参数值，该值表示教师是否咳嗽 + String tiscough = req.getParameter("tiscough"); + // 从HTTP请求的参数中获取名为"tisseem"的参数值，该值表示教师是否有其他症状 + String tisseem = req.getParameter("tisseem"); + // 从HTTP请求的参数中获取名为"tisdiagnose"的参数值，该值表示教师是否被诊断 + String tisdiagnose = req.getParameter("tisdiagnose"); + // 从HTTP请求的参数中获取名为"tstatus"的参数值，该值表示教师当前状态 + String tstatus = req.getParameter("tstatus"); + + // 设置教师打卡状态为"是"，表示已打卡 + String tispunch = "是"; + // 创建Date对象，获取当前时间 + Date date = new Date(); + + // 创建SimpleDateFormat对象，用于将日期格式化为"yyyy-MM-dd"的字符串 + SimpleDateFormat sf1 = new SimpleDateFormat("yyyy-MM-dd"); + // 格式化当前日期 + String tpunchdate = sf1.format(date); + // 将当前日期打印到控制台，用于调试 + System.out.println(tpunchdate); + + // 创建SimpleDateFormat对象，用于将时间格式化为"HH:mm"的字符串 + SimpleDateFormat sf2 = new SimpleDateFormat("HH:mm"); + // 格式化当前时间 + String tpunchtime = sf2.format(date); + // 将当前时间打印到控制台，用于调试 + System.out.println(tpunchtime); + + // 初始化SQL语句变量 + String sql = null; + + // 构造SQL查询语句，用于查询该教师今天是否已经打卡 + sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?"; + // 创建包含SQL语句参数的对象数组，依次为教师编号、打卡日期 + Object[] objects1 = {tno, tpunchdate}; + // 调用FrontWebDao的findTotalCount方法执行SQL查询，获取查询结果的数量 + int count = FrontWebDao.findTotalCount(sql, objects1); + + if (count == 0) { + // 如果查询结果数量为0，表示该教师今天还未打卡，则执行插入操作 + sql = "insert into teapunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)"; + // 创建包含SQL语句参数的对象数组，依次为教师编号、是否打卡、打卡日期、打卡时间、是否发热、是否咳嗽、是否有其他症状、是否被诊断、当前状态 + Object[] objects2 = {tno, tispunch, tpunchdate, tpunchtime, tishot, tiscough, tisseem, tisdiagnose, tstatus}; + + // 调用FrontWebDao的executeUpdate方法执行SQL插入语句，并获取受影响的行数 + int num = FrontWebDao.executeUpdate(sql, objects2); + + // 将受影响的行数打印到控制台，用于调试 + System.out.println(num); + + // 通过响应输出一段JavaScript代码，弹出提示框提示打卡成功 + // 并将页面重定向到教师信息页面，同时关闭当前窗口 + resp.getWriter().write(""); + + } else { + // 如果查询结果数量不为0，表示该教师今天已经打卡 + // 通过响应输出一段JavaScript代码，弹出提示框提示今天已打卡，不能再次打卡 + // 并将页面重定向到教师信息页面，同时关闭当前窗口 + resp.getWriter().write(""); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + this.doGet(req, resp); + } +} +package com.controller.schoadmin; +// 声明该类所在的包名为com.controller.schoadmin + +import com.dao.DeptAdminDao; +// 导入自定义的DeptAdminDao类，用于数据库操作 + +import javax.servlet.ServletException; +// 导入ServletException类，用于处理Servlet异常 + +import javax.servlet.annotation.WebServlet; +// 导入WebServlet注解，用于将Servlet映射到URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入HttpServletRequest类，用于获取客户端请求信息 + +import javax.servlet.http.HttpServletResponse; +// 导入HttpServletResponse类，用于向客户端发送响应信息 + +import java.io.IOException; +// 导入IOException类，用于处理输入输出异常 + +/** + * 学校管理员添加学生打卡记录的Servlet + * 处理添加学生打卡信息的请求，检查记录是否存在并执行相应操作 + */ +@WebServlet("/SchoAddStuPunchServlet") +public class SchoAddStuPunchServlet extends HttpServlet { + + /** + * 处理GET请求 + * @param req HttpServletRequest对象，包含客户端请求信息 + * @param resp HttpServletResponse对象，用于向客户端发送响应 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @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"); + + // 获取表单请求的参数 + String sno = req.getParameter("sno"); // 学生学号 + String sispunch = req.getParameter("sispunch"); // 是否打卡 + String spunchdate = req.getParameter("spunchdate"); // 打卡日期 + String spunchtime = req.getParameter("spunchtime"); // 打卡时间 + String sishot = req.getParameter("sishot"); // 是否发烧 + String siscough = req.getParameter("siscough"); // 是否咳嗽 + String sisseem = req.getParameter("sisseem"); // 是否有其他症状 + String sisdiagnose = req.getParameter("sisdiagnose"); // 是否就医诊断 + String sstatus = req.getParameter("sstatus"); // 健康状态 + + // 声明SQL语句变量 + String sql = null; + + // 打印调试信息 + System.out.println("shgshgh"); + + // 查询是否存在该学生在指定日期的打卡记录 + sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?"; + Object[] objects = {sno, spunchdate}; + // 调用DeptAdminDao的方法查询记录数量 + int count = DeptAdminDao.findTotalCount(sql, objects); + + // 如果记录不存在 + if (count == 0) { + // 插入新的打卡记录 + sql = "insert into stupunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)"; + Object[] objects1 = {sno, sispunch, spunchdate, spunchtime, sishot, siscough, sisseem, sisdiagnose, sstatus}; + + // 执行插入操作并获取受影响的行数 + int num = DeptAdminDao.executeUpdate(sql, objects1); + + // 打印插入结果 + System.out.println(num); + + // 重定向到分页查询Servlet，显示第一页数据 + req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp); + } else { + // 如果记录已存在，转发到提示页面 + req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp); + } + } + + /** + * 处理POST请求，直接调用doGet方法处理 + * @param req HttpServletRequest对象，包含客户端请求信息 + * @param resp HttpServletResponse对象，用于向客户端发送响应 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + doGet(req, resp); + } +}package com.controller.schoadmin; +// 声明该类所在的包名为com.controller.schoadmin + +import com.dao.DeptAdminDao; +// 导入自定义的数据访问对象类，用于数据库操作 + +import javax.servlet.ServletException; +// 导入Servlet异常处理类 + +import javax.servlet.annotation.WebServlet; +// 导入Servlet注解，用于映射Servlet到URL路径 + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet基类，所有Servlet都继承自此类 + +import javax.servlet.http.HttpServletRequest; +// 导入HTTP请求对象类，用于获取客户端请求信息 + +import javax.servlet.http.HttpServletResponse; +// 导入HTTP响应对象类，用于向客户端发送响应 + +import java.io.IOException; +// 导入输入输出异常类 + +/** + * 学校管理员添加学生信息的Servlet + * 处理添加学生信息的请求，检查学生是否已存在并执行相应操作 + */ +@WebServlet("/SchoAddStuServlet") +public class SchoAddStuServlet extends HttpServlet { + + /** + * 处理GET请求的方法 + * @param req HTTP请求对象 + * @param resp HTTP响应对象 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @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"); + + // 获取表单请求的参数 + String sno = req.getParameter("sno"); // 学生学号 + String sname = req.getParameter("sname"); // 学生姓名 + String ssex = req.getParameter("ssex"); // 学生性别 + String sage = req.getParameter("sage"); // 学生年龄 + String specialty = req.getParameter("specialty"); // 专业 + String sclass = req.getParameter("sclass"); // 班级 + String sdept = req.getParameter("sdept"); // 系部 + String sphone = req.getParameter("sphone"); // 联系电话 + String spsw = req.getParameter("spsw"); // 密码 + + // 将年龄字符串转换为整数类型 + int sage1 = Integer.parseInt(sage); + + // 声明SQL语句变量 + String sql = null; + + // 打印调试信息 + System.out.println("shgshgh"); + + // 查询数据库中是否已存在该学号的学生 + sql = "select count(*) as num from student where sno = ?"; + Object[] objects = {sno}; + // 调用DAO方法执行查询，获取记录数量 + int count = DeptAdminDao.findTotalCount(sql, objects); + + // 如果学生不存在 + if (count == 0) { + // 构造插入学生信息的SQL语句 + sql = "insert into student values(?, ?, ?, ?, ?, ?, ?, ?, ?)"; + Object[] objects1 = {sno, sname, ssex, sage1, sclass, specialty, sdept, sphone, spsw}; + + // 调用DAO方法执行插入操作，获取受影响的行数 + int num = DeptAdminDao.executeUpdate(sql, objects1); + + // 打印插入结果 + System.out.println(num); + + // 转发请求到分页查询Servlet，显示第一页学生列表 + req.getRequestDispatcher("/SchoQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=").forward(req, resp); + } else { + // 如果学生已存在，转发到提示页面 + req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp); + } + } + + /** + * 处理POST请求的方法，直接调用doGet方法处理 + * @param req HTTP请求对象 + * @param resp HTTP响应对象 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + doGet(req, resp); + } +} +package com.controller.schoadmin; +// 声明该类所在的包名为com.controller.schoadmin + +import com.dao.DeptAdminDao; +// 导入自定义的数据访问对象类，用于数据库操作 + +import javax.servlet.ServletException; +// 导入Servlet异常处理类 + +import javax.servlet.annotation.WebServlet; +// 导入Servlet注解，用于映射Servlet到URL路径 + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet基类，所有Servlet都继承自此类 + +import javax.servlet.http.HttpServletRequest; +// 导入HTTP请求对象类，用于获取客户端请求信息 + +import javax.servlet.http.HttpServletResponse; +// 导入HTTP响应对象类，用于向客户端发送响应 + +import java.io.IOException; +// 导入输入输出异常类 + +/** + * 学校管理员添加教师打卡记录的Servlet + * 处理添加教师打卡信息的请求，检查记录是否存在并执行相应操作 + */ +@WebServlet("/SchoAddTeaPunchServlet") +public class SchoAddTeaPunchServlet extends HttpServlet { + + /** + * 处理GET请求的方法 + * @param req HTTP请求对象 + * @param resp HTTP响应对象 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @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"); + + // 获取表单请求的参数 + String tno = req.getParameter("tno"); // 教师工号 + String tispunch = req.getParameter("tispunch"); // 是否打卡 + String tpunchdate = req.getParameter("tpunchdate"); // 打卡日期 + String tpunchtime = req.getParameter("tpunchtime"); // 打卡时间 + String tishot = req.getParameter("tishot"); // 是否发烧 + String tiscough = req.getParameter("tiscough"); // 是否咳嗽 + String tisseem = req.getParameter("tisseem"); // 是否有其他症状 + String tisdiagnose = req.getParameter("tisdiagnose"); // 是否就医诊断 + String tstatus = req.getParameter("tstatus"); // 健康状态 + + // 声明SQL语句变量 + String sql = null; + + // 打印调试信息 + System.out.println("shgshgh"); + + // 查询数据库中是否已存在该教师在指定日期的打卡记录 + sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?"; + Object[] objects = {tno, tpunchdate}; + // 调用DAO方法执行查询，获取记录数量 + int count = DeptAdminDao.findTotalCount(sql, objects); + + // 如果记录不存在 + if (count == 0) { + // 构造插入教师打卡记录的SQL语句 + sql = "insert into teapunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)"; + Object[] objects1 = {tno, tispunch, tpunchdate, tpunchtime, tishot, tiscough, tisseem, tisdiagnose, tstatus}; + + // 调用DAO方法执行插入操作，获取受影响的行数 + int num = DeptAdminDao.executeUpdate(sql, objects1); + + // 打印插入结果 + System.out.println(num); + + // 转发请求到分页查询Servlet，显示第一页教师打卡记录 + req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp); + } else { + // 如果记录已存在，转发到提示页面 + req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp); + } + } + + /** + * 处理POST请求的方法，直接调用doGet方法处理 + * @param req HTTP请求对象 + * @param resp HTTP响应对象 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + doGet(req, resp); + } +} +package com.controller.schoadmin; +// 声明该类所在的包名为com.controller.schoadmin + +import com.dao.DeptAdminDao; +// 导入数据访问对象类，用于执行数据库的查询和更新操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet运行时可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，可获取请求参数等信息 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，可设置响应内容、状态码等 + +import java.io.IOException; +// 导入用于处理I/O异常的类，如在读写数据时可能发生的异常 + +@WebServlet("/SchoAddTeaServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoAddTeaServlet" +public class SchoAddTeaServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，并且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取表单请求的参数 + String tno = req.getParameter("tno");// 教师编号 + String tname = req.getParameter("tname");// 教师姓名 + String tsex = req.getParameter("tsex");// 教师性别 + String tage = req.getParameter("tage");// 教师年龄 + String tdept = req.getParameter("tdept");// 教师所在系部 + String tphone = req.getParameter("tphone");// 教师联系电话 + String tpsw = req.getParameter("tpsw");// 教师密码 + + // 数据类型转换，将年龄从字符串转换为整数 + int tage1 = Integer.parseInt(tage); + + // 声明SQL语句变量 + String sql = null; + + // 打印调试信息 + System.out.println("shgshgh"); + + // 查询是否存在该教师（根据教师编号查询） + sql = "select count(*) as num from teacher where tno = ?"; + Object[] objects = {tno}; + // 调用DeptAdminDao的方法执行SQL查询，获取符合条件的记录数量 + int count = DeptAdminDao.findTotalCount(sql, objects); + + if (count == 0) { // 如果不存在该教师记录 + // 构造插入教师信息的SQL语句 + sql = "insert into teacher values(?, ?, ?, ?, ?, ?, ?)"; + Object[] objects1 = {tno, tname, tsex, tage1, tdept, tphone, tpsw}; + + // 调用DeptAdminDao的方法执行SQL插入操作，获取受影响的行数 + int num = DeptAdminDao.executeUpdate(sql, objects1); + + // 打印插入操作影响的行数，用于调试 + System.out.println(num); + + // 转发请求到分页查询教师信息的Servlet，传递参数设置当前页为1，每页显示7条记录，其他查询条件为空 + req.getRequestDispatcher("/SchoQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=").forward(req, resp); + } else { + // 如果教师记录已存在，转发请求到提示已存在数据的页面 + req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + doGet(req, resp); + } +} +package com.controller.schoadmin; +// 声明该类所在的包名为com.controller.schoadmin + +import com.dao.DeptAdminDao; +// 导入数据访问对象类，用于执行数据库操作 + +import javax.servlet.ServletException; +// 导入Servlet异常处理类 + +import javax.servlet.annotation.WebServlet; +// 导入Servlet注解，用于映射Servlet到URL路径 + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet基类，所有Servlet都继承自此类 + +import javax.servlet.http.HttpServletRequest; +// 导入HTTP请求对象类，用于获取客户端请求信息 + +import javax.servlet.http.HttpServletResponse; +// 导入HTTP响应对象类，用于向客户端发送响应 + +import java.io.IOException; +// 导入输入输出异常类 + +/** + * 学校管理员修改学生打卡记录的Servlet + * 处理修改学生打卡信息的请求，更新数据库中的记录 + */ +@WebServlet("/SchoAlterStuPunchServlet") +public class SchoAlterStuPunchServlet extends HttpServlet { + + /** + * 处理GET请求的方法 + * @param req HTTP请求对象 + * @param resp HTTP响应对象 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @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"); + + // 获取表单请求的参数 + String sno = req.getParameter("sno"); // 学生学号 + String sispunch = req.getParameter("sispunch"); // 是否打卡 + String spunchdate = req.getParameter("spunchdate"); // 打卡日期 + String spunchtime = req.getParameter("spunchtime"); // 打卡时间 + String sishot = req.getParameter("sishot"); // 是否发烧 + String siscough = req.getParameter("siscough"); // 是否咳嗽 + String sisseem = req.getParameter("sisseem"); // 是否有其他症状 + String sisdiagnose = req.getParameter("sisdiagnose"); // 是否就医诊断 + String sstatus = req.getParameter("sstatus"); // 健康状态 + + // 构造更新学生打卡记录的SQL语句 + String sql = "update stupunchin set sispunch = ?, spunchtime = ?, sishot = ?, siscough = ?, sisseem = ?, sisdiagnose = ?, sstatus = ? where sno = ? and spunchdate = ?"; + // 准备SQL语句的参数 + Object[] objects = {sispunch, spunchtime, sishot, siscough, sisseem, sisdiagnose, sstatus, sno, spunchdate}; + + // 调用DAO方法执行更新操作，获取受影响的行数 + int num = DeptAdminDao.executeUpdate(sql, objects); + + // 打印更新结果 + System.out.println(num); + + // 转发请求到分页查询Servlet，显示第一页学生打卡记录 + req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp); + } + + /** + * 处理POST请求的方法，直接调用doGet方法处理 + * @param req HTTP请求对象 + * @param resp HTTP响应对象 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + doGet(req, resp); + } +} +package com.controller.schoadmin; +// 声明该类所在的包名为com.controller.schoadmin + +import com.dao.DeptAdminDao; +// 导入数据访问对象类，用于执行数据库的更新操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet运行时可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，可获取请求参数等信息 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，可设置响应内容、状态码等 + +import java.io.IOException; +// 导入用于处理I/O异常的类，如在读写数据时可能发生的异常 + +@WebServlet("/SchoAlterStuServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoAlterStuServlet" +public class SchoAlterStuServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，并且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取表单请求的参数 + String sno = req.getParameter("sno");// 学生学号 + String sname = req.getParameter("sname");// 学生姓名 + String ssex = req.getParameter("ssex");// 学生性别 + String sage = req.getParameter("sage");// 学生年龄 + String sclass = req.getParameter("sclass");// 学生班级 + String specialty = req.getParameter("specialty");// 学生专业 + String sdept = req.getParameter("sdept");// 学生所在系部 + String sphone = req.getParameter("sphone");// 学生联系电话 + String spsw = req.getParameter("spsw");// 学生密码 + + // 数据类型转换，将年龄从字符串转换为整数 + int sage1 = Integer.parseInt(sage); + + // 构造更新学生信息的SQL语句 + String sql = "update student set sname = ?, ssex = ?, sage = ?, sclass = ?, specialty = ?, sdept = ?, sphone = ?, spsw = ? where sno = ?"; + // 创建包含SQL语句参数的对象数组 + Object[] objects = {sname, ssex, sage1, sclass, specialty, sdept, sphone, spsw, sno}; + + // 调用DeptAdminDao的executeUpdate方法执行SQL更新操作，获取受影响的行数 + int num = DeptAdminDao.executeUpdate(sql, objects); + + // 打印受影响的行数，用于调试 + System.out.println(num); + + // 转发请求到分页查询学生信息的Servlet，传递参数设置当前页为1，每页显示7条记录，其他查询条件为空 + req.getRequestDispatcher("/SchoQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=").forward(req, resp); + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + doGet(req, resp); + } +} +package com.controller.schoadmin; +// 声明该类所在的包名为com.controller.schoadmin + +import com.dao.DeptAdminDao; +// 导入自定义的数据访问对象类，用于数据库操作 + +import javax.servlet.ServletException; +// 导入Servlet异常处理类 + +import javax.servlet.annotation.WebServlet; +// 导入Servlet注解，用于映射Servlet到URL路径 + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet基类，所有Servlet都继承自此类 + +import javax.servlet.http.HttpServletRequest; +// 导入HTTP请求对象类，用于获取客户端请求信息 + +import javax.servlet.http.HttpServletResponse; +// 导入HTTP响应对象类，用于向客户端发送响应 + +import java.io.IOException; +// 导入输入输出异常类 + +/** + * 学校管理员修改教师打卡记录的Servlet + * 处理修改教师打卡信息的请求，更新数据库中的相关记录 + */ +@WebServlet("/SchoAlterTeaPunchServlet") +public class SchoAlterTeaPunchServlet extends HttpServlet { + + /** + * 处理GET请求的方法 + * @param req HTTP请求对象 + * @param resp HTTP响应对象 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @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"); + + // 获取表单请求的参数 + String tno = req.getParameter("tno"); // 教师工号 + String tispunch = req.getParameter("tispunch"); // 是否打卡 + String tpunchdate = req.getParameter("tpunchdate"); // 打卡日期 + String tpunchtime = req.getParameter("tpunchtime"); // 打卡时间 + String tishot = req.getParameter("tishot"); // 是否发烧 + String tiscough = req.getParameter("tiscough"); // 是否咳嗽 + String tisseem = req.getParameter("tisseem"); // 是否有其他症状 + String tisdiagnose = req.getParameter("tisdiagnose"); // 是否就医诊断 + String tstatus = req.getParameter("tstatus"); // 健康状态 + + // 构造用于更新教师打卡记录的SQL语句 + String sql = "update teapunchin set tispunch = ?, tpunchtime = ?, tishot = ?, tiscough = ?, tisseem = ?, tisdiagnose = ?, tstatus = ? where tno = ? and tpunchdate = ?"; + // 准备SQL语句的参数 + Object[] objects = {tispunch, tpunchtime, tishot, tiscough, tisseem, tisdiagnose, tstatus, tno, tpunchdate}; + + // 调用DeptAdminDao的方法执行SQL更新操作，获取受影响的行数 + int num = DeptAdminDao.executeUpdate(sql, objects); + + // 打印更新操作影响的行数，用于调试 + System.out.println(num); + + // 转发请求到分页查询教师打卡记录的Servlet，设置当前页为1，每页显示7条记录，其他查询参数为空 + req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp); + } + + /** + * 处理POST请求的方法，直接调用doGet方法处理 + * @param req HTTP请求对象 + * @param resp HTTP响应对象 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + doGet(req, resp); + } +} +package com.controller.schoadmin; +// 声明该类所属的包名为com.controller.schoadmin + +import com.dao.DeptAdminDao; +// 导入数据访问对象类，用于执行数据库操作，如查询、更新等 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet在运行过程中可能抛出的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +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("/SchoAlterTeaServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoAlterTeaServlet" +public class SchoAlterTeaServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，以正确处理请求参数中的中文字符 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，以正确处理响应内容中的中文字符 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML，字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取表单请求的参数 + String tno = req.getParameter("tno"); // 获取教师编号 + String tname = req.getParameter("tname"); // 获取教师姓名 + String tsex = req.getParameter("tsex"); // 获取教师性别 + String tage = req.getParameter("tage"); // 获取教师年龄 + String tdept = req.getParameter("tdept"); // 获取教师所在系部 + String tphone = req.getParameter("tphone"); // 获取教师联系电话 + String tpsw = req.getParameter("tpsw"); // 获取教师密码 + + // 数据类型转换，将年龄从字符串转换为整数 + int tage1 = Integer.parseInt(tage); + + // 构造SQL更新语句，用于更新教师信息表中的记录 + String sql = "update teacher set tname = ?, tsex = ?, tage = ?, tdept = ?, tphone = ?, tpsw = ? where tno = ?"; + // 创建一个包含SQL语句参数的对象数组 + Object[] objects = {tname, tsex, tage1, tdept, tphone, tpsw, tno}; + + // 调用DeptAdminDao的executeUpdate方法执行SQL更新操作，并获取受影响的行数 + int num = DeptAdminDao.executeUpdate(sql, objects); + + // 打印受影响的行数，用于调试和查看更新操作是否成功 + System.out.println(num); + + // 转发请求到分页查询教师信息的Servlet，设置当前页为1，每页显示7条记录，其他查询条件为空 + req.getRequestDispatcher("/SchoQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=").forward(req, resp); + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + doGet(req, resp); + } +}package com.controller.schoadmin; +// 声明该类所在的包名为com.controller.schoadmin + +import com.dao.DeptAdminDao; +// 导入数据访问对象类，用于执行数据库操作 + +import javax.servlet.ServletException; +// 导入Servlet异常处理类 + +import javax.servlet.annotation.WebServlet; +// 导入Servlet注解，用于映射Servlet到URL路径 + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet基类，所有Servlet都继承自此类 + +import javax.servlet.http.HttpServletRequest; +// 导入HTTP请求对象类，用于获取客户端请求信息 + +import javax.servlet.http.HttpServletResponse; +// 导入HTTP响应对象类，用于向客户端发送响应 + +import java.io.IOException; +// 导入输入输出异常类 + +/** + * 学校管理员删除学生打卡记录的Servlet + * 处理删除学生打卡信息的请求，检查记录是否存在并执行删除操作 + */ +@WebServlet("/SchoDeleteStuPunchServlet") +public class SchoDeleteStuPunchServlet extends HttpServlet { + + /** + * 处理GET请求的方法 + * @param req HTTP请求对象 + * @param resp HTTP响应对象 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @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"); + + // 获取请求参数，参数格式为"学号,打卡日期" + String snodate = req.getParameter("snodate"); + + // 打印获取的参数，用于调试 + System.out.println(snodate); + + // 分离学号和打卡日期两个参数，使用逗号作为分隔符 + String[] params = snodate.split(","); + String sno = params[0]; // 学生学号 + String spunchdate = params[1]; // 打卡日期 + + // 打印分离后的参数，用于调试 + System.out.println(sno); + System.out.println(spunchdate); + + // 注释掉的代码，尝试将字符串转换为日期类型（实际未使用） +// Date spunchdate1 = new Date(spunchdate); +// SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); +// Date spunchdate1 = ft.format(spunchdate); + + // 声明SQL语句变量 + String sql = null; + // 准备SQL语句的参数 + Object[] objects = {sno, spunchdate}; + + // 查询是否存在该学生在指定日期的打卡记录 + sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?"; + // 调用DAO方法执行查询，获取记录数量 + int count = DeptAdminDao.findTotalCount(sql, objects); + + // 如果记录存在 + if (count > 0) { + // 构造删除学生打卡记录的SQL语句 + sql = "delete from stupunchin where sno = ? and spunchdate = ?"; + // 调用DAO方法执行删除操作，获取受影响的行数 + int num1 = DeptAdminDao.executeUpdate(sql, objects); + // 打印删除结果 + System.out.println(num1); + + // 转发请求到分页查询Servlet，显示第一页学生打卡记录 + req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp); + } else { + // 如果记录不存在，转发到提示页面 + req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); + } + } + + /** + * 处理POST请求的方法，直接调用doGet方法处理 + * @param req HTTP请求对象 + * @param resp HTTP响应对象 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + doGet(req, resp); + } +} +package com.controller.schoadmin; +// 声明该类所在的包名为com.controller.schoadmin + +import com.dao.DeptAdminDao; +// 导入自定义的数据访问对象类，用于数据库的查询和更新操作 + +import javax.servlet.ServletException; +// 导入Servlet异常处理类，用于处理Servlet运行过程中可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入Servlet注解，用于将Servlet映射到指定的URL路径 + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet基类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，可获取请求参数、会话等信息 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，可设置响应内容、状态码等 + +import javax.servlet.http.HttpSession; +// 导入用于处理HTTP会话的类，可获取和设置会话属性 + +import java.io.IOException; +// 导入用于处理I/O异常的类，如文件读写、网络传输等操作中可能出现的异常 + +@WebServlet("/SchoDeleteStuPunchServlet1") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoDeleteStuPunchServlet1" +public class SchoDeleteStuPunchServlet1 extends HttpServlet { + + /** + * 处理GET请求的方法 + * @param req HTTP请求对象 + * @param resp HTTP响应对象 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @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"); + + // 获取表单请求的参数 + String sno = req.getParameter("sno"); // 学生学号 + String spunchdate = req.getParameter("spunchdate"); // 打卡日期 + + // 打印获取的学号参数，用于调试 + System.out.println(sno); + // 打印获取的打卡日期参数，用于调试 + System.out.println(spunchdate); + + // 获取登录时的session会话对象 + HttpSession session = req.getSession(); +// String userName = (String) session.getAttribute("userName"); +// String sno = (String) session.getAttribute("sno"); + String belong = (String) session.getAttribute("belong"); // 获取会话中存储的"belong"属性值 + + // 注释掉的代码，尝试将字符串转换为日期类型（实际未使用） +// Date spunchdate1 = new Date(spunchdate); +// SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); +// Date spunchdate1 = ft.format(spunchdate); + + // 声明SQL语句变量 + String sql = null; + // 创建包含SQL语句参数的对象数组 + Object[] objects = {sno, spunchdate}; + + // 查询是否存在符合条件的学生打卡记录（通过关联student和stupunchin表） + sql = "select count(*) as num from student s,stupunchin sp where s.sno = sp.sno and s.sno = ? and sp.spunchdate = ?"; + // 调用DeptAdminDao的方法执行SQL查询，获取符合条件的记录数量 + int count = DeptAdminDao.findTotalCount(sql, objects); + + // 如果存在符合条件的记录 + if (count > 0) { + // 构造删除学生打卡记录的SQL语句 + sql = "delete from stupunchin where sno = ? and spunchdate = ?"; + // 调用DeptAdminDao的方法执行SQL删除操作，获取受影响的行数 + int num1 = DeptAdminDao.executeUpdate(sql, objects); + // 打印受影响的行数，用于调试 + System.out.println(num1); + + // 转发请求到分页查询学生打卡记录的Servlet，传递参数设置当前页为1，每页显示7条记录，其他查询条件为空 + req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp); + } else { + // 如果不存在符合条件的记录，转发请求到提示已存在数据的页面 + req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); + } + } + + /** + * 处理POST请求的方法，直接调用doGet方法处理 + * @param req HTTP请求对象 + * @param resp HTTP响应对象 + * @throws ServletException 如果处理请求时发生Servlet异常 + * @throws IOException 如果发生输入输出异常 + */ + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + doGet(req, resp); + } +} +package com.controller.stu; +// 声明该Servlet所在的包名为com.controller.stu + +import com.dao.StuDao; +// 导入学生数据访问对象类StuDao，用于执行数据库查询操作 + +import com.entity.Student; +// 导入学生实体类，用于封装学生相关信息 + +import com.utils.JDBCUtils; +// 导入JDBC工具类，用于数据库连接的管理和资源关闭等操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet运行时可能出现的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，通过它可以获取请求参数、请求头信息等 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，通过它可以设置响应内容、响应头信息等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关信息 + +import java.io.IOException; +// 导入用于处理I/O异常的类，如在读取或写入数据时可能发生的异常 + +import java.sql.ResultSet; +// 导入用于处理数据库查询结果的类，用于获取查询到的数据 + +import java.util.ArrayList; +// 导入ArrayList类，用于存储多个学生对象 + +@WebServlet("/StuQueryInfoServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuQueryInfoServlet" +public class StuQueryInfoServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，并且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取当前请求的会话对象 + HttpSession session = req.getSession(); + // 从会话中获取名为"userName"的属性值，并将其转换为String类型 + String userName = (String) session.getAttribute("userName"); + // 从会话中获取名为"sno"的属性值，并将其转换为String类型，该值表示学生编号 + String sno = (String) session.getAttribute("sno"); + + // 将userName打印到控制台，用于调试 + System.out.println(userName); + // 将sno打印到控制台，用于调试 + System.out.println(sno); + // 打印一个字符串到控制台，可能是用于调试的无意义字符串 + System.out.println("hdghghjg"); + + // 构造SQL查询语句，用于从student表中查询指定学生编号（sno）的学生信息 + String sql = "select * from student where sno = ?"; + // 创建包含SQL语句参数的对象数组，参数为学生编号 + Object[] objects = {sno}; + + // 调用StuDao的qureyInfo方法执行SQL查询，并获取结果集 + ResultSet resultSet = StuDao.qureyInfo(sql, objects); + // 创建一个ArrayList对象，用于存储查询到的学生对象 + ArrayList stuArrayList = new ArrayList(); + + try { + // 遍历结果集，将每一行数据封装到Student对象中，并添加到ArrayList中 + while (resultSet.next()){ + // 创建一个新的Student对象 + Student student = new Student(); + // 设置学生编号 + student.setSno(resultSet.getString("sno")); + // 设置学生姓名 + student.setSname(resultSet.getString("sname")); + // 设置学生性别 + student.setSsex(resultSet.getString("ssex")); + // 设置学生年龄，将数据库中的整数类型值转换为int类型 + student.setSage(resultSet.getInt("sage")); + // 设置学生班级 + student.setSclass(resultSet.getString("sclass")); + // 设置学生专业 + student.setSpecialty(resultSet.getString("specialty")); + // 设置学生所在系部 + student.setSdept(resultSet.getString("sdept")); + // 设置学生电话号码 + student.setSphone(resultSet.getString("sphone")); + // 设置学生密码 + student.setSpsw(resultSet.getString("spsw")); + // 将封装好的学生对象添加到ArrayList中 + stuArrayList.add(student); + } + } catch (Exception e) { + // 捕获异常并打印异常堆栈信息，用于调试和错误排查 + e.printStackTrace(); + } finally { + // 无论是否发生异常，都调用JDBCUtils的close方法关闭结果集，释放资源 + JDBCUtils.close(resultSet); + } + + // 将存储学生对象的ArrayList打印到控制台，用于调试 + System.out.println(stuArrayList); + + // 将存储学生对象的ArrayList设置为请求属性，以便在后续页面中使用 + req.setAttribute("stuArrayList", stuArrayList); + + // 转发请求到指定的页面（/view/stu/stuinfo.jsp），并传递请求和响应对象 + req.getRequestDispatcher("/view/stu/stuinfo.jsp").forward(req, resp); + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + doGet(req, resp); + } +} +package com.controller.stu; +// 声明该Servlet所在的包名为com.controller.stu + +import com.dao.StuDao; +// 导入学生数据访问对象类，用于执行数据库的查询、统计等操作 + +import com.entity.PageBean; +// 导入分页数据封装的实体类，用于存储分页相关信息 + +import com.entity.StuPunch; +// 导入学生打卡信息的实体类，用于封装学生打卡的具体数据 + +import com.utils.JDBCUtils; +// 导入JDBC工具类，用于数据库连接的获取、关闭以及结果集的处理等操作 + +import javax.servlet.ServletException; +// 导入Servlet异常类，用于处理Servlet在运行过程中可能抛出的异常 + +import javax.servlet.annotation.WebServlet; +// 导入注解，用于将Servlet映射到特定的URL + +import javax.servlet.http.HttpServlet; +// 导入HttpServlet类，所有基于HTTP协议的Servlet都继承自该类 + +import javax.servlet.http.HttpServletRequest; +// 导入用于处理HTTP请求的类，可获取请求参数、会话等信息 + +import javax.servlet.http.HttpServletResponse; +// 导入用于处理HTTP响应的类，可设置响应内容、状态码等 + +import javax.servlet.http.HttpSession; +// 导入HttpSession类，用于管理用户会话，存储用户相关信息 + +import java.io.IOException; +// 导入用于处理I/O异常的类，如在读写数据时可能发生的异常 + +import java.sql.ResultSet; +// 导入用于处理数据库查询结果的类 + +import java.util.ArrayList; +// 导入ArrayList类，用于存储多个对象，这里用于存储学生打卡信息对象 + +@WebServlet("/StuQueryPunchByPageServlet") +// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuQueryPunchByPageServlet" +public class StuQueryPunchByPageServlet extends HttpServlet { + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doGet方法，用于处理HTTP GET请求 + + // 设置请求的字符编码为UTF-8，防止请求参数中的中文乱码 + req.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为UTF-8，防止响应内容中的中文乱码 + resp.setCharacterEncoding("utf-8"); + // 设置响应的内容类型为HTML格式，并且字符编码为UTF-8，告知客户端如何解析响应内容 + resp.setContentType("text/html;charset=utf-8"); + + // 获取查找的参数，这里是打卡日期 + String spunchdate = req.getParameter("spunchdate"); + + // 如果获取的打卡日期为空，则设置为空字符串 + if (spunchdate == null){ + spunchdate = ""; + } + + // 对打卡日期进行模糊查询的格式处理，在前后添加通配符% + String spunchdate1 = "%" + spunchdate + "%"; + // 打印处理后的打卡日期，用于调试 + System.out.println(spunchdate1); + + // 将原始的打卡日期设置为请求属性，以便在后续页面中使用 + req.setAttribute("spunchdate", spunchdate); + + // 获取登录时的session会话对象 + HttpSession session = req.getSession(); + // 从会话中获取名为"userName"的属性值，并将其转换为String类型 + String userName = (String) session.getAttribute("userName"); + // 从会话中获取名为"sno"的属性值，并将其转换为String类型，该值表示学生编号 + String sno = (String) session.getAttribute("sno"); + + // 初始化SQL语句变量 + String sql = null; + + // 打印userName，用于调试 + System.out.println(userName); + // 打印sno，用于调试 + System.out.println(sno); + // 打印一个字符串，可能是用于调试的无意义字符串 + System.out.println("hdghghjg"); + + // 从请求对象中获取当前页码 + String currentPage = req.getParameter("currentPage"); + // 从请求对象中获取每页显示的行数 + String rows = req.getParameter("rows"); + + // 如果当前页码为空或为空字符串，则设置当前页码为1 + if (currentPage == null || "".equals(currentPage)){ + currentPage = "1"; + } + + // 如果每页显示的行数为空或为空字符串，则设置每页显示的行数为7 + if (rows == null || "".equals(rows)){ + rows = "7"; + } + + // 将当前页码转换为整数类型 + int currentPage1 = Integer.parseInt(currentPage); + // 将每页显示的行数转换为整数类型 + int rows1 = Integer.parseInt(rows); + + // 如果当前页数小于1，则设置当前页数为1 + if (currentPage1 <= 0){ + currentPage1 = 1; + } + + // 创建PageBean对象，泛型为StuPunch，用于存储分页信息和学生打卡信息列表 + PageBean pageBean = new PageBean(); + + // 设置当前页码到PageBean对象中 + pageBean.setCurrentPage(currentPage1); + + // 设置每页的记录数到PageBean对象中 + pageBean.setRows(rows1); + + // 构造SQL语句，用于统计符合条件（打卡日期模糊匹配且学生编号匹配）的记录总数 + sql = " select count(*) as num from student s,stupunchin sp where s.sno = sp.sno and sp.spunchdate like ? and s.sno = ?"; + // 创建包含SQL语句参数的对象数组，参数为处理后的打卡日期和学生编号 + Object[] objects = {spunchdate1, sno}; + + // 调用StuDao的findTotalCount方法执行SQL查询，获取总记录数 + int totalCount = StuDao.findTotalCount(sql, objects); + // 打印总记录数，用于调试 + System.out.println(totalCount); + // 设置总记录数到PageBean对象中 + pageBean.setTotalCount(totalCount); + + 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); + } + + // 计算开始的记录位置，为（当前页码 - 1）乘以每页记录数 + int start = (currentPage1 - 1) * rows1; + // 构造SQL语句，用于查询符合条件的学生打卡信息，进行分页查询 + sql = "select s.sname,sp.* from student s,stupunchin sp where s.sno = sp.sno and sp.spunchdate like ? and sp.sno = ? limit ?, ?"; + // 创建包含SQL语句参数的对象数组，参数为处理后的打卡日期、学生编号、开始记录位置、每页记录数 + Object[] objects1 = {spunchdate1, sno, start, rows1}; + + // 调用StuDao的QureyInfoByPage方法执行SQL查询，获取查询结果集 + ResultSet resultSet = StuDao.QureyInfoByPage(sql, objects1); + // 创建ArrayList对象，用于存储查询到的学生打卡信息对象 + ArrayList stuPunchArrayList = new ArrayList(); + + try { + // 遍历结果集，将每一行数据封装到StuPunch对象中，并添加到ArrayList中 + while (resultSet.next()){ + StuPunch stuPunch = new StuPunch(); + stuPunch.setSname(resultSet.getString("sname")); + stuPunch.setSispunch(resultSet.getString("sispunch")); + stuPunch.setSpunchdate(resultSet.getDate("spunchdate")); + stuPunch.setSpunchtime(resultSet.getString("spunchtime")); + stuPunch.setSishot(resultSet.getString("sishot")); + stuPunch.setSiscough(resultSet.getString("siscough")); + stuPunch.setSisseem(resultSet.getString("sisseem")); + stuPunch.setSisdiagnose(resultSet.getString("sisdiagnose")); + stuPunch.setSstatus(resultSet.getString("sstatus")); + stuPunchArrayList.add(stuPunch); + } + } catch (Exception e) { + // 捕获异常并打印异常堆栈信息，用于调试和错误排查 + e.printStackTrace(); + } finally { + // 无论是否发生异常，都调用JDBCUtils的close方法关闭结果集，释放资源 + JDBCUtils.close(resultSet); + } + // 将存储学生打卡信息对象的ArrayList设置到PageBean对象中 + pageBean.setArrayList(stuPunchArrayList); + + // 打印存储学生打卡信息对象的ArrayList，用于调试 + System.out.println(stuPunchArrayList); + // 打印PageBean对象，用于调试 + System.out.println(pageBean); + + // 将PageBean对象设置为请求属性，以便在后续页面中使用 + req.setAttribute("pageBean", pageBean); + + // 转发请求到指定的页面（/view/stu/stupunchinfo.jsp），并传递请求和响应对象 + req.getRequestDispatcher("/view/stu/stupunchinfo.jsp").forward(req, resp); + }else { + // 如果总记录数为0，说明没有符合条件的数据，转发请求到无数据提示页面（/view/alluse/nodata.jsp） + req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp); + } + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求 + // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑 + doGet(req, resp); + } +} +package com.utils; +// 声明该类所在的包名为com.utils + +import org.jfree.chart.JFreeChart; +// 导入JFreeChart类，它是JFreeChart库中表示图表的核心类 + +import org.jfree.chart.block.BlockBorder; +// 导入BlockBorder类，用于设置图表中块（如图例）的边框 + +import org.jfree.data.category.DefaultCategoryDataset; +// 导入DefaultCategoryDataset类，用于处理柱状图、折线图等类别数据的数据集 + +import org.jfree.data.general.DefaultPieDataset; +// 导入DefaultPieDataset类，用于处理饼图的数据集 + +import org.jfree.ui.RectangleEdge; +// 导入RectangleEdge类，用于指定图表中元素（如图例）的位置，如在矩形的哪条边上 + +import java.awt.*; +// 导入java.awt包，包含用于处理图形和用户界面的类 + +import java.util.Vector; +// 导入Vector类，它是一个动态数组，用于存储数据系列等 + +/** + * 生成JFreeChart图表的工厂类
+ * 目的：根据MVC的设计思想，数据与展现分离。调用者只需传入数据，即可生成图表。 + * + * @author liuyimin + * + */ +public class ChartFactory { + /** + * 生成柱状图 + * + * @param title + * 柱状图的标题 + * @param categoryAxisLabel + * x轴标题 + * @param valueAxisLabel + * y轴标题 + * @param series + * 数据 + * @param categories + * 类别 + * @return + */ + public static JFreeChart createBarChart(String title, + String categoryAxisLabel, String valueAxisLabel, + Vector series, String[] categories) { + // 1：创建数据集合 + // 调用ChartUtils的createDefaultCategoryDataset方法，根据传入的数据系列和类别创建一个默认的类别数据集 + DefaultCategoryDataset dataset = ChartUtils + .createDefaultCategoryDataset(series, categories); + // 使用JFreeChart的工厂方法创建一个柱状图，传入标题、x轴标题、y轴标题和数据集 + JFreeChart chart = org.jfree.chart.ChartFactory.createBarChart(title, + categoryAxisLabel, valueAxisLabel, dataset); + // 3:设置抗锯齿，防止字体显示不清楚 + // 调用ChartUtils的setAntiAlias方法，为图表设置抗锯齿，使字体等显示更清晰 + ChartUtils.setAntiAlias(chart);// 抗锯齿 + // 4:对柱子进行渲染 + // 调用ChartUtils的setBarRenderer方法，对柱状图的柱子进行渲染，第二个参数false可能表示某种渲染相关的设置 + ChartUtils.setBarRenderer(chart.getCategoryPlot(), false);// + // 5:对其他部分进行渲染 + // 调用ChartUtils的setXAixs方法，对图表的X坐标轴进行渲染 + ChartUtils.setXAixs(chart.getCategoryPlot());// X坐标轴渲染 + // 调用ChartUtils的setYAixs方法，对图表的Y坐标轴进行渲染 + ChartUtils.setYAixs(chart.getCategoryPlot());// Y坐标轴渲染 + // 设置标注无边框 + // 创建一个白色边框的BlockBorder对象，并将其设置为图表图例的边框 + chart.getLegend().setFrame(new BlockBorder(Color.WHITE)); + // 返回创建并渲染好的柱状图 + return chart; + } + + /** + * 生成饼图 + * + * @param title + * 饼图的标题 + * @param categories + * 类别 + * @param datas + * 数据 + * @return + */ + public static JFreeChart createPieChart(String title, String[] categories, + Object[] datas) { + // 1：创建数据集合 + // 调用ChartUtils的createDefaultPieDataset方法，根据传入的类别和数据创建一个默认的饼图数据集 + DefaultPieDataset dataset = ChartUtils.createDefaultPieDataset( + categories, datas); + // 使用JFreeChart的工厂方法创建一个饼图，传入标题和数据集 + JFreeChart chart = org.jfree.chart.ChartFactory.createPieChart(title, + dataset); + // 3:设置抗锯齿，防止字体显示不清楚 + // 调用ChartUtils的setAntiAlias方法，为图表设置抗锯齿，使字体等显示更清晰 + ChartUtils.setAntiAlias(chart);// 抗锯齿 + // 4:对柱子进行渲染[创建不同图形] + // 调用ChartUtils的setPieRender方法，对饼图的绘图区域进行渲染 + ChartUtils.setPieRender(chart.getPlot()); + /** + * 可以注释测试 + */ + // plot.setSimpleLabels(true);//简单标签,不绘制线条 + // plot.setLabelGenerator(null);//不显示数字 + // 设置标注无边框 + // 创建一个白色边框的BlockBorder对象，并将其设置为图表图例的边框 + chart.getLegend().setFrame(new BlockBorder(Color.WHITE)); + // 将图表的图例位置设置为右侧 + chart.getLegend().setPosition(RectangleEdge.RIGHT); + // 返回创建并渲染好的饼图 + return chart; + } + + /** + * 生成折线图 + * + * @param title + * 折线图的标题 + * @param categoryAxisLabel + * x轴标题 + * @param valueAxisLabel + * y轴标题 + * @param series + * 数据 + * @param categories + * 类别 + * @return + */ + public static JFreeChart createLineChart(String title, + String categoryAxisLabel, String valueAxisLabel, + Vector series, String[] categories) { + // 1：创建数据集合 + // 调用ChartUtils的createDefaultCategoryDataset方法，根据传入的数据系列和类别创建一个默认的类别数据集 + DefaultCategoryDataset dataset = ChartUtils + .createDefaultCategoryDataset(series, categories); + // 使用JFreeChart的工厂方法创建一个折线图，传入标题、x轴标题、y轴标题和数据集 + JFreeChart chart = org.jfree.chart.ChartFactory.createLineChart(title, + categoryAxisLabel, valueAxisLabel, dataset); + // 3:设置抗锯齿，防止字体显示不清楚 + // 调用ChartUtils的setAntiAlias方法，为图表设置抗锯齿，使字体等显示更清晰 + ChartUtils.setAntiAlias(chart);// 抗锯齿 + // 4:对柱子进行渲染[[采用不同渲染]] + // 调用ChartUtils的setLineRender方法，对折线图的绘图区域进行渲染，后面的参数false和true可能表示某种渲染相关的设置 + ChartUtils.setLineRender(chart.getCategoryPlot(), false, true);// + // 5:对其他部分进行渲染 + // 调用ChartUtils的setXAixs方法，对图表的X坐标轴进行渲染 + ChartUtils.setXAixs(chart.getCategoryPlot());// X坐标轴渲染 + // 调用ChartUtils的setYAixs方法，对图表的Y坐标轴进行渲染 + ChartUtils.setYAixs(chart.getCategoryPlot());// Y坐标轴渲染 + // 设置标注无边框 + // 创建一个白色边框的BlockBorder对象，并将其设置为图表图例的边框 + chart.getLegend().setFrame(new BlockBorder(Color.WHITE)); + // 返回创建并渲染好的折线图 + return chart; + } + + /** + * 生成StackedBarChart + * + * @param title + * StackedBarChart的标题 + * @param domainAxisLabel + * @param rangeAxisLabel + * @param series + * 数据 + * @param categories + * 类别 + * @return + */ + public static JFreeChart createStackedBarChart(String title, + String domainAxisLabel, String rangeAxisLabel, + Vector series, String[] categories) { + // 1：创建数据集合 + // 调用ChartUtils的createDefaultCategoryDataset方法，根据传入的数据系列和类别创建一个默认的类别数据集 + DefaultCategoryDataset dataset = ChartUtils + .createDefaultCategoryDataset(series, categories); + // 使用JFreeChart的工厂方法创建一个堆积柱状图，传入标题、x轴标题、y轴标题和数据集 + JFreeChart chart = org.jfree.chart.ChartFactory.createStackedBarChart( + title, domainAxisLabel, rangeAxisLabel, dataset); + // 3:设置抗锯齿，防止字体显示不清楚 + // 调用ChartUtils的setAntiAlias方法，为图表设置抗锯齿，使字体等显示更清晰 + ChartUtils.setAntiAlias(chart);// 抗锯齿 + // 4:对柱子进行渲染[创建不同图形] + // 调用ChartUtils的setStackBarRender方法，对堆积柱状图的绘图区域进行渲染 + ChartUtils.setStackBarRender(chart.getCategoryPlot()); + // 5:对其他部分进行渲染 + // 调用ChartUtils的setXAixs方法，对图表的X坐标轴进行渲染 + ChartUtils.setXAixs(chart.getCategoryPlot());// X坐标轴渲染 + // 调用ChartUtils的setYAixs方法，对图表的Y坐标轴进行渲染 + ChartUtils.setYAixs(chart.getCategoryPlot());// Y坐标轴渲染 + // 设置标注无边框 + // 创建一个白色边框的BlockBorder对象，并将其设置为图表图例的边框 + chart.getLegend().setFrame(new BlockBorder(Color.WHITE)); + // 返回创建并渲染好的堆积柱状图 + return chart; + } +} +package com.utils; +// 声明该类所在的包名为com.utils + +import org.jfree.chart.ChartFactory; +// 导入JFreeChart库中的图表工厂类，用于创建各种类型的图表 + +import org.jfree.chart.JFreeChart; +// 导入JFreeChart类，它是JFreeChart库中表示图表的核心类 + +import org.jfree.chart.StandardChartTheme; +// 导入标准图表主题类，用于设置图表的外观主题 + +import org.jfree.chart.axis.DateAxis; +// 导入日期轴类，用于在图表中显示日期 + +import org.jfree.chart.axis.DateTickUnit; +// 导入日期刻度单位类，用于定义日期轴上的刻度间隔 + +import org.jfree.chart.axis.DateTickUnitType; +// 导入日期刻度单位类型枚举类，用于指定日期刻度的类型（如年、月、日等） + +import org.jfree.chart.axis.ValueAxis; +// 导入值轴类，用于表示图表中的数值轴 + +import org.jfree.chart.block.BlockBorder; +// 导入块边框类，用于设置图表中块（如图例）的边框 + +import org.jfree.chart.labels.*; +// 导入JFreeChart中用于标签相关的类的包，用于设置图表的标签显示等 + +import org.jfree.chart.plot.*; +// 导入JFreeChart中用于绘图区域相关的类的包，用于处理图表的绘图区域设置 + +import org.jfree.chart.renderer.category.BarRenderer; +// 导入柱状图渲染器类，用于渲染柱状图 + +import org.jfree.chart.renderer.category.LineAndShapeRenderer; +// 导入折线图和形状渲染器类，用于渲染折线图和数据点的形状 + +import org.jfree.chart.renderer.category.StackedBarRenderer; +// 导入堆积柱状图渲染器类，用于渲染堆积柱状图 + +import org.jfree.chart.renderer.category.StandardBarPainter; +// 导入标准柱状图绘制器类，用于绘制柱状图的外观 + +import org.jfree.chart.renderer.xy.StandardXYBarPainter; +// 导入标准XY柱状图绘制器类，用于绘制XY图表中的柱状图外观 + +import org.jfree.chart.renderer.xy.XYBarRenderer; +// 导入XY柱状图渲染器类，用于渲染XY图表中的柱状图 + +import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer; +// 导入XY折线图和形状渲染器类，用于渲染XY图表中的折线图和数据点的形状 + +import org.jfree.data.category.DefaultCategoryDataset; +// 导入默认的类别数据集类，用于处理柱状图、折线图等类别数据的数据集 + +import org.jfree.data.general.DefaultPieDataset; +// 导入默认的饼图数据集类，用于处理饼图的数据集 + +import org.jfree.data.time.Day; +// 导入表示一天的时间类，用于时间序列数据 + +import org.jfree.data.time.TimeSeries; +// 导入时间序列类，用于处理时间序列数据 + +import org.jfree.ui.RectangleInsets; +// 导入矩形边距类，用于设置图表中元素的边距 + +import org.jfree.ui.TextAnchor; +// 导入文本锚点类，用于指定文本的位置 + +import java.awt.*; +// 导入java.awt包，包含用于处理图形和用户界面的类 + +import java.text.DecimalFormat; +// 导入十进制格式化类，用于格式化数字 + +import java.text.NumberFormat; +// 导入数字格式化类，用于格式化数字 + +import java.text.ParseException; +// 导入解析异常类，用于处理日期等解析时可能抛出的异常 + +import java.text.SimpleDateFormat; +// 导入简单日期格式化类，用于格式化日期 + +import java.util.Date; +// 导入日期类，用于表示日期和时间 + +import java.util.Vector; +// 导入Vector类，它是一个动态数组，用于存储数据系列等 + +/** + * Jfreechart工具类 + *

+ * 解决中文乱码问题
+ * 用来创建类别图表数据集、创建饼图数据集、时间序列图数据集
+ * 用来对柱状图、折线图、饼图、堆积柱状图、时间序列图的样式进行渲染
+ * 设置X-Y坐标轴样式 + *

+ * + * + * @author chenchangwen + * @since:2014-2-18 + * + */ +public class ChartUtils { + // 定义一个静态字符串，用于表示无数据时的提示信息 + private static String NO_DATA_MSG = "暂无数据"; + // 定义一个静态字体对象，设置字体为宋体，样式为普通，大小为12 + private static Font FONT = new Font("宋体", Font.PLAIN, 12); + // 定义一个静态颜色数组，包含多种颜色，用于图表的颜色设置 + public static Color[] CHART_COLORS = { new Color(31, 129, 188), + new Color(92, 92, 97), new Color(144, 237, 125), + new Color(255, 188, 117), new Color(153, 158, 255), + new Color(255, 117, 153), new Color(253, 236, 109), + new Color(128, 133, 232), new Color(158, 90, 102), + new Color(255, 204, 102) }; + + // 静态代码块，在类加载时执行，用于设置图表主题 + static { + setChartTheme(); + } + + // 空的构造函数 + public ChartUtils() { + } + + /** + * 中文主题样式 解决乱码 + */ + public static void setChartTheme() { + // 创建一个标准图表主题对象，命名为"CN" + StandardChartTheme chartTheme = new StandardChartTheme("CN"); + // 设置标题字体为之前定义的字体 + chartTheme.setExtraLargeFont(FONT); + // 设置图例的字体为之前定义的字体 + chartTheme.setRegularFont(FONT); + // 设置轴向的字体为之前定义的字体 + chartTheme.setLargeFont(FONT); + chartTheme.setSmallFont(FONT); + // 设置标题的颜色为灰色 + chartTheme.setTitlePaint(new Color(51, 51, 51)); + // 设置副标题的颜色为深灰色 + chartTheme.setSubtitlePaint(new Color(85, 85, 85)); + + // 设置图例的背景颜色为白色 + chartTheme.setLegendBackgroundPaint(Color.WHITE); + // 设置图例项的颜色为黑色 + chartTheme.setLegendItemPaint(Color.BLACK); + // 设置图表的背景颜色为白色 + chartTheme.setChartBackgroundPaint(Color.WHITE); + // 绘制颜色绘制颜色.轮廓供应商 + // paintSequence,outlinePaintSequence,strokeSequence,outlineStrokeSequence,shapeSequence + + // 定义轮廓颜色数组，这里只有白色 + Paint[] OUTLINE_PAINT_SEQUENCE = new Paint[] { Color.WHITE }; + // 创建一个默认的绘图供应商，设置颜色、轮廓颜色等 + DefaultDrawingSupplier drawingSupplier = new DefaultDrawingSupplier( + CHART_COLORS, CHART_COLORS, OUTLINE_PAINT_SEQUENCE, + DefaultDrawingSupplier.DEFAULT_STROKE_SEQUENCE, + DefaultDrawingSupplier.DEFAULT_OUTLINE_STROKE_SEQUENCE, + DefaultDrawingSupplier.DEFAULT_SHAPE_SEQUENCE); + // 设置图表主题的绘图供应商 + chartTheme.setDrawingSupplier(drawingSupplier); + + // 设置绘图区域的背景颜色为白色 + chartTheme.setPlotBackgroundPaint(Color.WHITE); + // 设置绘图区域外边框的颜色为白色 + chartTheme.setPlotOutlinePaint(Color.WHITE); + // 设置链接标签的颜色 + chartTheme.setLabelLinkPaint(new Color(8, 55, 114)); + // 设置标签链接的样式为三次曲线 + chartTheme.setLabelLinkStyle(PieLabelLinkStyle.CUBIC_CURVE); + + // 设置图表的边距 + chartTheme.setAxisOffset(new RectangleInsets(5, 12, 5, 12)); + // 设置X坐标轴垂直网格的颜色 + chartTheme.setDomainGridlinePaint(new Color(192, 208, 224)); + // 设置Y坐标轴水平网格的颜色 + chartTheme.setRangeGridlinePaint(new Color(192, 192, 192)); + + // 设置基线的颜色为白色 + chartTheme.setBaselinePaint(Color.WHITE); + // 设置十字准线的颜色为蓝色 + chartTheme.setCrosshairPaint(Color.BLUE); + // 设置坐标轴标题文字的颜色 + chartTheme.setAxisLabelPaint(new Color(51, 51, 51)); + // 设置刻度数字的颜色 + chartTheme.setTickLabelPaint(new Color(67, 67, 72)); + // 设置柱状图的渲染器为标准柱状图绘制器 + chartTheme.setBarPainter(new StandardBarPainter()); + // 设置XYBar的渲染器为标准XYBar绘制器 + chartTheme.setXYBarPainter(new StandardXYBarPainter()); + + // 设置项目标签的颜色为黑色 + chartTheme.setItemLabelPaint(Color.black); + // 设置温度计的颜色为白色 + chartTheme.setThermometerPaint(Color.white); + + // 设置JFreeChart的全局图表主题 + ChartFactory.setChartTheme(chartTheme); + } + + /** + * 必须设置文本抗锯齿 + */ + public static void setAntiAlias(JFreeChart chart) { + // 设置图表的文本抗锯齿为关闭状态 + chart.setTextAntiAlias(false); + } + + /** + * 设置图例无边框，默认黑色边框 + */ + public static void setLegendEmptyBorder(JFreeChart chart) { + // 创建一个白色边框的BlockBorder对象，并将其设置为图表图例的边框 + chart.getLegend().setFrame(new BlockBorder(Color.WHITE)); + } + + /** + * 创建类别数据集合 + */ + public static DefaultCategoryDataset createDefaultCategoryDataset( + Vector series, String[] categories) { + // 创建一个默认的类别数据集对象 + DefaultCategoryDataset dataset = new DefaultCategoryDataset(); + + // 遍历数据系列 + for (Serie serie : series) { + // 获取数据系列的名称 + String name = serie.getName(); + // 获取数据系列的数据 + Vector data = serie.getData(); + // 如果数据和类别都不为空，且数据数量和类别数量相等 + if (data != null && categories != null + && data.size() == categories.length) { + // 遍历数据 + for (int index = 0; index < data.size(); index++) { + // 获取数据值，并处理为字符串 + String value = data.get(index) == null? "" : data.get( + index).toString(); + // 如果数据是百分比形式 + if (isPercent(value)) { + // 去掉百分比符号 + value = value.substring(0, value.length() - 1); + } + // 如果数据是数字 + if (isNumber(value)) { + // 将数据值添加到数据集中 + dataset.setValue(Double.parseDouble(value), name, + categories[index]); + } + } + } + } + // 返回创建好的数据集 + return dataset; + } + + /** + * 创建饼图数据集合 + */ + public static DefaultPieDataset createDefaultPieDataset( + String[] categories, Object[] datas) { + // 创建一个默认的饼图数据集对象 + DefaultPieDataset dataset = new DefaultPieDataset(); + // 遍历类别 + for (int i = 0; i < categories.length && categories != null; i++) { + // 获取数据值，并处理为字符串 + String value = datas[i].toString(); + // 如果数据是百分比形式 + if (isPercent(value)) { + // 去掉百分比符号 + value = value.substring(0, value.length() - 1); + } + // 如果数据是数字 + if (isNumber(value)) { + // 将数据值添加到数据集中 + dataset.setValue(categories[i], Double.valueOf(value)); + } + } + // 返回创建好的数据集 + return dataset; + } + + /** + * 创建时间序列数据 + * + * @param category + * 类别 + * @param dateValues + * 日期-值 数组 + * @param xAxisTitle + * X坐标轴标题 + * @return + */ + public static TimeSeries createTimeseries(String category, + Vector dateValues) { + // 创建一个时间序列对象，传入类别名称 + TimeSeries timeseries = new TimeSeries(category); + + // 如果日期值数组不为空 + if (dateValues != null) { + // 创建一个简单日期格式化对象，格式为"yyyy-MM-dd" + SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); + // 遍历日期值数组 + for (Object[] objects : dateValues) { + // 初始化日期对象 + Date date = null; + try { + // 解析日期字符串为日期对象 + date = dateFormat.parse(objects[0].toString()); + } catch (ParseException e) { + } + // 获取数据值，并处理为字符串 + String sValue = objects[1].toString(); + // 初始化数据值为0 + double dValue = 0; + // 如果日期不为空且数据是数字 + if (date != null && isNumber(sValue)) { + // 将数据值转换为double类型 + dValue = Double.parseDouble(sValue); + // 将数据添加到时间序列中 + timeseries.add(new Day(date), dValue); + } + } + } + + // 返回创建好的时间序列对象 + return timeseries; + } + + /** + * 设置 折线图样式 + * + * @param plot + * @param isShowDataLabels + * 是否显示数据标签 默认不显示节点形状 + */ + public static void setLineRender(CategoryPlot plot, boolean isShowDataLabels) { + // 调用另一个设置折线图样式的方法，不显示节点形状 + setLineRender(plot, isShowDataLabels, false); + } + + /** + * 设置折线图样式 + * + * @param plot + * @param isShowDataLabels + * 是否显示数据标签 + */ + @SuppressWarnings("deprecation") + public static void setLineRender(CategoryPlot plot, + boolean isShowDataLabels, boolean isShapesVisible) { + // 设置无数据时的提示信息 + plot.setNoDataMessage(NO_DATA_MSG); + // 设置绘图区域的边距 + plot.setInsets(new RectangleInsets(10, 10, 0, 10), false); + // 获取折线图的渲染器 + LineAndShapeRenderer renderer = (LineAndShapeRenderer) plot + .getRenderer(); + + // 设置线条的粗细为1.5F + renderer.setStroke(new BasicStroke(1.5F)); + // 如果要显示数据标签 + if (isShowDataLabels) { + // 设置基本项目标签可见 + renderer.setBaseItemLabelsVisible(true); + // 设置基本项目标签生成器 + renderer.setBaseItemLabelGenerator(new StandardCategoryItemLabelGenerator( + StandardCategoryItemLabelGenerator.DEFAULT_LABEL_FORMAT_STRING, + NumberFormat.getInstance())); + // 设置基本正项目标签的位置 + renderer.setBasePositiveItemLabelPosition(new ItemLabelPosition( + ItemLabelAnchor.OUTSIDE1, TextAnchor.BOTTOM_CENTER)); + } + // 设置数据点绘制形状的可见性 + renderer.setBaseShapesVisible(isShapesVisible); + // 设置X坐标轴样式 + setXAixs(plot); + // 设置Y坐标轴样式 + setYAixs(plot); + } + + /** + * 设置时间序列图样式 + * + * @param plot + * @param isShowData + * 是否显示数据 + * @param isShapesVisible + * 是否显示数据节点形状 + */ + public static void setTimeSeriesRender(Plot plot, boolean isShowData, + boolean isShapesVisible) { + + // 将绘图区域转换为XYPlot类型 + XYPlot xyplot = (XYPlot) plot; + // 设置无数据时的提示信息 + xyplot.setNoDataMessage(NO_DATA_MSG); + // 设置绘图区域的边距 + xyplot.setInsets(new RectangleInsets(10, 10, 5, 10)); + + // 获取XY折线图和形状渲染器 + XYLineAndShapeRenderer xyRenderer = (XYLineAndShapeRenderer) xyplot + .getRenderer(); + + // 设置基本项目标签生成器 + xyRenderer + .setBaseItemLabelGenerator(new StandardXYItemLabelGenerator()); + // 设置基本数据点形状不可见 + xyRenderer.setBaseShapesVisible(false); + // 如果要显示数据 + if (isShowData) { + // 设置基本项目标签可见 + xyRenderer.setBaseItemLabelsVisible(true); + // 设置基本项目标签生成器 + xyRenderer + .setBaseItemLabelGenerator(new StandardXYItemLabelGenerator()); + // 设置基本正项目标签的位置 + xyRenderer.setBasePositiveItemLabelPosition(new ItemLabelPosition( + ItemLabelAnchor.OUTSIDE1, TextAnchor.BOTTOM_CENTER)); + } + // 设置数据点绘制形状的可见性 + xyRenderer.setBaseShapesVisible(isShapesVisible); + + // +package com.utils; +// 声明该类所在的包名为com.utils + +import java.sql.Connection; +// 导入java.sql包中的Connection类，用于表示与数据库的连接 + +import java.sql.DriverManager; +// 导入java.sql包中的DriverManager类，用于管理数据库驱动程序 + +import java.sql.ResultSet; +// 导入java.sql包中的ResultSet类，用于处理数据库查询结果集 + +import java.sql.Statement; +// 导入java.sql包中的Statement类，用于执行SQL语句 + +/** + * JDBC工具类，提供数据库连接和资源关闭的静态方法 + */ +public class JDBCUtils { + + // 数据库驱动类名，这里使用的是MySQL的旧驱动 + private static String driver = "com.mysql.jdbc.Driver"; + // 数据库连接URL，指定了连接的主机、端口和数据库名 + private static String url = "jdbc:mysql://localhost:3306/lsyqfksys"; + // 数据库用户名 + private static String user = "root"; + // 数据库密码 + private static String psw = "105293"; + + /** + * 获取数据库连接 + * @return 数据库连接对象，如果连接失败则返回null + */ + public static Connection getConnection(){ + // 声明数据库连接对象 + Connection connection = null; + try { + // 加载数据库驱动类 + Class.forName(driver); + // 通过DriverManager获取数据库连接 + connection = DriverManager.getConnection(url, user, psw); + // 打印连接成功信息 + System.out.println("连接成功"); + } + catch (Exception e){ + // 打印异常堆栈信息 + e.printStackTrace(); + } + + // 返回数据库连接对象 + return connection; + } + + /** + * 释放查询操作相关的资源（ResultSet, Statement, Connection） + * @param resultSet 结果集对象 + * @param statement SQL语句执行对象 + * @param connection 数据库连接对象 + */ + public static void close(ResultSet resultSet, Statement statement, Connection connection) { + // 关闭结果集 + if (resultSet != null) { + try { + resultSet.close(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + // 关闭Statement对象 + if (statement != null) { + try { + statement.close(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + // 关闭数据库连接 + if (connection != null) { + try { + connection.close(); + } catch (Exception e) { + e.printStackTrace(); + } + } + } + + /** + * 释放更新操作相关的资源（Statement, Connection） + * @param statement SQL语句执行对象 + * @param connection 数据库连接对象 + */ + public static void close(Statement statement, Connection connection) { + // 关闭Statement对象 + if (statement != null) { + try { + statement.close(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + // 关闭数据库连接 + if (connection != null) { + try { + connection.close(); + } catch (Exception e) { + e.printStackTrace(); + } + } + } + + /** + * 关闭结果集资源 + * @param resultSet 结果集对象 + */ + public static void close(ResultSet resultSet) { + // 关闭结果集 + if (resultSet != null) { + try { + resultSet.close(); + } catch (Exception e) { + e.printStackTrace(); + } + } + } +}package com.utils; +// 声明该类所在的包名为com.utils + +import java.io.Serializable; +// 导入java.io包中的Serializable接口，用于实现对象的序列化 + +import java.util.Vector; +// 导入java.util包中的Vector类，用于存储数据集合 + +/** + * 系列:名字和数据集合 构成一条曲线
可以将serie看作一根线或者一根柱子： + * + *

+ * 参照JS图表来描述数据：
series: [{ name: 'Tokyo', data: [7.0, 6.9, 9.5, 14.5] + * },
{ name: 'New York', data: [-0.2, 0.8, 5.7, 11.3} ]
+ *

+ * + * @author ccw + * @date 2014-6-4 + */ +public class Serie implements Serializable { + + // 序列化版本号，用于确保序列化和反序列化的兼容性 + private static final long serialVersionUID = 1L; + // 系列的名称，例如在图表中表示一条线或一个柱子的名称 + private String name; + // 系列的数据集合，使用Vector存储各种类型的数据值 + private Vector data; + + // 无参构造函数 + public Serie() { + + } + + /** + * + * @param name + * 名称（线条名称） + * @param data + * 数据（线条上的所有数据值） + */ + public Serie(String name, Vector data) { + // 初始化系列名称 + this.name = name; + // 初始化系列数据 + this.data = data; + } + + /** + * + * @param name + * 名称（线条名称） + * @param array + * 数据（线条上的所有数据值） + */ + public Serie(String name, Object[] array) { + // 初始化系列名称 + this.name = name; + // 如果传入的数据数组不为空 + if (array != null) { + // 创建一个初始容量为数组长度的Vector + data = new Vector(array.length); + // 遍历数组，将元素添加到Vector中 + for (int i = 0; i < array.length; i++) { + data.add(array[i]); + } + } + } + + // 获取系列名称的方法 + public String getName() { + return name; + } + + // 设置系列名称的方法 + public void setName(String name) { + this.name = name; + } + + // 获取系列数据集合的方法 + public Vector getData() { + return data; + } + + // 设置系列数据集合的方法 + public void setData(Vector data) { + this.data = data; + } +} \ No newline at end of file diff --git a/src/com/controller/alluse/LoginServlet.java b/src/com/controller/alluse/LoginServlet.java index 07709fc..024cc1a 100644 --- a/src/com/controller/alluse/LoginServlet.java +++ b/src/com/controller/alluse/LoginServlet.java @@ -13,7 +13,7 @@ import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; import java.io.IOException; import java.sql.ResultSet; - +//vgfghv @WebServlet("/LoginServlet") public class LoginServlet extends HttpServlet { diff --git a/src/com/controller/deptadmin/DeptAddStuPunchServlet.java b/src/com/controller/deptadmin/DeptAddStuPunchServlet.java index 1e2fa5c..b98f918 100644 --- a/src/com/controller/deptadmin/DeptAddStuPunchServlet.java +++ b/src/com/controller/deptadmin/DeptAddStuPunchServlet.java @@ -1,5 +1,5 @@ package com.controller.deptadmin; - +// import com.dao.DeptAdminDao; import javax.servlet.ServletException; @@ -7,54 +7,59 @@ import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; -import java.io.IOException; +import java.io.IOException; //导入IO异常和日期类 import java.util.Date; @WebServlet("/DeptAddStuPunchServlet") -public class DeptAddStuPunchServlet extends HttpServlet { +public class DeptAddStuPunchServlet extends HttpServlet { //定义一个继承自HttpServlet的Servlet类。 @Override - protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //重写doGet方法，处理HTTP GET请求。 + //统一请求和响应的字符编码为UTF-8，防止中文乱码，并设置响应内容类型为HTML。 req.setCharacterEncoding("utf-8"); resp.setCharacterEncoding("utf-8"); resp.setContentType("text/html;charset=utf-8"); //获取表单请求的参数 - String sno = req.getParameter("sno"); - String sispunch = req.getParameter("sispunch"); - String spunchdate = req.getParameter("spunchdate"); - String spunchtime = req.getParameter("spunchtime"); - String sishot = req.getParameter("sishot"); - String siscough = req.getParameter("siscough"); - String sisseem = req.getParameter("sisseem"); - String sisdiagnose = req.getParameter("sisdiagnose"); - String sstatus = req.getParameter("sstatus"); + String sno = req.getParameter("sno"); //从 HTTP 请求中获取参数名为 "sno" 的值，并将其赋值给 sno 变量 + String sispunch = req.getParameter("sispunch");//从 HTTP 请求中获取参数名为 "sispunch" 的值，并将其赋值给 sispunch 变量 + String spunchdate = req.getParameter("spunchdate");//从 HTTP 请求中获取参数名为 "spunchdate" 的值，并将其赋值给 spunchdate 变量 + String spunchtime = req.getParameter("spunchtime");//从 HTTP 请求中获取参数名为 "spunchtime" 的值，并将其赋值给 spunchtime 变量 + String sishot = req.getParameter("sishot");//从 HTTP 请求中获取参数名为 "sishot" 的值，并将其赋值给 sishot 变量 + String siscough = req.getParameter("siscough");//从 HTTP 请求中获取参数名为 "siscough" 的值，并将其赋值给 siscough 变量 + String sisseem = req.getParameter("sisseem");//从 HTTP 请求中获取参数名为 "sisseem" 的值，并将其赋值给 sisseem 变量 + String sisdiagnose = req.getParameter("sisdiagnose");//从 HTTP 请求中获取参数名为 "sisdiagnose" 的值，并将其赋值给 sisdiagnose 变量 + String sstatus = req.getParameter("sstatus");//从 HTTP 请求中获取参数名为 "sstatus" 的值，并将其赋值给 sstatus 变量 String sql = null; - + //声明SQL语句变量，并输出调试信息 System.out.println("shgshgh"); //查询是否存在此人 - sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?"; - Object[] objects = {sno, spunchdate}; - int count = DeptAdminDao.findTotalCount(sql, objects); + sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?";//检查stupunchin表中是否存在相同学号和日期的记录 + Object[] objects = {sno, spunchdate}; //使用Object数组传递参数，防止SQL注入。 + int count = DeptAdminDao.findTotalCount(sql, objects);//调用DAO方法findTotalCount返回匹配记录数。 - if (count == 0){//无则操作 + if (count == 0){//条件判断：如果不存在重复记录（count为0），执行插入操作。 sql = "insert into stupunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)"; Object[] objects1 = {sno, sispunch, spunchdate, spunchtime, sishot, siscough, sisseem, sisdiagnose, sstatus}; + //SQL插入语句：向stupunchin表插入包含9个字段的新记录 + //参数绑定：将表单参数按顺序填入占位符 - int num = DeptAdminDao.executeUpdate(sql, objects1); + int num = DeptAdminDao.executeUpdate(sql, objects1);//执行更新：调用DAO方法executeUpdate执行插入，返回受影响的行数。 System.out.println(num); req.getRequestDispatcher("/DeptQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&spunchdate=").forward(req, resp); }else { - req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp); - } + req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp);//转发请求：插入成功后，转发到分页查询Servlet，显示第一页数据（参数currentPage=1，每页7行）。 + }//处理重复数据：如果记录已存在，转发到提示页面existdataofadd.jsp } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { - doGet(req, resp); + doGet(req, resp);//处理POST请求：重写doPost方法，直接调用doGet，统一处理GET和POST请求 + + } } diff --git a/src/com/controller/deptadmin/DeptAddStuServlet.java b/src/com/controller/deptadmin/DeptAddStuServlet.java index d12721c..89a8d3f 100644 --- a/src/com/controller/deptadmin/DeptAddStuServlet.java +++ b/src/com/controller/deptadmin/DeptAddStuServlet.java @@ -9,56 +9,56 @@ import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; -@WebServlet("/DeptAddStuServlet") -public class DeptAddStuServlet extends HttpServlet { +@WebServlet("/DeptAddStuServlet")//@WebServlet("/DeptAddStuServlet")：这是一个 Servlet 注解，表示这个类处理访问路径为 /DeptAddStuServlet 的 HTTP 请求。 +public class DeptAddStuServlet extends HttpServlet { //DeptAddStuServlet 继承了 HttpServlet 类，是一个处理 HTTP 请求的 Servlet 类。 - @Override + @Override//doGet 方法是处理 GET 请求的入口。由于 Web 表单通常使用 GET 或 POST 提交数据，因此我们在这里处理来自客户端的 GET 请求。 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { - req.setCharacterEncoding("utf-8"); + req.setCharacterEncoding("utf-8"); //设置请求和响应的字符编码为 UTF-8，确保处理过程中不会出现中文乱码问题。 resp.setCharacterEncoding("utf-8"); - resp.setContentType("text/html;charset=utf-8"); + resp.setContentType("text/html;charset=utf-8");//设置响应内容类型为 HTML，并指定字符编码为 UTF-8。 - //获取表单请求的参数 - String sno = req.getParameter("sno"); - String sname = req.getParameter("sname"); - String ssex = req.getParameter("ssex"); - String sage = req.getParameter("sage"); - String specialty = req.getParameter("specialty"); - String sclass = req.getParameter("sclass"); - String sdept = req.getParameter("sdept"); - String sphone = req.getParameter("sphone"); - String spsw = req.getParameter("spsw"); + //req.getParameter("parameterName") 用来获取来自表单提交的参数值。每个 getParameter 调用会返回一个字符串，表示对应表单字段的值。 + String sno = req.getParameter("sno");//学号 + String sname = req.getParameter("sname");//姓名 + String ssex = req.getParameter("ssex");//性别 + String sage = req.getParameter("sage");//年龄 + String specialty = req.getParameter("specialty");//学生专业 + String sclass = req.getParameter("sclass");//学生班级 + String sdept = req.getParameter("sdept");//学生所属部门 + String sphone = req.getParameter("sphone");//学生电话 + String spsw = req.getParameter("spsw");//学生密码 //数据类型转换 int sage1 = Integer.parseInt(sage); - + //将学生的年龄 sage（字符串类型）转换为 int 类型。这里使用 Integer.parseInt() 方法进行类型转换。 String sql = null; System.out.println("shgshgh"); //查询是否存在此人 sql = "select count(*) as num from student where sno = ?"; - Object[] objects = {sno}; - int count = DeptAdminDao.findTotalCount(sql, objects); + Object[] objects = {sno};//构造一个 SQL 查询语句，检查数据库中是否已经存在学号为 sno 的学生。 + int count = DeptAdminDao.findTotalCount(sql, objects);//DeptAdminDao.findTotalCount() 是自定义的数据库操作方法，用于执行 SQL 查询并返回符合条件的记录数。返回值 count 为查询结果，表示匹配的学生数量。 - if (count == 0){//无则操作 + if (count == 0){//如果查询结果 count 为 0，说明没有找到该学号的学生，学生信息可以插入数据库。 sql = "insert into student values(?, ?, ?, ?, ?, ?, ?, ?, ?)"; Object[] objects1 = {sno, sname, ssex, sage1, sclass, specialty, sdept, sphone, spsw}; - + //构造一个 SQL 插入语句，将学生信息插入 student 表 int num = DeptAdminDao.executeUpdate(sql, objects1); - - System.out.println(num); + //DeptAdminDao.executeUpdate() 方法执行插入操作，并返回受影响的行数（即成功插入的记录数）。此时 num 表示执行的结果。 + System.out.println(num);//在控制台打印 num，用来调试输出插入操作是否成功。通常在开发阶段，使用 System.out.println() 打印日志。 // req.getRequestDispatcher("/DeptQueryStuByPageServlet?currentPage=1&rows=8").forward(req, resp); - - req.getRequestDispatcher("/DeptQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&specialty=").forward(req, resp); + //如果学生成功插入数据库，跳转到另一个 Servlet（DeptQueryStuByPageServlet），用于分页查询学生信息。 + req.getRequestDispatcher("/DeptQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&specialty=").forward(req, resp);//使用 req.getRequestDispatcher().forward() 方法将请求转发到指定的 Servlet，并携带一些查询参数（例如：当前页码 currentPage=1 和每页显示的学生数 rows=7）。 }else { - req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp); + req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp);//如果数据库中已经存在该学号的学生，转发到一个名为 existdataofadd.jsp 的页面，通常用于提示用户该学生已经存在，无法再次添加。 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { - doGet(req, resp); + doGet(req, resp);//doPost 方法处理 POST 请求。这里通过调用 doGet(req, resp)，使得 POST 请求和 GET 请求的处理逻辑一致，避免重复代码。 } } diff --git a/src/com/controller/deptadmin/DeptAddTeaPunchServlet.java b/src/com/controller/deptadmin/DeptAddTeaPunchServlet.java index 6b7c465..6c1e056 100644 --- a/src/com/controller/deptadmin/DeptAddTeaPunchServlet.java +++ b/src/com/controller/deptadmin/DeptAddTeaPunchServlet.java @@ -1,6 +1,6 @@ -package com.controller.deptadmin; +package com.controller.deptadmin;//包声明：类位于com.controller.deptadmin包中，归类管理部门相关的控制器。 -import com.dao.DeptAdminDao; +import com.dao.DeptAdminDao;//包声明：类位于com.controller.deptadmin包中，归类管理部门相关的控制器。 import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; @@ -9,51 +9,52 @@ import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; -@WebServlet("/DeptAddTeaPunchServlet") +@WebServlet("/DeptAddTeaPunchServlet")//Servlet注解与类定义：映射URL路径/DeptAddTeaPunchServlet，继承HttpServlet处理HTTP请求。 public class DeptAddTeaPunchServlet extends HttpServlet { @Override - protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {//处理GET请求：重写doGet方法，处理HTTP GET请求。 req.setCharacterEncoding("utf-8"); resp.setCharacterEncoding("utf-8"); - resp.setContentType("text/html;charset=utf-8"); - - //获取表单请求的参数 - String tno = req.getParameter("tno"); - String tispunch = req.getParameter("tispunch"); - String tpunchdate = req.getParameter("tpunchdate"); - String tpunchtime = req.getParameter("tpunchtime"); - String tishot = req.getParameter("tishot"); - String tiscough = req.getParameter("tiscough"); - String tisseem = req.getParameter("tisseem"); - String tisdiagnose = req.getParameter("tisdiagnose"); - String tstatus = req.getParameter("tstatus"); + resp.setContentType("text/html;charset=utf-8");//统一请求和响应的字符编码为UTF-8，防止中文乱码，并设置响应内容类型为HTML + + //使用 req.getParameter("parameterName") 获取前端表单提交的每个参数的值 + String tno = req.getParameter("tno");//教师编号 + String tispunch = req.getParameter("tispunch");//是否打卡 + String tpunchdate = req.getParameter("tpunchdate");//打卡日期 + String tpunchtime = req.getParameter("tpunchtime");//打卡时间 + String tishot = req.getParameter("tishot");//是否发热 + String tiscough = req.getParameter("tiscough");//是否咳嗽 + String tisseem = req.getParameter("tisseem");//是否见过人 + String tisdiagnose = req.getParameter("tisdiagnose");//是否诊断 + String tstatus = req.getParameter("tstatus");//状态 String sql = null; - System.out.println("shgshgh"); + System.out.println("shgshgh");//这行代码是一个调试语句，打印 "shgshgh" 到控制台。它通常用于开发调试阶段，帮助开发者跟踪程序执行情况。可以在正式环境中移除。 //查询是否已打卡 sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?"; - Object[] objects = {tno, tpunchdate}; - int count = DeptAdminDao.findTotalCount(sql, objects); + Object[] objects = {tno, tpunchdate};//构造一个 SQL 查询语句，检查数据库中是否已经存在该教师（tno）在指定日期（tpunchdate）的打卡记录。 + int count = DeptAdminDao.findTotalCount(sql, objects);//使用 DeptAdminDao.findTotalCount() 方法执行查询，并返回匹配的记录数。count 表示查询结果，判断是否已有相同的打卡记录。 - if (count == 0){//无则操作 + if (count == 0){//如果查询结果 count 为 0，表示该教师在该日期没有打卡记录，因此可以插入新的打卡记录。 sql = "insert into teapunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)"; Object[] objects1 = {tno, tispunch, tpunchdate, tpunchtime, tishot, tiscough, tisseem, tisdiagnose, tstatus}; + //构造 SQL 插入语句，将教师的打卡信息插入到 teapunchin 表中。插入的字段包括：教师编号、是否打卡、打卡日期、打卡时间、是否发热、是否咳嗽、是否见过人、是否诊断、状态。 - int num = DeptAdminDao.executeUpdate(sql, objects1); + int num = DeptAdminDao.executeUpdate(sql, objects1);//使用 DeptAdminDao.executeUpdate() 方法执行插入操作，返回受影响的行数（即成功插入的记录数）。将插入操作的结果存储在 num 变量中。 - System.out.println(num); + System.out.println(num);//在控制台打印 num，用来调试输出插入操作是否成功，通常用于开发过程中查看插入操作是否成功。 req.getRequestDispatcher("/DeptQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tpunchdate=").forward(req, resp); - }else { + }else {//如果插入操作成功，使用 req.getRequestDispatcher().forward() 方法将请求转发到另一个 Servlet (DeptQueryTeaPunchByPageServlet)，用于分页查询教师的打卡记录。 req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp); - } + } //如果查询到已经存在相同的打卡记录（count > 0），则转发请求到 existdataofadd.jsp 页面，提示用户该打卡记录已存在，无法再次添加。 } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { - doGet(req, resp); + doGet(req, resp);//doPost 方法处理 HTTP POST 请求。此处，doPost 方法调用 doGet 方法，使得 POST 请求和 GET 请求的处理逻辑一致，避免重复代码。 } } diff --git a/src/com/controller/deptadmin/DeptAddTeaServlet.java b/src/com/controller/deptadmin/DeptAddTeaServlet.java index 32781c9..c1dd2c8 100644 --- a/src/com/controller/deptadmin/DeptAddTeaServlet.java +++ b/src/com/controller/deptadmin/DeptAddTeaServlet.java @@ -1,59 +1,49 @@ -package com.controller.deptadmin; +package com.controller.deptadmin;//这一行定义了当前类所在的包，com.controller.deptadmin 表示该类是 deptadmin 包下的控制器类。 -import com.dao.DeptAdminDao; +import com.dao.DeptAdminDao;//导入 DeptAdminDao 类，这个类通常包含与数据库交互的代码。它用于执行数据库操作，比如执行 update 或 select 操作。 -import javax.servlet.ServletException; -import javax.servlet.annotation.WebServlet; +import javax.servlet.ServletException;//ServletException 用于处理 Servlet 的异常。 +import javax.servlet.annotation.WebServlet;//WebServlet 是用于定义 Servlet 的注解。 +//HttpServlet, HttpServletRequest, HttpServletResponse 是 HTTP 协议相关的 Servlet 类，处理请求和响应。 import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; -import java.io.IOException; +import java.io.IOException;//IOException 用于处理输入输出相关的异常。 -@WebServlet("/DeptAddTeaServlet") -public class DeptAddTeaServlet extends HttpServlet { +@WebServlet("/DeptAlterStuPunchServlet")//这是一个注解，用来声明这个 Servlet 的 URL 映射路径。用户访问 /DeptAlterStuPunchServlet 路径时会触发该 Servlet。 +public class DeptAlterStuPunchServlet extends HttpServlet {//这是定义一个 DeptAlterStuPunchServlet 类，它继承自 HttpServlet，说明这是一个处理 HTTP 请求的 Servlet 类。 + //这是重写的 doGet 方法，处理 HTTP GET 请求。每当用户通过 GET 请求访问该 Servlet 时，doGet 方法会被调用。 @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"); + resp.setContentType("text/html;charset=utf-8");//设置请求和响应的字符编码为 UTF-8，确保请求和响应的文本内容能够正确处理中文字符。 - //获取表单请求的参数 - String tno = req.getParameter("tno"); - String tname = req.getParameter("tname"); - String tsex = req.getParameter("tsex"); - String tage = req.getParameter("tage"); - String tdept = req.getParameter("tdept"); - String tphone = req.getParameter("tphone"); - String tpsw = req.getParameter("tpsw"); + //从 HTTP 请求中获取用户提交的表单参数 + String sno = req.getParameter("sno");//学生学号 + String sispunch = req.getParameter("sispunch");//是否打卡 + String spunchdate = req.getParameter("spunchdate");//打卡日期 + String spunchtime = req.getParameter("spunchtime");//打卡时间 + String sishot = req.getParameter("sishot");//是否发热 + String siscough = req.getParameter("siscough");//是否咳嗽 + String sisseem = req.getParameter("sisseem");//是否有乏力 + String sisdiagnose = req.getParameter("sisdiagnose");//诊断结果 + String sstatus = req.getParameter("sstatus");//打卡状态 - //数据类型转换 - int tage1 = Integer.parseInt(tage); + //构造了一个 SQL 更新语句，用于修改 stupunchin 表中的数据。更新的字段包括打卡状态、时间、症状信息等，查询条件是 sno（学生学号）和 spunchdate（打卡日期）。 + String sql = "update stupunchin set sispunch = ?, spunchtime = ?, sishot = ?, siscough = ?, sisseem = ?, sisdiagnose = ?, sstatus = ? where sno = ? and spunchdate = ?"; + Object[] objects = {sispunch, spunchtime, sishot, siscough, sisseem, sisdiagnose, sstatus, sno, spunchdate};//创建一个对象数组 objects，该数组包含了 SQL 更新语句中使用的参数。数组中的值会被传递给数据库操作。 - String sql = null; + int num = DeptAdminDao.executeUpdate(sql, objects);//调用 DeptAdminDao 类中的 executeUpdate 方法执行 SQL 更新操作。该方法会返回受影响的行数（更新成功的记录数），并将其赋值给 num 变量。 - System.out.println("shgshgh"); + System.out.println(num);//打印更新操作影响的记录行数，通常用于调试和查看更新操作的效果。 - //查询是否存在此人 - sql = "select count(*) as num from teacher where tno = ?"; - Object[] objects = {tno}; - int count = DeptAdminDao.findTotalCount(sql, objects); + req.getRequestDispatcher("/DeptQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&spunchdate=").forward(req, resp);//调用 RequestDispatcher 的 forward 方法，将请求转发到另一个 Servlet，通常是用于显示更新后的学生打卡信息。这会将用户重定向到 DeptQueryStuPunchByPageServlet，并附带了一些查询参数。 - if (count == 0){//无则操作 - sql = "insert into teacher values(?, ?, ?, ?, ?, ?, ?)"; - Object[] objects1 = {tno, tname, tsex, tage1, tdept, tphone, tpsw}; - - int num = DeptAdminDao.executeUpdate(sql, objects1); - - System.out.println(num); - - /* req.getRequestDispatcher("/DeptQueryTeaByPageServlet?currentPage=1&rows=8").forward(req, resp);*/ - req.getRequestDispatcher("/DeptQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tsex=").forward(req, resp); - }else { - req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp); - } } + //这是重写的 doPost 方法。由于 doPost 方法的实现只是调用了 doGet，这意味着该 Servlet 支持同时处理 GET 和 POST 请求。实际上，POST 请求会被当作 GET 请求处理。 @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); diff --git a/src/com/controller/deptadmin/DeptAlterStuPunchServlet.java b/src/com/controller/deptadmin/DeptAlterStuPunchServlet.java index b968fbd..5206e28 100644 --- a/src/com/controller/deptadmin/DeptAlterStuPunchServlet.java +++ b/src/com/controller/deptadmin/DeptAlterStuPunchServlet.java @@ -1,7 +1,8 @@ -package com.controller.deptadmin; +package com.controller.deptadmin;//这行代码定义了当前类的包路径，表示该类属于 com.controller.deptadmin 包。 -import com.dao.DeptAdminDao; +import com.dao.DeptAdminDao;//导入 DeptAdminDao 类，这是一个自定义的 DAO (数据访问对象) 类，提供了与数据库交互的操作方法。 +//这些是从 javax.servlet 和 java.io 包导入的类。它们提供了与 Servlet 相关的功能，比如请求处理 (HttpServletRequest 和 HttpServletResponse) 和异常处理 (ServletException, IOException)。 import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; @@ -9,37 +10,52 @@ import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; -@WebServlet("/DeptAlterStuPunchServlet") -public class DeptAlterStuPunchServlet extends HttpServlet { +@WebServlet("/DeptAddTeaServlet")//@WebServlet("/DeptAddTeaServlet") 是一个注解，表示这个 Servlet 会处理 URL 为 /DeptAddTeaServlet 的请求。 +public class DeptAddTeaServlet extends HttpServlet {//DeptAddTeaServlet 类继承自 HttpServlet，意味着它是一个处理 HTTP 请求的 Servlet。 + //重写 doGet 方法，处理 HTTP GET 请求。当浏览器发起 GET 请求时，Servlet 会调用该方法。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { - req.setCharacterEncoding("utf-8"); + req.setCharacterEncoding("utf-8");//设置请求和响应的字符编码为 UTF-8，确保中文字符能够正确处理，避免乱码。 resp.setCharacterEncoding("utf-8"); - resp.setContentType("text/html;charset=utf-8"); + resp.setContentType("text/html;charset=utf-8");//设置响应的内容类型为 text/html，并指定字符编码为 UTF-8，这通常用于返回 HTML 页面。 //获取表单请求的参数 - String sno = req.getParameter("sno"); - String sispunch = req.getParameter("sispunch"); - String spunchdate = req.getParameter("spunchdate"); - String spunchtime = req.getParameter("spunchtime"); - String sishot = req.getParameter("sishot"); - String siscough = req.getParameter("siscough"); - String sisseem = req.getParameter("sisseem"); - String sisdiagnose = req.getParameter("sisdiagnose"); - String sstatus = req.getParameter("sstatus"); - - String sql = "update stupunchin set sispunch = ?, spunchtime = ?, sishot = ?, siscough = ?, sisseem = ?, sisdiagnose = ?, sstatus = ? where sno = ? and spunchdate = ?"; - Object[] objects = {sispunch, spunchtime, sishot, siscough, sisseem, sisdiagnose, sstatus, sno, spunchdate}; - - int num = DeptAdminDao.executeUpdate(sql, objects); - - System.out.println(num); - - req.getRequestDispatcher("/DeptQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&spunchdate=").forward(req, resp); - + String tno = req.getParameter("tno");//获取表单中名为 "tno" 的参数值，并将其赋值给变量 tno。这个参数通常是教师编号。 + String tname = req.getParameter("tname");//获取表单中名为 "tname" 的参数值，并将其赋值给变量 tname。这个参数通常是教师的姓名。 + String tsex = req.getParameter("tsex");//获取表单中名为 "tsex" 的参数值，并将其赋值给变量 tsex。这个参数通常是教师的性别。 + String tage = req.getParameter("tage");//获取表单中名为 "tage" 的参数值，并将其赋值给变量 tage。这个参数通常是教师的年龄，类型是字符串。 + String tdept = req.getParameter("tdept");//获取表单中名为 "tdept" 的参数值，并将其赋值给变量 tdept。这个参数通常是教师所属的部门。 + String tphone = req.getParameter("tphone");//获取表单中名为 "tphone" 的参数值，并将其赋值给变量 tphone。这个参数通常是教师的电话。 + String tpsw = req.getParameter("tpsw");//获取表单中名为 "tpsw" 的参数值，并将其赋值给变量 tpsw。这个参数通常是教师的密码。 + + //将 tage（年龄）从字符串转换为整数类型。因为表单中的数据都是字符串，需要进行类型转换才能插入到数据库中。 + int tage1 = Integer.parseInt(tage); + + String sql = null;//声明一个 SQL 语句字符串变量 sql，用来存储后续的 SQL 查询语句。 + + System.out.println("shgshgh");//输出一个调试信息到控制台，用于验证代码是否正确执行。 + + //该段代码构造了一个 SQL 查询语句，用于检查教师编号（tno）是否已经存在于数据库中的 teacher 表。 + sql = "select count(*) as num from teacher where tno = ?"; + Object[] objects = {tno}; + int count = DeptAdminDao.findTotalCount(sql, objects);//DeptAdminDao.findTotalCount(sql, objects) 是自定义的方法，它执行该 SQL 查询并返回结果，即该编号的教师是否存在。返回的是一个整数，表示该编号的教师数量。 + + if (count == 0){//如果 count 为 0，表示数据库中没有该教师编号的记录，接下来的代码会执行插入操作。 + sql = "insert into teacher values(?, ?, ?, ?, ?, ?, ?)";//构造 SQL 插入语句，将教师的各项信息插入到 teacher 表中。 + Object[] objects1 = {tno, tname, tsex, tage1, tdept, tphone, tpsw};//objects1 数组包含了插入教师数据所需的所有参数。 + + int num = DeptAdminDao.executeUpdate(sql, objects1);//调用 DeptAdminDao.executeUpdate(sql, objects1) 执行插入操作。该方法执行 SQL 更新语句（包括插入、更新、删除），并返回受影响的记录数。 + System.out.println(num);//输出插入操作的受影响的记录数，用于调试和验证。 + + /* req.getRequestDispatcher("/DeptQueryTeaByPageServlet?currentPage=1&rows=8").forward(req, resp);*/ + //这里的代码会将请求转发到 DeptQueryTeaByPageServlet，该 Servlet 用于显示教师列表的分页信息。请求被转发到新的 URL，重新加载教师数据并显示给用户。这里的 currentPage=1&rows=7 表示请求第一页并每页显示 7 条记录。 + req.getRequestDispatcher("/DeptQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tsex=").forward(req, resp); + }else { + req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp);//如果 count 不为 0，表示数据库中已经存在该编号的教师，代码会将请求转发到 existdataofadd.jsp 页面，显示错误信息（例如“该教师编号已经存在”）。 + } } - + //重写 doPost 方法，以便当接收到 POST 请求时，调用 doGet 方法进行处理。这是因为这两个方法的逻辑相同，都是处理添加教师的功能。 @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); diff --git a/src/com/controller/deptadmin/DeptAlterStuServlet.java b/src/com/controller/deptadmin/DeptAlterStuServlet.java index 996e494..54f1792 100644 --- a/src/com/controller/deptadmin/DeptAlterStuServlet.java +++ b/src/com/controller/deptadmin/DeptAlterStuServlet.java @@ -1,50 +1,58 @@ -package com.controller.deptadmin; +package com.controller.deptadmin;//这一行指定了当前类所在的 Java 包，com.controller.deptadmin 表示该类属于 deptadmin 包下的控制器类。 -import com.dao.DeptAdminDao; +import com.dao.DeptAdminDao;//导入 DeptAdminDao 类，它通常是一个用于与数据库交互的 DAO（数据访问对象）类，包含了执行 SQL 查询或更新操作的方法。 -import javax.servlet.ServletException; -import javax.servlet.annotation.WebServlet; +import javax.servlet.ServletException;//ServletException：用于处理 Servlet 相关的异常。 +import javax.servlet.annotation.WebServlet;//WebServlet：用于定义 Servlet 的注解，它可以声明 URL 映射。 + +//HttpServlet, HttpServletRequest, HttpServletResponse：处理 HTTP 请求和响应的类。 import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; -import java.io.IOException; +import java.io.IOException;//IOException：用于处理输入输出相关的异常。 + +@WebServlet("/DeptAlterStuServlet")//这是一个 Servlet 注解，标明该类是一个 Servlet，并定义了它的 URL 映射。用户访问 /DeptAlterStuServlet 路径时会触发该 Servlet。 -@WebServlet("/DeptAlterStuServlet") +//定义了一个 DeptAlterStuServlet 类，它继承自 HttpServlet，表示这是一个处理 HTTP 请求的 Servlet。 public class DeptAlterStuServlet extends HttpServlet { + //这是重写的 doGet 方法，用于处理 HTTP GET 请求。当用户通过 GET 请求访问该 Servlet 时，doGet 方法会被调用。 @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 sno = req.getParameter("sno"); - String sname = req.getParameter("sname"); - String ssex = req.getParameter("ssex"); - String sage = req.getParameter("sage"); - String sclass = req.getParameter("sclass"); - String specialty = req.getParameter("specialty"); - String sdept = req.getParameter("sdept"); - String sphone = req.getParameter("sphone"); - String spsw = req.getParameter("spsw"); - - //数据类型转换 + req.setCharacterEncoding("utf-8");//req.setCharacterEncoding("utf-8")：设置请求的字符编码。 + resp.setCharacterEncoding("utf-8");//resp.setCharacterEncoding("utf-8")：设置响应的字符编码。 + resp.setContentType("text/html;charset=utf-8");//resp.setContentType("text/html;charset=utf-8")：设置响应的内容类型为 HTML，字符集为 UTF-8。 + + //从 HTTP 请求中获取前端表单提交的参数。req.getParameter() 方法用于获取指定参数名的值，并将其赋值给相应的变量 + String sno = req.getParameter("sno");//学生学号 + String sname = req.getParameter("sname");//学生姓名 + String ssex = req.getParameter("ssex");//学生姓名 + String sage = req.getParameter("sage");//学生年龄 + String sclass = req.getParameter("sclass");//学生班级 + String specialty = req.getParameter("specialty");//学生专业 + String sdept = req.getParameter("sdept");//学生院系 + String sphone = req.getParameter("sphone");//学生手机号码 + String spsw = req.getParameter("spsw");//学生密码 + + //将 sage（学生年龄，字符串类型）转换为整数类型 sage1。Integer.parseInt() 方法将字符串转换为整数。 int sage1 = Integer.parseInt(sage); + //构建 SQL 更新语句，用于更新 student 表中的学生信息。SQL 语句中使用了占位符 ?，这些占位符将在后面通过参数值进行替换。 String sql = "update student set sname = ?, ssex = ?, sage = ?, sclass = ?, specialty = ?, sdept = ?, sphone = ?, spsw = ? where sno = ?"; - Object[] objects = {sname, ssex, sage1, sclass, specialty, sdept, sphone, spsw, sno}; + Object[] objects = {sname, ssex, sage1, sclass, specialty, sdept, sphone, spsw, sno};//创建一个 Object 数组 objects，数组中存储了 SQL 语句中的占位符所需的参数值，按顺序传入 sname, ssex, sage1, sclass, specialty, sdept, sphone, spsw, sno。 - int num = DeptAdminDao.executeUpdate(sql, objects); + int num = DeptAdminDao.executeUpdate(sql, objects);//调用 DeptAdminDao.executeUpdate 方法执行 SQL 更新操作。该方法返回受影响的行数，即更新的记录数。num 变量将存储这个结果 - System.out.println(num); + System.out.println(num);//打印出更新操作影响的记录数，通常用于调试，确认操作是否成功。 // req.getRequestDispatcher("/DeptQueryStuByPageServlet?currentPage=1&rows=8").forward(req, resp); + //该行代码将请求转发到 DeptQueryStuByPageServlet，并附带了查询参数（currentPage=1, rows=7, sname=, sclass=, specialty=）。这是为了分页显示学生信息，并可能过滤学生的姓名、班级或专业。 req.getRequestDispatcher("/DeptQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&specialty=").forward(req, resp); } + //这是重写的 doPost 方法。在 doPost 中调用 doGet 方法，意味着无论是通过 GET 请求还是 POST 请求，都会执行相同的操作。 @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); diff --git a/src/com/controller/deptadmin/DeptAlterTeaPunchServlet.java b/src/com/controller/deptadmin/DeptAlterTeaPunchServlet.java index 3d3b485..e267082 100644 --- a/src/com/controller/deptadmin/DeptAlterTeaPunchServlet.java +++ b/src/com/controller/deptadmin/DeptAlterTeaPunchServlet.java @@ -1,46 +1,53 @@ -package com.controller.deptadmin; +package com.controller.deptadmin;//定义了当前类所在的 Java 包，com.controller.deptadmin，表示这是一个与部门管理员相关的控制器类。 -import com.dao.DeptAdminDao; +import com.dao.DeptAdminDao;//导入 DeptAdminDao 类，它通常用于数据库操作（如执行 SQL 查询或更新）。 -import javax.servlet.ServletException; -import javax.servlet.annotation.WebServlet; +import javax.servlet.ServletException;//ServletException：用于处理 Servlet 相关的异常。 +import javax.servlet.annotation.WebServlet;//WebServlet：用于定义 Servlet 的注解，声明该类是一个 Servlet，并且绑定 URL 映射。 + +//HttpServlet、HttpServletRequest 和 HttpServletResponse：用于处理 HTTP 请求和响应。 import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; -import java.io.IOException; +import java.io.IOException;//IOException：用于处理与输入输出相关的异常。 @WebServlet("/DeptAlterTeaPunchServlet") public class DeptAlterTeaPunchServlet extends HttpServlet { - @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 tno = req.getParameter("tno"); - String tispunch = req.getParameter("tispunch"); - String tpunchdate = req.getParameter("tpunchdate"); - String tpunchtime = req.getParameter("tpunchtime"); - String tishot = req.getParameter("tishot"); - String tiscough = req.getParameter("tiscough"); - String tisseem = req.getParameter("tisseem"); - String tisdiagnose = req.getParameter("tisdiagnose"); - String tstatus = req.getParameter("tstatus"); + @Override//使用 @WebServlet 注解将该类绑定到 /DeptAlterTeaPunchServlet 路径。意味着当浏览器请求这个 URL 时，Servlet 将被触发。 + //定义了一个继承自 HttpServlet 的 DeptAlterTeaPunchServlet 类。HttpServlet 是 Servlet 的一个标准实现，用于处理 HTTP 请求。 + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + req.setCharacterEncoding("utf-8");//req.setCharacterEncoding("utf-8")：设置请求的字符编码。 + resp.setCharacterEncoding("utf-8");//resp.setCharacterEncoding("utf-8")：设置响应的字符编码。 + resp.setContentType("text/html;charset=utf-8");//resp.setContentType("text/html;charset=utf-8")：设置响应内容的类型为 HTML，并指定字符集为 UTF-8。 + + //从 HTTP 请求中获取前端表单提交的参数。req.getParameter() 方法用于获取特定参数名的值。 + String tno = req.getParameter("tno");//教师工号 + String tispunch = req.getParameter("tispunch");//是否打卡 + String tpunchdate = req.getParameter("tpunchdate");//打卡日期 + String tpunchtime = req.getParameter("tpunchtime");//打卡时间 + String tishot = req.getParameter("tishot");//是否发热 + String tiscough = req.getParameter("tiscough");//是否咳嗽 + String tisseem = req.getParameter("tisseem");//是否有嗅觉 + String tisdiagnose = req.getParameter("tisdiagnose");//是否诊断为疾病 + String tstatus = req.getParameter("tstatus");//当前的考勤情况 + + //构建了一个 SQL 更新语句，用于更新教师考勤记录。SQL 语句中使用了占位符（?），这些占位符将由 objects 数组中的实际值替换。 String sql = "update teapunchin set tispunch = ?, tpunchtime = ?, tishot = ?, tiscough = ?, tisseem = ?, tisdiagnose = ?, tstatus = ? where tno = ? and tpunchdate = ?"; - Object[] objects = {tispunch, tpunchtime, tishot, tiscough, tisseem, tisdiagnose, tstatus, tno, tpunchdate}; + Object[] objects = {tispunch, tpunchtime, tishot, tiscough, tisseem, tisdiagnose, tstatus, tno, tpunchdate};//创建一个 Object[] 数组 objects，将前面从表单中获取的参数按顺序放入数组中，这些值将在执行 SQL 更新时替代 SQL 语句中的 ? 占位符。 - int num = DeptAdminDao.executeUpdate(sql, objects); + int num = DeptAdminDao.executeUpdate(sql, objects);//调用 DeptAdminDao.executeUpdate 方法执行 SQL 更新操作。executeUpdate 方法会根据 SQL 语句更新数据库中的记录，返回值 num 表示受影响的行数（即更新了多少条记录）。 - System.out.println(num); + System.out.println(num);//打印更新操作影响的行数。通常用于调试，以确认操作是否成功。 + //将请求转发到另一个 Servlet DeptQueryTeaPunchByPageServlet，并传递一些分页参数（currentPage=1&rows=7）以及查询条件（tno=, tname=, tpunchdate=）。 req.getRequestDispatcher("/DeptQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tpunchdate=").forward(req, resp); } @Override + //重写 doPost 方法。由于该方法没有做任何额外的处理，它直接调用了 doGet 方法。这样，GET 请求和 POST 请求都会执行相同的操作。 protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); } diff --git a/src/com/controller/deptadmin/DeptAlterTeaServlet.java b/src/com/controller/deptadmin/DeptAlterTeaServlet.java index 9cf7b82..dfc468f 100644 --- a/src/com/controller/deptadmin/DeptAlterTeaServlet.java +++ b/src/com/controller/deptadmin/DeptAlterTeaServlet.java @@ -1,47 +1,51 @@ -package com.controller.deptadmin; +package com.controller.deptadmin;//定义了当前类所在的 Java 包，com.controller.deptadmin，说明这是一个部门管理员相关的控制器类。 -import com.dao.DeptAdminDao; +import com.dao.DeptAdminDao;//导入 DeptAdminDao 类，它通常用于与数据库进行交互，例如执行 SQL 查询或更新操作。 -import javax.servlet.ServletException; -import javax.servlet.annotation.WebServlet; +import javax.servlet.ServletException;//ServletException：用于处理 Servlet 异常。 +import javax.servlet.annotation.WebServlet;//WebServlet：注解，用于将这个类声明为一个 Servlet 并绑定一个 URL 路径。 + +//HttpServlet、HttpServletRequest 和 HttpServletResponse：用于处理 HTTP 请求和响应。 import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; -import java.io.IOException; +import java.io.IOException;//IOException：用于处理输入输出异常。 -@WebServlet("/DeptAlterTeaServlet") -public class DeptAlterTeaServlet extends HttpServlet { +@WebServlet("/DeptAlterTeaServlet")//使用 @WebServlet 注解定义了这个 Servlet 的 URL 映射为 /DeptAlterTeaServlet。当浏览器请求该路径时，Servlet 会被调用。 +public class DeptAlterTeaServlet extends HttpServlet {//定义了一个继承自 HttpServlet 的类 DeptAlterTeaServlet，这是一个处理 HTTP 请求的 Servlet 类。 - @Override + @Override//重写 doGet 方法，这个方法处理 HTTP GET 请求。当用户发出 GET 请求时，这个方法将被调用。 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 tno = req.getParameter("tno"); - String tname = req.getParameter("tname"); - String tsex = req.getParameter("tsex"); - String tage = req.getParameter("tage"); - String tdept = req.getParameter("tdept"); - String tphone = req.getParameter("tphone"); - String tpsw = req.getParameter("tpsw"); - - //数据类型转换 + req.setCharacterEncoding("utf-8");//req.setCharacterEncoding("utf-8")：设置请求的字符编码。 + resp.setCharacterEncoding("utf-8");//resp.setCharacterEncoding("utf-8")：设置响应的字符编码。 + resp.setContentType("text/html;charset=utf-8");//resp.setContentType("text/html;charset=utf-8")：设置响应的内容类型为 HTML，并指定字符集为 UTF-8。 + + //从 HTTP 请求中获取前端提交的表单参数 + String tno = req.getParameter("tno");//教师工号 + String tname = req.getParameter("tname");//教师姓名 + String tsex = req.getParameter("tsex");//教师性别 + String tage = req.getParameter("tage");//教师年龄 + String tdept = req.getParameter("tdept");//教师所属部门 + String tphone = req.getParameter("tphone");//教师联系电话 + String tpsw = req.getParameter("tpsw");//教师密码 + + //将 tage（从表单中获得的年龄）转换为整数类型。Integer.parseInt() 方法将字符串类型的 tage 转换为整数 tage1。 int tage1 = Integer.parseInt(tage); - String sql = "update teacher set tname = ?, tsex = ?, tage = ?, tdept = ?, tphone = ?, tpsw = ? where tno = ?"; - Object[] objects = {tname, tsex, tage1, tdept, tphone, tpsw, tno}; + String sql = "update teacher set tname = ?, tsex = ?, tage = ?, tdept = ?, tphone = ?, tpsw = ? where tno = ?";//构建一个 SQL 更新语句，用于更新教师的信息。? 是占位符，在实际执行时会用实际参数替换。这个 SQL 语句将教师的姓名、性别、年龄、部门、电话和密码更新到数据库中，条件是教师的工号 tno。 + Object[] objects = {tname, tsex, tage1, tdept, tphone, tpsw, tno};//创建一个 Object[] 数组，将前面从请求中获取的参数按顺序存放在数组中。这些参数将用于替代 SQL 语句中的占位符 ?。 - int num = DeptAdminDao.executeUpdate(sql, objects); + int num = DeptAdminDao.executeUpdate(sql, objects);//调用 DeptAdminDao.executeUpdate 方法来执行 SQL 更新操作，传入 SQL 语句和参数数组。该方法返回一个整数 num，表示受影响的行数，即更新了多少条记录。 - System.out.println(num); + System.out.println(num);//打印出受影响的行数 num，用于调试和确认是否成功更新了记录。 // req.getRequestDispatcher("/DeptQueryTeaByPageServlet?currentPage=1&rows=8").forward(req, resp); + //通过 RequestDispatcher 转发请求到另一个 Servlet /DeptQueryTeaByPageServlet。在转发时传递一些分页参数（currentPage=1&rows=7）以及查询条件（tno=, tname=, tsex=）。 req.getRequestDispatcher("/DeptQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tsex=").forward(req, resp); } + //重写 doPost 方法。该方法调用了 doGet，这样无论是 GET 请求还是 POST 请求都会执行相同的逻辑。 @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); diff --git a/src/com/controller/deptadmin/DeptDelSelectedStuPunchServlet.java b/src/com/controller/deptadmin/DeptDelSelectedStuPunchServlet.java index 065cbbe..34264a2 100644 --- a/src/com/controller/deptadmin/DeptDelSelectedStuPunchServlet.java +++ b/src/com/controller/deptadmin/DeptDelSelectedStuPunchServlet.java @@ -1,61 +1,144 @@ package com.controller.deptadmin; +// 声明该类所属的包为 com.controller.deptadmin，包机制是 Java 中用于组织和管理类的一种方式， +// 它将相关的类归为一组，便于代码的维护、查找和管理，同时避免类名冲突。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，这个类通常包含了与数据库交互的各种方法， +// 比如执行 SQL 查询语句（如 select）、插入数据（insert）、更新数据（update）以及删除数据（delete）等操作， +// 在后续代码中会利用这些方法来实现对数据库中数据的操作。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现错误或异常情况时， +// 例如请求处理失败、资源加载异常等，会抛出 ServletException 异常，以便进行异常处理。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，它是 Java EE 中用于将一个普通的 Java 类标记为 Servlet 的注解。 +// 通过该注解可以方便地指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法。 +// 我们定义的 Servlet 类需要继承 HttpServlet 类，从而获得处理 HTTP 请求的能力。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，它用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容。Servlet 可以通过这个类来获取客户端传递的各种数据。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，它用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等。Servlet 可以利用这个类来设置并返回给客户端相应的响应数据。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出相关的操作（如网络数据传输、文件读写等）时， +// 如果出现错误，就会抛出 IOException 异常，以便进行相应的错误处理。 @WebServlet("/DeptDelSelectedStuPunchServlet") +// 使用 WebServlet 注解将 DeptDelSelectedStuPunchServlet 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptDelSelectedStuPunchServlet，这样客户端就可以通过这个路径向该 Servlet 发送请求。 + public class DeptDelSelectedStuPunchServlet extends HttpServlet { + // 定义一个名为 DeptDelSelectedStuPunchServlet 的类，继承自 HttpServlet 类， + // 这使得该类成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端发送的 GET 和 POST 请求。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法专门用于处理客户端发送的 HTTP GET 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，这样可以确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确性。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，这保证了服务器返回给客户端的内容能够正确显示中文等特殊字符， + // 使得客户端能够准确地解析和展示响应信息。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 这告诉客户端服务器返回的是 HTML 格式的内容，并且按照 UTF-8 编码进行解析和显示。 //获取请求时复选框有选中的状态参数 String[] snodates = req.getParameterValues("snodates"); + // 从 HTTP 请求中获取名为 "snodates" 的参数值，由于该参数可能有多个值（对应多个复选框的选中状态）， + // 所以使用 getParameterValues 方法，将获取到的值存储在字符串数组 snodates 中。这里的 snodates 可能包含了学生编号和打卡日期的组合信息。 System.out.println(snodates); + // 在控制台打印 snodates 数组，用于调试目的，方便开发人员查看接收到的参数数组。 + // 但需要注意的是，直接打印数组会输出数组的内存地址，若要查看具体值，通常需要遍历数组。 - if(snodates.length > 0 && snodates != null){ - //遍历并删除选中的sno,y一个一个删除 - for (String snodate: snodates) { + if (snodates.length > 0 && snodates != null) { + // 判断 snodates 数组是否为空且长度大于 0，如果满足这个条件， + // 说明客户端确实选中了一些复选框，有需要处理的参数数据，因此可以继续执行后续的删除操作。 + + //遍历并删除选中的sno,一个一个删除 + for (String snodate : snodates) { + // 使用增强型 for 循环遍历 snodates 数组，每次取出一个 snodate 元素， + // 该元素包含了学生编号和打卡日期的组合信息，接下来对其进行分离处理。 //分离两个参数 String[] params = snodate.split(","); + // 使用 split 方法将 snodate 字符串按逗号分隔成一个字符串数组 params， + // 以便将学生编号和打卡日期分开。 + String sno = params[0]; + // 将数组 params 的第一个元素赋值给字符串变量 sno，代表学生编号。 + String spunchdate = params[1]; + // 将数组 params 的第二个元素赋值给字符串变量 spunchdate，代表学生的打卡日期。 System.out.println(sno); System.out.println(spunchdate); + // 在控制台分别打印 sno 和 spunchdate 的值，用于调试， + // 方便开发人员确认从参数中分离出的学生编号和打卡日期是否正确。 //字符串转为日期类型 // Date spunchdate1 = new Date(spunchdate); + // 注释掉的代码，原本意图是将字符串类型的打卡日期 spunchdate 转换为 Date 类型， + // 但这种方式在传入字符串格式不匹配时可能会出错，并且此处未实际使用。 + //或 // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); // Date spunchdate1 = ft.format(spunchdate); + // 注释掉的代码，提供了另一种将字符串按 "yyyy-MM-dd" 格式转换为 Date 类型的方式， + // 同样未在当前代码中实际使用，可能是后续功能的预留或根据实际需求不需要进行此转换。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 + Object[] objects = {sno, spunchdate}; + // 创建一个 Object 类型的数组 objects，将 sno 和 spunchdate 作为元素存储在数组中， + // 这个数组将作为参数传递给数据库操作方法，用于绑定 SQL 语句中的占位符。 //删除stupunchin中的该导游信息 sql = "delete from stupunchin where sno = ? and spunchdate = ?"; + // 定义一个 SQL 删除语句，用于从 stupunchin 表中删除学生编号为 sno 且打卡日期为 spunchdate 的记录， + // 使用占位符 ? 来提高 SQL 语句的安全性，防止 SQL 注入攻击。 + int num1 = DeptAdminDao.executeUpdate(sql, objects); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句， + // 并将受影响的记录数量赋值给整数变量 num1，通过这个数量可以判断删除操作是否成功以及影响的记录数。 + System.out.println(num1); + // 在控制台打印受影响的记录数量 num1，用于调试目的， + // 方便开发人员确认删除 stupunchin 表中对应记录的操作是否成功，以及删除的记录数量是否符合预期。 } req.getRequestDispatcher("/DeptQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&spunchdate=").forward(req, resp); + // 将请求转发到 /DeptQueryStuPunchByPageServlet 页面，并传递相应的参数， + // 当前页码 currentPage 为 1，每页显示行数 rows 为 7，学生姓名 sname、学生班级 sclass 和打卡日期 spunchdate 为空。 + // 这一步通常是在完成删除操作后，将页面重定向到查询学生打卡信息的页面，以便用户查看更新后的打卡记录列表。 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，该方法用于处理客户端发送的 HTTP POST 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以应对可能出现的错误情况。 + doGet(req, resp); + // 调用 doGet 方法来处理 POST 请求，这意味着对于该 Servlet，POST 请求和 GET 请求的处理逻辑是相同的， + // 这样可以避免重复编写相似的代码，提高代码的复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptDelSelectedStuServlet.java b/src/com/controller/deptadmin/DeptDelSelectedStuServlet.java index 4b0636c..3773b37 100644 --- a/src/com/controller/deptadmin/DeptDelSelectedStuServlet.java +++ b/src/com/controller/deptadmin/DeptDelSelectedStuServlet.java @@ -1,56 +1,151 @@ package com.controller.deptadmin; +// 声明该类所属的包为 com.controller.deptadmin，包的作用是对相关的类进行组织和管理， +// 便于代码的维护和查找，同时避免类名冲突，在大型项目中有助于构建清晰的代码结构。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的操作方法， +// 例如执行 SQL 查询、插入数据、更新数据以及删除数据等操作。后续代码会使用该类的方法来操作数据库。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 类，一般来说，这个类会包含与 JDBC（Java Database Connectivity） +// 相关的工具方法，比如获取数据库连接、关闭连接等，以简化数据库操作的流程。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现异常情况时， +// 例如请求处理失败、资源加载错误等，会抛出 ServletException 异常， +// 以便进行相应的异常处理和错误恢复。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是 Java EE 中用于将普通 Java 类标记为 Servlet 的注解。 +// 通过该注解可以指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法。 +// 我们定义的 Servlet 类需要继承 HttpServlet 类，从而获得处理 HTTP 请求的能力。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容。Servlet 可以通过这个类获取客户端传递的各种数据。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等。Servlet 可以利用这个类来设置并返回给客户端相应的响应数据。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出相关的操作（如网络数据传输、文件读写等）时， +// 如果出现错误，就会抛出 IOException 异常，以便进行相应的错误处理。 + import java.sql.ResultSet; +// 导入 ResultSet 类，它用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据。 + import java.sql.SQLException; +// 导入 SQL 异常类，当与数据库进行交互（如执行 SQL 语句）过程中出现错误时， +// 例如数据库连接失败、SQL 语句语法错误等，会抛出 SQLException 异常， +// 用于捕获和处理这些与数据库操作相关的异常情况。 + import java.util.ArrayList; +// 导入 ArrayList 类，它是 Java 集合框架中的一种动态数组实现。 +// 可以用来存储和管理一组对象，并且可以根据需要动态地增加或减少元素数量。 + import java.util.Iterator; +// 导入 Iterator 接口，它提供了一种遍历集合元素的通用方式。 +// 通过实现 Iterator 接口的方法，可以对集合（如 ArrayList）中的元素进行迭代访问。 @WebServlet("/DeptDelSelectedStuServlet") +// 使用 WebServlet 注解将 DeptDelSelectedStuServlet 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptDelSelectedStuServlet，这样客户端就可以通过这个路径向该 Servlet 发送请求。 + public class DeptDelSelectedStuServlet extends HttpServlet { + // 定义一个名为 DeptDelSelectedStuServlet 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端发送的 GET 和 POST 请求。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法用于处理客户端发送的 HTTP GET 请求。 + // 方法接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并可能抛出 ServletException 和 IOException 异常，以处理请求过程中可能出现的错误。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保能够正确处理包含中文等特殊字符的请求参数， + // 避免因字符编码问题导致的乱码，保证请求数据的准确解析。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容，以便客户端能够正确解析和显示响应信息。 //获取请求时复选框有选中的状态参数 String[] snos = req.getParameterValues("sno"); + // 从 HTTP 请求中获取名为 "sno" 的参数值，由于该参数可能有多个值（对应多个复选框的选中状态）， + // 所以使用 getParameterValues 方法，将获取到的值存储在字符串数组 snos 中。这里的 snos 代表多个学生编号。 System.out.println(snos); + // 在控制台打印 snos 数组，用于调试目的，方便开发人员查看接收到的学生编号参数数组。 + // 但需注意，直接打印数组会输出数组的内存地址，若要查看具体值，需遍历数组。 + + if (snos.length > 0 && snos != null) { + // 判断 snos 数组是否为空且长度大于 0，如果满足这个条件， + // 说明客户端确实选中了一些复选框，有需要处理的学生编号数据，因此可以继续执行后续的删除操作。 + + //遍历并删除选中的sno,一个一个删除 + for (String sno : snos) { + // 使用增强型 for 循环遍历 snos 数组，每次取出一个 sno 元素， + // 该元素代表一个学生编号，接下来针对该学生编号执行删除操作。 - if(snos.length > 0 && snos != null){ - //遍历并删除选中的sno,y一个一个删除 - for (String sno: snos) { String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务需求动态地构建和赋值 SQL 语句。 + Object[] objects = {sno}; + // 创建一个 Object 类型的数组 objects，将 sno 作为唯一元素存储在数组中， + // 这个数组将作为参数传递给数据库操作方法，用于绑定 SQL 语句中的占位符。 //删除stupunchin中的该导游信息 sql = "delete from stupunchin where sno = ?"; + // 定义一个 SQL 删除语句，用于从 stupunchin 表中删除学生编号为 sno 的记录， + // 使用占位符 ? 来提高 SQL 语句的安全性，防止 SQL 注入攻击。 + int num1 = DeptAdminDao.executeUpdate(sql, objects); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句， + // 并将受影响的记录数量赋值给整数变量 num1，通过这个数量可以判断删除操作是否成功以及影响的记录数。 + System.out.println(num1); + // 在控制台打印受影响的记录数量 num1，用于调试目的， + // 方便开发人员确认删除 stupunchin 表中对应记录的操作是否成功，以及删除的记录数量是否符合预期。 //删除student表中该导游信息 sql = "delete from student where sno = ?"; + // 定义一个 SQL 删除语句，用于从 student 表中删除学生编号为 sno 的记录， + // 同样使用占位符 ? 来确保 SQL 语句的安全性。 + int num2 = DeptAdminDao.executeUpdate(sql, objects); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句， + // 并将受影响的记录数量赋值给整数变量 num2，用于判断删除 student 表中记录的操作是否成功。 + System.out.println(num2); + // 在控制台打印受影响的记录数量 num2，用于调试目的， + // 方便开发人员确认删除 student 表中对应记录的操作是否成功，以及删除的记录数量是否符合预期。 } req.getRequestDispatcher("/DeptQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&specialty=").forward(req, resp); + // 将请求转发到 /DeptQueryStuByPageServlet 页面，并传递相应的参数， + // 当前页码 currentPage 为 1，每页显示行数 rows 为 7，学生姓名 sname、学生班级 sclass 和专业 specialty 为空。 + // 这一步通常是在完成删除操作后，将页面重定向到查询学生信息的页面，以便用户查看更新后的学生列表。 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，该方法用于处理客户端发送的 HTTP POST 请求。 + // 方法接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并可能抛出 ServletException 和 IOException 异常，以处理请求过程中可能出现的错误。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同， + // 这样可以避免重复编写相似的代码，提高代码的复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptDelSelectedTeaPunchServlet.java b/src/com/controller/deptadmin/DeptDelSelectedTeaPunchServlet.java index 28efd3c..12444df 100644 --- a/src/com/controller/deptadmin/DeptDelSelectedTeaPunchServlet.java +++ b/src/com/controller/deptadmin/DeptDelSelectedTeaPunchServlet.java @@ -1,61 +1,143 @@ package com.controller.deptadmin; +// 声明该类所属的包为 com.controller.deptadmin，包用于对相关类进行组织管理， +// 方便代码的维护和查找，避免类名冲突，构建清晰的项目结构。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常包含与数据库交互的方法， +// 如执行 SQL 查询、插入、更新、删除等操作，后续代码将使用这些方法操作数据库。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行中出现错误或异常（如请求处理失败、资源加载问题等）时， +// 会抛出 ServletException 异常，以便进行异常处理。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将普通 Java 类标记为 Servlet，并指定其访问路径， +// 使客户端能够通过特定 URL 访问该 Servlet。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供处理 HTTP 请求的基本框架和方法， +// 我们定义的 Servlet 类需继承它以获得处理 HTTP 请求的能力。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等，Servlet 可借此获取客户端数据。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等，Servlet 可通过它设置并返回响应数据。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出操作（如网络传输、文件读写等）出现错误时， +// 会抛出 IOException 异常，以便进行错误处理。 @WebServlet("/DeptDelSelectedTeaPunchServlet") +// 使用 WebServlet 注解将 DeptDelSelectedTeaPunchServlet 类标记为 Servlet， +// 并指定访问路径为 /DeptDelSelectedTeaPunchServlet，客户端可通过此路径发送请求。 + public class DeptDelSelectedTeaPunchServlet extends HttpServlet { + // 定义名为 DeptDelSelectedTeaPunchServlet 的类，继承自 HttpServlet 类， + // 使其能处理 HTTP 请求，响应客户端的 GET 和 POST 请求。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，处理客户端的 HTTP GET 请求。 + // 接收 HttpServletRequest 和 HttpServletResponse 对象作为参数， + // 可能抛出 ServletException 和 IOException 异常以处理请求中的错误。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保能正确处理含中文等特殊字符的请求参数， + // 避免乱码，保证请求数据准确解析。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能正确显示中文等特殊字符， + // 确保响应数据正确呈现。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式内容，以便正确解析和显示。 //获取请求时复选框有选中的状态参数 String[] tnodates = req.getParameterValues("tnodates"); + // 从 HTTP 请求中获取名为 "tnodates" 的参数值，因该参数可能有多个值（复选框选中状态）， + // 用 getParameterValues 方法，将值存于字符串数组 tnodates 中，可能包含教师编号和打卡日期组合信息。 System.out.println(tnodates); + // 在控制台打印 tnodates 数组，用于调试，查看接收到的参数数组。 + // 直接打印数组输出的是内存地址，查看具体值需遍历数组。 + + if (tnodates.length > 0 && tnodates != null) { + // 判断 tnodates 数组是否为空且长度大于 0，满足则说明有选中复选框， + // 有需要处理的数据，可继续执行后续删除操作。 - if(tnodates.length > 0 && tnodates != null){ //遍历并删除选中的sno,y一个一个删除 - for (String tnodate: tnodates) { + for (String tnodate : tnodates) { + // 用增强型 for 循环遍历 tnodates 数组，每次取出一个 tnodate 元素， + // 该元素含教师编号和打卡日期组合信息，进行分离处理。 //分离两个参数 String[] params = tnodate.split(","); + // 用 split 方法将 tnodate 字符串按逗号分隔成字符串数组 params， + // 以分离教师编号和打卡日期。 + String tno = params[0]; + // 将数组 params 的第一个元素赋值给 tno，代表教师编号。 + String tpunchdate = params[1]; + //将数组 params 的第二个元素赋值给 tpunchdate，代表教师打卡日期。 System.out.println(tno); System.out.println(tpunchdate); + // 在控制台分别打印 tno 和 tpunchdate 的值，用于调试， + // 确认分离出的教师编号和打卡日期是否正确。 //字符串转为日期类型 // Date spunchdate1 = new Date(spunchdate); + // 注释掉的代码，原试图将字符串类型打卡日期转换为 Date 类型， + // 但格式不匹配时可能出错，且此处未实际使用。 + //或 // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); // Date spunchdate1 = ft.format(spunchdate); + // 注释掉的代码，提供另一种将字符串按 "yyyy-MM-dd" 格式转换为 Date 类型的方式， + // 同样未实际使用，可能为后续功能预留或无需此转换。 String sql = null; + // 声明字符串变量 sql，用于存储 SQL 语句，初始值为 null， + // 后续根据业务逻辑动态构建和赋值。 + Object[] objects = {tno, tpunchdate}; + // 创建 Object 类型数组 objects，将 tno 和 tpunchdate 作为元素存储， + // 作为参数传递给数据库操作方法，绑定 SQL 语句中的占位符。 //删除stupunchin中的该信息 sql = "delete from teapunchin where tno = ? and tpunchdate = ?"; + // 定义 SQL 删除语句，从 teapunchin 表中删除教师编号为 tno 且打卡日期为 tpunchdate 的记录， + // 用占位符 ? 提高 SQL 语句安全性，防止 SQL 注入攻击。 + int num1 = DeptAdminDao.executeUpdate(sql, objects); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行 SQL 删除语句， + // 将受影响的记录数量赋值给 num1，判断删除操作是否成功及影响的记录数。 + System.out.println(num1); + // 在控制台打印受影响的记录数量 num1，用于调试， + // 确认删除 teapunchin 表中对应记录的操作是否成功及记录数量是否符合预期。 } req.getRequestDispatcher("/DeptQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tpunchdate=").forward(req, resp); + // 将请求转发到 /DeptQueryTeaPunchByPageServlet 页面，并传递参数， + // 当前页码 currentPage 为 1，每页显示行数 rows 为 7，教师编号 tno、教师姓名 tname、打卡日期 tpunchdate 为空。 + // 完成删除操作后，重定向到查询教师打卡信息页面，让用户查看更新后的打卡记录列表。 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，处理客户端的 HTTP POST 请求。 + // 接收 HttpServletRequest 和 HttpServletResponse 对象作为参数， + // 可能抛出 ServletException 和 IOException 异常以处理请求中的错误。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即该 Servlet 的 POST 和 GET 请求处理逻辑相同， + // 避免重复代码，提高代码复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptDelSelectedTeaServlet.java b/src/com/controller/deptadmin/DeptDelSelectedTeaServlet.java index a69643e..bbbde17 100644 --- a/src/com/controller/deptadmin/DeptDelSelectedTeaServlet.java +++ b/src/com/controller/deptadmin/DeptDelSelectedTeaServlet.java @@ -1,51 +1,129 @@ package com.controller.deptadmin; +// 声明该类所在的包为 com.controller.deptadmin，包机制用于将相关的类组织在一起， +// 方便代码的管理和维护，避免不同类之间的命名冲突，也有助于构建清晰的项目结构。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，这个类通常封装了与数据库交互的操作方法， +// 像执行 SQL 查询、插入、更新和删除等操作，后续代码会借助这些方法来操作数据库。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在执行过程中出现异常情况， +// 例如请求处理失败、资源加载错误等，就会抛出 ServletException 异常，用于异常处理。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，它是 Java EE 中用于将普通 Java 类标记为 Servlet 的注解， +// 通过该注解可以指定 Servlet 的访问路径，使客户端能够通过特定的 URL 来访问该 Servlet。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本结构和方法， +// 我们定义的 Servlet 类继承它，从而具备处理 HTTP 请求的能力。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容，Servlet 可以通过它获取客户端传递的数据。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等，Servlet 可以利用它设置并返回响应数据给客户端。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出操作（如网络传输、文件读写等）出现错误时， +// 会抛出 IOException 异常，以便进行相应的错误处理。 @WebServlet("/DeptDelSelectedTeaServlet") +// 使用 WebServlet 注解将 DeptDelSelectedTeaServlet 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptDelSelectedTeaServlet，客户端可以通过这个路径向该 Servlet 发送请求。 + public class DeptDelSelectedTeaServlet extends HttpServlet { + // 定义一个名为 DeptDelSelectedTeaServlet 的类，继承自 HttpServlet 类， + // 使其成为一个能够处理 HTTP 请求的 Servlet，可响应客户端的 GET 和 POST 请求。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 HTTP GET 请求。 + // 该方法接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF - 8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确解析。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF - 8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF - 8， + // 告知客户端返回的是 HTML 格式的内容，以便客户端正确解析和显示响应信息。 //获取请求时复选框有选中的状态参数 String[] tnos = req.getParameterValues("tno"); + // 从 HTTP 请求中获取名为 "tno" 的参数值，由于该参数可能有多个值（对应多个复选框的选中状态）， + // 所以使用 getParameterValues 方法，将获取到的值存储在字符串数组 tnos 中，这里的 tnos 代表多个教师编号。 System.out.println(tnos); + // 在控制台打印 tnos 数组，用于调试目的，方便开发人员查看接收到的教师编号参数数组。 + // 不过直接打印数组会输出数组的内存地址，若要查看具体值，需要遍历数组。 + + if (tnos.length > 0 && tnos != null) { + // 判断 tnos 数组是否为空且长度大于 0，如果满足这个条件， + // 说明客户端确实选中了一些复选框，有需要处理的教师编号数据，因此可以继续执行后续的删除操作。 - if(tnos.length > 0 && tnos != null){ //遍历并删除选中的sno,y一个一个删除 - for (String tno: tnos) { + for (String tno : tnos) { + // 使用增强型 for 循环遍历 tnos 数组，每次取出一个 tno 元素， + // 该元素代表一个教师编号，接下来针对该教师编号执行删除操作。 + String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 + Object[] objects = {tno}; + // 创建一个 Object 类型的数组 objects，将 tno 作为唯一元素存储在数组中， + // 这个数组将作为参数传递给数据库操作方法，用于绑定 SQL 语句中的占位符。 //删除stupunchin中的该导游信息 sql = "delete from teapunchin where tno = ?"; + // 定义一个 SQL 删除语句，用于从 teapunchin 表中删除教师编号为 tno 的记录， + // 使用占位符 ? 来提高 SQL 语句的安全性，防止 SQL 注入攻击。 + int num1 = DeptAdminDao.executeUpdate(sql, objects); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句， + // 并将受影响的记录数量赋值给整数变量 num1，通过这个数量可以判断删除操作是否成功以及影响的记录数。 + System.out.println(num1); + // 在控制台打印受影响的记录数量 num1，用于调试目的， + // 方便开发人员确认删除 teapunchin 表中对应记录的操作是否成功，以及删除的记录数量是否符合预期。 //删除student表中该导游信息 sql = "delete from teacher where tno = ?"; + // 定义一个 SQL 删除语句，用于从 teacher 表中删除教师编号为 tno 的记录， + // 同样使用占位符 ? 来确保 SQL 语句的安全性。 + int num2 = DeptAdminDao.executeUpdate(sql, objects); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句， + // 并将受影响的记录数量赋值给整数变量 num2，用于判断删除 teacher 表中记录的操作是否成功。 + System.out.println(num2); + // 在控制台打印受影响的记录数量 num2，用于调试目的， + // 方便开发人员确认删除 teacher 表中对应记录的操作是否成功，以及删除的记录数量是否符合预期。 } req.getRequestDispatcher("/DeptQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tsex=").forward(req, resp); + // 将请求转发到 /DeptQueryTeaByPageServlet 页面，并传递相应的参数， + // 当前页码 currentPage 为 1，每页显示行数 rows 为 7，教师编号 tno、教师姓名 tname、教师性别 tsex 为空。 + // 这一步通常是在完成删除操作后，将页面重定向到查询教师信息的页面，以便用户查看更新后的教师列表。 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 HTTP POST 请求。 + // 该方法接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同， + // 这样可以避免重复编写相似的代码，提高代码的复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptDeleteStuPunchServlet.java b/src/com/controller/deptadmin/DeptDeleteStuPunchServlet.java index c9d4f15..878c0fd 100644 --- a/src/com/controller/deptadmin/DeptDeleteStuPunchServlet.java +++ b/src/com/controller/deptadmin/DeptDeleteStuPunchServlet.java @@ -1,35 +1,38 @@ -package com.controller.deptadmin; +package com.controller.deptadmin;//定义了当前类所在的 Java 包 com.controller.deptadmin，表示这是一个与部门管理员相关的控制器类。 -import com.dao.DeptAdminDao; +import com.dao.DeptAdminDao;//导入 DeptAdminDao 类，该类通常用于执行数据库操作（如查询、更新、删除等）。 -import javax.servlet.ServletException; -import javax.servlet.annotation.WebServlet; +import javax.servlet.ServletException;//ServletException：用于处理 Servlet 异常。 +import javax.servlet.annotation.WebServlet;//WebServlet：注解，用于将类声明为 Servlet，并将其与特定的 URL 路径映射。 + +//HttpServlet、HttpServletRequest 和 HttpServletResponse：用于处理 HTTP 请求和响应。 import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; -import java.io.IOException; +import java.io.IOException;//IOException：用于处理输入输出异常。 import java.text.SimpleDateFormat; import java.util.Date; -@WebServlet("/DeptDeleteStuPunchServlet") -public class DeptDeleteStuPunchServlet extends HttpServlet { +@WebServlet("/DeptDeleteStuPunchServlet")//使用 @WebServlet 注解，将这个 Servlet 映射到 URL 路径 /DeptDeleteStuPunchServlet，即当访问该路径时，Servlet 会被触发。 +public class DeptDeleteStuPunchServlet extends HttpServlet {//定义了一个继承自 HttpServlet 的类 DeptDeleteStuPunchServlet，它处理 HTTP 请求，执行删除学生考勤记录的操作。 - @Override + @Override//重写 doGet 方法，用于处理 HTTP GET 请求。 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"); + req.setCharacterEncoding("utf-8");//req.setCharacterEncoding("utf-8")：设置请求的字符编码为 UTF-8。 + resp.setCharacterEncoding("utf-8");//resp.setCharacterEncoding("utf-8")：设置响应的字符编码为 UTF-8。 + resp.setContentType("text/html;charset=utf-8");//resp.setContentType("text/html;charset=utf-8")：设置响应的内容类型为 HTML，并指定字符集为 UTF-8。 - //获取请求参数 + //从请求中获取参数 snodate，这个参数包含了学生学号和考勤日期，通常以逗号分隔。 String snodate = req.getParameter("snodate"); - System.out.println(snodate); + System.out.println(snodate);//输出获取到的 snodate 参数，便于调试时查看该参数的值。 //分离两个参数,用日期和学号来删除 - String[] params = snodate.split(","); + String[] params = snodate.split(",");//将 snodate 字符串按逗号分隔，得到学号和考勤日期两个部分，分别存储在 sno（学号）和 spunchdate（考勤日期）变量中。 String sno = params[0]; String spunchdate = params[1]; + //输出分离后的学号和考勤日期，便于调试时查看它们的值。 System.out.println(sno); System.out.println(spunchdate); @@ -39,26 +42,29 @@ public class DeptDeleteStuPunchServlet extends HttpServlet { // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); // Date spunchdate1 = ft.format(spunchdate); + //初始化一个 SQL 查询语句的变量 sql，并创建一个 Object[] 数组，将学号 sno 和考勤日期 spunchdate 存放到数组中。这个数组将作为 SQL 查询的参数。 String sql = null; Object[] objects = {sno, spunchdate}; //查询是否存在此人 - sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?"; + sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?";//构建一个 SQL 查询语句，查询 stupunchin 表中是否存在该学号和考勤日期的记录。调用 DeptAdminDao.findTotalCount 方法执行查询并返回计数值 count。 int count = DeptAdminDao.findTotalCount(sql, objects); - if (count > 0) { //有则继续操作 - //删除stupunchin中的该信息 + if (count > 0) { //如果查询结果中存在记录（即 count 大于 0），则继续执行删除操作。 + //构建一个 SQL 删除语句，从 stupunchin 表中删除指定学号和考勤日期的记录。调用 DeptAdminDao.executeUpdate 方法执行删除操作，并输出受影响的行数 num1，以确认是否成功删除。 sql = "delete from stupunchin where sno = ? and spunchdate = ?"; int num1 = DeptAdminDao.executeUpdate(sql, objects); System.out.println(num1); + //如果删除成功，使用 RequestDispatcher 将请求转发到 /DeptQueryStuPunchByPageServlet，并传递一些分页和查询参数（如当前页、每页行数、学生姓名、班级、考勤日期等）。这将使用户看到更新后的学生考勤记录列表。 req.getRequestDispatcher("/DeptQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&spunchdate=").forward(req, resp); }else { - req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); + req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);//如果查询结果中没有找到该记录（即 count 为 0），则表示该学号和考勤日期的记录不存在，使用 RequestDispatcher 转发请求到一个页面（noexistdataofdelete.jsp），提示用户该数据不存在。 } - } + }//重写 doPost 方法。因为该 Servlet 处理删除操作时是基于 GET 请求的，所以 doPost 方法直接调用 doGet 方法，这样无论是 GET 请求还是 POST 请求都会执行相同的逻辑。2121212 + //重写 doPost 方法。因为该 Servlet 处理删除操作时是基于 GET 请求的，所以 doPost 方法直接调用 doGet 方法，这样无论是 GET 请求还是 POST 请求都会执行相同的逻辑。 @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req, resp); diff --git a/src/com/controller/deptadmin/DeptDeleteStuPunchServlet1.java b/src/com/controller/deptadmin/DeptDeleteStuPunchServlet1.java index 4b9edba..eab695c 100644 --- a/src/com/controller/deptadmin/DeptDeleteStuPunchServlet1.java +++ b/src/com/controller/deptadmin/DeptDeleteStuPunchServlet1.java @@ -1,67 +1,106 @@ package com.controller.deptadmin; +// 声明该类所在的包名为 com.controller.deptadmin，用于组织和管理代码结构 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类可能包含与数据库交互的方法 import javax.servlet.ServletException; +// 导入 Servlet 异常类，用于处理 Servlet 操作过程中可能出现的异常 import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将该类标记为一个 Servlet 并指定其访问路径 import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，这是所有 Servlet 类的基类，用于处理 HTTP 请求 import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息 import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息 import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户会话，存储用户相关的信息 import java.io.IOException; +// 导入 IOException 类，用于处理输入输出操作过程中可能出现的异常 @WebServlet("/DeptDeleteStuPunchServlet1") +// 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /DeptDeleteStuPunchServlet1 + public class DeptDeleteStuPunchServlet1 extends HttpServlet { + // 定义一个名为 DeptDeleteStuPunchServlet1 的类，继承自 HttpServlet 类，使其成为一个 Servlet @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 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" 的参数值，并将其赋值给字符串变量 sno String spunchdate = req.getParameter("spunchdate"); + // 从请求中获取名为 "spunchdate" 的参数值，并将其赋值给字符串变量 spunchdate System.out.println(sno); + // 在控制台打印 sno 的值，用于调试 System.out.println(spunchdate); + // 在控制台打印 spunchdate 的值，用于调试 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则创建一个新的会话 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值 // String sno = (String) session.getAttribute("sno"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值 String belong = (String) session.getAttribute("belong"); - + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong //字符串转为日期类型 // Date spunchdate1 = new Date(spunchdate); + // 注释掉的代码，原本用于将 spunchdate 字符串转换为 Date 类型 //或 // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); // Date spunchdate1 = ft.format(spunchdate); + // 注释掉的代码，原本用于使用 SimpleDateFormat 将 spunchdate 字符串按照 "yyyy-MM-dd" 格式转换为 Date 类型 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 语句，初始值为 null Object[] objects = {sno, spunchdate, belong}; + // 创建一个 Object 类型的数组 objects，用于存储 SQL 语句中的参数值 //查询是否存在此人 sql = "select count(*) as num from student s,stupunchin sp where s.sno = sp.sno and s.sno = ? and sp.spunchdate = ? and s.sdept = ?"; + // 定义一个 SQL 查询语句，用于查询满足条件的记录数量 int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行 SQL 查询并返回满足条件的记录数量 Object[] objects1 = {sno, spunchdate}; + // 创建一个新的 Object 类型的数组 objects1，用于存储删除操作的 SQL 语句中的参数值 if (count > 0) { //有则继续操作 + // 如果查询结果的记录数量大于 0，说明存在满足条件的记录 //删除stupunchin中的该信息 sql = "delete from stupunchin where sno = ? and spunchdate = ?"; + // 定义一个 SQL 删除语句，用于删除 stupunchin 表中满足条件的记录 int num1 = DeptAdminDao.executeUpdate(sql, objects1); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行 SQL 删除操作并返回受影响的记录数量 System.out.println(num1); + // 在控制台打印受影响的记录数量，用于调试 req.getRequestDispatcher("/DeptQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&spunchdate=").forward(req, resp); + // 将请求转发到 /DeptQueryStuPunchByPageServlet 页面，并传递相应的参数 }else { req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); + // 如果查询结果的记录数量为 0，说明不存在满足条件的记录，将请求转发到 /view/alluse/noexistdataofdelete.jsp 页面 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 POST 请求 doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即 POST 请求和 GET 请求的处理逻辑相同 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptDeleteStuServlet.java b/src/com/controller/deptadmin/DeptDeleteStuServlet.java index 4fb4449..3998d7d 100644 --- a/src/com/controller/deptadmin/DeptDeleteStuServlet.java +++ b/src/com/controller/deptadmin/DeptDeleteStuServlet.java @@ -1,59 +1,115 @@ package com.controller.deptadmin; +// 声明该类所属的包名为 com.controller.deptadmin，包名通常用于组织和管理代码，避免命名冲突 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，这个类可能包含了与数据库交互的方法，如查询、插入、更新和删除等操作 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 类，这个类一般用于封装 JDBC（Java Database Connectivity）操作，如数据库连接的获取和关闭等 import javax.servlet.ServletException; +// 导入 Servlet 异常类，用于处理 Servlet 操作过程中可能出现的异常情况 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将当前类标记为一个 Servlet，并指定其访问路径 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，用于处理 HTTP 请求 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息，包括请求参数、请求头、请求方法等 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息，包括响应状态码、响应头、响应体等 + import java.io.IOException; +// 导入输入输出异常类，用于处理在输入输出操作（如文件读写、网络传输等）过程中可能出现的异常 + import java.sql.ResultSet; +// 导入 ResultSet 类，它用于表示数据库查询结果集，可通过它遍历查询结果中的每一行数据 + import java.sql.SQLException; +// 导入 SQL 异常类，用于处理与数据库交互过程中可能出现的 SQL 相关异常 + import java.util.ArrayList; +// 导入 ArrayList 类，它是 Java 集合框架中的一种动态数组，可用于存储和操作一组对象 + import java.util.Iterator; +// 导入 Iterator 接口，它提供了一种遍历集合元素的方式 @WebServlet("/DeptDeleteStuServlet") +// 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /DeptDeleteStuServlet，客户端可以通过该路径访问这个 Servlet + public class DeptDeleteStuServlet extends HttpServlet { + // 定义一个名为 DeptDeleteStuServlet 的类，继承自 HttpServlet 类，使其成为一个 Servlet @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 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，告诉客户端返回的是 HTML 格式的内容 String sno = req.getParameter("sno"); + // 从 HTTP 请求中获取名为 "sno" 的参数值，并将其赋值给字符串变量 sno，sno 可能代表学生编号 System.out.println(sno); + // 在控制台打印 sno 的值，用于调试目的 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 语句，初始值为 null + Object[] objects = {sno}; + // 创建一个 Object 类型的数组 objects，将 sno 作为唯一元素存储在数组中，这个数组将用于 SQL 语句的参数绑定 //查询是否存在此人 sql = "select count(*) as num from student where sno = ?"; + // 定义一个 SQL 查询语句，用于查询 student 表中 sno 等于传入参数的记录数量，使用占位符 ? 表示参数 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询，并将查询结果（记录数量）赋值给整数变量 count if (count > 0) { //有则继续操作 + // 如果查询到的记录数量大于 0，说明数据库中存在该学生的记录 + //删除stupunchin中的该导游信息 sql = "delete from stupunchin where sno = ?"; + // 定义一个 SQL 删除语句，用于删除 stupunchin 表中 sno 等于传入参数的记录 + int num1 = DeptAdminDao.executeUpdate(sql, objects); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句，并将受影响的记录数量赋值给整数变量 num1 + System.out.println(num1); + // 在控制台打印受影响的记录数量，用于调试目的 //删除student表中该导游信息 sql = "delete from student where sno = ?"; + // 定义一个 SQL 删除语句，用于删除 student 表中 sno 等于传入参数的记录 + int num2 = DeptAdminDao.executeUpdate(sql, objects); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句，并将受影响的记录数量赋值给整数变量 num2 + System.out.println(num2); + // 在控制台打印受影响的记录数量，用于调试目的 req.getRequestDispatcher("/DeptQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&specialty=").forward(req, resp); - }else { + // 将请求转发到 /DeptQueryStuByPageServlet 页面，并传递相应的参数，用于重新查询学生信息并显示在页面上 + + } else { req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); + // 如果查询到的记录数量为 0，说明数据库中不存在该学生的记录，将请求转发到 /view/alluse/noexistdataofdelete.jsp 页面，提示用户无数据可删除 } - } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 HTTP POST 请求 doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptDeleteStuServlet1.java b/src/com/controller/deptadmin/DeptDeleteStuServlet1.java index fdc3a70..9aee6b0 100644 --- a/src/com/controller/deptadmin/DeptDeleteStuServlet1.java +++ b/src/com/controller/deptadmin/DeptDeleteStuServlet1.java @@ -1,64 +1,121 @@ package com.controller.deptadmin; +// 声明该类所在的包，用于组织和管理代码，将相关功能的类放在同一个包中，方便维护和查找。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常包含与数据库交互的方法，比如查询、插入、更新和删除等操作。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 操作出现异常时会抛出该异常。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将一个类标记为 Servlet 并指定其访问路径。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，用于处理 HTTP 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息，例如请求参数、请求头、请求方法等。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息，例如响应状态码、响应头、响应体等。 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户会话，存储用户在一次会话期间的相关信息。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出操作（如文件读写、网络传输等）出现异常时会抛出该异常。 @WebServlet("/DeptDeleteStuServlet1") +// 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /DeptDeleteStuServlet1，客户端可以通过这个路径访问该 Servlet。 + public class DeptDeleteStuServlet1 extends HttpServlet { + // 定义一个名为 DeptDeleteStuServlet1 的类，继承自 HttpServlet 类，使其成为一个 Servlet。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 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，告诉客户端返回的是 HTML 格式的内容。 String sno = req.getParameter("sno"); + // 从 HTTP 请求中获取名为 "sno" 的参数值，并将其赋值给字符串变量 sno，通常 "sno" 可能代表学生编号。 System.out.println(sno); + // 在控制台打印 sno 的值，用于调试目的，方便开发人员查看接收到的参数。 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值。 + // String sno = (String) session.getAttribute("sno"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值，这里注释掉避免与前面已定义的 sno 变量冲突。 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong，通常 "belong" 可能代表学生所属的部门。 System.out.println(belong); + // 在控制台打印 belong 的值，用于调试目的，方便开发人员查看从会话中获取的部门信息。 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 语句，初始值为 null。 + Object[] objects = {sno, belong}; + // 创建一个 Object 类型的数组 objects，将 sno 和 belong 作为元素存储在数组中，这个数组将用于 SQL 语句的参数绑定。 //查询是否存在此人 sql = "select count(*) as num from student where sno = ? and sdept = ?"; + // 定义一个 SQL 查询语句，用于查询 student 表中学生编号为 sno 且所属部门为 belong 的记录数量，使用占位符 ? 表示参数。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询，并将查询结果（记录数量）赋值给整数变量 count。 Object[] objects1 = {sno}; + // 创建一个新的 Object 类型的数组 objects1，只包含 sno 作为元素，用于后续删除操作的 SQL 语句参数绑定。 + if (count > 0) { //有则继续操作 + // 如果查询到的记录数量大于 0，说明数据库中存在符合条件的学生记录。 + //删除stupunchin中的该导游信息 sql = "delete from stupunchin where sno = ?"; + // 定义一个 SQL 删除语句，用于删除 stupunchin 表中学生编号为 sno 的记录。 + int num1 = DeptAdminDao.executeUpdate(sql, objects1); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句，并将受影响的记录数量赋值给整数变量 num1。 + System.out.println(num1); + // 在控制台打印受影响的记录数量，用于调试目的，方便开发人员查看删除操作的结果。 //删除student表中该导游信息 sql = "delete from student where sno = ?"; + // 定义一个 SQL 删除语句，用于删除 student 表中学生编号为 sno 的记录。 + int num2 = DeptAdminDao.executeUpdate(sql, objects1); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句，并将受影响的记录数量赋值给整数变量 num2。 + System.out.println(num2); + // 在控制台打印受影响的记录数量，用于调试目的，方便开发人员查看删除操作的结果。 req.getRequestDispatcher("/DeptQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&specialty=").forward(req, resp); - }else { + // 将请求转发到 /DeptQueryStuByPageServlet 页面，并传递相应的参数，用于重新查询学生信息并显示在页面上，实现页面刷新。 + } else { req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); + // 如果查询到的记录数量为 0，说明数据库中不存在符合条件的学生记录，将请求转发到 /view/alluse/noexistdataofdelete.jsp 页面，提示用户无数据可删除。 } - } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 HTTP POST 请求。 doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptDeleteTeaPunchServlet.java b/src/com/controller/deptadmin/DeptDeleteTeaPunchServlet.java index 37c797c..3b3bbeb 100644 --- a/src/com/controller/deptadmin/DeptDeleteTeaPunchServlet.java +++ b/src/com/controller/deptadmin/DeptDeleteTeaPunchServlet.java @@ -1,64 +1,113 @@ package com.controller.deptadmin; +// 声明该类所属的包名为 com.controller.deptadmin，包用于组织和管理代码，使代码结构更清晰，便于维护和查找相关类。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类一般封装了与数据库交互的方法，如执行查询、更新、删除等操作，方便在本 Servlet 中进行数据库操作。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 操作过程中出现异常时，会抛出该异常，以便进行异常处理。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将当前类标记为一个 Servlet，并指定其访问路径，方便客户端通过该路径访问此 Servlet。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本功能和方法。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息，包括请求参数、请求头、请求方法等，方便在 Servlet 中获取和处理这些信息。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息，如响应状态码、响应头、响应体等，可对响应内容进行设置和输出。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出操作（如网络传输、文件读写等）出现异常时会抛出该异常，以便进行相应处理。 @WebServlet("/DeptDeleteTeaPunchServlet") +// 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /DeptDeleteTeaPunchServlet，客户端可通过此路径访问该 Servlet 来执行相应功能。 + public class DeptDeleteTeaPunchServlet extends HttpServlet { + // 定义一个名为 DeptDeleteTeaPunchServlet 的类，继承自 HttpServlet 类，使其成为一个 Servlet，可处理 HTTP 请求。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 HTTP GET 请求。该方法接收 HttpServletRequest 和 HttpServletResponse 对象作为参数，同时可能抛出 ServletException 和 IOException 异常。 req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF - 8，确保能够正确处理包含中文等特殊字符的请求参数。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF - 8，保证返回给客户端的内容能正确显示中文等特殊字符。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF - 8，告知客户端返回的是 HTML 格式的内容。 //获取请求参数 String tnodate = req.getParameter("tnodate"); + // 从 HTTP 请求中获取名为 "tnodate" 的参数值，并将其赋值给字符串变量 tnodate。该参数可能包含教师编号和打卡日期，且两者以逗号分隔。 System.out.println(tnodate); + // 在控制台打印 tnodate 的值，用于调试，方便开发人员查看接收到的参数内容。 //分离两个参数,用日期和学号来删除 String[] params = tnodate.split(","); + // 使用 split 方法将 tnodate 字符串按逗号分隔成一个字符串数组 params，方便后续分别获取教师编号和打卡日期。 + String tno = params[0]; + // 将数组 params 的第一个元素赋值给字符串变量 tno，代表教师编号。 + String tpunchdate = params[1]; + // 将数组 params 的第二个元素赋值给字符串变量 tpunchdate，代表教师的打卡日期。 System.out.println(tno); System.out.println(tpunchdate); + // 在控制台分别打印 tno 和 tpunchdate 的值，用于调试，方便开发人员确认分离后的参数是否正确。 //字符串转为日期类型 // Date spunchdate1 = new Date(spunchdate); + // 注释掉的代码，原本用于将字符串类型的日期转换为 Date 类型，但此处未实际使用。 + //或 // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); // Date spunchdate1 = ft.format(spunchdate); + // 注释掉的代码，提供了另一种将字符串按 "yyyy - MM - dd" 格式转换为 Date 类型的方式，同样未在当前代码中使用。 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 语句，初始值设为 null。 + Object[] objects = {tno, tpunchdate}; + // 创建一个 Object 类型的数组 objects，将 tno 和 tpunchdate 作为元素存储在数组中，后续用于 SQL 语句的参数绑定。 //查询是否存在此人 sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?"; + // 定义一个 SQL 查询语句，用于查询 teapunchin 表中教师编号为 tno 且打卡日期为 tpunchdate 的记录数量，使用占位符 ? 表示参数。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句，并将查询结果（符合条件的记录数量）赋值给整数变量 count。 if (count > 0) { //有则继续操作 + // 如果查询到的记录数量大于 0，说明数据库中存在该教师在指定日期的打卡记录。 + //删除stupunchin中的该信息 sql = "delete from teapunchin where tno = ? and tpunchdate = ?"; + // 定义一个 SQL 删除语句，用于删除 teapunchin 表中教师编号为 tno 且打卡日期为 tpunchdate 的记录。 + int num1 = DeptAdminDao.executeUpdate(sql, objects); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句，并将受影响的记录数量赋值给整数变量 num1。 + System.out.println(num1); + // 在控制台打印受影响的记录数量，用于调试，方便开发人员确认删除操作是否成功以及删除的记录数量。 req.getRequestDispatcher("/DeptQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tpunchdate=").forward(req, resp); - }else { + // 将请求转发到 /DeptQueryTeaPunchByPageServlet 页面，并传递相应的参数，用于重新查询教师打卡信息并显示在页面上，实现页面刷新。 + } else { req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); + // 如果查询到的记录数量为 0，说明数据库中不存在该教师在指定日期的打卡记录，将请求转发到 /view/alluse/noexistdataofdelete.jsp 页面，提示用户无数据可删除。 } - } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 HTTP POST 请求。 doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptDeleteTeaPunchServlet1.java b/src/com/controller/deptadmin/DeptDeleteTeaPunchServlet1.java index 10352ab..523c1af 100644 --- a/src/com/controller/deptadmin/DeptDeleteTeaPunchServlet1.java +++ b/src/com/controller/deptadmin/DeptDeleteTeaPunchServlet1.java @@ -1,67 +1,124 @@ package com.controller.deptadmin; +// 声明该类所在的包为 com.controller.deptadmin，用于对代码进行组织和管理，方便维护和查找相关类 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常包含与数据库交互的方法，如执行 SQL 查询、插入、更新、删除等操作 import javax.servlet.ServletException; +// 导入 Servlet 异常类，用于处理在 Servlet 操作过程中可能出现的异常情况 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将当前类标记为一个 Servlet，并指定其访问路径 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本方法和结构 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息，例如请求参数、请求头、请求方法等 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息，包括响应状态码、响应头、响应体等 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户会话，存储用户在会话期间的相关信息，如登录状态、用户信息等 + import java.io.IOException; +// 导入输入输出异常类，用于处理在输入输出操作（如文件读写、网络传输等）过程中可能出现的异常情况 @WebServlet("/DeptDeleteTeaPunchServlet1") +// 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /DeptDeleteTeaPunchServlet1，客户端可以通过这个路径访问该 Servlet + public class DeptDeleteTeaPunchServlet1 extends HttpServlet { + // 定义一个名为 DeptDeleteTeaPunchServlet1 的类，继承自 HttpServlet 类，使其成为一个能够处理 HTTP 请求的 Servlet @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 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，告知客户端返回的是 HTML 格式的内容 //获取请求参数 String tno = req.getParameter("tno"); + // 从 HTTP 请求中获取名为 "tno" 的参数值，并将其赋值给字符串变量 tno，这里 tno 可能代表教师编号 + String tpunchdate = req.getParameter("tpunchdate"); + // 从 HTTP 请求中获取名为 "tpunchdate" 的参数值，并将其赋值给字符串变量 tpunchdate，这里 tpunchdate 可能代表教师打卡日期 System.out.println(tno); + // 在控制台打印 tno 的值，用于调试，方便开发人员查看接收到的教师编号参数 + System.out.println(tpunchdate); + // 在控制台打印 tpunchdate 的值，用于调试，方便开发人员查看接收到的教师打卡日期参数 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值，这里未使用 + // String sno = (String) session.getAttribute("sno"); - String belong = (String) session.getAttribute("belong"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值，这里未使用，且可能与其他变量重复定义有冲突 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong，这里 belong 可能代表所属部门等信息 //字符串转为日期类型 // Date spunchdate1 = new Date(spunchdate); + // 注释掉的代码，原本用于将字符串类型的日期转换为 Date 类型，但此处未实际使用 + //或 // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); // Date spunchdate1 = ft.format(spunchdate); + // 注释掉的代码，提供了另一种将字符串按 "yyyy-MM-dd" 格式转换为 Date 类型的方式，同样未在当前代码中使用 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 语句，初始值设为 null + Object[] objects = {tno, tpunchdate, belong}; + // 创建一个 Object 类型的数组 objects，将 tno、tpunchdate 和 belong 作为元素存储在数组中，用于后续 SQL 语句的参数绑定 //查询是否存在此人 sql = "select count(*) as num from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ? and t.tdept = ?"; + // 定义一个 SQL 查询语句，用于查询 teacher 表和 teapunchin 表中符合条件（教师编号、打卡日期和所属部门）的记录数量，使用占位符? 表示参数 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句，并将查询结果（符合条件的记录数量）赋值给整数变量 count Object[] objects1 = {tno, tpunchdate}; + // 创建一个新的 Object 类型的数组 objects1，只包含 tno 和 tpunchdate 作为元素，用于后续删除操作的 SQL 语句参数绑定 + if (count > 0) { //有则继续操作 + // 如果查询到的记录数量大于 0，说明数据库中存在符合条件的教师打卡记录 + //删除stupunchin中的该信息 sql = "delete from teapunchin where tno = ? and tpunchdate = ?"; + // 定义一个 SQL 删除语句，用于删除 teapunchin 表中教师编号为 tno 且打卡日期为 tpunchdate 的记录 + int num1 = DeptAdminDao.executeUpdate(sql, objects1); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句，并将受影响的记录数量赋值给整数变量 num1 + System.out.println(num1); + // 在控制台打印受影响的记录数量，用于调试，方便开发人员确认删除操作是否成功以及删除的记录数量 req.getRequestDispatcher("/DeptQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tpunchdate=").forward(req, resp); - }else { + // 将请求转发到 /DeptQueryTeaPunchByPageServlet 页面，并传递相应的参数，用于重新查询教师打卡信息并显示在页面上，实现页面刷新 + } else { req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); + // 如果查询到的记录数量为 0，说明数据库中不存在符合条件的教师打卡记录，将请求转发到 /view/alluse/noexistdataofdelete.jsp 页面，提示用户无数据可删除 } - } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 HTTP POST 请求 doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptDeleteTeaServlet.java b/src/com/controller/deptadmin/DeptDeleteTeaServlet.java index e003fcd..419aac7 100644 --- a/src/com/controller/deptadmin/DeptDeleteTeaServlet.java +++ b/src/com/controller/deptadmin/DeptDeleteTeaServlet.java @@ -1,54 +1,122 @@ package com.controller.deptadmin; +// 声明该类所在的包为 com.controller.deptadmin，包是 Java 中组织代码的一种方式， +// 可以将相关的类放在同一个包下，便于管理和维护，避免命名冲突。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的方法， +// 如查询、插入、更新和删除等操作，在本 Servlet 中会使用这些方法来操作数据库。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在执行过程中出现异常时，会抛出该异常， +// 用于统一处理 Servlet 相关的异常情况。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是 Java Servlet 3.0 引入的注解， +// 用于将一个普通的 Java 类标记为 Servlet，并指定其访问路径。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类， +// 提供了处理 HTTP 请求的基本方法和结构，我们的类继承它以实现 Servlet 功能。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等，方便在 Servlet 中获取和处理这些信息。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等，可以对响应进行设置和输出。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出操作（如网络传输、文件读写等）时， +// 可能会出现异常，使用该类进行异常处理。 @WebServlet("/DeptDeleteTeaServlet") +// 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /DeptDeleteTeaServlet， +// 客户端可以通过该路径向此 Servlet 发送请求。 + public class DeptDeleteTeaServlet extends HttpServlet { + // 定义一个名为 DeptDeleteTeaServlet 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 HTTP GET 请求。 + // 该方法接收 HttpServletRequest 和 HttpServletResponse 对象作为参数， + // 并可能抛出 ServletException 和 IOException 异常。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保能够正确处理包含中文等特殊字符的请求参数。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能正确显示中文等特殊字符。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容。 String tno = req.getParameter("tno"); + // 从 HTTP 请求中获取名为 "tno" 的参数值，并将其赋值给字符串变量 tno， + // 这里 tno 可能代表教师编号。 System.out.println(tno); + // 在控制台打印 tno 的值，用于调试，方便开发人员查看接收到的参数。 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 语句，初始值设为 null。 + Object[] objects = {tno}; + // 创建一个 Object 类型的数组 objects，将 tno 作为唯一元素存储在数组中， + // 后续会将该数组作为参数传递给数据库操作方法。 - //查询是否存在此人 + // 查询是否存在此人 sql = "select count(*) as num from teacher where tno = ?"; + // 定义一个 SQL 查询语句，用于查询 teacher 表中教师编号为 tno 的记录数量， + // 使用占位符 ? 表示参数，可防止 SQL 注入。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句， + // 并将查询结果（符合条件的记录数量）赋值给整数变量 count。 + + if (count > 0) { // 有则继续操作 + // 如果查询到的记录数量大于 0，说明数据库中存在该教师的记录。 - if (count > 0) { //有则继续操作 - //删除stupunchin中的该导游信息 + // 删除 teapunchin 中的该教师信息 sql = "delete from teapunchin where tno = ?"; + // 定义一个 SQL 删除语句，用于删除 teapunchin 表中教师编号为 tno 的记录。 + int num1 = DeptAdminDao.executeUpdate(sql, objects); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句， + // 并将受影响的记录数量赋值给整数变量 num1。 + System.out.println(num1); + // 在控制台打印受影响的记录数量，用于调试，查看删除操作是否成功。 - //删除student表中该导游信息 + // 删除 teacher 表中该教师信息 sql = "delete from teacher where tno = ?"; + // 定义一个 SQL 删除语句，用于删除 teacher 表中教师编号为 tno 的记录。 + int num2 = DeptAdminDao.executeUpdate(sql, objects); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句， + // 并将受影响的记录数量赋值给整数变量 num2。 + System.out.println(num2); + // 在控制台打印受影响的记录数量，用于调试，查看删除操作是否成功。 req.getRequestDispatcher("/DeptQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tsex=").forward(req, resp); - }else { + // 将请求转发到 /DeptQueryTeaByPageServlet 页面，并传递相应的参数， + // 用于重新查询教师信息并显示在页面上，实现页面刷新。 + } else { req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); + // 如果查询到的记录数量为 0，说明数据库中不存在该教师的记录， + // 将请求转发到 /view/alluse/noexistdataofdelete.jsp 页面，提示用户无数据可删除。 } - } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 HTTP POST 请求。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptDeleteTeaServlet1.java b/src/com/controller/deptadmin/DeptDeleteTeaServlet1.java index eb4eac3..956aa71 100644 --- a/src/com/controller/deptadmin/DeptDeleteTeaServlet1.java +++ b/src/com/controller/deptadmin/DeptDeleteTeaServlet1.java @@ -1,65 +1,170 @@ package com.controller.deptadmin; +// 声明该类所在的包为 com.controller.deptadmin，包用于对相关类进行组织和管理，方便代码的维护和查找， +// 同时避免不同类之间的命名冲突，有助于构建清晰的项目结构。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，这个类通常封装了与数据库交互的操作方法， +// 比如执行 SQL 查询语句、插入数据、更新数据以及删除数据等功能，后续代码会使用这些方法来操作数据库。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现错误或异常情况时， +// 如请求处理失败、资源加载错误等，会抛出 ServletException 异常，以便进行相应的异常处理。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是用于将一个普通的 Java 类标记为 Servlet 的注解， +// 通过该注解可以指定 Servlet 的访问路径，方便客户端通过 URL 来访问该 Servlet。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法， +// 我们定义的 Servlet 类需要继承 HttpServlet 类才能具备处理 HTTP 请求的能力。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，它用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容，Servlet 可以通过该类获取客户端的请求数据。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，它用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等，Servlet 可以通过该类设置并返回响应数据给客户端。 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户的会话状态，能够在用户的多次请求之间存储和共享数据， +// 例如用户的登录信息、购物车内容等。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出操作（如文件读写、网络传输等）时，如果出现错误， +// 会抛出 IOException 异常，以便进行异常处理和错误恢复。 @WebServlet("/DeptDeleteTeaServlet1") +// 使用 WebServlet 注解将 DeptDeleteTeaServlet1 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptDeleteTeaServlet1，客户端可以通过这个路径向该 Servlet 发送请求。 + public class DeptDeleteTeaServlet1 extends HttpServlet { + // 定义一个名为 DeptDeleteTeaServlet1 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端的 GET 和 POST 请求。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法用于处理客户端发送的 HTTP GET 请求。 + // 方法接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并可能抛出 ServletException 和 IOException 异常，以处理请求过程中可能出现的错误。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的正确解析。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容，以便客户端正确解析和显示响应。 String tno = req.getParameter("tno"); + // 从 HTTP 请求中获取名为 "tno" 的参数值，并将其赋值给字符串变量 tno， + // 这里的 tno 可能代表教师的编号，用于后续的数据库操作和业务逻辑处理。 System.out.println(tno); + // 在控制台打印 tno 的值，用于调试目的，方便开发人员查看接收到的教师编号参数是否正确， + // 以便及时发现和解决问题。 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。 + // 通过会话对象可以存储和获取用户在会话期间的相关信息，如用户的登录状态、权限等。 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值， + // 但在当前代码中未被使用，可能是根据实际需求进行了调整或暂时不需要该功能。 + // String sno = (String) session.getAttribute("sno"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值， + // 同样在当前代码中未被使用，可能是后续功能的预留或不再需要该属性值。 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong， + // 这里的 belong 可能代表教师所属的部门等信息，用于后续的数据库查询条件。 System.out.println(belong); - + // 在控制台打印 belong 的值，用于调试目的，方便开发人员查看从会话中获取的部门信息是否正确， + // 帮助进行问题排查和代码调试。 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 语句，初始值设为 null， + // 后续会根据业务需求动态构建和赋值 SQL 语句。 + Object[] objects = {tno, belong}; + // 创建一个 Object 类型的数组 objects，将 tno 和 belong 作为元素存储在数组中， + // 这个数组将作为参数传递给数据库操作方法，用于绑定 SQL 语句中的占位符。 //查询是否存在此人 sql = "select count(*) as num from teacher where tno = ? and tdept = ?"; + // 定义一个 SQL 查询语句，用于查询 teacher 表中教师编号为 tno 且所属部门为 belong（通过 tdept 字段匹配）的记录数量。 + // 使用占位符 ? 表示参数，这种方式可以提高 SQL 语句的安全性，防止 SQL 注入攻击。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句， + // 并将查询结果（符合条件的记录数量）赋值给整数变量 count， + // 用于判断数据库中是否存在符合条件的教师记录。 Object[] objects1 = {tno}; + // 创建一个新的 Object 类型的数组 objects1，只包含 tno 作为元素， + // 这个数组将用于后续的删除操作，作为 SQL 语句的参数。 + if (count > 0) { //有则继续操作 - //删除stupunchin中的该导游信息 + // 如果查询到的记录数量 count 大于 0，说明数据库中存在符合条件的教师记录， + // 可以继续进行后续的删除操作。 + + //删除teapunchin中的该导游信息 sql = "delete from teapunchin where tno = ?"; + // 定义一个 SQL 删除语句，用于删除 teapunchin 表中教师编号为 tno 的记录， + // 这里的 tno 作为删除条件，指定要删除的具体记录。 + int num1 = DeptAdminDao.executeUpdate(sql, objects1); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句， + // 并将受影响的记录数量赋值给整数变量 num1， + // 用于判断删除操作是否成功以及影响的记录数量。 + System.out.println(num1); + // 在控制台打印受影响的记录数量 num1，用于调试目的， + // 方便开发人员查看删除 teapunchin 表中记录的操作是否成功， + // 以及确认删除的记录数量是否符合预期。 - //删除student表中该导游信息 + //删除teacher表中该导游信息 sql = "delete from teacher where tno = ?"; + // 定义一个 SQL 删除语句，用于删除 teacher 表中教师编号为 tno 的记录， + // 同样以 tno 作为删除条件，将该教师的记录从 teacher 表中移除。 + int num2 = DeptAdminDao.executeUpdate(sql, objects1); + // 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句， + // 并将受影响的记录数量赋值给整数变量 num2， + // 用于判断删除 teacher 表中记录的操作是否成功。 + System.out.println(num2); + // 在控制台打印受影响的记录数量 num2，用于调试目的， + // 方便开发人员查看删除 teacher 表中记录的操作是否成功， + // 以及确认删除的记录数量是否符合预期。 req.getRequestDispatcher("/DeptQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tsex=").forward(req, resp); - }else { + // 将请求转发到 /DeptQueryTeaByPageServlet 页面，并传递相应的参数， + // 当前页码 currentPage 为 1，每页显示行数 rows 为 7，教师编号 tno、教师姓名 tname、教师性别 tsex 为空。 + // 这样在删除操作完成后，会跳转到查询教师信息的页面，展示更新后的教师列表。 + } else { req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp); + // 如果查询到的记录数量 count 不大于 0，即数据库中不存在符合条件的教师记录， + // 则将请求转发到 /view/alluse/noexistdataofdelete.jsp 页面， + // 该页面用于提示用户没有可删除的数据，给用户一个明确的反馈。 } - } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，该方法用于处理客户端发送的 HTTP POST 请求。 + // 方法接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并可能抛出 ServletException 和 IOException 异常，以处理请求过程中可能出现的错误。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同， + // 这样可以避免重复编写相似的代码，提高代码的复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptQueryStuByIdServlet.java b/src/com/controller/deptadmin/DeptQueryStuByIdServlet.java index 70f4a54..cdeba2b 100644 --- a/src/com/controller/deptadmin/DeptQueryStuByIdServlet.java +++ b/src/com/controller/deptadmin/DeptQueryStuByIdServlet.java @@ -1,70 +1,196 @@ package com.controller.deptadmin; +// 声明该类所属的包为 com.controller.deptadmin，包机制用于对相关类进行组织管理， +// 便于代码的维护和查找，避免类名冲突，同时也有助于构建清晰的项目结构， +// 使得同一包下的类在逻辑上具有相关性。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的各种操作方法， +// 例如执行 SQL 查询语句（如 select）、插入数据（insert）、更新数据（update）以及删除数据（delete）等操作。 +// 在后续代码中，会使用该类的方法来实现对数据库中数据的查询和修改等功能。 + import com.entity.Student; +// 导入自定义的 Student 实体类，该类用于封装学生的相关信息， +// 例如学生编号（sno）、学生姓名（sname）、性别（ssex）等。 +// 在本 Servlet 中，会通过从数据库查询到的数据来实例化 Student 对象，并将其传递到后续的页面。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，一般来说，这个类会包含与 JDBC（Java Database Connectivity） +// 相关的通用工具方法，比如获取数据库连接、关闭数据库连接、处理结果集等操作， +// 以简化数据库操作的流程，提高代码的可维护性和复用性。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现异常情况时， +// 例如请求处理失败、资源加载错误、内部逻辑错误等，会抛出 ServletException 异常， +// 以便进行相应的异常处理和错误恢复，确保系统的稳定性和可靠性。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，它是 Java EE 中用于将普通的 Java 类标记为 Servlet 的注解。 +// 通过该注解可以方便地指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet， +// 从而实现与服务器的交互。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法。 +// 我们定义的 Servlet 类需要继承 HttpServlet 类，从而获得处理 HTTP 请求的能力， +// 能够响应客户端发送的 GET 和 POST 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容。Servlet 可以通过这个类获取客户端传递的各种数据， +// 以便根据这些数据进行相应的业务逻辑处理。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等。Servlet 可以利用这个类来设置并返回给客户端相应的响应数据， +// 以满足客户端的需求。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出相关的操作（如网络数据传输、文件读写等）时， +// 如果出现错误，就会抛出 IOException 异常，以便进行相应的错误处理， +// 保证系统在面对异常情况时能够做出合理的响应。 + import java.sql.ResultSet; +// 导入 ResultSet 类，它用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据， +// 以便进行进一步的处理和分析。 @WebServlet("/DeptQueryStuByIdServlet") +// 使用 WebServlet 注解将 DeptQueryStuByIdServlet 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptQueryStuByIdServlet，这样客户端就可以通过这个路径向该 Servlet 发送请求， +// 从而触发该 Servlet 中的业务逻辑处理。 + public class DeptQueryStuByIdServlet extends HttpServlet { + // 定义一个名为 DeptQueryStuByIdServlet 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端发送的 GET 和 POST 请求， + // 并实现根据学生编号查询学生信息的功能。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法专门用于处理客户端发送的 HTTP GET 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确性和完整性。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 使得客户端能够准确地解析和展示响应信息，避免出现乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容，并且按照 UTF-8 编码进行解析和显示， + // 以便客户端能够正确处理和展示响应数据。 String sno = req.getParameter("sno"); + // 从 HTTP 请求中获取名为 "sno" 的参数值，并将其赋值给字符串变量 sno。 + // 这里的 sno 代表学生编号，用于后续根据该编号查询学生的相关信息。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 + Object[] objects = {sno}; + // 创建一个 Object 类型的数组 objects，将 sno 作为唯一元素存储在数组中， + // 这个数组将作为参数传递给数据库操作方法，用于绑定 SQL 语句中的占位符， + // 以提高 SQL 语句的安全性和灵活性。 //查询是否存在此人 sql = "select count(*) as num from student where sno = ?"; + // 定义一个 SQL 查询语句，用于查询 student 表中学生编号为 sno 的记录数量。 + // 使用占位符? 来提高 SQL 语句的安全性，防止 SQL 注入攻击， + // 并将查询结果的数量别名为 num。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句， + // 并将查询结果（符合条件的记录数量）赋值给整数变量 count， + // 通过这个数量可以判断数据库中是否存在该学生的记录。 if (count > 0){ //有则继续操作 + // 如果查询到的记录数量 count 大于 0，说明数据库中存在该学生的记录， + // 可以继续执行后续的查询和处理操作。 + sql = "select * from student where sno = ?"; + // 定义一个新的 SQL 查询语句，用于查询 student 表中学生编号为 sno 的所有字段信息。 + // 同样使用占位符? 来确保 SQL 语句的安全性。 + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，执行上述 SQL 查询语句， + // 并将查询结果存储在 ResultSet 对象 resultSet 中，以便后续遍历和处理。 + Student student = new Student(); + // 创建一个 Student 对象 student，用于存储从数据库中查询到的学生信息。 try { while (resultSet.next()){ + // 遍历 ResultSet 对象，每次移动到下一行数据。 + // 如果有数据（resultSet.next() 返回 true），则将当前行的数据赋值给 student 对象的相应属性。 + student.setSno(resultSet.getString("sno")); + // 将查询结果中 "sno" 字段的值（学生编号）设置为 student 对象的 sno 属性。 + student.setSname(resultSet.getString("sname")); + // 将查询结果中 "sname" 字段的值（学生姓名）设置为 student 对象的 sname 属性。 + student.setSsex(resultSet.getString("ssex")); + // 将查询结果中 "ssex" 字段的值（学生性别）设置为 student 对象的 ssex 属性。 + student.setSage(resultSet.getInt("sage")); + // 将查询结果中 "sage" 字段的值（学生年龄）设置为 student 对象的 sage 属性， + // 并将其转换为整数类型。 + student.setSclass(resultSet.getString("sclass")); + // 将查询结果中 "sclass" 字段的值（学生班级）设置为 student 对象的 sclass 属性。 + student.setSpecialty(resultSet.getString("specialty")); + // 将查询结果中 "specialty" 字段的值（学生专业）设置为 student 对象的 specialty 属性。 + student.setSdept(resultSet.getString("sdept")); + // 将查询结果中 "sdept" 字段的值（学生所属系部）设置为 student 对象的 sdept 属性。 + student.setSphone(resultSet.getString("sphone")); + // 将查询结果中 "sphone" 字段的值（学生电话号码）设置为 student 对象的 sphone 属性。 + student.setSpsw(resultSet.getString("spsw")); + // 将查询结果中 "spsw" 字段的值（学生密码）设置为 student 对象的 spsw 属性。 } } catch (Exception e) { e.printStackTrace(); + // 如果在遍历和设置属性的过程中出现异常，打印异常堆栈信息， + // 以便开发人员进行调试和错误排查。 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，都要关闭 ResultSet 对象，释放数据库资源， + // 调用 JDBCUtils 类的 close 方法来关闭 resultSet。 } System.out.println(student.getSsex()); + // 在控制台打印 student 对象的 ssex 属性值，用于调试目的， + // 方便开发人员查看查询到的学生性别信息是否正确。 req.setAttribute("student", student); + // 将 student 对象设置为请求的属性，键为 "student"， + // 这样在后续的页面中可以通过这个键获取到 student 对象，从而展示学生信息。 req.getRequestDispatcher("/view/deptadmin/alterstu.jsp").forward(req, resp); + // 将请求转发到 /view/deptadmin/alterstu.jsp 页面， + // 并将包含学生信息的 student 对象传递到该页面，以便进行学生信息的修改操作。 }else { req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp); + // 如果查询到的记录数量 count 不大于 0，即数据库中不存在该学生的记录， + // 将请求转发到 /view/alluse/noexistdataofalter.jsp 页面， + // 该页面用于提示用户没有可修改的数据，给用户一个明确的反馈。 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，该方法用于处理客户端发送的 HTTP POST 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同， + // 这样可以避免重复编写相似的代码，提高代码的复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptQueryStuByIdServlet1.java b/src/com/controller/deptadmin/DeptQueryStuByIdServlet1.java index 0c2c5e0..9f4ced2 100644 --- a/src/com/controller/deptadmin/DeptQueryStuByIdServlet1.java +++ b/src/com/controller/deptadmin/DeptQueryStuByIdServlet1.java @@ -1,79 +1,219 @@ package com.controller.deptadmin; +// 声明该类所在的包为 com.controller.deptadmin，包用于对相关的类进行组织和管理， +// 便于代码的维护和查找，避免类名冲突，在项目中有助于构建清晰的代码结构。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的操作方法， +// 例如执行 SQL 查询、插入、更新和删除等操作。后续代码会使用这些方法来操作数据库， +// 以实现根据学生编号查询学生信息的功能。 + import com.entity.Student; +// 导入自定义的 Student 实体类，用于封装学生的各种信息， +// 如学生编号（sno）、姓名（sname）、性别（ssex）等。在后续代码中， +// 将从数据库查询到的学生信息存储到 Student 对象中，并传递到其他页面。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，一般包含与 JDBC（Java Database Connectivity） +// 相关的通用方法，如获取数据库连接、关闭连接、处理结果集等， +// 用于简化数据库操作流程，提高代码的可维护性和复用性。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现异常情况时， +// 如请求处理失败、资源加载错误等，会抛出 ServletException 异常， +// 以便进行相应的异常处理和错误恢复。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是 Java EE 中用于将普通 Java 类标记为 Servlet 的注解。 +// 通过该注解可以指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet， +// 从而实现与服务器的交互。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法。 +// 我们定义的 Servlet 类继承 HttpServlet 类，从而获得处理 HTTP 请求的能力， +// 能够响应客户端发送的 GET 和 POST 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容。Servlet 可以通过这个类获取客户端传递的数据， +// 以便根据这些数据进行相应的业务逻辑处理。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等。Servlet 可以利用这个类来设置并返回给客户端相应的响应数据， +// 以满足客户端的需求。 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户的会话状态，能够在用户的多次请求之间存储和共享数据， +// 例如用户的登录信息、权限信息等。在本 Servlet 中，将使用它来获取用户所属部门等会话信息。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出相关的操作（如网络数据传输、文件读写等）时， +// 如果出现错误，就会抛出 IOException 异常，以便进行相应的错误处理。 + import java.sql.ResultSet; +// 导入 ResultSet 类，用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据， +// 以便进行进一步的处理和分析。 @WebServlet("/DeptQueryStuByIdServlet1") +// 使用 WebServlet 注解将 DeptQueryStuByIdServlet1 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptQueryStuByIdServlet1，这样客户端就可以通过这个路径向该 Servlet 发送请求， +// 从而触发该 Servlet 中的业务逻辑处理。 + public class DeptQueryStuByIdServlet1 extends HttpServlet { + // 定义一个名为 DeptQueryStuByIdServlet1 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端发送的 GET 和 POST 请求， + // 并实现根据学生编号和所属部门查询学生信息的功能。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法专门用于处理客户端发送的 HTTP GET 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确性。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容，并且按照 UTF-8 编码进行解析和显示， + // 以便客户端能够正确处理和展示响应数据。 String sno = req.getParameter("sno"); + // 从 HTTP 请求中获取名为 "sno" 的参数值，并将其赋值给字符串变量 sno。 + // 这里的 sno 代表学生编号，用于后续根据该编号查询学生的相关信息。 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。 + // 通过会话对象可以存储和获取用户在会话期间的相关信息，如用户所属部门等。 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值， + // 但在当前代码中未被使用，可能是根据实际需求进行了调整或暂时不需要该功能。 + // String sno = (String) session.getAttribute("sno"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值， + // 这里的变量名与前面获取请求参数的 sno 重复，且在当前代码中未被使用， + // 可能是后续功能的预留或不再需要该属性值。 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong。 + // 这里的 belong 可能代表用户所属的部门信息，用于后续的数据库查询条件。 System.out.println(belong); + // 在控制台打印 belong 的值，用于调试目的，方便开发人员查看从会话中获取的部门信息是否正确， + // 帮助进行问题排查和代码调试。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 + Object[] objects = {sno, belong}; + // 创建一个 Object 类型的数组 objects，将 sno 和 belong 作为元素存储在数组中， + // 这个数组将作为参数传递给数据库操作方法，用于绑定 SQL 语句中的占位符， + // 以提高 SQL 语句的安全性和灵活性。 //查询是否存在此人 sql = "select count(*) as num from student where sno = ? and sdept = ?"; + // 定义一个 SQL 查询语句，用于查询 student 表中学生编号为 sno 且所属部门为 belong（通过 sdept 字段匹配）的记录数量。 + // 使用占位符? 来提高 SQL 语句的安全性，防止 SQL 注入攻击，并将查询结果的数量别名为 num。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句， + // 并将查询结果（符合条件的记录数量）赋值给整数变量 count， + // 通过这个数量可以判断数据库中是否存在该学生的记录。 if (count > 0){ //有则继续操作 + // 如果查询到的记录数量 count 大于 0，说明数据库中存在该学生的记录， + // 可以继续执行后续的查询和处理操作。 + sql = "select * from student where sno = ? and sdept = ?"; + // 定义一个新的 SQL 查询语句，用于查询 student 表中学生编号为 sno 且所属部门为 belong 的所有字段信息。 + // 同样使用占位符? 来确保 SQL 语句的安全性。 + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，执行上述 SQL 查询语句， + // 并将查询结果存储在 ResultSet 对象 resultSet 中，以便后续遍历和处理。 + Student student = new Student(); + // 创建一个 Student 对象 student，用于存储从数据库中查询到的学生信息。 try { while (resultSet.next()){ + // 遍历 ResultSet 对象，每次移动到下一行数据。 + // 如果有数据（resultSet.next() 返回 true），则将当前行的数据赋值给 student 对象的相应属性。 + student.setSno(resultSet.getString("sno")); + // 将查询结果中 "sno" 字段的值（学生编号）设置为 student 对象的 sno 属性。 + student.setSname(resultSet.getString("sname")); + // 将查询结果中 "sname" 字段的值（学生姓名）设置为 student 对象的 sname 属性。 + student.setSsex(resultSet.getString("ssex")); + // 将查询结果中 "ssex" 字段的值（学生性别）设置为 student 对象的 ssex 属性。 + student.setSage(resultSet.getInt("sage")); + // 将查询结果中 "sage" 字段的值（学生年龄）设置为 student 对象的 sage 属性， + // 并将其转换为整数类型。 + student.setSclass(resultSet.getString("sclass")); + // 将查询结果中 "sclass" 字段的值（学生班级）设置为 student 对象的 sclass 属性。 + student.setSpecialty(resultSet.getString("specialty")); + // 将查询结果中 "specialty" 字段的值（学生专业）设置为 student 对象的 specialty 属性。 + student.setSdept(resultSet.getString("sdept")); + // 将查询结果中 "sdept" 字段的值（学生所属系部）设置为 student 对象的 sdept 属性。 + student.setSphone(resultSet.getString("sphone")); + // 将查询结果中 "sphone" 字段的值（学生电话号码）设置为 student 对象的 sphone 属性。 + student.setSpsw(resultSet.getString("spsw")); + // 将查询结果中 "spsw" 字段的值（学生密码）设置为 student 对象的 spsw 属性。 } } catch (Exception e) { e.printStackTrace(); + // 如果在遍历和设置属性的过程中出现异常，打印异常堆栈信息， + // 以便开发人员进行调试和错误排查。 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，都要关闭 ResultSet 对象，释放数据库资源， + // 调用 JDBCUtils 类的 close 方法来关闭 resultSet。 } System.out.println(student.getSsex()); + // 在控制台打印 student 对象的 ssex 属性值，用于调试目的， + // 方便开发人员查看查询到的学生性别信息是否正确。 req.setAttribute("student", student); + // 将 student 对象设置为请求的属性，键为 "student"， + // 这样在后续的页面中可以通过这个键获取到 student 对象，从而展示学生信息。 req.getRequestDispatcher("/view/deptadmin/alterstu.jsp").forward(req, resp); + // 将请求转发到 /view/deptadmin/alterstu.jsp 页面， + // 并将包含学生信息的 student 对象传递到该页面，以便进行学生信息的修改操作。 }else { req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp); + // 如果查询到的记录数量 count 不大于 0，即数据库中不存在该学生的记录， + // 将请求转发到 /view/alluse/noexistdataofalter.jsp 页面， + // 该页面用于提示用户没有可修改的数据，给用户一个明确的反馈。 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，该方法用于处理客户端发送的 HTTP POST 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同， + // 这样可以避免重复编写相似的代码，提高代码的复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptQueryStuByPageServlet.java b/src/com/controller/deptadmin/DeptQueryStuByPageServlet.java index 1817741..b8c75ee 100644 --- a/src/com/controller/deptadmin/DeptQueryStuByPageServlet.java +++ b/src/com/controller/deptadmin/DeptQueryStuByPageServlet.java @@ -1,187 +1,280 @@ package com.controller.deptadmin; +// 声明该类所属的包为 com.controller.deptadmin，包机制用于组织和管理相关的类， +// 方便代码的维护和复用，避免类名冲突，在项目中有助于构建清晰的代码结构， +// 使同一包下的类在逻辑上具有相关性，便于管理和查找。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的操作方法， +// 例如执行 SQL 查询语句（如 select）、插入数据（insert）、更新数据（update）以及删除数据（delete）等操作。 +// 在后续代码中，会使用该类的方法来实现对数据库中数据的查询和统计等功能，以支持学生信息的分页查询业务。 + import com.dao.StuDao; +// 导入自定义的 StuDao 类，它可能专门用于处理与学生相关的数据访问操作， +// 例如根据特定条件查询学生信息、分页查询学生信息等。在本 Servlet 中，会调用该类的方法来获取学生数据。 + import com.entity.PageBean; +// 导入自定义的 PageBean 实体类，用于封装分页相关的信息， +// 例如当前页码、每页显示的记录数、总记录数、总页数以及数据列表等。 +// 在本 Servlet 中，将使用 PageBean 对象来管理和传递分页查询的结果。 + import com.entity.StuPunch; +// 导入自定义的 StuPunch 实体类，虽然在当前代码中暂未看到对该类的实际使用， +// 但它可能用于封装学生打卡相关的信息，在项目的其他部分可能会有相关的业务逻辑与之关联。 + import com.entity.Student; +// 导入自定义的 Student 实体类，用于封装学生的各种信息， +// 如学生编号（sno）、学生姓名（sname）、性别（ssex）、年龄（sage）、班级（sclass）、 +// 专业（specialty）、所属系部（sdept）、电话号码（sphone）、密码（spsw）等。 +// 在本 Servlet 中，将从数据库查询到的学生信息存储到 Student 对象中，并添加到数据列表中。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，一般包含与 JDBC（Java Database Connectivity） +// 相关的通用方法，如获取数据库连接、关闭数据库连接、处理结果集等， +// 用于简化数据库操作流程，提高代码的可维护性和复用性。在本 Servlet 中， +// 会使用该类的方法来关闭数据库查询结果集（ResultSet），释放数据库资源。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现异常情况时， +// 例如请求处理失败、资源加载错误、内部逻辑错误等，会抛出 ServletException 异常， +// 以便进行相应的异常处理和错误恢复，确保系统的稳定性和可靠性。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，它是 Java EE 中用于将普通的 Java 类标记为 Servlet 的注解。 +// 通过该注解可以方便地指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet， +// 从而实现与服务器的交互。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法。 +// 我们定义的 Servlet 类需要继承 HttpServlet 类，从而获得处理 HTTP 请求的能力， +// 能够响应客户端发送的 GET 和 POST 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容。Servlet 可以通过这个类获取客户端传递的各种数据， +// 以便根据这些数据进行相应的业务逻辑处理，如获取学生信息查询的条件参数和分页参数等。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等。Servlet 可以利用这个类来设置并返回给客户端相应的响应数据， +// 以满足客户端的需求，如设置响应的字符编码和内容类型，以及将查询结果页面转发给客户端等。 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户的会话状态，能够在用户的多次请求之间存储和共享数据， +// 例如用户的登录信息、权限信息、所属部门等。在本 Servlet 中，将使用它来获取用户所属部门等会话信息， +// 作为学生信息查询的条件之一。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出相关的操作（如网络数据传输、文件读写等）时， +// 如果出现错误，就会抛出 IOException 异常，以便进行相应的错误处理， +// 保证系统在面对异常情况时能够做出合理的响应。 + import java.net.URL; +// 导入 URL 类，用于表示统一资源定位符（URL），在网络编程中用于定位和访问网络资源。 +// 在本 Servlet 中暂未看到对该类的实际使用，可能在项目的其他部分会有相关的功能需求。 + import java.net.URLDecoder; +// 导入 URLDecoder 类，用于对 URL 编码的字符串进行解码操作。 +// 在本 Servlet 中暂未看到对该类的实际使用，可能在处理含有 URL 编码参数的请求时会用到。 + import java.net.URLEncoder; +// 导入 URLEncoder 类，用于对字符串进行 URL 编码操作。 +// 在本 Servlet 中暂未看到对该类的实际使用，可能在构建含有参数的 URL 时会用到。 + import java.sql.ResultSet; +// 导入 ResultSet 类，用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据， +// 以便进行进一步的处理和分析，如将查询到的学生信息存储到 Student 对象中。 + import java.util.ArrayList; +// 导入 ArrayList 类，它是 Java 集合框架中的一种动态数组实现。 +// 可以用来存储和管理一组对象，并且可以根据需要动态地增加或减少元素数量。 +// 在本 Servlet 中，将使用 ArrayList 来存储从数据库查询到的学生对象（Student）。 + import java.util.HashMap; +// 导入 HashMap 类，它是 Java 集合框架中的一种键值对存储结构， +// 用于存储和管理具有映射关系的数据。在本 Servlet 中暂未看到对该类的实际使用， +// 可能在项目的其他部分会有相关的功能需求。 + import java.util.Map; +// 导入 Map 接口，它定义了一种键值对的映射关系，HashMap 等类实现了该接口。 +// 在本 Servlet 中暂未看到对该接口的实际使用，可能在处理需要键值对存储和操作的数据时会用到。 @WebServlet("/DeptQueryStuByPageServlet") +// 使用 WebServlet 注解将 DeptQueryStuByPageServlet 类标记为一个 Servlet， +//并指定其访问路径为 /DeptQueryStuByPageServlet，这样客户端就可以通过这个路径向该 Servlet 发送请求， +//从而触发该 Servlet 中的业务逻辑处理，实现学生信息的分页查询功能。 + public class DeptQueryStuByPageServlet extends HttpServlet { + // 定义一个名为 DeptQueryStuByPageServlet 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端发送的 GET 和 POST 请求， + // 并实现根据条件分页查询学生信息的功能。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法专门用于处理客户端发送的 HTTP GET 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确性和完整性。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容，并且按照 UTF-8 编码进行解析和显示， + // 以便客户端能够正确处理和展示响应数据。 //获取请求参数 String sname = req.getParameter("sname"); + // 从 HTTP 请求中获取名为 "sname" 的参数值，并将其赋值给字符串变量 sname。 + // 这里的 sname 代表学生姓名，用于后续根据学生姓名进行模糊查询学生信息。 + String sclass = req.getParameter("sclass"); - String specialty = req.getParameter("specialty"); + // 从 HTTP 请求中获取名为 "sclass" 的参数值，并将其赋值给字符串变量 sclass。 + // 这里的 sclass 代表学生班级，用于后续根据学生班级进行模糊查询学生信息。 + String specialty = req.getParameter("specialty"); + // 从 HTTP 请求中获取名为 "specialty" 的参数值，并将其赋值给字符串变量 specialty。 + // 这里的 specialty 代表学生专业，用于后续根据学生专业进行模糊查询学生信息。 //如果传入的参数为null，则置为空字符串 if (sname == null){ sname = ""; } + // 如果获取到的学生姓名参数 sname 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 + if (sclass == null){ sclass = ""; } + // 如果获取到的学生班级参数 sclass 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 + if (specialty == null){ specialty = ""; } + // 如果获取到的学生专业参数 specialty 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 //变为like查询所需的字符串参数 String sname1 = "%" + sname + "%"; + // 将学生姓名参数 sname 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 sname 的前后添加通配符 "%"，以便查询包含该姓名片段的学生记录。 + String sclass1 = "%" + sclass + "%"; + // 将学生班级参数 sclass 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 sclass 的前后添加通配符 "%"，以便查询包含该班级片段的学生记录。 + String specialty1 = "%" + specialty + "%"; + // 将学生专业参数 specialty 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 specialty 的前后添加通配符 "%"，以便查询包含该专业片段的学生记录。 //设置请求的属性参数，后面需要用 req.setAttribute("sname",sname); + // 将原始的学生姓名参数 sname 设置为请求的属性，键为 "sname"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 + req.setAttribute("sclass", sclass); + // 将原始的学生班级参数 sclass 设置为请求的属性，键为 "sclass"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 + req.setAttribute("specialty",specialty); + // 将原始的学生专业参数 specialty 设置为请求的属性，键为 "specialty"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 System.out.println(sname1); + // 在控制台打印转换后的学生姓名模糊查询参数 sname1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 + System.out.println(sclass1); - System.out.println(specialty1); + // 在控制台打印转换后的学生班级模糊查询参数 sclass1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 + System.out.println(specialty1); + // 在控制台打印转换后的学生专业模糊查询参数 specialty1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。 + // 通过会话对象可以存储和获取用户在会话期间的相关信息，如用户所属部门等。 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值， + // 但在当前代码中未被使用，可能是根据实际需求进行了调整或暂时不需要该功能。 + // String sno = (String) session.getAttribute("sno"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值， + // 这里的变量名与前面获取请求参数的 sname、sclass、specialty 等不同， + // 且在当前代码中未被使用，可能是后续功能的预留或不再需要该属性值。 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong。 + // 这里的 belong 可能代表用户所属的部门信息，用于后续的数据库查询条件， + // 确保查询的学生信息是该部门下的学生。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 // System.out.println(userName); + // 注释掉的代码，原本用于在控制台打印从会话中获取的用户名 userName， + // 但由于该变量未被使用，所以此打印语句也被注释掉。 + // System.out.println(sno); + // 注释掉的代码，原本用于在控制台打印从会话中获取的学生编号 sno， + // 但由于该变量未被使用，所以此打印语句也被注释掉。 + System.out.println(belong); + // 在控制台打印从会话中获取的用户所属部门信息 belong，用于调试目的， + // 方便开发人员查看获取到的部门信息是否正确。 + System.out.println("hdghghjg"); + // 在控制台打印字符串 "hdghghjg"，可能是开发人员用于调试或标记的输出内容， + // 可以帮助确定代码执行到的位置。 String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码 + // 从 HTTP 请求中获取名为 "currentPage" 的参数值，并将其赋值给字符串变量 currentPage。 + // 这里的 currentPage 代表当前页码，用于实现分页查询功能。 + String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数 + // 从 HTTP 请求中获取名为 "rows" 的参数值，并将其赋值给字符串变量 rows。 + // 这里的 rows 代表每页显示的记录数，用于实现分页查询功能。 //如果未设请求参数，此处自动设置参数为第一页 if (currentPage == null || "".equals(currentPage)){ currentPage = "1"; } + // 如果获取到的当前页码参数 currentPage 为 null 或空字符串，则将其设置为 "1"， + // 即默认显示第一页的学生信息，确保分页查询的正常进行。 //如果没有设置rows的请求参数，此处自动设置 if (rows == null || "".equals(rows)){ rows = "7"; } + // 如果获取到的每页显示行数参数 rows 为 null 或空字符串，则将其设置为 "7"， + // 即默认每页显示 7 条学生记录，确保分页查询的正常进行。 //获取条件查询的参数 int currentPage1 = Integer.parseInt(currentPage); + // 将字符串类型的当前页码参数 currentPage 转换为整数类型，并赋值给变量 currentPage1， + // 以便后续进行计算和处理。 + int rows1 = Integer.parseInt(rows); + // 将字符串类型的每页显示行数参数 rows 转换为整数类型，并赋值给变量 rows1， + // 以便后续进行计算和处理。 //如果当前页数小于1，则设置当前页数为1 if (currentPage1 <= 0){ currentPage1 = 1; } + // 如果转换后的当前页码 currentPage1 小于等于 0，则将其设置为 1， + // 确保当前页码是有效的，避免出现负数或零页码的情况。 //设置StuPunch类的对象类型 PageBean pageBean = new PageBean(); - - //设置当前页码 - pageBean.setCurrentPage(currentPage1); - - //设置每页的记录数 - pageBean.setRows(rows1); - - - sql = " select count(*) as num from student where sname like ? and sclass like ? and specialty like ? and sdept = ?"; - Object[] objects = {sname1, sclass1, specialty1, belong}; - - - /*sql = " select count(*) as num from student where sdept = ?"; - Object[] objects = {belong};*/ - - - //计算总记录数，并设置 - int totalCount = DeptAdminDao.findTotalCount(sql, objects); - System.out.println(totalCount); - pageBean.setTotalCount(totalCount); - - if (totalCount > 0){ - //计算总页码，并设置 - int totalPage = (totalCount % rows1) == 0 ? totalCount/rows1 : (totalCount/rows1 + 1); - pageBean.setTotalPage(totalPage); - - //如果当前页数大于总页数 - if (currentPage1 > pageBean.getTotalPage()){ - currentPage1 = pageBean.getTotalPage(); - //重新设置当前页码 - pageBean.setCurrentPage(currentPage1); - } - - //计算开始的记录和list对象集合，并设置 - int start = (currentPage1 - 1) * rows1; - - - sql = "select * from student where sname like ? and sclass like ? and specialty like ? and sdept = ? limit ?, ?"; - Object[] objects1 = {sname1, sclass1, specialty1, belong, start, rows1}; - - - /*sql = "select * from student where sdept = ? limit ?, ?"; - Object[] objects1 = {belong, start, rows1};*/ - - ResultSet resultSet = StuDao.QureyInfoByPage(sql, objects1); - ArrayList stuArrayList = new ArrayList(); - - try { - while (resultSet.next()){ - Student student = new Student(); - student.setSno(resultSet.getString("sno")); - student.setSname(resultSet.getString("sname")); - student.setSsex(resultSet.getString("ssex")); - student.setSage(resultSet.getInt("sage")); - student.setSclass(resultSet.getString("sclass")); - student.setSpecialty(resultSet.getString("specialty")); - student.setSdept(resultSet.getString("sdept")); - student.setSphone(resultSet.getString("sphone")); - student.setSpsw(resultSet.getString("spsw")); - stuArrayList.add(student); - } - } catch (Exception e) { - e.printStackTrace(); - }finally { - JDBCUtils.close(resultSet); - } - pageBean.setArrayList(stuArrayList); - - System.out.println(stuArrayList); - System.out.println(pageBean); - - req.setAttribute("pageBean", pageBean); - - req.getRequestDispatcher("/view/deptadmin/stuinfolist.jsp").forward(req, resp); - - }else { - req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp); - } - } - - @Override - protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { - this.doGet(req, resp); - } -} + // 创建一个 PageBean 对象 pageBean，泛型类型为 Student，用于封装分页查询的相关信息， \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptQueryStuPunchByIdServlet.java b/src/com/controller/deptadmin/DeptQueryStuPunchByIdServlet.java index cc7946c..c8f2788 100644 --- a/src/com/controller/deptadmin/DeptQueryStuPunchByIdServlet.java +++ b/src/com/controller/deptadmin/DeptQueryStuPunchByIdServlet.java @@ -1,72 +1,192 @@ package com.controller.deptadmin; +// 声明该类所在的包为 com.controller.deptadmin，包机制有助于将相关的类组织在一起， +// 方便代码的管理和维护，避免类名冲突，同时也能体现项目的逻辑结构。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，这个类通常封装了与数据库交互的操作方法， +// 比如执行 SQL 查询、更新、删除等操作，后续代码会使用该类的方法来查询学生打卡信息。 + import com.entity.StuPunch; +// 导入自定义的 StuPunch 实体类，用于封装学生打卡的相关信息， +// 例如打卡日期、是否打卡、体温情况等，在后续代码中会用它来存储从数据库查询到的打卡信息。 + import com.entity.Student; +// 导入自定义的 Student 实体类，该类用于封装学生的基本信息， +// 如学生编号、姓名等，虽然在当前代码中没有直接使用该类的对象进行数据操作， +// 但在 SQL 查询语句中会关联该表以获取学生姓名。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，一般包含了与 JDBC（Java Database Connectivity） +// 相关的通用方法，例如获取数据库连接、关闭数据库连接、处理结果集等， +// 用于简化数据库操作的流程，提高代码的可维护性和复用性。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在执行过程中出现异常情况， +// 如请求处理失败、资源加载错误等，会抛出 ServletException 异常， +// 用于在代码中进行异常处理和错误恢复。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是 Java EE 中用于将普通 Java 类标记为 Servlet 的注解， +// 通过该注解可以指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本结构和方法。 +// 我们定义的 Servlet 类继承它，从而具备处理 HTTP 请求的能力。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容，Servlet 可以通过它获取客户端传递的数据。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等，Servlet 可以利用它设置并返回响应数据给客户端。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出操作（如网络传输、文件读写等）出现错误时， +// 会抛出 IOException 异常，以便进行相应的错误处理。 + import java.sql.ResultSet; +// 导入 ResultSet 类，它用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据。 @WebServlet("/DeptQueryStuPunchByIdServlet") +// 使用 WebServlet 注解将 DeptQueryStuPunchByIdServlet 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptQueryStuPunchByIdServlet，客户端可以通过这个路径向该 Servlet 发送请求。 + public class DeptQueryStuPunchByIdServlet extends HttpServlet { + // 定义一个名为 DeptQueryStuPunchByIdServlet 的类，继承自 HttpServlet 类， + // 使其成为一个能够处理 HTTP 请求的 Servlet，可响应客户端的 GET 和 POST 请求。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 HTTP GET 请求。 + // 该方法接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF - 8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确解析。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF - 8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF - 8， + // 告知客户端返回的是 HTML 格式的内容，以便客户端正确解析和显示响应信息。 //获取请求参数 String sno = req.getParameter("sno"); + // 从 HTTP 请求中获取名为 "sno" 的参数值，该参数代表学生编号， + // 用于后续根据学生编号查询学生打卡信息。 + String spunchdate = req.getParameter("spunchdate"); + // 从 HTTP 请求中获取名为 "spunchdate" 的参数值，该参数代表学生打卡日期， + // 用于后续根据打卡日期查询学生打卡信息。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 + Object[] objects = {sno, spunchdate}; + // 创建一个 Object 类型的数组 objects，将 sno 和 spunchdate 作为元素存储在数组中， + // 这个数组将作为参数传递给数据库操作方法，用于绑定 SQL 语句中的占位符。 //查询是否存在此人 sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?"; + // 定义一个 SQL 查询语句，用于查询 stupunchin 表中，学生编号为 sno 且打卡日期为 spunchdate 的记录数量。 + // 使用占位符 ? 来提高 SQL 语句的安全性，防止 SQL 注入攻击，并将查询结果的数量别名为 num。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句， + // 并将查询结果（符合条件的记录数量）赋值给整数变量 count， + // 通过这个数量可以判断数据库中是否存在该学生在指定日期的打卡记录。 if (count > 0){ //有则继续操作 + // 如果查询到的记录数量 count 大于 0，说明数据库中存在该学生在指定日期的打卡记录， + // 可以继续执行后续的查询和处理操作。 + sql = "select s.sname,sp.* from student s,stupunchin sp where s.sno = sp.sno and sp.sno = ? and sp.spunchdate = ?"; + // 定义一个新的 SQL 查询语句，用于查询 student 表和 stupunchin 表关联后的信息， + // 选取学生姓名（s.sname）和 stupunchin 表的所有字段（sp.*），条件是学生编号匹配且打卡日期匹配。 + // 同样使用占位符 ? 来确保 SQL 语句的安全性。 + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，执行上述 SQL 查询语句， + // 并将查询结果存储在 ResultSet 对象 resultSet 中，以便后续遍历和处理。 + StuPunch stuPunch = new StuPunch(); + // 创建一个 StuPunch 对象 stuPunch，用于存储从数据库中查询到的学生打卡信息。 try { while (resultSet.next()){ + // 遍历 ResultSet 对象，每次移动到下一行数据。 + // 如果有数据（resultSet.next() 返回 true），则将当前行的数据赋值给 stuPunch 对象的相应属性。 + stuPunch.setSno(resultSet.getString("sno")); + // 将查询结果中 "sno" 字段的值（学生编号）设置为 stuPunch 对象的 sno 属性。 + stuPunch.setSname(resultSet.getString("sname")); + // 将查询结果中 "sname" 字段的值（学生姓名）设置为 stuPunch 对象的 sname 属性。 + stuPunch.setSispunch(resultSet.getString("sispunch")); + // 将查询结果中 "sispunch" 字段的值（是否打卡）设置为 stuPunch 对象的 sispunch 属性。 + stuPunch.setSpunchdate(resultSet.getDate("spunchdate")); + // 将查询结果中 "spunchdate" 字段的值（打卡日期）设置为 stuPunch 对象的 spunchdate 属性， + // 并将其转换为 java.sql.Date 类型。 + stuPunch.setSpunchtime(resultSet.getString("spunchtime")); + // 将查询结果中 "spunchtime" 字段的值（打卡时间）设置为 stuPunch 对象的 spunchtime 属性。 + stuPunch.setSishot(resultSet.getString("sishot")); + // 将查询结果中 "sishot" 字段的值（是否发热）设置为 stuPunch 对象的 sishot 属性。 + stuPunch.setSiscough(resultSet.getString("siscough")); + // 将查询结果中 "siscough" 字段的值（是否咳嗽）设置为 stuPunch 对象的 siscough 属性。 + stuPunch.setSisseem(resultSet.getString("sisseem")); + // 将查询结果中 "sisseem" 字段的值（是否有疑似症状）设置为 stuPunch 对象的 sisseem 属性。 + stuPunch.setSisdiagnose(resultSet.getString("sisdiagnose")); + // 将查询结果中 "sisdiagnose" 字段的值（是否确诊）设置为 stuPunch 对象的 sisdiagnose 属性。 + stuPunch.setSstatus(resultSet.getString("sstatus")); + // 将查询结果中 "sstatus" 字段的值（学生状态）设置为 stuPunch 对象的 sstatus 属性。 } } catch (Exception e) { e.printStackTrace(); + // 如果在遍历和设置属性的过程中出现异常，打印异常堆栈信息， + // 以便开发人员进行调试和错误排查。 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，都要关闭 ResultSet 对象，释放数据库资源， + // 调用 JDBCUtils 类的 close 方法来关闭 resultSet。 } req.setAttribute("stuPunch", stuPunch); + // 将 stuPunch 对象设置为请求的属性，键为 "stuPunch"， + // 这样在后续的页面中可以通过这个键获取到 stuPunch 对象，从而展示学生打卡信息。 req.getRequestDispatcher("/view/deptadmin/alterstupunch.jsp").forward(req, resp); + // 将请求转发到 /view/deptadmin/alterstupunch.jsp 页面， + // 并将包含学生打卡信息的 stuPunch 对象传递到该页面，以便进行学生打卡信息的修改操作。 }else { req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp); + // 如果查询到的记录数量 count 不大于 0，即数据库中不存在该学生在指定日期的打卡记录， + // 将请求转发到 /view/alluse/noexistdataofalter.jsp 页面， + // 该页面用于提示用户没有可修改的数据，给用户一个明确的反馈。 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 HTTP POST 请求。 + // 该方法接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同， + // 这样可以避免重复编写相似的代码，提高代码的复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptQueryStuPunchByIdServlet1.java b/src/com/controller/deptadmin/DeptQueryStuPunchByIdServlet1.java index ea52410..b39c1d1 100644 --- a/src/com/controller/deptadmin/DeptQueryStuPunchByIdServlet1.java +++ b/src/com/controller/deptadmin/DeptQueryStuPunchByIdServlet1.java @@ -1,80 +1,222 @@ package com.controller.deptadmin; +// 声明该类所属的包为 com.controller.deptadmin，包机制用于对相关类进行组织和管理， +// 便于代码的维护和查找，避免类名冲突，在项目中有助于构建清晰的代码结构。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的操作方法， +// 例如执行 SQL 查询、插入、更新和删除等操作。后续代码会使用这些方法来查询学生打卡信息。 + import com.entity.StuPunch; +// 导入自定义的 StuPunch 实体类，用于封装学生打卡的相关信息， +// 如学生编号、是否打卡、打卡日期、打卡时间、身体状况等信息，后续将从数据库查询结果中填充这些属性。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，一般包含与 JDBC（Java Database Connectivity） +// 相关的通用方法，如获取数据库连接、关闭连接、处理结果集等， +// 用于简化数据库操作流程，提高代码的可维护性和复用性。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现异常情况时， +// 如请求处理失败、资源加载错误等，会抛出 ServletException 异常， +// 以便进行相应的异常处理和错误恢复。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是 Java EE 中用于将普通 Java 类标记为 Servlet 的注解。 +// 通过该注解可以指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet， +// 从而实现与服务器的交互。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法。 +// 我们定义的 Servlet 类继承 HttpServlet 类，从而获得处理 HTTP 请求的能力， +// 能够响应客户端发送的 GET 和 POST 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容。Servlet 可以通过这个类获取客户端传递的数据， +// 以便根据这些数据进行相应的业务逻辑处理。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等。Servlet 可以利用这个类来设置并返回给客户端相应的响应数据， +// 以满足客户端的需求。 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户的会话状态，能够在用户的多次请求之间存储和共享数据， +// 例如用户的登录信息、权限信息、所属部门等。在本 Servlet 中，将使用它来获取用户所属部门等会话信息。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出相关的操作（如网络数据传输、文件读写等）时， +// 如果出现错误，就会抛出 IOException 异常，以便进行相应的错误处理。 + import java.sql.ResultSet; +// 导入 ResultSet 类，用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据， +// 以便进行进一步的处理和分析。 @WebServlet("/DeptQueryStuPunchByIdServlet1") +// 使用 WebServlet 注解将 DeptQueryStuPunchByIdServlet1 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptQueryStuPunchByIdServlet1，这样客户端就可以通过这个路径向该 Servlet 发送请求， +// 从而触发该 Servlet 中的业务逻辑处理。 + public class DeptQueryStuPunchByIdServlet1 extends HttpServlet { + // 定义一个名为 DeptQueryStuPunchByIdServlet1 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端发送的 GET 和 POST 请求， + // 并实现根据学生编号和打卡日期查询学生打卡信息的功能。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法专门用于处理客户端发送的 HTTP GET 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确性。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容，并且按照 UTF-8 编码进行解析和显示， + // 以便客户端能够正确处理和展示响应数据。 //获取请求参数 String sno = req.getParameter("sno"); + // 从 HTTP 请求中获取名为 "sno" 的参数值，并将其赋值给字符串变量 sno。 + // 这里的 sno 代表学生编号，用于后续根据该编号查询学生的打卡信息。 + String spunchdate = req.getParameter("spunchdate"); + // 从 HTTP 请求中获取名为 "spunchdate" 的参数值，并将其赋值给字符串变量 spunchdate。 + // 这里的 spunchdate 代表学生打卡日期，用于后续根据该日期查询学生的打卡信息。 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。 + // 通过会话对象可以存储和获取用户在会话期间的相关信息，如用户所属部门等。 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值， + // 但在当前代码中未被使用，可能是根据实际需求进行了调整或暂时不需要该功能。 + // String sno = (String) session.getAttribute("sno"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值， + // 这里的变量名与前面获取请求参数的 sno 重复，且在当前代码中未被使用， + // 可能是后续功能的预留或不再需要该属性值。 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong。 + // 这里的 belong 可能代表用户所属的部门信息，用于后续的数据库查询条件。 System.out.println(belong); + // 在控制台打印 belong 的值，用于调试目的，方便开发人员查看从会话中获取的部门信息是否正确， + // 帮助进行问题排查和代码调试。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 + Object[] objects = {sno, spunchdate, belong}; + // 创建一个 Object 类型的数组 objects，将 sno、spunchdate 和 belong 作为元素存储在数组中， + // 这个数组将作为参数传递给数据库操作方法，用于绑定 SQL 语句中的占位符， + // 以提高 SQL 语句的安全性和灵活性。 //查询是否存在此人 sql = "select count(*) as num from student s,stupunchin sp where s.sno = sp.sno and s.sno = ? and sp.spunchdate = ? and s.sdept = ?"; + // 定义一个 SQL 查询语句，用于查询 student 表和 stupunchin 表中，学生编号为 sno、打卡日期为 spunchdate 且学生所属部门为 belong 的记录数量。 + // 使用占位符? 来提高 SQL 语句的安全性，防止 SQL 注入攻击，并将查询结果的数量别名为 num。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句， + // 并将查询结果（符合条件的记录数量）赋值给整数变量 count， + // 通过这个数量可以判断数据库中是否存在该学生在指定日期且属于指定部门的打卡记录。 if (count > 0){ //有则继续操作 + // 如果查询到的记录数量 count 大于 0，说明数据库中存在该学生在指定日期且属于指定部门的打卡记录， + // 可以继续执行后续的查询和处理操作。 + sql = "select s.sname,sp.* from student s,stupunchin sp where s.sno = sp.sno and sp.sno = ? and sp.spunchdate = ? and sdept = ?"; + // 定义一个新的 SQL 查询语句，用于查询 student 表和 stupunchin 表关联后的信息， + // 选取学生姓名（s.sname）和 stupunchin 表的所有字段（sp.*），条件是学生编号匹配、打卡日期匹配且学生所属部门匹配。 + // 同样使用占位符? 来确保 SQL 语句的安全性。 + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，执行上述 SQL 查询语句， + // 并将查询结果存储在 ResultSet 对象 resultSet 中，以便后续遍历和处理。 + StuPunch stuPunch = new StuPunch(); + // 创建一个 StuPunch 对象 stuPunch，用于存储从数据库中查询到的学生打卡信息。 try { while (resultSet.next()){ + // 遍历 ResultSet 对象，每次移动到下一行数据。 + // 如果有数据（resultSet.next() 返回 true），则将当前行的数据赋值给 stuPunch 对象的相应属性。 + stuPunch.setSno(resultSet.getString("sno")); + // 将查询结果中 "sno" 字段的值（学生编号）设置为 stuPunch 对象的 sno 属性。 + stuPunch.setSname(resultSet.getString("sname")); + // 将查询结果中 "sname" 字段的值（学生姓名）设置为 stuPunch 对象的 sname 属性。 + stuPunch.setSispunch(resultSet.getString("sispunch")); + // 将查询结果中 "sispunch" 字段的值（是否打卡）设置为 stuPunch 对象的 sispunch 属性。 + stuPunch.setSpunchdate(resultSet.getDate("spunchdate")); + // 将查询结果中 "spunchdate" 字段的值（打卡日期）设置为 stuPunch 对象的 spunchdate 属性， + // 并将其转换为 java.sql.Date 类型。 + stuPunch.setSpunchtime(resultSet.getString("spunchtime")); + // 将查询结果中 "spunchtime" 字段的值（打卡时间）设置为 stuPunch 对象的 spunchtime 属性。 + stuPunch.setSishot(resultSet.getString("sishot")); + // 将查询结果中 "sishot" 字段的值（是否发热）设置为 stuPunch 对象的 sishot 属性。 + stuPunch.setSiscough(resultSet.getString("siscough")); + // 将查询结果中 "siscough" 字段的值（是否咳嗽）设置为 stuPunch 对象的 siscough 属性。 + stuPunch.setSisseem(resultSet.getString("sisseem")); + // 将查询结果中 "sisseem" 字段的值（是否有疑似症状）设置为 stuPunch 对象的 sisseem 属性。 + stuPunch.setSisdiagnose(resultSet.getString("sisdiagnose")); + // 将查询结果中 "sisdiagnose" 字段的值（是否确诊）设置为 stuPunch 对象的 sisdiagnose 属性。 + stuPunch.setSstatus(resultSet.getString("sstatus")); + // 将查询结果中 "sstatus" 字段的值（学生状态）设置为 stuPunch 对象的 sstatus 属性。 } } catch (Exception e) { e.printStackTrace(); + // 如果在遍历和设置属性的过程中出现异常，打印异常堆栈信息， + // 以便开发人员进行调试和错误排查。 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，都要关闭 ResultSet 对象，释放数据库资源， + // 调用 JDBCUtils 类的 close 方法来关闭 resultSet。 } req.setAttribute("stuPunch", stuPunch); + // 将 stuPunch 对象设置为请求的属性，键为 "stuPunch"， + // 这样在后续的页面中可以通过这个键获取到 stuPunch 对象，从而展示学生打卡信息。 req.getRequestDispatcher("/view/deptadmin/alterstupunch.jsp").forward(req, resp); + // 将请求转发到 /view/deptadmin/alterstupunch.jsp 页面， + // 并将包含学生打卡信息的 stuPunch 对象传递到该页面，以便进行学生打卡信息的修改操作。 }else { req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp); + // 如果查询到的记录数量 count 不大于 0，即数据库中不存在该学生在指定日期且属于指定部门的打卡记录， + // 将请求转发到 /view/alluse/noexistdataofalter.jsp 页面， + // 该页面用于提示用户没有可修改的数据，给用户一个明确的反馈。 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，该方法用于处理客户端发送的 HTTP POST 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同， + // 这样可以避免重复编写相似的代码，提高代码的复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptQueryStuPunchByPageServlet.java b/src/com/controller/deptadmin/DeptQueryStuPunchByPageServlet.java index efdcb24..80e7681 100644 --- a/src/com/controller/deptadmin/DeptQueryStuPunchByPageServlet.java +++ b/src/com/controller/deptadmin/DeptQueryStuPunchByPageServlet.java @@ -1,175 +1,282 @@ package com.controller.deptadmin; +// 声明该类所属的包为 com.controller.deptadmin，包用于对相关的类进行组织和管理， +// 便于代码的维护和查找，避免类名冲突，在项目中有助于构建清晰的代码结构。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的操作方法， +// 例如执行 SQL 查询、插入、更新和删除等操作。后续代码会使用这些方法来实现对数据库中数据的查询和统计等功能， +// 以支持学生打卡信息的分页查询业务。 + import com.dao.StuDao; +// 导入自定义的 StuDao 类，它可能专门用于处理与学生相关的数据访问操作， +// 例如根据特定条件查询学生信息、分页查询学生信息等。在本 Servlet 中，会调用该类的方法来获取学生打卡信息。 + import com.entity.PageBean; +// 导入自定义的 PageBean 实体类，用于封装分页相关的信息， +// 例如当前页码、每页显示的记录数、总记录数、总页数以及数据列表等。 +// 在本 Servlet 中，将使用 PageBean 对象来管理和传递分页查询的结果。 + import com.entity.StuPunch; +// 导入自定义的 StuPunch 实体类，用于封装学生打卡的相关信息， +// 如学生编号、学生姓名、班级、专业、是否打卡、打卡日期、打卡时间、身体状况等信息。 +// 在本 Servlet 中，将从数据库查询到的学生打卡信息存储到 StuPunch 对象中，并添加到数据列表中。 + import com.entity.Student; +// 导入自定义的 Student 实体类，用于封装学生的基本信息， +// 如学生编号、学生姓名、班级、专业、所属系部等。在本 Servlet 中，会与 StuPunch 表关联查询， +// 以获取更全面的学生打卡相关信息。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，一般包含与 JDBC（Java Database Connectivity） +// 相关的通用方法，如获取数据库连接、关闭数据库连接、处理结果集等， +// 用于简化数据库操作流程，提高代码的可维护性和复用性。在本 Servlet 中， +// 会使用该类的方法来关闭数据库查询结果集（ResultSet），释放数据库资源。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现异常情况时， +// 例如请求处理失败、资源加载错误、内部逻辑错误等，会抛出 ServletException 异常， +// 以便进行相应的异常处理和错误恢复，确保系统的稳定性和可靠性。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，它是 Java EE 中用于将普通的 Java 类标记为 Servlet 的注解。 +// 通过该注解可以方便地指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet， +// 从而实现与服务器的交互。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法。 +// 我们定义的 Servlet 类需要继承 HttpServlet 类，从而获得处理 HTTP 请求的能力， +// 能够响应客户端发送的 GET 和 POST 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容。Servlet 可以通过这个类获取客户端传递的各种数据， +// 以便根据这些数据进行相应的业务逻辑处理，如获取学生打卡信息查询的条件参数和分页参数等。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等。Servlet 可以利用这个类来设置并返回给客户端相应的响应数据， +// 以满足客户端的需求，如设置响应的字符编码和内容类型，以及将查询结果页面转发给客户端等。 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户的会话状态，能够在用户的多次请求之间存储和共享数据， +// 例如用户的登录信息、权限信息、所属部门等。在本 Servlet 中，将使用它来获取用户所属部门等会话信息， +// 作为学生打卡信息查询的条件之一。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出相关的操作（如网络数据传输、文件读写等）时， +// 如果出现错误，就会抛出 IOException 异常，以便进行相应的错误处理， +// 保证系统在面对异常情况时能够做出合理的响应。 + import java.sql.ResultSet; +// 导入 ResultSet 类，用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据， +// 以便进行进一步的处理和分析，如将查询到的学生打卡信息存储到 StuPunch 对象中。 + import java.util.ArrayList; +// 导入 ArrayList 类，它是 Java 集合框架中的一种动态数组实现。 +// 可以用来存储和管理一组对象，并且可以根据需要动态地增加或减少元素数量。 +// 在本 Servlet 中，将使用 ArrayList 来存储从数据库查询到的学生打卡对象（StuPunch）。 @WebServlet("/DeptQueryStuPunchByPageServlet") +// 使用 WebServlet 注解将 DeptQueryStuPunchByPageServlet 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptQueryStuPunchByPageServlet，这样客户端就可以通过这个路径向该 Servlet 发送请求， +// 从而触发该 Servlet 中的业务逻辑处理，实现学生打卡信息的分页查询功能。 + public class DeptQueryStuPunchByPageServlet extends HttpServlet { + // 定义一个名为 DeptQueryStuPunchByPageServlet 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端发送的 GET 和 POST 请求， + // 并实现根据条件分页查询学生打卡信息的功能。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法专门用于处理客户端发送的 HTTP GET 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确性和完整性。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容，并且按照 UTF-8 编码进行解析和显示， + // 以便客户端能够正确处理和展示响应数据。 //获取请求参数 String sname = req.getParameter("sname"); + // 从 HTTP 请求中获取名为 "sname" 的参数值，并将其赋值给字符串变量 sname。 + // 这里的 sname 代表学生姓名，用于后续根据学生姓名进行模糊查询学生打卡信息。 + String sclass = req.getParameter("sclass"); + // 从 HTTP 请求中获取名为 "sclass" 的参数值，并将其赋值给字符串变量 sclass。 + // 这里的 sclass 代表学生班级，用于后续根据学生班级进行模糊查询学生打卡信息。 + String spunchdate = req.getParameter("spunchdate"); + // 从 HTTP 请求中获取名为 "spunchdate" 的参数值，并将其赋值给字符串变量 spunchdate。 + // 这里的 spunchdate 代表学生打卡日期，用于后续根据学生打卡日期进行模糊查询学生打卡信息。 System.out.println(sname); + // 在控制台打印学生姓名参数 sname，用于调试目的， + // 方便开发人员查看获取到的参数值是否正确。 + System.out.println(sclass); - System.out.println(spunchdate); + // 在控制台打印学生班级参数 sclass，用于调试目的， + // 方便开发人员查看获取到的参数值是否正确。 + System.out.println(spunchdate); + // 在控制台打印学生打卡日期参数 spunchdate，用于调试目的， + // 方便开发人员查看获取到的参数值是否正确。 //如果传入的参数为null，则置为空字符串 if (sname == null){ sname = ""; } + // 如果获取到的学生姓名参数 sname 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 + if (sclass == null){ sclass = ""; } + // 如果获取到的学生班级参数 sclass 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 + if (spunchdate == null){ spunchdate = ""; } + // 如果获取到的学生打卡日期参数 spunchdate 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 //变为like查询所需的字符串参数 String sname1 = "%" + sname + "%"; + // 将学生姓名参数 sname 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 sname 的前后添加通配符 "%"，以便查询包含该姓名片段的学生打卡记录。 + String sclass1 = "%" + sclass + "%"; + // 将学生班级参数 sclass 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 sclass 的前后添加通配符 "%"，以便查询包含该班级片段的学生打卡记录。 + String spunchdate1 = "%" + spunchdate + "%"; + // 将学生打卡日期参数 spunchdate 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 spunchdate 的前后添加通配符 "%"，以便查询包含该日期片段的学生打卡记录。 //设置请求的属性参数，后面需要用 req.setAttribute("sname",sname); + // 将原始的学生姓名参数 sname 设置为请求的属性，键为 "sname"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 + req.setAttribute("sclass", sclass); + // 将原始的学生班级参数 sclass 设置为请求的属性，键为 "sclass"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 + req.setAttribute("spunchdate",spunchdate); + // 将原始的学生打卡日期参数 spunchdate 设置为请求的属性，键为 "spunchdate"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 System.out.println(sname1); + // 在控制台打印转换后的学生姓名模糊查询参数 sname1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 + System.out.println(sclass1); + // 在控制台打印转换后的学生班级模糊查询参数 sclass1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 + System.out.println(spunchdate1); + // 在控制台打印转换后的学生打卡日期模糊查询参数 spunchdate1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。 + // 通过会话对象可以存储和获取用户在会话期间的相关信息，如用户所属部门等。 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值， + // 但在当前代码中未被使用，可能是根据实际需求进行了调整或暂时不需要该功能。 + // String sno = (String) session.getAttribute("sno"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值， + // 这里的变量名与前面获取请求参数的 sname、sclass、spunchdate 等不同， + // 且在当前代码中未被使用，可能是后续功能的预留或不再需要该属性值。 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong。 + // 这里的 belong 可能代表用户所属的部门信息，用于后续的数据库查询条件， + // 确保查询的学生打卡信息是该部门下的学生的记录。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 // System.out.println(userName); + // 注释掉的代码，原本用于在控制台打印从会话中获取的用户名 userName， + // 但由于该变量未被使用，所以此打印语句也被注释掉。 + // System.out.println(sno); + // 注释掉的代码，原本用于在控制台打印从会话中获取的学生编号 sno， + // 但由于该变量未被使用，所以此打印语句也被注释掉。 + System.out.println(belong); + // 在控制台打印从会话中获取的用户所属部门信息 belong，用于调试目的， + // 方便开发人员查看获取到的部门信息是否正确。 + System.out.println("hdghghjg"); + // 在控制台打印字符串 "hdghghjg"，可能是开发人员用于调试或标记的输出内容， + // 可以帮助确定代码执行到的位置。 String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码 + // 从 HTTP 请求中获取名为 "currentPage" 的参数值，并将其赋值给字符串变量 currentPage。 + // 这里的 currentPage 代表当前页码，用于实现分页查询功能。 + String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数 + // 从 HTTP 请求中获取名为 "rows" 的参数值，并将其赋值给字符串变量 rows。 + // 这里的 rows 代表每页显示的记录数，用于实现分页查询功能。 //如果未设请求参数，此处自动设置参数为第一页 if (currentPage == null || "".equals(currentPage)){ currentPage = "1"; } + // 如果获取到的当前页码参数 currentPage 为 null 或空字符串，则将其设置为 "1"， + // 即默认显示第一页的学生打卡信息，确保分页查询的正常进行。 //如果没有设置rows的请求参数，此处自动设置 if (rows == null || "".equals(rows)){ rows = "7"; } + // 如果获取到的每页显示行数参数 rows 为 null 或空字符串，则将其设置为 "7"， + // 即默认每页显示 7 条学生打卡记录，确保分页查询的正常进行。 //获取条件查询的参数 int currentPage1 = Integer.parseInt(currentPage); + // 将字符串类型的当前页码参数 currentPage 转换为整数类型，并赋值给变量 currentPage1， + // 以便后续进行计算和处理。 + int rows1 = Integer.parseInt(rows); + // 将字符串类型的每页显示行数参数 rows 转换为整数类型，并赋值给变量 rows1， + // 以便后续进行计算和处理。 //如果当前页数小于1，则设置当前页数为1 if (currentPage1 <= 0){ currentPage1 = 1; } + // 如果转换后的当前页码 currentPage1 小于等于 0，则将其设置为 1， + // 确保当前页码是有效的，避免出现负数或零页码的情况。 //设置StuPunch类的对象类型 PageBean pageBean = new PageBean(); + // 创建一个 PageBean 对象 pageBean，泛型类型为 StuPunch，用于封装分页查询学生打卡信息的相关信息， //设置当前页码 pageBean.setCurrentPage(currentPage1); + // 将当前页码 currentPage1 设置到 pageBean 对象中，以便在后续处理中使用。 //设置每页的记录数 pageBean.setRows(rows1); + // 将每页显示的记录数 rows1 设置到 pageBean 对象中，以便在后续处理中使用。 sql = " select count(*) as num from student s, stupunchin sp where s.sno = sp.sno and s.sname like ? and s.sclass like ? and sp.spunchdate like ? and s.sdept = ?"; - Object[] objects = {sname1, sclass1, spunchdate1,belong}; - - //计算总记录数，并设置 - int totalCount = DeptAdminDao.findTotalCount(sql, objects); - System.out.println(totalCount); - pageBean.setTotalCount(totalCount); - - if (totalCount > 0){ - //计算总页码，并设置 - int totalPage = (totalCount % rows1) == 0 ? totalCount/rows1 : (totalCount/rows1 + 1); - pageBean.setTotalPage(totalPage); - - //如果当前页数大于总页数 - if (currentPage1 > pageBean.getTotalPage()){ - currentPage1 = pageBean.getTotalPage(); - //重新设置当前页码 - pageBean.setCurrentPage(currentPage1); - } - - //计算开始的记录和list对象集合，并设置 - int start = (currentPage1 - 1) * rows1; - sql = "select s.sname,s.sclass,s.specialty,sp.* from student s, stupunchin sp where s.sno = sp.sno and s.sname like ? and s.sclass like ? and sp.spunchdate like ? and s.sdept = ? limit ?, ?"; - Object[] objects1 = {sname1, sclass1, spunchdate1, belong, start, rows1}; - - ResultSet resultSet = StuDao.QureyInfoByPage(sql, objects1); - ArrayList stuPunchArrayList = new ArrayList(); - - try { - while (resultSet.next()){ - StuPunch stuPunch = new StuPunch(); - stuPunch.setSno(resultSet.getString("sno")); - stuPunch.setSname(resultSet.getString("sname")); - stuPunch.setSclass(resultSet.getString("sclass")); - stuPunch.setSpecialty(resultSet.getString("specialty")); - stuPunch.setSispunch(resultSet.getString("sispunch")); - stuPunch.setSpunchdate(resultSet.getDate("spunchdate")); - stuPunch.setSpunchtime(resultSet.getString("spunchtime")); - stuPunch.setSishot(resultSet.getString("sishot")); - stuPunch.setSiscough(resultSet.getString("siscough")); - stuPunch.setSisseem(resultSet.getString("sisseem")); - stuPunch.setSisdiagnose(resultSet.getString("sisdiagnose")); - stuPunch.setSstatus(resultSet.getString("sstatus")); - stuPunchArrayList.add(stuPunch); - } - } catch (Exception e) { - e.printStackTrace(); - }finally { - JDBCUtils.close(resultSet); - } - pageBean.setArrayList(stuPunchArrayList); - - System.out.println(stuPunchArrayList); - System.out.println(pageBean); - - req.setAttribute("pageBean", pageBean); - - req.getRequestDispatcher("/view/deptadmin/stupunchlist.jsp").forward(req, resp); - }else { - req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp); - } - } - - @Override - protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { - doGet(req, resp); - } -} + // 定义一个 SQL 查询语句，用于查询 student 表和 stupunchin 表中， + // 满足学生编号关联、学生姓名模糊匹配、学生班级模糊 \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptQueryTeaByIdServlet.java b/src/com/controller/deptadmin/DeptQueryTeaByIdServlet.java index ecee9d8..18a7af0 100644 --- a/src/com/controller/deptadmin/DeptQueryTeaByIdServlet.java +++ b/src/com/controller/deptadmin/DeptQueryTeaByIdServlet.java @@ -1,73 +1,181 @@ package com.controller.deptadmin; +// 声明该类所在的包为 com.controller.deptadmin，包用于组织和管理相关的类， +// 有助于避免类名冲突，同时方便代码的维护和查找，体现了项目的逻辑结构。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的操作方法， +// 如执行 SQL 查询、插入、更新、删除等操作，后续会使用它来查询教师信息。 + import com.entity.Student; +// 导入自定义的 Student 实体类，不过在当前代码中未使用该类，可能是后续扩展功能预留的。 + import com.entity.Teacher; +// 导入自定义的 Teacher 实体类，用于封装教师的相关信息，如教师编号、姓名、性别等， +// 后续会用它来存储从数据库查询到的教师信息。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，一般包含了与 JDBC（Java Database Connectivity） +// 相关的通用方法，例如获取数据库连接、关闭数据库连接、处理结果集等， +// 用于简化数据库操作的流程，提高代码的可维护性和复用性。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在执行过程中出现异常情况， +// 如请求处理失败、资源加载错误等，会抛出 ServletException 异常， +// 用于在代码中进行异常处理和错误恢复。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是 Java EE 中用于将普通 Java 类标记为 Servlet 的注解， +// 通过该注解可以指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本结构和方法。 +// 我们定义的 Servlet 类继承它，从而具备处理 HTTP 请求的能力。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容，Servlet 可以通过它获取客户端传递的数据。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等，Servlet 可以利用它设置并返回响应数据给客户端。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出操作（如网络传输、文件读写等）出现错误时， +// 会抛出 IOException 异常，以便进行相应的错误处理。 + import java.sql.ResultSet; +// 导入 ResultSet 类，它用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据。 @WebServlet("/DeptQueryTeaByIdServlet") +// 使用 WebServlet 注解将 DeptQueryTeaByIdServlet 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptQueryTeaByIdServlet，客户端可以通过这个路径向该 Servlet 发送请求。 + public class DeptQueryTeaByIdServlet extends HttpServlet { + // 定义一个名为 DeptQueryTeaByIdServlet 的类，继承自 HttpServlet 类， + // 使其成为一个能够处理 HTTP 请求的 Servlet，可响应客户端的 GET 和 POST 请求。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 HTTP GET 请求。 + // 该方法接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF - 8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确解析。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF - 8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF - 8， + // 告知客户端返回的是 HTML 格式的内容，以便客户端正确解析和显示响应信息。 String tno = req.getParameter("tno"); + // 从 HTTP 请求中获取名为 "tno" 的参数值，该参数代表教师编号， + // 用于后续根据教师编号查询教师信息。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 + Object[] objects = {tno}; + // 创建一个 Object 类型的数组 objects，将 tno 作为元素存储在数组中， + // 这个数组将作为参数传递给数据库操作方法，用于绑定 SQL 语句中的占位符。 System.out.println(tno); + // 在控制台打印获取到的教师编号 tno，用于调试目的，方便开发人员查看参数值是否正确。 //查询是否存在此人 sql = "select count(*) as num from teacher where tno = ?"; + // 定义一个 SQL 查询语句，用于查询 teacher 表中，教师编号为 tno 的记录数量。 + // 使用占位符 ? 来提高 SQL 语句的安全性，防止 SQL 注入攻击，并将查询结果的数量别名为 num。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句， + // 并将查询结果（符合条件的记录数量）赋值给整数变量 count， + // 通过这个数量可以判断数据库中是否存在该教师编号对应的教师记录。 if (count > 0) { //有则继续操作 + // 如果查询到的记录数量 count 大于 0，说明数据库中存在该教师编号对应的教师记录， + // 可以继续执行后续的查询和处理操作。 + sql = "select * from teacher where tno = ?"; + // 定义一个新的 SQL 查询语句，用于查询 teacher 表中，教师编号为 tno 的所有字段信息。 + // 同样使用占位符 ? 来确保 SQL 语句的安全性。 + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，执行上述 SQL 查询语句， + // 并将查询结果存储在 ResultSet 对象 resultSet 中，以便后续遍历和处理。 + Teacher teacher = new Teacher(); + // 创建一个 Teacher 对象 teacher，用于存储从数据库中查询到的教师信息。 try { while (resultSet.next()){ + // 遍历 ResultSet 对象，每次移动到下一行数据。 + // 如果有数据（resultSet.next() 返回 true），则将当前行的数据赋值给 teacher 对象的相应属性。 + teacher.setTno(resultSet.getString("tno")); + // 将查询结果中 "tno" 字段的值（教师编号）设置为 teacher 对象的 tno 属性。 + teacher.setTname(resultSet.getString("tname")); + // 将查询结果中 "tname" 字段的值（教师姓名）设置为 teacher 对象的 tname 属性。 + teacher.setTsex(resultSet.getString("tsex")); + // 将查询结果中 "tsex" 字段的值（教师性别）设置为 teacher 对象的 tsex 属性。 + teacher.setTage(resultSet.getInt("tage")); + // 将查询结果中 "tage" 字段的值（教师年龄）设置为 teacher 对象的 tage 属性， + // 并将其转换为整数类型。 + teacher.setTdept(resultSet.getString("tdept")); + // 将查询结果中 "tdept" 字段的值（教师所属部门）设置为 teacher 对象的 tdept 属性。 + teacher.setTphone(resultSet.getString("tphone")); + // 将查询结果中 "tphone" 字段的值（教师联系电话）设置为 teacher 对象的 tphone 属性。 + teacher.setTpsw(resultSet.getString("tpsw")); + // 将查询结果中 "tpsw" 字段的值（教师密码）设置为 teacher 对象的 tpsw 属性。 } } catch (Exception e) { e.printStackTrace(); + // 如果在遍历和设置属性的过程中出现异常，打印异常堆栈信息， + // 以便开发人员进行调试和错误排查。 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，都要关闭 ResultSet 对象，释放数据库资源， + // 调用 JDBCUtils 类的 close 方法来关闭 resultSet。 } System.out.println(teacher.getTsex()); + // 在控制台打印教师对象的性别属性，用于调试目的，方便开发人员查看查询结果是否正确。 req.setAttribute("teacher", teacher); + // 将 teacher 对象设置为请求的属性，键为 "teacher"， + // 这样在后续的页面中可以通过这个键获取到 teacher 对象，从而展示教师信息。 req.getRequestDispatcher("/view/deptadmin/altertea.jsp").forward(req, resp); - + // 将请求转发到 /view/deptadmin/altertea.jsp 页面， + // 并将包含教师信息的 teacher 对象传递到该页面，以便进行教师信息的修改操作。 }else { req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp); + // 如果查询到的记录数量 count 不大于 0，即数据库中不存在该教师编号对应的教师记录， + // 将请求转发到 /view/alluse/noexistdataofalter.jsp 页面， + // 该页面用于提示用户没有可修改的数据，给用户一个明确的反馈。 } - } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 HTTP POST 请求。 + // 该方法接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同， + // 这样可以避免重复编写相似的代码，提高代码的复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptQueryTeaByIdServlet1.java b/src/com/controller/deptadmin/DeptQueryTeaByIdServlet1.java index 1ea26fa..ef4c6e0 100644 --- a/src/com/controller/deptadmin/DeptQueryTeaByIdServlet1.java +++ b/src/com/controller/deptadmin/DeptQueryTeaByIdServlet1.java @@ -1,81 +1,216 @@ package com.controller.deptadmin; +// 声明该类所在的包为 com.controller.deptadmin，包机制用于组织和管理相关的类， +// 便于在项目中对代码进行分类管理，避免类名冲突，提高代码的可读性和可维护性。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的操作方法， +// 例如执行 SQL 查询、插入、更新和删除等操作。后续代码会使用该类的方法来查询教师的相关信息。 + import com.entity.Teacher; +// 导入自定义的 Teacher 实体类，用于封装教师的各种信息， +// 如教师编号（tno）、教师姓名（tname）、性别（tsex）、年龄（tage）、所属部门（tdept）、 +// 联系电话（tphone）、密码（tpsw）等。在后续代码中，将从数据库查询到的教师信息存储到该实体类对象中。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，一般包含与 JDBC（Java Database Connectivity） +// 相关的通用方法，如获取数据库连接、关闭连接、处理结果集等， +// 用于简化数据库操作流程，提高代码的可维护性和复用性。在本代码中，会使用该类关闭数据库查询结果集。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现异常情况， +// 如请求处理失败、资源加载错误、内部逻辑错误等，会抛出 ServletException 异常， +// 以便在代码中进行异常处理，确保程序的稳定性和可靠性。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是 Java EE 中用于将普通 Java 类标记为 Servlet 的注解。 +// 通过该注解可以指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet， +// 从而实现客户端与服务器之间的交互。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法。 +// 我们定义的 Servlet 类继承 HttpServlet 类，从而获得处理 HTTP 请求的能力， +// 能够响应客户端发送的 GET 和 POST 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容。Servlet 可以通过这个类获取客户端传递的数据， +// 以便根据这些数据进行相应的业务逻辑处理。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等。Servlet 可以利用这个类来设置并返回给客户端相应的响应数据， +// 以满足客户端的需求。 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户的会话状态，能够在用户的多次请求之间存储和共享数据， +// 例如用户的登录信息、权限信息、所属部门等。在本 Servlet 中，将使用它来获取用户所属部门等会话信息。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出相关的操作（如网络数据传输、文件读写等）时， +// 如果出现错误，就会抛出 IOException 异常，以便进行相应的错误处理，保证程序的正常运行。 + import java.sql.ResultSet; +// 导入 ResultSet 类，用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据， +// 以便进行进一步的处理和分析。 @WebServlet("/DeptQueryTeaByIdServlet1") +// 使用 WebServlet 注解将 DeptQueryTeaByIdServlet1 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptQueryTeaByIdServlet1，这样客户端就可以通过这个路径向该 Servlet 发送请求， +// 从而触发该 Servlet 中的业务逻辑处理。 + public class DeptQueryTeaByIdServlet1 extends HttpServlet { + // 定义一个名为 DeptQueryTeaByIdServlet1 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端发送的 GET 和 POST 请求， + // 并实现根据教师编号和所属部门查询教师信息的功能。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法专门用于处理客户端发送的 HTTP GET 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确性。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容，并且按照 UTF-8 编码进行解析和显示， + // 以便客户端能够正确处理和展示响应数据。 String tno = req.getParameter("tno"); + // 从 HTTP 请求中获取名为 "tno" 的参数值，并将其赋值给字符串变量 tno。 + // 这里的 tno 代表教师编号，用于后续根据该编号查询教师的信息。 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。 + // 通过会话对象可以存储和获取用户在会话期间的相关信息，如用户所属部门等。 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值， + // 但在当前代码中未被使用，可能是根据实际需求进行了调整或暂时不需要该功能。 + // String sno = (String) session.getAttribute("sno"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值， + // 这里的变量名与前面获取请求参数的 tno 不同，且在当前代码中未被使用， + // 可能是后续功能的预留或不再需要该属性值。 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong。 + // 这里的 belong 可能代表用户所属的部门信息，用于后续的数据库查询条件。 System.out.println(belong); + // 在控制台打印 belong 的值，用于调试目的，方便开发人员查看从会话中获取的部门信息是否正确， + // 帮助进行问题排查和代码调试。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 + Object[] objects = {tno, belong}; + // 创建一个 Object 类型的数组 objects，将 tno 和 belong 作为元素存储在数组中， + // 这个数组将作为参数传递给数据库操作方法，用于绑定 SQL 语句中的占位符， + // 以提高 SQL 语句的安全性和灵活性。 System.out.println(tno); + // 在控制台打印获取到的教师编号 tno，用于调试目的，方便开发人员查看参数值是否正确。 //查询是否存在此人 sql = "select count(*) as num from teacher where tno = ? and tdept = ?"; + // 定义一个 SQL 查询语句，用于查询 teacher 表中，教师编号为 tno 且所属部门为 belong 的记录数量。 + // 使用占位符? 来提高 SQL 语句的安全性，防止 SQL 注入攻击，并将查询结果的数量别名为 num。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句， + // 并将查询结果（符合条件的记录数量）赋值给整数变量 count， + // 通过这个数量可以判断数据库中是否存在该教师在指定部门的记录。 if (count > 0) { //有则继续操作 + // 如果查询到的记录数量 count 大于 0，说明数据库中存在该教师在指定部门的记录， + // 可以继续执行后续的查询和处理操作。 + sql = "select * from teacher where tno = ? and tdept = ?"; + // 定义一个新的 SQL 查询语句，用于查询 teacher 表中，教师编号为 tno 且所属部门为 belong 的所有字段信息。 + // 同样使用占位符? 来确保 SQL 语句的安全性。 + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，执行上述 SQL 查询语句， + // 并将查询结果存储在 ResultSet 对象 resultSet 中，以便后续遍历和处理。 + Teacher teacher = new Teacher(); + // 创建一个 Teacher 对象 teacher，用于存储从数据库中查询到的教师信息。 try { while (resultSet.next()){ + // 遍历 ResultSet 对象，每次移动到下一行数据。 + // 如果有数据（resultSet.next() 返回 true），则将当前行的数据赋值给 teacher 对象的相应属性。 + teacher.setTno(resultSet.getString("tno")); + // 将查询结果中 "tno" 字段的值（教师编号）设置为 teacher 对象的 tno 属性。 + teacher.setTname(resultSet.getString("tname")); + // 将查询结果中 "tname" 字段的值（教师姓名）设置为 teacher 对象的 tname 属性。 + teacher.setTsex(resultSet.getString("tsex")); + // 将查询结果中 "tsex" 字段的值（教师性别）设置为 teacher 对象的 tsex 属性。 + teacher.setTage(resultSet.getInt("tage")); + // 将查询结果中 "tage" 字段的值（教师年龄）设置为 teacher 对象的 tage 属性， + // 并将其转换为整数类型。 + teacher.setTdept(resultSet.getString("tdept")); + // 将查询结果中 "tdept" 字段的值（教师所属部门）设置为 teacher 对象的 tdept 属性。 + teacher.setTphone(resultSet.getString("tphone")); + // 将查询结果中 "tphone" 字段的值（教师联系电话）设置为 teacher 对象的 tphone 属性。 + teacher.setTpsw(resultSet.getString("tpsw")); + // 将查询结果中 "tpsw" 字段的值（教师密码）设置为 teacher 对象的 tpsw 属性。 } } catch (Exception e) { e.printStackTrace(); + // 如果在遍历和设置属性的过程中出现异常，打印异常堆栈信息， + // 以便开发人员进行调试和错误排查。 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，都要关闭 ResultSet 对象，释放数据库资源， + // 调用 JDBCUtils 类的 close 方法来关闭 resultSet。 } System.out.println(teacher.getTsex()); + // 在控制台打印教师对象的性别属性，用于调试目的，方便开发人员查看查询结果是否正确。 req.setAttribute("teacher", teacher); + // 将 teacher 对象设置为请求的属性，键为 "teacher"， + // 这样在后续的页面中可以通过这个键获取到 teacher 对象，从而展示教师信息。 req.getRequestDispatcher("/view/deptadmin/altertea.jsp").forward(req, resp); + // 将请求转发到 /view/deptadmin/altertea.jsp 页面， + // 并将包含教师信息的 teacher 对象传递到该页面，以便进行教师信息的修改操作。 }else { req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp); + // 如果查询到的记录数量 count 不大于 0，即数据库中不存在该教师在指定部门的记录， + // 将请求转发到 /view/alluse/noexistdataofalter.jsp 页面， + // 该页面用于提示用户没有可修改的数据，给用户一个明确的反馈。 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，该方法用于处理客户端发送的 HTTP POST 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同， + // 这样可以避免重复编写相似的代码，提高代码的复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptQueryTeaByPageServlet.java b/src/com/controller/deptadmin/DeptQueryTeaByPageServlet.java index d7ea66b..84e932e 100644 --- a/src/com/controller/deptadmin/DeptQueryTeaByPageServlet.java +++ b/src/com/controller/deptadmin/DeptQueryTeaByPageServlet.java @@ -1,173 +1,285 @@ package com.controller.deptadmin; +// 声明该类所属的包为 com.controller.deptadmin，包机制用于组织和管理相关的类， +// 便于代码的维护和查找，避免类名冲突，体现项目的逻辑结构。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的操作方法， +// 如执行 SQL 查询、插入、更新和删除等操作。后续代码会使用这些方法来实现对教师信息的查询和统计等功能。 + import com.dao.StuDao; +// 导入自定义的 StuDao 类，虽然类名是 StuDao（学生数据访问对象）， +// 但在本代码中用于执行教师信息的分页查询操作（调用了其 QureyInfoByPage 方法）， +// 可能该类也包含一些通用的分页查询方法。 + import com.entity.PageBean; +// 导入自定义的 PageBean 实体类，用于封装分页相关的信息， +// 如当前页码、每页显示的记录数、总记录数、总页数以及数据列表等， +// 用于管理和传递教师信息分页查询的结果。 + import com.entity.Student; +// 导入自定义的 Student 实体类，在当前代码中未使用该类， +// 可能是项目中其他部分会用到，或者是在代码的扩展过程中预留的。 + import com.entity.Teacher; +// 导入自定义的 Teacher 实体类，用于封装教师的相关信息， +// 如教师编号、姓名、性别、年龄、所属部门、联系电话、密码等， +// 后续会用它来存储从数据库查询到的教师信息。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，一般包含与 JDBC（Java Database Connectivity） +// 相关的通用方法，如获取数据库连接、关闭数据库连接、处理结果集等， +// 用于简化数据库操作流程，提高代码的可维护性和复用性。在本代码中， +// 会使用该类的方法来关闭数据库查询结果集（ResultSet），释放数据库资源。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现异常情况时， +// 如请求处理失败、资源加载错误、内部逻辑错误等，会抛出 ServletException 异常， +// 以便进行相应的异常处理和错误恢复，确保系统的稳定性和可靠性。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是 Java EE 中用于将普通 Java 类标记为 Servlet 的注解。 +// 通过该注解可以指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet， +// 从而实现与服务器的交互。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法。 +// 我们定义的 Servlet 类继承 HttpServlet 类，从而获得处理 HTTP 请求的能力， +// 能够响应客户端发送的 GET 和 POST 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容。Servlet 可以通过这个类获取客户端传递的各种数据， +// 以便根据这些数据进行相应的业务逻辑处理，如获取教师信息查询的条件参数和分页参数等。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等。Servlet 可以利用这个类来设置并返回给客户端相应的响应数据， +// 以满足客户端的需求，如设置响应的字符编码和内容类型，以及将查询结果页面转发给客户端等。 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户的会话状态，能够在用户的多次请求之间存储和共享数据， +// 例如用户的登录信息、权限信息、所属部门等。在本 Servlet 中，将使用它来获取用户所属部门等会话信息， +// 作为教师信息查询的条件之一。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出相关的操作（如网络数据传输、文件读写等）时， +// 如果出现错误，就会抛出 IOException 异常，以便进行相应的错误处理， +// 保证系统在面对异常情况时能够做出合理的响应。 + import java.sql.ResultSet; +// 导入 ResultSet 类，用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据， +// 以便进行进一步的处理和分析，如将查询到的教师信息存储到 Teacher 对象中。 + import java.util.ArrayList; +// 导入 ArrayList 类，它是 Java 集合框架中的一种动态数组实现。 +// 可以用来存储和管理一组对象，并且可以根据需要动态地增加或减少元素数量。 +// 在本 Servlet 中，将使用 ArrayList 来存储从数据库查询到的教师对象（Teacher）。 @WebServlet("/DeptQueryTeaByPageServlet") +// 使用 WebServlet 注解将 DeptQueryTeaByPageServlet 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptQueryTeaByPageServlet，这样客户端就可以通过这个路径向该 Servlet 发送请求， +// 从而触发该 Servlet 中的业务逻辑处理，实现教师信息的分页查询功能。 + public class DeptQueryTeaByPageServlet extends HttpServlet { + // 定义一个名为 DeptQueryTeaByPageServlet 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端发送的 GET 和 POST 请求， + // 并实现根据条件分页查询教师信息的功能。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法专门用于处理客户端发送的 HTTP GET 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确性和完整性。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容，并且按照 UTF-8 编码进行解析和显示， + // 以便客户端能够正确处理和展示响应数据。 //获取请求参数 String tno = req.getParameter("tno"); + // 从 HTTP 请求中获取名为 "tno" 的参数值，并将其赋值给字符串变量 tno。 + // 这里的 tno 代表教师编号，用于后续根据教师编号进行模糊查询教师信息。 + String tname = req.getParameter("tname"); - String tsex = req.getParameter("tsex"); + // 从 HTTP 请求中获取名为 "tname" 的参数值，并将其赋值给字符串变量 tname。 + // 这里的 tname 代表教师姓名，用于后续根据教师姓名进行模糊查询教师信息。 + String tsex = req.getParameter("tsex"); + // 从 HTTP 请求中获取名为 "tsex" 的参数值，并将其赋值给字符串变量 tsex。 + // 这里的 tsex 代表教师性别，用于后续根据教师性别进行模糊查询教师信息。 //如果传入的参数为null，则置为空字符串 if (tno == null){ tno = ""; } + // 如果获取到的教师编号参数 tno 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 + if (tname == null){ tname = ""; } + // 如果获取到的教师姓名参数 tname 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 + if (tsex == null){ tsex = ""; } + // 如果获取到的教师性别参数 tsex 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 //变为like查询所需的字符串参数 String tno1 = "%" + tno + "%"; + // 将教师编号参数 tno 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 tno 的前后添加通配符 "%"，以便查询包含该编号片段的教师记录。 + String tname1 = "%" + tname + "%"; + // 将教师姓名参数 tname 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 tname 的前后添加通配符 "%"，以便查询包含该姓名片段的教师记录。 + String tsex1 = "%" + tsex + "%"; + // 将教师性别参数 tsex 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 tsex 的前后添加通配符 "%"，以便查询包含该性别片段的教师记录。 //设置请求的属性参数，后面需要用 req.setAttribute("tno",tno); + // 将原始的教师编号参数 tno 设置为请求的属性，键为 "tno"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 + req.setAttribute("tname",tname); + // 将原始的教师姓名参数 tname 设置为请求的属性，键为 "tname"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 + req.setAttribute("tsex", tsex); + // 将原始的教师性别参数 tsex 设置为请求的属性，键为 "tsex"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 System.out.println(tno1); + // 在控制台打印转换后的教师编号模糊查询参数 tno1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 + System.out.println(tname1); - System.out.println(tsex1); + // 在控制台打印转换后的教师姓名模糊查询参数 tname1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 + System.out.println(tsex1); + // 在控制台打印转换后的教师性别模糊查询参数 tsex1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。 + // 通过会话对象可以存储和获取用户在会话期间的相关信息，如用户所属部门等。 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值， + // 但在当前代码中未被使用，可能是根据实际需求进行了调整或暂时不需要该功能。 + // String sno = (String) session.getAttribute("sno"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值， + // 这里的变量名与前面获取请求参数的 tno、tname、tsex 等不同， + // 且在当前代码中未被使用，可能是后续功能的预留或不再需要该属性值。 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong。 + // 这里的 belong 可能代表用户所属的部门信息，用于后续的数据库查询条件， + // 确保查询的教师信息是该部门下的教师记录。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 // System.out.println(userName); + // 注释掉的代码，原本用于在控制台打印从会话中获取的用户名 userName， + // 但由于该变量未被使用，所以此打印语句也被注释掉。 + // System.out.println(sno); + // 注释掉的代码，原本用于在控制台打印从会话中获取的学生编号 sno， + // 但由于该变量未被使用，所以此打印语句也被注释掉。 + System.out.println(belong); + // 在控制台打印从会话中获取的用户所属部门信息 belong，用于调试目的， + // 方便开发人员查看获取到的部门信息是否正确。 + System.out.println("hdghghjg"); + // 在控制台打印字符串 "hdghghjg"，可能是开发人员用于调试或标记的输出内容， + // 可以帮助确定代码执行到的位置。 String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码 + // 从 HTTP 请求中获取名为 "currentPage" 的参数值，并将其赋值给字符串变量 currentPage。 + // 这里的 currentPage 代表当前页码，用于实现分页查询功能。 + String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数 + // 从 HTTP 请求中获取名为 "rows" 的参数值，并将其赋值给字符串变量 rows。 + // 这里的 rows 代表每页显示的记录数，用于实现分页查询功能。 //如果未设请求参数，此处自动设置参数为第一页 if (currentPage == null || "".equals(currentPage)){ currentPage = "1"; } + // 如果获取到的当前页码参数 currentPage 为 null 或空字符串，则将其设置为 "1"， + // 即默认显示第一页的教师信息，确保分页查询的正常进行。 //如果没有设置rows的请求参数，此处自动设置 if (rows == null || "".equals(rows)){ rows = "7"; } + // 如果获取到的每页显示行数参数 rows 为 null 或空字符串，则将其设置为 "7"， + // 即默认每页显示 7 条教师记录，确保分页查询的正常进行。 //获取条件查询的参数 int currentPage1 = Integer.parseInt(currentPage); + // 将字符串类型的当前页码参数 currentPage 转换为整数类型，并赋值给变量 currentPage1， + // 以便后续进行计算和处理。 + int rows1 = Integer.parseInt(rows); + // 将字符串类型的每页显示行数参数 rows 转换为整数类型，并赋值给变量 rows1， + // 以便后续进行计算和处理。 //如果当前页数小于1，则设置当前页数为1 if (currentPage1 <= 0){ currentPage1 = 1; } + // 如果转换后的当前页码 currentPage1 小于等于 0，则将其设置为 1， + // 确保当前页码是有效的，避免出现负数或零页码的情况。 //设置StuPunch类的对象类型 PageBean pageBean = new PageBean(); + // 创建一个 PageBean 对象 pageBean，泛型类型为 Teacher，用于封装分页查询教师信息的相关信息， //设置当前页码 pageBean.setCurrentPage(currentPage1); + // 将当前页码 currentPage1 设置到 pageBean 对象中，以便在后续处理中使用。 //设置每页的记录数 pageBean.setRows(rows1); + // 将每页显示的记录数 rows1 设置到 pageBean 对象中，以便在后续处理中使用。 sql = " select count(*) as num from teacher where tno like ? and tname like ? and tsex like ? and tdept = ?"; + // 定义一个 SQL 查询语句，用于查询 teacher 表中，满足教师编号模糊匹配、 + // 教师姓名模糊匹配、教师性别模糊匹配且所属部门为 belong 的记录数量。 + // 使用占位符? 来提高 SQL 语句的安全性，防止 SQL 注入攻击，并将查询结果的数量别名为 num。 + Object[] objects = {tno1, tname1, tsex1, belong}; + // 创建一个 Object 类型的数组 objects，将转换后的模糊查询参数 tno1、tname1、tsex1 + // 和所属部门信息 belong 作为元素存储在数组中，这个数组将作为参数传递给数据库操作方法， + // 用于绑定 SQL 语句中的占位符。 /* sql = " select count(*) as num from teacher where tdept = ?"; Object[] objects = {belong};*/ + // 注释掉的代码，原本是一个简单的 SQL 查询语句，用于查询所属部门为 belong 的教师记录数量， + // 可能由于业务需求的变化，现在使用更复杂的带模糊查询条件的语句，所以将其注释掉。 //计算总记录数，并设置 int totalCount = DeptAdminDao.findTotalCount(sql, objects); - System.out.println(totalCount); - pageBean.setTotalCount(totalCount); - - if (totalCount > 0){ - //计算总页码，并设置 - int totalPage = (totalCount % rows1) == 0 ? totalCount/rows1 : (totalCount/rows1 + 1); - pageBean.setTotalPage(totalPage); - - //如果当前页数大于总页数 - if (currentPage1 > pageBean.getTotalPage()){ - currentPage1 = pageBean.getTotalPage(); - //重新设置当前页码 - pageBean.setCurrentPage(currentPage1); - } - - //计算开始的记录和list对象集合，并设置 - int start = (currentPage1 - 1) * rows1; - sql = "select * from teacher where tno like ? and tname like ? and tsex like ? and tdept = ? limit ?, ?"; - Object[] objects1 = {tno1, tname1, tsex1, belong, start, rows1}; - - /* sql = "select * from teacher where tdept = ? limit ?, ?"; - Object[] objects1 = {belong, start, rows1};*/ - - ResultSet resultSet = StuDao.QureyInfoByPage(sql, objects1); - ArrayList teaArrayList = new ArrayList(); - - try { - while (resultSet.next()){ - Teacher teacher = new Teacher(); - teacher.setTno(resultSet.getString("tno")); - teacher.setTname(resultSet.getString("tname")); - teacher.setTsex(resultSet.getString("tsex")); - teacher.setTage(resultSet.getInt("tage")); - teacher.setTdept(resultSet.getString("tdept")); - teacher.setTphone(resultSet.getString("tphone")); - teacher.setTpsw(resultSet.getString("tpsw")); - teaArrayList.add(teacher); - } - } catch (Exception e) { - e.printStackTrace(); - }finally { - JDBCUtils.close(resultSet); - } - pageBean.setArrayList(teaArrayList); - - System.out.println(teaArrayList); - System.out.println(pageBean); - - req.setAttribute("pageBean", pageBean); - - req.getRequestDispatcher("/view/deptadmin/teainfolist.jsp").forward(req, resp); - }else { - req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp); - } - } - - @Override - protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { - doGet(req, resp); - } -} + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句， + // 并将查询结果（符合条件的记录数量）赋值给 \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptQueryTeaPunchByIdServlet.java b/src/com/controller/deptadmin/DeptQueryTeaPunchByIdServlet.java index a4eea77..3a1370d 100644 --- a/src/com/controller/deptadmin/DeptQueryTeaPunchByIdServlet.java +++ b/src/com/controller/deptadmin/DeptQueryTeaPunchByIdServlet.java @@ -1,75 +1,198 @@ package com.controller.deptadmin; +// 声明该类所在的包为 com.controller.deptadmin，包用于组织和管理相关的类， +// 避免类名冲突，同时也方便代码的维护和查找，体现了项目的逻辑结构。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的操作方法， +// 如执行 SQL 查询、插入、更新和删除等操作。后续代码会使用该类的方法来查询教师打卡信息。 + import com.entity.StuPunch; +// 导入自定义的 StuPunch 实体类，在当前代码中未使用该类， +// 可能是项目中其他部分会用到，或者是在代码的扩展过程中预留的。 + import com.entity.TeaPunch; +// 导入自定义的 TeaPunch 实体类，用于封装教师打卡的相关信息， +// 如教师编号、教师姓名、是否打卡、打卡日期、打卡时间、身体状况等。 +// 后续会用它来存储从数据库查询到的教师打卡信息。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，一般包含了与 JDBC（Java Database Connectivity） +// 相关的通用方法，例如获取数据库连接、关闭数据库连接、处理结果集等， +// 用于简化数据库操作的流程，提高代码的可维护性和复用性。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在执行过程中出现异常情况， +// 如请求处理失败、资源加载错误等，会抛出 ServletException 异常， +// 用于在代码中进行异常处理和错误恢复。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是 Java EE 中用于将普通 Java 类标记为 Servlet 的注解， +// 通过该注解可以指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本结构和方法。 +// 我们定义的 Servlet 类继承它，从而具备处理 HTTP 请求的能力。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容，Servlet 可以通过它获取客户端传递的数据。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等，Servlet 可以利用它设置并返回响应数据给客户端。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出操作（如网络传输、文件读写等）出现错误时， +// 会抛出 IOException 异常，以便进行相应的错误处理。 + import java.sql.ResultSet; +// 导入 ResultSet 类，它用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据。 @WebServlet("/DeptQueryTeaPunchByIdServlet") +// 使用 WebServlet 注解将 DeptQueryTeaPunchByIdServlet 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptQueryTeaPunchByIdServlet，客户端可以通过这个路径向该 Servlet 发送请求。 + public class DeptQueryTeaPunchByIdServlet extends HttpServlet { + // 定义一个名为 DeptQueryTeaPunchByIdServlet 的类，继承自 HttpServlet 类， + // 使其成为一个能够处理 HTTP 请求的 Servlet，可响应客户端的 GET 和 POST 请求。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 HTTP GET 请求。 + // 该方法接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF - 8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确解析。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF - 8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF - 8， + // 告知客户端返回的是 HTML 格式的内容，以便客户端正确解析和显示响应信息。 //获取请求参数 String tno = req.getParameter("tno"); + // 从 HTTP 请求中获取名为 "tno" 的参数值，该参数代表教师编号， + // 用于后续根据教师编号查询教师打卡信息。 + String tpunchdate = req.getParameter("tpunchdate"); + // 从 HTTP 请求中获取名为 "tpunchdate" 的参数值，该参数代表教师打卡日期， + // 用于后续根据打卡日期查询教师打卡信息。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 + Object[] objects = {tno, tpunchdate}; + // 创建一个 Object 类型的数组 objects，将 tno 和 tpunchdate 作为元素存储在数组中， + // 这个数组将作为参数传递给数据库操作方法，用于绑定 SQL 语句中的占位符。 //查询是否存在此人 sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?"; + // 定义一个 SQL 查询语句，用于查询 teapunchin 表中，教师编号为 tno 且打卡日期为 tpunchdate 的记录数量。 + // 使用占位符 ? 来提高 SQL 语句的安全性，防止 SQL 注入攻击，并将查询结果的数量别名为 num。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句， + // 并将查询结果（符合条件的记录数量）赋值给整数变量 count， + // 通过这个数量可以判断数据库中是否存在该教师在指定日期的打卡记录。 if (count > 0){ //有则继续操作 + // 如果查询到的记录数量 count 大于 0，说明数据库中存在该教师在指定日期的打卡记录， + // 可以继续执行后续的查询和处理操作。 + sql = "select t.tname,tp.* from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ?"; + // 定义一个新的 SQL 查询语句，用于查询 teacher 表和 teapunchin 表关联后的信息， + // 选取教师姓名（t.tname）和 teapunchin 表的所有字段（tp.*），条件是教师编号匹配且打卡日期匹配。 + // 同样使用占位符 ? 来确保 SQL 语句的安全性。 + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，执行上述 SQL 查询语句， + // 并将查询结果存储在 ResultSet 对象 resultSet 中，以便后续遍历和处理。 + TeaPunch teaPunch = new TeaPunch(); + // 创建一个 TeaPunch 对象 teaPunch，用于存储从数据库中查询到的教师打卡信息。 try { while (resultSet.next()){ + // 遍历 ResultSet 对象，每次移动到下一行数据。 + // 如果有数据（resultSet.next() 返回 true），则将当前行的数据赋值给 teaPunch 对象的相应属性。 + teaPunch.setTno(resultSet.getString("tno")); + // 将查询结果中 "tno" 字段的值（教师编号）设置为 teaPunch 对象的 tno 属性。 + teaPunch.setTname(resultSet.getString("tname")); + // 将查询结果中 "tname" 字段的值（教师姓名）设置为 teaPunch 对象的 tname 属性。 + teaPunch.setTispunch(resultSet.getString("tispunch")); + // 将查询结果中 "tispunch" 字段的值（是否打卡）设置为 teaPunch 对象的 tispunch 属性。 + teaPunch.setTpunchdate(resultSet.getDate("tpunchdate")); + // 将查询结果中 "tpunchdate" 字段的值（打卡日期）设置为 teaPunch 对象的 tpunchdate 属性， + // 并将其转换为 java.sql.Date 类型。 + teaPunch.setTpunchtime(resultSet.getString("tpunchtime")); + // 将查询结果中 "tpunchtime" 字段的值（打卡时间）设置为 teaPunch 对象的 tpunchtime 属性。 + teaPunch.setTishot(resultSet.getString("tishot")); + // 将查询结果中 "tishot" 字段的值（是否发热）设置为 teaPunch 对象的 tishot 属性。 + teaPunch.setTiscough(resultSet.getString("tiscough")); + // 将查询结果中 "tiscough" 字段的值（是否咳嗽）设置为 teaPunch 对象的 tiscough 属性。 + teaPunch.setTisseem(resultSet.getString("tisseem")); + // 将查询结果中 "tisseem" 字段的值（是否有疑似症状）设置为 teaPunch 对象的 tisseem 属性。 + teaPunch.setTisdiagnose(resultSet.getString("tisdiagnose")); + // 将查询结果中 "tisdiagnose" 字段的值（是否确诊）设置为 teaPunch 对象的 tisdiagnose 属性。 + teaPunch.setTstatus(resultSet.getString("tstatus")); + // 将查询结果中 "tstatus" 字段的值（教师状态）设置为 teaPunch 对象的 tstatus 属性。 } } catch (Exception e) { e.printStackTrace(); + // 如果在遍历和设置属性的过程中出现异常，打印异常堆栈信息， + // 以便开发人员进行调试和错误排查。 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，都要关闭 ResultSet 对象，释放数据库资源， + // 调用 JDBCUtils 类的 close 方法来关闭 resultSet。 } System.out.println(teaPunch.getTno()); + // 在控制台打印教师打卡对象的教师编号属性，用于调试目的，方便开发人员查看查询结果是否正确。 + System.out.println(teaPunch.getTname()); + // 在控制台打印教师打卡对象的教师姓名属性，用于调试目的，方便开发人员查看查询结果是否正确。 req.setAttribute("teaPunch", teaPunch); + // 将 teaPunch 对象设置为请求的属性，键为 "teaPunch"， + // 这样在后续的页面中可以通过这个键获取到 teaPunch 对象，从而展示教师打卡信息。 req.getRequestDispatcher("/view/deptadmin/alterteapunch.jsp").forward(req, resp); + // 将请求转发到 /view/deptadmin/alterteapunch.jsp 页面， + // 并将包含教师打卡信息的 teaPunch 对象传递到该页面，以便进行教师打卡信息的修改操作。 }else { req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp); + // 如果查询到的记录数量 count 不大于 0，即数据库中不存在该教师在指定日期的打卡记录， + // 将请求转发到 /view/alluse/noexistdataofalter.jsp 页面， + // 该页面用于提示用户没有可修改的数据，给用户一个明确的反馈。 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 HTTP POST 请求。 + // 该方法接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同， + // 这样可以避免重复编写相似的代码，提高代码的复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptQueryTeaPunchByIdServlet1.java b/src/com/controller/deptadmin/DeptQueryTeaPunchByIdServlet1.java index 6069645..d314375 100644 --- a/src/com/controller/deptadmin/DeptQueryTeaPunchByIdServlet1.java +++ b/src/com/controller/deptadmin/DeptQueryTeaPunchByIdServlet1.java @@ -1,83 +1,229 @@ package com.controller.deptadmin; +// 声明该类所属的包为 com.controller.deptadmin，包机制用于对相关类进行组织管理， +// 方便代码的维护与查找，避免类名冲突，体现项目的逻辑结构层次。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的操作方法， +// 例如执行 SQL 查询、插入、更新和删除等操作。后续代码会利用该类的方法实现对教师打卡信息的数据库查询。 + import com.entity.TeaPunch; +// 导入自定义的 TeaPunch 实体类，用于封装教师打卡的相关信息， +// 如教师编号、教师姓名、是否打卡、打卡日期、打卡时间、身体状况等。后续会将从数据库查询到的教师打卡信息存储到该实体类对象中。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，一般包含与 JDBC（Java Database Connectivity）相关的通用方法， +// 如获取数据库连接、关闭数据库连接、处理结果集等。用于简化数据库操作流程，提高代码的可维护性和复用性。在本代码中，将使用该类关闭数据库查询结果集。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现异常情况， +// 如请求处理失败、资源加载错误、内部逻辑错误等，会抛出 ServletException 异常， +// 以便进行相应的异常处理和错误恢复，确保系统的稳定性和可靠性。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是 Java EE 中用于将普通 Java 类标记为 Servlet 的注解。 +// 通过该注解可以指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet， +// 从而实现客户端与服务器之间的交互。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法。 +// 我们定义的 Servlet 类继承 HttpServlet 类，从而获得处理 HTTP 请求的能力，能够响应客户端发送的 GET 和 POST 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容。Servlet 可以通过这个类获取客户端传递的数据， +// 以便根据这些数据进行相应的业务逻辑处理，如获取教师编号和打卡日期等查询参数。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等。Servlet 可以利用这个类来设置并返回给客户端相应的响应数据， +// 以满足客户端的需求，如设置响应的字符编码和内容类型，以及将查询结果页面转发给客户端等。 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户的会话状态，能够在用户的多次请求之间存储和共享数据， +// 例如用户的登录信息、权限信息、所属部门等。在本 Servlet 中，将使用它来获取用户所属部门等会话信息，作为查询条件之一。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出相关的操作（如网络数据传输、文件读写等）时， +// 如果出现错误，就会抛出 IOException 异常，以便进行相应的错误处理，保证系统在面对异常情况时能够做出合理的响应。 + import java.sql.ResultSet; +// 导入 ResultSet 类，用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据， +// 以便进行进一步的处理和分析，如将查询到的教师打卡信息存储到 TeaPunch 对象中。 @WebServlet("/DeptQueryTeaPunchByIdServlet1") +// 使用 WebServlet 注解将 DeptQueryTeaPunchByIdServlet1 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptQueryTeaPunchByIdServlet1，这样客户端就可以通过这个路径向该 Servlet 发送请求， +// 从而触发该 Servlet 中的业务逻辑处理，实现根据教师编号和打卡日期查询教师打卡信息的功能。 + public class DeptQueryTeaPunchByIdServlet1 extends HttpServlet { + // 定义一个名为 DeptQueryTeaPunchByIdServlet1 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端发送的 GET 和 POST 请求， + // 并实现根据教师编号、打卡日期以及所属部门查询教师打卡信息的功能。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法专门用于处理客户端发送的 HTTP GET 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确性。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容，并且按照 UTF-8 编码进行解析和显示， + // 以便客户端能够正确处理和展示响应数据。 //获取请求参数 String tno = req.getParameter("tno"); + // 从 HTTP 请求中获取名为 "tno" 的参数值，并将其赋值给字符串变量 tno。 + // 这里的 tno 代表教师编号，用于后续根据该编号查询教师的打卡信息。 + String tpunchdate = req.getParameter("tpunchdate"); + // 从 HTTP 请求中获取名为 "tpunchdate" 的参数值，并将其赋值给字符串变量 tpunchdate。 + // 这里的 tpunchdate 代表教师打卡日期，用于后续根据该日期查询教师的打卡信息。 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。 + // 通过会话对象可以存储和获取用户在会话期间的相关信息，如用户所属部门等。 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值， + // 但在当前代码中未被使用，可能是根据实际需求进行了调整或暂时不需要该功能。 + // String sno = (String) session.getAttribute("sno"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值， + // 这里的变量名与前面获取请求参数的 tno 不同，且在当前代码中未被使用， + // 可能是后续功能的预留或不再需要该属性值。 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong。 + // 这里的 belong 可能代表用户所属的部门信息，用于后续的数据库查询条件， + // 确保查询的教师打卡信息是该部门下的教师的记录。 System.out.println(belong); + // 在控制台打印 belong 的值，用于调试目的，方便开发人员查看从会话中获取的部门信息是否正确， + // 帮助进行问题排查和代码调试。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 + Object[] objects = {tno, tpunchdate, belong}; + // 创建一个 Object 类型的数组 objects，将 tno、tpunchdate 和 belong 作为元素存储在数组中， + // 这个数组将作为参数传递给数据库操作方法，用于绑定 SQL 语句中的占位符， + // 以提高 SQL 语句的安全性和灵活性。 //查询是否存在此人 sql = "select count(*) as num from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ? and t.tdept = ?"; + // 定义一个 SQL 查询语句，用于查询 teacher 表和 teapunchin 表中， + // 满足教师编号关联、教师编号为 tno、打卡日期为 tpunchdate 且教师所属部门为 belong 的记录数量。 + // 使用占位符? 来提高 SQL 语句的安全性，防止 SQL 注入攻击，并将查询结果的数量别名为 num。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询语句， + // 并将查询结果（符合条件的记录数量）赋值给整数变量 count， + // 通过这个数量可以判断数据库中是否存在该教师在指定部门、指定日期的打卡记录。 if (count > 0){ //有则继续操作 + // 如果查询到的记录数量 count 大于 0，说明数据库中存在该教师在指定部门、指定日期的打卡记录， + // 可以继续执行后续的查询和处理操作。 + sql = "select t.tname,tp.* from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ? and t.tdept = ?"; + // 定义一个新的 SQL 查询语句，用于查询 teacher 表和 teapunchin 表关联后的信息， + // 选取教师姓名（t.tname）和 teapunchin 表的所有字段（tp.*）， + // 条件是教师编号匹配、教师编号为 tno、打卡日期为 tpunchdate 且教师所属部门为 belong。 + // 同样使用占位符? 来确保 SQL 语句的安全性。 + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，执行上述 SQL 查询语句， + // 并将查询结果存储在 ResultSet 对象 resultSet 中，以便后续遍历和处理。 + TeaPunch teaPunch = new TeaPunch(); + // 创建一个 TeaPunch 对象 teaPunch，用于存储从数据库中查询到的教师打卡信息。 try { while (resultSet.next()){ + // 遍历 ResultSet 对象，每次移动到下一行数据。 + // 如果有数据（resultSet.next() 返回 true），则将当前行的数据赋值给 teaPunch 对象的相应属性。 + teaPunch.setTno(resultSet.getString("tno")); + // 将查询结果中 "tno" 字段的值（教师编号）设置为 teaPunch 对象的 tno 属性。 + teaPunch.setTname(resultSet.getString("tname")); + // 将查询结果中 "tname" 字段的值（教师姓名）设置为 teaPunch 对象的 tname 属性。 + teaPunch.setTispunch(resultSet.getString("tispunch")); + // 将查询结果中 "tispunch" 字段的值（是否打卡）设置为 teaPunch 对象的 tispunch 属性。 + teaPunch.setTpunchdate(resultSet.getDate("tpunchdate")); + // 将查询结果中 "tpunchdate" 字段的值（打卡日期）设置为 teaPunch 对象的 tpunchdate 属性， + // 并将其转换为 java.sql.Date 类型。 + teaPunch.setTpunchtime(resultSet.getString("tpunchtime")); + // 将查询结果中 "tpunchtime" 字段的值（打卡时间）设置为 teaPunch 对象的 tpunchtime 属性。 + teaPunch.setTishot(resultSet.getString("tishot")); + // 将查询结果中 "tishot" 字段的值（是否发热）设置为 teaPunch 对象的 tishot 属性。 + teaPunch.setTiscough(resultSet.getString("tiscough")); + // 将查询结果中 "tiscough" 字段的值（是否咳嗽）设置为 teaPunch 对象的 tiscough 属性。 + teaPunch.setTisseem(resultSet.getString("tisseem")); + // 将查询结果中 "tisseem" 字段的值（是否有疑似症状）设置为 teaPunch 对象的 tisseem 属性。 + teaPunch.setTisdiagnose(resultSet.getString("tisdiagnose")); + // 将查询结果中 "tisdiagnose" 字段的值（是否确诊）设置为 teaPunch 对象的 tisdiagnose 属性。 + teaPunch.setTstatus(resultSet.getString("tstatus")); + // 将查询结果中 "tstatus" 字段的值（教师状态）设置为 teaPunch 对象的 tstatus 属性。 } } catch (Exception e) { e.printStackTrace(); + // 如果在遍历和设置属性的过程中出现异常，打印异常堆栈信息， + // 以便开发人员进行调试和错误排查。 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，都要关闭 ResultSet 对象，释放数据库资源， + // 调用 JDBCUtils 类的 close 方法来关闭 resultSet。 } System.out.println(teaPunch.getTno()); + // 在控制台打印教师打卡对象的教师编号属性，用于调试目的，方便开发人员查看查询结果是否正确。 + System.out.println(teaPunch.getTname()); + // 在控制台打印教师打卡对象的教师姓名属性，用于调试目的，方便开发人员查看查询结果是否正确。 req.setAttribute("teaPunch", teaPunch); + // 将 teaPunch 对象设置为请求的属性，键为 "teaPunch"， + // 这样在后续的页面中可以通过这个键获取到 teaPunch 对象，从而展示教师打卡信息。 req.getRequestDispatcher("/view/deptadmin/alterteapunch.jsp").forward(req, resp); + // 将请求转发到 /view/deptadmin/alterteapunch.jsp 页面， + // 并将包含教师打卡信息的 teaPunch 对象传递到该页面，以便进行教师打卡信息的修改操作。 }else { req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp); + // 如果查询到的记录数量 count 不大于 0，即数据库中不存在该教师在指定部门、指定日期的打卡记录， + // 将请求转发到 /view/alluse/noexistdataofalter.jsp 页面， + // 该页面用于提示用户没有可修改的数据，给用户一个明确的反馈。 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，该方法用于处理客户端发送的 HTTP POST 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同， + // 这样可以避免重复编写相似的代码，提高代码的复用性和可维护性。 } -} +} \ No newline at end of file diff --git a/src/com/controller/deptadmin/DeptQueryTeaPunchByPageServlet.java b/src/com/controller/deptadmin/DeptQueryTeaPunchByPageServlet.java index d826933..51c5014 100644 --- a/src/com/controller/deptadmin/DeptQueryTeaPunchByPageServlet.java +++ b/src/com/controller/deptadmin/DeptQueryTeaPunchByPageServlet.java @@ -1,174 +1,282 @@ package com.controller.deptadmin; +// 声明该类所在的包为 com.controller.deptadmin，包机制用于组织和管理相关的类， +// 避免类名冲突，同时方便代码的维护和查找，体现项目的逻辑结构层次。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类通常封装了与数据库交互的操作方法， +// 如执行 SQL 查询、插入、更新、删除等操作。后续代码会使用该类的方法来计算总记录数等数据库操作。 + import com.dao.StuDao; +// 导入自定义的 StuDao 类，虽然类名是 StuDao（学生数据访问对象）， +// 但在本代码中用于执行教师打卡信息的分页查询操作（调用了其 QureyInfoByPage 方法）， +// 可能该类也包含一些通用的分页查询方法。 + import com.entity.PageBean; +// 导入自定义的 PageBean 实体类，用于封装分页相关的信息， +// 如当前页码、每页显示的记录数、总记录数、总页数以及数据列表等， +// 用于管理和传递教师打卡信息分页查询的结果。 + import com.entity.StuPunch; +// 导入自定义的 StuPunch 实体类，在当前代码中未使用该类， +// 可能是项目中其他部分会用到，或者是在代码的扩展过程中预留的。 + import com.entity.Student; +// 导入自定义的 Student 实体类，在当前代码中未使用该类， +// 可能是项目中其他部分会用到，或者是在代码的扩展过程中预留的。 + import com.entity.TeaPunch; +// 导入自定义的 TeaPunch 实体类，用于封装教师打卡的相关信息， +// 如教师编号、教师姓名、是否打卡、打卡日期、打卡时间、身体状况等。 +// 后续会用它来存储从数据库查询到的教师打卡信息。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，一般包含与 JDBC（Java Database Connectivity） +// 相关的通用方法，如获取数据库连接、关闭数据库连接、处理结果集等， +// 用于简化数据库操作流程，提高代码的可维护性和复用性。在本代码中， +// 会使用该类的方法来关闭数据库查询结果集（ResultSet），释放数据库资源。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现异常情况时， +// 如请求处理失败、资源加载错误、内部逻辑错误等，会抛出 ServletException 异常， +// 以便进行相应的异常处理和错误恢复，确保系统的稳定性和可靠性。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是 Java EE 中用于将普通 Java 类标记为 Servlet 的注解。 +// 通过该注解可以指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet， +// 从而实现客户端与服务器之间的交互。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法。 +// 我们定义的 Servlet 类继承 HttpServlet 类，从而获得处理 HTTP 请求的能力， +// 能够响应客户端发送的 GET 和 POST 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容。Servlet 可以通过这个类获取客户端传递的数据， +// 以便根据这些数据进行相应的业务逻辑处理，如获取教师打卡信息查询的条件参数和分页参数等。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等。Servlet 可以利用这个类来设置并返回给客户端相应的响应数据， +// 以满足客户端的需求，如设置响应的字符编码和内容类型，以及将查询结果页面转发给客户端等。 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户的会话状态，能够在用户的多次请求之间存储和共享数据， +// 例如用户的登录信息、权限信息、所属部门等。在本 Servlet 中，将使用它来获取用户所属部门等会话信息， +// 作为教师打卡信息查询的条件之一。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出相关的操作（如网络数据传输、文件读写等）时， +// 如果出现错误，就会抛出 IOException 异常，以便进行相应的错误处理， +// 保证系统在面对异常情况时能够做出合理的响应。 + import java.sql.ResultSet; +// 导入 ResultSet 类，用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据， +// 以便进行进一步的处理和分析，如将查询到的教师打卡信息存储到 TeaPunch 对象中。 + import java.util.ArrayList; +// 导入 ArrayList 类，它是 Java 集合框架中的一种动态数组实现。 +// 可以用来存储和管理一组对象，并且可以根据需要动态地增加或减少元素数量。 +// 在本 Servlet 中，将使用 ArrayList 来存储从数据库查询到的教师打卡对象（TeaPunch）。 @WebServlet("/DeptQueryTeaPunchByPageServlet") +// 使用 WebServlet 注解将 DeptQueryTeaPunchByPageServlet 类标记为一个 Servlet， +// 并指定其访问路径为 /DeptQueryTeaPunchByPageServlet，这样客户端就可以通过这个路径向该 Servlet 发送请求， +// 从而触发该 Servlet 中的业务逻辑处理，实现教师打卡信息的分页查询功能。 + public class DeptQueryTeaPunchByPageServlet extends HttpServlet { + // 定义一个名为 DeptQueryTeaPunchByPageServlet 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端发送的 GET 和 POST 请求， + // 并实现根据条件分页查询教师打卡信息的功能。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法专门用于处理客户端发送的 HTTP GET 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确性。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容，并且按照 UTF-8 编码进行解析和显示， + // 以便客户端能够正确处理和展示响应数据。 //获取请求参数 String tno = req.getParameter("tno"); + // 从 HTTP 请求中获取名为 "tno" 的参数值，并将其赋值给字符串变量 tno。 + // 这里的 tno 代表教师编号，用于后续根据教师编号进行模糊查询教师打卡信息。 + String tname = req.getParameter("tname"); + // 从 HTTP 请求中获取名为 "tname" 的参数值，并将其赋值给字符串变量 tname。 + // 这里的 tname 代表教师姓名，用于后续根据教师姓名进行模糊查询教师打卡信息。 + String tpunchdate = req.getParameter("tpunchdate"); + // 从 HTTP 请求中获取名为 "tpunchdate" 的参数值，并将其赋值给字符串变量 tpunchdate。 + // 这里的 tpunchdate 代表教师打卡日期，用于后续根据打卡日期进行模糊查询教师打卡信息。 System.out.println(tno); + // 在控制台打印获取到的教师编号参数 tno，用于调试目的，方便开发人员查看参数值是否正确。 + System.out.println(tname); - System.out.println(tpunchdate); + // 在控制台打印获取到的教师姓名参数 tname，用于调试目的，方便开发人员查看参数值是否正确。 + System.out.println(tpunchdate); + // 在控制台打印获取到的教师打卡日期参数 tpunchdate，用于调试目的，方便开发人员查看参数值是否正确。 //如果传入的参数为null，则置为空字符串 if (tno == null){ tno = ""; } + // 如果获取到的教师编号参数 tno 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 + if (tname == null){ tname = ""; } + // 如果获取到的教师姓名参数 tname 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 + if (tpunchdate == null){ tpunchdate = ""; } + // 如果获取到的教师打卡日期参数 tpunchdate 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 //变为like查询所需的字符串参数 String tno1 = "%" + tno + "%"; + // 将教师编号参数 tno 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 tno 的前后添加通配符 "%"，以便查询包含该编号片段的教师打卡记录。 + String tname1 = "%" + tname + "%"; + // 将教师姓名参数 tname 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 tname 的前后添加通配符 "%"，以便查询包含该姓名片段的教师打卡记录。 + String tpunchdate1 = "%" + tpunchdate + "%"; + // 将教师打卡日期参数 tpunchdate 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 tpunchdate 的前后添加通配符 "%"，以便查询包含该日期片段的教师打卡记录。 //设置请求的属性参数，后面需要用 req.setAttribute("tno", tno); + // 将原始的教师编号参数 tno 设置为请求的属性，键为 "tno"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 + req.setAttribute("tname",tname); + // 将原始的教师姓名参数 tname 设置为请求的属性，键为 "tname"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 + req.setAttribute("tpunchdate",tpunchdate); + // 将原始的教师打卡日期参数 tpunchdate 设置为请求的属性，键为 "tpunchdate"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 System.out.println(tno1); + // 在控制台打印转换后的教师编号模糊查询参数 tno1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 + System.out.println(tname1); + // 在控制台打印转换后的教师姓名模糊查询参数 tname1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 + System.out.println(tpunchdate1); + // 在控制台打印转换后的教师打卡日期模糊查询参数 tpunchdate1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。 + // 通过会话对象可以存储和获取用户在会话期间的相关信息，如用户所属部门等。 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值， + // 但在当前代码中未被使用，可能是根据实际需求进行了调整或暂时不需要该功能。 + // String sno = (String) session.getAttribute("sno"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值， + // 这里的变量名与前面获取请求参数的 tno、tname、tpunchdate 等不同， + // 且在当前代码中未被使用，可能是后续功能的预留或不再需要该属性值。 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong。 + // 这里的 belong 可能代表用户所属的部门信息，用于后续的数据库查询条件， + // 确保查询的教师打卡信息是该部门下的教师的记录。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 // System.out.println(userName); + // 注释掉的代码，原本用于在控制台打印从会话中获取的用户名 userName， + // 但由于该变量未被使用，所以此打印语句也被注释掉。 + // System.out.println(sno); + // 注释掉的代码，原本用于在控制台打印从会话中获取的学生编号 sno， + // 但由于该变量未被使用，所以此打印语句也被注释掉。 + System.out.println(belong); + // 在控制台打印从会话中获取的用户所属部门信息 belong，用于调试目的， + // 方便开发人员查看获取到的部门信息是否正确。 + System.out.println("hdghghjg"); + // 在控制台打印字符串 "hdghghjg"，可能是开发人员用于调试或标记的输出内容， + // 可以帮助确定代码执行到的位置。 String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码 + // 从 HTTP 请求中获取名为 "currentPage" 的参数值，并将其赋值给字符串变量 currentPage。 + // 这里的 currentPage 代表当前页码，用于实现分页查询功能。 + String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数 + // 从 HTTP 请求中获取名为 "rows" 的参数值，并将其赋值给字符串变量 rows。 + // 这里的 rows 代表每页显示的记录数，用于实现分页查询功能。 //如果未设请求参数，此处自动设置参数为第一页 if (currentPage == null || "".equals(currentPage)){ currentPage = "1"; } + // 如果获取到的当前页码参数 currentPage 为 null 或空字符串，则将其设置为 "1"， + // 即默认显示第一页的教师打卡信息，确保分页查询的正常进行。 //如果没有设置rows的请求参数，此处自动设置 if (rows == null || "".equals(rows)){ rows = "8"; } + // 如果获取到的每页显示行数参数 rows 为 null 或空字符串，则将其设置为 "8"， + // 即默认每页显示 8 条教师打卡记录，确保分页查询的正常进行。 //获取条件查询的参数 int currentPage1 = Integer.parseInt(currentPage); + // 将字符串类型的当前页码参数 currentPage 转换为整数类型，并赋值给变量 currentPage1， + // 以便后续进行计算和处理。 + int rows1 = Integer.parseInt(rows); + // 将字符串类型的每页显示行数参数 rows 转换为整数类型，并赋值给变量 rows1， + // 以便后续进行计算和处理。 //如果当前页数小于1，则设置当前页数为1 if (currentPage1 <= 0){ currentPage1 = 1; } + // 如果转换后的当前页码 currentPage1 小于等于 0，则将其设置为 1， + // 确保当前页码是有效的，避免出现负数或零页码的情况。 //设置StuPunch类的对象类型 PageBean pageBean = new PageBean(); + // 创建一个 PageBean 对象 pageBean，泛型类型为 TeaPunch，用于封装分页查询教师打卡信息的相关信息。 //设置当前页码 pageBean.setCurrentPage(currentPage1); + // 将当前页码 currentPage1 设置到 pageBean 对象中，以便在后续处理中使用。 //设置每页的记录数 pageBean.setRows(rows1); + // 将每页显示的记录数 rows1 设置到 pageBean 对象中，以便在后续处理中使用。 sql = " select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tno like ? and t.tname like ? and tp.tpunchdate like ? and t.tdept = ?"; - Object[] objects = {tno1, tname1, tpunchdate1, belong}; - - //计算总记录数，并设置 - int totalCount = DeptAdminDao.findTotalCount(sql, objects); - System.out.println(totalCount); - pageBean.setTotalCount(totalCount); - - if (totalCount > 0){ - //计算总页码，并设置 - int totalPage = (totalCount % rows1) == 0 ? totalCount/rows1 : (totalCount/rows1 + 1); - pageBean.setTotalPage(totalPage); - - //如果当前页数大于总页数 - if (currentPage1 > pageBean.getTotalPage()){ - currentPage1 = pageBean.getTotalPage(); - //重新设置当前页码 - pageBean.setCurrentPage(currentPage1); - } - - //计算开始的记录和list对象集合，并设置 - int start = (currentPage1 - 1) * rows1; - sql = "select t.tname, tp.* from teacher t, teapunchin tp where t.tno = tp.tno and t.tno like ? and t.tname like ? and tp.tpunchdate like ? and t.tdept = ? limit ?, ?"; - Object[] objects1 = {tno1, tname1, tpunchdate1, belong, start, rows1}; - - ResultSet resultSet = StuDao.QureyInfoByPage(sql, objects1); - ArrayList teaPunchArrayList = new ArrayList(); - - try { - while (resultSet.next()){ - TeaPunch teaPunch = new TeaPunch(); - teaPunch.setTno(resultSet.getString("tno")); - teaPunch.setTname(resultSet.getString("tname")); - teaPunch.setTispunch(resultSet.getString("tispunch")); - teaPunch.setTpunchdate(resultSet.getDate("tpunchdate")); - teaPunch.setTpunchtime(resultSet.getString("tpunchtime")); - teaPunch.setTishot(resultSet.getString("tishot")); - teaPunch.setTiscough(resultSet.getString("tiscough")); - teaPunch.setTisseem(resultSet.getString("tisseem")); - teaPunch.setTisdiagnose(resultSet.getString("tisdiagnose")); - teaPunch.setTstatus(resultSet.getString("tstatus")); - teaPunchArrayList.add(teaPunch); - } - } catch (Exception e) { - e.printStackTrace(); - }finally { - JDBCUtils.close(resultSet); - } - pageBean.setArrayList(teaPunchArrayList); - - System.out.println(teaPunchArrayList); - System.out.println(pageBean); - - req.setAttribute("pageBean", pageBean); - - req.getRequestDispatcher("/view/deptadmin/teapunchlist.jsp").forward(req, resp); - }else { - req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp); - } - } - - @Override - protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { - doGet(req, resp); - } -} + // 定义一个 SQL 查询语句，用于查询 teacher 表和 teapunchin 表中， + // 满足教师编号关联、教师编号模糊匹配、教师姓名模糊匹配、打卡日期模糊匹配且教师所属部门为 belong 的记录数量。 \ No newline at end of file diff --git a/src/com/controller/schoadmin/SchoQueryStuByPageServlet.java b/src/com/controller/schoadmin/SchoQueryStuByPageServlet.java index 5c28aa0..6c86b36 100644 --- a/src/com/controller/schoadmin/SchoQueryStuByPageServlet.java +++ b/src/com/controller/schoadmin/SchoQueryStuByPageServlet.java @@ -1,167 +1,317 @@ package com.controller.schoadmin; +// 声明该类所属的包为 com.controller.schoadmin，用于组织和管理与学校管理员相关的控制器类 import com.dao.DeptAdminDao; +// 导入 DeptAdminDao 类，该类通常封装了与部门管理相关的数据访问方法，用于执行数据库操作，如查询记录总数等 + import com.dao.StuDao; +// 导入 StuDao 类，它是用于学生数据访问的类，可执行与学生信息相关的数据库查询操作 + import com.entity.PageBean; +// 导入 PageBean 类，这是一个自定义的分页信息封装类，用于存储分页相关的信息，如当前页码、每页记录数、总记录数等 + import com.entity.Student; +// 导入 Student 类，这是学生实体类，用于封装学生的各种属性，如学号、姓名、性别等 + import com.utils.JDBCUtils; +// 导入 JDBCUtils 类，它是一个工具类，通常包含了与 JDBC（Java Database Connectivity）操作相关的工具方法，如获取数据库连接、关闭连接、处理结果集等 import javax.servlet.ServletException; +// 导入 ServletException 类，用于处理 Servlet 执行过程中可能出现的异常情况 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将一个普通的 Java 类标记为 Servlet，并指定其在 Web 应用中的访问路径 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，所有的 HTTP Servlet 都需要继承该类，并重写相应的方法来处理 HTTP 请求 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 接口，用于封装客户端发送的 HTTP 请求信息，如请求参数、请求头、请求方法等 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 接口，用于封装服务器返回给客户端的 HTTP 响应信息，如响应状态码、响应头、响应内容等 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 接口，用于管理用户会话，存储用户在一次会话期间的相关信息，如用户登录状态、用户信息等 + import java.io.IOException; +// 导入 IOException 类，用于处理输入输出操作中可能出现的异常情况，如网络传输异常等 + import java.sql.ResultSet; +// 导入 ResultSet 接口，用于表示数据库查询的结果集，通过该接口可以遍历和获取查询结果中的每一行数据 + import java.util.ArrayList; +// 导入 ArrayList 类，它是一个动态数组，用于存储和管理多个对象，这里用于存储查询到的学生信息 @WebServlet("/SchoQueryStuByPageServlet") +// 使用 WebServlet 注解将当前类标记为一个 Servlet，并指定其访问路径为 /SchoQueryStuByPageServlet，客户端可以通过该路径访问该 Servlet + public class SchoQueryStuByPageServlet extends HttpServlet { + // 定义一个公共类 SchoQueryStuByPageServlet，继承自 HttpServlet 类，用于处理 HTTP 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 GET 请求 + // req 是 HttpServletRequest 对象，封装了客户端的请求信息；resp 是 HttpServletResponse 对象，用于向客户端发送响应信息 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保能正确处理包含中文等特殊字符的请求参数 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，确保能正确输出包含中文等特殊字符的响应内容 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8，告知客户端响应的内容是 HTML 格式，且使用 UTF-8 编码 //获取请求参数 String sname = req.getParameter("sname"); + // 从请求中获取名为 "sname" 的参数值，该参数可能表示学生姓名，存储在字符串变量 sname 中 + String sclass = req.getParameter("sclass"); - String sdept = req.getParameter("sdept"); + // 从请求中获取名为 "sclass" 的参数值，该参数可能表示学生班级，存储在字符串变量 sclass 中 + String sdept = req.getParameter("sdept"); + // 从请求中获取名为 "sdept" 的参数值，该参数可能表示学生所在部门，存储在字符串变量 sdept 中 //如果传入的参数为null，则置为空字符串 if (sname == null){ sname = ""; } + // 如果 sname 参数为 null，将其设置为空字符串，避免后续操作出现空指针异常 + if (sclass == null){ sclass = ""; } + // 如果 sclass 参数为 null，将其设置为空字符串，避免后续操作出现空指针异常 + if (sdept == null){ sdept = ""; } + // 如果 sdept 参数为 null，将其设置为空字符串，避免后续操作出现空指针异常 //变为like查询所需的字符串参数 String sname1 = "%" + sname + "%"; + // 在 sname 前后添加 % 符号，用于模糊查询，匹配包含 sname 字符串的学生姓名 + String sclass1 = "%" + sclass + "%"; + // 在 sclass 前后添加 % 符号，用于模糊查询，匹配包含 sclass 字符串的学生班级 + String sdept1 = "%" + sdept + "%"; + // 在 sdept 前后添加 % 符号，用于模糊查询，匹配包含 sdept 字符串的学生所在部门 //设置请求的属性参数，后面需要用 req.setAttribute("sname",sname); + // 将 sname 参数设置为请求的属性，方便后续页面或其他处理使用 + req.setAttribute("sclass", sclass); + // 将 sclass 参数设置为请求的属性，方便后续页面或其他处理使用 + req.setAttribute("sdept",sdept); + // 将 sdept 参数设置为请求的属性，方便后续页面或其他处理使用 System.out.println(sname1); + // 将 sname1 的值输出到控制台，用于调试目的，查看模糊查询的学生姓名参数 + System.out.println(sclass1); + // 将 sclass1 的值输出到控制台，用于调试目的，查看模糊查询的学生班级参数 + System.out.println(sdept1); + // 将 sdept1 的值输出到控制台，用于调试目的，查看模糊查询的学生所在部门参数 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话 + // String userName = (String) session.getAttribute("userName"); +// 注释掉的代码，原本是从会话中获取名为 "userName" 的属性值，并将其转换为字符串类型存储在 userName 变量中 + // String sno = (String) session.getAttribute("sno"); +// 注释掉的代码，原本是从会话中获取名为 "sno" 的属性值，并将其转换为字符串类型存储在 sno 变量中 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其转换为字符串类型存储在 belong 变量中，该属性可能表示用户所属的部门或角色等信息 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 查询语句，初始值为 null // System.out.println(userName); +// 注释掉的代码，原本是将 userName 的值输出到控制台，用于调试目的 + // System.out.println(sno); +// 注释掉的代码，原本是将 sno 的值输出到控制台，用于调试目的 + System.out.println(belong); + // 将 belong 的值输出到控制台，用于调试目的 + System.out.println("hdghghjg"); + // 输出一个调试信息，用于确认代码执行到此处 String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码 + // 从请求中获取名为 "currentPage" 的参数值，该参数表示当前页码 + String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数 + // 从请求中获取名为 "rows" 的参数值，该参数表示每页显示的记录数 //如果未设请求参数，此处自动设置参数为第一页 if (currentPage == null || "".equals(currentPage)){ currentPage = "1"; } + // 如果当前页码参数为空或未设置，将当前页码设置为 1 //如果没有设置rows的请求参数，此处自动设置 if (rows == null || "".equals(rows)){ rows = "7"; } + // 如果每页显示的记录数参数为空或未设置，将每页显示的记录数设置为 7 //获取条件查询的参数 int currentPage1 = Integer.parseInt(currentPage); + // 将当前页码字符串转换为整数类型 + int rows1 = Integer.parseInt(rows); + // 将每页显示的记录数字符串转换为整数类型 //如果当前页数小于1，则设置当前页数为1 if (currentPage1 <= 0){ currentPage1 = 1; } + // 如果当前页码小于等于 0，将当前页码设置为 1 //设置StuPunch类的对象类型 PageBean pageBean = new PageBean(); + // 创建一个 PageBean 类的对象 pageBean，泛型指定为 Student 类型，用于存储学生信息的分页数据 //设置当前页码 pageBean.setCurrentPage(currentPage1); + // 将当前页码设置到 pageBean 对象中 //设置每页的记录数 pageBean.setRows(rows1); + // 将每页显示的记录数设置到 pageBean 对象中 sql = " select count(*) as num from student where sname like ? and sclass like ? and sdept like ?"; + // 定义一个 SQL 查询语句，用于查询满足条件（学生姓名、班级、部门模糊匹配）的学生记录总数 + Object[] objects = {sname1, sclass1, sdept1}; + // 创建一个 Object 类型的数组 objects，将模糊查询所需的参数放入数组中 //计算总记录数，并设置 int totalCount = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回满足条件的记录总数 + System.out.println(totalCount); + // 将总记录数输出到控制台，用于调试目的 + pageBean.setTotalCount(totalCount); + // 将总记录数设置到 pageBean 对象中 if (totalCount > 0){ + // 如果总记录数大于 0，说明存在满足条件的记录 + //计算总页码，并设置 int totalPage = (totalCount % rows1) == 0 ? totalCount/rows1 : (totalCount/rows1 + 1); + // 根据总记录数和每页显示的记录数计算总页码，如果总记录数能被每页记录数整除，则总页码为总记录数除以每页记录数；否则，总页码为总记录数除以每页记录数加 1 + pageBean.setTotalPage(totalPage); + // 将总页码设置到 pageBean 对象中 //如果当前页数大于总页数 if (currentPage1 > pageBean.getTotalPage()){ currentPage1 = pageBean.getTotalPage(); + // 如果当前页码大于总页码，将当前页码设置为总页码 + //重新设置当前页码 pageBean.setCurrentPage(currentPage1); + // 将更新后的当前页码重新设置到 pageBean 对象中 } //计算开始的记录和list对象集合，并设置 int start = (currentPage1 - 1) * rows1; + // 根据当前页码和每页显示的记录数计算当前页的起始记录索引 + sql = "select * from student where sname like ? and sclass like ? and sdept like ? limit ?, ?"; + // 定义一个 SQL 查询语句，用于查询当前页的学生信息，使用 limit 关键字进行分页查询 + Object[] objects1 = {sname1, sclass1, sdept1, start, rows1}; + // 创建一个 Object 类型的数组 objects1，将模糊查询所需的参数和分页参数放入数组中 ResultSet resultSet = StuDao.QureyInfoByPage(sql, objects1); + // 调用 StuDao 类的 QureyInfoByPage 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回结果集 + ArrayList stuArrayList = new ArrayList(); + // 创建一个 ArrayList 对象，用于存储查询到的学生信息 try { while (resultSet.next()){ + // 遍历结果集，每次循环处理结果集中的一行数据 + Student student = new Student(); + // 创建一个 Student 类的对象，用于存储当前行的学生信息 + student.setSno(resultSet.getString("sno")); + // 从结果集中获取名为 "sno" 的列的值，并将其设置到 student 对象的 sno 属性中 + student.setSname(resultSet.getString("sname")); + // 从结果集中获取名为 "sname" 的列的值，并将其设置到 student 对象的 sname 属性中 + student.setSsex(resultSet.getString("ssex")); + // 从结果集中获取名为 "ssex" 的列的值，并将其设置到 student 对象的 ssex 属性中 + student.setSage(resultSet.getInt("sage")); + // 从结果集中获取名为 "sage" 的列的值，并将其设置到 student 对象的 sage 属性中 + student.setSclass(resultSet.getString("sclass")); + // 从结果集中获取名为 "sclass" 的列的值，并将其设置到 student 对象的 sclass 属性中 + student.setSpecialty(resultSet.getString("specialty")); + // 从结果集中获取名为 "specialty" 的列的值，并将其设置到 student 对象的 specialty 属性中 + student.setSdept(resultSet.getString("sdept")); + // 从结果集中获取名为 "sdept" 的列的值，并将其设置到 student 对象的 sdept 属性中 + student.setSphone(resultSet.getString("sphone")); + // 从结果集中获取名为 "sphone" 的列的值，并将其设置到 student 对象的 sphone 属性中 + student.setSpsw(resultSet.getString("spsw")); + // 从结果集中获取名为 "spsw" 的列的值，并将其设置到 student 对象的 spsw 属性中 + stuArrayList.add(student); + // 将存储了当前行学生信息的 student 对象添加到 stuArrayList 中 } } catch (Exception e) { e.printStackTrace(); + // 捕获并处理可能出现的异常，将异常的堆栈跟踪信息输出到控制台，方便调试 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，最终都调用 JDBCUtils 类的 close 方法关闭结果集，释放相关资源 } + pageBean.setArrayList(stuArrayList); + // 将存储学生信息的 ArrayList 设置到 pageBean 对象中 System.out.println(stuArrayList); + // 将 stuArrayList 输出到控制台，用于调试目的 + System.out.println(pageBean); + // 将 pageBean 输出到控制台，用于调试目的 req.setAttribute("pageBean", pageBean); + // 将 pageBean 对象作为属性添加到请求对象中，属性名为 "pageBean"，以便在后续的 JSP 页面中可以获取该对象 req.getRequestDispatcher("/view/schoadmin/stuinfolist.jsp").forward(req, resp); + // 获取请求转发器，将请求和响应对象转发到 /view/schoadmin/stuinfolist.jsp 页面，让该页面继续处理请求并显示学生信息 + }else { req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp); + // 如果总记录数为 0，说明不存在满足条件的记录，将请求和响应对象转发到 /view/alluse/nodata.jsp 页面，提示用户没有相关数据 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 POST 请求 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同 } -} +} \ No newline at end of file diff --git a/src/com/controller/schoadmin/SchoQueryStuPunchByIdServlet.java b/src/com/controller/schoadmin/SchoQueryStuPunchByIdServlet.java index 206fc11..dcf7687 100644 --- a/src/com/controller/schoadmin/SchoQueryStuPunchByIdServlet.java +++ b/src/com/controller/schoadmin/SchoQueryStuPunchByIdServlet.java @@ -1,71 +1,147 @@ package com.controller.schoadmin; +// 声明该类所在的包名为 com.controller.schoadmin，通常用于组织与学校管理员相关的控制器类 import com.dao.DeptAdminDao; +// 导入自定义的数据访问对象类 DeptAdminDao，该类可能包含了用于执行数据库查询等操作的方法 + import com.entity.StuPunch; +// 导入自定义的实体类 StuPunch，用于封装学生打卡的相关信息，例如学生编号、姓名、打卡状态等 + import com.utils.JDBCUtils; +// 导入自定义的工具类 JDBCUtils，该类可能提供了与 JDBC（Java Database Connectivity）操作相关的工具方法，如数据库连接的获取、关闭以及结果集的处理等 import javax.servlet.ServletException; +// 导入 Servlet 异常类，用于处理在 Servlet 执行过程中可能出现的异常情况 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将普通的 Java 类标记为 Servlet，并指定其在 Web 应用中的访问路径 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，所有的 HTTP Servlet 都需要继承该类，并重写相应方法来处理 HTTP 请求 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 接口，用于封装客户端发送的 HTTP 请求信息，如请求参数、请求头、请求方法等 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 接口，用于封装服务器返回给客户端的 HTTP 响应信息，如响应状态码、响应头、响应内容等 + import java.io.IOException; +// 导入 IOException 类，用于处理在输入输出操作中可能出现的异常情况 + import java.sql.ResultSet; +// 导入 ResultSet 接口，用于表示数据库查询的结果集，通过该接口可以遍历和获取查询结果中的每一行数据 @WebServlet("/SchoQueryStuPunchByIdServlet") +// 使用 WebServlet 注解将当前类标记为一个 Servlet，并指定其访问路径为 /SchoQueryStuPunchByIdServlet，客户端可通过该路径访问此 Servlet + public class SchoQueryStuPunchByIdServlet extends HttpServlet { + // 定义一个公共类 SchoQueryStuPunchByIdServlet，继承自 HttpServlet 类，用于处理 HTTP 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 GET 请求 + // req 是 HttpServletRequest 对象，封装了客户端的请求信息；resp 是 HttpServletResponse 对象，用于向客户端发送响应信息 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，以确保能够正确处理包含中文等特殊字符的请求参数 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，以保证能够正确输出包含中文等特殊字符的响应内容 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8，告知客户端响应的内容是 HTML 格式，且使用 UTF-8 编码 //获取请求参数 String sno = req.getParameter("sno"); + // 从请求中获取名为 "sno" 的参数值，该参数可能表示学生的编号，将其存储在字符串变量 sno 中 + String spunchdate = req.getParameter("spunchdate"); + // 从请求中获取名为 "spunchdate" 的参数值，该参数可能表示学生的打卡日期，将其存储在字符串变量 spunchdate 中 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 查询语句，初始值设为 null + Object[] objects = {sno, spunchdate}; + // 创建一个 Object 类型的数组 objects，将 sno 和 spunchdate 作为数组元素，用于后续的 SQL 查询参数传递 //查询是否存在此人 sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?"; + // 定义一个 SQL 查询语句，用于查询 stupunchin 表中，学生编号为 sno 且打卡日期为 spunchdate 的记录数量，并将结果列命名为 num + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，传入 SQL 查询语句和查询参数数组 objects，执行查询并返回满足条件的记录数量，将结果存储在整数变量 count 中 if (count > 0){ //有则继续操作 + // 如果查询到的记录数量大于 0，说明存在符合条件的学生打卡记录，则继续后续操作 + sql = "select s.sname,sp.* from student s,stupunchin sp where s.sno = sp.sno and sp.sno = ? and sp.spunchdate = ?"; + // 定义一个新的 SQL 查询语句，通过关联 student 表和 stupunchin 表，查询学生姓名以及学生打卡的详细信息，条件是学生编号为 sno 且打卡日期为 spunchdate + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，传入 SQL 查询语句和查询参数数组 objects，执行查询并返回结果集，将结果存储在 ResultSet 对象 resultSet 中 + StuPunch stuPunch = new StuPunch(); + // 创建一个 StuPunch 类的对象 stuPunch，用于存储查询到的学生打卡信息 try { while (resultSet.next()){ + // 遍历结果集，每次循环处理结果集中的一行数据 + stuPunch.setSno(resultSet.getString("sno")); + // 从结果集中获取名为 "sno" 的列的值，并将其设置到 stuPunch 对象的 sno 属性中 + stuPunch.setSname(resultSet.getString("sname")); + // 从结果集中获取名为 "sname" 的列的值，并将其设置到 stuPunch 对象的 sname 属性中 + stuPunch.setSispunch(resultSet.getString("sispunch")); + // 从结果集中获取名为 "sispunch" 的列的值，并将其设置到 stuPunch 对象的 sispunch 属性中 + stuPunch.setSpunchdate(resultSet.getDate("spunchdate")); + // 从结果集中获取名为 "spunchdate" 的列的值，并将其设置到 stuPunch 对象的 spunchdate 属性中 + stuPunch.setSpunchtime(resultSet.getString("spunchtime")); + // 从结果集中获取名为 "spunchtime" 的列的值，并将其设置到 stuPunch 对象的 spunchtime 属性中 + stuPunch.setSishot(resultSet.getString("sishot")); + // 从结果集中获取名为 "sishot" 的列的值，并将其设置到 stuPunch 对象的 sishot 属性中 + stuPunch.setSiscough(resultSet.getString("siscough")); + // 从结果集中获取名为 "siscough" 的列的值，并将其设置到 stuPunch 对象的 siscough 属性中 + stuPunch.setSisseem(resultSet.getString("sisseem")); + // 从结果集中获取名为 "sisseem" 的列的值，并将其设置到 stuPunch 对象的 sisseem 属性中 + stuPunch.setSisdiagnose(resultSet.getString("sisdiagnose")); + // 从结果集中获取名为 "sisdiagnose" 的列的值，并将其设置到 stuPunch 对象的 sisdiagnose 属性中 + stuPunch.setSstatus(resultSet.getString("sstatus")); + // 从结果集中获取名为 "sstatus" 的列的值，并将其设置到 stuPunch 对象的 sstatus 属性中 } } catch (Exception e) { e.printStackTrace(); + // 捕获并处理可能出现的异常情况，将异常的堆栈跟踪信息输出到控制台，以便进行调试 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，最终都调用 JDBCUtils 类的 close 方法关闭结果集，释放相关的数据库资源 } req.setAttribute("stuPunch", stuPunch); + // 将 stuPunch 对象作为属性添加到请求对象 req 中，属性名为 "stuPunch"，以便后续的 JSP 页面可以获取该对象 req.getRequestDispatcher("/view/schoadmin/alterstupunch.jsp").forward(req, resp); + // 获取请求转发器，将请求 req 和响应 resp 转发到 /view/schoadmin/alterstupunch.jsp 页面，使该页面能够继续处理请求并显示学生的打卡信息，可能用于修改操作 + }else { req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp); + // 如果查询到的记录数量为 0，说明不存在符合条件的学生打卡记录，则将请求 req 和响应 resp 转发到 /view/alluse/noexistdataofalter.jsp 页面，提示用户没有可修改的相关数据 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 POST 请求 + doGet(req, resp); + // 调用 doGet 方法来处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同 } -} +} \ No newline at end of file diff --git a/src/com/controller/schoadmin/SchoQueryStuPunchByIdServlet1.java b/src/com/controller/schoadmin/SchoQueryStuPunchByIdServlet1.java index 8026fe4..ecb9f10 100644 --- a/src/com/controller/schoadmin/SchoQueryStuPunchByIdServlet1.java +++ b/src/com/controller/schoadmin/SchoQueryStuPunchByIdServlet1.java @@ -1,80 +1,166 @@ package com.controller.schoadmin; +// 声明该类所在的包为 com.controller.schoadmin，用于组织和管理与学校管理员相关的控制器类 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类可能封装了与数据库交互的方法，用于执行数据库查询等操作 + import com.entity.StuPunch; +// 导入自定义的 StuPunch 实体类，用于封装学生打卡的相关信息，如学生编号、姓名、打卡状态等 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 类，通常包含与 JDBC（Java Database Connectivity）操作相关的工具方法，如获取数据库连接、关闭连接、处理结果集等 import javax.servlet.ServletException; +// 导入 Servlet 异常类，用于处理 Servlet 执行过程中可能出现的异常情况 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将一个普通的 Java 类标记为 Servlet，并指定其访问路径 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，所有的 HTTP Servlet 都需要继承该类，并重写相应方法来处理 HTTP 请求 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 接口，用于封装客户端发送的 HTTP 请求信息，如请求参数、请求头、请求方法等 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 接口，用于封装服务器返回给客户端的 HTTP 响应信息，如响应状态码、响应头、响应内容等 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 接口，用于管理用户会话，存储用户在一次会话期间的相关信息，如用户登录状态、用户信息等 + import java.io.IOException; +// 导入 IOException 类，用于处理输入输出操作中可能出现的异常情况，如网络传输异常等 + import java.sql.ResultSet; +// 导入 ResultSet 接口，用于表示数据库查询结果集，通过该接口可以遍历查询结果中的每一行数据 @WebServlet("/SchoQueryStuPunchByIdServlet1") +// 使用 WebServlet 注解将当前类标记为一个 Servlet，并指定其访问路径为 /SchoQueryStuPunchByIdServlet1，客户端可通过该路径访问该 Servlet + public class SchoQueryStuPunchByIdServlet1 extends HttpServlet { + // 定义一个公共类 SchoQueryStuPunchByIdServlet1，继承自 HttpServlet 类，用于处理 HTTP 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 GET 请求 + // req 是 HttpServletRequest 对象，封装了客户端的请求信息；resp 是 HttpServletResponse 对象，用于向客户端发送响应信息 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保能正确处理包含中文等特殊字符的请求参数 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，确保能正确输出包含中文等特殊字符的响应内容 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8，告知客户端响应的内容是 HTML 格式，且使用 UTF-8 编码 //获取请求参数 String sno = req.getParameter("sno"); + // 从请求中获取名为 "sno" 的参数值，该参数可能表示学生编号，将其存储在字符串变量 sno 中 + String spunchdate = req.getParameter("spunchdate"); + // 从请求中获取名为 "spunchdate" 的参数值，该参数可能表示学生打卡日期，将其存储在字符串变量 spunchdate 中 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话 + // String userName = (String) session.getAttribute("userName"); +// 注释掉的代码，原本是从会话中获取名为 "userName" 的属性值，并将其转换为字符串类型存储在 userName 变量中 + // String sno = (String) session.getAttribute("sno"); +// 注释掉的代码，原本是从会话中获取名为 "sno" 的属性值，并将其转换为字符串类型存储在 sno 变量中 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其转换为字符串类型存储在 belong 变量中，该属性可能表示用户所属的部门或角色等信息 System.out.println(belong); + // 将 belong 变量的值输出到控制台，用于调试目的 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 查询语句，初始值为 null + Object[] objects = {sno, spunchdate}; + // 创建一个 Object 类型的数组 objects，将 sno 和 spunchdate 作为数组元素，用于后续的 SQL 查询参数传递 //查询是否存在此人 sql = "select count(*) as num from student s,stupunchin sp where s.sno = sp.sno and s.sno = ? and sp.spunchdate = ?"; + // 定义一个 SQL 查询语句，用于查询 student 表和 stupunchin 表中，学生编号为 sno 且打卡日期为 spunchdate 的记录数量，并将结果列命名为 num + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回满足条件的记录数量，将结果存储在整数变量 count 中 if (count > 0){ //有则继续操作 + // 如果查询到的记录数量大于 0，说明存在该学生在指定日期的打卡记录，则继续后续操作 + sql = "select s.sname,sp.* from student s,stupunchin sp where s.sno = sp.sno and sp.sno = ? and sp.spunchdate = ?"; + // 定义一个新的 SQL 查询语句，用于查询 student 表和 stupunchin 表中，学生编号为 sno 且打卡日期为 spunchdate 的学生姓名和打卡详细信息 + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回结果集，将结果存储在 ResultSet 对象 resultSet 中 + StuPunch stuPunch = new StuPunch(); + // 创建一个 StuPunch 类的对象 stuPunch，用于存储查询到的学生打卡信息 try { while (resultSet.next()){ + // 遍历结果集，每次循环处理结果集中的一行数据 + stuPunch.setSno(resultSet.getString("sno")); + // 从结果集中获取名为 "sno" 的列的值，并将其设置到 stuPunch 对象的 sno 属性中 + stuPunch.setSname(resultSet.getString("sname")); + // 从结果集中获取名为 "sname" 的列的值，并将其设置到 stuPunch 对象的 sname 属性中 + stuPunch.setSispunch(resultSet.getString("sispunch")); + // 从结果集中获取名为 "sispunch" 的列的值，并将其设置到 stuPunch 对象的 sispunch 属性中 + stuPunch.setSpunchdate(resultSet.getDate("spunchdate")); + // 从结果集中获取名为 "spunchdate" 的列的值，并将其设置到 stuPunch 对象的 spunchdate 属性中 + stuPunch.setSpunchtime(resultSet.getString("spunchtime")); + // 从结果集中获取名为 "spunchtime" 的列的值，并将其设置到 stuPunch 对象的 spunchtime 属性中 + stuPunch.setSishot(resultSet.getString("sishot")); + // 从结果集中获取名为 "sishot" 的列的值，并将其设置到 stuPunch 对象的 sishot 属性中 + stuPunch.setSiscough(resultSet.getString("siscough")); + // 从结果集中获取名为 "siscough" 的列的值，并将其设置到 stuPunch 对象的 siscough 属性中 + stuPunch.setSisseem(resultSet.getString("sisseem")); + // 从结果集中获取名为 "sisseem" 的列的值，并将其设置到 stuPunch 对象的 sisseem 属性中 + stuPunch.setSisdiagnose(resultSet.getString("sisdiagnose")); + // 从结果集中获取名为 "sisdiagnose" 的列的值，并将其设置到 stuPunch 对象的 sisdiagnose 属性中 + stuPunch.setSstatus(resultSet.getString("sstatus")); + // 从结果集中获取名为 "sstatus" 的列的值，并将其设置到 stuPunch 对象的 sstatus 属性中 } } catch (Exception e) { e.printStackTrace(); + // 捕获并处理可能出现的异常，将异常的堆栈跟踪信息输出到控制台，方便调试 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，最终都调用 JDBCUtils 类的 close 方法关闭结果集，释放相关资源 } req.setAttribute("stuPunch", stuPunch); + // 将 stuPunch 对象作为属性添加到请求对象中，属性名为 "stuPunch"，以便在后续的 JSP 页面中可以获取该对象 req.getRequestDispatcher("/view/schoadmin/alterstupunch.jsp").forward(req, resp); + // 获取请求转发器，将请求和响应对象转发到 /view/schoadmin/alterstupunch.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 { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 POST 请求 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同 } -} +} \ No newline at end of file diff --git a/src/com/controller/schoadmin/SchoQueryStuPunchByPageServlet.java b/src/com/controller/schoadmin/SchoQueryStuPunchByPageServlet.java index dec3f4e..152d580 100644 --- a/src/com/controller/schoadmin/SchoQueryStuPunchByPageServlet.java +++ b/src/com/controller/schoadmin/SchoQueryStuPunchByPageServlet.java @@ -1,182 +1,319 @@ package com.controller.schoadmin; +// 声明该类所在的包为 com.controller.schoadmin，用于组织和管理与学校管理员相关的控制器类 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类可能封装了与数据库交互的方法，如执行 SQL 查询、获取记录总数等操作 + import com.dao.StuDao; +// 导入自定义的 StuDao 类，用于执行与学生相关的数据查询操作，如查询学生打卡信息等 + import com.entity.PageBean; +// 导入自定义的 PageBean 类，用于封装分页相关的信息，如当前页码、每页记录数、总记录数、数据列表等 + import com.entity.StuPunch; +// 导入自定义的 StuPunch 类，这是一个实体类，用于封装学生打卡的相关信息，如学生编号、姓名、班级、打卡状态等 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 类，通常包含与 JDBC（Java Database Connectivity）操作相关的工具方法，如获取数据库连接、关闭连接、处理结果集等 import javax.servlet.ServletException; +// 导入 Servlet 异常类，用于处理 Servlet 执行过程中可能出现的异常情况 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将一个普通的 Java 类标记为 Servlet，并指定其访问路径 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，所有的 HTTP Servlet 都需要继承该类，并重写相应的方法来处理 HTTP 请求 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 接口，用于封装客户端发送的 HTTP 请求信息，如请求参数、请求头、请求方法等 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 接口，用于封装服务器返回给客户端的 HTTP 响应信息，如响应状态码、响应头、响应内容等 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 接口，用于管理用户会话，存储用户在一次会话期间的相关信息，如用户登录状态、用户信息等 + import java.io.IOException; +// 导入 IOException 类，用于处理输入输出操作中可能出现的异常情况，如文件读取、网络传输等异常 + import java.sql.ResultSet; +// 导入 ResultSet 接口，用于表示数据库查询结果集，通过该接口可以遍历和获取查询结果中的每一行数据 + import java.util.ArrayList; +// 导入 ArrayList 类，用于存储和操作动态数组，这里用于存储查询到的学生打卡信息 @WebServlet("/SchoQueryStuPunchByPageServlet") +// 使用 WebServlet 注解将当前类标记为一个 Servlet，并指定其访问路径为 /SchoQueryStuPunchByPageServlet，客户端可以通过该路径访问该 Servlet + public class SchoQueryStuPunchByPageServlet extends HttpServlet { + // 定义一个公共类 SchoQueryStuPunchByPageServlet，继承自 HttpServlet 类，用于处理 HTTP 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 GET 请求 + // req 是 HttpServletRequest 对象，封装了客户端的请求信息；resp 是 HttpServletResponse 对象，用于向客户端发送响应信息 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保能正确处理包含中文等特殊字符的请求参数 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，确保能正确输出包含中文等特殊字符的响应内容 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8，告诉客户端响应的内容是 HTML 格式，且使用 UTF-8 编码 //获取请求参数 String sname = req.getParameter("sname"); + // 从请求中获取名为 "sname" 的参数值，该参数可能表示学生姓名，存储在字符串变量 sname 中 + String sclass = req.getParameter("sclass"); + // 从请求中获取名为 "sclass" 的参数值，该参数可能表示学生班级，存储在字符串变量 sclass 中 + String sdept = req.getParameter("sdept"); + // 从请求中获取名为 "sdept" 的参数值，该参数可能表示学生所在部门，存储在字符串变量 sdept 中 + String spunchdate = req.getParameter("spunchdate"); + // 从请求中获取名为 "spunchdate" 的参数值，该参数可能表示学生打卡日期，存储在字符串变量 spunchdate 中 System.out.println(sname); + // 将 sname 的值输出到控制台，用于调试目的，查看获取的学生姓名参数值 + System.out.println(sclass); + // 将 sclass 的值输出到控制台，用于调试目的，查看获取的学生班级参数值 + System.out.println(sdept); - System.out.println(spunchdate); + // 将 sdept 的值输出到控制台，用于调试目的，查看获取的学生所在部门参数值 + System.out.println(spunchdate); + // 将 spunchdate 的值输出到控制台，用于调试目的，查看获取的学生打卡日期参数值 //如果传入的参数为null，则置为空字符串 if (sname == null){ sname = ""; } + // 如果 sname 参数为 null，将其设置为空字符串，避免后续操作出现空指针异常 + if (sclass == null){ sclass = ""; } + // 如果 sclass 参数为 null，将其设置为空字符串，避免后续操作出现空指针异常 + if (sdept == null){ sdept = ""; } + // 如果 sdept 参数为 null，将其设置为空字符串，避免后续操作出现空指针异常 + if (spunchdate == null){ spunchdate = ""; } + // 如果 spunchdate 参数为 null，将其设置为空字符串，避免后续操作出现空指针异常 //变为like查询所需的字符串参数 String sname1 = "%" + sname + "%"; + // 在 sname 前后添加 % 符号，用于模糊查询，匹配包含 sname 字符串的学生姓名 + String sclass1 = "%" + sclass + "%"; + // 在 sclass 前后添加 % 符号，用于模糊查询，匹配包含 sclass 字符串的学生班级 + String sdept1 = "%" + sdept + "%"; + // 在 sdept 前后添加 % 符号，用于模糊查询，匹配包含 sdept 字符串的学生所在部门 + String spunchdate1 = "%" + spunchdate + "%"; + // 在 spunchdate 前后添加 % 符号，用于模糊查询，匹配包含 spunchdate 字符串的学生打卡日期 //设置请求的属性参数，后面需要用 req.setAttribute("sname",sname); + // 将 sname 参数设置为请求的属性，方便后续页面或其他处理使用 + req.setAttribute("sclass", sclass); + // 将 sclass 参数设置为请求的属性，方便后续页面或其他处理使用 + req.setAttribute("sdept", sdept); + // 将 sdept 参数设置为请求的属性，方便后续页面或其他处理使用 + req.setAttribute("spunchdate",spunchdate); + // 将 spunchdate 参数设置为请求的属性，方便后续页面或其他处理使用 System.out.println(sname1); + // 将 sname1 的值输出到控制台，用于调试目的，查看模糊查询的学生姓名参数 + System.out.println(sclass1); + // 将 sclass1 的值输出到控制台，用于调试目的，查看模糊查询的学生班级参数 + System.out.println(sdept1); + // 将 sdept1 的值输出到控制台，用于调试目的，查看模糊查询的学生所在部门参数 + System.out.println(spunchdate1); + // 将 spunchdate1 的值输出到控制台，用于调试目的，查看模糊查询的学生打卡日期参数 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话 + // String userName = (String) session.getAttribute("userName"); +// 注释掉的代码，原本是从会话中获取名为 "userName" 的属性值，并将其转换为字符串类型存储在 userName 变量中 + // String sno = (String) session.getAttribute("sno"); +// 注释掉的代码，原本是从会话中获取名为 "sno" 的属性值，并将其转换为字符串类型存储在 sno 变量中 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其转换为字符串类型存储在 belong 变量中，该属性可能表示用户所属的部门或角色等信息 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 查询语句，初始值为 null // System.out.println(userName); +// 注释掉的代码，原本是将 userName 的值输出到控制台，用于调试目的 + // System.out.println(sno); +// 注释掉的代码，原本是将 sno 的值输出到控制台，用于调试目的 + System.out.println(belong); + // 将 belong 的值输出到控制台，用于调试目的 + System.out.println("hdghghjg"); + // 输出一个调试信息，用于确认代码执行到此处 String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码 + // 从请求中获取名为 "currentPage" 的参数值，该参数表示当前页码 + String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数 + // 从请求中获取名为 "rows" 的参数值，该参数表示每页显示的记录数 //如果未设请求参数，此处自动设置参数为第一页 if (currentPage == null || "".equals(currentPage)){ currentPage = "1"; } + // 如果当前页码参数为空或未设置，将当前页码设置为 1 //如果没有设置rows的请求参数，此处自动设置 if (rows == null || "".equals(rows)){ rows = "7"; } + // 如果每页显示的记录数参数为空或未设置，将每页显示的记录数设置为 7 //获取条件查询的参数 int currentPage1 = Integer.parseInt(currentPage); + // 将当前页码字符串转换为整数类型 + int rows1 = Integer.parseInt(rows); + // 将每页显示的记录数字符串转换为整数类型 //如果当前页数小于1，则设置当前页数为1 if (currentPage1 <= 0){ currentPage1 = 1; } + // 如果当前页码小于等于 0，将当前页码设置为 1 //设置StuPunch类的对象类型 PageBean pageBean = new PageBean(); + // 创建一个 PageBean 类的对象 pageBean，泛型指定为 StuPunch 类型，用于存储学生打卡信息的分页数据 //设置当前页码 pageBean.setCurrentPage(currentPage1); + // 将当前页码设置到 pageBean 对象中 //设置每页的记录数 pageBean.setRows(rows1); + // 将每页显示的记录数设置到 pageBean 对象中 sql = " select count(*) as num from student s, stupunchin sp where s.sno = sp.sno and s.sname like ? and s.sclass like ? and s.sdept like ? and sp.spunchdate like ?"; + // 定义一个 SQL 查询语句，用于查询满足条件（学生姓名、班级、部门、打卡日期模糊匹配）的学生打卡记录总数，通过关联 student 表和 stupunchin 表 + Object[] objects = {sname1, sclass1, sdept1, spunchdate1}; + // 创建一个 Object 类型的数组 objects，将模糊查询所需的参数放入数组中 //计算总记录数，并设置 int totalCount = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回满足条件的记录总数 + System.out.println(totalCount); + // 将总记录数输出到控制台，用于调试目的 + pageBean.setTotalCount(totalCount); + // 将总记录数设置到 pageBean 对象中 if (totalCount > 0){ + // 如果总记录数大于 0，说明存在满足条件的记录 + //计算总页码，并设置 int totalPage = (totalCount % rows1) == 0 ? totalCount/rows1 : (totalCount/rows1 + 1); + // 根据总记录数和每页显示的记录数计算总页码，如果总记录数能被每页记录数整除，则总页码为总记录数除以每页记录数；否则，总页码为总记录数除以每页记录数加 1 + pageBean.setTotalPage(totalPage); + // 将总页码设置到 pageBean 对象中 //如果当前页数大于总页数 if (currentPage1 > pageBean.getTotalPage()){ currentPage1 = pageBean.getTotalPage(); + // 如果当前页码大于总页码，将当前页码设置为总页码 + //重新设置当前页码 pageBean.setCurrentPage(currentPage1); + // 将更新后的当前页码重新设置到 pageBean 对象中 } //计算开始的记录和list对象集合，并设置 int start = (currentPage1 - 1) * rows1; + // 根据当前页码和每页显示的记录数计算当前页的起始记录索引 + sql = "select s.sname,s.sclass,s.sdept,sp.* from student s, stupunchin sp where s.sno = sp.sno and s.sname like ? and s.sclass like ? and s.sdept like ? and sp.spunchdate like ? limit ?, ?"; + // 定义一个 SQL 查询语句，用于查询当前页的学生打卡信息，使用 limit 关键字进行分页查询，通过关联 student 表和 stupunchin 表 + Object[] objects1 = {sname1, sclass1, sdept1, spunchdate1, start, rows1}; + // 创建一个 Object 类型的数组 objects1，将模糊查询所需的参数和分页参数放入数组中 ResultSet resultSet = StuDao.QureyInfoByPage(sql, objects1); + // 调用 StuDao 类的 QureyInfoByPage 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回结果集 + ArrayList stuPunchArrayList = new ArrayList(); + // 创建一个 ArrayList 对象，用于存储查询到的学生打卡信息 try { while (resultSet.next()){ + // 遍历结果集，每次循环处理结果集中的一行数据 + StuPunch stuPunch = new StuPunch(); + // 创建一个 StuPunch 类的对象，用于存储当前行的学生打卡信息 + stuPunch.setSno(resultSet.getString("sno")); + // 从结果集中获取名为 "sno" 的列的值，并将其设置到 stuPunch 对象的 sno 属性中 + stuPunch.setSname(resultSet.getString("sname")); + // 从结果集中获取名为 "sname" 的列的值，并将其设置到 stuPunch 对象的 sname 属性中 + stuPunch.setSclass(resultSet.getString("sclass")); + // 从结果集中获取名为 "sclass" 的列的值，并将其设置到 stuPunch 对象的 sclass 属性中 + stuPunch.setSdept(resultSet.getString("sdept")); + // 从结果集中获取名为 "sdept" 的列的值，并将其设置到 stuPunch 对象的 sdept 属性中 + stuPunch.setSispunch(resultSet.getString("sispunch")); + // 从结果集中获取名为 "sispunch" 的列的值，并将其设置到 stuPunch 对象的 sispunch 属性中 + stuPunch.setSpunchdate(resultSet.getDate("spunchdate")); + // 从结果集中获取名为 "spunchdate" 的列的值，并将其设置到 stuPunch 对象的 spunchdate 属性中 + stuPunch.setSpunchtime(resultSet.getString("spunchtime")); + // 从结果集中获取名为 "spunchtime" 的列的值，并将其设置到 stuPunch 对象的 spunchtime 属性中 + stuPunch.setSishot(resultSet.getString("sishot")); + // 从结果集中获取名为 "sishot" 的列的值，并将其设置到 stuPunch 对象的 sishot 属性中 + stuPunch.setSiscough(resultSet.getString("siscough")); + // 从结果集中获取名为 "siscough" 的列的值，并将其设置到 stuPunch 对象的 siscough 属性中 + stuPunch.setSisseem(resultSet.getString("sisseem")); + // 从结果集中获取名为 "sisseem" 的列的值，并将其设置到 stuPunch 对象的 sisseem 属性中 + stuPunch.setSisdiagnose(resultSet.getString("sisdiagnose")); + // 从结果集中获取名为 "sisdiagnose" 的列的值，并将其设置到 stuPunch 对象的 sisdiagnose 属性中 + stuPunch.setSstatus(resultSet.getString("sstatus")); + // 从结果集中获取名为 "sstatus" 的列的值，并将其设置到 stuPunch 对象的 sstatus 属性中 + stuPunchArrayList.add(stuPunch); + // 将存储了当前行学生打卡信息的 stuPunch 对象添加到 stuPunchArrayList 中 } - } catch (Exception e) { - e.printStackTrace(); - }finally { - JDBCUtils.close(resultSet); - } - pageBean.setArrayList(stuPunchArrayList); - - System.out.println(stuPunchArrayList); - System.out.println(pageBean); - - req.setAttribute("pageBean", pageBean); - - req.getRequestDispatcher("/view/schoadmin/stupunchlist.jsp").forward(req, resp); - }else { - req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp); - } - } - - @Override - protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { - doGet(req, resp); - } -} + } catch (Exception e) \ No newline at end of file diff --git a/src/com/controller/schoadmin/SchoQueryTeaByIdServlet.java b/src/com/controller/schoadmin/SchoQueryTeaByIdServlet.java index e64e099..0b4365b 100644 --- a/src/com/controller/schoadmin/SchoQueryTeaByIdServlet.java +++ b/src/com/controller/schoadmin/SchoQueryTeaByIdServlet.java @@ -1,72 +1,141 @@ package com.controller.schoadmin; +// 声明该类所属的包为 com.controller.schoadmin，通常用于组织和管理与学校管理员相关的控制器类 import com.dao.DeptAdminDao; +// 导入自定义的数据访问对象类 DeptAdminDao，该类可能包含了与数据库交互的方法，比如执行 SQL 查询等操作 + import com.entity.Teacher; +// 导入自定义的实体类 Teacher，用于封装教师的相关信息，例如教师编号、姓名、性别等属性 + import com.utils.JDBCUtils; +// 导入自定义的工具类 JDBCUtils，该类可能提供了与 JDBC（Java Database Connectivity）操作相关的工具方法，如数据库连接的获取与关闭等 import javax.servlet.ServletException; +// 导入 Servlet 异常类，用于处理在 Servlet 执行过程中可能出现的异常情况 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这个注解用于将一个普通的 Java 类标记为 Servlet，并指定其在 Web 应用中的访问路径 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，所有的 HTTP Servlet 都需要继承该类，并重写相应的方法来处理 HTTP 请求 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 接口，它用于封装客户端发送的 HTTP 请求信息，比如请求参数、请求头、请求方法等 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 接口，它用于封装服务器返回给客户端的 HTTP 响应信息，例如响应状态码、响应头、响应内容等 + import java.io.IOException; +// 导入 IOException 类，用于处理在输入输出操作过程中可能出现的异常情况，比如网络传输异常等 + import java.sql.ResultSet; +// 导入 ResultSet 接口，用于表示数据库查询的结果集，通过该接口可以遍历和获取查询结果中的每一行数据 @WebServlet("/SchoQueryTeaByIdServlet") +// 使用 WebServlet 注解将当前类标记为一个 Servlet，并指定其访问路径为 /SchoQueryTeaByIdServlet，客户端可以通过这个路径来访问该 Servlet + public class SchoQueryTeaByIdServlet extends HttpServlet { + // 定义一个公共类 SchoQueryTeaByIdServlet，它继承自 HttpServlet 类，用于处理 HTTP 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法用于处理客户端发送的 GET 请求 + // req 是 HttpServletRequest 对象，封装了客户端的请求信息；resp 是 HttpServletResponse 对象，用于向客户端发送响应信息 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，这样可以确保正确处理包含中文等特殊字符的请求参数 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，以保证正确输出包含中文等特殊字符的响应内容 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8，告知客户端响应的内容是 HTML 格式，并且使用 UTF-8 编码 String tno = req.getParameter("tno"); + // 从请求中获取名为 "tno" 的参数值，这个参数可能表示教师的编号，将其存储在字符串变量 tno 中 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 查询语句，初始值设为 null + Object[] objects = {tno}; + // 创建一个 Object 类型的数组 objects，将 tno 作为数组的元素，用于后续的 SQL 查询参数传递 System.out.println(tno); + // 将 tno 的值输出到控制台，主要用于调试目的，方便查看获取到的教师编号 //查询是否存在此人 sql = "select count(*) as num from teacher where tno = ?"; + // 定义一个 SQL 查询语句，用于查询 teacher 表中教师编号（tno）等于传入参数 tno 的记录数量，并将结果列命名为 num + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，传入 SQL 查询语句和查询参数数组 objects，执行查询操作并返回满足条件的记录数量，将结果存储在整数变量 count 中 if (count > 0) { //有则继续操作 + // 如果查询到的记录数量大于 0，说明存在对应的教师记录，则继续后续的操作 + sql = "select * from teacher where tno = ?"; + // 定义一个新的 SQL 查询语句，用于查询 teacher 表中教师编号为 tno 的教师的详细信息（所有列） + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，传入 SQL 查询语句和查询参数数组 objects，执行查询操作并返回结果集，将结果存储在 ResultSet 对象 resultSet 中 + Teacher teacher = new Teacher(); + // 创建一个 Teacher 类的对象 teacher，用于存储从数据库查询到的教师信息 try { while (resultSet.next()){ + // 遍历结果集，每次循环处理结果集中的一行数据 + teacher.setTno(resultSet.getString("tno")); + // 从结果集中获取名为 "tno" 的列的值，并将其设置到 teacher 对象的 tno 属性中 + teacher.setTname(resultSet.getString("tname")); + // 从结果集中获取名为 "tname" 的列的值，并将其设置到 teacher 对象的 tname 属性中 + teacher.setTsex(resultSet.getString("tsex")); + // 从结果集中获取名为 "tsex" 的列的值，并将其设置到 teacher 对象的 tsex 属性中 + teacher.setTage(resultSet.getInt("tage")); + // 从结果集中获取名为 "tage" 的列的值，并将其设置到 teacher 对象的 tage 属性中 + teacher.setTdept(resultSet.getString("tdept")); + // 从结果集中获取名为 "tdept" 的列的值，并将其设置到 teacher 对象的 tdept 属性中 + teacher.setTphone(resultSet.getString("tphone")); + // 从结果集中获取名为 "tphone" 的列的值，并将其设置到 teacher 对象的 tphone 属性中 + teacher.setTpsw(resultSet.getString("tpsw")); + // 从结果集中获取名为 "tpsw" 的列的值，并将其设置到 teacher 对象的 tpsw 属性中 } } catch (Exception e) { e.printStackTrace(); + // 捕获并处理可能出现的异常情况，将异常的堆栈跟踪信息输出到控制台，方便进行调试 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，最终都调用 JDBCUtils 类的 close 方法关闭结果集，释放相关的数据库资源 } System.out.println(teacher.getTsex()); + // 将 teacher 对象的 tsex 属性值输出到控制台，用于调试目的，查看获取到的教师性别信息 req.setAttribute("teacher", teacher); + // 将 teacher 对象作为属性添加到请求对象 req 中，属性名为 "teacher"，以便后续的 JSP 页面可以获取到该教师信息 req.getRequestDispatcher("/view/schoadmin/altertea.jsp").forward(req, resp); + // 获取请求转发器，将请求 req 和响应 resp 转发到 /view/schoadmin/altertea.jsp 页面，让该页面继续处理请求并显示教师的信息，可能用于修改教师信息 }else { req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp); + // 如果查询到的记录数量为 0，说明不存在对应的教师记录，则将请求 req 和响应 resp 转发到 /view/alluse/noexistdataofalter.jsp 页面，提示用户没有可修改的数据 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，该方法用于处理客户端发送的 POST 请求 + doGet(req, resp); + // 调用 doGet 方法来处理 POST 请求，即对于这个 Servlet，POST 请求和 GET 请求的处理逻辑是相同的 } -} +} \ No newline at end of file diff --git a/src/com/controller/schoadmin/SchoQueryTeaByIdServlet1.java b/src/com/controller/schoadmin/SchoQueryTeaByIdServlet1.java index 35186a9..2dee3ce 100644 --- a/src/com/controller/schoadmin/SchoQueryTeaByIdServlet1.java +++ b/src/com/controller/schoadmin/SchoQueryTeaByIdServlet1.java @@ -1,81 +1,160 @@ package com.controller.schoadmin; +// 声明该类所在的包为 com.controller.schoadmin，用于组织和管理与学校管理员相关的控制器类 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类可能封装了与数据库交互的操作方法，用于执行数据库查询等操作 + import com.entity.Teacher; +// 导入自定义的 Teacher 实体类，用于封装教师的相关信息，如教师编号、姓名、性别、年龄等 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 类，通常包含与 JDBC（Java Database Connectivity）相关的工具方法，如获取数据库连接、关闭连接、处理结果集等 import javax.servlet.ServletException; +// 导入 Servlet 异常类，用于处理 Servlet 执行过程中可能出现的异常情况 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将一个普通的 Java 类标记为 Servlet，并指定其访问路径 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，所有的 HTTP Servlet 都需要继承该类，并重写相应方法来处理 HTTP 请求 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 接口，用于封装客户端发送的 HTTP 请求信息，如请求参数、请求头、请求方法等 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 接口，用于封装服务器返回给客户端的 HTTP 响应信息，如响应状态码、响应头、响应内容等 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 接口，用于管理用户会话，存储用户在一次会话期间的相关信息，如用户登录状态、用户信息等 + import java.io.IOException; +// 导入 IOException 类，用于处理输入输出操作中可能出现的异常情况，如网络传输异常等 + import java.sql.ResultSet; +// 导入 ResultSet 接口，用于表示数据库查询结果集，通过该接口可以遍历查询结果中的每一行数据 @WebServlet("/SchoQueryTeaByIdServlet1") +// 使用 WebServlet 注解将当前类标记为一个 Servlet，并指定其访问路径为 /SchoQueryTeaByIdServlet1，客户端可通过该路径访问该 Servlet + public class SchoQueryTeaByIdServlet1 extends HttpServlet { + // 定义一个公共类 SchoQueryTeaByIdServlet1，继承自 HttpServlet 类，用于处理 HTTP 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 GET 请求 + // req 是 HttpServletRequest 对象，封装了客户端的请求信息；resp 是 HttpServletResponse 对象，用于向客户端发送响应信息 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保能正确处理包含中文等特殊字符的请求参数 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，确保能正确输出包含中文等特殊字符的响应内容 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8，告知客户端响应的内容是 HTML 格式，且使用 UTF-8 编码 String tno = req.getParameter("tno"); + // 从请求中获取名为 "tno" 的参数值，该参数可能表示教师编号，将其存储在字符串变量 tno 中 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话 + // String userName = (String) session.getAttribute("userName"); +// 注释掉的代码，原本是从会话中获取名为 "userName" 的属性值，并将其转换为字符串类型存储在 userName 变量中 + // String sno = (String) session.getAttribute("sno"); +// 注释掉的代码，原本是从会话中获取名为 "sno" 的属性值，并将其转换为字符串类型存储在 sno 变量中 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其转换为字符串类型存储在 belong 变量中，该属性可能表示用户所属的部门或角色等信息 System.out.println(belong); + // 将 belong 变量的值输出到控制台，用于调试目的 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 查询语句，初始值为 null + Object[] objects = {tno}; + // 创建一个 Object 类型的数组 objects，将 tno 作为数组元素，用于后续的 SQL 查询参数传递 System.out.println(tno); + // 将 tno 变量的值输出到控制台，用于调试目的 //查询是否存在此人 sql = "select count(*) as num from teacher where tno = ?"; + // 定义一个 SQL 查询语句，用于查询教师表中教师编号为 tno 的记录数量，并将结果列命名为 num + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回满足条件的记录数量，将结果存储在整数变量 count 中 if (count > 0) { //有则继续操作 + // 如果查询到的记录数量大于 0，说明存在该教师编号对应的教师记录，则继续后续操作 + sql = "select * from teacher where tno = ?"; + // 定义一个新的 SQL 查询语句，用于查询教师表中教师编号为 tno 的教师的详细信息 + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回结果集，将结果存储在 ResultSet 对象 resultSet 中 + Teacher teacher = new Teacher(); + // 创建一个 Teacher 类的对象 teacher，用于存储查询到的教师信息 try { while (resultSet.next()){ + // 遍历结果集，每次循环处理结果集中的一行数据 + teacher.setTno(resultSet.getString("tno")); + // 从结果集中获取名为 "tno" 的列的值，并将其设置到 teacher 对象的 tno 属性中 + teacher.setTname(resultSet.getString("tname")); + // 从结果集中获取名为 "tname" 的列的值，并将其设置到 teacher 对象的 tname 属性中 + teacher.setTsex(resultSet.getString("tsex")); + // 从结果集中获取名为 "tsex" 的列的值，并将其设置到 teacher 对象的 tsex 属性中 + teacher.setTage(resultSet.getInt("tage")); + // 从结果集中获取名为 "tage" 的列的值，并将其设置到 teacher 对象的 tage 属性中 + teacher.setTdept(resultSet.getString("tdept")); + // 从结果集中获取名为 "tdept" 的列的值，并将其设置到 teacher 对象的 tdept 属性中 + teacher.setTphone(resultSet.getString("tphone")); + // 从结果集中获取名为 "tphone" 的列的值，并将其设置到 teacher 对象的 tphone 属性中 + teacher.setTpsw(resultSet.getString("tpsw")); + // 从结果集中获取名为 "tpsw" 的列的值，并将其设置到 teacher 对象的 tpsw 属性中 } } catch (Exception e) { e.printStackTrace(); + // 捕获并处理可能出现的异常，将异常的堆栈跟踪信息输出到控制台，方便调试 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，最终都调用 JDBCUtils 类的 close 方法关闭结果集，释放相关资源 } System.out.println(teacher.getTsex()); + // 将 teacher 对象的 tsex 属性值输出到控制台，用于调试目的 req.setAttribute("teacher", teacher); + // 将 teacher 对象作为属性添加到请求对象中，属性名为 "teacher"，以便在后续的 JSP 页面中可以获取该对象 req.getRequestDispatcher("/view/schoadmin/altertea.jsp").forward(req, resp); + // 获取请求转发器，将请求和响应对象转发到 /view/schoadmin/altertea.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 { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 POST 请求 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同 } -} +} \ No newline at end of file diff --git a/src/com/controller/schoadmin/SchoQueryTeaByPageServlet.java b/src/com/controller/schoadmin/SchoQueryTeaByPageServlet.java index 83259ec..0ec1715 100644 --- a/src/com/controller/schoadmin/SchoQueryTeaByPageServlet.java +++ b/src/com/controller/schoadmin/SchoQueryTeaByPageServlet.java @@ -1,165 +1,310 @@ package com.controller.schoadmin; +// 声明该类所在的包，用于组织和管理与学校管理员相关的控制器类 import com.dao.DeptAdminDao; +// 导入部门管理员数据访问对象类，用于与数据库进行交互，执行与部门管理相关的数据库操作 + import com.dao.StuDao; +// 导入学生数据访问对象类，用于执行与学生数据相关的数据库操作 + import com.entity.PageBean; +// 导入分页信息封装类，用于存储分页相关的数据，如当前页码、每页记录数、总记录数等 + import com.entity.Teacher; +// 导入教师实体类，用于封装教师的相关信息，如教师编号、姓名、性别等 + import com.utils.JDBCUtils; +// 导入 JDBC 工具类，该类提供了与 JDBC 操作相关的工具方法，如数据库连接的获取和关闭等 import javax.servlet.ServletException; +// 导入 Servlet 异常类，用于处理 Servlet 执行过程中可能出现的异常情况 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将一个普通的 Java 类标记为 Servlet，并指定其访问路径 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，所有的 HTTP Servlet 都需要继承该类，并重写相应的方法来处理 HTTP 请求 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 接口，用于封装客户端发送的 HTTP 请求信息，如请求参数、请求头、请求方法等 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 接口，用于封装服务器返回给客户端的 HTTP 响应信息，如响应状态码、响应头、响应内容等 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 接口，用于管理用户会话，存储用户在一次会话期间的相关信息，如用户登录状态、用户信息等 + import java.io.IOException; +// 导入 IOException 类，用于处理输入输出操作中可能出现的异常情况 + import java.sql.ResultSet; +// 导入 ResultSet 接口，用于表示数据库查询结果集，通过该接口可以遍历查询结果中的每一行数据 + import java.util.ArrayList; +// 导入 ArrayList 类，用于存储和操作动态数组，这里用于存储查询到的教师信息 @WebServlet("/SchoQueryTeaByPageServlet") +// 使用 WebServlet 注解将当前类标记为一个 Servlet，并指定其访问路径为 /SchoQueryTeaByPageServlet，客户端可以通过该路径访问该 Servlet + public class SchoQueryTeaByPageServlet extends HttpServlet { + // 定义一个公共类 SchoQueryTeaByPageServlet，继承自 HttpServlet 类，用于处理 HTTP 请求 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 GET 请求 + // req 是 HttpServletRequest 对象，封装了客户端的请求信息；resp 是 HttpServletResponse 对象，用于向客户端发送响应信息 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保可以正确处理包含中文等特殊字符的请求参数 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，确保可以正确输出包含中文等特殊字符的响应内容 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8，告诉客户端响应的内容是 HTML 格式，且使用 UTF-8 编码 //获取请求参数 String tno = req.getParameter("tno"); + // 从请求中获取名为 "tno" 的参数值，该参数可能表示教师编号 + String tname = req.getParameter("tname"); - String tdept = req.getParameter("tdept"); + // 从请求中获取名为 "tname" 的参数值，该参数可能表示教师姓名 + String tdept = req.getParameter("tdept"); + // 从请求中获取名为 "tdept" 的参数值，该参数可能表示教师所在部门 //如果传入的参数为null，则置为空字符串 if (tno == null){ tno = ""; } + // 如果 tno 参数为 null，则将其设置为空字符串，避免后续操作出现空指针异常 + if (tname == null){ tname = ""; } + // 如果 tname 参数为 null，则将其设置为空字符串，避免后续操作出现空指针异常 + if (tdept == null){ tdept = ""; } + // 如果 tdept 参数为 null，则将其设置为空字符串，避免后续操作出现空指针异常 //变为like查询所需的字符串参数 String tno1 = "%" + tno + "%"; + // 在 tno 前后添加 % 符号，用于模糊查询，匹配包含 tno 字符串的教师编号 + String tname1 = "%" + tname + "%"; + // 在 tname 前后添加 % 符号，用于模糊查询，匹配包含 tname 字符串的教师姓名 + String tdept1 = "%" + tdept + "%"; + // 在 tdept 前后添加 % 符号，用于模糊查询，匹配包含 tdept 字符串的教师所在部门 //设置请求的属性参数，后面需要用 req.setAttribute("tno", tno); + // 将 tno 参数设置为请求的属性，方便后续页面或其他处理使用 + req.setAttribute("tname",tname); + // 将 tname 参数设置为请求的属性，方便后续页面或其他处理使用 + req.setAttribute("tdept",tdept); + // 将 tdept 参数设置为请求的属性，方便后续页面或其他处理使用 System.out.println(tno1); + // 将 tno1 的值输出到控制台，用于调试目的 + System.out.println(tname1); + // 将 tname1 的值输出到控制台，用于调试目的 + System.out.println(tdept1); + // 将 tdept1 的值输出到控制台，用于调试目的 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话 + // String userName = (String) session.getAttribute("userName"); +// 注释掉的代码，原本是从会话中获取名为 "userName" 的属性值，并将其转换为字符串类型存储在 userName 变量中 + // String sno = (String) session.getAttribute("sno"); +// 注释掉的代码，原本是从会话中获取名为 "sno" 的属性值，并将其转换为字符串类型存储在 sno 变量中 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其转换为字符串类型存储在 belong 变量中，该属性可能表示用户所属的部门或角色等信息 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 查询语句，初始值为 null // System.out.println(userName); +// 注释掉的代码，原本是将 userName 的值输出到控制台，用于调试目的 + // System.out.println(sno); +// 注释掉的代码，原本是将 sno 的值输出到控制台，用于调试目的 + System.out.println(belong); + // 将 belong 的值输出到控制台，用于调试目的 + System.out.println("hdghghjg"); + // 输出一个调试信息，用于确认代码执行到此处 String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码 + // 从请求中获取名为 "currentPage" 的参数值，该参数表示当前页码 + String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数 + // 从请求中获取名为 "rows" 的参数值，该参数表示每页显示的记录数 //如果未设请求参数，此处自动设置参数为第一页 if (currentPage == null || "".equals(currentPage)){ currentPage = "1"; } + // 如果当前页码参数为空或未设置，则将当前页码设置为 1 //如果没有设置rows的请求参数，此处自动设置 if (rows == null || "".equals(rows)){ rows = "7"; } + // 如果每页显示的记录数参数为空或未设置，则将每页显示的记录数设置为 7 //获取条件查询的参数 int currentPage1 = Integer.parseInt(currentPage); + // 将当前页码字符串转换为整数类型 + int rows1 = Integer.parseInt(rows); + // 将每页显示的记录数字符串转换为整数类型 //如果当前页数小于1，则设置当前页数为1 if (currentPage1 <= 0){ currentPage1 = 1; } + // 如果当前页码小于等于 0，则将当前页码设置为 1 //设置StuPunch类的对象类型 PageBean pageBean = new PageBean(); + // 创建一个 PageBean 类的对象 pageBean，用于存储分页相关的信息，泛型指定为 Teacher 类型，表示存储的是教师信息 //设置当前页码 pageBean.setCurrentPage(currentPage1); + // 将当前页码设置到 pageBean 对象中 //设置每页的记录数 pageBean.setRows(rows1); + // 将每页显示的记录数设置到 pageBean 对象中 sql = " select count(*) as num from teacher where tno like ? and tname like ? and tdept like ?"; + // 定义一个 SQL 查询语句，用于查询满足条件（教师编号、姓名、部门模糊匹配）的记录总数 + Object[] objects = {tno1, tname1, tdept1}; + // 创建一个 Object 类型的数组 objects，将模糊查询所需的参数放入数组中 //计算总记录数，并设置 int totalCount = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回满足条件的记录总数 + System.out.println(totalCount); + // 将总记录数输出到控制台，用于调试目的 + pageBean.setTotalCount(totalCount); + // 将总记录数设置到 pageBean 对象中 if (totalCount > 0){ + // 如果总记录数大于 0，说明存在满足条件的记录 + //计算总页码，并设置 int totalPage = (totalCount % rows1) == 0 ? totalCount/rows1 : (totalCount/rows1 + 1); + // 根据总记录数和每页显示的记录数计算总页码，如果总记录数能被每页记录数整除，则总页码为总记录数除以每页记录数；否则，总页码为总记录数除以每页记录数加 1 + pageBean.setTotalPage(totalPage); + // 将总页码设置到 pageBean 对象中 //如果当前页数大于总页数 if (currentPage1 > pageBean.getTotalPage()){ currentPage1 = pageBean.getTotalPage(); + // 如果当前页码大于总页码，则将当前页码设置为总页码 + //重新设置当前页码 pageBean.setCurrentPage(currentPage1); + // 将更新后的当前页码重新设置到 pageBean 对象中 } //计算开始的记录和list对象集合，并设置 int start = (currentPage1 - 1) * rows1; + // 根据当前页码和每页显示的记录数计算当前页的起始记录索引 + sql = "select * from teacher where tno like ? and tname like ? and tdept like ? limit ?, ?"; + // 定义一个 SQL 查询语句，用于查询当前页的教师信息，使用 limit 关键字进行分页查询 + Object[] objects1 = {tno1, tname1, tdept1, start, rows1}; + // 创建一个 Object 类型的数组 objects1，将模糊查询所需的参数和分页参数放入数组中 ResultSet resultSet = StuDao.QureyInfoByPage(sql, objects1); + // 调用 StuDao 类的 QureyInfoByPage 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回结果集 + ArrayList teaArrayList = new ArrayList(); + // 创建一个 ArrayList 对象，用于存储查询到的教师信息 try { while (resultSet.next()){ + // 遍历结果集，每次循环处理结果集中的一行数据 + Teacher teacher = new Teacher(); + // 创建一个 Teacher 类的对象，用于存储当前行的教师信息 + teacher.setTno(resultSet.getString("tno")); + // 从结果集中获取名为 "tno" 的列的值，并将其设置到 teacher 对象的 tno 属性中 + teacher.setTname(resultSet.getString("tname")); + // 从结果集中获取名为 "tname" 的列的值，并将其设置到 teacher 对象的 tname 属性中 + teacher.setTsex(resultSet.getString("tsex")); + // 从结果集中获取名为 "tsex" 的列的值，并将其设置到 teacher 对象的 tsex 属性中 + teacher.setTage(resultSet.getInt("tage")); + // 从结果集中获取名为 "tage" 的列的值，并将其设置到 teacher 对象的 tage 属性中 + teacher.setTdept(resultSet.getString("tdept")); + // 从结果集中获取名为 "tdept" 的列的值，并将其设置到 teacher 对象的 tdept 属性中 + teacher.setTphone(resultSet.getString("tphone")); + // 从结果集中获取名为 "tphone" 的列的值，并将其设置到 teacher 对象的 tphone 属性中 + teacher.setTpsw(resultSet.getString("tpsw")); + // 从结果集中获取名为 "tpsw" 的列的值，并将其设置到 teacher 对象的 tpsw 属性中 + teaArrayList.add(teacher); + // 将存储了当前行教师信息的 teacher 对象添加到 teaArrayList 中 } } catch (Exception e) { e.printStackTrace(); + // 捕获并处理可能出现的异常，将异常的堆栈跟踪信息输出到控制台，方便调试 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，最终都调用 JDBCUtils 类的 close 方法关闭结果集，释放资源 } pageBean.setArrayList(teaArrayList); + // 将存储了当前页教师信息的 teaArrayList 设置到 pageBean 对象中 System.out.println(teaArrayList); + // 将 teaArrayList 输出到控制台，用于调试目的 + System.out.println(pageBean); + // 将 pageBean 输出到控制台，用于调试目的 req.setAttribute("pageBean", pageBean); + // 将 pageBean 对象作为属性添加到请求对象中，属性名为 "pageBean"，以便在后续的 JSP 页面中可以获取该对象 req.getRequestDispatcher("/view/schoadmin/teainfolist.jsp").forward(req, resp); + // 获取请求转发器，将请求和响应对象转发到 /view/schoadmin/teainfolist.jsp 页面，让该页面继续处理请求并显示当前页的教师信息 + }else { req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp); + // 如果总记录数为 0，说明不存在满足条件的记录，则将请求和响应对象转发到 /view/alluse/nodata.jsp 页面，提示用户没有相关数据 } } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 POST 请求 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同 } -} +} \ No newline at end of file diff --git a/src/com/controller/schoadmin/SchoQueryTeaPunchByIdServlet.java b/src/com/controller/schoadmin/SchoQueryTeaPunchByIdServlet.java index 996ba27..3f1c57a 100644 --- a/src/com/controller/schoadmin/SchoQueryTeaPunchByIdServlet.java +++ b/src/com/controller/schoadmin/SchoQueryTeaPunchByIdServlet.java @@ -1,74 +1,153 @@ package com.controller.schoadmin; +// 声明该类所在的包名为 com.controller.schoadmin，通常用于存放与学校管理员相关的控制器类。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类可能封装了与数据库交互的方法，如查询、插入、更新等操作。 + import com.entity.TeaPunch; +// 导入自定义的 TeaPunch 类，这是一个实体类，用于封装教师打卡的相关信息，比如教师编号、打卡日期、打卡状态等。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 类，该类一般包含了与 JDBC（Java Database Connectivity）操作相关的工具方法，例如数据库连接的获取和关闭等。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，用于处理 Servlet 执行过程中可能出现的异常情况。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，此注解可将一个普通的 Java 类标记为 Servlet，并指定其访问路径。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，这是 Java Servlet API 中的核心类，所有的 HTTP Servlet 都需要继承该类，并重写相应的方法来处理 HTTP 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 接口，用于封装客户端发送的 HTTP 请求信息，像请求参数、请求头、请求方法等都可以通过该接口获取。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 接口，用于封装服务器返回给客户端的 HTTP 响应信息，例如响应状态码、响应头、响应内容等。 + import java.io.IOException; +// 导入 IOException 类，用于处理输入输出操作中可能出现的异常，比如网络传输异常等。 + import java.sql.ResultSet; +// 导入 ResultSet 接口，该接口用于表示数据库查询的结果集，通过它可以遍历查询结果中的每一行数据。 @WebServlet("/SchoQueryTeaPunchByIdServlet") +// 使用 WebServlet 注解将当前类标记为一个 Servlet，并指定其访问路径为 /SchoQueryTeaPunchByIdServlet，客户端可以通过该路径访问该 Servlet。 + public class SchoQueryTeaPunchByIdServlet extends HttpServlet { + // 定义一个公共类 SchoQueryTeaPunchByIdServlet，继承自 HttpServlet 类，用于处理 HTTP 请求。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法用于处理客户端发送的 GET 请求。 + // req 是 HttpServletRequest 对象，封装了客户端的请求信息；resp 是 HttpServletResponse 对象，用于向客户端发送响应信息。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保可以正确处理包含中文等特殊字符的请求参数。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证可以正确输出包含中文等特殊字符的响应内容。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8，告知客户端响应的内容是 HTML 格式，且使用 UTF-8 编码。 //获取请求参数 String tno = req.getParameter("tno"); + // 从请求中获取名为 "tno" 的参数值，并将其存储在字符串变量 tno 中，这个参数可能代表教师编号。 + String tpunchdate = req.getParameter("tpunchdate"); + // 从请求中获取名为 "tpunchdate" 的参数值，并将其存储在字符串变量 tpunchdate 中，该参数可能表示教师打卡的日期。 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 查询语句，初始值设为 null。 + Object[] objects = {tno, tpunchdate}; + // 创建一个 Object 类型的数组 objects，将 tno 和 tpunchdate 作为数组元素，用于后续的 SQL 查询参数传递。 //查询是否存在此人 sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?"; + // 定义一个 SQL 查询语句，用于查询满足条件（教师编号为 tno 且打卡日期为 tpunchdate）的记录数量，并将结果列命名为 num。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回满足条件的记录数量，将结果存储在整数变量 count 中。 if (count > 0){ //有则继续操作 + // 如果查询到的记录数量大于 0，说明存在满足条件的教师打卡记录，继续后续操作。 + sql = "select t.tname,tp.* from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ?"; + // 定义一个新的 SQL 查询语句，用于查询满足条件的教师姓名和打卡记录的详细信息，通过关联 teacher 表和 teapunchin 表来获取数据。 + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回结果集，将结果存储在 ResultSet 对象 resultSet 中。 + TeaPunch teaPunch = new TeaPunch(); + // 创建一个 TeaPunch 类的对象 teaPunch，用于存储查询到的教师打卡信息。 try { while (resultSet.next()){ + // 遍历结果集，每次循环处理结果集中的一行数据。 + teaPunch.setTno(resultSet.getString("tno")); + // 从结果集中获取名为 "tno" 的列的值，并将其设置到 teaPunch 对象的 tno 属性中。 + teaPunch.setTname(resultSet.getString("tname")); + // 从结果集中获取名为 "tname" 的列的值，并将其设置到 teaPunch 对象的 tname 属性中。 + teaPunch.setTispunch(resultSet.getString("tispunch")); + // 从结果集中获取名为 "tispunch" 的列的值，并将其设置到 teaPunch 对象的 tispunch 属性中。 + teaPunch.setTpunchdate(resultSet.getDate("tpunchdate")); + // 从结果集中获取名为 "tpunchdate" 的列的值，并将其设置到 teaPunch 对象的 tpunchdate 属性中。 + teaPunch.setTpunchtime(resultSet.getString("tpunchtime")); + // 从结果集中获取名为 "tpunchtime" 的列的值，并将其设置到 teaPunch 对象的 tpunchtime 属性中。 + teaPunch.setTishot(resultSet.getString("tishot")); + // 从结果集中获取名为 "tishot" 的列的值，并将其设置到 teaPunch 对象的 tishot 属性中。 + teaPunch.setTiscough(resultSet.getString("tiscough")); + // 从结果集中获取名为 "tiscough" 的列的值，并将其设置到 teaPunch 对象的 tiscough 属性中。 + teaPunch.setTisseem(resultSet.getString("tisseem")); + // 从结果集中获取名为 "tisseem" 的列的值，并将其设置到 teaPunch 对象的 tisseem 属性中。 + teaPunch.setTisdiagnose(resultSet.getString("tisdiagnose")); + // 从结果集中获取名为 "tisdiagnose" 的列的值，并将其设置到 teaPunch 对象的 tisdiagnose 属性中。 + teaPunch.setTstatus(resultSet.getString("tstatus")); + // 从结果集中获取名为 "tstatus" 的列的值，并将其设置到 teaPunch 对象的 tstatus 属性中。 } } catch (Exception e) { e.printStackTrace(); + // 捕获并处理可能出现的异常，将异常的堆栈跟踪信息输出到控制台，方便调试。 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，最终都调用 JDBCUtils 类的 close 方法关闭结果集，释放相关资源。 } System.out.println(teaPunch.getTno()); + // 将 teaPunch 对象的 tno 属性值输出到控制台，用于调试目的。 + System.out.println(teaPunch.getTname()); + // 将 teaPunch 对象的 tname 属性值输出到控制台，用于调试目的。 req.setAttribute("teaPunch", teaPunch); + // 将 teaPunch 对象作为属性添加到请求对象中，属性名为 "teaPunch"，以便在后续的 JSP 页面中可以获取该对象。 req.getRequestDispatcher("/view/schoadmin/alterteapunch.jsp").forward(req, resp); + // 获取请求转发器，将请求和响应对象转发到 /view/schoadmin/alterteapunch.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 { + // 重写 HttpServlet 类的 doPost 方法，该方法用于处理客户端发送的 POST 请求。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同。 } -} +} \ No newline at end of file diff --git a/src/com/controller/schoadmin/SchoQueryTeaPunchByIdServlet1.java b/src/com/controller/schoadmin/SchoQueryTeaPunchByIdServlet1.java index 0dba841..b7124f5 100644 --- a/src/com/controller/schoadmin/SchoQueryTeaPunchByIdServlet1.java +++ b/src/com/controller/schoadmin/SchoQueryTeaPunchByIdServlet1.java @@ -1,83 +1,172 @@ package com.controller.schoadmin; +// 声明该类所在的包为 com.controller.schoadmin，用于组织和管理相关的控制器类，通常与学校管理员的功能相关。 import com.dao.DeptAdminDao; +// 导入自定义的 DeptAdminDao 类，该类可能封装了与数据库交互的操作，用于处理部门管理员相关的数据访问逻辑。 + import com.entity.TeaPunch; +// 导入自定义的 TeaPunch 类，这是一个实体类，用于封装教师打卡相关的信息，如教师编号、打卡日期、打卡状态等。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 类，该类通常包含了与 JDBC（Java Database Connectivity）操作相关的工具方法，如数据库连接、关闭资源等。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，用于处理 Servlet 执行过程中可能出现的异常情况。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，用于将一个普通的 Java 类标记为 Servlet，并指定其访问路径。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，这是 Java Servlet API 中的一个抽象类，所有的 HTTP Servlet 都需要继承该类，并重写相应的方法来处理 HTTP 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 接口，用于封装客户端发送的 HTTP 请求信息，如请求参数、请求头、请求方法等。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 接口，用于封装服务器返回给客户端的 HTTP 响应信息，如响应状态码、响应头、响应内容等。 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 接口，用于管理用户会话，存储用户在一次会话期间的相关信息，如用户登录状态、用户信息等。 + import java.io.IOException; +// 导入 IOException 类，用于处理输入输出操作中可能出现的异常情况。 + import java.sql.ResultSet; +// 导入 ResultSet 接口，用于表示数据库查询结果集，通过该接口可以遍历查询结果中的每一行数据。 @WebServlet("/SchoQueryTeaPunchByIdServlet1") +// 使用 WebServlet 注解将当前类标记为一个 Servlet，并指定其访问路径为 /SchoQueryTeaPunchByIdServlet1，客户端可以通过该路径访问该 Servlet。 + public class SchoQueryTeaPunchByIdServlet1 extends HttpServlet { + // 定义一个公共类 SchoQueryTeaPunchByIdServlet1，继承自 HttpServlet 类，用于处理 HTTP 请求。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 GET 请求。 + // req 是 HttpServletRequest 对象，封装了客户端的请求信息；resp 是 HttpServletResponse 对象，用于向客户端发送响应信息。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保可以正确处理包含中文等特殊字符的请求参数。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，确保可以正确输出包含中文等特殊字符的响应内容。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8，告诉客户端响应的内容是 HTML 格式，且使用 UTF-8 编码。 //获取请求参数 String tno = req.getParameter("tno"); + // 从请求中获取名为 "tno" 的参数值，并将其存储在字符串变量 tno 中，该参数可能表示教师编号。 + String tpunchdate = req.getParameter("tpunchdate"); + // 从请求中获取名为 "tpunchdate" 的参数值，并将其存储在字符串变量 tpunchdate 中，该参数可能表示教师打卡日期。 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。 + // String userName = (String) session.getAttribute("userName"); +// 注释掉的代码，原本是从会话中获取名为 "userName" 的属性值，并将其转换为字符串类型存储在 userName 变量中。 + // String sno = (String) session.getAttribute("sno"); +// 注释掉的代码，原本是从会话中获取名为 "sno" 的属性值，并将其转换为字符串类型存储在 sno 变量中。 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其转换为字符串类型存储在 belong 变量中，该属性可能表示用户所属的部门或角色等信息。 System.out.println(belong); + // 将 belong 变量的值输出到控制台，用于调试目的。 String sql = null; + // 声明一个字符串变量 sql，用于存储 SQL 查询语句，初始值为 null。 + Object[] objects = {tno, tpunchdate}; + // 创建一个 Object 类型的数组 objects，将 tno 和 tpunchdate 作为数组元素，用于后续的 SQL 查询参数传递。 //查询是否存在此人 sql = "select count(*) as num from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ?"; + // 定义一个 SQL 查询语句，用于查询满足条件（教师编号为 tno 且打卡日期为 tpunchdate）的记录数量，并将结果列命名为 num。 + int count = DeptAdminDao.findTotalCount(sql, objects); + // 调用 DeptAdminDao 类的 findTotalCount 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回满足条件的记录数量，存储在整数变量 count 中。 if (count > 0){ //有则继续操作 + // 如果查询到的记录数量大于 0，说明存在满足条件的教师打卡记录，则继续后续操作。 + sql = "select t.tname,tp.* from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ?"; + // 定义一个新的 SQL 查询语句，用于查询满足条件的教师姓名和打卡记录的详细信息。 + ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects); + // 调用 DeptAdminDao 类的 qureyInfo 方法，传入 SQL 查询语句和查询参数数组，执行查询并返回结果集，存储在 ResultSet 对象 resultSet 中。 + TeaPunch teaPunch = new TeaPunch(); + // 创建一个 TeaPunch 类的对象 teaPunch，用于存储查询到的教师打卡信息。 try { while (resultSet.next()){ + // 遍历结果集，每次循环处理结果集中的一行数据。 + teaPunch.setTno(resultSet.getString("tno")); + // 从结果集中获取名为 "tno" 的列的值，并将其设置到 teaPunch 对象的 tno 属性中。 + teaPunch.setTname(resultSet.getString("tname")); + // 从结果集中获取名为 "tname" 的列的值，并将其设置到 teaPunch 对象的 tname 属性中。 + teaPunch.setTispunch(resultSet.getString("tispunch")); + // 从结果集中获取名为 "tispunch" 的列的值，并将其设置到 teaPunch 对象的 tispunch 属性中。 + teaPunch.setTpunchdate(resultSet.getDate("tpunchdate")); + // 从结果集中获取名为 "tpunchdate" 的列的值，并将其设置到 teaPunch 对象的 tpunchdate 属性中。 + teaPunch.setTpunchtime(resultSet.getString("tpunchtime")); + // 从结果集中获取名为 "tpunchtime" 的列的值，并将其设置到 teaPunch 对象的 tpunchtime 属性中。 + teaPunch.setTishot(resultSet.getString("tishot")); + // 从结果集中获取名为 "tishot" 的列的值，并将其设置到 teaPunch 对象的 tishot 属性中。 + teaPunch.setTiscough(resultSet.getString("tiscough")); + // 从结果集中获取名为 "tiscough" 的列的值，并将其设置到 teaPunch 对象的 tiscough 属性中。 + teaPunch.setTisseem(resultSet.getString("tisseem")); + // 从结果集中获取名为 "tisseem" 的列的值，并将其设置到 teaPunch 对象的 tisseem 属性中。 + teaPunch.setTisdiagnose(resultSet.getString("tisdiagnose")); + // 从结果集中获取名为 "tisdiagnose" 的列的值，并将其设置到 teaPunch 对象的 tisdiagnose 属性中。 + teaPunch.setTstatus(resultSet.getString("tstatus")); + // 从结果集中获取名为 "tstatus" 的列的值，并将其设置到 teaPunch 对象的 tstatus 属性中。 } } catch (Exception e) { e.printStackTrace(); + // 捕获并处理可能出现的异常，将异常的堆栈跟踪信息输出到控制台，方便调试。 }finally { JDBCUtils.close(resultSet); + // 无论是否发生异常，最终都调用 JDBCUtils 类的 close 方法关闭结果集，释放资源。 } System.out.println(teaPunch.getTno()); + // 将 teaPunch 对象的 tno 属性值输出到控制台，用于调试目的。 + System.out.println(teaPunch.getTname()); + // 将 teaPunch 对象的 tname 属性值输出到控制台，用于调试目的。 req.setAttribute("teaPunch", teaPunch); + // 将 teaPunch 对象作为属性添加到请求对象中，属性名为 "teaPunch"，以便在后续的 JSP 页面中可以获取该对象。 req.getRequestDispatcher("/view/schoadmin/alterteapunch.jsp").forward(req, resp); + // 获取请求转发器，将请求和响应对象转发到 /view/schoadmin/alterteapunch.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 { + // 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 POST 请求。 + doGet(req, resp); + // 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同。 } -} +} \ No newline at end of file diff --git a/src/com/controller/schoadmin/SchoQueryTeaPunchByPageServlet.java b/src/com/controller/schoadmin/SchoQueryTeaPunchByPageServlet.java index c29dfa0..4194ca4 100644 --- a/src/com/controller/schoadmin/SchoQueryTeaPunchByPageServlet.java +++ b/src/com/controller/schoadmin/SchoQueryTeaPunchByPageServlet.java @@ -1,181 +1,284 @@ package com.controller.schoadmin; +// 声明该类所在的包为 com.controller.schoadmin，通过包的组织， +// 可以将相关功能的类集中管理，避免类名冲突，方便代码的维护和查找，体现了项目的逻辑结构。 import com.dao.DeptAdminDao; +// 导入自定义的数据访问对象类 DeptAdminDao，该类通常封装了与数据库交互的方法， +// 如执行 SQL 查询、插入、更新、删除等操作。在本代码中，会使用该类的方法来计算满足条件的记录总数。 + import com.dao.StuDao; +// 导入自定义的数据访问对象类 StuDao，虽然类名包含“Stu”（可能暗示与学生相关）， +// 但在本代码中用于执行分页查询教师打卡信息的操作（调用了其 QureyInfoByPage 方法）， +// 推测该类可能包含一些通用的分页查询数据库的方法。 + import com.entity.PageBean; +// 导入自定义的 PageBean 实体类，用于封装分页相关的信息， +// 例如当前页码、每页显示的记录数、总记录数、总页数以及数据列表等。 +// 这里用于管理和传递教师打卡信息的分页查询结果。 + import com.entity.TeaPunch; +// 导入自定义的 TeaPunch 实体类，用于封装教师打卡的相关信息， +// 包括教师编号、教师姓名、所属部门、是否打卡、打卡日期、打卡时间、身体状况等信息。 +// 后续会用它来存储从数据库查询到的教师打卡记录。 + import com.utils.JDBCUtils; +// 导入自定义的 JDBCUtils 工具类，该类一般包含与 JDBC（Java Database Connectivity） +// 相关的通用方法，如获取数据库连接、关闭数据库连接、处理结果集等操作。 +// 在本代码中，将使用该类的方法来关闭数据库查询结果集（ResultSet），释放数据库资源。 import javax.servlet.ServletException; +// 导入 Servlet 异常类，当 Servlet 在运行过程中出现异常情况， +// 如请求处理失败、资源加载错误、内部逻辑错误等，会抛出 ServletException 异常， +// 以便在代码中进行异常处理，保证程序的稳定性和可靠性。 + import javax.servlet.annotation.WebServlet; +// 导入 WebServlet 注解，这是 Java EE 中用于将普通 Java 类标记为 Servlet 的注解。 +// 通过该注解可以指定 Servlet 的访问路径，使得客户端能够通过特定的 URL 来访问该 Servlet， +// 从而实现客户端与服务器之间的交互。 + import javax.servlet.http.HttpServlet; +// 导入 HttpServlet 类，它是所有 Servlet 类的基类，提供了处理 HTTP 请求的基本框架和方法。 +// 我们定义的 Servlet 类继承 HttpServlet 类，从而获得处理 HTTP 请求的能力， +// 能够响应客户端发送的 GET 和 POST 请求。 + import javax.servlet.http.HttpServletRequest; +// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息， +// 包括请求参数、请求头、请求方法等内容。Servlet 可以通过这个类获取客户端传递的数据， +// 以便根据这些数据进行相应的业务逻辑处理，如获取教师打卡信息查询的条件参数和分页参数等。 + import javax.servlet.http.HttpServletResponse; +// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息， +// 如响应状态码、响应头、响应体等。Servlet 可以利用这个类来设置并返回给客户端相应的响应数据， +// 以满足客户端的需求，如设置响应的字符编码和内容类型，以及将查询结果页面转发给客户端等。 + import javax.servlet.http.HttpSession; +// 导入 HttpSession 类，用于管理用户的会话状态，能够在用户的多次请求之间存储和共享数据， +// 例如用户的登录信息、权限信息、所属部门等。在本 Servlet 中，将使用它来获取用户所属部门等会话信息， +// 作为教师打卡信息查询的条件之一。 + import java.io.IOException; +// 导入输入输出异常类，当进行输入输出相关的操作（如网络数据传输、文件读写等）时， +// 如果出现错误，就会抛出 IOException 异常，以便进行相应的错误处理， +// 保证系统在面对异常情况时能够做出合理的响应。 + import java.sql.ResultSet; +// 导入 ResultSet 类，用于表示数据库查询结果集。当执行 SQL 查询语句后， +// 数据库返回的数据会被封装在 ResultSet 对象中，通过它可以遍历和获取查询结果的每一行数据， +// 以便进行进一步的处理和分析，如将查询到的教师打卡信息存储到 TeaPunch 对象中。 + import java.util.ArrayList; +// 导入 ArrayList 类，它是 Java 集合框架中的一种动态数组实现。 +// 可以用来存储和管理一组对象，并且可以根据需要动态地增加或减少元素数量。 +// 在本 Servlet 中，将使用 ArrayList 来存储从数据库查询到的教师打卡对象（TeaPunch）。 @WebServlet("/SchoQueryTeaPunchByPageServlet") +// 使用 WebServlet 注解将 SchoQueryTeaPunchByPageServlet 类标记为一个 Servlet， +// 并指定其访问路径为 /SchoQueryTeaPunchByPageServlet，这样客户端就可以通过这个路径向该 Servlet 发送请求， +// 从而触发该 Servlet 中的业务逻辑处理，实现教师打卡信息的分页查询功能。 + public class SchoQueryTeaPunchByPageServlet extends HttpServlet { + // 定义一个名为 SchoQueryTeaPunchByPageServlet 的类，继承自 HttpServlet 类， + // 使其成为一个可以处理 HTTP 请求的 Servlet，能够响应客户端发送的 GET 和 POST 请求， + // 并实现根据条件分页查询教师打卡信息的功能。 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 重写 HttpServlet 类的 doGet 方法，该方法专门用于处理客户端发送的 HTTP GET 请求。 + // 它接收 HttpServletRequest 对象 req 和 HttpServletResponse 对象 resp 作为参数， + // 并且在执行过程中可能会抛出 ServletException 和 IOException 异常，以处理可能出现的错误情况。 + req.setCharacterEncoding("utf-8"); + // 设置请求的字符编码为 UTF-8，确保服务器能够正确处理包含中文等特殊字符的请求参数， + // 避免出现乱码问题，保证请求数据的准确性。 + resp.setCharacterEncoding("utf-8"); + // 设置响应的字符编码为 UTF-8，保证返回给客户端的内容能够正确显示中文等特殊字符， + // 确保响应数据的正确呈现，避免客户端显示乱码。 + resp.setContentType("text/html;charset=utf-8"); + // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8， + // 告知客户端返回的是 HTML 格式的内容，并且按照 UTF-8 编码进行解析和显示， + // 以便客户端能够正确处理和展示响应数据。 //获取请求参数 String tno = req.getParameter("tno"); + // 从 HTTP 请求中获取名为 "tno" 的参数值，并将其赋值给字符串变量 tno。 + // 这里的 tno 代表教师编号，用于后续根据教师编号进行模糊查询教师打卡信息。 + String tname = req.getParameter("tname"); + // 从 HTTP 请求中获取名为 "tname" 的参数值，并将其赋值给字符串变量 tname。 + // 这里的 tname 代表教师姓名，用于后续根据教师姓名进行模糊查询教师打卡信息。 + String tdept = req.getParameter("tdept"); + // 从 HTTP 请求中获取名为 "tdept" 的参数值，并将其赋值给字符串变量 tdept。 + // 这里的 tdept 代表教师所属部门，用于后续根据部门进行模糊查询教师打卡信息。 + String tpunchdate = req.getParameter("tpunchdate"); + // 从 HTTP 请求中获取名为 "tpunchdate" 的参数值，并将其赋值给字符串变量 tpunchdate。 + // 这里的 tpunchdate 代表教师打卡日期，用于后续根据打卡日期进行模糊查询教师打卡信息。 System.out.println(tno); + // 在控制台打印获取到的教师编号参数 tno，用于调试目的，方便开发人员查看参数值是否正确。 + System.out.println(tname); + // 在控制台打印获取到的教师姓名参数 tname，用于调试目的，方便开发人员查看参数值是否正确。 + System.out.println(tdept); - System.out.println(tpunchdate); + // 在控制台打印获取到的教师所属部门参数 tdept，用于调试目的，方便开发人员查看参数值是否正确。 + System.out.println(tpunchdate); + // 在控制台打印获取到的教师打卡日期参数 tpunchdate，用于调试目的，方便开发人员查看参数值是否正确。 //如果传入的参数为null，则置为空字符串 if (tno == null){ tno = ""; } + // 如果获取到的教师编号参数 tno 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 + if (tname == null){ tname = ""; } + // 如果获取到的教师姓名参数 tname 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 + if (tdept == null){ tdept = ""; } + // 如果获取到的教师所属部门参数 tdept 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 + if (tpunchdate == null){ tpunchdate = ""; } + // 如果获取到的教师打卡日期参数 tpunchdate 为 null，则将其设置为空字符串， + // 以确保后续的模糊查询能够正常进行，避免空指针异常。 //变为like查询所需的字符串参数 String tno1 = "%" + tno + "%"; + // 将教师编号参数 tno 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 tno 的前后添加通配符 "%"，以便查询包含该编号片段的教师打卡记录。 + String tname1 = "%" + tname + "%"; + // 将教师姓名参数 tname 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 tname 的前后添加通配符 "%"，以便查询包含该姓名片段的教师打卡记录。 + String tdept1 = "%" + tdept + "%"; + // 将教师所属部门参数 tdept 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 tdept 的前后添加通配符 "%"，以便查询包含该部门片段的教师打卡记录。 + String tpunchdate1 = "%" + tpunchdate + "%"; + // 将教师打卡日期参数 tpunchdate 转换为适合 SQL 模糊查询（LIKE 语句）的字符串格式， + // 在 tpunchdate 的前后添加通配符 "%"，以便查询包含该日期片段的教师打卡记录。 //设置请求的属性参数，后面需要用 req.setAttribute("tno", tno); + // 将原始的教师编号参数 tno 设置为请求的属性，键为 "tno"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 + req.setAttribute("tname",tname); + // 将原始的教师姓名参数 tname 设置为请求的属性，键为 "tname"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 + req.setAttribute("tdept", tdept); + // 将原始的教师所属部门参数 tdept 设置为请求的属性，键为 "tdept"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 + req.setAttribute("tpunchdate",tpunchdate); + // 将原始的教师打卡日期参数 tpunchdate 设置为请求的属性，键为 "tpunchdate"， + // 以便在后续的页面中可以通过这个键获取到该参数值，用于展示查询条件或进行其他操作。 System.out.println(tno1); + // 在控制台打印转换后的教师编号模糊查询参数 tno1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 + System.out.println(tname1); + // 在控制台打印转换后的教师姓名模糊查询参数 tname1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 + System.out.println(tdept1); + // 在控制台打印转换后的教师所属部门模糊查询参数 tdept1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 + System.out.println(tpunchdate1); + // 在控制台打印转换后的教师打卡日期模糊查询参数 tpunchdate1，用于调试目的， + // 方便开发人员查看转换后的参数是否正确。 //获取登录时的session会话对象 HttpSession session = req.getSession(); + // 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。 + // 通过会话对象可以存储和获取用户在会话期间的相关信息，如用户所属部门等。 + // String userName = (String) session.getAttribute("userName"); + // 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值， + // 但在当前代码中未被使用，可能是根据实际需求进行了调整或暂时不需要该功能。 + // String sno = (String) session.getAttribute("sno"); + // 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值， + // 这里的变量名与前面获取请求参数的 tno、tname、tdept、tpunchdate 等不同， + // 且在当前代码中未被使用，可能是后续功能的预留或不再需要该属性值。 + String belong = (String) session.getAttribute("belong"); + // 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong。 + // 这里的 belong 可能代表用户所属的部门信息，用于后续的数据库查询条件， + // 确保查询的教师打卡信息与用户所属部门相关。 String sql = null; + // 声明一个字符串变量 sql，用于存储即将执行的 SQL 语句，初始值设为 null， + // 后续会根据业务逻辑动态地构建和赋值 SQL 语句。 // System.out.println(userName); + // 注释掉的代码，原本用于在控制台打印从会话中获取的用户名 userName， + // 但由于该变量未被使用，所以此打印语句也被注释掉。 + // System.out.println(sno); + // 注释掉的代码，原本用于在控制台打印从会话中获取的学生编号 sno， + // 但由于该变量未被使用，所以此打印语句也被注释掉。 + System.out.println(belong); + // 在控制台打印从会话中获取的用户所属部门信息 belong，用于调试目的， + // 方便开发人员查看获取到的部门信息是否正确。 + System.out.println("hdghghjg"); + // 在控制台打印字符串 "hdghghjg"，可能是开发人员用于调试或标记的输出内容， + // 可以帮助确定代码执行到的位置。 String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码 + // 从 HTTP 请求中获取名为 "currentPage" 的参数值，并将其赋值给字符串变量 currentPage。 + // 这里的 currentPage 代表当前页码，用于实现分页查询功能。 + String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数 + // 从 HTTP 请求中获取名为 "rows" 的参数值，并将其赋值给字符串变量 rows。 + // 这里的 rows 代表每页显示的记录数，用于实现分页查询功能。 //如果未设请求参数，此处自动设置参数为第一页 if (currentPage == null || "".equals(currentPage)){ currentPage = "1"; } + // 如果获取到的当前页码参数 currentPage 为 null 或空字符串，则将其设置为 "1"， + // 即默认显示第一页的教师打卡信息，确保分页查询的正常进行。 //如果没有设置rows的请求参数，此处自动设置 if (rows == null || "".equals(rows)){ rows = "7"; } + // 如果获取到的每页显示行数参数 rows 为 null 或空字符串，则将其设置为 "7"， + // 即默认每页显示 7 条教师打卡记录，确保分页查询的正常进行。 //获取条件查询的参数 int currentPage1 = Integer.parseInt(currentPage); + // 将字符串类型的当前页码参数 currentPage 转换为整数类型，并赋值给变量 currentPage1， + // 以便后续进行计算和处理。 + int rows1 = Integer.parseInt(rows); + // 将字符串类型的每页显示行数参数 rows 转换为整数类型，并赋值给变量 rows1， + // 以便后续进行计算和处理。 //如果当前页数小于1，则设置当前页数为1 if (currentPage1 <= 0){ currentPage1 = 1; } + // 如果转换后的当前页码 currentPage1 小于等于 0，则将其设置为 1， + // 确保当前页码是有效的，避免出现负数或零页码的情况。 - //设置StuPunch类的对象类型 - PageBean pageBean = new PageBean(); - - //设置当前页码 - pageBean.setCurrentPage(currentPage1); - - //设置每页的记录数 - pageBean.setRows(rows1); - - sql = " select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tno like ? and t.tname like ? and t.tdept like ? and tp.tpunchdate like ?"; - Object[] objects = {tno1, tname1, tdept1, tpunchdate1}; - - //计算总记录数，并设置 - int totalCount = DeptAdminDao.findTotalCount(sql, objects); - System.out.println(totalCount); - pageBean.setTotalCount(totalCount); - - if (totalCount > 0){ - //计算总页码，并设置 - int totalPage = (totalCount % rows1) == 0 ? totalCount/rows1 : (totalCount/rows1 + 1); - pageBean.setTotalPage(totalPage); - - //如果当前页数大于总页数 - if (currentPage1 > pageBean.getTotalPage()){ - currentPage1 = pageBean.getTotalPage(); - //重新设置当前页码 - pageBean.setCurrentPage(currentPage1); - } - - //计算开始的记录和list对象集合，并设置 - int start = (currentPage1 - 1) * rows1; - sql = "select t.tname,t.tdept, tp.* from teacher t, teapunchin tp where t.tno = tp.tno and t.tno like ? and t.tname like ? and t.tdept like ? and tp.tpunchdate like ? limit ?, ?"; - Object[] objects1 = {tno1, tname1, tdept1, tpunchdate1, start, rows1}; - - ResultSet resultSet = StuDao.QureyInfoByPage(sql, objects1); - ArrayList teaPunchArrayList = new ArrayList(); - - try { - while (resultSet.next()){ - TeaPunch teaPunch = new TeaPunch(); - teaPunch.setTno(resultSet.getString("tno")); - teaPunch.setTname(resultSet.getString("tname")); - teaPunch.setTdept(resultSet.getString("tdept")); - teaPunch.setTispunch(resultSet.getString("tispunch")); - teaPunch.setTpunchdate(resultSet.getDate("tpunchdate")); - teaPunch.setTpunchtime(resultSet.getString("tpunchtime")); - teaPunch.setTishot(resultSet.getString("tishot")); - teaPunch.setTiscough(resultSet.getString("tiscough")); - teaPunch.setTisseem(resultSet.getString("tisseem")); - teaPunch.setTisdiagnose(resultSet.getString("tisdiagnose")); - teaPunch.setTstatus(resultSet.getString("tstatus")); - teaPunchArrayList.add(teaPunch); - } - } catch (Exception e) { - e.printStackTrace(); - }finally { - JDBCUtils.close(resultSet); - } - pageBean.setArrayList(teaPunchArrayList); - - System.out.println(teaPunchArrayList); - System.out.println(pageBean); - - req.setAttribute("pageBean", pageBean); - - req.getRequestDispatcher("/view/schoadmin/teapunchlist.jsp").forward(req, resp); - }else { - req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp); - } - } - - @Override - protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { - doGet(req, resp); - } -} + //设置St \ No newline at end of file diff --git a/src/com/controller/tea/TeaQueryInfoServlet.java b/src/com/controller/tea/TeaQueryInfoServlet.java index b83bbd6..a74813a 100644 --- a/src/com/controller/tea/TeaQueryInfoServlet.java +++ b/src/com/controller/tea/TeaQueryInfoServlet.java @@ -11,7 +11,7 @@ import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; -import javax.servlet.http.HttpSession; +import javax.servlet.http.HttpSession;//不急不急 import java.io.IOException; import java.sql.ResultSet; import java.util.ArrayList; diff --git a/zp.txt b/zp.txt new file mode 100644 index 0000000..e7b6f34 --- /dev/null +++ b/zp.txt @@ -0,0 +1,3821 @@ +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() { + + } +} \ No newline at end of file diff --git a/行数说明.txt b/行数说明.txt new file mode 100644 index 0000000..c3d476a --- /dev/null +++ b/行数说明.txt @@ -0,0 +1,3 @@ +韩强龙总代码行数：6931行 +刘嘉成总代码行数：4500行 +邹鹏总代码行数 ：3800行 \ No newline at end of file