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

2 #12

Closed
pt3ulnghe wants to merge 7 commits from feature/hql into develop
Conversation 0 Commits 7 Files Changed 14
14 changed files with 493 additions and 364 deletions
Show Stats Download Patch File Download Diff File

2
.idea/misc.xml
Unescape View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
<component name="ProjectRootManager" version="2" languageLevel="JDK_23" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" />
</component>
</project>

190
.idea/workspace.xml
Unescape View File

@ -5,8 +5,13 @@
<artifact name="lsepidemicsituationsystem:war exploded" />
</artifacts-to-build>
</component>
<component name="AutoImportSettings">
<option name="autoReloadType" value="SELECTIVE" />
</component>
<component name="ChangeListManager">
<list default="true" id="0ffa26fe-3275-4667-90ad-c688ca600b30" name="Default Changelist" comment="" />
<list default="true" id="0ffa26fe-3275-4667-90ad-c688ca600b30" name="Default Changelist" comment="Default Changelist">
<change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
</list>
<option name="SHOW_DIALOG" value="false" />
<option name="HIGHLIGHT_CONFLICTS" value="true" />
<option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
@ -23,6 +28,14 @@
</list>
</option>
</component>
<component name="Git.Settings">
<option name="RECENT_BRANCH_BY_REPOSITORY">
<map>
<entry key="$PROJECT_DIR$" value="zp" />
</map>
</option>
<option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
</component>
<component name="LogFilters">
<option name="FILTER_ERRORS" value="false" />
<option name="FILTER_WARNINGS" value="false" />
@ -33,7 +46,8 @@
<component name="MavenImportPreferences">
<option name="generalSettings">
<MavenGeneralSettings>
<option name="mavenHome" value="$PROJECT_DIR$/../../../../Program Files/apache-maven-3.6.3-bin/apache-maven-3.6.3" />
<option name="customMavenHome" value="$PROJECT_DIR$/../../Program Files/apache-maven-3.6.3-bin/apache-maven-3.6.3" />
<option name="mavenHomeTypeForPersistence" value="CUSTOM" />
</MavenGeneralSettings>
</option>
<option name="importingSettings">
@ -42,27 +56,28 @@
</MavenImportingSettings>
</option>
</component>
<component name="ProjectColorInfo">{
&quot;associatedIndex&quot;: 8
}</component>
<component name="ProjectId" id="1ZsRq0O38W9j2DAyvPgaq78h6F5" />
<component name="ProjectViewState">
<option name="showExcludedFiles" value="true" />
<option name="showLibraryContents" value="true" />
</component>
<component name="PropertiesComponent">
<property name="RunOnceActivity.ShowReadmeOnStart" value="true" />
<property name="WebServerToolWindowFactoryState" value="false" />
<property name="aspect.path.notification.shown" value="true" />
<property name="last_opened_file_path" value="$PROJECT_DIR$/web" />
<property name="node.js.detected.package.eslint" value="true" />
<property name="node.js.detected.package.tslint" value="true" />
<property name="node.js.path.for.package.eslint" value="project" />
<property name="node.js.path.for.package.tslint" value="project" />
<property name="node.js.selected.package.eslint" value="(autodetect)" />
<property name="node.js.selected.package.tslint" value="(autodetect)" />
<property name="project.structure.last.edited" value="Artifacts" />
<property name="project.structure.proportion" value="0.15" />
<property name="project.structure.side.proportion" value="0.2" />
<property name="settings.editor.selected.configurable" value="com.alibabacloud.intellij.config.AccountConfigurable" />
</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>
<component name="RecentsManager">
<key name="CopyClassDialog.RECENTS_KEY">
<recent name="com.filter" />
@ -181,6 +196,15 @@
</list>
</option>
</component>
<component name="SharedIndexes">
<attachedChunks>
<set>
<option value="bundled-jdk-9823dce3aa75-125ca727e0f0-intellij.indexing.shared.core-IU-243.24978.46" />
<option value="bundled-js-predefined-d6986cc7102b-76f8388c3a79-JavaScript-IU-243.24978.46" />
</set>
</attachedChunks>
</component>
<component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="应用程序级" UseSingleDictionary="true" transferred="true" />
<component name="SshConsoleOptionsProvider">
<option name="myEncoding" value="UTF-8" />
</component>
@ -328,116 +352,32 @@
<workItem from="1588858985099" duration="3090000" />
<workItem from="1588865103089" duration="22000" />
<workItem from="1589092133957" duration="947000" />
<workItem from="1745901580332" duration="1948000" />
</task>
<task id="LOCAL-00001" summary="Default Changelist">
<option name="closed" value="true" />
<created>1745902440005</created>
<option name="number" value="00001" />
<option name="presentableId" value="LOCAL-00001" />
<option name="project" value="LOCAL" />
<updated>1745902440005</updated>
</task>
<task id="LOCAL-00002" summary="Default Changelist">
<option name="closed" value="true" />
<created>1745903462350</created>
<option name="number" value="00002" />
<option name="presentableId" value="LOCAL-00002" />
<option name="project" value="LOCAL" />
<updated>1745903462350</updated>
</task>
<option name="localTasksCounter" value="3" />
<servers />
</component>
<component name="TypeScriptGeneratedFilesManager">
<option name="version" value="1" />
<option name="version" value="3" />
</component>
<component name="WindowStateProjectService">
<state x="361" y="71" key="#Deployment" timestamp="1586742405632">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="361" y="71" key="#Deployment/0.0.1536.824@0.0.1536.824" timestamp="1586742405632" />
<state x="361" y="71" key="#Notifications" timestamp="1586873500031">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="361" y="71" key="#Notifications/0.0.1536.824@0.0.1536.824" timestamp="1586873500031" />
<state x="223" y="67" key="#com.intellij.execution.impl.EditConfigurationsDialog" timestamp="1587092060624">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="223" y="67" key="#com.intellij.execution.impl.EditConfigurationsDialog/0.0.1536.824@0.0.1536.824" timestamp="1587092060624" />
<state x="574" y="113" key="#com.intellij.ide.util.MemberChooser" timestamp="1588834378807">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="574" y="113" key="#com.intellij.ide.util.MemberChooser/0.0.1536.824@0.0.1536.824" timestamp="1588834378807" />
<state x="360" y="70" key="#com.intellij.j2ee.appServerIntegrations.ApplicationServersConfigurable" timestamp="1586936177273">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="360" y="70" key="#com.intellij.j2ee.appServerIntegrations.ApplicationServersConfigurable/0.0.1536.824@0.0.1536.824" timestamp="1586936177273" />
<state x="449" y="147" key="#com.intellij.openapi.updateSettings.impl.PluginUpdateInfoDialog" timestamp="1587015912260">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="449" y="147" key="#com.intellij.openapi.updateSettings.impl.PluginUpdateInfoDialog/0.0.1536.824@0.0.1536.824" timestamp="1587015912260" />
<state x="548" y="297" width="441" height="239" key="#com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesDialog.classes" timestamp="1588836089834">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="548" y="297" width="441" height="239" key="#com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesDialog.classes/0.0.1536.824@0.0.1536.824" timestamp="1588836089834" />
<state x="499" y="159" key="#com.intellij.refactoring.safeDelete.UnsafeUsagesDialog" timestamp="1585703317967">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="499" y="159" key="#com.intellij.refactoring.safeDelete.UnsafeUsagesDialog/0.0.1536.824@0.0.1536.824" timestamp="1585703317967" />
<state x="499" y="167" key="#com.intellij.util.ui.classpath.ChooseLibrariesDialog" timestamp="1585649986773">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="499" y="167" key="#com.intellij.util.ui.classpath.ChooseLibrariesDialog/0.0.1536.824@0.0.1536.824" timestamp="1585649986773" />
<state x="548" y="167" key="FileChooserDialogImpl" timestamp="1588862467375">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="548" y="167" key="FileChooserDialogImpl/0.0.1536.824@0.0.1536.824" timestamp="1588862467375" />
<state width="1023" height="221" key="GridCell.Tab.0.bottom" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.0.bottom/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.0.center" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.0.center/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.0.left" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.0.left/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.0.right" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.0.right/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.1.bottom" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.1.bottom/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.1.center" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.1.center/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.1.left" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.1.left/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.1.right" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.1.right/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.2.bottom" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.2.bottom/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.2.center" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.2.center/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.2.left" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.2.left/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.2.right" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.2.right/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state x="270" y="0" key="SettingsEditor" timestamp="1588862594087">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="270" y="0" key="SettingsEditor/0.0.1536.824@0.0.1536.824" timestamp="1588862594087" />
<state x="418" y="92" key="com.intellij.openapi.editor.actions.MultiplePasteAction$ClipboardContentChooser" timestamp="1587023080650">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="418" y="92" key="com.intellij.openapi.editor.actions.MultiplePasteAction$ClipboardContentChooser/0.0.1536.824@0.0.1536.824" timestamp="1587023080650" />
<state x="178" y="22" key="new project wizard" timestamp="1586955583169">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="178" y="22" key="new project wizard/0.0.1536.824@0.0.1536.824" timestamp="1586955583169" />
<state x="431" y="145" width="672" height="678" key="search.everywhere.popup" timestamp="1586439092287">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="431" y="145" width="672" height="678" key="search.everywhere.popup/0.0.1536.824@0.0.1536.824" timestamp="1586439092287" />
<component name="VcsManagerConfiguration">
<MESSAGE value="Default Changelist" />
<option name="LAST_COMMIT_MESSAGE" value="Default Changelist" />
</component>
</project>

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

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

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

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

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

