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

Compare commits

merge into: pt3ulnghe:master
Branches Tags
pt3ulnghe:develop
pt3ulnghe:feature/hql
pt3ulnghe:ljc
pt3ulnghe:zp
pt3ulnghe:main
pt3ulnghe:master
...
pull from: pt3ulnghe:zp
Branches Tags
pt3ulnghe:develop
pt3ulnghe:feature/hql
pt3ulnghe:ljc
pt3ulnghe:zp
pt3ulnghe:main
pt3ulnghe:master

3 Commits
master ... zp

Author SHA1 Message Date
zp dce0951257 Default Changelist
10 months ago
zp c797ea3862 Default Changelist
10 months ago
zp 46a4e324bd Default Changelist
10 months ago
37 changed files with 2050 additions and 389 deletions
Show Stats

6
.idea/vcs.xml
Unescape View File

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="" vcs="Git" />
</component>
</project>

184
.idea/workspace.xml
Unescape View File

@ -5,16 +5,18 @@
<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" />
<option name="LAST_RESOLUTION" value="IGNORE" />
</component>
<component name="FavoritesManager">
<favorites_list name="lsepidemicsituationsystem" />
</component>
<component name="FileTemplateManagerImpl">
<option name="RECENT_TEMPLATES">
<list>
@ -23,6 +25,14 @@
</list>
</option>
</component>
<component name="Git.Settings">
<option name="RECENT_BRANCH_BY_REPOSITORY">
<map>
<entry key="$PROJECT_DIR$" value="master" />
</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" />
@ -30,6 +40,9 @@
<option name="FILTER_DEBUG" value="true" />
<option name="CUSTOM_FILTER" />
</component>
<component name="MarkdownSettingsMigration">
<option name="stateVersion" value="1" />
</component>
<component name="MavenImportPreferences">
<option name="generalSettings">
<MavenGeneralSettings>
@ -44,14 +57,15 @@
</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="ASKED_SHARE_PROJECT_CONFIGURATION_FILES" value="true" />
<property name="RunOnceActivity.ShowReadmeOnStart" value="true" />
<property name="SHARE_PROJECT_CONFIGURATION_FILES" 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="last_opened_file_path" value="$PROJECT_DIR$" />
<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" />
@ -62,6 +76,7 @@
<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" />
<property name="vue.rearranger.settings.migration" value="true" />
</component>
<component name="RecentsManager">
<key name="CopyClassDialog.RECENTS_KEY">
@ -181,6 +196,7 @@
</list>
</option>
</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 +344,60 @@
<workItem from="1588858985099" duration="3090000" />
<workItem from="1588865103089" duration="22000" />
<workItem from="1589092133957" duration="947000" />
<workItem from="1745902575121" duration="2753000" />
</task>
<task id="LOCAL-00001" summary="Default Changelist">
<created>1745902622019</created>
<option name="number" value="00001" />
<option name="presentableId" value="LOCAL-00001" />
<option name="project" value="LOCAL" />
<updated>1745902622019</updated>
</task>
<task id="LOCAL-00002" summary="Default Changelist">
<created>1745903347586</created>
<option name="number" value="00002" />
<option name="presentableId" value="LOCAL-00002" />
<option name="project" value="LOCAL" />
<updated>1745903347586</updated>
</task>
<task id="LOCAL-00003" summary="Default Changelist">
<created>1745917928087</created>
<option name="number" value="00003" />
<option name="presentableId" value="LOCAL-00003" />
<option name="project" value="LOCAL" />
<updated>1745917928088</updated>
</task>
<option name="localTasksCounter" value="4" />
<servers />
</component>
<component name="TypeScriptGeneratedFilesManager">
<option name="version" value="1" />
<option name="version" value="3" />
</component>
<component name="Vcs.Log.Tabs.Properties">
<option name="TAB_STATES">
<map>
<entry key="MAIN">
<value>
<State>
<option name="FILTERS">
<map>
<entry key="branch">
<value>
<list>
<option value="origin/zp" />
</list>
</value>
</entry>
</map>
</option>
</State>
</value>
</entry>
</map>
</option>
</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>

53
src/com/controller/schoadmin/SchoDelSelectedStuPunchServlet.java
Unescape View File

@ -1,61 +1,112 @@
package com.controller.schoadmin;
// 声明该类所在的包为 com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入自定义的数据访问对象类 DeptAdminDao，用于与数据库进行交互
import javax.servlet.ServletException;
// 导入 Servlet 异常类，用于处理 Servlet 操作中可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入用于标注 Servlet 映射路径的注解类
import javax.servlet.http.HttpServlet;
// 导入 HttpServlet 类，是所有 HTTP Servlet 的基类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理 HTTP 请求的类
import javax.servlet.http.HttpServletResponse;
// 导入用于处理 HTTP 响应的类
import java.io.IOException;
// 导入输入输出异常类，用于处理输入输出操作时可能出现的异常
@WebServlet("/SchoDelSelectedStuPunchServlet")
// 使用注解指定该 Servlet 的访问路径为 /SchoDelSelectedStuPunchServlet
public class SchoDelSelectedStuPunchServlet extends HttpServlet {
// 定义一个名为 SchoDelSelectedStuPunchServlet 的公共类，继承自 HttpServlet
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写 HttpServlet 类的 doGet 方法，用于处理 HTTP GET 请求，可能会抛出 ServletException 和 IOException 异常
req.setCharacterEncoding("utf-8");
// 设置请求的字符编码为 UTF-8，以正确处理中文字符等
resp.setCharacterEncoding("utf-8");
// 设置响应的字符编码为 UTF-8
resp.setContentType("text/html;charset=utf-8");
// 设置响应的内容类型为 HTML，字符编码为 UTF-8
//获取请求时复选框有选中的状态参数
String[] snodates = req.getParameterValues("snodates");
// 从请求中获取名为 "snodates" 的多个参数值，存储在字符串数组 snodates 中
System.out.println(snodates);
// 在控制台打印 snodates 数组的引用信息
if(snodates.length > 0 && snodates != null){
// 检查 snodates 数组不为空且有元素
//遍历并删除选中的sno,y一个一个删除
for (String snodate: snodates) {
// 遍历 snodates 数组中的每个元素
//分离两个参数
String[] params = snodate.split(",");
// 将每个 snodate 字符串按逗号分隔成字符串数组 params
String sno = params[0];
// 取出分隔后的第一个元素作为学生编号 sno
String spunchdate = params[1];
// 取出分隔后的第二个元素作为打卡日期 spunchdate
System.out.println(sno);
// 在控制台打印学生编号 sno
System.out.println(spunchdate);
// 在控制台打印打卡日期 spunchdate
//字符串转为日期类型
// Date spunchdate1 = new Date(spunchdate);
// 注释掉的代码，尝试将字符串 spunchdate 转换为 Date 类型
//或
// SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
// Date spunchdate1 = ft.format(spunchdate);
// 注释掉的代码，使用 SimpleDateFormat 将字符串 spunchdate 格式化为日期类型
String sql = null;
// 声明一个字符串变量 sql 并初始化为 null，用于存储 SQL 语句
Object[] objects = {sno, spunchdate};
// 创建一个 Object 类型的数组 objects，包含学生编号和打卡日期
//删除stupunchin中的该导游信息
sql = "delete from stupunchin where sno = ? and spunchdate = ?";
// 构建 SQL 语句，用于从 stupunchin 表中删除指定学生编号和打卡日期的记录
int num1 = DeptAdminDao.executeUpdate(sql, objects);
// 调用 DeptAdminDao 类的 executeUpdate 方法执行 SQL 删除操作，传入 SQL 语句和参数数组，返回受影响的行数并存储在 num1 中
System.out.println(num1);
// 在控制台打印受影响的行数
}
req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp);
// 创建请求转发器，将请求转发到 /SchoQueryStuPunchByPageServlet 并附带一些查询参数，然后将请求和响应对象传递给转发器进行转发
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写 HttpServlet 类的 doPost 方法，用于处理 HTTP POST 请求，可能会抛出 ServletException 和 IOException 异常
doGet(req, resp);
// 调用 doGet 方法处理 POST 请求，即让 POST 请求的处理逻辑和 GET 请求相同
}
}
}

89
src/com/controller/schoadmin/SchoDelSelectedStuServlet.java
Unescape View File

@ -1,51 +1,112 @@
package com.controller.schoadmin;
// 声明该类所在的包为 com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入自定义的数据访问对象类 DeptAdminDao，用于与数据库进行交互
import javax.servlet.ServletException;
// 导入 Servlet 异常类，用于处理 Servlet 操作中可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入用于标注 Servlet 映射路径的注解类
import javax.servlet.http.HttpServlet;
// 导入 HttpServlet 类，是所有 HTTP Servlet 的基类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理 HTTP 请求的类
import javax.servlet.http.HttpServletResponse;
// 导入用于处理 HTTP 响应的类
import java.io.IOException;
// 导入输入输出异常类，用于处理输入输出操作时可能出现的异常
@WebServlet("/SchoDelSelectedStuPunchServlet")
// 使用注解指定该 Servlet 的访问路径为 /SchoDelSelectedStuPunchServlet
@WebServlet("/SchoDelSelectedStuServlet")
public class SchoDelSelectedStuServlet extends HttpServlet {
public class SchoDelSelectedStuPunchServlet extends HttpServlet {
// 定义一个名为 SchoDelSelectedStuPunchServlet 的公共类，继承自 HttpServlet
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写 HttpServlet 类的 doGet 方法，用于处理 HTTP GET 请求，可能会抛出 ServletException 和 IOException 异常
req.setCharacterEncoding("utf-8");
// 设置请求的字符编码为 UTF-8，以正确处理中文字符等
resp.setCharacterEncoding("utf-8");
// 设置响应的字符编码为 UTF-8
resp.setContentType("text/html;charset=utf-8");
// 设置响应的内容类型为 HTML，字符编码为 UTF-8
//获取请求时复选框有选中的状态参数
String[] snos = req.getParameterValues("sno");
String[] snodates = req.getParameterValues("snodates");
// 从请求中获取名为 "snodates" 的多个参数值，存储在字符串数组 snodates 中
System.out.println(snos);
System.out.println(snodates);
// 在控制台打印 snodates 数组的引用信息
if(snodates.length > 0 && snodates != null){
// 检查 snodates 数组不为空且有元素
if(snos.length > 0 && snos != null){
//遍历并删除选中的sno,y一个一个删除
for (String sno: snos) {
for (String snodate: snodates) {
// 遍历 snodates 数组中的每个元素
//分离两个参数
String[] params = snodate.split(",");
// 将每个 snodate 字符串按逗号分隔成字符串数组 params
String sno = params[0];
// 取出分隔后的第一个元素作为学生编号 sno
String spunchdate = params[1];
// 取出分隔后的第二个元素作为打卡日期 spunchdate
System.out.println(sno);
// 在控制台打印学生编号 sno
System.out.println(spunchdate);
// 在控制台打印打卡日期 spunchdate
//字符串转为日期类型
// Date spunchdate1 = new Date(spunchdate);
// 注释掉的代码，尝试将字符串 spunchdate 转换为 Date 类型
//或
// SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
// Date spunchdate1 = ft.format(spunchdate);
// 注释掉的代码，使用 SimpleDateFormat 将字符串 spunchdate 格式化为日期类型
String sql = null;
Object[] objects = {sno};
// 声明一个字符串变量 sql 并初始化为 null，用于存储 SQL 语句
Object[] objects = {sno, spunchdate};
// 创建一个 Object 类型的数组 objects，包含学生编号和打卡日期
//删除stupunchin中的该导游信息
sql = "delete from stupunchin where sno = ?";
sql = "delete from stupunchin where sno = ? and spunchdate = ?";
// 构建 SQL 语句，用于从 stupunchin 表中删除指定学生编号和打卡日期的记录
int num1 = DeptAdminDao.executeUpdate(sql, objects);
// 调用 DeptAdminDao 类的 executeUpdate 方法执行 SQL 删除操作，传入 SQL 语句和参数数组，返回受影响的行数并存储在 num1 中
System.out.println(num1);
// 在控制台打印受影响的行数
//删除student表中该导游信息
sql = "delete from student where sno = ?";
int num2 = DeptAdminDao.executeUpdate(sql, objects);
System.out.println(num2);
}
req.getRequestDispatcher("/SchoQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=").forward(req, resp);
req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp);
// 创建请求转发器，将请求转发到 /SchoQueryStuPunchByPageServlet 并附带一些查询参数，然后将请求和响应对象传递给转发器进行转发
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写 HttpServlet 类的 doPost 方法，用于处理 HTTP POST 请求，可能会抛出 ServletException 和 IOException 异常
doGet(req, resp);
// 调用 doGet 方法处理 POST 请求，即让 POST 请求的处理逻辑和 GET 请求相同
}
}
}

86
src/com/controller/schoadmin/SchoDelSelectedTeaPunchServlet.java
Unescape View File

@ -11,7 +11,93 @@ import java.io.IOException;
@WebServlet("/SchoDelSelectedTeaPunchServlet")
public class SchoDelSelectedTeaPunchServlet extends HttpServlet {
// 声明该类所属的包，表明该类用于处理学校管理员相关的控制器逻辑
package com.controller.schoadmin;
// 导入部门管理员数据访问对象类，用于执行数据库操作
import com.dao.DeptAdminDao;
// 导入Servlet异常类，用于处理Servlet执行过程中可能出现的异常
import javax.servlet.ServletException;
// 导入Servlet注解，用于将该Servlet映射到指定的URL路径
import javax.servlet.annotation.WebServlet;
// 导入HttpServlet基类，该类继承自它以处理HTTP请求
import javax.servlet.http.HttpServlet;
// 导入HTTP请求对象类，用于获取请求中的参数、属性等信息
import javax.servlet.http.HttpServletRequest;
// 导入HTTP响应对象类，用于设置响应的内容、状态码等信息
import javax.servlet.http.HttpServletResponse;
// 导入输入输出异常类，用于处理输入输出操作中可能出现的异常
import java.io.IOException;
// 使用注解将该Servlet映射到指定的URL路径，客户端通过此路径访问该Servlet
@WebServlet("/SchoDelSelectedTeaPunchServlet")
// 定义一个继承自HttpServlet的类，用于处理学校管理员删除选中教师打卡信息的请求
public class SchoDelSelectedTeaPunchServlet extends HttpServlet {
// 重写doGet方法，用于处理HTTP GET请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为UTF-8，确保能正确处理包含中文等特殊字符的请求参数
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8，保证响应内容中的特殊字符能正确显示
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML，字符编码为UTF-8，告知客户端返回的是HTML格式的数据
resp.setContentType("text/html;charset=utf-8");
// 从请求中获取名为tnodates的参数数组，该数组包含了用户在复选框中选中的教师编号和打卡日期组合
String[] tnodates = req.getParameterValues("tnodates");
// 在控制台打印获取到的参数数组，用于调试
System.out.println(tnodates);
// 判断参数数组是否不为空且长度大于0，即是否有选中的记录
if (tnodates.length > 0 && tnodates != null) {
// 遍历参数数组，对每个选中的记录进行处理
for (String tnodate : tnodates) {
// 将每个组合字符串按逗号分隔成教师编号和打卡日期两个参数
String[] params = tnodate.split(",");
// 获取教师编号
String tno = params[0];
// 获取打卡日期
String tpunchdate = params[1];
// 在控制台打印教师编号，用于调试
System.out.println(tno);
// 在控制台打印打卡日期，用于调试
System.out.println(tpunchdate);
// 以下注释掉的代码原本用于将字符串类型的日期转换为日期类型，但存在错误，转换方式不正确
// 字符串转为日期类型
// Date spunchdate1 = new Date(spunchdate);
// 或
// SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
// Date spunchdate1 = ft.format(spunchdate);
// 声明一个用于存储SQL语句的变量
String sql = null;
// 创建一个包含SQL语句参数的对象数组，分别为教师编号和打卡日期
Object[] objects = {tno, tpunchdate};
// 构建SQL删除语句，用于删除教师打卡信息表中指定教师编号和打卡日期的记录
sql = "delete from teapunchin where tno = ? and tpunchdate = ?";
// 调用部门管理员数据访问对象的方法，执行SQL删除操作，并返回受影响的行数
int num1 = DeptAdminDao.executeUpdate(sql, objects);
// 在控制台打印受影响的行数，用于调试
System.out.println(num1);
}
// 将请求转发到分页查询教师打卡信息的Servlet，同时传递一些默认的查询参数，如当前页码为1，每页显示7条记录等
req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp);
}
}
// 重写doPost方法，用于处理HTTP POST请求，这里直接调用doGet方法，即POST请求的处理逻辑与GET请求相同
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");

109
src/com/controller/schoadmin/SchoDelSelectedTeaServlet.java
Unescape View File

@ -1,51 +1,118 @@
// 声明该类所在的包为 com.controller.schoadmin
package com.controller.schoadmin;
// 导入 com.dao 包下的 DeptAdminDao 类，用于数据访问操作
import com.dao.DeptAdminDao;
// 导入 com.entity 包下的 Student 类，用于表示学生实体
import com.entity.Student;
// 导入 com.utils 包下的 JDBCUtils 类，用于处理 JDBC 相关操作，如关闭资源等
import com.utils.JDBCUtils;
// 导入 Servlet 相关的异常类，用于处理 Servlet 操作中可能出现的异常
import javax.servlet.ServletException;
// 导入用于将 Servlet 映射到特定 URL 模式的注解
import javax.servlet.annotation.WebServlet;
// 导入 HttpServlet 类，这是所有 Servlet 类的基类
import javax.servlet.http.HttpServlet;
// 导入 HttpServletRequest 类，用于处理 HTTP 请求
import javax.servlet.http.HttpServletRequest;
// 导入 HttpServletResponse 类，用于处理 HTTP 响应
import javax.servlet.http.HttpServletResponse;
// 导入 IOException 类，用于处理输入输出异常
import java.io.IOException;
// 导入 ResultSet 类，用于处理 SQL 查询结果集
import java.sql.ResultSet;
@WebServlet("/SchoDelSelectedTeaServlet")
public class SchoDelSelectedTeaServlet extends HttpServlet {
// 使用 WebServlet 注解将该 Servlet 映射到 "/SchoQueryStuByIdServlet" 路径，
// 当客户端请求访问该路径时，该 Servlet 会被触发执行
@WebServlet("/SchoQueryStuByIdServlet")
// 定义 SchoQueryStuByIdServlet 类，继承自 HttpServlet 类，表明这是一个 Servlet 类
public class SchoQueryStuByIdServlet extends HttpServlet {
// 重写 doGet 方法，用于处理 HTTP GET 请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为 UTF-8，以正确处理中文等字符
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
// 设置响应的字符编码为 UTF-8，以正确返回中文等字符
resp.setCharacterEncoding("utf-8");//ugu
// 设置响应的内容类型为 HTML，字符编码为 UTF-8
resp.setContentType("text/html;charset=utf-8");
//获取请求时复选框有选中的状态参数
String[] tnos = req.getParameterValues("tno");
// 从请求参数中获取名为 "sno" 的参数值，该值代表学生的学号
String sno = req.getParameter("sno");
System.out.println(tnos);
// 声明一个 SQL 语句变量，初始化为 null
String sql = null;
// 创建一个对象数组，用于存储 SQL 查询中的参数，这里存储了学号
Object[] objects = {sno};
if(tnos.length > 0 && tnos != null){
//遍历并删除选中的sno,y一个一个删除
for (String tno: tnos) {
String sql = null;
Object[] objects = {tno};
// 查询是否存在该学号对应的学生
// 构造 SQL 语句，使用 count(*) 统计满足条件的记录数量，并将结果命名为 num
sql = "select count(*) as num from student where sno = ?";
// 调用 DeptAdminDao 类的 findTotalCount 方法，执行 SQL 查询并返回记录数量
int count = DeptAdminDao.findTotalCount(sql, objects);
//删除stupunchin中的该导游信息
sql = "delete from teapunchin where tno = ?";
int num1 = DeptAdminDao.executeUpdate(sql, objects);
System.out.println(num1);
// 如果查询到的记录数量大于 0，说明存在该学生
if (count > 0){
// 构造 SQL 语句，查询该学号对应的学生的所有信息
sql = "select * from student where sno = ?";
// 调用 DeptAdminDao 类的 qureyInfo 方法，执行 SQL 查询并返回结果集
ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects);
// 创建一个 Student 对象，用于存储查询到的学生信息
Student student = new Student();
//删除student表中该导游信息
sql = "delete from teacher where tno = ?";
int num2 = DeptAdminDao.executeUpdate(sql, objects);
System.out.println(num2);
try {
// 遍历结果集
while (resultSet.next()){
// 从结果集中获取学生的学号，并设置到 Student 对象中
student.setSno(resultSet.getString("sno"));
// 从结果集中获取学生的姓名，并设置到 Student 对象中
student.setSname(resultSet.getString("sname"));
// 从结果集中获取学生的性别，并设置到 Student 对象中
student.setSsex(resultSet.getString("ssex"));
// 从结果集中获取学生的年龄，并设置到 Student 对象中
student.setSage(resultSet.getInt("sage"));
// 从结果集中获取学生的班级，并设置到 Student 对象中
student.setSclass(resultSet.getString("sclass"));
// 从结果集中获取学生的专业，并设置到 Student 对象中
student.setSpecialty(resultSet.getString("specialty"));
// 从结果集中获取学生的系别，并设置到 Student 对象中
student.setSdept(resultSet.getString("sdept"));
// 从结果集中获取学生的电话号码，并设置到 Student 对象中
student.setSphone(resultSet.getString("sphone"));
// 从结果集中获取学生的密码，并设置到 Student 对象中
student.setSpsw(resultSet.getString("spsw"));
}
} catch (Exception e) {
// 捕获并打印异常堆栈信息
e.printStackTrace();
} finally {
// 无论是否发生异常，都关闭结果集以释放资源
JDBCUtils.close(resultSet);
}
req.getRequestDispatcher("/SchoQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=").forward(req, resp);
// 打印学生的性别信息，用于调试
System.out.println(student.getSsex());
// 将 Student 对象存储到请求属性中，以便在后续页面中使用
req.setAttribute("student", student);
// 使用请求转发将请求转发到 "/view/schoadmin/alterstu.jsp" 页面，
// 并携带请求和响应对象，用于修改学生信息
req.getRequestDispatcher("/view/schoadmin/alterstu.jsp").forward(req, resp);
} else {
// 如果查询到的记录数量为 0，说明不存在该学生
// 使用请求转发将请求转发到 "/view/alluse/noexistdataofalter.jsp" 页面，
// 提示用户要修改的数据不存在
req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp);
}
}
// 重写 doPost 方法，用于处理 HTTP POST 请求
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 对于 POST 请求，直接调用 doGet 方法进行处理，实现请求方法的统一处理
doGet(req, resp);
}
}
}

