Compare commits

..

No commits in common. 'zp' and 'master' have entirely different histories.
zp ... master

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

@ -5,18 +5,16 @@
<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="Default Changelist">
<change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
</list>
<list default="true" id="0ffa26fe-3275-4667-90ad-c688ca600b30" name="Default Changelist" comment="" />
<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>
@ -25,14 +23,6 @@
</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" />
@ -40,9 +30,6 @@
<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>
@ -57,15 +44,14 @@
</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$" />
<property name="last_opened_file_path" value="$PROJECT_DIR$/web" />
<property name="node.js.detected.package.eslint" value="true" />
<property name="node.js.detected.package.tslint" value="true" />
<property name="node.js.path.for.package.eslint" value="project" />
@ -76,7 +62,6 @@
<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">
@ -196,7 +181,6 @@
</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>
@ -344,60 +328,116 @@
<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="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>
<option name="version" value="1" />
</component>
<component name="VcsManagerConfiguration">
<MESSAGE value="Default Changelist" />
<option name="LAST_COMMIT_MESSAGE" value="Default Changelist" />
<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>
</project>

@ -1,112 +1,61 @@
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 请求相同
}
}
}

@ -1,112 +1,51 @@
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
@WebServlet("/SchoDelSelectedStuServlet")
public class SchoDelSelectedStuServlet extends 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 中
String[] snos = req.getParameterValues("sno");
System.out.println(snodates);
// 在控制台打印 snodates 数组的引用信息
if(snodates.length > 0 && snodates != null){
// 检查 snodates 数组不为空且有元素
System.out.println(snos);
if(snos.length > 0 && snos != null){
//遍历并删除选中的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 格式化为日期类型
for (String sno: snos) {
String sql = null;
// 声明一个字符串变量 sql 并初始化为 null用于存储 SQL 语句
Object[] objects = {sno, spunchdate};
// 创建一个 Object 类型的数组 objects包含学生编号和打卡日期
Object[] objects = {sno};
//删除stupunchin中的该导游信息
sql = "delete from stupunchin where sno = ? and spunchdate = ?";
// 构建 SQL 语句,用于从 stupunchin 表中删除指定学生编号和打卡日期的记录
sql = "delete from stupunchin where sno = ?";
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("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp);
// 创建请求转发器,将请求转发到 /SchoQueryStuPunchByPageServlet 并附带一些查询参数,然后将请求和响应对象传递给转发器进行转发
req.getRequestDispatcher("/SchoQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=").forward(req, resp);
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写 HttpServlet 类的 doPost 方法,用于处理 HTTP POST 请求,可能会抛出 ServletException 和 IOException 异常
doGet(req, resp);
// 调用 doGet 方法处理 POST 请求,即让 POST 请求的处理逻辑和 GET 请求相同
}
}
}

@ -11,93 +11,7 @@ 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");

@ -1,118 +1,51 @@
// 声明该类所在的包为 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 注解将该 Servlet 映射到 "/SchoQueryStuByIdServlet" 路径,
// 当客户端请求访问该路径时,该 Servlet 会被触发执行
@WebServlet("/SchoQueryStuByIdServlet")
// 定义 SchoQueryStuByIdServlet 类,继承自 HttpServlet 类,表明这是一个 Servlet 类
public class SchoQueryStuByIdServlet extends HttpServlet {
@WebServlet("/SchoDelSelectedTeaServlet")
public class SchoDelSelectedTeaServlet 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");//ugu
// 设置响应的内容类型为 HTML字符编码为 UTF-8
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
// 从请求参数中获取名为 "sno" 的参数值,该值代表学生的学号
String sno = req.getParameter("sno");
//获取请求时复选框有选中的状态参数
String[] tnos = req.getParameterValues("tno");
// 声明一个 SQL 语句变量,初始化为 null
String sql = null;
// 创建一个对象数组,用于存储 SQL 查询中的参数,这里存储了学号
Object[] objects = {sno};
System.out.println(tnos);
// 查询是否存在该学号对应的学生
// 构造 SQL 语句,使用 count(*) 统计满足条件的记录数量,并将结果命名为 num
sql = "select count(*) as num from student where sno = ?";
// 调用 DeptAdminDao 类的 findTotalCount 方法,执行 SQL 查询并返回记录数量
int count = DeptAdminDao.findTotalCount(sql, objects);
if(tnos.length > 0 && tnos != null){
//遍历并删除选中的sno,y一个一个删除
for (String tno: tnos) {
String sql = null;
Object[] objects = {tno};
// 如果查询到的记录数量大于 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();
//删除stupunchin中的该导游信息
sql = "delete from teapunchin where tno = ?";
int num1 = DeptAdminDao.executeUpdate(sql, objects);
System.out.println(num1);
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);
//删除student表中该导游信息
sql = "delete from teacher where tno = ?";
int num2 = DeptAdminDao.executeUpdate(sql, objects);
System.out.println(num2);
}
// 打印学生的性别信息,用于调试
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);
req.getRequestDispatcher("/SchoQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=").forward(req, resp);
}
}
// 重写 doPost 方法,用于处理 HTTP POST 请求
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 对于 POST 请求,直接调用 doGet 方法进行处理,实现请求方法的统一处理
doGet(req, resp);
}
}
}