68
src/com/controller/deptadmin/DeptAlterStuPunchServlet.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,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);

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

43
src/com/controller/deptadmin/DeptDeleteStuPunchServlet1.java
Unescape View File

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

62
src/com/controller/deptadmin/DeptDeleteStuServlet.java
Unescape View File

@ -1,59 +1,115 @@
package com.controller.deptadmin;
// 声明该类所属的包名为 com.controller.deptadmin，包名通常用于组织和管理代码，避免命名冲突
import com.dao.DeptAdminDao;
// 导入自定义的 DeptAdminDao 类，这个类可能包含了与数据库交互的方法，如查询、插入、更新和删除等操作
import com.utils.JDBCUtils;
// 导入自定义的 JDBCUtils 类，这个类一般用于封装 JDBC（Java Database Connectivity）操作，如数据库连接的获取和关闭等
import javax.servlet.ServletException;
// 导入 Servlet 异常类，用于处理 Servlet 操作过程中可能出现的异常情况
import javax.servlet.annotation.WebServlet;
// 导入 WebServlet 注解，用于将当前类标记为一个 Servlet，并指定其访问路径
import javax.servlet.http.HttpServlet;
// 导入 HttpServlet 类，它是所有 Servlet 类的基类，用于处理 HTTP 请求
import javax.servlet.http.HttpServletRequest;
// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息，包括请求参数、请求头、请求方法等
import javax.servlet.http.HttpServletResponse;
// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息，包括响应状态码、响应头、响应体等
import java.io.IOException;
// 导入输入输出异常类，用于处理在输入输出操作（如文件读写、网络传输等）过程中可能出现的异常
import java.sql.ResultSet;
// 导入 ResultSet 类，它用于表示数据库查询结果集，可通过它遍历查询结果中的每一行数据
import java.sql.SQLException;
// 导入 SQL 异常类，用于处理与数据库交互过程中可能出现的 SQL 相关异常
import java.util.ArrayList;
// 导入 ArrayList 类，它是 Java 集合框架中的一种动态数组，可用于存储和操作一组对象
import java.util.Iterator;
// 导入 Iterator 接口，它提供了一种遍历集合元素的方式
@WebServlet("/DeptDeleteStuServlet")
// 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /DeptDeleteStuServlet，客户端可以通过该路径访问这个 Servlet
public class DeptDeleteStuServlet extends HttpServlet {
// 定义一个名为 DeptDeleteStuServlet 的类，继承自 HttpServlet 类，使其成为一个 Servlet
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 HTTP GET 请求
req.setCharacterEncoding("utf-8");
// 设置请求的字符编码为 UTF-8，确保能够正确处理包含中文等特殊字符的请求参数
resp.setCharacterEncoding("utf-8");
// 设置响应的字符编码为 UTF-8，确保返回给客户端的内容能够正确显示中文等特殊字符
resp.setContentType("text/html;charset=utf-8");
// 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8，告诉客户端返回的是 HTML 格式的内容
String sno = req.getParameter("sno");
// 从 HTTP 请求中获取名为 "sno" 的参数值，并将其赋值给字符串变量 sno，sno 可能代表学生编号
System.out.println(sno);
// 在控制台打印 sno 的值，用于调试目的
String sql = null;
// 声明一个字符串变量 sql，用于存储 SQL 语句，初始值为 null
Object[] objects = {sno};
// 创建一个 Object 类型的数组 objects，将 sno 作为唯一元素存储在数组中，这个数组将用于 SQL 语句的参数绑定
//查询是否存在此人
sql = "select count(*) as num from student where sno = ?";
// 定义一个 SQL 查询语句，用于查询 student 表中 sno 等于传入参数的记录数量，使用占位符 ? 表示参数
int count = DeptAdminDao.findTotalCount(sql, objects);
// 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询，并将查询结果（记录数量）赋值给整数变量 count
if (count > 0) { //有则继续操作
// 如果查询到的记录数量大于 0，说明数据库中存在该学生的记录
//删除stupunchin中的该导游信息
sql = "delete from stupunchin where sno = ?";
// 定义一个 SQL 删除语句，用于删除 stupunchin 表中 sno 等于传入参数的记录
int num1 = DeptAdminDao.executeUpdate(sql, objects);
// 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句，并将受影响的记录数量赋值给整数变量 num1
System.out.println(num1);
// 在控制台打印受影响的记录数量，用于调试目的
//删除student表中该导游信息
sql = "delete from student where sno = ?";
// 定义一个 SQL 删除语句，用于删除 student 表中 sno 等于传入参数的记录
int num2 = DeptAdminDao.executeUpdate(sql, objects);
// 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句，并将受影响的记录数量赋值给整数变量 num2
System.out.println(num2);
// 在控制台打印受影响的记录数量，用于调试目的
req.getRequestDispatcher("/DeptQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&specialty=").forward(req, resp);
}else {
// 将请求转发到 /DeptQueryStuByPageServlet 页面，并传递相应的参数，用于重新查询学生信息并显示在页面上
} else {
req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);
// 如果查询到的记录数量为 0，说明数据库中不存在该学生的记录，将请求转发到 /view/alluse/noexistdataofdelete.jsp 页面，提示用户无数据可删除
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 HTTP POST 请求
doGet(req, resp);
// 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同
}
}
}