59
src/com/controller/schoadmin/SchoDeleteStuServlet.java
Unescape View File

@ -1,54 +1,111 @@
package com.controller.schoadmin;
// 包声明，指定该 Java 类所属的包为 com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入自定义的数据访问对象类 DeptAdminDao，用于执行数据库操作
import javax.servlet.ServletException;
// 导入 Servlet 异常类，用于处理 Servlet 相关的异常
import javax.servlet.annotation.WebServlet;
// 导入用于声明 Servlet 的注解类
import javax.servlet.http.HttpServlet;
// 导入 HttpServlet 类，这是所有 HTTP Servlet 的基类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理 HTTP 请求的类
import javax.servlet.http.HttpServletResponse;
// 导入用于处理 HTTP 响应的类
import java.io.IOException;
// 导入用于处理输入输出异常的类
@WebServlet("/SchoDeleteStuServlet")
// 使用注解声明该 Servlet 的访问路径为 /SchoDeleteStuServlet
public class SchoDeleteStuServlet extends HttpServlet {
// 定义一个名为 SchoDeleteStuServlet 的公共类，继承自 HttpServlet
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类 HttpServlet 的 doGet 方法，处理 HTTP GET 请求，可能会抛出 ServletException 和 IOException 异常
req.setCharacterEncoding("utf-8");
// 设置请求的字符编码为 UTF-8
resp.setCharacterEncoding("utf-8");
// 设置响应的字符编码为 UTF-8
resp.setContentType("text/html;charset=utf-8");
// 设置响应的内容类型为 HTML，字符编码为 UTF-8
String sno = req.getParameter("sno");
// 从请求中获取名为 "sno" 的参数值，并赋值给字符串变量 sno
System.out.println(sno);
// 在控制台打印输出 sno 的值
String sql = null;
// 声明一个字符串变量 sql 并初始化为 null，用于存储 SQL 语句
Object[] objects = {sno};
// 创建一个 Object 类型的数组 objects，包含一个元素 sno
//查询是否存在此人
// 注释，说明下面 SQL 语句的作用是查询是否存在该学生
sql = "select count(*) as num from student where sno = ?";
// 构建 SQL 语句，用于统计 student 表中 sno 等于指定值的记录数量，将结果别名为 num
int count = DeptAdminDao.findTotalCount(sql, objects);
// 调用 DeptAdminDao 类的 findTotalCount 方法执行 SQL 查询，传入 SQL 语句和参数数组，将返回的记录数量赋值给变量 count
if (count > 0) { //有则继续操作
// 如果 count 大于 0，说明存在该学生，执行下面的操作
//删除stupunchin中的该导游信息
// 注释，说明下面 SQL 语句的作用是删除 stupunchin 表中该学生的信息
sql = "delete from stupunchin where sno = ?";
// 构建 SQL 语句，用于从 stupunchin 表中删除 sno 等于指定值的记录
int num1 = DeptAdminDao.executeUpdate(sql, objects);
// 调用 DeptAdminDao 类的 executeUpdate 方法执行 SQL 删除操作，传入 SQL 语句和参数数组，将受影响的行数赋值给变量 num1
System.out.println(num1);
// 在控制台打印输出 num1 的值
//删除student表中该导游信息
// 注释，说明下面 SQL 语句的作用是删除 student 表中该学生的信息
sql = "delete from student where sno = ?";
// 构建 SQL 语句，用于从 student 表中删除 sno 等于指定值的记录
int num2 = DeptAdminDao.executeUpdate(sql, objects);
// 调用 DeptAdminDao 类的 executeUpdate 方法执行 SQL 删除操作，传入 SQL 语句和参数数组，将受影响的行数赋值给变量 num2
System.out.println(num2);
// 在控制台打印输出 num2 的值
req.getRequestDispatcher("/SchoQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=").forward(req, resp);
// 创建请求转发器，将请求转发到 /SchoQueryStuByPageServlet，并附带一些查询参数，然后将请求和响应对象传递给转发器进行转发
}else {
// 如果 count 不大于 0，即不存在该学生
req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);
// 创建请求转发器，将请求转发到 /view/alluse/noexistdataofdelete.jsp 页面，并将请求和响应对象传递给转发器进行转发
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类 HttpServlet 的 doPost 方法，处理 HTTP POST 请求，可能会抛出 ServletException 和 IOException 异常
doGet(req, resp);
// 调用 doGet 方法来处理 POST 请求，即让 POST 请求的处理逻辑和 GET 请求一致
}
}
}

54
src/com/controller/schoadmin/SchoDeleteTeaPunchServlet.java
Unescape View File

@ -1,64 +1,92 @@
// 声明该类所在的包为 com.controller.schoadmin
package com.controller.schoadmin;
// 导入 DeptAdminDao 类，该类可能封装了与部门管理员相关的数据库操作方法
import com.dao.DeptAdminDao;
// 导入 Servlet 异常类，用于处理 Servlet 操作过程中可能出现的异常
import javax.servlet.ServletException;
// 导入 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径
import javax.servlet.annotation.WebServlet;
// 导入 HttpServlet 类，这是所有 Servlet 类的基类
import javax.servlet.http.HttpServlet;
// 导入 HttpServletRequest 类，用于获取客户端的请求信息
import javax.servlet.http.HttpServletRequest;
// 导入 HttpServletResponse 类，用于向客户端发送响应信息
import javax.servlet.http.HttpServletResponse;
// 导入输入输出异常类，用于处理输入输出操作中可能出现的异常
import java.io.IOException;
// 使用 WebServlet 注解将该类映射到 /SchoDeleteTeaPunchServlet 路径，客户端可通过此路径访问该 Servlet
@WebServlet("/SchoDeleteTeaPunchServlet")
// 定义 SchoDeleteTeaPunchServlet 类，继承自 HttpServlet，表明这是一个处理 HTTP 请求的 Servlet
public class SchoDeleteTeaPunchServlet extends HttpServlet {
// 重写 doGet 方法，用于处理客户端的 GET 请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为 UTF-8，防止中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为 UTF-8，防止中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为 HTML，字符编码为 UTF-8
resp.setContentType("text/html;charset=utf-8");
//获取请求参数
// 从请求中获取名为 tnodate 的参数，该参数可能包含教师编号和打卡日期
String tnodate = req.getParameter("tnodate");
// 将获取到的 tnodate 参数打印到控制台，用于调试
System.out.println(tnodate);
//分离两个参数,用日期和学号来删除
// 使用逗号作为分隔符，将 tnodate 字符串拆分成一个字符串数组
String[] params = tnodate.split(",");
// 数组的第一个元素赋值给 tno 变量，代表教师编号
String tno = params[0];
// 数组的第二个元素赋值给 tpunchdate 变量，代表打卡日期
String tpunchdate = params[1];
// 将教师编号打印到控制台，用于调试
System.out.println(tno);
// 将打卡日期打印到控制台，用于调试
System.out.println(tpunchdate);
//字符串转为日期类型
// Date spunchdate1 = new Date(spunchdate);
//或
// SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
// Date spunchdate1 = ft.format(spunchdate);
// 以下两行代码被注释掉，原计划将字符串类型的日期转换为 Date 类型，但未实际使用
// Date spunchdate1 = new Date(spunchdate);
// SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
// Date spunchdate1 = ft.format(spunchdate);
// 声明一个 SQL 语句变量，用于后续存储 SQL 语句
String sql = null;
// 创建一个 Object 数组，用于存储 SQL 查询或更新语句中的参数
Object[] objects = {tno, tpunchdate};
//查询是否存在此人
// 构建 SQL 查询语句，用于查询在 teapunchin 表中，指定教师编号和打卡日期的记录数量
sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?";
// 调用 DeptAdminDao 类的 findTotalCount 方法执行查询，返回符合条件的记录数量
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count > 0) { //有则继续操作
//删除stupunchin中的该信息
// 如果查询到的记录数量大于 0，说明存在该教师在指定日期的打卡记录
if (count > 0) {
// 构建 SQL 删除语句，用于删除 teapunchin 表中指定教师编号和打卡日期的记录
sql = "delete from teapunchin where tno = ? and tpunchdate = ?";
// 调用 DeptAdminDao 类的 executeUpdate 方法执行删除操作，返回受影响的行数
int num1 = DeptAdminDao.executeUpdate(sql, objects);
// 将受影响的行数打印到控制台，用于调试
System.out.println(num1);
// 将请求转发到 SchoQueryTeaPunchByPageServlet，并传递分页和查询参数，刷新教师打卡记录页面
req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp);
}else {
} else {
// 如果查询到的记录数量为 0，说明不存在该教师在指定日期的打卡记录
// 将请求转发到 noexistdataofdelete.jsp 页面，提示用户要删除的数据不存在
req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);
}
}
// 重写 doPost 方法，用于处理客户端的 POST 请求
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 调用 doGet 方法处理 POST 请求，实现 GET 和 POST 请求的统一处理
doGet(req, resp);
}
}
}

50
src/com/controller/schoadmin/SchoDeleteTeaPunchServlet1.java
Unescape View File

@ -1,66 +1,94 @@
// 声明该类所属的包为com.controller.schoadmin，通常用于存放与学校管理员相关的控制器类
package com.controller.schoadmin;
// 导入数据访问对象类，用于执行与部门管理员操作相关的数据访问，如数据库查询和更新
import com.dao.DeptAdminDao;
// 导入处理Servlet异常的类，当Servlet执行过程中出现异常时会抛出该异常
import javax.servlet.ServletException;
// 导入用于将Servlet映射到特定URL的注解
import javax.servlet.annotation.WebServlet;
// 导入所有HTTP Servlet的基类
import javax.servlet.http.HttpServlet;
// 导入用于封装HTTP请求信息的类
import javax.servlet.http.HttpServletRequest;
// 导入用于封装HTTP响应信息的类
import javax.servlet.http.HttpServletResponse;
// 导入用于管理用户会话的类，可获取和设置会话中的属性
import javax.servlet.http.HttpSession;
// 导入处理输入输出异常的类，当在输入输出操作中发生错误时会抛出该异常
import java.io.IOException;
// 使用WebServlet注解将该Servlet映射到/SchoDeleteTeaPunchServlet1路径
@WebServlet("/SchoDeleteTeaPunchServlet1")
// 定义一个名为SchoDeleteTeaPunchServlet1的类，继承自HttpServlet，用于处理学校管理员删除教师打卡信息的请求
public class SchoDeleteTeaPunchServlet1 extends HttpServlet {
// 重写doGet方法，用于处理HTTP GET请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为UTF - 8，确保能正确处理包含中文字符等的请求参数
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF - 8，保证响应内容中的中文字符能正确显示
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML，字符编码为UTF - 8，告知客户端返回的是HTML格式的数据
resp.setContentType("text/html;charset=utf-8");
//获取请求参数
// 从请求中获取名为tno的参数，代表教师编号
String tno = req.getParameter("tno");
// 从请求中获取名为tpunchdate的参数，代表打卡日期
String tpunchdate = req.getParameter("tpunchdate");
// 在控制台打印获取到的教师编号，用于调试，查看是否正确获取参数
System.out.println(tno);
// 在控制台打印获取到的打卡日期，用于调试
System.out.println(tpunchdate);
//获取登录时的session会话对象
// 获取当前请求对应的会话对象
HttpSession session = req.getSession();
// 以下两行代码被注释掉，原本用于从会话中获取用户名和学号，这里未使用
// String userName = (String) session.getAttribute("userName");
// String sno = (String) session.getAttribute("sno");
// 从会话中获取名为belong的属性值，可能代表教师所属部门
String belong = (String) session.getAttribute("belong");
//字符串转为日期类型
// 以下注释掉的代码原本用于将字符串类型的日期转换为日期类型，但存在错误，转换方式不正确
// 字符串转为日期类型
// Date spunchdate1 = new Date(spunchdate);
//或
// 或
// SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
// Date spunchdate1 = ft.format(spunchdate);
// 声明一个用于存储SQL语句的变量，初始值为null
String sql = null;
// 创建一个Object数组，用于存储SQL语句中的参数值，包含教师编号和打卡日期
Object[] objects = {tno, tpunchdate};
//查询是否存在此人
// 构建SQL查询语句，用于查询数据库中是否存在指定教师编号和打卡日期的记录，count(*) as num用于统计符合条件的记录数
sql = "select count(*) as num from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ?";
// 调用DeptAdminDao类的findTotalCount方法执行SQL查询，获取符合条件的记录数
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count > 0) { //有则继续操作
//删除stupunchin中的该信息
// 如果count大于0，说明存在该教师编号和打卡日期对应的记录，可以继续进行删除操作
if (count > 0) {
// 构建SQL删除语句，用于从teapunchin表中删除指定教师编号和打卡日期的记录
sql = "delete from teapunchin where tno = ? and tpunchdate = ?";
// 调用DeptAdminDao类的executeUpdate方法执行SQL删除操作，并返回受影响的行数
int num1 = DeptAdminDao.executeUpdate(sql, objects);
// 在控制台打印受影响的行数，用于调试，查看删除操作是否成功
System.out.println(num1);
// 将请求转发到/SchoQueryTeaPunchByPageServlet，并传递一些参数，可能用于重新查询教师打卡信息列表，当前页码为1，每页显示7条记录，其他查询参数为空
req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp);
}else {
} else {
// 如果count不大于0，说明不存在该教师编号和打卡日期对应的记录，将请求转发到提示不存在要删除数据的页面
req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);
}
}
// 重写doPost方法，用于处理HTTP POST请求，这里直接调用doGet方法，即POST请求的处理逻辑与GET请求相同
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

42
src/com/controller/schoadmin/SchoDeleteTeaServlet.java
Unescape View File

@ -1,54 +1,82 @@
// 声明该类所在的包名为 com.controller.schoadmin
package com.controller.schoadmin;
// 导入 DeptAdminDao 类，该类可能包含了与部门管理相关的数据库操作方法
import com.dao.DeptAdminDao;
// 导入 Servlet 异常类，用于处理 Servlet 执行过程中可能出现的异常
import javax.servlet.ServletException;
// 导入 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径
import javax.servlet.annotation.WebServlet;
// 导入 HttpServlet 类，这是所有 Servlet 类的基类
import javax.servlet.http.HttpServlet;
// 导入 HttpServletRequest 类，用于获取客户端发送的请求信息
import javax.servlet.http.HttpServletRequest;
// 导入 HttpServletResponse 类，用于向客户端发送响应信息
import javax.servlet.http.HttpServletResponse;
// 导入输入输出异常类，用于处理输入输出操作可能产生的异常
import java.io.IOException;
// 使用 WebServlet 注解将该类映射到 /SchoDeleteTeaServlet 路径，客户端可通过此路径访问该 Servlet
@WebServlet("/SchoDeleteTeaServlet")
// 定义 SchoDeleteTeaServlet 类，继承自 HttpServlet，表明这是一个处理 HTTP 请求的 Servlet
public class SchoDeleteTeaServlet extends HttpServlet {
// 重写 doGet 方法，用于处理客户端发送的 HTTP GET 请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为 UTF-8，防止中文等字符出现乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为 UTF-8，防止响应信息出现乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为 HTML，并且字符编码为 UTF-8
resp.setContentType("text/html;charset=utf-8");
// 从请求参数中获取教师编号 tno
String tno = req.getParameter("tno");
// 将获取到的教师编号打印到控制台，方便调试
System.out.println(tno);
// 声明一个字符串变量 sql，用于存储 SQL 语句
String sql = null;
// 创建一个 Object 类型的数组 objects，用于存储 SQL 语句中的参数
Object[] objects = {tno};
//查询是否存在此人
// 构建一个 SQL 查询语句，用于查询 teacher 表中是否存在指定教师编号的记录
sql = "select count(*) as num from teacher where tno = ?";
// 调用 DeptAdminDao 类的 findTotalCount 方法执行上述 SQL 查询，返回符合条件的记录数量
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count > 0) { //有则继续操作
//删除stupunchin中的该导游信息
// 如果查询到的记录数量大于 0，说明该教师记录存在
if (count > 0) {
// 构建 SQL 删除语句，用于删除 teapunchin 表中该教师的打卡信息
sql = "delete from teapunchin where tno = ?";
// 调用 DeptAdminDao 类的 executeUpdate 方法执行删除操作，返回受影响的行数
int num1 = DeptAdminDao.executeUpdate(sql, objects);
// 将受影响的行数打印到控制台，方便调试
System.out.println(num1);
//删除student表中该导游信息
// 构建 SQL 删除语句，用于删除 teacher 表中该教师的信息
sql = "delete from teacher where tno = ?";
// 调用 DeptAdminDao 类的 executeUpdate 方法执行删除操作，返回受影响的行数
int num2 = DeptAdminDao.executeUpdate(sql, objects);
// 将受影响的行数打印到控制台，方便调试
System.out.println(num2);
// 将请求转发到 SchoQueryTeaByPageServlet 并携带分页和查询参数，刷新教师列表页面
req.getRequestDispatcher("/SchoQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=").forward(req, resp);
}else {
} else {
// 如果查询到的记录数量为 0，说明该教师记录不存在
// 将请求转发到 noexistdataofdelete.jsp 页面，提示用户要删除的数据不存在
req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);
}
}
// 重写 doPost 方法，用于处理客户端发送的 HTTP POST 请求
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 调用 doGet 方法处理 POST 请求，实现 GET 和 POST 请求的统一处理
doGet(req, resp);
}
}
}

55
src/com/controller/schoadmin/SchoQueryTeaByIdServlet.java
Unescape View File

@ -1,72 +1,111 @@
// 声明该类所属的包，表明该类是用于学校管理员相关功能的控制器类
package com.controller.schoadmin;
// 导入部门管理员数据访问对象类，用于执行数据库查询和统计等操作
import com.dao.DeptAdminDao;
// 导入教师实体类，用于封装从数据库中查询到的教师信息
import com.entity.Teacher;
// 导入JDBC工具类，用于关闭数据库连接、结果集等资源
import com.utils.JDBCUtils;
// 导入Servlet异常类，当Servlet执行过程中出现异常时会抛出该异常
import javax.servlet.ServletException;
// 导入Servlet注解，用于将该Servlet映射到指定的URL路径
import javax.servlet.annotation.WebServlet;
// 导入HttpServlet基类，所有Servlet类都需要继承自它
import javax.servlet.http.HttpServlet;
// 导入HTTP请求对象类，用于获取请求中的参数、属性等信息
import javax.servlet.http.HttpServletRequest;
// 导入HTTP响应对象类，用于设置响应的内容、状态码等信息
import javax.servlet.http.HttpServletResponse;
// 导入输入输出异常类，当进行输入输出操作时可能会抛出该异常
import java.io.IOException;
// 导入数据库结果集类，用于存储数据库查询的结果
import java.sql.ResultSet;
// 使用注解将该Servlet映射到指定的URL路径，客户端通过此路径访问该Servlet
@WebServlet("/SchoQueryTeaByIdServlet")
// 定义一个继承自HttpServlet的类，用于处理学校管理员根据教师编号查询教师信息的请求
public class SchoQueryTeaByIdServlet extends HttpServlet {
// 重写doGet方法，用于处理HTTP GET请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为UTF-8，确保能正确处理包含中文字符等的请求参数
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8，保证响应内容中的中文字符能正确显示
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML，字符编码为UTF-8，告知客户端返回的是HTML格式的数据
resp.setContentType("text/html;charset=utf-8");
// 从请求中获取名为tno的参数，该参数代表教师编号
String tno = req.getParameter("tno");
// 声明一个用于存储SQL语句的变量，初始值为null
String sql = null;
// 创建一个Object数组，用于存储SQL语句中的参数值，这里只有教师编号
Object[] objects = {tno};
// 在控制台打印获取到的教师编号，用于调试
System.out.println(tno);
//查询是否存在此人
// 构建SQL查询语句，用于查询数据库中是否存在指定教师编号的记录，count(*) as num用于统计符合条件的记录数
sql = "select count(*) as num from teacher where tno = ?";
// 调用DeptAdminDao类的findTotalCount方法执行SQL查询，获取符合条件的记录数
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count > 0) { //有则继续操作
// 如果count大于0，说明存在该教师编号对应的记录，可以继续查询详细信息
if (count > 0) {
// 构建SQL查询语句，用于获取指定教师编号的教师详细信息
sql = "select * from teacher where tno = ?";
// 调用DeptAdminDao类的qureyInfo方法执行SQL查询，并将结果存储在ResultSet对象中
ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects);
// 创建一个Teacher对象，用于封装查询到的教师信息
Teacher teacher = new Teacher();
try {
while (resultSet.next()){
// 遍历结果集，由于查询结果理论上只有一条记录，这里while循环通常只会执行一次
while (resultSet.next()) {
// 从结果集中获取教师编号，并设置到Teacher对象中
teacher.setTno(resultSet.getString("tno"));
// 从结果集中获取教师姓名，并设置到Teacher对象中
teacher.setTname(resultSet.getString("tname"));
// 从结果集中获取教师性别，并设置到Teacher对象中
teacher.setTsex(resultSet.getString("tsex"));
// 从结果集中获取教师年龄，并设置到Teacher对象中
teacher.setTage(resultSet.getInt("tage"));
// 从结果集中获取教师所属部门，并设置到Teacher对象中
teacher.setTdept(resultSet.getString("tdept"));
// 从结果集中获取教师联系电话，并设置到Teacher对象中
teacher.setTphone(resultSet.getString("tphone"));
// 从结果集中获取教师密码，并设置到Teacher对象中
teacher.setTpsw(resultSet.getString("tpsw"));
}
} catch (Exception e) {
// 若在遍历结果集过程中出现异常，打印异常堆栈信息，方便调试
e.printStackTrace();
}finally {
} finally {
// 无论是否出现异常，最后都调用JDBCUtils类的close方法关闭结果集，释放资源
JDBCUtils.close(resultSet);
}
// 在控制台打印教师性别，用于调试，查看获取的教师信息是否正确
System.out.println(teacher.getTsex());
// 将封装好教师信息的Teacher对象添加到请求属性中，属性名为teacher
req.setAttribute("teacher", teacher);
// 将请求转发到/view/schoadmin/altertea.jsp页面，在该页面可以对教师信息进行修改操作
req.getRequestDispatcher("/view/schoadmin/altertea.jsp").forward(req, resp);
}else {
} else {
// 如果count不大于0，说明不存在该教师编号对应的记录，将请求转发到提示不存在数据的页面
req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp);
}
}
// 重写doPost方法，用于处理HTTP POST请求，这里直接调用doGet方法，即POST请求的处理逻辑与GET请求相同
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

