4 #10

Closed
pxake4hfp wants to merge 5 commits from ljc into master

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

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

@ -14,62 +14,69 @@ import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.sql.ResultSet;
/**
* Servlet
* (//)
*/
@WebServlet("/LoginServlet")
public class LoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求和响应的字符编码,防止中文乱码
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
// 从请求参数中获取用户输入的用户名、密码和身份
String userName = req.getParameter("userName");
String psw = req.getParameter("psw");
String identity = req.getParameter("identity1");
// 打印日志用于调试
System.out.println(userName);
System.out.println(psw);
System.out.println(identity);
// 根据用户选择的身份进行不同的验证逻辑
if (identity.equals("学生")){//学生身份
boolean flag = false;
String sql = "select * from student where sname = ? and spsw = ?";
Object[] objects = {userName, psw};
ResultSet resultSet = StuDao.login(sql, objects);
String sno = null;
boolean flag = false; // 标记是否验证成功
String sql = "select * from student where sname = ? and spsw = ?"; // SQL查询语句
Object[] objects = {userName, psw}; // SQL查询参数
ResultSet resultSet = StuDao.login(sql, objects); // 执行数据库查询
String sno = null; // 学生学号
try {
if (resultSet.next()){
flag = true;
sno = resultSet.getString("sno");
if (resultSet.next()){ // 如果查询结果不为空
flag = true; // 验证成功
sno = resultSet.getString("sno"); // 获取学生学号
}
} catch (Exception e) {
e.printStackTrace();
e.printStackTrace(); // 打印异常堆栈信息
}finally {
JdbcUtils.close(resultSet);
JdbcUtils.close(resultSet); // 关闭结果集,释放资源
}
if (flag){
if (flag){ // 验证成功
System.out.println("登录成功!");
//创建会话,处理请求要用
// 创建会话,存储用户信息
HttpSession session = req.getSession();
session.setAttribute("userName", userName);
// 创建请求属性对象,处理请求要用
session.setAttribute("sno", sno);
session.setAttribute("userName", userName); // 存储用户名
session.setAttribute("sno", sno); // 存储学号
System.out.println(sno);
// 设置跳转信息并转发到提示页面
req.setAttribute("httpUrl","/view/stu/stumainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至后台首页!");
req.setAttribute("title","登录成功");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
// resp.sendRedirect(req.getContextPath() + "/view/stu/stumainview.jsp");
}else {
}else { // 验证失败
System.out.println("用户名或密码错误!请重新登录!");
//返回登录成功的信息
// 设置错误信息并转发到提示页面
req.setAttribute("httpUrl","/view/login/login.jsp");
req.setAttribute("info", "登录失败!用户名或密码错误!即将跳转至登录页面!");
req.setAttribute("title","登录失败");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
}
}else
if (identity.equals("教师")){//教师身份
}else if (identity.equals("教师")){//教师身份
boolean flag = false;
String sql = "select * from teacher where tname = ? and tpsw = ?";
Object[] objects = {userName, psw};
@ -87,13 +94,13 @@ public class LoginServlet extends HttpServlet {
}
if (flag){
System.out.println("登录成功!");
//创建会话,处理请求要用
// 创建会话,存储用户信息
HttpSession session = req.getSession();
session.setAttribute("userName", userName);
// 创建请求属性对象,处理请求要用
session.setAttribute("tno", tno);
System.out.println(tno);
// 设置跳转信息并转发到提示页面
req.setAttribute("httpUrl","/view/tea/teamainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至后台首页!");
req.setAttribute("title","登录成功");
@ -101,72 +108,68 @@ public class LoginServlet extends HttpServlet {
// resp.sendRedirect(req.getContextPath() + "/view/guide/mainview_guide.jsp");
}else {
System.out.println("用户名或密码错误!请重新登录!");
//返回登录成功的信息
// 设置错误信息并转发到提示页面
req.setAttribute("httpUrl","/view/login/login.jsp");
req.setAttribute("info", "登录失败!用户名或密码错误!即将跳转至登录页面!");
req.setAttribute("title","登录失败");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
}
}else {//如果是管理员
boolean flag = false;
String sql = "select * from admin where adname = ? and adpsw = ? and belong = ?";
Object[] objects = {userName, psw, identity};
ResultSet resultSet = SchoAdminDao.login(sql, objects);
// String belong = null;
try {
if (resultSet.next()){
flag = true;
// belong = resultSet.getString("belong");
}
} catch (Exception e) {
e.printStackTrace();
}finally {
JdbcUtils.close(resultSet);
boolean flag = false;
String sql = "select * from admin where adname = ? and adpsw = ? and belong = ?";
Object[] objects = {userName, psw, identity};
ResultSet resultSet = SchoAdminDao.login(sql, objects);
try {
if (resultSet.next()){
flag = true;
}
} catch (Exception e) {
e.printStackTrace();
}finally {
JdbcUtils.close(resultSet);
}
if (flag){
if (identity.equals("学校")){//学校管理员
System.out.println("登录成功!");
HttpSession session = req.getSession();
// 创建会话属性对象,处理请求要用
session.setAttribute("belong", identity);
System.out.println(identity);
// session.setAttribute("belong", belong);
// System.out.println(belong);
if (flag){ // 管理员验证成功
req.setAttribute("httpUrl","/view/schoadmin/schomainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至后台首页!");
req.setAttribute("title","登录成功");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
}else {//二级学院管理员
System.out.println("登录成功!");
//创建会话,处理请求要用
HttpSession session = req.getSession();
// 创建请求属性对象,处理请求要用
session.setAttribute("belong", identity);
System.out.println(identity);
if (identity.equals("学校")){//学校管理员
System.out.println("登录成功!");
HttpSession session = req.getSession();
session.setAttribute("belong", identity); // 存储管理员所属单位
System.out.println(identity);
req.setAttribute("httpUrl","/view/deptadmin/deptmainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至后台首页!");
req.setAttribute("title","登录成功");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
// resp.sendRedirect(req.getContextPath() + "/view/guide/mainview_guide.jsp");
}
// 设置跳转信息并转发到提示页面
req.setAttribute("httpUrl","/view/schoadmin/schomainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至后台首页!");
req.setAttribute("title","登录成功");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
}else {//二级学院管理员
System.out.println("登录成功!");
// 创建会话,存储用户信息
HttpSession session = req.getSession();
session.setAttribute("belong", identity);
System.out.println(identity);
}else {
System.out.println("用户名或密码错误!请重新登录!");
//返回登录成功的信息
req.setAttribute("httpUrl","/view/login/login.jsp");
req.setAttribute("info", "登录失败!用户名或密码错误!即将跳转至登录页面!");
req.setAttribute("title","登录失败");
// 设置跳转信息并转发到提示页面
req.setAttribute("httpUrl","/view/deptadmin/deptmainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至后台首页!");
req.setAttribute("title","登录成功");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
// resp.sendRedirect(req.getContextPath() + "/view/guide/mainview_guide.jsp");
}
}else {
System.out.println("用户名或密码错误!请重新登录!");
// 设置错误信息并转发到提示页面
req.setAttribute("httpUrl","/view/login/login.jsp");
req.setAttribute("info", "登录失败!用户名或密码错误!即将跳转至登录页面!");
req.setAttribute("title","登录失败");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
}
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
doGet(req, resp); // 对于POST请求直接调用doGet方法处理
}
}
}

@ -11,43 +11,53 @@ import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* Servlet
* ID
*/
@WebServlet("/DelNewsServlet")
public class DelNewsServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求和响应的字符编码,防止中文乱码
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
// 从请求参数中获取要删除的新闻ID
String nid = req.getParameter("nid");
int nid1 = Integer.parseInt(nid);
int nid1 = Integer.parseInt(nid); // 将字符串类型的ID转换为整数
// 打印日志用于调试
System.out.println(nid1);
String sql = null;
String sql = null; // SQL语句变量
// 第一步:检查新闻是否存在
sql = "select count(*) as num from news where nid = ?";
Object[] objects = {nid1};
int num = FrontWebDao.findTotalCount(sql, objects);
Object[] objects = {nid1}; // SQL查询参数
int num = FrontWebDao.findTotalCount(sql, objects); // 执行查询,获取新闻数量
System.out.println(num);
if (num > 0){//有则删除
if (num > 0){ // 如果新闻存在,则执行删除操作
sql = "delete from news where nid = ?";
Object[] objects1 = {nid1};
int num1 = FrontWebDao.executeUpdate(sql, objects1);
if (num1 > 0){
int num1 = FrontWebDao.executeUpdate(sql, objects1); // 执行删除操作
if (num1 > 0){ // 删除成功
// 通过JavaScript弹出提示框并关闭当前窗口
resp.getWriter().write("<script>alert('删除成功!'); window.location='" + req.getContextPath() + "/view/frontweb/delnews.jsp';" + "window.close();</script>");
}else {
}else { // 删除失败(可能是数据库操作异常)
resp.getWriter().write("<script>alert('删除失败!'); window.location='" + req.getContextPath() + "/view/frontweb/delnews.jsp';" + "window.close();</script>");
}
}else {//否则不能删除
}else { // 新闻不存在,不能删除
resp.getWriter().write("<script>alert('删除失败!不存在此新闻编号!'); window.location='" + req.getContextPath() + "/view/frontweb/delnews.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req, resp);
this.doGet(req, resp); // 对于POST请求直接调用doGet方法处理
}
}
}

@ -10,37 +10,46 @@ import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
/**
* Servlet
*
*/
@WebServlet("/DeptAdmAlterPswServlet")
public class DeptAdmAlterPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求和响应的字符编码,防止中文乱码
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
// 从会话中获取管理员编号(标识当前登录用户)
HttpSession session = req.getSession();
String adno = (String) session.getAttribute("adno");
// 从请求参数中获取用户输入的新密码和确认密码
String adpsw = req.getParameter("adpsw");
String adpsw1 = req.getParameter("adpsw1");
//判断两次密码是否相同
if (adpsw.equals(adpsw1)){//相同则进行修改操作
String sql = "update admin set adpsw = ? where adno = ?";
Object[] objects = {adpsw, adno};
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 判断两次输入的密码是否相同
if (adpsw.equals(adpsw1)){// 相同则进行修改操作
String sql = "update admin set adpsw = ? where adno = ?"; // SQL更新语句
Object[] objects = {adpsw, adno}; // SQL参数新密码和管理员编号
int num = FrontWebDao.executeUpdate(sql, objects); // 执行数据库更新操作
if (num > 0){ // 更新成功
// 提示用户修改成功并要求重新登录
resp.getWriter().write("<script>alert('修改密码成功!请重新登录!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmlogin.jsp';" + "window.close();</script>");
}else {
}else { // 更新失败(可能是数据库操作异常)
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmalterpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {// 两次密码不同,提示用户重新输入
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmalterpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req, resp);
this.doGet(req, resp); // 对于POST请求直接调用doGet方法处理
}
}
}

@ -9,36 +9,45 @@ import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* Servlet
*
*/
@WebServlet("/DeptAdmForgetPswServlet")
public class DeptAdmForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求和响应的字符编码,防止中文乱码
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
// 从请求参数中获取管理员编号(用户输入的需要重置密码的账号)
String adno = req.getParameter("adno");
// 从请求参数中获取用户输入的新密码和确认密码
String adpsw = req.getParameter("adpsw");
String adpsw1 = req.getParameter("adpsw1");
//判断两次密码是否相同
if (adpsw.equals(adpsw1)){//相同则进行修改操作
String sql = "update admin set adpsw = ? where adno = ?";
Object[] objects = {adpsw, adno};
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 判断两次输入的密码是否相同
if (adpsw.equals(adpsw1)){// 相同则进行修改操作
String sql = "update admin set adpsw = ? where adno = ?"; // SQL更新语句
Object[] objects = {adpsw, adno}; // SQL参数新密码和管理员编号
int num = FrontWebDao.executeUpdate(sql, objects); // 执行数据库更新操作
if (num > 0){ // 更新成功
// 提示用户修改成功并跳转到登录页面
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmlogin.jsp';" + "window.close();</script>");
}else {
}else { // 更新失败(可能是管理员编号不存在或数据库操作异常)
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {// 两次密码不同,提示用户重新输入
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req, resp);
this.doGet(req, resp); // 对于POST请求直接调用doGet方法处理
}
}
}

@ -7,58 +7,80 @@ import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.sql.ResultSet;
@WebServlet("/DeptAdmLoginServlet")
public class DeptAdmLoginServlet extends HttpServlet {
/**
* Servlet
*
*/
@WebServlet("/DeptAdmForgetPswServlet")
public class DeptAdmForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求和响应的字符编码,防止中文乱码
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
//获取表单请求个参数
// 从请求参数中获取管理员编号(用户输入的需要重置密码的账号)
String adno = req.getParameter("adno");
// 从请求参数中获取用户输入的新密码和确认密码
String adpsw = req.getParameter("adpsw");
String belong = req.getParameter("belong");
System.out.println(belong);
String adpsw1 = req.getParameter("adpsw1");
// 输入验证:检查参数是否为空
if (adno == null || adpsw == null || adpsw1 == null) {
resp.getWriter().write("<script>alert('参数不能为空!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
return;
}
// 判断两次输入的密码是否相同
if (adpsw.equals(adpsw1)){// 相同则进行修改操作
// 验证密码强度示例至少8位包含字母和数字
if (!isPasswordValid(adpsw)) {
resp.getWriter().write("<script>alert('密码强度不足至少8位包含字母和数字'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
return;
}
String sql = "select * from admin where adno = ? and adpsw = ? and belong = ?";
Object[] objects = {adno, adpsw, belong};
ResultSet resultSet = FrontWebDao.login(sql, objects);
//判断密码和账号是否正确
try {
if (resultSet.next()){
// 创建会话属性对象,后面处理请求要用
HttpSession session = req.getSession();
session.setAttribute("adno", adno);
session.setAttribute("belong", belong);
session.setAttribute("deptadno", adno);
String sql = "update admin set adpsw = ? where adno = ?"; // SQL更新语句
Object[] objects = {adpsw, adno}; // SQL参数新密码和管理员编号
System.out.println("登陆成功!");
req.setAttribute("httpUrl","/view/deptadmin/deptmainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至二级学院管理员后台首页!");
req.setAttribute("title","登录成功");
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
// 验证管理员是否存在
if (!isAdminExists(adno)) {
resp.getWriter().write("<script>alert('管理员账号不存在!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
return;
}
int num = FrontWebDao.executeUpdate(sql, objects); // 执行数据库更新操作
}else {
System.out.println("用户名或密码错误!请重新登录!");
//返回登录成功的信息
req.setAttribute("httpUrl","/view/frontweb/deptadmlogin.jsp");
req.setAttribute("info", "登录失败!管理员账号或密码错误!即将跳转至登录页面!");
req.setAttribute("title","登录失败");
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
if (num > 0){ // 更新成功
// 提示用户修改成功并跳转到登录页面
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmlogin.jsp';" + "window.close();</script>");
}else { // 更新失败
resp.getWriter().write("<script>alert('修改密码失败!请联系管理员'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
}
} catch (Exception e) {
e.printStackTrace();
}else {// 两次密码不同,提示用户重新输入
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req, resp);
this.doGet(req, resp); // 对于POST请求直接调用doGet方法处理
}
// 验证管理员是否存在
private boolean isAdminExists(String adno) {
String sql = "select count(*) as num from admin where adno = ?";
Object[] params = {adno};
int count = FrontWebDao.findTotalCount(sql, params);
return count > 0;
}
// 验证密码强度
private boolean isPasswordValid(String password) {
// 至少8位包含字母和数字
return password.matches("^(?=.*[A-Za-z])(?=.*\\d).{8,}$");
}
}
}

@ -1,375 +1,112 @@
package com.controller.frontweb;
import com.dao.FrontWebDao;
import com.entity.News;
import com.entity.WebStu;
import com.entity.WebTea;
import com.utils.ChartUtils;
import org.jfree.chart.ChartColor;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.CategoryAxis;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.block.BlockBorder;
import org.jfree.chart.labels.StandardCategoryItemLabelGenerator;
import org.jfree.chart.labels.StandardPieSectionLabelGenerator;
import org.jfree.chart.plot.CategoryPlot;
import org.jfree.chart.plot.PiePlot3D;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.renderer.category.BarRenderer;
import org.jfree.chart.servlet.ServletUtilities;
import org.jfree.chart.title.TextTitle;
import org.jfree.data.category.DefaultCategoryDataset;
import org.jfree.data.general.DefaultPieDataset;
import org.jfree.ui.RectangleEdge;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.awt.*;
import java.io.IOException;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
@WebServlet("/FrontWebServlet")
public class FrontWebServlet extends HttpServlet {
/**
* Servlet
*
*/
@WebServlet("/DeptAdmForgetPswServlet")
public class DeptAdmForgetPswServlet extends HttpServlet {
@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 sql = null;
HashMap<String, Object> hashMap = new HashMap<String, Object>();
HttpSession session = req.getSession();
String str = "是";
Object[] objects = {str};
//计算学生已经打卡
sql = "select count(*) as num from stupunchin where sispunch = ?";
int stuPunNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(stuPunNum);
//计算教师已经打卡
sql = "select count(*) as num from teapunchin where tispunch = ?";
int teaPunNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(teaPunNum);
//总打卡数
int allPunNum = teaPunNum + stuPunNum;
System.out.println(allPunNum);
//设置请求的变量属性
req.setAttribute("allPunNum", allPunNum);
//计算学生发烧
sql = "select count(*) as num from stupunchin where sishot = ?";
int stuHotNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(stuHotNum);
//计算教师发烧
sql = "select count(*) as num from teapunchin where tishot = ?";
int teaHotNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(teaHotNum);
//总发烧
int allHotNum = teaHotNum + stuHotNum;
System.out.println(allHotNum);
hashMap.put("发烧", allHotNum);
//设置请求的变量属性
req.setAttribute("allHotNum", allHotNum);
//计算学生咳嗽
sql = "select count(*) as num from stupunchin where siscough = ?";
int stuCoughNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(stuCoughNum);
//计算教师咳嗽
sql = "select count(*) as num from teapunchin where tiscough = ?";
int teaCoughNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(teaCoughNum);
//总咳嗽
int allCoughNum = teaCoughNum + stuCoughNum;
System.out.println(allCoughNum);
hashMap.put("咳嗽", allCoughNum);
//设置请求的变量属性
req.setAttribute("allCoughNum", allCoughNum);
//计算学生疑似病例
sql = "select count(*) as num from stupunchin where sisseem = ?";
int stuSeemNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(stuSeemNum);
//计算教师疑似病例
sql = "select count(*) as num from teapunchin where tisseem = ?";
int teaSeemNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(teaSeemNum);
//总疑似病例
int allSeemNum = stuSeemNum + teaSeemNum;
System.out.println(allSeemNum);
hashMap.put("疑似病例", allSeemNum);
//设置请求的变量属性
req.setAttribute("allSeemNum", allSeemNum);
//计算学生确诊病例
sql = "select count(*) as num from stupunchin where sisdiagnose = ?";
int stuDiagNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(stuDiagNum);
//计算教师确诊病例
sql = "select count(*) as num from teapunchin where tisdiagnose = ?";
int teaDiagNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(teaDiagNum);
//总确诊病例
int allDiagNum = stuDiagNum + teaDiagNum;
System.out.println(allDiagNum);
hashMap.put("确诊病例", allDiagNum);
//设置请求的变量属性
req.setAttribute("allDiagNum", allDiagNum);
//计算学生异常
str = "异常";
Object[] objects1 = {str};
sql = "select count(*) as num from stupunchin where sstatus = ?";
int sStatusNum = FrontWebDao.findTotalCount(sql, objects1);
System.out.println(sStatusNum);
//计算教师异常
sql = "select count(*) as num from teapunchin where tstatus = ?";
int tStatusNum = FrontWebDao.findTotalCount(sql, objects1);
System.out.println(tStatusNum);
//总异常
int allStatusNum = tStatusNum + sStatusNum;
System.out.println(allStatusNum);
hashMap.put("健康异常", allStatusNum);
//设置请求的变量属性
req.setAttribute("allStatusNum", allStatusNum);
//计算状态正常
int normalNum = allPunNum - allStatusNum;
System.out.println(normalNum);
hashMap.put("健康正常", normalNum);
//创建饼状图
//实例化核心类对象
DefaultPieDataset dataset = new DefaultPieDataset();
//法2用iterator遍历key
Iterator<String> iterator = hashMap.keySet().iterator();
while (iterator.hasNext()){
String key = iterator.next();
dataset.setValue(key, (Number) hashMap.get(key));
System.out.println(key+ ":" + (Number) hashMap.get(key));
}
//创建饼状图
JFreeChart chart = ChartFactory.createPieChart3D("各情况占比分析", dataset, true, true, true);
//无背景色
chart.setBackgroundPaint(null);
/*//处理主标题的乱码
chart.getTitle().setFont(new Font("宋体",Font.BOLD,18));
//处理子标题乱码
chart.getLegend().setItemFont(new Font("宋体",Font.BOLD,15));
//获取图表区域对象
PiePlot3D categoryPlot = (PiePlot3D)chart.getPlot();
//设置背景透明度
categoryPlot.setBackgroundAlpha(0);
//设置饼图透明度
categoryPlot.setForegroundAlpha(0.7f);
// 去除背景边框线
categoryPlot.setOutlinePaint(null);
//处理图像上的乱码
categoryPlot.setLabelFont(new Font("宋体",Font.BOLD,15));
//设置图形的生成格式为(张三 23 10%))(姓名 值 百分比)
String fm = "{0} {1} ({2})";
categoryPlot.setLabelGenerator(new StandardPieSectionLabelGenerator(fm));*/
// 设置抗锯齿,防止字体显示不清楚
ChartUtils.setAntiAlias(chart);// 抗锯齿
// 对柱子进行渲染[创建不同图形]
ChartUtils.setPieRender(chart.getPlot());
// plot.setSimpleLabels(true);//简单标签,不绘制线条
// plot.setLabelGenerator(null);//不显示数字
// 设置标注无边框
chart.getLegend().setFrame(new BlockBorder(Color.WHITE));
// 标注位于右侧
chart.getLegend().setPosition(RectangleEdge.RIGHT);
String filename = ServletUtilities.saveChartAsPNG(chart, 500, 300, null, session);
String graphUrl = req.getContextPath() + "/DisplayChart?filename=" + filename;
req.setAttribute("graphUrl", graphUrl);
//创建柱形图
//实例化核心类对象
DefaultCategoryDataset dataset1 = new DefaultCategoryDataset();
//设置图表值
dataset1.addValue(stuHotNum, "学生", "发烧");
dataset1.addValue(teaHotNum, "教师", "发烧");
dataset1.addValue(stuCoughNum, "学生", "咳嗽");
dataset1.addValue(teaCoughNum, "教师", "咳嗽");
dataset1.addValue(stuSeemNum, "学生", "疑似病例");
dataset1.addValue(teaSeemNum, "教师", "疑似病例");
dataset1.addValue(stuDiagNum, "学生", "确诊病例");
dataset1.addValue(teaDiagNum, "教师", "确诊病例");
dataset1.addValue(sStatusNum, "学生", "健康异常");
dataset1.addValue(tStatusNum, "教师", "健康异常");
//生成柱形图
JFreeChart chart1 = ChartFactory.createBarChart("学生和教师情况统计", // 图表标题
null, // x轴的显示标签
"个体数目", // y轴的显示标签
dataset1, // 数据
PlotOrientation.VERTICAL, // 图表方向:水平、垂直
true, // 显示图例
true, // 生成工具
true // URL链接
);
// 对整个图形设置整个柱状图的颜色和文字针
/* chart1.setBackgroundPaint(null);
// chart.setBackgroundPaint(ChartColor.WHITE); // 设置总的背景颜色
// 获得图形对象,并通过此对象对图形的颜色文字进行设置
CategoryPlot polt = chart1.getCategoryPlot();// 获得图表对象
polt.setBackgroundPaint(ChartColor.lightGray);// 图形背景颜色
polt.setRangeGridlinePaint(ChartColor.WHITE);// 图形表格颜色
// 设置柱宽度
BarRenderer renderer = (BarRenderer) polt.getRenderer();
renderer.setMaximumBarWidth(0.06);
renderer.setBaseItemLabelGenerator(new StandardCategoryItemLabelGenerator());
renderer.setBaseItemLabelsVisible(true);
renderer.setBaseItemLabelFont(new Font("宋体", Font.BOLD, 15));
// 图形设置标题文字
TextTitle textTitle = chart1.getTitle();
textTitle.setFont(new Font("宋体", Font.BOLD, 20));
// 设置图形X轴坐标文字
CategoryPlot plot = (CategoryPlot) chart1.getPlot();
CategoryAxis axis = plot.getDomainAxis();
axis.setLabelFont(new Font("宋体", Font.BOLD, 22)); // 设置X轴坐标上标题的文字
axis.setTickLabelFont(new Font("宋体", Font.BOLD, 15)); // 设置X轴坐标上的文字
// 设置图形Y轴坐标文字
ValueAxis valueAxis = plot.getRangeAxis();
valueAxis.setLabelFont(new Font("宋体", Font.BOLD, 12)); // 设置Y轴坐标上标题的文字
valueAxis.setTickLabelFont(new Font("sans-serif", Font.BOLD, 12));// 设置Y轴坐标上的文字
// 设置提示内容的文字
chart1.getLegend().setItemFont(new Font("宋体", Font.BOLD, 15));*/
// 设置抗锯齿,防止字体显示不清楚
ChartUtils.setAntiAlias(chart1);// 抗锯齿
// 对柱子进行渲染
ChartUtils.setBarRenderer(chart1.getCategoryPlot(), false);//
// 对其他部分进行渲染
ChartUtils.setXAixs(chart1.getCategoryPlot());// X坐标轴渲染
ChartUtils.setYAixs(chart1.getCategoryPlot());// Y坐标轴渲染
// 设置标注无边框
chart1.getLegend().setFrame(new BlockBorder(Color.WHITE));
//无背景色
chart1.setBackgroundPaint(null);
String filename1 = ServletUtilities.saveChartAsPNG(chart1, 500, 300, null, session);
String graphUrl1 = req.getContextPath() + "/DisplayChart?filename=" + filename1;
req.setAttribute("graphUrl1", graphUrl1);
String[] depts = {"马克思主义学院", "文学与传媒学院", "法政学院", "外国语学院", "教育科学学院", "信息工程学院", "数学与统计学院",
"物理科学与技术学院", "机电工程学院", "化学化工学院", "生命与科学学院", "商学院", "体育科学学院", "美术与设计学院",
"音乐与舞蹈学院", "创新创业教育学院", "教师教育学院", "基础教育学院"};
//学生表格处理
ArrayList<WebStu> webStuArrayList = new ArrayList<WebStu>();
System.out.println(depts.length);
for (int i = 0; i < depts.length; i++) {
WebStu webStu = new WebStu();
String dept = depts[i];
webStu.setSdept(dept);
sql = "select count(*) as num from student s, stupunchin sp where s.sno = sp.sno and s.sdept= ? and sp.sishot = ?";
Object[] obj2 = {dept, "是"};
int tbStuHotNum = FrontWebDao.findTotalCount(sql, obj2);
webStu.setSishotNum(tbStuHotNum);
sql = "select count(*) as num from student s, stupunchin sp where s.sno = sp.sno and s.sdept= ? and sp.siscough = ?";
int tbStuCoughNum = FrontWebDao.findTotalCount(sql, obj2);
webStu.setSiscoughNum(tbStuCoughNum);
sql = "select count(*) as num from student s, stupunchin sp where s.sno = sp.sno and s.sdept= ? and sp.sisseem = ?";
int tbStuSeemNum = FrontWebDao.findTotalCount(sql, obj2);
webStu.setSisseemNum(tbStuSeemNum);
sql = "select count(*) as num from student s, stupunchin sp where s.sno = sp.sno and s.sdept= ? and sp.sisdiagnose = ?";
int tbStuDiagNum = FrontWebDao.findTotalCount(sql, obj2);
webStu.setSisdiagnoseNum(tbStuDiagNum);
sql = "select count(*) as num from student s, stupunchin sp where s.sno = sp.sno and s.sdept= ? and sp.sstatus = ?";
Object[] obj3 = {dept, "异常"};
int tbStuStatusNum = FrontWebDao.findTotalCount(sql, obj3);
webStu.setSstatusNum(tbStuStatusNum);
webStuArrayList.add(webStu);
}
System.out.println(webStuArrayList);
req.setAttribute("webStuArrayList", webStuArrayList);
//教师表格
ArrayList<WebTea> webTeaArrayList = new ArrayList<WebTea>();
for (int i = 0; i < depts.length; i++) {
WebTea webTea = new WebTea();
String dept = depts[i];
webTea.setTdept(dept);
sql = "select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tdept= ? and tp.tishot = ?";
Object[] obj2 = {dept, "是"};
int tbTeaHotNum = FrontWebDao.findTotalCount(sql, obj2);
webTea.setTishotNum(tbTeaHotNum);
sql = "select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tdept= ? and tp.tiscough = ?";
int tbTeaCoughNum = FrontWebDao.findTotalCount(sql, obj2);
webTea.setTiscoughNum(tbTeaCoughNum);
sql = "select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tdept= ? and tp.tisseem = ?";
int tbTeaSeemNum = FrontWebDao.findTotalCount(sql, obj2);
webTea.setTisseemNum(tbTeaSeemNum);
sql = "select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tdept= ? and tp.tisdiagnose = ?";
int tbTeaDiagNum = FrontWebDao.findTotalCount(sql, obj2);
webTea.setTisdiagnoseNum(tbTeaDiagNum);
sql = "select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tdept= ? and tp.tstatus = ?";
Object[] obj3 = {dept, "异常"};
int tbTeaStatusNum = FrontWebDao.findTotalCount(sql, obj3);
webTea.setTstatusNum(tbTeaStatusNum);
webTeaArrayList.add(webTea);
// 从请求参数中获取管理员编号(用户输入的需要重置密码的账号)
String adno = req.getParameter("adno");
// 从请求参数中获取用户输入的新密码
String adpsw = req.getParameter("adpsw");
// 从请求参数中获取用户输入的确认密码
String adpsw1 = req.getParameter("adpsw1");
// 输入验证:检查获取到的管理员编号、新密码、确认密码参数是否为空
if (adno == null || adpsw == null || adpsw1 == null) {
// 如果参数为空通过响应输出一段JavaScript代码弹出提示框显示“参数不能为空
// 并将页面重定向到密码重置页面(/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('参数不能为空!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前方法的执行
return;
}
System.out.println(webTeaArrayList);
req.setAttribute("webTeaArrayList", webTeaArrayList);
// 判断两次输入的密码是否相同
if (adpsw.equals(adpsw1)){// 相同则进行修改操作
// 调用isPasswordValid方法验证密码强度示例至少8位包含字母和数字
if (!isPasswordValid(adpsw)) {
// 如果密码强度不足通过响应输出一段JavaScript代码弹出提示框显示“密码强度不足至少8位包含字母和数字”
// 并将页面重定向到密码重置页面(/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('密码强度不足至少8位包含字母和数字'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前方法的执行
return;
}
//实时播报
sql = "select * from news order by nid desc limit 7";
Object[] objects2 = {};
ArrayList<News> newsArrayList = new ArrayList<News>();
// 构造SQL更新语句用于更新管理员表中指定管理员编号的密码
String sql = "update admin set adpsw = ? where adno = ?";
// 设置SQL语句的参数第一个参数为新密码第二个参数为管理员编号
Object[] objects = {adpsw, adno};
// 调用isAdminExists方法验证管理员是否存在
if (!isAdminExists(adno)) {
// 如果管理员账号不存在通过响应输出一段JavaScript代码弹出提示框显示“管理员账号不存在
// 并将页面重定向到密码重置页面(/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('管理员账号不存在!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前方法的执行
return;
}
ResultSet resultSet = FrontWebDao.qureyInfo(sql, objects2);
try {
while (resultSet.next()){
News news = new News();
news.setTitle(resultSet.getString("title"));
news.setUrl(resultSet.getString("url"));
news.setPubdate(resultSet.getDate("pubdate"));
newsArrayList.add(news);
System.out.println(news);
// 调用FrontWebDao的executeUpdate方法执行SQL更新语句返回受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
// 如果受影响的行数大于0说明更新成功
if (num > 0){
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码成功请登录
// 并将页面重定向到部门管理员登录页面(/view/frontweb/deptadmlogin.jsp同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmlogin.jsp';" + "window.close();</script>");
}else { // 如果受影响的行数不大于0说明更新失败
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码失败请联系管理员”
// 并将页面重定向到密码重置页面(/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('修改密码失败!请联系管理员'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
}
} catch (Exception e) {
e.printStackTrace();
}else {// 如果两次密码不同
// 通过响应输出一段JavaScript代码弹出提示框显示“两次密码不一样!请重新输入密码!”
// 并将页面重定向到密码重置页面(/view/frontweb/deptadmforgetpsw.jsp同时关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';" + "window.close();</script>");
}
System.out.println(newsArrayList);
req.setAttribute("newsArrayList", newsArrayList);
req.getRequestDispatcher("/view/frontweb/mainweb.jsp").forward(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 对于POST请求直接调用doGet方法进行处理
this.doGet(req, resp);
}
}
// 验证管理员是否存在的私有方法
private boolean isAdminExists(String adno) {
// 构造SQL查询语句统计管理员表中指定管理员编号的记录数量
String sql = "select count(*) as num from admin where adno = ?";
// 设置SQL语句的参数为管理员编号
Object[] params = {adno};
// 调用FrontWebDao的findTotalCount方法执行SQL查询语句获取记录数量
int count = FrontWebDao.findTotalCount(sql, params);
// 如果记录数量大于0返回true否则返回false
return count > 0;
}
// 验证密码强度的私有方法
private boolean isPasswordValid(String password) {
// 使用正则表达式判断密码是否至少8位并且包含字母和数字
return password.matches("^(?=.*[A-Za-z])(?=.*\\d).{8,}$");
}
}

@ -1,7 +1,6 @@
package com.controller.frontweb;
import com.dao.FrontWebDao;
import com.entity.News;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
@ -9,47 +8,118 @@ import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.sql.ResultSet;
import java.util.ArrayList;
@WebServlet("/MoreNewsServlet")
public class MoreNewsServlet extends HttpServlet {
/**
* Servlet
*
*/
@WebServlet("/DeptAdmForgetPswServlet")
public class DeptAdmForgetPswServlet extends HttpServlet {
@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 sql = "select * from news";
Object[] objects = {};
// 从HTTP请求的参数中获取名为"adno"的参数值,该值代表管理员编号(用户输入的需要重置密码的账号)
String adno = req.getParameter("adno");
ArrayList<News> newsArrayList = new ArrayList<News>();
// 从HTTP请求的参数中获取名为"adpsw"的参数值,该值代表用户输入的新密码
String adpsw = req.getParameter("adpsw");
// 从HTTP请求的参数中获取名为"adpsw1"的参数值,该值代表用户输入的用于确认的新密码
String adpsw1 = req.getParameter("adpsw1");
ResultSet resultSet = FrontWebDao.qureyInfo(sql, objects);
// 进行输入验证检查获取到的管理员编号、新密码、确认密码这三个参数是否有任何一个为null
if (adno == null || adpsw == null || adpsw1 == null) {
// 如果存在参数为null的情况通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“参数不能为空!”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('参数不能为空!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前doGet方法的执行不再继续后续操作
return;
}
try {
while (resultSet.next()){
News news = new News();
news.setTitle(resultSet.getString("title"));
news.setUrl(resultSet.getString("url"));
news.setPubdate(resultSet.getDate("pubdate"));
newsArrayList.add(news);
System.out.println(news);
// 判断用户输入的新密码和确认密码是否相等
if (adpsw.equals(adpsw1)){
// 如果相等则进行密码强度验证调用isPasswordValid方法来检查密码是否符合要求
if (!isPasswordValid(adpsw)) {
// 如果密码强度不符合要求例如长度不足8位或不包含字母和数字
// 通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框显示“密码强度不足至少8位包含字母和数字”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('密码强度不足至少8位包含字母和数字'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前doGet方法的执行不再继续后续操作
return;
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(newsArrayList);
// 构造一条SQL更新语句用于更新数据库中admin表的记录
// 将指定管理员编号adno对应的密码adpsw进行更新
String sql = "update admin set adpsw = ? where adno = ?";
// 创建一个包含SQL语句参数的对象数组第一个参数是新密码第二个参数是管理员编号
Object[] objects = {adpsw, adno};
req.setAttribute("newsArrayList", newsArrayList);
// 调用isAdminExists方法来验证要重置密码的管理员账号是否存在于数据库中
if (!isAdminExists(adno)) {
// 如果管理员账号不存在通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“管理员账号不存在!”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('管理员账号不存在!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前doGet方法的执行不再继续后续操作
return;
}
// 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句
// 该方法会返回受影响的行数即成功更新的记录数量将其存储在num变量中
int num = FrontWebDao.executeUpdate(sql, objects);
req.getRequestDispatcher("/view/frontweb/morenews.jsp").forward(req, resp);
// 判断受影响的行数是否大于0若大于0表示密码更新操作成功
if (num > 0){
// 如果更新成功通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“修改密码成功!请登录!”
// 并将页面重定向到部门管理员登录页面(路径为/view/frontweb/deptadmlogin.jsp同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmlogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码更新操作失败
// 通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“修改密码失败!请联系管理员”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('修改密码失败!请联系管理员'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
}
}else {
// 如果用户输入的新密码和确认密码不相等
// 通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“两次密码不一样!请重新输入密码!”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp同时关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 对于接收到的POST请求直接调用doGet方法来处理复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
// 私有方法,用于验证管理员账号是否存在于数据库中
private boolean isAdminExists(String adno) {
// 构造一条SQL查询语句用于统计admin表中指定管理员编号adno的记录数量
String sql = "select count(*) as num from admin where adno = ?";
// 创建一个包含SQL语句参数的对象数组参数为管理员编号
Object[] params = {adno};
// 调用FrontWebDao类中的findTotalCount方法执行SQL查询语句
// 该方法会返回查询结果中记录的数量将其存储在count变量中
int count = FrontWebDao.findTotalCount(sql, params);
// 如果记录数量大于0说明管理员账号存在返回true否则返回false
return count > 0;
}
// 私有方法,用于验证密码强度是否符合要求
private boolean isPasswordValid(String password) {
// 使用正则表达式进行匹配判断密码是否至少8位并且同时包含字母和数字
// 如果匹配成功说明密码强度符合要求返回true否则返回false
return password.matches("^(?=.*[A-Za-z])(?=.*\\d).{8,}$");
}
}

@ -1,63 +1,136 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库相关操作
import javax.servlet.ServletException;
// 导入处理Servlet异常的类ServletException
import javax.servlet.annotation.WebServlet;
// 导入用于将Servlet映射到URL的注解WebServlet
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类是所有基于HTTP协议的Servlet的基类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类HttpServletRequest
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类HttpServletResponse
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
@WebServlet("/PubNewsServlet")
public class PubNewsServlet extends HttpServlet {
// 导入处理I/O异常的类IOException
/**
* Servlet
*
*/
@WebServlet("/DeptAdmForgetPswServlet")
// 使用WebServlet注解将该Servlet映射到URL路径"/DeptAdmForgetPswServlet"
public class DeptAdmForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法处理HTTP GET请求
// 设置请求的字符编码为UTF-8确保能正确处理请求中的中文字符等防止乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8保证响应内容在传输过程中字符的正确性防止乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
String nid = req.getParameter("nid");
int nid1 = Integer.parseInt(nid);
String title = req.getParameter("title");
String url = req.getParameter("url");
System.out.println(nid1);
System.out.println(title);
System.out.println(url);
//获取当前时间,并格式化
Date date = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
String date1 = simpleDateFormat.format(date);
System.out.println(date1);
String sql = null;
sql = "select count(*) as num from news where nid = ?";
Object[] objects = {nid1};
int num = FrontWebDao.findTotalCount(sql, objects);
System.out.println(num);
if (num == 0){//无则发布
sql = "insert into news values(?, ? , ?, ?)";
Object[] objects1 = {nid1, title, url, date1};
int num1 = FrontWebDao.executeUpdate(sql, objects1);
if (num1 > 0){
resp.getWriter().write("<script>alert('发布成功!'); window.location='" + req.getContextPath() + "/view/frontweb/pubnews.jsp';" + "window.close();</script>");
// 从HTTP请求的参数中获取名为"adno"的参数值,该值代表管理员编号(用户输入的需要重置密码的账号)
String adno = req.getParameter("adno");
// 从HTTP请求的参数中获取名为"adpsw"的参数值,该值代表用户输入的新密码
String adpsw = req.getParameter("adpsw");
// 从HTTP请求的参数中获取名为"adpsw1"的参数值,该值代表用户输入的用于确认的新密码
String adpsw1 = req.getParameter("adpsw1");
// 进行输入验证检查获取到的管理员编号、新密码、确认密码这三个参数是否有任何一个为null
if (adno == null || adpsw == null || adpsw1 == null) {
// 如果存在参数为null的情况通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“参数不能为空!”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('参数不能为空!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前doGet方法的执行不再继续后续操作
return;
}
// 判断用户输入的新密码和确认密码是否相等
if (adpsw.equals(adpsw1)){
// 如果相等则进行密码强度验证调用isPasswordValid方法来检查密码是否符合要求
if (!isPasswordValid(adpsw)) {
// 如果密码强度不符合要求例如长度不足8位或不包含字母和数字
// 通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框显示“密码强度不足至少8位包含字母和数字”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('密码强度不足至少8位包含字母和数字'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前doGet方法的执行不再继续后续操作
return;
}
// 构造一条SQL更新语句用于更新数据库中admin表的记录
// 将指定管理员编号adno对应的密码adpsw进行更新
String sql = "update admin set adpsw = ? where adno = ?";
// 创建一个包含SQL语句参数的对象数组第一个参数是新密码第二个参数是管理员编号
Object[] objects = {adpsw, adno};
// 调用isAdminExists方法来验证要重置密码的管理员账号是否存在于数据库中
if (!isAdminExists(adno)) {
// 如果管理员账号不存在通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“管理员账号不存在!”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('管理员账号不存在!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前doGet方法的执行不再继续后续操作
return;
}
// 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句
// 该方法会返回受影响的行数即成功更新的记录数量将其存储在num变量中
int num = FrontWebDao.executeUpdate(sql, objects);
// 判断受影响的行数是否大于0若大于0表示密码更新操作成功
if (num > 0){
// 如果更新成功通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“修改密码成功!请登录!”
// 并将页面重定向到部门管理员登录页面(路径为/view/frontweb/deptadmlogin.jsp同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmlogin.jsp';" + "window.close();</script>");
}else {
resp.getWriter().write("<script>alert('发布失败!'); window.location='" + req.getContextPath() + "/view/frontweb/pubnews.jsp';" + "window.close();</script>");
// 如果受影响的行数不大于0说明密码更新操作失败
// 通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“修改密码失败!请联系管理员”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('修改密码失败!请联系管理员'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
}
}else {//否则不能发布
resp.getWriter().write("<script>alert('发布失败!此新闻编号已存在!'); window.location='" + req.getContextPath() + "/view/frontweb/pubnews.jsp';" + "window.close();</script>");
}else {
// 如果用户输入的新密码和确认密码不相等
// 通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“两次密码不一样!请重新输入密码!”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp同时关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法处理HTTP POST请求
// 对于接收到的POST请求直接调用doGet方法来处理复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
// 私有方法,用于验证管理员账号是否存在于数据库中
private boolean isAdminExists(String adno) {
// 构造一条SQL查询语句用于统计admin表中指定管理员编号adno的记录数量
String sql = "select count(*) as num from admin where adno = ?";
// 创建一个包含SQL语句参数的对象数组参数为管理员编号
Object[] params = {adno};
// 调用FrontWebDao类中的findTotalCount方法执行SQL查询语句
// 该方法会返回查询结果中记录的数量将其存储在count变量中
int count = FrontWebDao.findTotalCount(sql, params);
// 如果记录数量大于0说明管理员账号存在返回true否则返回false
return count > 0;
}
// 私有方法,用于验证密码强度是否符合要求
private boolean isPasswordValid(String password) {
// 使用正则表达式进行匹配判断密码是否至少8位并且同时包含字母和数字
// 如果匹配成功说明密码强度符合要求返回true否则返回false
return password.matches("^(?=.*[A-Za-z])(?=.*\\d).{8,}$");
}
}

@ -1,46 +1,86 @@
package com.controller.frontweb;
// 声明该Servlet所在的包为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库相关操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet相关的异常情况
import javax.servlet.annotation.WebServlet;
// 导入用于将Servlet映射到URL的注解
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类这是所有基于HTTP协议的Servlet的基类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话
import java.io.IOException;
// 导入用于处理I/O异常的类
@WebServlet("/SchoAdmAlterPswServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoAdmAlterPswServlet"
public class SchoAdmAlterPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"adno"的属性值并将其转换为String类型该值表示管理员编号
String adno = (String) session.getAttribute("adno");
// 从请求参数中获取名为"adpsw"的参数值,该值表示用户输入的新密码
String adpsw = req.getParameter("adpsw");
// 从请求参数中获取名为"adpsw1"的参数值,该值表示用户再次输入的新密码用于确认
String adpsw1 = req.getParameter("adpsw1");
//判断两次密码是否相同
if (adpsw.equals(adpsw1)){//相同则进行修改操作
// 判断两次输入的密码是否相同
if (adpsw.equals(adpsw1)){
// 如果相同,则进行密码修改操作
// 构造SQL更新语句用于更新admin表中指定adno的管理员的密码
String sql = "update admin set adpsw = ? where adno = ?";
// 创建包含SQL语句参数的对象数组第一个参数是新密码第二个参数是管理员编号
Object[] objects = {adpsw, adno};
// 调用FrontWebDao的executeUpdate方法执行SQL更新语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 如果受影响的行数大于0说明密码修改成功
// 通过响应输出一段JavaScript代码弹出提示框提示修改密码成功并要求用户重新登录
// 同时将页面重定向到学校管理员登录页面,并关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请重新登录!'); window.location='" + req.getContextPath() + "/view/frontweb/schoadmlogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码修改失败
// 通过响应输出一段JavaScript代码弹出提示框提示修改密码失败并让用户重新输入密码
// 同时将页面重定向到学校管理员修改密码页面,并关闭当前窗口
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/schoadmalterpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {
// 如果两次输入的密码不同
// 通过响应输出一段JavaScript代码弹出提示框提示两次密码不一样并让用户重新输入密码
// 同时将页面重定向到学校管理员修改密码页面,并关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/schoadmalterpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的逻辑
this.doGet(req, resp);
}
}
}

@ -1,44 +1,81 @@
package com.controller.frontweb;
// 声明该Servlet所属的包为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于后续执行数据库操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类这是编写Servlet时的基础类用于处理HTTP请求和响应
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import java.io.IOException;
// 导入用于处理I/O异常的类例如在读写数据时可能出现的异常
@WebServlet("/SchoAdmForgetPswServlet")
// 使用@WebServlet注解将当前Servlet映射到URL路径为"/SchoAdmForgetPswServlet"
public class SchoAdmForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中出现中文乱码问题
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中出现中文乱码问题
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 从HTTP请求的参数中获取名为"adno"的参数值,该值代表管理员编号
String adno = req.getParameter("adno");
// 从HTTP请求的参数中获取名为"adpsw"的参数值,该值代表用户输入的新密码
String adpsw = req.getParameter("adpsw");
// 从HTTP请求的参数中获取名为"adpsw1"的参数值,该值代表用户再次输入的用于确认的新密码
String adpsw1 = req.getParameter("adpsw1");
//判断两次密码是否相同
if (adpsw.equals(adpsw1)){//相同则进行修改操作
// 判断用户输入的新密码和确认密码是否相等
if (adpsw.equals(adpsw1)){
// 如果相等,则进行密码修改操作
// 构造SQL更新语句用于更新数据库中admin表的记录将指定管理员编号adno对应的密码adpsw进行更新
String sql = "update admin set adpsw = ? where adno = ?";
// 创建一个包含SQL语句参数的对象数组第一个参数是新密码第二个参数是管理员编号
Object[] objects = {adpsw, adno};
// 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 如果受影响的行数大于0说明密码更新操作成功
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码成功请登录
// 并将页面重定向到学校管理员登录页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/schoadmlogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码更新操作失败
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码失败请重新输入密码
// 并将页面重定向到学校管理员忘记密码重置页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/schoadmforgetpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {
// 如果用户输入的新密码和确认密码不相等
// 通过响应输出一段JavaScript代码弹出提示框显示“两次密码不一样!请重新输入密码!”
// 并将页面重定向到学校管理员忘记密码重置页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/schoadmforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,64 +1,111 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库相关操作如查询等
import javax.servlet.ServletException;
// 导入处理Servlet异常的类在Servlet处理请求过程中发生异常时使用
import javax.servlet.annotation.WebServlet;
// 导入用于将Servlet映射到URL的注解
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数、请求头信息等
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、响应头信息等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import javax.sql.rowset.serial.SerialStruct;
// 导入SerialStruct类这里未使用到属于无用导入可删除
import java.io.IOException;
// 导入处理I/O异常的类如在读取或写入数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类,用于获取查询到的数据
@WebServlet("/SchoAdmLoginServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoAdmLoginServlet"
public class SchoAdmLoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
//获取表单请求个参数
// 获取表单请求中的参数,这里获取管理员编号
String adno = req.getParameter("adno");
// 获取表单请求中的参数,这里获取管理员密码
String adpsw = req.getParameter("adpsw");
// 固定设置所属单位为"学校",表示学校管理员
String belong = "学校";
// 构造SQL查询语句用于从admin表中查询匹配的管理员记录
String sql = "select * from admin where adno = ? and adpsw = ? and belong = ?";
// 创建包含SQL语句参数的对象数组依次为管理员编号、密码、所属单位
Object[] objects = {adno, adpsw, belong};
// 调用FrontWebDao的login方法执行SQL查询并获取结果集
ResultSet resultSet = FrontWebDao.login(sql, objects);
//判断密码和账号是否正确
// 判断密码和账号是否正确
try {
// 如果结果集有下一条记录,说明查询到了匹配的管理员记录
if (resultSet.next()){
// 创建会话属性对象,后面处理请求要
// 创建会话对象,用于存储用户会话信息
HttpSession session = req.getSession();
// 在会话中存储管理员编号
session.setAttribute("adno", adno);
// 在会话中存储所属单位(这里是"学校"
session.setAttribute("belong", belong);
// 在会话中存储学校管理员编号与adno相同这里可能存在命名重复问题
session.setAttribute("schoadno", adno);
// 打印登录成功信息到控制台,用于调试
System.out.println("登陆成功!");
// 设置请求属性指定跳转的URL路径
req.setAttribute("httpUrl","/view/schoadmin/schomainview.jsp");
// 设置请求属性,指定提示信息
req.setAttribute("info", "登录成功!即将跳转至学校管理员后台首页!");
// 设置请求属性,指定页面标题
req.setAttribute("title","登录成功");
// 转发请求到指定的页面(/view/frontweb/info.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
}else {
// 如果结果集没有下一条记录,说明账号或密码错误
System.out.println("用户名或密码错误!请重新登录!");
//返回登录成功的信息
// 设置请求属性指定跳转回登录页面的URL路径
req.setAttribute("httpUrl","/view/frontweb/schoadmlogin.jsp");
// 设置请求属性,指定错误提示信息
req.setAttribute("info", "登录失败!管理员账号或密码错误!即将跳转至登录页面!");
// 设置请求属性,指定页面标题
req.setAttribute("title","登录失败");
// 转发请求到指定的页面(/view/frontweb/info.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
}
} catch (Exception e) {
// 捕获异常并打印异常堆栈信息,用于调试和错误排查
e.printStackTrace();
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,46 +1,86 @@
package com.controller.frontweb;
// 声明该Servlet所在的包为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库相关操作如更新操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet在运行过程中可能出现的异常情况
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类这是编写Servlet时继承的基础类用于处理HTTP请求和响应
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数、请求头信息等
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关的信息
import java.io.IOException;
// 导入用于处理I/O异常的类例如在读写数据时可能出现的异常
@WebServlet("/StuAlterPswServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuAlterPswServlet"
public class StuAlterPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"sno"的属性值并将其转换为String类型该值表示学生编号
String sno = (String) session.getAttribute("sno");
// 从请求参数中获取名为"spsw"的参数值,该值表示学生输入的新密码
String spsw = req.getParameter("spsw");
// 从请求参数中获取名为"spsw1"的参数值,该值表示学生再次输入的新密码用于确认
String spsw1 = req.getParameter("spsw1");
//判断两次密码是否相同
if (spsw.equals(spsw1)){//相同则进行修改操作
// 判断两次输入的密码是否相同
if (spsw.equals(spsw1)){
// 如果相同,则进行密码修改操作
// 构造SQL更新语句用于更新student表中指定sno的学生的密码
String sql = "update student set spsw = ? where sno = ?";
// 创建包含SQL语句参数的对象数组第一个参数是新密码第二个参数是学生编号
Object[] objects = {spsw, sno};
// 调用FrontWebDao的executeUpdate方法执行SQL更新语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 如果受影响的行数大于0说明密码修改成功
// 通过响应输出一段JavaScript代码弹出提示框提示修改密码成功并要求学生重新登录
// 同时将页面重定向到学生登录页面,并关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请重新登录!'); window.location='" + req.getContextPath() + "/view/frontweb/stulogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码修改失败
// 通过响应输出一段JavaScript代码弹出提示框提示修改密码失败并让学生重新输入密码
// 同时将页面重定向到学生修改密码页面,并关闭当前窗口
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/stualterpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {
// 如果两次输入的密码不同
// 通过响应输出一段JavaScript代码弹出提示框提示两次密码不一样并让学生重新输入密码
// 同时将页面重定向到学生修改密码页面,并关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/stualterpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的逻辑
this.doGet(req, resp);
}
}
}

@ -1,45 +1,84 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库操作如更新密码的SQL语句
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet在运行过程中可能抛出的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类这是编写Servlet时的基类用于处理HTTP请求和响应
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类可获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类可设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息虽然此处未使用会话存储相关信息但导入了该类
import java.io.IOException;
// 导入用于处理I/O异常的类例如在读写数据时可能出现的异常
@WebServlet("/StuForgetPswServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuForgetPswServlet"
public class StuForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 从HTTP请求的参数中获取名为"sno"的参数值,该值代表学生编号
String sno = req.getParameter("sno");
// 从HTTP请求的参数中获取名为"spsw"的参数值,该值代表学生输入的新密码
String spsw = req.getParameter("spsw");
// 从HTTP请求的参数中获取名为"spsw1"的参数值,该值代表学生再次输入的用于确认的新密码
String spsw1 = req.getParameter("spsw1");
//判断两次密码是否相同
if (spsw.equals(spsw1)){//相同则进行修改操作
// 判断用户输入的新密码和确认密码是否相等
if (spsw.equals(spsw1)){
// 如果相等,则进行密码修改操作
// 构造SQL更新语句用于更新student表中指定学生编号sno对应的密码spsw
String sql = "update student set spsw = ? where sno = ?";
// 创建一个包含SQL语句参数的对象数组第一个参数是新密码第二个参数是学生编号
Object[] objects = {spsw, sno};
// 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 如果受影响的行数大于0说明密码更新操作成功
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码成功请登录
// 并将页面重定向到学生登录页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/stulogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码更新操作失败
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码失败请重新输入密码
// 并将页面重定向到学生忘记密码重置页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/stuforgetpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {
// 如果用户输入的新密码和确认密码不相等
// 通过响应输出一段JavaScript代码弹出提示框显示“两次密码不一样!请重新输入密码!”
// 并将页面重定向到学生忘记密码重置页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/stuforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,61 +1,113 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库查询操作
import com.dao.StuDao;
// 导入StuDao类这里未使用到属于无用导入可删除
import com.entity.Student;
// 导入Student实体类用于封装学生相关信息
import com.utils.JDBCUtils;
// 导入JDBC工具类用于数据库连接的管理和资源关闭等操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数、请求头信息等
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、响应头信息等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类如在读取或写入数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类,用于获取查询到的数据
import java.util.ArrayList;
// 导入ArrayList类这里未使用到属于无用导入可删除
@WebServlet("/StuInfoServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuInfoServlet"
public class StuInfoServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"sno"的属性值并将其转换为String类型该值表示学生编号
String sno = (String) session.getAttribute("sno");
// 构造SQL查询语句用于从student表中查询指定学生编号sno的学生信息
String sql = "select * from student where sno = ?";
// 创建包含SQL语句参数的对象数组参数为学生编号
Object[] objects = {sno};
// 调用FrontWebDao的qureyInfo方法执行SQL查询并获取结果集
ResultSet resultSet = FrontWebDao.qureyInfo(sql, objects);
// 创建一个Student对象用于存储查询到的学生信息
Student student = new Student();
try {
// 遍历结果集将每一行数据封装到Student对象中
while (resultSet.next()){
// 设置学生编号
student.setSno(resultSet.getString("sno"));
// 设置学生姓名
student.setSname(resultSet.getString("sname"));
// 设置学生性别
student.setSsex(resultSet.getString("ssex"));
// 设置学生年龄将数据库中的整数类型值转换为int类型
student.setSage(resultSet.getInt("sage"));
// 设置学生班级
student.setSclass(resultSet.getString("sclass"));
// 设置学生专业
student.setSpecialty(resultSet.getString("specialty"));
// 设置学生所在系部
student.setSdept(resultSet.getString("sdept"));
// 设置学生电话号码
student.setSphone(resultSet.getString("sphone"));
}
} catch (Exception e) {
// 捕获异常并打印异常堆栈信息,用于调试和错误排查
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常都调用JDBCUtils的close方法关闭结果集释放资源
JDBCUtils.close(resultSet);
}
// 将封装好的学生信息对象student设置为请求属性以便在后续页面中使用
req.setAttribute("student", student);
// 转发请求到指定的页面(/view/frontweb/stuinfo.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/stuinfo.jsp").forward(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,56 +1,104 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库查询操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类如在读写数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类
import java.sql.SQLException;
// 导入用于处理SQL异常的类
@WebServlet("/StuLoginServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuLoginServlet"
public class StuLoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 从HTTP请求的参数中获取名为"sno"的参数值,该值代表学生编号
String sno = req.getParameter("sno");
// 从HTTP请求的参数中获取名为"spsw"的参数值,该值代表学生密码
String spsw = req.getParameter("spsw");
// 将获取到的学生编号打印到控制台,用于调试
System.out.println(sno);
// 将获取到的学生密码打印到控制台,用于调试
System.out.println(spsw);
// 获取当前请求的会话对象,如果不存在则创建一个新的会话
HttpSession session = req.getSession();
// 将学生编号存储到会话中,以便在后续请求中可以获取该信息
session.setAttribute("sno", sno);
// 构造SQL查询语句用于从student表中查询匹配的学生记录
String sql = "select * from student where sno = ? and spsw = ?";
// 创建包含SQL语句参数的对象数组依次为学生编号、学生密码
Object[] objects = {sno, spsw};
// 调用FrontWebDao的login方法执行SQL查询并获取结果集
ResultSet resultSet = FrontWebDao.login(sql, objects);
try {
// 如果结果集有下一条记录,说明查询到了匹配的学生记录
if (resultSet.next()){
// 设置请求属性指定跳转的URL路径为"/StuInfoServlet"即学生信息Servlet
req.setAttribute("httpUrl","/StuInfoServlet");
// 设置请求属性,指定提示信息
req.setAttribute("info", "登录成功!即将跳转至学生信息页面!");
// 设置请求属性,指定页面标题
req.setAttribute("title","登录成功");
// 转发请求到指定的页面(/view/frontweb/info.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
}else {
// 如果结果集没有下一条记录,说明学号或密码错误
// 设置请求属性指定跳转回登录页面的URL路径
req.setAttribute("httpUrl","/view/frontweb/stulogin.jsp");
// 设置请求属性,指定错误提示信息
req.setAttribute("info", "登录失败!学号或密码错误!即将跳转至登录页面!");
// 设置请求属性,指定页面标题
req.setAttribute("title","登录失败");
// 转发请求到指定的页面(/view/frontweb/info.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
}
} catch (SQLException e) {
// 捕获SQL异常并打印异常堆栈信息用于调试和错误排查
e.printStackTrace();
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,80 +1,144 @@
package com.controller.frontweb;
// 声明该Servlet所在的包为com.controller.frontweb
import com.dao.DeptAdminDao;
// 导入部门管理员数据访问对象类但在本Servlet中未使用
import com.dao.FrontWebDao;
// 导入前端数据访问对象类,用于执行数据库操作
import com.mysql.fabric.Response;
// 导入MySQL Fabric响应类但在本Servlet中未使用
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import javax.swing.*;
// 导入Swing组件类但在本Servlet中未使用
import java.io.IOException;
// 导入用于处理I/O异常的类如在读写数据时可能发生的异常
import java.io.PrintWriter;
// 导入用于输出响应内容的类但在本Servlet中未直接使用
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类
import java.sql.SQLException;
// 导入用于处理SQL异常的类
import java.text.SimpleDateFormat;
// 导入用于格式化日期的类
import java.util.Date;
// 导入日期类,用于获取当前日期和时间
@WebServlet("/StuPunchServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuPunchServlet"
public class StuPunchServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
//获取sno
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"sno"的属性值并将其转换为String类型该值表示学生编号
String sno = (String) session.getAttribute("sno");
// 打印学生编号到控制台,用于调试
System.out.println(sno);
//获取表单请求的参数
/*String sno = req.getParameter("sno");*/
// 从HTTP请求的参数中获取名为"sishot"的参数值,该值表示学生是否发热
String sishot = req.getParameter("sishot");
// 从HTTP请求的参数中获取名为"siscough"的参数值,该值表示学生是否咳嗽
String siscough = req.getParameter("siscough");
// 从HTTP请求的参数中获取名为"sisseem"的参数值,该值表示学生是否有其他症状
String sisseem = req.getParameter("sisseem");
// 从HTTP请求的参数中获取名为"sisdiagnose"的参数值,该值表示学生是否被诊断
String sisdiagnose = req.getParameter("sisdiagnose");
// 从HTTP请求的参数中获取名为"sstatus"的参数值,该值表示学生当前状态
String sstatus = req.getParameter("sstatus");
// 设置学生打卡状态为"是",表示已打卡
String sispunch = "是";
// 创建Date对象获取当前时间
Date date = new Date();
//获取当前日期
// 创建SimpleDateFormat对象用于将日期格式化为"yyyy-MM-dd"的字符串
SimpleDateFormat sf1 = new SimpleDateFormat("yyyy-MM-dd");
// 格式化当前日期
String spunchdate = sf1.format(date);
// 打印当前日期到控制台,用于调试
System.out.println(spunchdate);
//获取当前时间
// 创建SimpleDateFormat对象用于将时间格式化为"HH:mm"的字符串
SimpleDateFormat sf2 = new SimpleDateFormat("HH:mm");
// 格式化当前时间
String spunchtime = sf2.format(date);
// 打印当前时间到控制台,用于调试
System.out.println(spunchtime);
// 声明SQL语句变量初始化为null
String sql = null;
//查询是否已经打卡
// 构造SQL查询语句,用于查询该学生今天是否已经打卡
sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?";
// 创建包含SQL语句参数的对象数组依次为学生编号、打卡日期
Object[] objects1 = {sno, spunchdate};
// 调用FrontWebDao的findTotalCount方法执行SQL查询获取查询结果的数量
int count = FrontWebDao.findTotalCount(sql, objects1);
if (count == 0){//无则操作
if (count == 0){
// 如果查询结果数量为0表示该学生今天还未打卡则执行插入操作
sql = "insert into stupunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)";
// 创建包含SQL语句参数的对象数组依次为学生编号、是否打卡、打卡日期、打卡时间、是否发热、是否咳嗽、是否有其他症状、是否被诊断、当前状态
Object[] objects2 = {sno, sispunch, spunchdate, spunchtime, sishot, siscough, sisseem, sisdiagnose, sstatus};
// 调用FrontWebDao的executeUpdate方法执行SQL插入语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects2);
// 打印受影响的行数到控制台,用于调试
System.out.println(num);
// 通过响应输出一段JavaScript代码弹出提示框提示打卡成功
// 并将页面重定向到学生信息页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('打卡成功!'); window.location='" + req.getContextPath() + "/StuInfoServlet';" + "window.close();</script>");
}else {//已打卡
}else {
// 如果查询结果数量不为0表示该学生今天已经打卡
// 通过响应输出一段JavaScript代码弹出提示框提示今天已打卡不能再次打卡
// 并将页面重定向到学生信息页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('您今天已成功打卡!不能再次打卡!'); window.location='" + req.getContextPath() + "/StuInfoServlet';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
doGet(req, resp);
}
}
}

@ -1,46 +1,86 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库相关操作如更新操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类这是编写Servlet时继承的基础类用于处理HTTP请求和响应
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数、请求头信息等
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类例如在读写数据时可能出现的异常
@WebServlet("/TeaAlterPswServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaAlterPswServlet"
public class TeaAlterPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"tno"的属性值并将其转换为String类型该值表示教师编号
String tno = (String) session.getAttribute("tno");
// 从请求参数中获取名为"tpsw"的参数值,该值表示教师输入的新密码
String tpsw = req.getParameter("tpsw");
// 从请求参数中获取名为"tpsw1"的参数值,该值表示教师再次输入的新密码用于确认
String tpsw1 = req.getParameter("tpsw1");
//判断两次密码是否相同
if (tpsw.equals(tpsw1)){//相同则进行修改操作
// 判断两次输入的密码是否相同
if (tpsw.equals(tpsw1)){
// 如果相同,则进行密码修改操作
// 构造SQL更新语句用于更新teacher表中指定tno的教师的密码
String sql = "update teacher set tpsw = ? where tno = ?";
// 创建包含SQL语句参数的对象数组第一个参数是新密码第二个参数是教师编号
Object[] objects = {tpsw, tno};
// 调用FrontWebDao的executeUpdate方法执行SQL更新语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 如果受影响的行数大于0说明密码修改成功
// 通过响应输出一段JavaScript代码弹出提示框提示修改密码成功并要求教师重新登录
// 同时将页面重定向到教师登录页面,并关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请重新登录!'); window.location='" + req.getContextPath() + "/view/frontweb/tealogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码修改失败
// 通过响应输出一段JavaScript代码弹出提示框提示修改密码失败并让教师重新输入密码
// 同时将页面重定向到教师修改密码页面,并关闭当前窗口
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/teaalterpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {
// 如果两次输入的密码不同
// 通过响应输出一段JavaScript代码弹出提示框提示两次密码不一样并让教师重新输入密码
// 同时将页面重定向到教师修改密码页面,并关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/teaalterpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的逻辑
this.doGet(req, resp);
}
}
}

@ -1,44 +1,81 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库操作如更新密码相关的SQL操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet在运行过程中可能出现的异常情况
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类用于处理HTTP请求和响应
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import java.io.IOException;
// 导入用于处理I/O异常的类例如在读写数据时可能出现的异常
@WebServlet("/TeaForgetPswServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaForgetPswServlet"
public class TeaForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 从HTTP请求的参数中获取名为"tno"的参数值,该值代表教师编号
String tno = req.getParameter("tno");
// 从HTTP请求的参数中获取名为"tpsw"的参数值,该值代表教师输入的新密码
String tpsw = req.getParameter("tpsw");
// 从HTTP请求的参数中获取名为"tpsw1"的参数值,该值代表教师再次输入的用于确认的新密码
String tpsw1 = req.getParameter("tpsw1");
//判断两次密码是否相同
if (tpsw.equals(tpsw1)){//相同则进行修改操作
// 判断教师输入的新密码和确认密码是否相等
if (tpsw.equals(tpsw1)){
// 如果相等,则进行密码修改操作
// 构造SQL更新语句用于更新teacher表中指定教师编号tno对应的密码tpsw
String sql = "update teacher set tpsw = ? where tno = ?";
// 创建一个包含SQL语句参数的对象数组第一个参数是新密码第二个参数是教师编号
Object[] objects = {tpsw, tno};
// 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 如果受影响的行数大于0说明密码更新操作成功
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码成功请登录
// 并将页面重定向到教师登录页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/tealogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码更新操作失败
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码失败请重新输入密码
// 并将页面重定向到教师忘记密码重置页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/teaforgetpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {
// 如果教师输入的新密码和确认密码不相等
// 通过响应输出一段JavaScript代码弹出提示框显示“两次密码不一样!请重新输入密码!”
// 并将页面重定向到教师忘记密码重置页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/teaforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,58 +1,107 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库查询操作
import com.entity.Student;
// 导入Student实体类这里未使用到属于无用导入可删除
import com.entity.Teacher;
// 导入Teacher实体类用于封装教师相关信息
import com.utils.JDBCUtils;
// 导入JDBC工具类用于数据库连接的管理和资源关闭等操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数、请求头信息等
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、响应头信息等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类如在读取或写入数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类,用于获取查询到的数据
@WebServlet("/TeaInfoServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaInfoServlet"
public class TeaInfoServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"tno"的属性值并将其转换为String类型该值表示教师编号
String tno = (String) session.getAttribute("tno");
// 构造SQL查询语句用于从teacher表中查询指定教师编号tno的教师信息
String sql = "select * from teacher where tno = ?";
// 创建包含SQL语句参数的对象数组参数为教师编号
Object[] objects = {tno};
// 调用FrontWebDao的qureyInfo方法执行SQL查询并获取结果集
ResultSet resultSet = FrontWebDao.qureyInfo(sql, objects);
// 创建一个Teacher对象用于存储查询到的教师信息
Teacher teacher = new Teacher();
try {
// 遍历结果集将每一行数据封装到Teacher对象中
while (resultSet.next()){
// 设置教师编号
teacher.setTno(resultSet.getString("tno"));
// 设置教师姓名
teacher.setTname(resultSet.getString("tname"));
// 设置教师性别
teacher.setTsex(resultSet.getString("tsex"));
// 设置教师年龄将数据库中的整数类型值转换为int类型
teacher.setTage(resultSet.getInt("tage"));
// 设置教师所在系部
teacher.setTdept(resultSet.getString("tdept"));
// 设置教师电话号码
teacher.setTphone(resultSet.getString("tphone"));
}
} catch (Exception e) {
// 捕获异常并打印异常堆栈信息,用于调试和错误排查
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常都调用JDBCUtils的close方法关闭结果集释放资源
JDBCUtils.close(resultSet);
}
// 将封装好的教师信息对象teacher设置为请求属性以便在后续页面中使用
req.setAttribute("teacher", teacher);
// 转发请求到指定的页面(/view/frontweb/teainfo.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/teainfo.jsp").forward(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
```

@ -1,56 +1,104 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库查询操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类如在读写数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类
import java.sql.SQLException;
// 导入用于处理SQL异常的类
@WebServlet("/TeaLoginServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaLoginServlet"
public class TeaLoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 从HTTP请求的参数中获取名为"tno"的参数值,该值代表教师编号
String tno = req.getParameter("tno");
// 从HTTP请求的参数中获取名为"tpsw"的参数值,该值代表教师密码
String tpsw = req.getParameter("tpsw");
// 将获取到的教师编号打印到控制台,用于调试
System.out.println(tno);
// 将获取到的教师密码打印到控制台,用于调试
System.out.println(tpsw);
// 获取当前请求的会话对象,如果不存在则创建一个新的会话
HttpSession session = req.getSession();
// 将教师编号存储到会话中,以便在后续请求中可以获取该信息
session.setAttribute("tno", tno);
// 构造SQL查询语句用于从teacher表中查询匹配的教师记录
String sql = "select * from teacher where tno = ? and tpsw = ?";
// 创建包含SQL语句参数的对象数组依次为教师编号、教师密码
Object[] objects = {tno, tpsw};
// 调用FrontWebDao的login方法执行SQL查询并获取结果集
ResultSet resultSet = FrontWebDao.login(sql, objects);
try {
// 如果结果集有下一条记录,说明查询到了匹配的教师记录
if (resultSet.next()){
// 设置请求属性指定跳转的URL路径为"/TeaInfoServlet"即教师信息Servlet
req.setAttribute("httpUrl","/TeaInfoServlet");
// 设置请求属性,指定提示信息
req.setAttribute("info", "登录成功!即将跳转至教师信息页面!");
// 设置请求属性,指定页面标题
req.setAttribute("title","登录成功");
// 转发请求到指定的页面(/view/frontweb/info.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
}else {
// 如果结果集没有下一条记录,说明教工号或密码错误
// 设置请求属性指定跳转回登录页面的URL路径
req.setAttribute("httpUrl","/view/frontweb/tealogin.jsp");
// 设置请求属性,指定错误提示信息
req.setAttribute("info", "登录失败!教工号或密码错误!即将跳转至登录页面!");
// 设置请求属性,指定页面标题
req.setAttribute("title","登录失败");
// 转发请求到指定的页面(/view/frontweb/info.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
}
} catch (SQLException e) {
// 捕获SQL异常并打印异常堆栈信息用于调试和错误排查
e.printStackTrace();
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,76 +1,132 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.DeptAdminDao;
// 导入部门管理员数据访问对象类,在本类中未使用
import com.dao.FrontWebDao;
// 导入前端数据访问对象类,用于执行数据库操作,如查询、插入等
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类可获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类可设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类如在读写数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类
import java.text.SimpleDateFormat;
// 导入用于格式化日期和时间的类
import java.util.Date;
// 导入日期类,用于获取当前日期和时间
@WebServlet("/TeaPunchServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaPunchServlet"
public class TeaPunchServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
//获取sno
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"tno"的属性值并将其转换为String类型该值表示教师编号
String tno = (String) session.getAttribute("tno");
// 将教师编号打印到控制台,用于调试
System.out.println(tno);
//获取表单请求的参数
/*String tno = req.getParameter("tno");*/
// 从HTTP请求的参数中获取名为"tishot"的参数值,该值表示教师是否发热
String tishot = req.getParameter("tishot");
// 从HTTP请求的参数中获取名为"tiscough"的参数值,该值表示教师是否咳嗽
String tiscough = req.getParameter("tiscough");
// 从HTTP请求的参数中获取名为"tisseem"的参数值,该值表示教师是否有其他症状
String tisseem = req.getParameter("tisseem");
// 从HTTP请求的参数中获取名为"tisdiagnose"的参数值,该值表示教师是否被诊断
String tisdiagnose = req.getParameter("tisdiagnose");
// 从HTTP请求的参数中获取名为"tstatus"的参数值,该值表示教师当前状态
String tstatus = req.getParameter("tstatus");
// 设置教师打卡状态为"是",表示已打卡
String tispunch = "是";
// 创建Date对象获取当前时间
Date date = new Date();
//获取当前日期
// 创建SimpleDateFormat对象用于将日期格式化为"yyyy-MM-dd"的字符串
SimpleDateFormat sf1 = new SimpleDateFormat("yyyy-MM-dd");
// 格式化当前日期
String tpunchdate = sf1.format(date);
// 将当前日期打印到控制台,用于调试
System.out.println(tpunchdate);
//获取当前时间
// 创建SimpleDateFormat对象用于将时间格式化为"HH:mm"的字符串
SimpleDateFormat sf2 = new SimpleDateFormat("HH:mm");
// 格式化当前时间
String tpunchtime = sf2.format(date);
// 将当前时间打印到控制台,用于调试
System.out.println(tpunchtime);
// 初始化SQL语句变量
String sql = null;
//查询是否已经打卡
// 构造SQL查询语句,用于查询该教师今天是否已经打卡
sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?";
// 创建包含SQL语句参数的对象数组依次为教师编号、打卡日期
Object[] objects1 = {tno, tpunchdate};
// 调用FrontWebDao的findTotalCount方法执行SQL查询获取查询结果的数量
int count = FrontWebDao.findTotalCount(sql, objects1);
if (count == 0){//无则操作
if (count == 0) {
// 如果查询结果数量为0表示该教师今天还未打卡则执行插入操作
sql = "insert into teapunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)";
// 创建包含SQL语句参数的对象数组依次为教师编号、是否打卡、打卡日期、打卡时间、是否发热、是否咳嗽、是否有其他症状、是否被诊断、当前状态
Object[] objects2 = {tno, tispunch, tpunchdate, tpunchtime, tishot, tiscough, tisseem, tisdiagnose, tstatus};
// 调用FrontWebDao的executeUpdate方法执行SQL插入语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects2);
// 将受影响的行数打印到控制台,用于调试
System.out.println(num);
// 通过响应输出一段JavaScript代码弹出提示框提示打卡成功
// 并将页面重定向到教师信息页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('打卡成功!'); window.location='" + req.getContextPath() + "/TeaInfoServlet';" + "window.close();</script>");
}else {//已经打卡
} else {
// 如果查询结果数量不为0表示该教师今天已经打卡
// 通过响应输出一段JavaScript代码弹出提示框提示今天已打卡不能再次打卡
// 并将页面重定向到教师信息页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('您今天已成功打卡!不能再次打卡!'); window.location='" + req.getContextPath() + "/TeaInfoServlet';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}
Loading…
Cancel
Save