@ -1,111 +1,54 @@
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 请求一致
}
}
}

@ -1,92 +1,64 @@
// 声明该类所在的包为 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 类型,但未实际使用
// Date spunchdate1 = new Date(spunchdate);
// SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
// Date spunchdate1 = ft.format(spunchdate);
//字符串转为日期类型
// 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);
// 如果查询到的记录数量大于 0说明存在该教师在指定日期的打卡记录
if (count > 0) {
// 构建 SQL 删除语句,用于删除 teapunchin 表中指定教师编号和打卡日期的记录
if (count > 0) { //有则继续操作
//删除stupunchin中的该信息
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 {
// 如果查询到的记录数量为 0说明不存在该教师在指定日期的打卡记录
// 将请求转发到 noexistdataofdelete.jsp 页面,提示用户要删除的数据不存在
}else {
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);
}
}
}

@ -1,94 +1,66 @@
// 声明该类所属的包为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);
// 如果count大于0说明存在该教师编号和打卡日期对应的记录可以继续进行删除操作
if (count > 0) {
// 构建SQL删除语句用于从teapunchin表中删除指定教师编号和打卡日期的记录
if (count > 0) { //有则继续操作
//删除stupunchin中的该信息
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 {
// 如果count不大于0说明不存在该教师编号和打卡日期对应的记录将请求转发到提示不存在要删除数据的页面
}else {
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);
}
}
}

@ -1,82 +1,54 @@
// 声明该类所在的包名为 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);
// 如果查询到的记录数量大于 0说明该教师记录存在
if (count > 0) {
// 构建 SQL 删除语句,用于删除 teapunchin 表中该教师的打卡信息
if (count > 0) { //有则继续操作
//删除stupunchin中的该导游信息
sql = "delete from teapunchin where tno = ?";
// 调用 DeptAdminDao 类的 executeUpdate 方法执行删除操作,返回受影响的行数
int num1 = DeptAdminDao.executeUpdate(sql, objects);
// 将受影响的行数打印到控制台,方便调试
System.out.println(num1);
// 构建 SQL 删除语句,用于删除 teacher 表中该教师的信息
//删除student表中该导游信息
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 {
// 如果查询到的记录数量为 0说明该教师记录不存在
// 将请求转发到 noexistdataofdelete.jsp 页面,提示用户要删除的数据不存在
}else {
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);
}
}
}