53
src/com/controller/schoadmin/SchoQueryTeaByIdServlet1.java
Unescape View File

@ -1,52 +1,83 @@
// 声明该类所在的包为 com.controller.schoadmin
package com.controller.schoadmin;
// 导入 DeptAdminDao 类，该类可能包含了与部门管理相关的数据库操作方法
import com.dao.DeptAdminDao;
// 导入 Teacher 实体类，用于封装教师的相关信息
import com.entity.Teacher;
// 导入 JDBCUtils 工具类，可能用于数据库连接的获取、关闭等操作
import com.utils.JDBCUtils;
// 导入 Servlet 异常处理类，用于处理 Servlet 执行过程中可能出现的异常
import javax.servlet.ServletException;
// 导入 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径
import javax.servlet.annotation.WebServlet;
// 导入 HttpServlet 类，这是所有 Servlet 类的基类
import javax.servlet.http.HttpServlet;
// 导入 HttpServletRequest 类，用于获取客户端发送的请求信息
import javax.servlet.http.HttpServletRequest;
// 导入 HttpServletResponse 类，用于向客户端发送响应信息
import javax.servlet.http.HttpServletResponse;
// 导入 HttpSession 类，用于管理用户会话
import javax.servlet.http.HttpSession;
// 导入输入输出异常类，用于处理输入输出操作时可能出现的异常
import java.io.IOException;
// 导入 ResultSet 类，用于存储数据库查询结果
import java.sql.ResultSet;
// 使用 WebServlet 注解将该类映射到 /SchoQueryTeaByIdServlet1 路径，客户端可通过此路径访问该 Servlet
@WebServlet("/SchoQueryTeaByIdServlet1")
// 定义 SchoQueryTeaByIdServlet1 类，继承自 HttpServlet，表明这是一个处理 HTTP 请求的 Servlet
public class SchoQueryTeaByIdServlet1 extends HttpServlet {
// 重写 doGet 方法，用于处理客户端的 GET 请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为 UTF-8，防止中文等字符在传输过程中出现乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为 UTF-8，确保响应内容能正确显示中文等字符
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为 HTML，并且字符编码为 UTF-8
resp.setContentType("text/html;charset=utf-8");
// 从请求参数中获取教师编号 tno
String tno = req.getParameter("tno");
//获取登录时的session会话对象
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 以下两行代码被注释掉，原本可能是想从会话中获取用户名和学号，但在当前代码中未使用
// String userName = (String) session.getAttribute("userName");
// String sno = (String) session.getAttribute("sno");
// 从会话中获取名为 "belong" 的属性值，具体含义需根据业务逻辑确定
String belong = (String) session.getAttribute("belong");
// 将获取到的 "belong" 属性值打印到控制台，方便调试
System.out.println(belong);
// 声明一个字符串变量 sql，用于存储 SQL 语句
String sql = null;
// 创建一个 Object 类型的数组 objects，用于存储 SQL 语句中的参数，这里参数就是教师编号 tno
Object[] objects = {tno};
// 将获取到的教师编号 tno 打印到控制台，方便调试
System.out.println(tno);
//查询是否存在此人
// 构建一个 SQL 查询语句，用于查询 teacher 表中是否存在指定教师编号的记录
sql = "select count(*) as num from teacher where tno = ?";
// 调用 DeptAdminDao 类的 findTotalCount 方法执行上述 SQL 查询，返回符合条件的记录数量
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count > 0) { //有则继续操作
// 如果查询到的记录数量大于 0，说明该教师记录存在
if (count > 0) {
// 构建 SQL 查询语句，用于获取指定教师编号的教师的详细信息
sql = "select * from teacher where tno = ?";
// 调用 DeptAdminDao 类的 qureyInfo 方法执行查询，返回查询结果集
ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects);
// 创建一个 Teacher 对象，用于封装查询到的教师信息
Teacher teacher = new Teacher();
try {
// 遍历结果集，将每一行数据中的教师信息设置到 Teacher 对象中
while (resultSet.next()){
teacher.setTno(resultSet.getString("tno"));
teacher.setTname(resultSet.getString("tname"));
@ -57,25 +88,33 @@ public class SchoQueryTeaByIdServlet1 extends HttpServlet {
teacher.setTpsw(resultSet.getString("tpsw"));
}
} catch (Exception e) {
// 如果在遍历结果集过程中出现异常，打印异常堆栈信息，方便调试
e.printStackTrace();
}finally {
} finally {
// 调用 JDBCUtils 类的 close 方法关闭结果集，释放数据库资源
JDBCUtils.close(resultSet);
}
// 将获取到的教师性别打印到控制台，方便调试
System.out.println(teacher.getTsex());
// 将封装好的教师信息对象存储到请求属性中，以便在后续的页面中使用
req.setAttribute("teacher", teacher);
// 将请求转发到 /view/schoadmin/altertea.jsp 页面，并将教师信息传递过去，用于显示和修改教师信息
req.getRequestDispatcher("/view/schoadmin/altertea.jsp").forward(req, resp);
}else {
} else {
// 如果查询到的记录数量为 0，说明该教师记录不存在
// 将请求转发到 /view/alluse/noexistdataofalter.jsp 页面，提示用户要修改的数据不存在
req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp);
}
}
// 重写 doPost 方法，用于处理客户端的 POST 请求
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 调用 doGet 方法处理 POST 请求，实现 GET 和 POST 请求的统一处理
doGet(req, resp);
}
}
}

134
src/com/controller/schoadmin/SchoQueryTeaByPageServlet.java
Unescape View File