63
src/com/controller/deptadmin/DeptDeleteStuServlet1.java
Unescape View File

@ -1,64 +1,121 @@
package com.controller.deptadmin;
// 声明该类所在的包，用于组织和管理代码，将相关功能的类放在同一个包中，方便维护和查找。
import com.dao.DeptAdminDao;
// 导入自定义的 DeptAdminDao 类，该类通常包含与数据库交互的方法，比如查询、插入、更新和删除等操作。
import javax.servlet.ServletException;
// 导入 Servlet 异常类，当 Servlet 操作出现异常时会抛出该异常。
import javax.servlet.annotation.WebServlet;
// 导入 WebServlet 注解，用于将一个类标记为 Servlet 并指定其访问路径。
import javax.servlet.http.HttpServlet;
// 导入 HttpServlet 类，它是所有 Servlet 类的基类，用于处理 HTTP 请求。
import javax.servlet.http.HttpServletRequest;
// 导入 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息，例如请求参数、请求头、请求方法等。
import javax.servlet.http.HttpServletResponse;
// 导入 HttpServletResponse 类，用于封装服务器返回给客户端的 HTTP 响应信息，例如响应状态码、响应头、响应体等。
import javax.servlet.http.HttpSession;
// 导入 HttpSession 类，用于管理用户会话，存储用户在一次会话期间的相关信息。
import java.io.IOException;
// 导入输入输出异常类，当进行输入输出操作（如文件读写、网络传输等）出现异常时会抛出该异常。
@WebServlet("/DeptDeleteStuServlet1")
// 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /DeptDeleteStuServlet1，客户端可以通过这个路径访问该 Servlet。
public class DeptDeleteStuServlet1 extends HttpServlet {
// 定义一个名为 DeptDeleteStuServlet1 的类，继承自 HttpServlet 类，使其成为一个 Servlet。
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写 HttpServlet 类的 doGet 方法，用于处理客户端发送的 HTTP GET 请求。
req.setCharacterEncoding("utf-8");
// 设置请求的字符编码为 UTF-8，确保能够正确处理包含中文等特殊字符的请求参数。
resp.setCharacterEncoding("utf-8");
// 设置响应的字符编码为 UTF-8，确保返回给客户端的内容能够正确显示中文等特殊字符。
resp.setContentType("text/html;charset=utf-8");
// 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8，告诉客户端返回的是 HTML 格式的内容。
String sno = req.getParameter("sno");
// 从 HTTP 请求中获取名为 "sno" 的参数值，并将其赋值给字符串变量 sno，通常 "sno" 可能代表学生编号。
System.out.println(sno);
// 在控制台打印 sno 的值，用于调试目的，方便开发人员查看接收到的参数。
//获取登录时的session会话对象
HttpSession session = req.getSession();
// 获取当前请求对应的 HttpSession 对象，如果会话不存在则会创建一个新的会话。
// String userName = (String) session.getAttribute("userName");
// 注释掉的代码，原本用于从会话中获取名为 "userName" 的属性值。
// String sno = (String) session.getAttribute("sno");
// 注释掉的代码，原本用于从会话中获取名为 "sno" 的属性值，这里注释掉避免与前面已定义的 sno 变量冲突。
String belong = (String) session.getAttribute("belong");
// 从会话中获取名为 "belong" 的属性值，并将其赋值给字符串变量 belong，通常 "belong" 可能代表学生所属的部门。
System.out.println(belong);
// 在控制台打印 belong 的值，用于调试目的，方便开发人员查看从会话中获取的部门信息。
String sql = null;
// 声明一个字符串变量 sql，用于存储 SQL 语句，初始值为 null。
Object[] objects = {sno, belong};
// 创建一个 Object 类型的数组 objects，将 sno 和 belong 作为元素存储在数组中，这个数组将用于 SQL 语句的参数绑定。
//查询是否存在此人
sql = "select count(*) as num from student where sno = ? and sdept = ?";
// 定义一个 SQL 查询语句，用于查询 student 表中学生编号为 sno 且所属部门为 belong 的记录数量，使用占位符 ? 表示参数。
int count = DeptAdminDao.findTotalCount(sql, objects);
// 调用 DeptAdminDao 类的 findTotalCount 方法，执行上述 SQL 查询，并将查询结果（记录数量）赋值给整数变量 count。
Object[] objects1 = {sno};
// 创建一个新的 Object 类型的数组 objects1，只包含 sno 作为元素，用于后续删除操作的 SQL 语句参数绑定。
if (count > 0) { //有则继续操作
// 如果查询到的记录数量大于 0，说明数据库中存在符合条件的学生记录。
//删除stupunchin中的该导游信息
sql = "delete from stupunchin where sno = ?";
// 定义一个 SQL 删除语句，用于删除 stupunchin 表中学生编号为 sno 的记录。
int num1 = DeptAdminDao.executeUpdate(sql, objects1);
// 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句，并将受影响的记录数量赋值给整数变量 num1。
System.out.println(num1);
// 在控制台打印受影响的记录数量，用于调试目的，方便开发人员查看删除操作的结果。
//删除student表中该导游信息
sql = "delete from student where sno = ?";
// 定义一个 SQL 删除语句，用于删除 student 表中学生编号为 sno 的记录。
int num2 = DeptAdminDao.executeUpdate(sql, objects1);
// 调用 DeptAdminDao 类的 executeUpdate 方法，执行上述 SQL 删除语句，并将受影响的记录数量赋值给整数变量 num2。
System.out.println(num2);
// 在控制台打印受影响的记录数量，用于调试目的，方便开发人员查看删除操作的结果。
req.getRequestDispatcher("/DeptQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&specialty=").forward(req, resp);
}else {
// 将请求转发到 /DeptQueryStuByPageServlet 页面，并传递相应的参数，用于重新查询学生信息并显示在页面上，实现页面刷新。
} else {
req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);
// 如果查询到的记录数量为 0，说明数据库中不存在符合条件的学生记录，将请求转发到 /view/alluse/noexistdataofdelete.jsp 页面，提示用户无数据可删除。
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写 HttpServlet 类的 doPost 方法，用于处理客户端发送的 HTTP POST 请求。
doGet(req, resp);
// 调用 doGet 方法处理 POST 请求，即对于该 Servlet，POST 请求和 GET 请求的处理逻辑相同。
}
}
}
Write Preview
Loading…
Cancel
Save