@ -1,111 +1,72 @@
// 声明该类所属的包,表明该类是用于学校管理员相关功能的控制器类
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);
// 如果count大于0说明存在该教师编号对应的记录可以继续查询详细信息
if (count > 0) {
// 构建SQL查询语句用于获取指定教师编号的教师详细信息
if (count > 0) { //有则继续操作
sql = "select * from teacher where tno = ?";
// 调用DeptAdminDao类的qureyInfo方法执行SQL查询并将结果存储在ResultSet对象中
ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects);
// 创建一个Teacher对象用于封装查询到的教师信息
Teacher teacher = new Teacher();
try {
// 遍历结果集由于查询结果理论上只有一条记录这里while循环通常只会执行一次
while (resultSet.next()) {
// 从结果集中获取教师编号并设置到Teacher对象中
while (resultSet.next()){
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 {
// 无论是否出现异常最后都调用JDBCUtils类的close方法关闭结果集释放资源
}finally {
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 {
// 如果count不大于0说明不存在该教师编号对应的记录将请求转发到提示不存在数据的页面
}else {
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);
}
}
}

@ -1,83 +1,52 @@
// 声明该类所在的包为 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);
// 如果查询到的记录数量大于 0说明该教师记录存在
if (count > 0) {
// 构建 SQL 查询语句,用于获取指定教师编号的教师的详细信息
if (count > 0) { //有则继续操作
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"));
@ -88,33 +57,25 @@ public class SchoQueryTeaByIdServlet1 extends HttpServlet {
teacher.setTpsw(resultSet.getString("tpsw"));
}
} catch (Exception e) {
// 如果在遍历结果集过程中出现异常,打印异常堆栈信息,方便调试
e.printStackTrace();
} finally {
// 调用 JDBCUtils 类的 close 方法关闭结果集,释放数据库资源
}finally {
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 {
// 如果查询到的记录数量为 0说明该教师记录不存在
// 将请求转发到 /view/alluse/noexistdataofalter.jsp 页面,提示用户要修改的数据不存在
}else {
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);
}
}
}

@ -1,229 +1,165 @@
// 声明该类所属的包,表明该类用于学校管理员相关功能的控制器类
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");
// 如果教师编号参数为空,将其设置为空字符串,方便后续进行模糊查询
if (tno == null) {
//如果传入的参数为null则置为空字符串
if (tno == null){
tno = "";
}
// 如果教师姓名参数为空,将其设置为空字符串
if (tname == null) {
if (tname == null){
tname = "";
}
// 如果教师所属部门参数为空,将其设置为空字符串
if (tdept == null) {
if (tdept == null){
tdept = "";
}
// 将教师编号参数转换为适合SQL like查询的格式即在前后添加通配符%
//变为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");
// 从请求中获取名为currentPage的参数代表当前页码
String currentPage = req.getParameter("currentPage");
// 从请求中获取名为rows的参数代表每页显示的记录数
String rows = req.getParameter("rows");
String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码
String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数
// 如果当前页码参数为空或为空字符串,将当前页码设置为第一页
if (currentPage == null || "".equals(currentPage)) {
//如果未设请求参数,此处自动设置参数为第一页
if (currentPage == null || "".equals(currentPage)){
currentPage = "1";
}
// 如果每页显示的记录数参数为空或为空字符串将每页显示记录数设置为7
if (rows == null || "".equals(rows)) {
//如果没有设置rows的请求参数此处自动设置
if (rows == null || "".equals(rows)){
rows = "7";
}
// 将当前页码参数转换为整数类型
//获取条件查询的参数
int currentPage1 = Integer.parseInt(currentPage);
// 将每页显示的记录数参数转换为整数类型
int rows1 = Integer.parseInt(rows);
// 如果当前页码小于等于0将当前页码设置为1
if (currentPage1 <= 0) {
//如果当前页数小于1则设置当前页数为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);
// 如果总记录数大于0说明有符合条件的记录
if (totalCount > 0) {
// 计算总页数如果总记录数能被每页记录数整除则总页数为总记录数除以每页记录数否则总页数为总记录数除以每页记录数再加1
int totalPage = (totalCount % rows1) == 0 ? totalCount / rows1 : (totalCount / rows1 + 1);
// 设置分页对象的总页数
if (totalCount > 0){
//计算总页码,并设置
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 {
// 如果总记录数为0说明没有符合条件的记录将请求转发到无数据提示页面
}else {
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);
}
}
}

@ -1,70 +1,44 @@
// 声明该类所属的包名为 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);
// 如果查询到的记录数量大于 0说明存在该教师在指定日期的打卡记录
if (count > 0) {
// 构建 SQL 查询语句,通过连接 teacher 表和 teapunchin 表,获取教师姓名和打卡信息
if (count > 0){ //有则继续操作
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 {
// 遍历结果集,将每一行数据中的打卡信息设置到 TeaPunch 对象中
while (resultSet.next()) {
while (resultSet.next()){
teaPunch.setTno(resultSet.getString("tno"));
teaPunch.setTname(resultSet.getString("tname"));
teaPunch.setTispunch(resultSet.getString("tispunch"));
@ -77,34 +51,24 @@ public class SchoQueryTeaPunchByIdServlet extends HttpServlet {
teaPunch.setTstatus(resultSet.getString("tstatus"));
}
} catch (Exception e) {
// 如果在遍历结果集过程中出现异常,打印异常堆栈信息,方便调试
e.printStackTrace();
} finally {
// 调用 JDBCUtils 类的 close 方法关闭结果集,释放数据库资源
}finally {
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 {
// 如果查询到的记录数量为 0说明不存在该教师在指定日期的打卡记录
// 将请求转发到 /view/alluse/noexistdataofalter.jsp 页面,提示用户要修改的数据不存在
}else {
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);
}
}
}

@ -1,131 +1,83 @@
// 声明该类所属的包,表明该类用于学校管理员相关功能的控制器类
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);
// 如果count大于0说明存在该教师编号和打卡日期对应的教师打卡记录可以继续查询详细信息
if (count > 0) {
// 构建SQL查询语句用于获取指定教师编号和打卡日期的教师打卡详细信息同时关联teacher表获取教师姓名
if (count > 0){ //有则继续操作
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循环通常只会执行一次
while (resultSet.next()) {
// 从结果集中获取教师编号并设置到TeaPunch对象中
while (resultSet.next()){
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 {
// 无论是否出现异常最后都调用JDBCUtils类的close方法关闭结果集释放资源
}finally {
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 {
// 如果count不大于0说明不存在该教师编号和打卡日期对应的教师打卡记录将请求转发到提示不存在数据的页面
}else {
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);
}
}
}

@ -1,193 +1,146 @@
// 声明该类所在的包为 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";
}
// 如果每页显示行数参数为 null 或空字符串,设置每页显示行数为 7
//如果没有设置rows的请求参数此处自动设置
if (rows == null || "".equals(rows)){
rows = "7";
}
// 将当前页码字符串转换为整数类型
//获取条件查询的参数
int currentPage1 = Integer.parseInt(currentPage);
// 将每页显示行数字符串转换为整数类型
int rows1 = Integer.parseInt(rows);
// 如果当前页码小于等于 0设置当前页码为 1
//如果当前页数小于1则设置当前页数为1
if (currentPage1 <= 0){
currentPage1 = 1;
}
// 创建一个 PageBean 对象,用于封装教师打卡信息的分页数据
//设置StuPunch类的对象类型
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"));
@ -204,35 +157,25 @@ public class SchoQueryTeaPunchByPageServlet extends HttpServlet {
teaPunchArrayList.add(teaPunch);
}
} catch (Exception e) {
// 如果在遍历结果集过程中出现异常,打印异常堆栈信息
e.printStackTrace();
} finally {
// 调用 JDBCUtils 的方法关闭结果集,释放资源
}finally {
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 {
// 如果总记录数为 0将请求转发到 /view/alluse/nodata.jsp 页面,提示没有数据
}else {
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);
}
}
}

@ -1,117 +1,70 @@
// 声明该类所属的包为 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 {
// 无论是否出现异常,最后都调用 JDBCUtils 类的 close 方法关闭结果集
}finally {
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);
}
}
}

@ -1,213 +1,147 @@
// 声明该类所属的包为 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");
// 如果获取到的 tpunchdate 为 null则将其赋值为空字符串
if (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");
// 从请求对象中获取名为 currentPage 的参数,该参数表示当前页码
String currentPage = req.getParameter("currentPage");
// 从请求对象中获取名为 rows 的参数,该参数表示每页显示的记录数
String rows = req.getParameter("rows");
String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码
String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数
// 如果当前页码参数为空或者为空字符串,则将当前页码设置为 1
if (currentPage == null || "".equals(currentPage)) {
//如果未设请求参数,此处自动设置参数为第一页
if (currentPage == null || "".equals(currentPage)){
currentPage = "1";
}
// 如果每页显示记录数参数为空或者为空字符串,则将每页显示记录数设置为 8
if (rows == null || "".equals(rows)) {
//如果没有设置rows的请求参数此处自动设置
if (rows == null || "".equals(rows)){
rows = "8";
}
// 将当前页码的字符串类型转换为整数类型
//获取条件查询的参数
int currentPage1 = Integer.parseInt(currentPage);
// 将每页显示记录数的字符串类型转换为整数类型
int rows1 = Integer.parseInt(rows);
// 如果当前页码小于等于 0则将当前页码设置为 1
if (currentPage1 <= 0) {
//如果当前页数小于1则设置当前页数为1
if (currentPage1 <= 0){
currentPage1 = 1;
}
// 创建一个 PageBean 类型的对象,泛型为 StuPunch此处类型可能有误应是 TeaPunch用于封装分页信息和教师打卡信息
//设置StuPunch类的对象类型
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);
// 如果总记录数大于 0说明有符合条件的记录
if (totalCount > 0) {
// 计算总页数,如果总记录数能被每页记录数整除,则总页数为总记录数除以每页记录数,否则总页数为总记录数除以每页记录数再加 1
int totalPage = (totalCount % rows1) == 0 ? totalCount / rows1 : (totalCount / rows1 + 1);
// 设置 PageBean 对象的总页数属性
if (totalCount > 0){
//计算总页码,并设置
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 对象的当前页码属性
//重新设置当前页码
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()) {
// 创建一个新的 TeaPunch 对象
while (resultSet.next()){
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 {
// 无论是否出现异常,最后都调用 JDBCUtils 类的 close 方法关闭结果集
}finally {
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 {
// 如果总记录数为 0说明没有符合条件的记录将请求转发到 /view/alluse/nodata.jsp 页面
}else {
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);
}
}
}

@ -1,148 +1,101 @@
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 {
// 无论是否发生异常,都调用 JDBCUtils 类的 close 方法关闭结果集、预编译语句对象和数据库连接,释放资源
}finally {
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 {
// 无论是否发生异常,都调用 JDBCUtils 类的 close 方法关闭预编译语句对象和数据库连接,释放资源
}finally {
JDBCUtils.close(preparedStatement, connection);
}
// 返回受影响的行数
return num;
}
}
}

@ -1,148 +1,102 @@
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;
// 导入 java.sql 包下的 PreparedStatement 类,用于执行预编译的 SQL 语句,提高性能和安全性
import java.sql.ResultSet;
// 导入 java.sql 包下的 ResultSet 类,用于处理数据库查询返回的结果集
public class DeptAdminDao {
// 定义一个静态的 Connection 类型变量,用于存储数据库连接对象,初始化为 null
public class FrontWebDao {
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 {
// 无论是否发生异常,都调用 JDBCUtils 类的 close 方法关闭结果集、预编译语句对象和数据库连接,释放资源
}finally {
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 {
// 无论是否发生异常,都调用 JDBCUtils 类的 close 方法关闭预编译语句对象和数据库连接,释放资源
}finally {
JDBCUtils.close(preparedStatement, connection);
}
// 返回受影响的行数
return num;
}
}
}

@ -1,177 +1,101 @@
// 声明该类所在的包名为 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 {
// 无论是否发生异常,都调用 JDBCUtils 类的 close 方法关闭 ResultSet、PreparedStatement 和 Connection 对象
}finally {
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 {
// 无论是否发生异常,都调用 JDBCUtils 类的 close 方法关闭 PreparedStatement 和 Connection 对象
}finally {
JDBCUtils.close(preparedStatement, connection);
}
// 返回受影响的行数
return num;
}
}
}

