pt3ulnghe
/
lsepidemicsituationsystem
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

1 #2

Merged
pt3ulnghe merged 18 commits from feature/hql into master 10 months ago
Conversation 0 Commits 18 Files Changed 11
11 changed files with 422 additions and 237 deletions
Show Stats Download Patch File Download Diff File

186
.idea/workspace.xml
Unescape View File

@ -9,10 +9,9 @@
<option name="autoReloadType" value="SELECTIVE" />
</component>
<component name="ChangeListManager">
<list default="true" id="0ffa26fe-3275-4667-90ad-c688ca600b30" name="Default Changelist" comment="Update README.md">
<change afterPath="$PROJECT_DIR$/demo" afterDir="false" />
<change beforePath="$PROJECT_DIR$/.idea/misc.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/misc.xml" afterDir="false" />
<list default="true" id="0ffa26fe-3275-4667-90ad-c688ca600b30" name="Default Changelist" comment="&#10;Update README.md">
<change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/com/controller/deptadmin/DeptDeleteStuPunchServlet.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/com/controller/deptadmin/DeptDeleteStuPunchServlet.java" afterDir="false" />
</list>
<option name="SHOW_DIALOG" value="false" />
<option name="HIGHLIGHT_CONFLICTS" value="true" />
@ -70,20 +69,20 @@
<component name="ProjectViewState">
<option name="showLibraryContents" value="true" />
</component>
<component name="PropertiesComponent"><![CDATA[{
"keyToString": {
"RunOnceActivity.git.unshallow": "true",
"git-widget-placeholder": "feature/hql",
"kotlin-language-version-configured": "true",
"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",
"settings.editor.selected.configurable": "terminal",
"vue.rearranger.settings.migration": "true"
<component name="PropertiesComponent">{
&quot;keyToString&quot;: {
&quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
&quot;git-widget-placeholder&quot;: &quot;feature/hql&quot;,
&quot;kotlin-language-version-configured&quot;: &quot;true&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;settings.editor.selected.configurable&quot;: &quot;terminal&quot;,
&quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
}
}]]></component>
}</component>
<component name="RecentsManager">
<key name="CopyClassDialog.RECENTS_KEY">
<recent name="com.filter" />
@ -360,7 +359,11 @@
<workItem from="1589092133957" duration="947000" />
<workItem from="1745045574258" duration="638000" />
<workItem from="1745046236628" duration="3804000" />
<workItem from="1745050261322" duration="300000" />
<workItem from="1745050261322" duration="1665000" />
<workItem from="1745132180317" duration="4054000" />
<workItem from="1745152233098" duration="1401000" />
<workItem from="1745221944690" duration="2795000" />
<workItem from="1745320993991" duration="14000" />
</task>
<task id="LOCAL-00001" summary="Update README.md">
<option name="closed" value="true" />
@ -370,7 +373,151 @@
<option name="project" value="LOCAL" />
<updated>1745045644849</updated>
</task>
<option name="localTasksCounter" value="2" />
<task id="LOCAL-00002" summary="Update README.md">
<option name="closed" value="true" />
<created>1745050571734</created>
<option name="number" value="00002" />
<option name="presentableId" value="LOCAL-00002" />
<option name="project" value="LOCAL" />
<updated>1745050571734</updated>
</task>
<task id="LOCAL-00003" summary="Update README.md">
<option name="closed" value="true" />
<created>1745050664664</created>
<option name="number" value="00003" />
<option name="presentableId" value="LOCAL-00003" />
<option name="project" value="LOCAL" />
<updated>1745050664664</updated>
</task>
<task id="LOCAL-00004" summary="Update README.md">
<option name="closed" value="true" />
<created>1745133972442</created>
<option name="number" value="00004" />
<option name="presentableId" value="LOCAL-00004" />
<option name="project" value="LOCAL" />
<updated>1745133972442</updated>
</task>
<task id="LOCAL-00005" summary="Update README.md">
<option name="closed" value="true" />
<created>1745134213616</created>
<option name="number" value="00005" />
<option name="presentableId" value="LOCAL-00005" />
<option name="project" value="LOCAL" />
<updated>1745134213616</updated>
</task>
<task id="LOCAL-00006" summary="Update README.md">
<option name="closed" value="true" />
<created>1745134491092</created>
<option name="number" value="00006" />
<option name="presentableId" value="LOCAL-00006" />
<option name="project" value="LOCAL" />
<updated>1745134491092</updated>
</task>
<task id="LOCAL-00007" summary="Update README.md">
<option name="closed" value="true" />
<created>1745134591190</created>
<option name="number" value="00007" />
<option name="presentableId" value="LOCAL-00007" />
<option name="project" value="LOCAL" />
<updated>1745134591190</updated>
</task>
<task id="LOCAL-00008" summary="Update README.md">
<option name="closed" value="true" />
<created>1745134663366</created>
<option name="number" value="00008" />
<option name="presentableId" value="LOCAL-00008" />
<option name="project" value="LOCAL" />
<updated>1745134663366</updated>
</task>
<task id="LOCAL-00009" summary="Update README.md">
<option name="closed" value="true" />
<created>1745134803994</created>
<option name="number" value="00009" />
<option name="presentableId" value="LOCAL-00009" />
<option name="project" value="LOCAL" />
<updated>1745134803994</updated>
</task>
<task id="LOCAL-00010" summary="Update README.md">
<option name="closed" value="true" />
<created>1745134869459</created>
<option name="number" value="00010" />
<option name="presentableId" value="LOCAL-00010" />
<option name="project" value="LOCAL" />
<updated>1745134869459</updated>
</task>
<task id="LOCAL-00011" summary="&#10;Update README.md">
<option name="closed" value="true" />
<created>1745135002854</created>
<option name="number" value="00011" />
<option name="presentableId" value="LOCAL-00011" />
<option name="project" value="LOCAL" />
<updated>1745135002854</updated>
</task>
<task id="LOCAL-00012" summary="&#10;Update README.md">
<option name="closed" value="true" />
<created>1745135472858</created>
<option name="number" value="00012" />
<option name="presentableId" value="LOCAL-00012" />
<option name="project" value="LOCAL" />
<updated>1745135472858</updated>
</task>
<task id="LOCAL-00013" summary="&#10;Update README.md">
<option name="closed" value="true" />
<created>1745135922838</created>
<option name="number" value="00013" />
<option name="presentableId" value="LOCAL-00013" />
<option name="project" value="LOCAL" />
<updated>1745135922838</updated>
</task>
<task id="LOCAL-00014" summary="&#10;Update README.md">
<option name="closed" value="true" />
<created>1745222555582</created>
<option name="number" value="00014" />
<option name="presentableId" value="LOCAL-00014" />
<option name="project" value="LOCAL" />
<updated>1745222555582</updated>
</task>
<task id="LOCAL-00015" summary="&#10;Update README.md">
<option name="closed" value="true" />
<created>1745222859116</created>
<option name="number" value="00015" />
<option name="presentableId" value="LOCAL-00015" />
<option name="project" value="LOCAL" />
<updated>1745222859116</updated>
</task>
<task id="LOCAL-00016" summary="&#10;Update README.md">
<option name="closed" value="true" />
<created>1745223222532</created>
<option name="number" value="00016" />
<option name="presentableId" value="LOCAL-00016" />
<option name="project" value="LOCAL" />
<updated>1745223222532</updated>
</task>
<task id="LOCAL-00017" summary="&#10;Update README.md">
<option name="closed" value="true" />
<created>1745223742348</created>
<option name="number" value="00017" />
<option name="presentableId" value="LOCAL-00017" />
<option name="project" value="LOCAL" />
<updated>1745223742348</updated>
</task>
<task id="LOCAL-00018" summary="&#10;Update README.md">
<option name="closed" value="true" />
<created>1745224222647</created>
<option name="number" value="00018" />
<option name="presentableId" value="LOCAL-00018" />
<option name="project" value="LOCAL" />
<updated>1745224222647</updated>
</task>
<task id="LOCAL-00019" summary="&#10;Update README.md">
<option name="closed" value="true" />
<created>1745224650073</created>
<option name="number" value="00019" />
<option name="presentableId" value="LOCAL-00019" />
<option name="project" value="LOCAL" />
<updated>1745224650073</updated>
</task>
<option name="localTasksCounter" value="20" />
<servers />
</component>
<component name="TypeScriptGeneratedFilesManager">
@ -400,7 +547,8 @@
<component name="VcsManagerConfiguration">
<MESSAGE value="Default Changelist" />
<MESSAGE value="Update README.md" />
<option name="LAST_COMMIT_MESSAGE" value="Update README.md" />
<MESSAGE value="&#10;Update README.md" />
<option name="LAST_COMMIT_MESSAGE" value="&#10;Update README.md" />
</component>
<component name="XSLT-Support.FileAssociations.UIState">
<expand />

2
src/com/controller/alluse/LoginServlet.java
Unescape View File

@ -16,7 +16,7 @@ import java.sql.ResultSet;
@WebServlet("/LoginServlet")
public class LoginServlet extends HttpServlet {
//1
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");

47
src/com/controller/deptadmin/DeptAddStuPunchServlet.java
Unescape View File

@ -7,54 +7,59 @@ import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.IOException; //导入IO异常和日期类
import java.util.Date;
@WebServlet("/DeptAddStuPunchServlet")
public class DeptAddStuPunchServlet extends HttpServlet {
public class DeptAddStuPunchServlet extends HttpServlet { //定义一个继承自HttpServlet的Servlet类。
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //重写doGet方法，处理HTTP GET请求。
//统一请求和响应的字符编码为UTF-8，防止中文乱码，并设置响应内容类型为HTML。
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
//获取表单请求的参数
String sno = req.getParameter("sno");
String sispunch = req.getParameter("sispunch");
String spunchdate = req.getParameter("spunchdate");
String spunchtime = req.getParameter("spunchtime");
String sishot = req.getParameter("sishot");
String siscough = req.getParameter("siscough");
String sisseem = req.getParameter("sisseem");
String sisdiagnose = req.getParameter("sisdiagnose");
String sstatus = req.getParameter("sstatus");
String sno = req.getParameter("sno"); //从 HTTP 请求中获取参数名为 "sno" 的值，并将其赋值给 sno 变量
String sispunch = req.getParameter("sispunch");//从 HTTP 请求中获取参数名为 "sispunch" 的值，并将其赋值给 sispunch 变量
String spunchdate = req.getParameter("spunchdate");//从 HTTP 请求中获取参数名为 "spunchdate" 的值，并将其赋值给 spunchdate 变量
String spunchtime = req.getParameter("spunchtime");//从 HTTP 请求中获取参数名为 "spunchtime" 的值，并将其赋值给 spunchtime 变量
String sishot = req.getParameter("sishot");//从 HTTP 请求中获取参数名为 "sishot" 的值，并将其赋值给 sishot 变量
String siscough = req.getParameter("siscough");//从 HTTP 请求中获取参数名为 "siscough" 的值，并将其赋值给 siscough 变量
String sisseem = req.getParameter("sisseem");//从 HTTP 请求中获取参数名为 "sisseem" 的值，并将其赋值给 sisseem 变量
String sisdiagnose = req.getParameter("sisdiagnose");//从 HTTP 请求中获取参数名为 "sisdiagnose" 的值，并将其赋值给 sisdiagnose 变量
String sstatus = req.getParameter("sstatus");//从 HTTP 请求中获取参数名为 "sstatus" 的值，并将其赋值给 sstatus 变量
String sql = null;
//声明SQL语句变量，并输出调试信息
System.out.println("shgshgh");
//查询是否存在此人
sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?";
Object[] objects = {sno, spunchdate};
int count = DeptAdminDao.findTotalCount(sql, objects);
sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?";//检查stupunchin表中是否存在相同学号和日期的记录
Object[] objects = {sno, spunchdate}; //使用Object数组传递参数，防止SQL注入。
int count = DeptAdminDao.findTotalCount(sql, objects);//调用DAO方法findTotalCount返回匹配记录数。
if (count == 0){//无则操作
if (count == 0){//条件判断：如果不存在重复记录（count为0），执行插入操作。
sql = "insert into stupunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)";
Object[] objects1 = {sno, sispunch, spunchdate, spunchtime, sishot, siscough, sisseem, sisdiagnose, sstatus};
//SQL插入语句：向stupunchin表插入包含9个字段的新记录
//参数绑定：将表单参数按顺序填入占位符
int num = DeptAdminDao.executeUpdate(sql, objects1);
int num = DeptAdminDao.executeUpdate(sql, objects1);//执行更新：调用DAO方法executeUpdate执行插入，返回受影响的行数。
System.out.println(num);
req.getRequestDispatcher("/DeptQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&spunchdate=").forward(req, resp);
}else {
req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp);
}
req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp);//转发请求：插入成功后，转发到分页查询Servlet，显示第一页数据（参数currentPage=1，每页7行）。
}//处理重复数据：如果记录已存在，转发到提示页面existdataofadd.jsp
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
doGet(req, resp);//处理POST请求：重写doPost方法，直接调用doGet，统一处理GET和POST请求
}
}

