diff --git a/.idea/workspace.xml b/.idea/workspace.xml index ecb35ed..0b09772 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -63,21 +63,21 @@ - { - "keyToString": { - "RunOnceActivity.git.unshallow": "true", - "SHARE_PROJECT_CONFIGURATION_FILES": "true", - "git-widget-placeholder": "feature/hql", - "kotlin-language-version-configured": "true", - "last_opened_file_path": "D:/demo8/lsepidemicsituationsystem", - "node.js.detected.package.eslint": "true", - "node.js.detected.package.tslint": "true", - "node.js.selected.package.eslint": "(autodetect)", - "node.js.selected.package.tslint": "(autodetect)", - "nodejs_package_manager_path": "npm", - "vue.rearranger.settings.migration": "true" + +}]]> @@ -370,7 +370,15 @@ diff --git a/src/com/controller/deptadmin/DeptAddStuPunchServlet.java b/src/com/controller/deptadmin/DeptAddStuPunchServlet.java index e46c73e..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.util.Date;//你好话能否凯撒今年佛龛 +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