@ -1,165 +1,229 @@
// 声明该类所属的包，表明该类用于学校管理员相关功能的控制器类
package com.controller.schoadmin;
// 导入部门管理员数据访问对象类，用于执行数据库查询和统计等操作
import com.dao.DeptAdminDao;
// 导入学生数据访问对象类，这里使用StuDao查询教师信息可能存在错误，应该使用DeptAdminDao（可能是代码复用未修改完全）
import com.dao.StuDao;
// 导入分页信息封装类，用于处理分页查询的相关信息
import com.entity.PageBean;
// 导入教师实体类，用于封装从数据库中查询到的教师信息
import com.entity.Teacher;
// 导入JDBC工具类，用于关闭数据库连接、结果集等资源
import com.utils.JDBCUtils;
// 导入Servlet异常类，当Servlet执行过程中出现异常时会抛出该异常
import javax.servlet.ServletException;
// 导入Servlet注解，用于将该Servlet映射到指定的URL路径
import javax.servlet.annotation.WebServlet;
// 导入HttpServlet基类，所有Servlet类都需要继承自它
import javax.servlet.http.HttpServlet;
// 导入HTTP请求对象类，用于获取请求中的参数、属性等信息
import javax.servlet.http.HttpServletRequest;
// 导入HTTP响应对象类，用于设置响应的内容、状态码等信息
import javax.servlet.http.HttpServletResponse;
// 导入HTTP会话对象类，用于管理用户的会话信息
import javax.servlet.http.HttpSession;
// 导入输入输出异常类，当进行输入输出操作时可能会抛出该异常
import java.io.IOException;
// 导入数据库结果集类，用于存储数据库查询的结果
import java.sql.ResultSet;
// 导入动态数组类，用于存储查询到的教师信息集合
import java.util.ArrayList;
// 使用注解将该Servlet映射到指定的URL路径，客户端通过此路径访问该Servlet
@WebServlet("/SchoQueryTeaByPageServlet")
// 定义一个继承自HttpServlet的类，用于处理学校管理员分页查询教师信息的请求
public class SchoQueryTeaByPageServlet extends HttpServlet {
// 重写doGet方法，用于处理HTTP GET请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为UTF-8，确保能正确处理包含中文字符等的请求参数
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8，保证响应内容中的中文字符能正确显示
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML，字符编码为UTF-8，告知客户端返回的是HTML格式的数据
resp.setContentType("text/html;charset=utf-8");
//获取请求参数
// 从请求中获取名为tno的参数，代表教师编号
String tno = req.getParameter("tno");
// 从请求中获取名为tname的参数，代表教师姓名
String tname = req.getParameter("tname");
// 从请求中获取名为tdept的参数，代表教师所属部门
String tdept = req.getParameter("tdept");
//如果传入的参数为null，则置为空字符串
if (tno == null){
// 如果教师编号参数为空，将其设置为空字符串，方便后续进行模糊查询
if (tno == null) {
tno = "";
}
if (tname == null){
// 如果教师姓名参数为空，将其设置为空字符串
if (tname == null) {
tname = "";
}
if (tdept == null){
// 如果教师所属部门参数为空，将其设置为空字符串
if (tdept == null) {
tdept = "";
}
//变为like查询所需的字符串参数
// 将教师编号参数转换为适合SQL like查询的格式，即在前后添加通配符%
String tno1 = "%" + tno + "%";
// 将教师姓名参数转换为适合SQL like查询的格式
String tname1 = "%" + tname + "%";
// 将教师所属部门参数转换为适合SQL like查询的格式
String tdept1 = "%" + tdept + "%";
//设置请求的属性参数，后面需要用
// 将原始的教师编号、姓名和所属部门参数设置为请求的属性，方便后续页面使用
req.setAttribute("tno", tno);
req.setAttribute("tname",tname);
req.setAttribute("tdept",tdept);
req.setAttribute("tname", tname);
req.setAttribute("tdept", tdept);
// 在控制台打印转换后的教师编号、姓名和所属部门参数，用于调试
System.out.println(tno1);
System.out.println(tname1);
System.out.println(tdept1);
//获取登录时的session会话对象
// 获取当前请求对应的会话对象
HttpSession session = req.getSession();
// 以下两行代码被注释掉，原本用于从会话中获取用户名和学号，这里未使用
// String userName = (String) session.getAttribute("userName");
// String sno = (String) session.getAttribute("sno");
// 从会话中获取名为belong的属性值，可能代表学校相关信息（这里用途不太明确）
String belong = (String) session.getAttribute("belong");
// 声明一个用于存储SQL语句的变量，初始值为null
String sql = null;
// 以下两行代码被注释掉，原本用于打印用户名和学号，这里未使用
// System.out.println(userName);
// System.out.println(sno);
// 在控制台打印获取到的belong属性值，用于调试
System.out.println(belong);
// 在控制台打印一段调试信息
System.out.println("hdghghjg");
String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码
String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数
// 从请求中获取名为currentPage的参数，代表当前页码
String currentPage = req.getParameter("currentPage");
// 从请求中获取名为rows的参数，代表每页显示的记录数
String rows = req.getParameter("rows");
//如果未设请求参数，此处自动设置参数为第一页
if (currentPage == null || "".equals(currentPage)){
// 如果当前页码参数为空或为空字符串，将当前页码设置为第一页
if (currentPage == null || "".equals(currentPage)) {
currentPage = "1";
}
//如果没有设置rows的请求参数，此处自动设置
if (rows == null || "".equals(rows)){
// 如果每页显示的记录数参数为空或为空字符串，将每页显示记录数设置为7
if (rows == null || "".equals(rows)) {
rows = "7";
}
//获取条件查询的参数
// 将当前页码参数转换为整数类型
int currentPage1 = Integer.parseInt(currentPage);
// 将每页显示的记录数参数转换为整数类型
int rows1 = Integer.parseInt(rows);
//如果当前页数小于1，则设置当前页数为1
if (currentPage1 <= 0){
// 如果当前页码小于等于0，将当前页码设置为1
if (currentPage1 <= 0) {
currentPage1 = 1;
}
//设置StuPunch类的对象类型
// 创建一个用于封装教师信息的分页对象
PageBean<Teacher> pageBean = new PageBean<Teacher>();
//设置当前页码
// 设置分页对象的当前页码
pageBean.setCurrentPage(currentPage1);
//设置每页的记录数
// 设置分页对象的每页记录数
pageBean.setRows(rows1);
// 构建SQL查询语句，用于查询符合条件的教师记录的总数（根据教师编号、姓名、所属部门模糊查询）
sql = " select count(*) as num from teacher where tno like ? and tname like ? and tdept like ?";
// 创建一个包含查询参数的对象数组
Object[] objects = {tno1, tname1, tdept1};
//计算总记录数，并设置
// 调用部门管理员数据访问对象的方法，计算符合条件的教师记录的总数
int totalCount = DeptAdminDao.findTotalCount(sql, objects);
// 在控制台打印查询到的总记录数，用于调试
System.out.println(totalCount);
// 设置分页对象的总记录数
pageBean.setTotalCount(totalCount);
if (totalCount > 0){
//计算总页码，并设置
int totalPage = (totalCount % rows1) == 0 ? totalCount/rows1 : (totalCount/rows1 + 1);
// 如果总记录数大于0，说明有符合条件的记录
if (totalCount > 0) {
// 计算总页数，如果总记录数能被每页记录数整除，则总页数为总记录数除以每页记录数，否则总页数为总记录数除以每页记录数再加1
int totalPage = (totalCount % rows1) == 0 ? totalCount / rows1 : (totalCount / rows1 + 1);
// 设置分页对象的总页数
pageBean.setTotalPage(totalPage);
//如果当前页数大于总页数
if (currentPage1 > pageBean.getTotalPage()){
// 如果当前页码大于总页数，将当前页码设置为总页数
if (currentPage1 > pageBean.getTotalPage()) {
currentPage1 = pageBean.getTotalPage();
//重新设置当前页码
// 重新设置分页对象的当前页码
pageBean.setCurrentPage(currentPage1);
}
//计算开始的记录和list对象集合，并设置
// 计算当前页开始的记录索引
int start = (currentPage1 - 1) * rows1;
// 构建SQL查询语句，用于查询当前页符合条件的教师记录
sql = "select * from teacher where tno like ? and tname like ? and tdept like ? limit ?, ?";
// 创建一个包含查询参数的对象数组，包括分页信息
Object[] objects1 = {tno1, tname1, tdept1, start, rows1};
// 调用学生数据访问对象的方法，查询当前页符合条件的教师记录（这里使用StuDao可能错误）
ResultSet resultSet = StuDao.QureyInfoByPage(sql, objects1);
// 创建一个动态数组，用于存储查询到的教师信息
ArrayList teaArrayList = new ArrayList();
try {
while (resultSet.next()){
// 遍历结果集，将每条记录封装成教师对象并添加到数组中
while (resultSet.next()) {
Teacher teacher = new Teacher();
// 设置教师编号
teacher.setTno(resultSet.getString("tno"));
// 设置教师姓名
teacher.setTname(resultSet.getString("tname"));
// 设置教师性别
teacher.setTsex(resultSet.getString("tsex"));
// 设置教师年龄
teacher.setTage(resultSet.getInt("tage"));
// 设置教师所属部门
teacher.setTdept(resultSet.getString("tdept"));
// 设置教师联系电话
teacher.setTphone(resultSet.getString("tphone"));
// 设置教师密码
teacher.setTpsw(resultSet.getString("tpsw"));
// 将教师对象添加到数组中
teaArrayList.add(teacher);
}
} catch (Exception e) {
// 若在遍历结果集过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}finally {
} finally {
// 无论是否出现异常，最后关闭结果集，释放资源
JDBCUtils.close(resultSet);
}
// 将存储教师信息的数组设置到分页对象中
pageBean.setArrayList(teaArrayList);
// 在控制台打印存储教师信息的数组，用于调试
System.out.println(teaArrayList);
// 在控制台打印分页对象，用于调试
System.out.println(pageBean);
// 将分页对象设置为请求的属性，方便后续页面使用
req.setAttribute("pageBean", pageBean);
// 将请求转发到学校管理员教师信息列表页面
req.getRequestDispatcher("/view/schoadmin/teainfolist.jsp").forward(req, resp);
}else {
} else {
// 如果总记录数为0，说明没有符合条件的记录，将请求转发到无数据提示页面
req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp);
}
}
// 重写doPost方法，用于处理HTTP POST请求，这里直接调用doGet方法，即POST请求的处理逻辑与GET请求相同
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

50
src/com/controller/schoadmin/SchoQueryTeaPunchByIdServlet.java
Unescape View File

@ -1,44 +1,70 @@
// 声明该类所属的包名为 com.controller.schoadmin
package com.controller.schoadmin;
// 导入 DeptAdminDao 类，该类应该包含了与部门管理相关的数据库操作方法
import com.dao.DeptAdminDao;
// 导入 TeaPunch 实体类，用于封装教师打卡信息
import com.entity.TeaPunch;
// 导入 JDBCUtils 工具类，通常用于管理 JDBC 资源，如关闭连接、结果集等
import com.utils.JDBCUtils;
// 导入 Servlet 异常处理类，用于处理 Servlet 执行过程中可能出现的异常
import javax.servlet.ServletException;
// 导入 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径
import javax.servlet.annotation.WebServlet;
// 导入 HttpServlet 类，它是所有 Servlet 类的基类
import javax.servlet.http.HttpServlet;
// 导入 HttpServletRequest 类，用于获取客户端发送的请求信息
import javax.servlet.http.HttpServletRequest;
// 导入 HttpServletResponse 类，用于向客户端发送响应信息
import javax.servlet.http.HttpServletResponse;
// 导入输入输出异常类，用于处理输入输出操作时可能出现的异常
import java.io.IOException;
// 导入 ResultSet 类，用于存储数据库查询结果
import java.sql.ResultSet;
// 使用 WebServlet 注解将该类映射到 /SchoQueryTeaPunchByIdServlet 路径，客户端可通过此路径访问该 Servlet
@WebServlet("/SchoQueryTeaPunchByIdServlet")
// 定义 SchoQueryTeaPunchByIdServlet 类，继承自 HttpServlet，表明这是一个处理 HTTP 请求的 Servlet
public class SchoQueryTeaPunchByIdServlet extends HttpServlet {
// 重写 doGet 方法，用于处理客户端发送的 HTTP GET 请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为 UTF-8，防止中文等字符在传输过程中出现乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为 UTF-8，确保响应内容能正确显示中文等字符
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为 HTML，并且字符编码为 UTF-8
resp.setContentType("text/html;charset=utf-8");
//获取请求参数
// 从请求参数中获取教师编号
String tno = req.getParameter("tno");
// 从请求参数中获取打卡日期
String tpunchdate = req.getParameter("tpunchdate");
// 声明一个字符串变量，用于存储 SQL 语句
String sql = null;
// 创建一个 Object 类型的数组，用于存储 SQL 语句中的参数
Object[] objects = {tno, tpunchdate};
//查询是否存在此人
// 构建 SQL 查询语句，用于查询 teapunchin 表中是否存在指定教师编号和打卡日期的记录
sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?";
// 调用 DeptAdminDao 类的 findTotalCount 方法执行上述 SQL 查询，返回符合条件的记录数量
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count > 0){ //有则继续操作
// 如果查询到的记录数量大于 0，说明存在该教师在指定日期的打卡记录
if (count > 0) {
// 构建 SQL 查询语句，通过连接 teacher 表和 teapunchin 表，获取教师姓名和打卡信息
sql = "select t.tname,tp.* from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ?";
// 调用 DeptAdminDao 类的 qureyInfo 方法执行上述 SQL 查询，返回结果集
ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects);
// 创建一个 TeaPunch 对象，用于封装查询到的打卡信息
TeaPunch teaPunch = new TeaPunch();
try {
while (resultSet.next()){
// 遍历结果集，将每一行数据中的打卡信息设置到 TeaPunch 对象中
while (resultSet.next()) {
teaPunch.setTno(resultSet.getString("tno"));
teaPunch.setTname(resultSet.getString("tname"));
teaPunch.setTispunch(resultSet.getString("tispunch"));
@ -51,24 +77,34 @@ public class SchoQueryTeaPunchByIdServlet extends HttpServlet {
teaPunch.setTstatus(resultSet.getString("tstatus"));
}
} catch (Exception e) {
// 如果在遍历结果集过程中出现异常，打印异常堆栈信息，方便调试
e.printStackTrace();
}finally {
} finally {
// 调用 JDBCUtils 类的 close 方法关闭结果集，释放数据库资源
JDBCUtils.close(resultSet);
}
// 打印教师编号到控制台，方便调试查看
System.out.println(teaPunch.getTno());
// 打印教师姓名到控制台，方便调试查看
System.out.println(teaPunch.getTname());
// 将封装好的打卡信息对象存储到请求属性中，以便在后续的 JSP 页面中使用
req.setAttribute("teaPunch", teaPunch);
// 将请求转发到 /view/schoadmin/alterteapunch.jsp 页面，用于修改教师打卡信息
req.getRequestDispatcher("/view/schoadmin/alterteapunch.jsp").forward(req, resp);
}else {
} else {
// 如果查询到的记录数量为 0，说明不存在该教师在指定日期的打卡记录
// 将请求转发到 /view/alluse/noexistdataofalter.jsp 页面，提示用户要修改的数据不存在
req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp);
}
}
// 重写 doPost 方法，用于处理客户端发送的 HTTP POST 请求
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 调用 doGet 方法处理 POST 请求，实现 GET 和 POST 请求的统一处理
doGet(req, resp);
}
}
}

64
src/com/controller/schoadmin/SchoQueryTeaPunchByIdServlet1.java
Unescape View File

@ -1,83 +1,131 @@
// 声明该类所属的包，表明该类用于学校管理员相关功能的控制器类
package com.controller.schoadmin;
// 导入部门管理员数据访问对象类，用于执行数据库查询等操作
import com.dao.DeptAdminDao;
// 导入教师打卡实体类，用于封装教师打卡的详细信息
import com.entity.TeaPunch;
// 导入JDBC工具类，用于处理数据库相关的操作，如关闭结果集
import com.utils.JDBCUtils;
// 导入Servlet异常类，用于处理Servlet执行过程中出现的异常情况
import javax.servlet.ServletException;
// 导入Servlet注解，用于将该Servlet映射到指定的URL路径
import javax.servlet.annotation.WebServlet;
// 导入HttpServlet基类，所有Servlet类都需要继承自它来处理HTTP请求
import javax.servlet.http.HttpServlet;
// 导入HTTP请求对象类，用于获取请求中的参数、属性等信息
import javax.servlet.http.HttpServletRequest;
// 导入HTTP响应对象类，用于设置响应的内容、状态码等信息
import javax.servlet.http.HttpServletResponse;
// 导入HTTP会话对象类，用于管理用户的会话信息
import javax.servlet.http.HttpSession;
// 导入输入输出异常类，用于处理输入输出操作中出现的异常
import java.io.IOException;
// 导入数据库结果集类，用于存储数据库查询的结果
import java.sql.ResultSet;
// 使用注解将该Servlet映射到指定的URL路径，客户端通过此路径访问该Servlet
@WebServlet("/SchoQueryTeaPunchByIdServlet1")
// 定义一个继承自HttpServlet的类，用于处理学校管理员根据教师编号和打卡日期查询教师打卡信息的请求
public class SchoQueryTeaPunchByIdServlet1 extends HttpServlet {
// 重写doGet方法，用于处理HTTP GET请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为UTF-8，确保能正确处理包含中文字符等的请求参数
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8，保证响应内容中的中文字符能正确显示
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML，字符编码为UTF-8，告知客户端返回的是HTML格式的数据
resp.setContentType("text/html;charset=utf-8");
//获取请求参数
// 从请求中获取名为tno的参数，代表教师编号
String tno = req.getParameter("tno");
// 从请求中获取名为tpunchdate的参数，代表教师打卡日期
String tpunchdate = req.getParameter("tpunchdate");
//获取登录时的session会话对象
// 获取当前请求对应的会话对象
HttpSession session = req.getSession();
// 以下两行代码被注释掉，原本用于从会话中获取用户名和学号，这里未使用
// String userName = (String) session.getAttribute("userName");
// String sno = (String) session.getAttribute("sno");
// 从会话中获取名为belong的属性值，可能代表教师所属部门或其他相关信息
String belong = (String) session.getAttribute("belong");
// 在控制台打印获取到的belong属性值，用于调试
System.out.println(belong);
// 声明一个用于存储SQL语句的变量，初始值为null
String sql = null;
// 创建一个Object数组，用于存储SQL语句中的参数值，包含教师编号和打卡日期
Object[] objects = {tno, tpunchdate};
//查询是否存在此人
// 构建SQL查询语句，用于查询数据库中是否存在指定教师编号和打卡日期的教师打卡记录，count(*) as num用于统计符合条件的记录数
sql = "select count(*) as num from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ?";
// 调用DeptAdminDao类的findTotalCount方法执行SQL查询，获取符合条件的记录数
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count > 0){ //有则继续操作
// 如果count大于0，说明存在该教师编号和打卡日期对应的教师打卡记录，可以继续查询详细信息
if (count > 0) {
// 构建SQL查询语句，用于获取指定教师编号和打卡日期的教师打卡详细信息，同时关联teacher表获取教师姓名
sql = "select t.tname,tp.* from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ?";
// 调用DeptAdminDao类的qureyInfo方法执行SQL查询，并将结果存储在ResultSet对象中
ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects);
// 创建一个TeaPunch对象，用于封装查询到的教师打卡信息
TeaPunch teaPunch = new TeaPunch();
try {
while (resultSet.next()){
// 遍历结果集，由于查询结果理论上只有一条记录（根据教师编号和打卡日期查询），这里while循环通常只会执行一次
while (resultSet.next()) {
// 从结果集中获取教师编号，并设置到TeaPunch对象中
teaPunch.setTno(resultSet.getString("tno"));
// 从结果集中获取教师姓名，并设置到TeaPunch对象中
teaPunch.setTname(resultSet.getString("tname"));
// 从结果集中获取是否打卡的信息，并设置到TeaPunch对象中
teaPunch.setTispunch(resultSet.getString("tispunch"));
// 从结果集中获取打卡日期，并设置到TeaPunch对象中
teaPunch.setTpunchdate(resultSet.getDate("tpunchdate"));
// 从结果集中获取打卡时间，并设置到TeaPunch对象中
teaPunch.setTpunchtime(resultSet.getString("tpunchtime"));
// 从结果集中获取是否发热的信息，并设置到TeaPunch对象中
teaPunch.setTishot(resultSet.getString("tishot"));
// 从结果集中获取是否咳嗽的信息，并设置到TeaPunch对象中
teaPunch.setTiscough(resultSet.getString("tiscough"));
// 从结果集中获取是否有其他症状的信息，并设置到TeaPunch对象中
teaPunch.setTisseem(resultSet.getString("tisseem"));
// 从结果集中获取是否确诊的信息，并设置到TeaPunch对象中
teaPunch.setTisdiagnose(resultSet.getString("tisdiagnose"));
// 从结果集中获取打卡状态的信息，并设置到TeaPunch对象中
teaPunch.setTstatus(resultSet.getString("tstatus"));
}
} catch (Exception e) {
// 若在遍历结果集过程中出现异常，打印异常堆栈信息，方便调试
e.printStackTrace();
}finally {
} finally {
// 无论是否出现异常，最后都调用JDBCUtils类的close方法关闭结果集，释放资源
JDBCUtils.close(resultSet);
}
// 在控制台打印教师编号，用于调试，查看获取的教师打卡信息是否正确
System.out.println(teaPunch.getTno());
// 在控制台打印教师姓名，用于调试
System.out.println(teaPunch.getTname());
// 将封装好教师打卡信息的TeaPunch对象添加到请求属性中，属性名为teaPunch
req.setAttribute("teaPunch", teaPunch);
// 将请求转发到/view/schoadmin/alterteapunch.jsp页面，在该页面可以对教师打卡信息进行修改操作
req.getRequestDispatcher("/view/schoadmin/alterteapunch.jsp").forward(req, resp);
}else {
} else {
// 如果count不大于0，说明不存在该教师编号和打卡日期对应的教师打卡记录，将请求转发到提示不存在数据的页面
req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp);
}
}
// 重写doPost方法，用于处理HTTP POST请求，这里直接调用doGet方法，即POST请求的处理逻辑与GET请求相同
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

103
src/com/controller/schoadmin/SchoQueryTeaPunchByPageServlet.java
Unescape View File

@ -1,146 +1,193 @@
// 声明该类所在的包为 com.controller.schoadmin
package com.controller.schoadmin;
// 导入 DeptAdminDao 类，可能包含与部门管理相关的数据库操作方法
import com.dao.DeptAdminDao;
// 导入 StuDao 类，从代码看可能用于与学生相关（这里实际用于教师打卡信息分页查询）的数据库操作
import com.dao.StuDao;
// 导入 PageBean 实体类，用于封装分页相关的数据
import com.entity.PageBean;
// 导入 TeaPunch 实体类，用于封装教师打卡信息
import com.entity.TeaPunch;
// 导入 JDBCUtils 工具类，用于管理 JDBC 相关的操作，如连接、关闭等
import com.utils.JDBCUtils;
// 导入 Servlet 异常处理类，处理 Servlet 执行过程中可能出现的异常
import javax.servlet.ServletException;
// 导入 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径
import javax.servlet.annotation.WebServlet;
// 导入 HttpServlet 类，所有 Servlet 类的基类
import javax.servlet.http.HttpServlet;
// 导入 HttpServletRequest 类，用于获取客户端的请求信息
import javax.servlet.http.HttpServletRequest;
// 导入 HttpServletResponse 类，用于向客户端发送响应信息
import javax.servlet.http.HttpServletResponse;
// 导入 HttpSession 类，用于管理用户会话
import javax.servlet.http.HttpSession;
// 导入输入输出异常类，处理输入输出操作时可能出现的异常
import java.io.IOException;
// 导入 ResultSet 类，用于存储数据库查询结果
import java.sql.ResultSet;
// 导入 ArrayList 类，用于存储对象集合
import java.util.ArrayList;
// 使用 WebServlet 注解将该类映射到 /SchoQueryTeaPunchByPageServlet 路径，客户端可通过此路径访问该 Servlet
@WebServlet("/SchoQueryTeaPunchByPageServlet")
// 定义 SchoQueryTeaPunchByPageServlet 类，继承自 HttpServlet，处理 HTTP 请求
public class SchoQueryTeaPunchByPageServlet extends HttpServlet {
// 重写 doGet 方法，处理客户端的 GET 请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为 UTF-8，防止中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为 UTF-8，防止中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为 HTML，字符编码为 UTF-8
resp.setContentType("text/html;charset=utf-8");
//获取请求参数
// 从请求中获取教师编号参数
String tno = req.getParameter("tno");
// 从请求中获取教师姓名参数
String tname = req.getParameter("tname");
// 从请求中获取教师部门参数
String tdept = req.getParameter("tdept");
// 从请求中获取打卡日期参数
String tpunchdate = req.getParameter("tpunchdate");
// 打印获取到的参数，用于调试
System.out.println(tno);
System.out.println(tname);
System.out.println(tdept);
System.out.println(tpunchdate);
//如果传入的参数为null，则置为空字符串
// 如果教师编号参数为 null，将其设置为空字符串
if (tno == null){
tno = "";
}
// 如果教师姓名参数为 null，将其设置为空字符串
if (tname == null){
tname = "";
}
// 如果教师部门参数为 null，将其设置为空字符串
if (tdept == null){
tdept = "";
}
// 如果打卡日期参数为 null，将其设置为空字符串
if (tpunchdate == null){
tpunchdate = "";
}
//变为like查询所需的字符串参数
// 将参数转换为用于模糊查询（like）的字符串格式
String tno1 = "%" + tno + "%";
String tname1 = "%" + tname + "%";
String tdept1 = "%" + tdept + "%";
String tpunchdate1 = "%" + tpunchdate + "%";
//设置请求的属性参数，后面需要用
// 将原始参数设置为请求属性，方便后续在 JSP 页面中使用
req.setAttribute("tno", tno);
req.setAttribute("tname",tname);
req.setAttribute("tdept", tdept);
req.setAttribute("tpunchdate",tpunchdate);
// 打印转换后的模糊查询参数，用于调试
System.out.println(tno1);
System.out.println(tname1);
System.out.println(tdept1);
System.out.println(tpunchdate1);
//获取登录时的session会话对象
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 以下两行代码被注释掉，原本可能是想从会话中获取用户名和学号，但在当前代码中未使用
// String userName = (String) session.getAttribute("userName");
// String sno = (String) session.getAttribute("sno");
// 从会话中获取名为 "belong" 的属性值，具体含义需根据业务逻辑确定
String belong = (String) session.getAttribute("belong");
// 声明 SQL 语句变量
String sql = null;
// 以下两行代码被注释掉，原本可能是想打印用户名和学号，但由于变量被注释掉，无法使用
// System.out.println(userName);
// System.out.println(sno);
// 打印获取到的 "belong" 属性值，用于调试
System.out.println(belong);
// 打印字符串，用于调试
System.out.println("hdghghjg");
String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码
String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数
// 从请求中获取当前页码参数
String currentPage = req.getParameter("currentPage");
// 从请求中获取每页显示的行数参数
String rows = req.getParameter("rows");
//如果未设请求参数，此处自动设置参数为第一页
// 如果当前页码参数为 null 或空字符串，设置当前页码为 1
if (currentPage == null || "".equals(currentPage)){
currentPage = "1";
}
//如果没有设置rows的请求参数，此处自动设置
// 如果每页显示行数参数为 null 或空字符串，设置每页显示行数为 7
if (rows == null || "".equals(rows)){
rows = "7";
}
//获取条件查询的参数
// 将当前页码字符串转换为整数类型
int currentPage1 = Integer.parseInt(currentPage);
// 将每页显示行数字符串转换为整数类型
int rows1 = Integer.parseInt(rows);
//如果当前页数小于1，则设置当前页数为1
// 如果当前页码小于等于 0，设置当前页码为 1
if (currentPage1 <= 0){
currentPage1 = 1;
}
//设置StuPunch类的对象类型
// 创建一个 PageBean 对象，用于封装教师打卡信息的分页数据
PageBean<TeaPunch> pageBean = new PageBean<TeaPunch>();
//设置当前页码
// 设置当前页码到 PageBean 对象中
pageBean.setCurrentPage(currentPage1);
//设置每页的记录数
// 设置每页的记录数到 PageBean 对象中
pageBean.setRows(rows1);
// 构建 SQL 语句，用于查询符合条件的记录总数
sql = " select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tno like ? and t.tname like ? and t.tdept like ? and tp.tpunchdate like ?";
// 创建参数数组，用于传递给 SQL 语句
Object[] objects = {tno1, tname1, tdept1, tpunchdate1};
//计算总记录数，并设置
// 调用 DeptAdminDao 的方法获取总记录数
int totalCount = DeptAdminDao.findTotalCount(sql, objects);
// 打印总记录数，用于调试
System.out.println(totalCount);
// 设置总记录数到 PageBean 对象中
pageBean.setTotalCount(totalCount);
// 如果总记录数大于 0
if (totalCount > 0){
//计算总页码，并设置
// 计算总页数，并设置到 PageBean 对象中
int totalPage = (totalCount % rows1) == 0 ? totalCount/rows1 : (totalCount/rows1 + 1);
pageBean.setTotalPage(totalPage);
//如果当前页数大于总页数
// 如果当前页码大于总页数
if (currentPage1 > pageBean.getTotalPage()){
currentPage1 = pageBean.getTotalPage();
//重新设置当前页码
// 重新设置当前页码到 PageBean 对象中
pageBean.setCurrentPage(currentPage1);
}
//计算开始的记录和list对象集合，并设置
// 计算查询开始的记录位置
int start = (currentPage1 - 1) * rows1;
// 构建 SQL 语句，用于查询当前页的教师打卡信息
sql = "select t.tname,t.tdept, tp.* from teacher t, teapunchin tp where t.tno = tp.tno and t.tno like ? and t.tname like ? and t.tdept like ? and tp.tpunchdate like ? limit ?, ?";
// 创建参数数组，用于传递给 SQL 语句
Object[] objects1 = {tno1, tname1, tdept1, tpunchdate1, start, rows1};
// 调用 StuDao 的方法执行查询，获取结果集
ResultSet resultSet = StuDao.QureyInfoByPage(sql, objects1);
// 创建 ArrayList 对象，用于存储查询到的教师打卡信息
ArrayList teaPunchArrayList = new ArrayList();
try {
// 遍历结果集，将每一条记录封装成 TeaPunch 对象，并添加到 ArrayList 中
while (resultSet.next()){
TeaPunch teaPunch = new TeaPunch();
teaPunch.setTno(resultSet.getString("tno"));
@ -157,25 +204,35 @@ public class SchoQueryTeaPunchByPageServlet extends HttpServlet {
teaPunchArrayList.add(teaPunch);
}
} catch (Exception e) {
// 如果在遍历结果集过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}finally {
} finally {
// 调用 JDBCUtils 的方法关闭结果集，释放资源
JDBCUtils.close(resultSet);
}
// 将存储教师打卡信息的 ArrayList 设置到 PageBean 对象中
pageBean.setArrayList(teaPunchArrayList);
// 打印 ArrayList，用于调试
System.out.println(teaPunchArrayList);
// 打印 PageBean 对象，用于调试
System.out.println(pageBean);
// 将 PageBean 对象设置为请求属性，以便在后续的 JSP 页面中使用
req.setAttribute("pageBean", pageBean);
// 将请求转发到 /view/schoadmin/teapunchlist.jsp 页面，展示教师打卡信息列表
req.getRequestDispatcher("/view/schoadmin/teapunchlist.jsp").forward(req, resp);
}else {
} else {
// 如果总记录数为 0，将请求转发到 /view/alluse/nodata.jsp 页面，提示没有数据
req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp);
}
}
// 重写 doPost 方法，处理客户端的 POST 请求
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 调用 doGet 方法处理 POST 请求，实现 GET 和 POST 请求的统一处理
doGet(req, resp);
}
}
}

51
src/com/controller/tea/TeaQueryInfoServlet.java
Unescape View File

@ -1,70 +1,117 @@
// 声明该类所属的包为 com.controller.tea，通常用于存放与教师相关的控制器类
package com.controller.tea;
// 导入 com.dao 包下的 StuDao 类，可能用于处理学生相关的数据访问操作，不过在本类中未使用
import com.dao.StuDao;
// 导入 com.dao 包下的 TeaDao 类，用于处理教师相关的数据访问操作，如查询教师信息
import com.dao.TeaDao;
// 导入 com.entity 包下的 Student 类，代表学生实体，在本类中未使用
import com.entity.Student;
// 导入 com.entity 包下的 Teacher 类，代表教师实体，用于封装教师的各种属性
import com.entity.Teacher;
// 导入 com.utils 包下的 JDBCUtils 类，通常用于处理 JDBC 操作的工具类，如关闭数据库连接、结果集等
import com.utils.JDBCUtils;
// 导入 javax.servlet 包下的 ServletException 类，用于处理 Servlet 操作过程中可能出现的异常
import javax.servlet.ServletException;
// 导入 javax.servlet.annotation 包下的 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径
import javax.servlet.annotation.WebServlet;
// 导入 javax.servlet.http 包下的 HttpServlet 类，这是所有 HTTP Servlet 的基类，该类继承自它以处理 HTTP 请求
import javax.servlet.http.HttpServlet;
// 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息
import javax.servlet.http.HttpServletRequest;
// 导入 javax.servlet.http 包下的 HttpServletResponse 类，用于封装服务器发送给客户端的 HTTP 响应信息
import javax.servlet.http.HttpServletResponse;
// 导入 javax.servlet.http 包下的 HttpSession 类，用于管理用户会话，存储用户的会话信息
import javax.servlet.http.HttpSession;
// 导入 java.io 包下的 IOException 类，用于处理输入输出操作中可能出现的异常
import java.io.IOException;
// 导入 java.sql 包下的 ResultSet 类，用于存储数据库查询操作返回的结果集
import java.sql.ResultSet;
// 导入 java.util 包下的 ArrayList 类，这是一个动态数组，用于存储 Teacher 对象
import java.util.ArrayList;
// 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /TeaQueryInfoServlet
@WebServlet("/TeaQueryInfoServlet")
// 定义一个名为 TeaQueryInfoServlet 的类，继承自 HttpServlet，用于处理教师信息查询的请求
public class TeaQueryInfoServlet extends HttpServlet {
// 重写 doGet 方法，用于处理 HTTP GET 请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求对象的字符编码为 UTF-8，确保能正确处理中文字符等
req.setCharacterEncoding("utf-8");
// 设置响应对象的字符编码为 UTF-8，确保返回给客户端的内容能正确显示中文字符等
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为 text/html，字符编码为 UTF-8，告知客户端返回的是 HTML 内容且使用 UTF-8 编码
resp.setContentType("text/html;charset=utf-8");
// 从请求对象中获取当前的会话对象
HttpSession session = req.getSession();
// 从会话对象中获取名为 userName 的属性值，并将其转换为 String 类型
String userName = (String) session.getAttribute("userName");
// 从会话对象中获取名为 tno 的属性值，并将其转换为 String 类型，tno 代表教师编号
String tno = (String) session.getAttribute("tno");
// 在控制台打印用户名
System.out.println(userName);
// 在控制台打印教师编号
System.out.println(tno);
// 在控制台打印一段调试信息
System.out.println("hdghghjg");
// 定义一个 SQL 查询语句，用于从 teacher 表中查询教师编号等于指定值的所有记录
String sql = "select * from teacher where tno = ?";
// 定义一个 Object 类型的数组，用于存储 SQL 查询语句中的参数值，这里存储的是教师编号
Object[] objects = {tno};
// 调用 TeaDao 类的 qureyInfo 方法执行 SQL 查询，并将查询结果存储在 ResultSet 对象中
ResultSet resultSet = TeaDao.qureyInfo(sql, objects);
// 创建一个 ArrayList 对象，用于存储查询到的 Teacher 对象
ArrayList<Teacher> teaArrayList = new ArrayList<Teacher>();
try {
// 遍历结果集，判断是否还有下一条记录
while (resultSet.next()){
// 创建一个新的 Teacher 对象
Teacher teacher = new Teacher();
// 从结果集中获取教师编号，并设置到 Teacher 对象中
teacher.setTno(resultSet.getString("tno"));
// 从结果集中获取教师姓名，并设置到 Teacher 对象中
teacher.setTname(resultSet.getString("tname"));
// 从结果集中获取教师性别，并设置到 Teacher 对象中
teacher.setTsex(resultSet.getString("tsex"));
// 从结果集中获取教师年龄，并设置到 Teacher 对象中
teacher.setTage(resultSet.getInt("tage"));
// 从结果集中获取教师所在部门，并设置到 Teacher 对象中
teacher.setTdept(resultSet.getString("tdept"));
// 从结果集中获取教师电话号码，并设置到 Teacher 对象中
teacher.setTphone(resultSet.getString("tphone"));
// 从结果集中获取教师密码，并设置到 Teacher 对象中
teacher.setTpsw(resultSet.getString("tpsw"));
// 将填充好信息的 Teacher 对象添加到 ArrayList 中
teaArrayList.add(teacher);
}
} catch (Exception e) {
// 若在遍历结果集过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}finally {
} finally {
// 无论是否出现异常，最后都调用 JDBCUtils 类的 close 方法关闭结果集
JDBCUtils.close(resultSet);
}
// 在控制台打印存储教师信息的 ArrayList
System.out.println(teaArrayList);
// 将存储教师信息的 ArrayList 作为属性添加到请求对象中，以便在后续的 JSP 页面中使用
req.setAttribute("teaArrayList", teaArrayList);
// 调用请求对象的 getRequestDispatcher 方法获取请求转发器，将请求转发到 /view/tea/teainfo.jsp 页面
req.getRequestDispatcher("/view/tea/teainfo.jsp").forward(req, resp);
}
// 重写 doPost 方法，用于处理 HTTP POST 请求，这里直接调用 doGet 方法，即 POST 请求的处理逻辑与 GET 请求相同
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

120
src/com/controller/tea/TeaQueryPunchByPageServlet.java
Unescape View File

@ -1,147 +1,213 @@
// 声明该类所属的包为 com.controller.tea，通常用于存放与教师相关的控制器类
package com.controller.tea;
// 导入 com.dao 包下的 StuDao 类，不过在当前代码中未使用该类，可能后续有扩展需求
import com.dao.StuDao;
// 导入 com.dao 包下的 TeaDao 类，该类用于处理与教师相关的数据访问操作，如查询、统计等
import com.dao.TeaDao;
// 导入 com.entity 包下的 PageBean 类，用于封装分页信息，辅助实现分页查询功能
import com.entity.PageBean;
// 导入 com.entity 包下的 StuPunch 类，代表学生打卡信息实体，此处虽使用但类型可能有误，实际应是 TeaPunch 类型
import com.entity.StuPunch;
// 导入 com.entity 包下的 TeaPunch 类，代表教师打卡信息实体，用于封装教师打卡的各项属性
import com.entity.TeaPunch;
// 导入 com.utils 包下的 JDBCUtils 类，这是一个工具类，通常用于处理 JDBC 操作，如关闭数据库连接、结果集等
import com.utils.JDBCUtils;
// 导入 javax.servlet 包下的 ServletException 类，用于处理 Servlet 操作过程中可能出现的异常
import javax.servlet.ServletException;
// 导入 javax.servlet.annotation 包下的 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径
import javax.servlet.annotation.WebServlet;
// 导入 javax.servlet.http 包下的 HttpServlet 类，这是所有 HTTP Servlet 的基类，该类继承自它以处理 HTTP 请求
import javax.servlet.http.HttpServlet;
// 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息
import javax.servlet.http.HttpServletRequest;
// 导入 javax.servlet.http 包下的 HttpServletResponse 类，用于封装服务器发送给客户端的 HTTP 响应信息
import javax.servlet.http.HttpServletResponse;
// 导入 javax.servlet.http 包下的 HttpSession 类，用于管理用户会话，存储用户的会话信息
import javax.servlet.http.HttpSession;
// 导入 java.io 包下的 IOException 类，用于处理输入输出操作中可能出现的异常
import java.io.IOException;
// 导入 java.sql 包下的 ResultSet 类，用于存储数据库查询操作返回的结果集
import java.sql.ResultSet;
// 导入 java.util 包下的 ArrayList 类，这是一个动态数组，用于存储 TeaPunch 对象
import java.util.ArrayList;
// 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /TeaQueryPunchByPageServlet
@WebServlet("/TeaQueryPunchByPageServlet")
// 定义一个名为 TeaQueryPunchByPageServlet 的类，继承自 HttpServlet，用于处理教师分页查询打卡信息的请求
public class TeaQueryPunchByPageServlet extends HttpServlet {
// 重写 doGet 方法，用于处理 HTTP GET 请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求对象的字符编码为 UTF-8，确保能正确处理中文字符等
req.setCharacterEncoding("utf-8");
// 设置响应对象的字符编码为 UTF-8，确保返回给客户端的内容能正确显示中文字符等
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为 text/html，字符编码为 UTF-8，告知客户端返回的是 HTML 内容且使用 UTF-8 编码
resp.setContentType("text/html;charset=utf-8");
//获取查找的参数
// 从请求对象中获取名为 tpunchdate 的参数，该参数用于作为查询教师打卡日期的条件
String tpunchdate = req.getParameter("tpunchdate");
if (tpunchdate == null){
// 如果获取到的 tpunchdate 为 null，则将其赋值为空字符串
if (tpunchdate == null) {
tpunchdate = "";
}
// 在 tpunchdate 前后添加 % 通配符，用于模糊查询
String tpunchdate1 = "%" + tpunchdate + "%";
// 在控制台打印处理后的 tpunchdate1
System.out.println(tpunchdate1);
// 将 tpunchdate 参数添加到请求对象的属性中，以便后续页面使用
req.setAttribute("tpunchdate", tpunchdate);
//获取登录时的session会话对象
// 从请求对象中获取当前的会话对象
HttpSession session = req.getSession();
// 从会话对象中获取名为 userName 的属性值，并将其转换为 String 类型
String userName = (String) session.getAttribute("userName");
// 从会话对象中获取名为 tno 的属性值，并将其转换为 String 类型，tno 代表教师编号
String tno = (String) session.getAttribute("tno");
// 声明一个 String 类型的变量 sql，用于存储 SQL 查询语句
String sql = null;
// 在控制台打印用户名
System.out.println(userName);
// 在控制台打印教师编号
System.out.println(tno);
// 在控制台打印一段调试信息
System.out.println("hdghghjg");
String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码
String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数
// 从请求对象中获取名为 currentPage 的参数，该参数表示当前页码
String currentPage = req.getParameter("currentPage");
// 从请求对象中获取名为 rows 的参数，该参数表示每页显示的记录数
String rows = req.getParameter("rows");
//如果未设请求参数，此处自动设置参数为第一页
if (currentPage == null || "".equals(currentPage)){
// 如果当前页码参数为空或者为空字符串，则将当前页码设置为 1
if (currentPage == null || "".equals(currentPage)) {
currentPage = "1";
}
//如果没有设置rows的请求参数，此处自动设置
if (rows == null || "".equals(rows)){
// 如果每页显示记录数参数为空或者为空字符串，则将每页显示记录数设置为 8
if (rows == null || "".equals(rows)) {
rows = "8";
}
//获取条件查询的参数
// 将当前页码的字符串类型转换为整数类型
int currentPage1 = Integer.parseInt(currentPage);
// 将每页显示记录数的字符串类型转换为整数类型
int rows1 = Integer.parseInt(rows);
//如果当前页数小于1，则设置当前页数为1
if (currentPage1 <= 0){
// 如果当前页码小于等于 0，则将当前页码设置为 1
if (currentPage1 <= 0) {
currentPage1 = 1;
}
//设置StuPunch类的对象类型
// 创建一个 PageBean 类型的对象，泛型为 StuPunch（此处类型可能有误，应是 TeaPunch），用于封装分页信息和教师打卡信息
PageBean<StuPunch> pageBean = new PageBean<StuPunch>();
//设置当前页码
// 设置 PageBean 对象的当前页码属性
pageBean.setCurrentPage(currentPage1);
//设置每页的记录数
// 设置 PageBean 对象的每页记录数属性
pageBean.setRows(rows1);
// 定义一个 SQL 查询语句，用于查询满足条件的记录总数
sql = " select count(*) as num from teacher t,teapunchin tp where t.tno = tp.tno and tp.tpunchdate like ? and t.tno = ?";
// 定义一个 Object 类型的数组，用于存储 SQL 查询语句中的参数值
Object[] objects = {tpunchdate1, tno};
//计算总记录数，并设置
// 调用 TeaDao 类的 findTotalCount 方法，根据 SQL 语句和参数计算满足条件的总记录数
int totalCount = TeaDao.findTotalCount(sql, objects);
// 在控制台打印总记录数
System.out.println(totalCount);
// 设置 PageBean 对象的总记录数属性
pageBean.setTotalCount(totalCount);
if (totalCount > 0){
//计算总页码，并设置
int totalPage = (totalCount % rows1) == 0 ? totalCount/rows1 : (totalCount/rows1 + 1);
// 如果总记录数大于 0，说明有符合条件的记录
if (totalCount > 0) {
// 计算总页数，如果总记录数能被每页记录数整除，则总页数为总记录数除以每页记录数，否则总页数为总记录数除以每页记录数再加 1
int totalPage = (totalCount % rows1) == 0 ? totalCount / rows1 : (totalCount / rows1 + 1);
// 设置 PageBean 对象的总页数属性
pageBean.setTotalPage(totalPage);
//如果当前页数大于总页数
if (currentPage1 > pageBean.getTotalPage()){
// 如果当前页码大于总页数，则将当前页码设置为总页数
if (currentPage1 > pageBean.getTotalPage()) {
currentPage1 = pageBean.getTotalPage();
//重新设置当前页码
// 重新设置 PageBean 对象的当前页码属性
pageBean.setCurrentPage(currentPage1);
}
//计算开始的记录和list对象集合，并设置
// 计算当前页开始的记录索引
int start = (currentPage1 - 1) * rows1;
// 定义一个 SQL 查询语句，用于查询当前页的教师打卡信息
sql = "select t.tname,tp.* from teacher t,teapunchin tp where t.tno = tp.tno and tp.tpunchdate like ? and tp.tno = ? limit ?, ?";
// 定义一个 Object 类型的数组，用于存储 SQL 查询语句中的参数值
Object[] objects1 = {tpunchdate1, tno, start, rows1};
// 调用 TeaDao 类的 QureyInfoByPage 方法，根据 SQL 语句和参数查询当前页的教师打卡信息，并将结果存储在 ResultSet 对象中
ResultSet resultSet = TeaDao.QureyInfoByPage(sql, objects1);
// 创建一个 ArrayList 对象，用于存储查询到的教师打卡信息
ArrayList teaPunchArrayList = new ArrayList();
try {
while (resultSet.next()){
// 遍历结果集，判断是否还有下一条记录
while (resultSet.next()) {
// 创建一个新的 TeaPunch 对象
TeaPunch teaPunch = new TeaPunch();
// 从结果集中获取教师姓名，并设置到 TeaPunch 对象中
teaPunch.setTname(resultSet.getString("tname"));
// 从结果集中获取是否打卡的信息，并设置到 TeaPunch 对象中
teaPunch.setTispunch(resultSet.getString("tispunch"));
// 从结果集中获取打卡日期，并设置到 TeaPunch 对象中
teaPunch.setTpunchdate(resultSet.getDate("tpunchdate"));
// 从结果集中获取打卡时间，并设置到 TeaPunch 对象中
teaPunch.setTpunchtime(resultSet.getString("tpunchtime"));
// 从结果集中获取是否发热的信息，并设置到 TeaPunch 对象中
teaPunch.setTishot(resultSet.getString("tishot"));
// 从结果集中获取是否咳嗽的信息，并设置到 TeaPunch 对象中
teaPunch.setTiscough(resultSet.getString("tiscough"));
// 从结果集中获取是否有症状的信息，并设置到 TeaPunch 对象中
teaPunch.setTisseem(resultSet.getString("tisseem"));
// 从结果集中获取是否确诊的信息，并设置到 TeaPunch 对象中
teaPunch.setTisdiagnose(resultSet.getString("tisdiagnose"));
// 从结果集中获取打卡状态的信息，并设置到 TeaPunch 对象中
teaPunch.setTstatus(resultSet.getString("tstatus"));
// 将填充好信息的 TeaPunch 对象添加到 ArrayList 中
teaPunchArrayList.add(teaPunch);
}
} catch (Exception e) {
// 若在遍历结果集过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}finally {
} finally {
// 无论是否出现异常，最后都调用 JDBCUtils 类的 close 方法关闭结果集
JDBCUtils.close(resultSet);
}
// 将存储教师打卡信息的 ArrayList 设置到 PageBean 对象中
pageBean.setArrayList(teaPunchArrayList);
// 在控制台打印存储教师打卡信息的 ArrayList
System.out.println(teaPunchArrayList);
// 在控制台打印 PageBean 对象
System.out.println(pageBean);
// 将 PageBean 对象作为属性添加到请求对象中，以便在后续的 JSP 页面中使用
req.setAttribute("pageBean", pageBean);
// 调用请求对象的 getRequestDispatcher 方法获取请求转发器，将请求转发到 /view/tea/teapunchinfo.jsp 页面
req.getRequestDispatcher("/view/tea/teapunchinfo.jsp").forward(req, resp);
}else {
} else {
// 如果总记录数为 0，说明没有符合条件的记录，将请求转发到 /view/alluse/nodata.jsp 页面
req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp);
}
}
// 重写 doPost 方法，用于处理 HTTP POST 请求，这里直接调用 doGet 方法，即 POST 请求的处理逻辑与 GET 请求相同
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

65
src/com/dao/DeptAdminDao.java
Unescape View File

@ -1,101 +1,148 @@
package com.dao;
// 声明该类所属的包为 com.dao，包用于组织和管理 Java 类
import com.utils.JDBCUtils;
// 导入 com.utils 包下的 JDBCUtils 类，这个类可能包含了一些与 JDBC 操作相关的工具方法，
// 例如获取数据库连接、关闭连接等
import java.sql.Connection;
// 导入 java.sql 包下的 Connection 类，用于表示与数据库的连接
import java.sql.PreparedStatement;
// 导入 java.sql 包下的 PreparedStatement 类，用于执行预编译的 SQL 语句，提高性能和安全性
import java.sql.ResultSet;
// 导入 java.sql 包下的 ResultSet 类，用于处理数据库查询返回的结果集
public class DeptAdminDao {
// 定义一个静态的 Connection 类型变量，用于存储数据库连接对象，初始化为 null
private static Connection connection = null;
// 定义一个静态的 PreparedStatement 类型变量，用于存储预编译的 SQL 语句对象，初始化为 null
private static PreparedStatement preparedStatement = null;
// 定义一个静态的 ResultSet 类型变量，用于存储数据库查询的结果集对象，初始化为 null
private static ResultSet resultSet = null;
//用于登录查找
// 用于登录查找的方法，接收 SQL 语句和一个包含查询参数的对象数组作为参数，返回查询结果集
public static ResultSet login(String sql, Object[] objects) {
try {
// 通过 JDBCUtils 类的 getConnection 方法获取数据库连接，并将其赋值给 connection 变量
connection = JDBCUtils.getConnection();
// 使用获取到的数据库连接创建一个 PreparedStatement 对象，预编译传入的 SQL 语句
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将每个参数设置到 PreparedStatement 对象的相应位置（索引从 1 开始）
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行预编译的 SQL 查询语句，并将查询结果存储在 resultSet 变量中
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 如果在上述操作中发生异常，打印异常的堆栈跟踪信息，方便调试
e.printStackTrace();
}
// 返回查询结果集
return resultSet;
}
//用于查询的所有表(带限制条件或无限制条件的)的数据，返回结果集
// 用于查询所有表（带限制条件或无限制条件）的数据的方法，接收 SQL 语句和参数数组，返回结果集
public static ResultSet qureyInfo(String sql, Object[] objects){
try {
// 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译的 SQL 语句对象
preparedStatement = connection.prepareStatement(sql);
// 设置查询参数
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行查询并获取结果集
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 捕获并打印异常信息
e.printStackTrace();
}
// 返回查询结果集
return resultSet;
}
//查询总记录数，返回总记录数
// 查询总记录数的方法，接收 SQL 语句和参数数组，返回查询到的总记录数
public static int findTotalCount(String sql, Object[] objects){
// 定义一个整型变量 num 用于存储总记录数，初始值为 0
int num = 0;
try {
// 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译的 SQL 语句对象
preparedStatement = connection.prepareStatement(sql);
// 设置查询参数
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行查询并获取结果集
resultSet = preparedStatement.executeQuery();
// 将结果集的指针移动到第一行（因为查询的是总记录数，一般只有一行结果）
resultSet.next();
// 从结果集中获取名为 "num" 的列的值，并赋值给 num 变量
num = resultSet.getInt("num");
// 打印总记录数（可能用于调试或查看中间结果）
System.out.println(num);
} catch (Exception e) {
// 捕获并打印异常信息
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭结果集、预编译语句对象和数据库连接，释放资源
JDBCUtils.close(resultSet, preparedStatement, connection);
}
// 返回总记录数
return num;
}
//查询每页的内容
// 查询每页内容的方法，接收 SQL 语句和参数数组，返回查询结果集
public static ResultSet QureyInfoByPage(String sql, Object[] objects){
try {
// 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译的 SQL 语句对象
preparedStatement = connection.prepareStatement(sql);
// 设置查询参数
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行查询并获取结果集
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 捕获并打印异常信息
e.printStackTrace();
}
// 返回查询结果集
return resultSet;
}
//执行更新语句，包括增、删、改操作
// 执行更新语句（包括增、删、改操作）的方法，接收 SQL 语句和参数数组，返回受影响的行数
public static int executeUpdate(String sql, Object[] objects){
// 定义一个整型变量 num 用于存储受影响的行数，初始值为 0
int num = 0;
try {
// 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译的 SQL 语句对象
preparedStatement = connection.prepareStatement(sql);
// 设置查询参数
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行更新操作，并将受影响的行数赋值给 num 变量
num = preparedStatement.executeUpdate();
} catch (Exception e) {
// 捕获并打印异常信息
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭预编译语句对象和数据库连接，释放资源
JDBCUtils.close(preparedStatement, connection);
}
// 返回受影响的行数
return num;
}
}
}

68
src/com/dao/FrontWebDao.java
Unescape View File

@ -1,102 +1,148 @@
package com.dao;
// 声明该类所属的包为 com.dao，包用于组织和管理 Java 类
import com.utils.JDBCUtils;
// 导入 com.utils 包下的 JDBCUtils 类，这个类可能包含了一些与 JDBC 操作相关的工具方法，
// 例如获取数据库连接、关闭连接等
import javax.servlet.annotation.WebServlet;
import java.sql.Connection;
// 导入 java.sql 包下的 Connection 类，用于表示与数据库的连接
import java.sql.PreparedStatement;
import java.sql.ResultSet;
// 导入 java.sql 包下的 PreparedStatement 类，用于执行预编译的 SQL 语句，提高性能和安全性
public class FrontWebDao {
import java.sql.ResultSet;
// 导入 java.sql 包下的 ResultSet 类，用于处理数据库查询返回的结果集
public class DeptAdminDao {
// 定义一个静态的 Connection 类型变量，用于存储数据库连接对象，初始化为 null
private static Connection connection = null;
// 定义一个静态的 PreparedStatement 类型变量，用于存储预编译的 SQL 语句对象，初始化为 null
private static PreparedStatement preparedStatement = null;
// 定义一个静态的 ResultSet 类型变量，用于存储数据库查询的结果集对象，初始化为 null
private static ResultSet resultSet = null;
//用于登录查找
// 用于登录查找的方法，接收 SQL 语句和一个包含查询参数的对象数组作为参数，返回查询结果集
public static ResultSet login(String sql, Object[] objects) {
try {
// 通过 JDBCUtils 类的 getConnection 方法获取数据库连接，并将其赋值给 connection 变量
connection = JDBCUtils.getConnection();
// 使用获取到的数据库连接创建一个 PreparedStatement 对象，预编译传入的 SQL 语句
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将每个参数设置到 PreparedStatement 对象的相应位置（索引从 1 开始）
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行预编译的 SQL 查询语句，并将查询结果存储在 resultSet 变量中
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 如果在上述操作中发生异常，打印异常的堆栈跟踪信息，方便调试
e.printStackTrace();
}
// 返回查询结果集
return resultSet;
}
//用于查询的所有表(带限制条件或无限制条件的)的数据，返回结果集
// 用于查询所有表（带限制条件或无限制条件）的数据的方法，接收 SQL 语句和参数数组，返回结果集
public static ResultSet qureyInfo(String sql, Object[] objects){
try {
// 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译的 SQL 语句对象
preparedStatement = connection.prepareStatement(sql);
// 设置查询参数
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行查询并获取结果集
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 捕获并打印异常信息
e.printStackTrace();
}
// 返回查询结果集
return resultSet;
}
//查询总记录数，返回总记录数
// 查询总记录数的方法，接收 SQL 语句和参数数组，返回查询到的总记录数
public static int findTotalCount(String sql, Object[] objects){
// 定义一个整型变量 num 用于存储总记录数，初始值为 0
int num = 0;
try {
// 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译的 SQL 语句对象
preparedStatement = connection.prepareStatement(sql);
// 设置查询参数
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行查询并获取结果集
resultSet = preparedStatement.executeQuery();
// 将结果集的指针移动到第一行（因为查询的是总记录数，一般只有一行结果）
resultSet.next();
// 从结果集中获取名为 "num" 的列的值，并赋值给 num 变量
num = resultSet.getInt("num");
// 打印总记录数（可能用于调试或查看中间结果）
System.out.println(num);
} catch (Exception e) {
// 捕获并打印异常信息
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭结果集、预编译语句对象和数据库连接，释放资源
JDBCUtils.close(resultSet, preparedStatement, connection);
}
// 返回总记录数
return num;
}
//查询每页的内容
// 查询每页内容的方法，接收 SQL 语句和参数数组，返回查询结果集
public static ResultSet QureyInfoByPage(String sql, Object[] objects){
try {
// 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译的 SQL 语句对象
preparedStatement = connection.prepareStatement(sql);
// 设置查询参数
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行查询并获取结果集
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 捕获并打印异常信息
e.printStackTrace();
}
// 返回查询结果集
return resultSet;
}
//执行更新语句，包括增、删、改操作
// 执行更新语句（包括增、删、改操作）的方法，接收 SQL 语句和参数数组，返回受影响的行数
public static int executeUpdate(String sql, Object[] objects){
// 定义一个整型变量 num 用于存储受影响的行数，初始值为 0
int num = 0;
try {
// 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译的 SQL 语句对象
preparedStatement = connection.prepareStatement(sql);
// 设置查询参数
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行更新操作，并将受影响的行数赋值给 num 变量
num = preparedStatement.executeUpdate();
} catch (Exception e) {
// 捕获并打印异常信息
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭预编译语句对象和数据库连接，释放资源
JDBCUtils.close(preparedStatement, connection);
}
// 返回受影响的行数
return num;
}
}
}

92
src/com/dao/SchoAdminDao.java
Unescape View File

@ -1,101 +1,177 @@
// 声明该类所在的包名为 com.dao
package com.dao;
// 导入自定义的 JDBC 工具类，该类应该包含了获取数据库连接、关闭资源等操作的方法
import com.utils.JDBCUtils;
// 导入 java.sql 包下的 Connection 类，用于表示与数据库的连接
import java.sql.Connection;
// 导入 java.sql 包下的 PreparedStatement 类，用于执行预编译的 SQL 语句
import java.sql.PreparedStatement;
// 导入 java.sql 包下的 ResultSet 类，用于存储 SQL 查询的结果集
import java.sql.ResultSet;
// 定义一个名为 SchoAdminDao 的公共类，用于封装与数据库交互的操作
public class SchoAdminDao {
// 声明一个静态的 Connection 类型变量，用于存储数据库连接对象，初始化为 null
private static Connection connection = null;
// 声明一个静态的 PreparedStatement 类型变量，用于执行预编译的 SQL 语句，初始化为 null
private static PreparedStatement preparedStatement = null;
// 声明一个静态的 ResultSet 类型变量，用于存储 SQL 查询的结果集，初始化为 null
private static ResultSet resultSet = null;
//用于登录查找
/**
* 用于登录查找的方法
* @param sql 要执行的 SQL 查询语句
* @param objects SQL 查询语句中的参数数组
* @return 包含查询结果的 ResultSet 对象
*/
public static ResultSet login(String sql, Object[] objects) {
try {
// 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
connection = JDBCUtils.getConnection();
// 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
for (int i = 0; i < objects.length; i++) {
// 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 若发生异常，打印异常堆栈信息
e.printStackTrace();
}
// 返回包含查询结果的 ResultSet 对象
return resultSet;
}
//用于查询的所有表(带限制条件或无限制条件的)的数据，返回结果集
/**
* 用于查询所有表（带限制条件或无限制条件）的数据，返回结果集
* @param sql 要执行的 SQL 查询语句
* @param objects SQL 查询语句中的参数数组
* @return 包含查询结果的 ResultSet 对象
*/
public static ResultSet qureyInfo(String sql, Object[] objects){
try {
// 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
connection = JDBCUtils.getConnection();
// 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
for (int i = 0; i < objects.length; i++) {
// 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 若发生异常，打印异常堆栈信息
e.printStackTrace();
}
// 返回包含查询结果的 ResultSet 对象
return resultSet;
}
//查询总记录数，返回总记录数
/**
* 查询总记录数，返回总记录数
* @param sql 要执行的 SQL 查询语句
* @param objects SQL 查询语句中的参数数组
* @return 总记录数
*/
public static int findTotalCount(String sql, Object[] objects){
// 声明一个整型变量 num，用于存储总记录数，初始值为 0
int num = 0;
try {
// 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
connection = JDBCUtils.getConnection();
// 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
for (int i = 0; i < objects.length; i++) {
// 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
resultSet = preparedStatement.executeQuery();
// 将 ResultSet 的指针移动到下一行（通常查询总记录数的结果只有一行）
resultSet.next();
// 从 ResultSet 中获取名为 "num" 的列的值，并赋值给 num 变量
num = resultSet.getInt("num");
// 打印总记录数
System.out.println(num);
} catch (Exception e) {
// 若发生异常，打印异常堆栈信息
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 ResultSet、PreparedStatement 和 Connection 对象
JDBCUtils.close(resultSet, preparedStatement, connection);
}
// 返回总记录数
return num;
}
//查询每页的内容
/**
* 查询每页的内容
* @param sql 要执行的 SQL 查询语句
* @param objects SQL 查询语句中的参数数组
* @return 包含查询结果的 ResultSet 对象
*/
public static ResultSet QureyInfoByPage(String sql, Object[] objects){
try {
// 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
connection = JDBCUtils.getConnection();
// 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
for (int i = 0; i < objects.length; i++) {
// 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 若发生异常，打印异常堆栈信息
e.printStackTrace();
}
// 返回包含查询结果的 ResultSet 对象
return resultSet;
}
//执行更新语句，包括增、删、改操作
/**
* 执行更新语句，包括增、删、改操作
* @param sql 要执行的 SQL 更新语句
* @param objects SQL 更新语句中的参数数组
* @return 受影响的行数
*/
public static int executeUpdate(String sql, Object[] objects){
// 声明一个整型变量 num，用于存储受影响的行数，初始值为 0
int num = 0;
try {
// 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
connection = JDBCUtils.getConnection();
// 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
for (int i = 0; i < objects.length; i++) {
// 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行 SQL 更新语句，并将受影响的行数赋值给 num 变量
num = preparedStatement.executeUpdate();
} catch (Exception e) {
// 若发生异常，打印异常堆栈信息
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 PreparedStatement 和 Connection 对象
JDBCUtils.close(preparedStatement, connection);
}
// 返回受影响的行数
return num;
}
}
}

92
src/com/dao/StuDao.java
Unescape View File

@ -1,101 +1,177 @@
// 声明该类所属的包为 com.dao，包用于组织和管理 Java 类，避免命名冲突
package com.dao;
// 导入自定义的 JDBC 工具类，该工具类应该封装了获取数据库连接、关闭连接等操作
import com.utils.JDBCUtils;
// 导入 java.sql 包中的 Connection 类，用于表示与数据库的连接
import java.sql.Connection;
// 导入 java.sql 包中的 PreparedStatement 类，用于执行预编译的 SQL 语句，可防止 SQL 注入
import java.sql.PreparedStatement;
// 导入 java.sql 包中的 ResultSet 类，用于存储 SQL 查询操作返回的结果集
import java.sql.ResultSet;
// 定义一个公共类 StuDao，该类可能用于处理与学生相关的数据库操作
public class StuDao {
// 声明一个静态的 Connection 类型变量，用于存储数据库连接对象，初始值为 null
private static Connection connection = null;
// 声明一个静态的 PreparedStatement 类型变量，用于执行预编译的 SQL 语句，初始值为 null
private static PreparedStatement preparedStatement = null;
// 声明一个静态的 ResultSet 类型变量，用于存储 SQL 查询结果集，初始值为 null
private static ResultSet resultSet = null;
//用于登录查找
/**
* 用于登录查找的方法
* @param sql 要执行的 SQL 查询语句，通常用于验证用户登录信息
* @param objects SQL 查询语句中的参数数组，用于填充 SQL 语句中的占位符
* @return 包含查询结果的 ResultSet 对象
*/
public static ResultSet login(String sql, Object[] objects) {
try {
// 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
connection = JDBCUtils.getConnection();
// 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
for (int i = 0; i < objects.length; i++) {
// 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 若发生异常，打印异常堆栈信息，方便调试
e.printStackTrace();
}
// 返回包含查询结果的 ResultSet 对象
return resultSet;
}
//用于查询的所有表(带限制条件或无限制条件的)的数据，返回结果集
/**
* 用于查询所有表（带限制条件或无限制条件）的数据，返回结果集
* @param sql 要执行的 SQL 查询语句
* @param objects SQL 查询语句中的参数数组
* @return 包含查询结果的 ResultSet 对象
*/
public static ResultSet qureyInfo(String sql, Object[] objects){
try {
// 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
connection = JDBCUtils.getConnection();
// 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
for (int i = 0; i < objects.length; i++) {
// 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 若发生异常，打印异常堆栈信息，方便调试
e.printStackTrace();
}
// 返回包含查询结果的 ResultSet 对象
return resultSet;
}
//查询总记录数，返回总记录数
/**
* 查询总记录数，返回总记录数
* @param sql 要执行的 SQL 查询语句，通常用于统计记录数量
* @param objects SQL 查询语句中的参数数组
* @return 总记录数
*/
public static int findTotalCount(String sql, Object[] objects){
// 声明一个整型变量 num，用于存储总记录数，初始值为 0
int num = 0;
try {
// 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
connection = JDBCUtils.getConnection();
// 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
for (int i = 0; i < objects.length; i++) {
// 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
resultSet = preparedStatement.executeQuery();
// 将 ResultSet 的指针移动到下一行（通常查询总记录数的结果只有一行）
resultSet.next();
// 从 ResultSet 中获取名为 "num" 的列的值，并赋值给 num 变量
num = resultSet.getInt("num");
// 打印总记录数，方便调试
System.out.println(num);
} catch (Exception e) {
// 若发生异常，打印异常堆栈信息，方便调试
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 ResultSet、PreparedStatement 和 Connection 对象
JDBCUtils.close(resultSet, preparedStatement, connection);
}
// 返回总记录数
return num;
}
//查询每页的内容
/**
* 查询每页的内容
* @param sql 要执行的 SQL 查询语句，通常用于分页查询
* @param objects SQL 查询语句中的参数数组
* @return 包含查询结果的 ResultSet 对象
*/
public static ResultSet QureyInfoByPage(String sql, Object[] objects){
try {
// 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
connection = JDBCUtils.getConnection();
// 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
for (int i = 0; i < objects.length; i++) {
// 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 若发生异常，打印异常堆栈信息，方便调试
e.printStackTrace();
}
// 返回包含查询结果的 ResultSet 对象
return resultSet;
}
//执行更新语句，包括增、删、改操作
/**
* 执行更新语句，包括增、删、改操作
* @param sql 要执行的 SQL 更新语句
* @param objects SQL 更新语句中的参数数组
* @return 受影响的行数
*/
public static int executeUpdate(String sql, Object[] objects){
// 声明一个整型变量 num，用于存储受影响的行数，初始值为 0
int num = 0;
try {
// 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
connection = JDBCUtils.getConnection();
// 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 更新语句
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
for (int i = 0; i < objects.length; i++) {
// 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行 SQL 更新语句，并将受影响的行数赋值给 num 变量
num = preparedStatement.executeUpdate();
} catch (Exception e) {
// 若发生异常，打印异常堆栈信息，方便调试
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 PreparedStatement 和 Connection 对象
JDBCUtils.close(preparedStatement, connection);
}
// 返回受影响的行数
return num;
}
}
}

70
src/com/dao/TeaDao.java
Unescape View File

@ -1,101 +1,155 @@
// 声明该类所在的包为 com.dao
package com.dao;
// 导入 JDBCUtils 工具类，该类用于管理 JDBC 连接等操作
import com.utils.JDBCUtils;
// 导入 Java 数据库连接相关的类，用于操作数据库
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
// 定义 TeaDao 类，该类可能用于对教师相关数据进行数据库操作
public class TeaDao {
// 声明静态的数据库连接对象，用于保持与数据库的连接
private static Connection connection = null;
// 声明静态的预编译语句对象，用于执行 SQL 语句
private static PreparedStatement preparedStatement = null;
// 声明静态的结果集对象，用于存储数据库查询结果
private static ResultSet resultSet = null;
//用于登录查找
// 定义 login 方法，用于执行登录相关的数据库查询操作，返回结果集
// sql 参数表示要执行的 SQL 查询语句
// objects 参数是一个包含查询参数的数组
public static ResultSet login(String sql, Object[] objects) {
try {
// 通过 JDBCUtils 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译语句对象，将 SQL 语句传入
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到预编译语句中
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行查询操作，并将结果存储到结果集对象中
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 如果在执行过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}
// 返回查询结果集
return resultSet;
}
//用于查询的所有表(带限制条件或无限制条件的)的数据，返回结果集
// 定义 qureyInfo 方法，用于执行带条件或不带条件的数据库查询操作，返回结果集
// sql 参数表示要执行的 SQL 查询语句
// objects 参数是一个包含查询参数的数组
public static ResultSet qureyInfo(String sql, Object[] objects){
try {
// 通过 JDBCUtils 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译语句对象，将 SQL 语句传入
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到预编译语句中
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行查询操作，并将结果存储到结果集对象中
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 如果在执行过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}
// 返回查询结果集
return resultSet;
}
//查询总记录数，返回总记录数
// 定义 findTotalCount 方法，用于查询符合条件的总记录数，返回总记录数
// sql 参数表示要执行的 SQL 查询语句，用于统计记录数
// objects 参数是一个包含查询参数的数组
public static int findTotalCount(String sql, Object[] objects){
// 初始化记录数变量为 0
int num = 0;
try {
// 通过 JDBCUtils 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译语句对象，将 SQL 语句传入
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到预编译语句中
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行查询操作，并将结果存储到结果集对象中
resultSet = preparedStatement.executeQuery();
// 将结果集指针移动到第一行（因为结果集中只有一行记录，即统计的总记录数）
resultSet.next();
// 从结果集中获取名为 "num" 的列的值，即总记录数
num = resultSet.getInt("num");
// 打印总记录数到控制台，用于调试
System.out.println(num);
} catch (Exception e) {
// 如果在执行过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}finally {
} finally {
// 调用 JDBCUtils 的方法关闭结果集、预编译语句和数据库连接，释放资源
JDBCUtils.close(resultSet, preparedStatement, connection);
}
// 返回总记录数
return num;
}
//查询每页的内容
// 定义 QureyInfoByPage 方法，用于查询每页的内容，返回结果集
// sql 参数表示要执行的 SQL 查询语句，用于获取指定页的数据
// objects 参数是一个包含查询参数的数组
public static ResultSet QureyInfoByPage(String sql, Object[] objects){
try {
// 通过 JDBCUtils 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译语句对象，将 SQL 语句传入
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到预编译语句中
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行查询操作，并将结果存储到结果集对象中
resultSet = preparedStatement.executeQuery();
} catch (Exception e) {
// 如果在执行过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}
// 返回查询结果集
return resultSet;
}
//执行更新语句，包括增、删、改操作
// 定义 executeUpdate 方法，用于执行数据库的增、删、改操作，返回受影响的行数
// sql 参数表示要执行的 SQL 语句，如插入、删除、更新语句
// objects 参数是一个包含操作参数的数组
public static int executeUpdate(String sql, Object[] objects){
// 初始化受影响的行数变量为 0
int num = 0;
try {
// 通过 JDBCUtils 获取数据库连接
connection = JDBCUtils.getConnection();
// 创建预编译语句对象，将 SQL 语句传入
preparedStatement = connection.prepareStatement(sql);
// 遍历参数数组，将参数依次设置到预编译语句中
for (int i = 0; i < objects.length; i++) {
preparedStatement.setObject(i + 1, objects[i]);
}
// 执行更新操作，并返回受影响的行数
num = preparedStatement.executeUpdate();
} catch (Exception e) {
// 如果在执行过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}finally {
} finally {
// 调用 JDBCUtils 的方法关闭预编译语句和数据库连接，释放资源
JDBCUtils.close(preparedStatement, connection);
}
// 返回受影响的行数
return num;
}
}
}

22
src/com/entity/News.java
Unescape View File

@ -1,43 +1,61 @@
package com.entity;
// 声明该类所属的包为 com.entity，包用于对类进行组织和管理，方便代码的维护和复用
import java.util.Date;
// 导入 java.util 包下的 Date 类，用于表示日期和时间
public class News {
// 定义一个私有字符串类型的变量 title，用于存储新闻的标题
private String title;
// 定义一个私有字符串类型的变量 url，用于存储新闻的链接地址
private String url;
// 定义一个私有 Date 类型的变量 pubdate，用于存储新闻的发布日期
private Date pubdate;
// 这是一个设置新闻标题的方法，接收一个字符串类型的参数 title
public void setTitle(String title) {
// 将传入的参数值赋给当前类的成员变量 title
this.title = title;
}
// 这是一个设置新闻链接的方法，接收一个字符串类型的参数 url
public void setUrl(String url) {
// 将传入的参数值赋给当前类的成员变量 url
this.url = url;
}
// 这是一个设置新闻发布日期的方法，接收一个 Date 类型的参数 pubdate
public void setPubdate(Date pubdate) {
// 将传入的参数值赋给当前类的成员变量 pubdate
this.pubdate = pubdate;
}
// 这是一个获取新闻标题的方法，返回值类型为字符串
public String getTitle() {
// 返回当前类的成员变量 title 的值
return title;
}
// 这是一个获取新闻链接的方法，返回值类型为字符串
public String getUrl() {
// 返回当前类的成员变量 url 的值
return url;
}
// 这是一个获取新闻发布日期的方法，返回值类型为 Date
public Date getPubdate() {
// 返回当前类的成员变量 pubdate 的值
return pubdate;
}
// 重写了父类 Object 的 toString 方法，用于将 News 对象以字符串的形式表示
@Override
public String toString() {
// 返回一个包含新闻标题、链接和发布日期的字符串，格式为 "News{title='xxx', url='xxx', pubdate=xxx}"
return "News{" +
"title='" + title + '\'' +
", url='" + url + '\'' +
", pubdate=" + pubdate +
'}';
}
}
}

82
src/com/entity/PageBean.java
Unescape View File

@ -1,63 +1,133 @@
// 声明该类所属的包为 com.entity，包用于组织和管理 Java 类，避免命名冲突
package com.entity;
// 导入 java.util 包中的 ArrayList 类，用于存储每页的数据
import java.util.ArrayList;
/**
* 泛型类 PageBean，用于封装分页信息
* @param <T> 泛型类型，表示每页数据的类型
*/
public class PageBean<T> {
private int totalCount;//总记录数
private int totalPage;//总页码
private ArrayList<T> arrayList;//每页的数据
private int currentPage;//当前页码
private int rows;//每页的记录数
// 定义一个整型变量 totalCount，用于存储总记录数
private int totalCount;
// 定义一个整型变量 totalPage，用于存储总页码数
private int totalPage;
// 定义一个泛型类型的 ArrayList 变量 arrayList，用于存储每页的数据
private ArrayList<T> arrayList;
// 定义一个整型变量 currentPage，用于存储当前页码
private int currentPage;
// 定义一个整型变量 rows，用于存储每页显示的记录数
private int rows;
/**
* 设置总记录数的方法
* @param totalCount 要设置的总记录数
*/
public void setTotalCount(int totalCount) {
// 将传入的总记录数赋值给类的成员变量 totalCount
this.totalCount = totalCount;
}
/**
* 设置总页码数的方法
* @param totalPage 要设置的总页码数
*/
public void setTotalPage(int totalPage) {
// 将传入的总页码数赋值给类的成员变量 totalPage
this.totalPage = totalPage;
}
/**
* 设置每页数据的方法
* @param arrayList 要设置的每页数据的 ArrayList
*/
public void setArrayList(ArrayList<T> arrayList) {
// 将传入的 ArrayList 赋值给类的成员变量 arrayList
this.arrayList = arrayList;
}
/**
* 设置当前页码的方法
* @param currentPage 要设置的当前页码
*/
public void setCurrentPage(int currentPage) {
// 将传入的当前页码赋值给类的成员变量 currentPage
this.currentPage = currentPage;
}
/**
* 设置每页记录数的方法
* @param rows 要设置的每页记录数
*/
public void setRows(int rows) {
// 将传入的每页记录数赋值给类的成员变量 rows
this.rows = rows;
}
/**
* 获取总记录数的方法
* @return 总记录数
*/
public int getTotalCount() {
// 返回类的成员变量 totalCount 的值
return totalCount;
}
/**
* 获取总页码数的方法
* @return 总页码数
*/
public int getTotalPage() {
// 返回类的成员变量 totalPage 的值
return totalPage;
}
/**
* 获取每页数据的方法
* @return 存储每页数据的 ArrayList
*/
public ArrayList<T> getArrayList() {
// 返回类的成员变量 arrayList 的值
return arrayList;
}
/**
* 获取当前页码的方法
* @return 当前页码
*/
public int getCurrentPage() {
// 返回类的成员变量 currentPage 的值
return currentPage;
}
/**
* 获取每页记录数的方法
* @return 每页记录数
*/
public int getRows() {
// 返回类的成员变量 rows 的值
return rows;
}
/**
* 重写 toString 方法，用于将对象的信息以字符串形式输出
* @return 包含对象属性信息的字符串
*/
@Override
public String toString() {
return "PageBean1{" +
// 拼接总记录数
"totalCount=" + totalCount +
// 拼接总页码数
", totalPage=" + totalPage +
// 拼接每页数据的 ArrayList
", arrayList=" + arrayList +
// 拼接当前页码
", currentPage=" + currentPage +
// 拼接每页记录数
", rows=" + rows +
'}';
}
}
}

169
src/com/entity/StuPunch.java
Unescape View File

@ -1,145 +1,312 @@
// 声明该类所属的包为 com.entity，包用于组织和管理 Java 类，避免命名冲突
package com.entity;
// 导入 java.sql 包中的 Date 类，用于表示日期
import java.sql.Date;
// 导入 java.sql 包中的 Timestamp 类，用于表示包含日期和时间的时间戳（这里未使用到）
import java.sql.Timestamp;
// 导入 java.text 包中的 SimpleDateFormat 类，用于格式化日期和时间（这里未使用到）
import java.text.SimpleDateFormat;
/**
* 定义一个名为 StuPunch 的类，用于表示学生打卡相关信息的实体类
*/
public class StuPunch {
// 学生学号，字符串类型
private String sno;
// 学生姓名，字符串类型
private String sname;
// 学生所在班级，字符串类型
private String sclass;
// 学生专业，字符串类型
private String specialty;
// 学生所在系部，字符串类型
private String sdept;
// 学生是否打卡的标识，字符串类型（例如 "是" 或 "否" 等）
private String sispunch;
// 学生打卡日期，Date 类型
private Date spunchdate;
// 学生打卡时间，字符串类型
private String spunchtime;
// 学生是否发热的标识，字符串类型（例如 "是" 或 "否" 等）
private String sishot;
// 学生是否咳嗽的标识，字符串类型（例如 "是" 或 "否" 等）
private String siscough;
// 学生的表观症状描述，字符串类型
private String sisseem;
// 学生的诊断结果，字符串类型
private String sisdiagnose;
// 学生的状态，字符串类型
private String sstatus;
/**
* 设置学生学号的方法
* @param sno 要设置的学生学号
*/
public void setSno(String sno) {
// 将传入的学号赋值给类的成员变量 sno
this.sno = sno;
}
/**
* 设置学生姓名的方法
* @param sname 要设置的学生姓名
*/
public void setSname(String sname) {
// 将传入的姓名赋值给类的成员变量 sname
this.sname = sname;
}
/**
* 设置学生所在班级的方法
* @param sclass 要设置的学生所在班级
*/
public void setSclass(String sclass) {
// 将传入的班级赋值给类的成员变量 sclass
this.sclass = sclass;
}
/**
* 设置学生所在系部的方法
* @param sdept 要设置的学生所在系部
*/
public void setSdept(String sdept) {
// 将传入的系部赋值给类的成员变量 sdept
this.sdept = sdept;
}
/**
* 设置学生专业的方法
* @param specialty 要设置的学生专业
*/
public void setSpecialty(String specialty) {
// 将传入的专业赋值给类的成员变量 specialty
this.specialty = specialty;
}
/**
* 设置学生是否打卡标识的方法
* @param sispunch 要设置的学生是否打卡标识
*/
public void setSispunch(String sispunch) {
// 将传入的是否打卡标识赋值给类的成员变量 sispunch
this.sispunch = sispunch;
}
/**
* 设置学生打卡日期的方法
* @param spunchdate 要设置的学生打卡日期
*/
public void setSpunchdate(Date spunchdate) {
// 将传入的打卡日期赋值给类的成员变量 spunchdate
this.spunchdate = spunchdate;
}
/**
* 设置学生打卡时间的方法
* @param spunchtime 要设置的学生打卡时间
*/
public void setSpunchtime(String spunchtime) {
// 将传入的打卡时间赋值给类的成员变量 spunchtime
this.spunchtime = spunchtime;
}
/**
* 设置学生是否发热标识的方法
* @param sishot 要设置的学生是否发热标识
*/
public void setSishot(String sishot) {
// 将传入的是否发热标识赋值给类的成员变量 sishot
this.sishot = sishot;
}
/**
* 设置学生是否咳嗽标识的方法
* @param siscough 要设置的学生是否咳嗽标识
*/
public void setSiscough(String siscough) {
// 将传入的是否咳嗽标识赋值给类的成员变量 siscough
this.siscough = siscough;
}
/**
* 设置学生表观症状描述的方法
* @param sisseem 要设置的学生表观症状描述
*/
public void setSisseem(String sisseem) {
// 将传入的表观症状描述赋值给类的成员变量 sisseem
this.sisseem = sisseem;
}
/**
* 设置学生诊断结果的方法
* @param sisdiagnose 要设置的学生诊断结果
*/
public void setSisdiagnose(String sisdiagnose) {
// 将传入的诊断结果赋值给类的成员变量 sisdiagnose
this.sisdiagnose = sisdiagnose;
}
/**
* 设置学生状态的方法
* @param sstatus 要设置的学生状态
*/
public void setSstatus(String sstatus) {
// 将传入的学生状态赋值给类的成员变量 sstatus
this.sstatus = sstatus;
}
/**
* 获取学生学号的方法
* @return 学生学号
*/
public String getSno() {
// 返回类的成员变量 sno 的值
return sno;
}
/**
* 获取学生姓名的方法
* @return 学生姓名
*/
public String getSname() {
// 返回类的成员变量 sname 的值
return sname;
}
/**
* 获取学生所在班级的方法
* @return 学生所在班级
*/
public String getSclass() {
// 返回类的成员变量 sclass 的值
return sclass;
}
/**
* 获取学生专业的方法
* @return 学生专业
*/
public String getSpecialty() {
// 返回类的成员变量 specialty 的值
return specialty;
}
/**
* 获取学生所在系部的方法
* @return 学生所在系部
*/
public String getSdept() {
// 返回类的成员变量 sdept 的值
return sdept;
}
/**
* 获取学生是否打卡标识的方法
* @return 学生是否打卡标识
*/
public String getSispunch() {
// 返回类的成员变量 sispunch 的值
return sispunch;
}
/**
* 获取学生打卡日期的方法
* @return 学生打卡日期
*/
public Date getSpunchdate() {
// 返回类的成员变量 spunchdate 的值
return spunchdate;
}
/**
* 获取学生打卡时间的方法
* @return 学生打卡时间
*/
public String getSpunchtime() {
// 返回类的成员变量 spunchtime 的值
return spunchtime;
}
/**
* 获取学生是否发热标识的方法
* @return 学生是否发热标识
*/
public String getSishot() {
// 返回类的成员变量 sishot 的值
return sishot;
}
/**
* 获取学生是否咳嗽标识的方法
* @return 学生是否咳嗽标识
*/
public String getSiscough() {
// 返回类的成员变量 siscough 的值
return siscough;
}
/**
* 获取学生表观症状描述的方法
* @return 学生表观症状描述
*/
public String getSisseem() {
// 返回类的成员变量 sisseem 的值
return sisseem;
}
/**
* 获取学生诊断结果的方法
* @return 学生诊断结果
*/
public String getSisdiagnose() {
// 返回类的成员变量 sisdiagnose 的值
return sisdiagnose;
}
/**
* 获取学生状态的方法
* @return 学生状态
*/
public String getSstatus() {
// 返回类的成员变量 sstatus 的值
return sstatus;
}
/**
* 重写 toString 方法，用于将对象的信息以字符串形式输出
* @return 包含对象属性信息的字符串
*/
@Override
public String toString() {
return "StuPunch{" +
// 拼接学生学号
"sno='" + sno + '\'' +
// 拼接学生姓名
", sname='" + sname + '\'' +
// 拼接学生所在班级
", sclass='" + sclass + '\'' +
// 拼接学生专业
", specialty='" + specialty + '\'' +
// 拼接学生所在系部
", sdept='" + sdept + '\'' +
// 拼接学生是否打卡标识
", sispunch='" + sispunch + '\'' +
// 拼接学生打卡日期
", spunchdate=" + spunchdate +
// 拼接学生打卡时间
", spunchtime='" + spunchtime + '\'' +
// 拼接学生是否发热标识
", sishot='" + sishot + '\'' +
// 拼接学生是否咳嗽标识
", siscough='" + siscough + '\'' +
// 拼接学生表观症状描述
", sisseem='" + sisseem + '\'' +
// 拼接学生诊断结果
", sisdiagnose='" + sisdiagnose + '\'' +
// 拼接学生状态
", sstatus='" + sstatus + '\'' +
'}';
}
}
}

51
src/com/entity/Student.java
Unescape View File

@ -1,91 +1,138 @@
package com.entity;
// 声明该类所属的包为 com.entity，包用于对类进行组织和管理，方便在项目中找到和使用相关的类
public class Student {
// 定义一个私有字符串类型的变量 sno，用于存储学生的学号
private String sno;
// 定义一个私有字符串类型的变量 sname，用于存储学生的姓名
private String sname;
// 定义一个私有字符串类型的变量 ssex，用于存储学生的性别
private String ssex;
// 定义一个私有整数类型的变量 sage，用于存储学生的年龄
private int sage;
// 定义一个私有字符串类型的变量 sclass，用于存储学生的班级
private String sclass;
// 定义一个私有字符串类型的变量 specialty，用于存储学生的专业
private String specialty;
// 定义一个私有字符串类型的变量 sdept，用于存储学生的所在系部
private String sdept;
// 定义一个私有字符串类型的变量 sphone，用于存储学生的电话号码
private String sphone;
// 定义一个私有字符串类型的变量 spsw，用于存储学生的密码
private String spsw;
// 这是一个设置学生学号的方法，接收一个字符串类型的参数 sno
public void setSno(String sno) {
// 将传入的参数值赋给当前类的成员变量 sno
this.sno = sno;
}
// 这是一个设置学生姓名的方法，接收一个字符串类型的参数 sname
public void setSname(String sname) {
// 将传入的参数值赋给当前类的成员变量 sname
this.sname = sname;
}
// 这是一个设置学生性别的方法，接收一个字符串类型的参数 ssex
public void setSsex(String ssex) {
// 将传入的参数值赋给当前类的成员变量 ssex
this.ssex = ssex;
}
// 这是一个设置学生年龄的方法，接收一个整数类型的参数 sage
public void setSage(int sage) {
// 将传入的参数值赋给当前类的成员变量 sage
this.sage = sage;
}
// 这是一个设置学生班级的方法，接收一个字符串类型的参数 sclass
public void setSclass(String sclass) {
// 将传入的参数值赋给当前类的成员变量 sclass
this.sclass = sclass;
}
// 这是一个设置学生专业的方法，接收一个字符串类型的参数 specialty
public void setSpecialty(String specialty) {
// 将传入的参数值赋给当前类的成员变量 specialty
this.specialty = specialty;
}
// 这是一个设置学生所在系部的方法，接收一个字符串类型的参数 sdept
public void setSdept(String sdept) {
// 将传入的参数值赋给当前类的成员变量 sdept
this.sdept = sdept;
}
// 这是一个设置学生电话号码的方法，接收一个字符串类型的参数 sphone
public void setSphone(String sphone) {
// 将传入的参数值赋给当前类的成员变量 sphone
this.sphone = sphone;
}
// 这是一个设置学生密码的方法，接收一个字符串类型的参数 spsw
public void setSpsw(String spsw) {
// 将传入的参数值赋给当前类的成员变量 spsw
this.spsw = spsw;
}
// 这是一个获取学生学号的方法，返回值类型为字符串
public String getSno() {
// 返回当前类的成员变量 sno 的值
return sno;
}
// 这是一个获取学生姓名的方法，返回值类型为字符串
public String getSname() {
// 返回当前类的成员变量 sname 的值
return sname;
}
// 这是一个获取学生性别的方法，返回值类型为字符串
public String getSsex() {
// 返回当前类的成员变量 ssex 的值
return ssex;
}
// 这是一个获取学生年龄的方法，返回值类型为整数
public int getSage() {
// 返回当前类的成员变量 sage 的值
return sage;
}
// 这是一个获取学生班级的方法，返回值类型为字符串
public String getSclass() {
// 返回当前类的成员变量 sclass 的值
return sclass;
}
// 这是一个获取学生专业的方法，返回值类型为字符串
public String getSpecialty() {
// 返回当前类的成员变量 specialty 的值
return specialty;
}
// 这是一个获取学生所在系部的方法，返回值类型为字符串
public String getSdept() {
// 返回当前类的成员变量 sdept 的值
return sdept;
}
// 这是一个获取学生电话号码的方法，返回值类型为字符串
public String getSphone() {
// 返回当前类的成员变量 sphone 的值
return sphone;
}
// 这是一个获取学生密码的方法，返回值类型为字符串
public String getSpsw() {
// 返回当前类的成员变量 spsw 的值
return spsw;
}
// 重写了父类 Object 的 toString 方法，用于将 Student 对象以字符串的形式表示
@Override
public String toString() {
// 返回一个包含学生各项信息的字符串，格式为 "Student{sno='xxx', sname='xxx', ssex='xxx', sage=xxx, sclass='xxx', specialty='xxx', sdept='xxx', sphone='xxx', spsw='xxx'}"
return "Student{" +
"sno='" + sno + '\'' +
", sname='" + sname + '\'' +
@ -98,4 +145,4 @@ public class Student {
", spsw='" + spsw + '\'' +
'}';
}
}
}

40
src/com/entity/TeaPunch.java
Unescape View File

@ -1,110 +1,148 @@
// 声明该类所属的包为 com.entity
package com.entity;
// 导入 java.sql.Date 类，用于表示日期（只包含年、月、日）
import java.sql.Date;
// 导入 java.sql.Timestamp 类，用于表示包含日期和时间（精确到纳秒）的数据类型（虽然在当前代码中未使用到该类，但导入了）
import java.sql.Timestamp;
// 定义 TeaPunch 类，该类用于封装教师打卡信息
public class TeaPunch {
// 定义私有属性 tno，表示教师编号
private String tno;
// 定义私有属性 tname，表示教师姓名
private String tname;
// 定义私有属性 tdept，表示教师所在部门
private String tdept;
// 定义私有属性 tispunch，表示教师是否打卡（可能是“是”或“否”等）
private String tispunch;
// 定义私有属性 tpunchdate，表示教师打卡日期
private Date tpunchdate;
// 定义私有属性 tpunchtime，表示教师打卡时间
private String tpunchtime;
// 定义私有属性 tishot，表示教师是否发热（可能是“是”或“否”等）
private String tishot;
// 定义私有属性 tiscough，表示教师是否咳嗽（可能是“是”或“否”等）
private String tiscough;
// 定义私有属性 tisseem，表示教师是否有疑似症状（可能是“是”或“否”等）
private String tisseem;
// 定义私有属性 tisdiagnose，表示教师是否确诊（可能是“是”或“否”等）
private String tisdiagnose;
// 定义私有属性 tstatus，表示教师的状态（可能包含其他相关状态信息）
private String tstatus;
// 定义 tno 属性的 setter 方法，用于设置教师编号
public void setTno(String tno) {
this.tno = tno;
}
// 定义 tname 属性的 setter 方法，用于设置教师姓名
public void setTname(String tname) {
this.tname = tname;
}
// 定义 tdept 属性的 setter 方法，用于设置教师所在部门
public void setTdept(String tdept) {
this.tdept = tdept;
}
// 定义 tispunch 属性的 setter 方法，用于设置教师是否打卡
public void setTispunch(String tispunch) {
this.tispunch = tispunch;
}
// 定义 tpunchdate 属性的 setter 方法，用于设置教师打卡日期
public void setTpunchdate(Date tpunchdate) {
this.tpunchdate = tpunchdate;
}
// 定义 tpunchtime 属性的 setter 方法，用于设置教师打卡时间
public void setTpunchtime(String tpunchtime) {
this.tpunchtime = tpunchtime;
}
// 定义 tishot 属性的 setter 方法，用于设置教师是否发热
public void setTishot(String tishot) {
this.tishot = tishot;
}
// 定义 tiscough 属性的 setter 方法，用于设置教师是否咳嗽
public void setTiscough(String tiscough) {
this.tiscough = tiscough;
}
// 定义 tisseem 属性的 setter 方法，用于设置教师是否有疑似症状
public void setTisseem(String tisseem) {
this.tisseem = tisseem;
}
// 定义 tisdiagnose 属性的 setter 方法，用于设置教师是否确诊
public void setTisdiagnose(String tisdiagnose) {
this.tisdiagnose = tisdiagnose;
}
// 定义 tstatus 属性的 setter 方法，用于设置教师的状态
public void setTstatus(String tstatus) {
this.tstatus = tstatus;
}
// 定义 tno 属性的 getter 方法，用于获取教师编号
public String getTno() {
return tno;
}
// 定义 tname 属性的 getter 方法，用于获取教师姓名
public String getTname() {
return tname;
}
// 定义 tdept 属性的 getter 方法，用于获取教师所在部门
public String getTdept() {
return tdept;
}
// 定义 tispunch 属性的 getter 方法，用于获取教师是否打卡
public String getTispunch() {
return tispunch;
}
// 定义 tpunchdate 属性的 getter 方法，用于获取教师打卡日期
public Date getTpunchdate() {
return tpunchdate;
}
// 定义 tpunchtime 属性的 getter 方法，用于获取教师打卡时间
public String getTpunchtime() {
return tpunchtime;
}
// 定义 tishot 属性的 getter 方法，用于获取教师是否发热
public String getTishot() {
return tishot;
}
// 定义 tiscough 属性的 getter 方法，用于获取教师是否咳嗽
public String getTiscough() {
return tiscough;
}
// 定义 tisseem 属性的 getter 方法，用于获取教师是否有疑似症状
public String getTisseem() {
return tisseem;
}
// 定义 tisdiagnose 属性的 getter 方法，用于获取教师是否确诊
public String getTisdiagnose() {
return tisdiagnose;
}
// 定义 tstatus 属性的 getter 方法，用于获取教师的状态
public String getTstatus() {
return tstatus;
}
// 重写 toString 方法，返回该对象的字符串表示形式，方便输出和调试
@Override
public String toString() {
return "TeaPunch{" +
@ -121,4 +159,4 @@ public class TeaPunch {
", tstatus='" + tstatus + '\'' +
'}';
}
}
}

47
src/com/entity/Teacher.java
Unescape View File

@ -1,81 +1,126 @@
// 声明该类所属的包，通常用于存放实体类
package com.entity;
// 定义一个名为Teacher的类，用于表示教师实体
public class Teacher {
// 定义私有属性tno，用于存储教师编号
private String tno;
// 定义私有属性tname，用于存储教师姓名
private String tname;
// 定义私有属性tsex，用于存储教师性别
private String tsex;
// 定义私有属性tage，用于存储教师年龄
private int tage;
// 定义私有属性tdept，用于存储教师所属部门
private String tdept;
// 定义私有属性tphone，用于存储教师联系电话
private String tphone;
// 定义私有属性tpsw，用于存储教师密码
private String tpsw;
// 定义setTno方法，用于设置教师编号
public void setTno(String tno) {
// 将传入的参数tno赋值给类的私有属性tno
this.tno = tno;
}
// 定义setTname方法，用于设置教师姓名
public void setTname(String tname) {
// 将传入的参数tname赋值给类的私有属性tname
this.tname = tname;
}
// 定义setTsex方法，用于设置教师性别
public void setTsex(String tsex) {
// 将传入的参数tsex赋值给类的私有属性tsex
this.tsex = tsex;
}
// 定义setTage方法，用于设置教师年龄
public void setTage(int tage) {
// 将传入的参数tage赋值给类的私有属性tage
this.tage = tage;
}
// 定义setTdept方法，用于设置教师所属部门
public void setTdept(String tdept) {
// 将传入的参数tdept赋值给类的私有属性tdept
this.tdept = tdept;
}
// 定义setTphone方法，用于设置教师联系电话
public void setTphone(String tphone) {
// 将传入的参数tphone赋值给类的私有属性tphone
this.tphone = tphone;
}
// 定义setTpsw方法，用于设置教师密码
public void setTpsw(String tpsw) {
// 将传入的参数tpsw赋值给类的私有属性tpsw
this.tpsw = tpsw;
}
// 定义getTno方法，用于获取教师编号
public String getTno() {
// 返回类的私有属性tno的值
return tno;
}
// 定义getTname方法，用于获取教师姓名
public String getTname() {
// 返回类的私有属性tname的值
return tname;
}
// 定义getTsex方法，用于获取教师性别
public String getTsex() {
// 返回类的私有属性tsex的值
return tsex;
}
// 定义getTage方法，用于获取教师年龄
public int getTage() {
// 返回类的私有属性tage的值
return tage;
}
// 定义getTdept方法，用于获取教师所属部门
public String getTdept() {
// 返回类的私有属性tdept的值
return tdept;
}
// 定义getTphone方法，用于获取教师联系电话
public String getTphone() {
// 返回类的私有属性tphone的值
return tphone;
}
// 定义getTpsw方法，用于获取教师密码
public String getTpsw() {
// 返回类的私有属性tpsw的值
return tpsw;
}
// 重写toString方法，用于将教师对象的属性信息以字符串形式输出
@Override
public String toString() {
return "Teacher{" +
// 输出教师编号
"tno='" + tno + '\'' +
// 输出教师姓名
", tname='" + tname + '\'' +
// 输出教师性别
", tsex='" + tsex + '\'' +
// 输出教师年龄
", tage=" + tage +
// 输出教师所属部门
", tdept='" + tdept + '\'' +
// 输出教师联系电话
", tphone='" + tphone + '\'' +
// 输出教师密码
", tpsw='" + tpsw + '\'' +
'}';
}
}
}

36
src/com/entity/WebStu.java
Unescape View File

@ -1,64 +1,96 @@
package com.entity;
// 声明该类所属的包为 com.entity，用于对相关实体类进行组织和管理，便于代码的模块化和维护
public class WebStu {
// 定义一个私有字符串类型的变量 sdept，用于存储系部名称
private String sdept;
// 定义一个私有整型变量 sishotNum，用于存储与发热相关的数量（可能是发热学生的数量等）
private int sishotNum;
// 定义一个私有整型变量 siscoughNum，用于存储与咳嗽相关的数量（可能是咳嗽学生的数量等）
private int siscoughNum;
// 定义一个私有整型变量 sstatusNum，用于存储与某种状态相关的数量（具体状态需根据上下文确定）
private int sstatusNum;
// 定义一个私有整型变量 sisseemNum，用于存储与某种表现相关的数量（可能是有特定症状表现的学生数量等）
private int sisseemNum;
// 定义一个私有整型变量 sisdiagnoseNum，用于存储与诊断结果相关的数量（可能是已诊断学生的数量等）
private int sisdiagnoseNum;
// 这是一个设置系部名称的方法，接收一个字符串类型的参数 sdept
public void setSdept(String sdept) {
// 将传入的参数值赋给当前类的成员变量 sdept
this.sdept = sdept;
}
// 这是一个设置与发热相关数量的方法，接收一个整型参数 sishotNum
public void setSishotNum(int sishotNum) {
// 将传入的参数值赋给当前类的成员变量 sishotNum
this.sishotNum = sishotNum;
}
// 这是一个设置与咳嗽相关数量的方法，接收一个整型参数 siscoughNum
public void setSiscoughNum(int siscoughNum) {
// 将传入的参数值赋给当前类的成员变量 siscoughNum
this.siscoughNum = siscoughNum;
}
// 这是一个设置与某种状态相关数量的方法，接收一个整型参数 sstatusNum
public void setSstatusNum(int sstatusNum) {
// 将传入的参数值赋给当前类的成员变量 sstatusNum
this.sstatusNum = sstatusNum;
}
// 这是一个设置与某种表现相关数量的方法，接收一个整型参数 sisseemNum
public void setSisseemNum(int sisseemNum) {
// 将传入的参数值赋给当前类的成员变量 sisseemNum
this.sisseemNum = sisseemNum;
}
// 这是一个设置与诊断结果相关数量的方法，接收一个整型参数 sisdiagnoseNum
public void setSisdiagnoseNum(int sisdiagnoseNum) {
// 将传入的参数值赋给当前类的成员变量 sisdiagnoseNum
this.sisdiagnoseNum = sisdiagnoseNum;
}
// 这是一个获取系部名称的方法，返回值类型为字符串
public String getSdept() {
// 返回当前类的成员变量 sdept 的值
return sdept;
}
// 这是一个获取与发热相关数量的方法，返回值类型为整型
public int getSishotNum() {
// 返回当前类的成员变量 sishotNum 的值
return sishotNum;
}
// 这是一个获取与咳嗽相关数量的方法，返回值类型为整型
public int getSiscoughNum() {
// 返回当前类的成员变量 siscoughNum 的值
return siscoughNum;
}
// 这是一个获取与某种状态相关数量的方法，返回值类型为整型
public int getSstatusNum() {
// 返回当前类的成员变量 sstatusNum 的值
return sstatusNum;
}
// 这是一个获取与某种表现相关数量的方法，返回值类型为整型
public int getSisseemNum() {
// 返回当前类的成员变量 sisseemNum 的值
return sisseemNum;
}
// 这是一个获取与诊断结果相关数量的方法，返回值类型为整型
public int getSisdiagnoseNum() {
// 返回当前类的成员变量 sisdiagnoseNum 的值
return sisdiagnoseNum;
}
// 重写了父类 Object 的 toString 方法，用于将 WebStu 对象以字符串的形式表示
@Override
public String toString() {
// 返回一个包含系部名称以及各类数量信息的字符串，格式为 "WebStu{sdept='xxx', sishotNum=xxx, siscoughNum=xxx, sstatusNum=xxx, sisseemNum=xxx, sisdiagnoseNum=xxx}"
return "WebStu{" +
"sdept='" + sdept + '\'' +
", sishotNum=" + sishotNum +
@ -68,4 +100,4 @@ public class WebStu {
", sisdiagnoseNum=" + sisdiagnoseNum +
'}';
}
}
}

36
src/com/entity/WebTea.java
Unescape View File

@ -1,64 +1,96 @@
package com.entity;
// 声明该类所属的包为 com.entity，通常用于存放实体类，方便代码的组织和管理
public class WebTea {
// 定义一个私有字符串类型的变量 tdept，用于存储教师所在的系部
private String tdept;
// 定义一个私有整型变量 tishotNum，用于存储教师中发热的人数
private int tishotNum;
// 定义一个私有整型变量 tiscoughNum，用于存储教师中咳嗽的人数
private int tiscoughNum;
// 定义一个私有整型变量 tstatusNum，用于存储处于某种特定状态的教师人数
private int tstatusNum;
// 定义一个私有整型变量 tisseemNum，用于存储有某种特定表现的教师人数
private int tisseemNum;
// 定义一个私有整型变量 tisdiagnoseNum，用于存储已被诊断的教师人数
private int tisdiagnoseNum;
// 设置教师所在系部的方法，接收一个字符串类型的参数 tdept
public void setTdept(String tdept) {
// 将传入的参数值赋给当前对象的 tdept 成员变量
this.tdept = tdept;
}
// 设置教师中发热人数的方法，接收一个整型参数 tishotNum
public void setTishotNum(int tishotNum) {
// 将传入的参数值赋给当前对象的 tishotNum 成员变量
this.tishotNum = tishotNum;
}
// 设置教师中咳嗽人数的方法，接收一个整型参数 tiscoughNum
public void setTiscoughNum(int tiscoughNum) {
// 将传入的参数值赋给当前对象的 tiscoughNum 成员变量
this.tiscoughNum = tiscoughNum;
}
// 设置处于特定状态的教师人数的方法，接收一个整型参数 tstatusNum
public void setTstatusNum(int tstatusNum) {
// 将传入的参数值赋给当前对象的 tstatusNum 成员变量
this.tstatusNum = tstatusNum;
}
// 设置有特定表现的教师人数的方法，接收一个整型参数 tisseemNum
public void setTisseemNum(int tisseemNum) {
// 将传入的参数值赋给当前对象的 tisseemNum 成员变量
this.tisseemNum = tisseemNum;
}
// 设置已被诊断的教师人数的方法，接收一个整型参数 tisdiagnoseNum
public void setTisdiagnoseNum(int tisdiagnoseNum) {
// 将传入的参数值赋给当前对象的 tisdiagnoseNum 成员变量
this.tisdiagnoseNum = tisdiagnoseNum;
}
// 获取教师所在系部的方法，返回值类型为字符串
public String getTdept() {
// 返回当前对象的 tdept 成员变量的值
return tdept;
}
// 获取教师中发热人数的方法，返回值类型为整型
public int getTishotNum() {
// 返回当前对象的 tishotNum 成员变量的值
return tishotNum;
}
// 获取教师中咳嗽人数的方法，返回值类型为整型
public int getTiscoughNum() {
// 返回当前对象的 tiscoughNum 成员变量的值
return tiscoughNum;
}
// 获取处于特定状态的教师人数的方法，返回值类型为整型
public int getTstatusNum() {
// 返回当前对象的 tstatusNum 成员变量的值
return tstatusNum;
}
// 获取有特定表现的教师人数的方法，返回值类型为整型
public int getTisseemNum() {
// 返回当前对象的 tisseemNum 成员变量的值
return tisseemNum;
}
// 获取已被诊断的教师人数的方法，返回值类型为整型
public int getTisdiagnoseNum() {
// 返回当前对象的 tisdiagnoseNum 成员变量的值
return tisdiagnoseNum;
}
// 重写 Object 类的 toString 方法，用于将对象的信息以字符串形式输出
@Override
public String toString() {
// 构建并返回包含对象各成员变量信息的字符串
return "WebTea{" +
"tdept='" + tdept + '\'' +
", tishotNum=" + tishotNum +
@ -68,4 +100,4 @@ public class WebTea {
", tisdiagnoseNum=" + tisdiagnoseNum +
'}';
}
}
}

39
src/com/filter/DeptAdmLoginFilter.java
Unescape View File

@ -1,34 +1,61 @@
// 声明该类所属的包为 com.filter，包用于组织和管理 Java 类，避免命名冲突
package com.filter;
// 导入 javax.servlet 包下的 Servlet、ServletRequest、ServletResponse、FilterChain 等接口，用于创建和处理 Servlet 相关操作
import javax.servlet.*;
// 导入 javax.servlet.annotation 包下的 WebFilter 注解，用于将该类标记为一个 Servlet 过滤器，并指定过滤的 URL 模式
import javax.servlet.annotation.WebFilter;
// 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于处理 HTTP 请求
import javax.servlet.http.HttpServletRequest;
// 导入 java.io 包下的 IOException 类，用于处理输入输出相关的异常
import java.io.IOException;
// 使用 WebFilter 注解将该类标记为一个 Servlet 过滤器，指定过滤的 URL 模式为 "/view/deptadmin/deptmainview.jsp"
@WebFilter("/view/deptadmin/deptmainview.jsp")
// 定义一个名为 DeptAdmLoginFilter 的类，实现 Filter 接口，用于实现部门管理员登录过滤功能
public class DeptAdmLoginFilter implements Filter {
/**
* 过滤器的初始化方法，在过滤器实例化后被调用，用于初始化过滤器的配置信息
* @param filterConfig 包含过滤器配置信息的 FilterConfig 对象
* @throws ServletException 当初始化过程中发生错误时抛出
*/
@Override
public void init(FilterConfig filterConfig) throws ServletException {
// 目前该方法为空，可在需要时添加初始化相关的代码
}
/**
* 过滤器的核心方法，用于对请求进行过滤处理
* @param servletRequest 表示客户端的请求
* @param servletResponse 表示对客户端的响应
* @param filterChain 用于调用过滤器链中的下一个过滤器或目标资源
* @throws IOException 当处理输入输出操作发生错误时抛出
* @throws ServletException 当处理 Servlet 相关操作发生错误时抛出
*/
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
// 将 ServletRequest 强制转换为 HttpServletRequest，以便使用 HTTP 相关的方法
HttpServletRequest request = (HttpServletRequest) servletRequest;
//3.从获取session中获取user
// 3. 从获取的 session 中获取名为 "deptadno" 的属性值，该属性可能用于标识部门管理员是否已登录
Object deptadno = request.getSession().getAttribute("deptadno");
// 打印获取到的 "deptadno" 属性值，用于调试和查看信息
System.out.println(deptadno);
// 判断获取到的 "deptadno" 属性值是否不为空
if (deptadno != null){
//登录了，放行
// 用户已登录，将请求和响应传递给过滤器链中的下一个过滤器或目标资源，即放行请求
filterChain.doFilter(servletRequest, servletResponse);
}else {
//没有登录,跳转到登录页面
// 用户没有登录，通过 RequestDispatcher 将请求转发到 "/view/frontweb/deptadmlogin.jsp" 页面，即跳转到登录页面
request.getRequestDispatcher("/view/frontweb/deptadmlogin.jsp").forward(servletRequest, servletResponse);
}
}
/**
* 过滤器的销毁方法，在过滤器实例被销毁前调用，用于释放过滤器占用的资源
*/
@Override
public void destroy() {
// 目前该方法为空，可在需要时添加释放资源相关的代码
}
}
}

50
src/com/filter/SchoAdmLoginFilter.java
Unescape View File

@ -1,34 +1,76 @@
// 声明该类所属的包为 com.filter，用于组织和管理过滤器相关的类
package com.filter;
// 导入 javax.servlet 包下的 Servlet、ServletRequest、ServletResponse、FilterChain 等接口，
// 这些接口是创建和使用 Servlet 过滤器所必需的基础接口
import javax.servlet.*;
// 导入 javax.servlet.annotation 包下的 WebFilter 注解，
// 该注解用于将一个类标记为 Servlet 过滤器，并指定过滤器所应用的 URL 模式
import javax.servlet.annotation.WebFilter;
// 导入 javax.servlet.http 包下的 HttpServletRequest 类，
// 用于处理 HTTP 请求相关的操作，这里主要用于获取 HTTP 请求中的会话信息
import javax.servlet.http.HttpServletRequest;
// 导入 java.io 包下的 IOException 类，用于处理输入输出相关的异常
import java.io.IOException;
// 使用 WebFilter 注解将该类标记为一个 Servlet 过滤器，
// 并指定该过滤器应用于 "/view/schoadmin/schomainview.jsp" 这个 URL 模式
@WebFilter("/view/schoadmin/schomainview.jsp")
// 定义一个名为 SchoAdmLoginFilter 的类，实现 Filter 接口，
// 用于实现学校管理员登录状态的过滤功能
public class SchoAdmLoginFilter implements Filter {
/**
* 过滤器的初始化方法，在过滤器实例化时被调用，
* 用于初始化过滤器的配置信息等资源。
* 这里目前为空实现，后续如有需要可以添加初始化相关的代码逻辑。
* @param filterConfig 包含过滤器配置信息的 FilterConfig 对象
* @throws ServletException 当初始化过程中发生异常时抛出
*/
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
/**
* 过滤器的核心方法，用于对请求进行过滤处理。
* 该方法会在每次请求经过该过滤器时被调用。
* @param servletRequest 表示客户端发送的请求对象
* @param servletResponse 表示服务器对客户端请求的响应对象
* @param filterChain 用于调用过滤器链中的下一个过滤器或目标资源
* @throws IOException 当在处理请求或响应过程中发生输入输出异常时抛出
* @throws ServletException 当在处理 Servlet 相关操作时发生异常时抛出
*/
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
// 将 ServletRequest 类型的对象强制转换为 HttpServletRequest 类型，
// 以便使用 HttpServletRequest 中特有的方法，如获取会话（session）信息等。
HttpServletRequest request = (HttpServletRequest) servletRequest;
//3.从获取session中获取user
// 从当前请求的会话（session）中获取名为 "schoadno" 的属性值，
// 这里的 "schoadno" 可能是用于标识学校管理员登录状态的一个属性。
Object schoadno = request.getSession().getAttribute("schoadno");
// 打印获取到的 "schoadno" 属性值，主要用于调试，方便查看该属性是否正确获取。
System.out.println(schoadno);
// 判断获取到的 "schoadno" 属性值是否不为空，
// 如果不为空，则认为用户已经登录。
if (schoadno != null){
//登录了，放行
// 用户已登录，将请求和响应传递给过滤器链中的下一个过滤器或目标资源，
// 即放行该请求，让其继续处理。
filterChain.doFilter(servletRequest, servletResponse);
}else {
//没有登录,跳转到登录页面
// 用户未登录，通过 RequestDispatcher 将请求转发到 "/view/frontweb/schoadmlogin.jsp" 页面，
// 从而实现将未登录用户重定向到学校管理员登录页面的功能。
request.getRequestDispatcher("/view/frontweb/schoadmlogin.jsp").forward(servletRequest, servletResponse);
}
}
/**
* 过滤器的销毁方法，在过滤器实例被销毁之前调用，
* 用于释放过滤器所占用的资源，如关闭数据库连接、释放文件句柄等。
* 这里目前为空实现，后续如有需要可以添加资源释放相关的代码逻辑。
*/
@Override
public void destroy() {
}
}
}

30
src/com/filter/StuLoginFilter.java
Unescape View File

@ -1,34 +1,56 @@
package com.filter;
// 声明该类所属的包为 com.filter，用于组织和管理过滤器相关的类
import javax.servlet.*;
// 导入 javax.servlet 包下的 Servlet 相关接口和类，用于创建和处理 Servlet 相关操作
import javax.servlet.annotation.WebFilter;
// 导入用于将 Servlet 过滤器映射到特定 URL 模式的注解
import javax.servlet.http.HttpServletRequest;
// 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于处理 HTTP 请求
import java.io.IOException;
// 导入用于处理输入输出异常的类
@WebFilter("/view/frontweb/stuinfo.jsp")
// 使用 WebFilter 注解将该过滤器映射到 "/view/frontweb/stuinfo.jsp" 这个 URL 路径上，
// 当客户端请求访问该路径时，此过滤器会被触发执行
public class StuLoginFilter implements Filter {
// 实现 Filter 接口的 init 方法，该方法在过滤器初始化时被调用，
// 用于执行一些初始化操作，这里为空实现
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
// 实现 Filter 接口的 doFilter 方法，该方法是过滤器的核心方法，
// 用于对请求和响应进行过滤处理
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
// 将 ServletRequest 强转为 HttpServletRequest，以便使用 HTTP 相关的方法
HttpServletRequest request = (HttpServletRequest) servletRequest;
//3.从获取session中获取user
// 从当前请求的 session 中获取名为 "sno" 的属性值，这里假设 "sno" 是用于标识用户登录状态的信息
Object sno = request.getSession().getAttribute("sno");
// 打印获取到的 "sno" 属性值，主要用于调试，查看是否获取到了正确的信息
System.out.println(sno);
// 判断获取到的 "sno" 属性值是否不为 null
if (sno != null){
//登录了，放行
// 如果不为 null，说明用户已经登录，调用 filterChain 的 doFilter 方法放行请求，
// 让请求继续传递到后续的过滤器或目标资源（如 JSP 页面）
filterChain.doFilter(servletRequest, servletResponse);
}else {
//没有登录,跳转到登录页面
// 如果为 null，说明用户没有登录，使用 request 的 getRequestDispatcher 方法获取一个请求转发器，
// 将请求转发到 "/view/frontweb/stulogin.jsp" 页面，即跳转到登录页面
request.getRequestDispatcher("/view/frontweb/stulogin.jsp").forward(servletRequest, servletResponse);
}
}
// 实现 Filter 接口的 destroy 方法，该方法在过滤器销毁时被调用，
// 用于执行一些清理资源等操作，这里为空实现
@Override
public void destroy() {
}
}
}

27
src/com/filter/StuLoginFilter1.java
Unescape View File

@ -1,34 +1,49 @@
// 声明该类所属的包，表明该类是用于过滤相关功能的类，属于com.filter包
package com.filter;
// 导入Servlet相关的接口和类，用于实现过滤器的功能
import javax.servlet.*;
// 导入Servlet注解，用于将过滤器映射到特定的URL路径
import javax.servlet.annotation.WebFilter;
// 导入HTTP请求相关的类，用于处理HTTP请求相关操作
import javax.servlet.http.HttpServletRequest;
// 导入处理输入输出异常的类，当在过滤器执行过程中出现输入输出相关错误时会抛出该异常
import java.io.IOException;
// 使用注解将该过滤器映射到/StuInfoServlet路径，对访问该路径的请求进行过滤操作
@WebFilter("/StuInfoServlet")
// 定义一个名为StuLoginFilter1的类，实现Filter接口，用于实现学生登录相关的过滤逻辑
public class StuLoginFilter1 implements Filter {
// 重写init方法，在过滤器初始化时调用，这里为空实现，目前没有在初始化时需要执行的操作
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
// 重写doFilter方法，这是过滤器的核心方法，用于处理请求和响应
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
// 将ServletRequest类型的请求对象强转为HttpServletRequest类型，以便使用HTTP相关的方法和属性
HttpServletRequest request = (HttpServletRequest) servletRequest;
//3.从获取session中获取user
// 从当前请求的会话（session）中获取名为sno的属性值，sno可能代表学生学号，用于判断学生是否登录
Object sno = request.getSession().getAttribute("sno");
// 在控制台打印获取到的sno属性值，用于调试，查看是否成功获取该属性
System.out.println(sno);
if (sno != null){
//登录了，放行
// 判断获取到的sno属性值是否不为空，若不为空则表示学生已登录
if (sno != null) {
// 如果学生已登录，调用过滤器链的doFilter方法，将请求和响应传递给下一个过滤器或目标资源，即放行请求
filterChain.doFilter(servletRequest, servletResponse);
}else {
//没有登录,跳转到登录页面
} else {
// 如果学生未登录，使用请求的getRequestDispatcher方法获取一个请求转发器
// 将请求转发到/view/frontweb/stulogin.jsp页面，即跳转到学生登录页面
request.getRequestDispatcher("/view/frontweb/stulogin.jsp").forward(servletRequest, servletResponse);
}
}
// 重写destroy方法，在过滤器销毁时调用，这里为空实现，目前没有在过滤器销毁时需要执行的清理操作
@Override
public void destroy() {
}
}
}

27
src/com/filter/TeacherLoginFilter.java
Unescape View File

@ -1,34 +1,49 @@
// 声明该类所属的包，表明该类是一个过滤器类，通常用于处理请求和响应的过滤逻辑
package com.filter;
// 导入Servlet相关的接口和类，用于处理Servlet请求和响应
import javax.servlet.*;
// 导入Servlet注解，用于将过滤器映射到指定的URL路径
import javax.servlet.annotation.WebFilter;
// 导入HTTP请求相关的类，用于处理HTTP请求
import javax.servlet.http.HttpServletRequest;
// 导入处理输入输出异常的类，当进行输入输出操作时可能会抛出该异常
import java.io.IOException;
// 使用注解将该过滤器映射到/view/frontweb/teainfo.jsp路径，对访问该路径的请求进行过滤
@WebFilter("/view/frontweb/teainfo.jsp")
// 定义一个名为TeacherLoginFilter的类，实现Filter接口，用于过滤教师登录相关的请求
public class TeacherLoginFilter implements Filter {
// 重写init方法，在过滤器初始化时调用，这里为空实现，未做任何初始化操作
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
// 重写doFilter方法，这是过滤器的核心方法，用于处理请求和响应
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
// 将ServletRequest强制转换为HttpServletRequest，以便使用HTTP相关的方法
HttpServletRequest request = (HttpServletRequest) servletRequest;
//3.从获取session中获取user
// 从当前请求的会话（session）中获取名为tno的属性值，tno可能代表教师编号，用于判断用户是否登录
Object tno = request.getSession().getAttribute("tno");
// 在控制台打印获取到的tno属性值，用于调试
System.out.println(tno);
if (tno != null){
//登录了，放行
// 判断获取到的tno属性值是否不为空，若不为空则表示用户已登录
if (tno != null) {
// 如果用户已登录，调用过滤器链的doFilter方法，将请求和响应传递给下一个过滤器或目标资源，即放行请求
filterChain.doFilter(servletRequest, servletResponse);
}else {
//没有登录,跳转到登录页面
} else {
// 如果用户未登录，使用请求的getRequestDispatcher方法获取一个请求转发器
// 将请求转发到/view/frontweb/tealogin.jsp页面，即跳转到教师登录页面
request.getRequestDispatcher("/view/frontweb/tealogin.jsp").forward(servletRequest, servletResponse);
}
}
// 重写destroy方法，在过滤器销毁时调用，这里为空实现，未做任何清理操作
@Override
public void destroy() {
}
}
}

34
src/com/filter/TeacherLoginFilter1.java
Unescape View File

@ -1,34 +1,58 @@
// 声明该类所在的包为 com.filter
package com.filter;
// 导入 Servlet 相关的接口和类，用于创建过滤器和处理 Servlet 请求/响应
import javax.servlet.*;
// 导入用于将过滤器映射到特定 URL 模式的注解
import javax.servlet.annotation.WebFilter;
// 导入 HttpServletRequest 类，用于处理 HTTP 请求
import javax.servlet.http.HttpServletRequest;
// 导入 IOException 类，用于处理输入输出异常
import java.io.IOException;
// 使用 WebFilter 注解将该过滤器映射到 "/TeaInfoServlet" 路径，
// 当客户端请求访问该路径时，该过滤器会被触发执行
@WebFilter("/TeaInfoServlet")
// 定义 TeacherLoginFilter1 类，实现 Filter 接口，表明这是一个过滤器类
public class TeacherLoginFilter1 implements Filter {
// 重写 init 方法，该方法在过滤器初始化时被调用，
// 通常用于初始化一些资源或配置信息。
// 这里为空实现，可能不需要在初始化时进行特殊操作
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
// 重写 doFilter 方法，这是过滤器的核心方法，
// 每次请求经过该过滤器时都会调用此方法来处理请求和响应。
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
// 将 ServletRequest 强转为 HttpServletRequest，以便使用 HTTP 相关的方法
HttpServletRequest request = (HttpServletRequest) servletRequest;
//3.从获取session中获取user
// 从当前请求的会话（session）中获取名为 "tno" 的属性值，
// 这里假设 "tno" 是用于标识教师登录状态的属性
Object tno = request.getSession().getAttribute("tno");
// 将获取到的 "tno" 属性值打印到控制台，用于调试
System.out.println(tno);
// 判断获取到的 "tno" 属性值是否不为 null，
// 如果不为 null 则表示用户已登录
if (tno != null){
//登录了，放行
// 用户已登录，调用 filterChain 的 doFilter 方法放行请求，
// 让请求继续传递到后续的 Servlet 或过滤器进行处理
filterChain.doFilter(servletRequest, servletResponse);
}else {
//没有登录,跳转到登录页面
} else {
// 用户未登录，使用请求转发将请求转发到 "/view/frontweb/tealogin.jsp" 页面，
// 即跳转到教师登录页面，让用户进行登录操作
request.getRequestDispatcher("/view/frontweb/tealogin.jsp").forward(servletRequest, servletResponse);
}
}
// 重写 destroy 方法，该方法在过滤器销毁时被调用，
// 通常用于释放初始化时创建的资源。
// 这里为空实现，可能不需要在销毁时进行特殊操作
@Override
public void destroy() {
}
}
}
Write Preview
Loading…
Cancel
Save