@ -1,177 +1,101 @@
// 声明该类所属的包为 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 {
// 无论是否发生异常,都调用 JDBCUtils 类的 close 方法关闭 ResultSet、PreparedStatement 和 Connection 对象
}finally {
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 {
// 无论是否发生异常,都调用 JDBCUtils 类的 close 方法关闭 PreparedStatement 和 Connection 对象
}finally {
JDBCUtils.close(preparedStatement, connection);
}
// 返回受影响的行数
return num;
}
}
}

@ -1,155 +1,101 @@
// 声明该类所在的包为 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 {
// 调用 JDBCUtils 的方法关闭结果集、预编译语句和数据库连接,释放资源
}finally {
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 {
// 调用 JDBCUtils 的方法关闭预编译语句和数据库连接,释放资源
}finally {
JDBCUtils.close(preparedStatement, connection);
}
// 返回受影响的行数
return num;
}
}
}

@ -1,61 +1,43 @@
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 +
'}';
}
}
}

@ -1,133 +1,63 @@
// 声明该类所属的包为 com.entity包用于组织和管理 Java 类,避免命名冲突
package com.entity;
// 导入 java.util 包中的 ArrayList 类,用于存储每页的数据
import java.util.ArrayList;
/**
* PageBean
* @param <T>
*/
public class PageBean<T> {
// 定义一个整型变量 totalCount用于存储总记录数
private int totalCount;
// 定义一个整型变量 totalPage用于存储总页码数
private int totalPage;
// 定义一个泛型类型的 ArrayList 变量 arrayList用于存储每页的数据
private ArrayList<T> arrayList;
// 定义一个整型变量 currentPage用于存储当前页码
private int currentPage;
// 定义一个整型变量 rows用于存储每页显示的记录数
private int rows;
private int totalCount;//总记录数
private int totalPage;//总页码
private ArrayList<T> arrayList;//每页的数据
private int currentPage;//当前页码
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 +
'}';
}
}
}