52
src/com/controller/deptadmin/DeptAddStuServlet.java
Unescape View File

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

51
src/com/controller/deptadmin/DeptAddTeaPunchServlet.java
Unescape View File

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

56
src/com/controller/deptadmin/DeptAddTeaServlet.java
Unescape View File

@ -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,51 +10,52 @@ import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet("/DeptAddTeaServlet")
public class DeptAddTeaServlet 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 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");
//数据类型转换
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;
String sql = null;//声明一个 SQL 语句字符串变量 sql，用来存储后续的 SQL 查询语句。
System.out.println("shgshgh");
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);
int count = DeptAdminDao.findTotalCount(sql, objects);//DeptAdminDao.findTotalCount(sql, objects) 是自定义的方法，它执行该 SQL 查询并返回结果，即该编号的教师是否存在。返回的是一个整数，表示该编号的教师数量。
if (count == 0){//无则操作
sql = "insert into teacher values(?, ?, ?, ?, ?, ?, ?)";
Object[] objects1 = {tno, tname, tsex, tage1, tdept, tphone, tpsw};
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);
System.out.println(num);
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);
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);

52
src/com/controller/deptadmin/DeptAlterStuPunchServlet.java
Unescape View File

@ -1,45 +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("/DeptAlterStuPunchServlet")
public class DeptAlterStuPunchServlet 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");
//获取表单请求的参数
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");
resp.setContentType("text/html;charset=utf-8");//设置请求和响应的字符编码为 UTF-8，确保请求和响应的文本内容能够正确处理中文字符。
//从 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");//打卡状态
//构造了一个 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};
Object[] objects = {sispunch, spunchtime, sishot, siscough, sisseem, sisdiagnose, sstatus, sno, spunchdate};//创建一个对象数组 objects，该数组包含了 SQL 更新语句中使用的参数。数组中的值会被传递给数据库操作。
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("/DeptQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&spunchdate=").forward(req, resp);
req.getRequestDispatcher("/DeptQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&spunchdate=").forward(req, resp);//调用 RequestDispatcher 的 forward 方法，将请求转发到另一个 Servlet，通常是用于显示更新后的学生打卡信息。这会将用户重定向到 DeptQueryStuPunchByPageServlet，并附带了一些查询参数。
}
//这是重写的 doPost 方法。由于 doPost 方法的实现只是调用了 doGet，这意味着该 Servlet 支持同时处理 GET 和 POST 请求。实际上，POST 请求会被当作 GET 请求处理。
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);

58
src/com/controller/deptadmin/DeptAlterStuServlet.java
Unescape View File

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

55
src/com/controller/deptadmin/DeptAlterTeaPunchServlet.java
Unescape View File

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

56
src/com/controller/deptadmin/DeptAlterTeaServlet.java
Unescape View File

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

44
src/com/controller/deptadmin/DeptDeleteStuPunchServlet.java
Unescape View File

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

Write Preview
Loading…
Cancel
Save