3 #14

Merged
pt3ulnghe merged 9 commits from feature/hql into develop 10 months ago

@ -63,21 +63,21 @@
<component name="ProjectViewState">
<option name="showLibraryContents" value="true" />
</component>
<component name="PropertiesComponent">{
&quot;keyToString&quot;: {
&quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
&quot;SHARE_PROJECT_CONFIGURATION_FILES&quot;: &quot;true&quot;,
&quot;git-widget-placeholder&quot;: &quot;feature/hql&quot;,
&quot;kotlin-language-version-configured&quot;: &quot;true&quot;,
&quot;last_opened_file_path&quot;: &quot;D:/demo8/lsepidemicsituationsystem&quot;,
&quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
&quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
&quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
&quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
&quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
&quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
<component name="PropertiesComponent"><![CDATA[{
"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"
}
}</component>
}]]></component>
<component name="RecentsManager">
<key name="CopyClassDialog.RECENTS_KEY">
<recent name="com.filter" />
@ -370,7 +370,15 @@
<option name="project" value="LOCAL" />
<updated>1745903462350</updated>
</task>
<option name="localTasksCounter" value="3" />
<task id="LOCAL-00003" summary="Default Changelist">
<option name="closed" value="true" />
<created>1745904438150</created>
<option name="number" value="00003" />
<option name="presentableId" value="LOCAL-00003" />
<option name="project" value="LOCAL" />
<updated>1745904438150</updated>
</task>
<option name="localTasksCounter" value="4" />
<servers />
</component>
<component name="TypeScriptGeneratedFilesManager">

@ -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请求
}
}

@ -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);
//如果学生成功插入数据库,跳转到另一个 ServletDeptQueryStuByPageServlet用于分页查询学生信息。
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 请求的处理逻辑一致,避免重复代码。
}
}

@ -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 请求的处理逻辑一致,避免重复代码。
}
}

@ -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);

@ -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);

@ -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);

@ -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);
}

@ -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);

@ -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);

@ -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 请求的处理逻辑相同
}
}
}

@ -1,59 +1,115 @@
package com.controller.deptadmin;
// 声明该类所属的包名为 com.controller.deptadmin包名通常用于组织和管理代码避免命名冲突
import com.dao.DeptAdminDao;
// 导入自定义的 DeptAdminDao 类,这个类可能包含了与数据库交互的方法,如查询、插入、更新和删除等操作
import com.utils.JDBCUtils;
// 导入自定义的 JDBCUtils 类,这个类一般用于封装 JDBCJava 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" 的参数值,并将其赋值给字符串变量 snosno 可能代表学生编号
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 请求,即对于该 ServletPOST 请求和 GET 请求的处理逻辑相同
}
}
}

@ -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 请求,即对于该 ServletPOST 请求和 GET 请求的处理逻辑相同。
}
}
}
Loading…
Cancel
Save