@ -1,312 +1,145 @@
// 声明该类所属的包为 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 + '\'' +
'}';
}
}
}

@ -1,138 +1,91 @@
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 + '\'' +
@ -145,4 +98,4 @@ public class Student {
", spsw='" + spsw + '\'' +
'}';
}
}
}

@ -1,148 +1,110 @@
// 声明该类所属的包为 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{" +
@ -159,4 +121,4 @@ public class TeaPunch {
", tstatus='" + tstatus + '\'' +
'}';
}
}
}

@ -1,126 +1,81 @@
// 声明该类所属的包,通常用于存放实体类
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 + '\'' +
'}';
}
}
}

@ -1,96 +1,64 @@
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 +
@ -100,4 +68,4 @@ public class WebStu {
", sisdiagnoseNum=" + sisdiagnoseNum +
'}';
}
}
}

@ -1,96 +1,64 @@
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 +
@ -100,4 +68,4 @@ public class WebTea {
", tisdiagnoseNum=" + tisdiagnoseNum +
'}';
}
}
}

@ -1,61 +1,34 @@
// 声明该类所属的包为 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 中获取名为 "deptadno" 的属性值,该属性可能用于标识部门管理员是否已登录
//3.从获取session中获取user
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() {
// 目前该方法为空,可在需要时添加释放资源相关的代码
}
}
}

@ -1,76 +1,34 @@
// 声明该类所属的包为 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;
// 从当前请求的会话session中获取名为 "schoadno" 的属性值,
// 这里的 "schoadno" 可能是用于标识学校管理员登录状态的一个属性。
//3.从获取session中获取user
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() {
}
}
}

@ -1,56 +1,34 @@
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;
// 从当前请求的 session 中获取名为 "sno" 的属性值,这里假设 "sno" 是用于标识用户登录状态的信息
//3.从获取session中获取user
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() {
}
}
}

@ -1,49 +1,34 @@
// 声明该类所属的包表明该类是用于过滤相关功能的类属于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;
// 从当前请求的会话session中获取名为sno的属性值sno可能代表学生学号用于判断学生是否登录
//3.从获取session中获取user
Object sno = request.getSession().getAttribute("sno");
// 在控制台打印获取到的sno属性值用于调试查看是否成功获取该属性
System.out.println(sno);
// 判断获取到的sno属性值是否不为空若不为空则表示学生已登录
if (sno != null) {
// 如果学生已登录调用过滤器链的doFilter方法将请求和响应传递给下一个过滤器或目标资源即放行请求
if (sno != null){
//登录了,放行
filterChain.doFilter(servletRequest, servletResponse);
} else {
// 如果学生未登录使用请求的getRequestDispatcher方法获取一个请求转发器
// 将请求转发到/view/frontweb/stulogin.jsp页面即跳转到学生登录页面
}else {
//没有登录,跳转到登录页面
request.getRequestDispatcher("/view/frontweb/stulogin.jsp").forward(servletRequest, servletResponse);
}
}
// 重写destroy方法在过滤器销毁时调用这里为空实现目前没有在过滤器销毁时需要执行的清理操作
@Override
public void destroy() {
}
}
}

@ -1,49 +1,34 @@
// 声明该类所属的包,表明该类是一个过滤器类,通常用于处理请求和响应的过滤逻辑
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;
// 从当前请求的会话session中获取名为tno的属性值tno可能代表教师编号用于判断用户是否登录
//3.从获取session中获取user
Object tno = request.getSession().getAttribute("tno");
// 在控制台打印获取到的tno属性值用于调试
System.out.println(tno);
// 判断获取到的tno属性值是否不为空若不为空则表示用户已登录
if (tno != null) {
// 如果用户已登录调用过滤器链的doFilter方法将请求和响应传递给下一个过滤器或目标资源即放行请求
if (tno != null){
//登录了,放行
filterChain.doFilter(servletRequest, servletResponse);
} else {
// 如果用户未登录使用请求的getRequestDispatcher方法获取一个请求转发器
// 将请求转发到/view/frontweb/tealogin.jsp页面即跳转到教师登录页面
}else {
//没有登录,跳转到登录页面
request.getRequestDispatcher("/view/frontweb/tealogin.jsp").forward(servletRequest, servletResponse);
}
}
// 重写destroy方法在过滤器销毁时调用这里为空实现未做任何清理操作
@Override
public void destroy() {
}
}
}

@ -1,58 +1,34 @@
// 声明该类所在的包为 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;
// 从当前请求的会话session中获取名为 "tno" 的属性值,
// 这里假设 "tno" 是用于标识教师登录状态的属性
//3.从获取session中获取user
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 {
// 用户未登录,使用请求转发将请求转发到 "/view/frontweb/tealogin.jsp" 页面,
// 即跳转到教师登录页面,让用户进行登录操作
}else {
//没有登录,跳转到登录页面
request.getRequestDispatcher("/view/frontweb/tealogin.jsp").forward(servletRequest, servletResponse);
}
}
// 重写 destroy 方法,该方法在过滤器销毁时被调用,
// 通常用于释放初始化时创建的资源。
// 这里为空实现,可能不需要在销毁时进行特殊操作
@Override
public void destroy() {
}
}
}

Loading…
Cancel
Save