diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..35eb1dd
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index e3c9483..359f8a3 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -5,8 +5,14 @@
+
+
+
-
+
+
+
+
@@ -23,6 +29,14 @@
+
+
+
+
@@ -33,7 +47,8 @@
+ {
+ "associatedIndex": 3
+}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
@@ -181,6 +198,15 @@
+
+
+
+
+
+
+
+
+
@@ -328,116 +354,45 @@
+
+
+
+
+ 1745902378186
+
+
+
+ 1745902378186
+
+
+
+ 1745903268367
+
+
+
+ 1745903268367
+
+
+
+ 1745905274230
+
+
+
+ 1745905274230
+
+
-
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
\ No newline at end of file
diff --git a/src/com/controller/alluse/LoginServlet.java b/src/com/controller/alluse/LoginServlet.java
index 07709fc..40250ba 100644
--- a/src/com/controller/alluse/LoginServlet.java
+++ b/src/com/controller/alluse/LoginServlet.java
@@ -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方法处理
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/DelNewsServlet.java b/src/com/controller/frontweb/DelNewsServlet.java
index 7c55eea..75a3f27 100644
--- a/src/com/controller/frontweb/DelNewsServlet.java
+++ b/src/com/controller/frontweb/DelNewsServlet.java
@@ -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("");
- }else {
+ }else { // 删除失败（可能是数据库操作异常）
resp.getWriter().write("");
}
- }else {//否则不能删除
+ }else { // 新闻不存在，不能删除
resp.getWriter().write("");
}
-
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
- this.doGet(req, resp);
+ this.doGet(req, resp); // 对于POST请求，直接调用doGet方法处理
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/DeptAdmAlterPswServlet.java b/src/com/controller/frontweb/DeptAdmAlterPswServlet.java
index 1ea73e4..ffa2707 100644
--- a/src/com/controller/frontweb/DeptAdmAlterPswServlet.java
+++ b/src/com/controller/frontweb/DeptAdmAlterPswServlet.java
@@ -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("");
- }else {
+ }else { // 更新失败（可能是数据库操作异常）
resp.getWriter().write("");
}
- }else {//不同则重新输入密码
+ }else {// 两次密码不同，提示用户重新输入
resp.getWriter().write("");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
- this.doGet(req, resp);
+ this.doGet(req, resp); // 对于POST请求，直接调用doGet方法处理
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/DeptAdmForgetPswServlet.java b/src/com/controller/frontweb/DeptAdmForgetPswServlet.java
index 3a2d02a..e26c821 100644
--- a/src/com/controller/frontweb/DeptAdmForgetPswServlet.java
+++ b/src/com/controller/frontweb/DeptAdmForgetPswServlet.java
@@ -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("");
- }else {
+ }else { // 更新失败（可能是管理员编号不存在或数据库操作异常）
resp.getWriter().write("");
}
- }else {//不同则重新输入密码
+ }else {// 两次密码不同，提示用户重新输入
resp.getWriter().write("");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
- this.doGet(req, resp);
+ this.doGet(req, resp); // 对于POST请求，直接调用doGet方法处理
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/DeptAdmLoginServlet.java b/src/com/controller/frontweb/DeptAdmLoginServlet.java
index 602ade3..114759b 100644
--- a/src/com/controller/frontweb/DeptAdmLoginServlet.java
+++ b/src/com/controller/frontweb/DeptAdmLoginServlet.java
@@ -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("");
+ return;
+ }
+
+ // 判断两次输入的密码是否相同
+ if (adpsw.equals(adpsw1)){// 相同则进行修改操作
+ // 验证密码强度（示例：至少8位，包含字母和数字）
+ if (!isPasswordValid(adpsw)) {
+ resp.getWriter().write("");
+ 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("");
+ 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("");
+ }else { // 更新失败
+ resp.getWriter().write("");
}
- } catch (Exception e) {
- e.printStackTrace();
+ }else {// 两次密码不同，提示用户重新输入
+ resp.getWriter().write("");
}
}
@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,}$");
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/FrontWebServlet.java b/src/com/controller/frontweb/FrontWebServlet.java
index c52f75b..22c5ee1 100644
--- a/src/com/controller/frontweb/FrontWebServlet.java
+++ b/src/com/controller/frontweb/FrontWebServlet.java
@@ -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 hashMap = new HashMap();
-
- 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 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 webStuArrayList = new ArrayList();
- 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 webTeaArrayList = new ArrayList();
- 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("");
+ // 终止当前方法的执行
+ 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("");
+ // 终止当前方法的执行
+ return;
+ }
- //实时播报
- sql = "select * from news order by nid desc limit 7";
- Object[] objects2 = {};
- ArrayList newsArrayList = new ArrayList();
+ // 构造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("");
+ // 终止当前方法的执行
+ 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("");
+ }else { // 如果受影响的行数不大于0，说明更新失败
+ // 通过响应输出一段JavaScript代码，弹出提示框显示“修改密码失败！请联系管理员”
+ // 并将页面重定向到密码重置页面（/view/frontweb/deptadmforgetpsw.jsp）
+ resp.getWriter().write("");
}
- } catch (Exception e) {
- e.printStackTrace();
+ }else {// 如果两次密码不同
+ // 通过响应输出一段JavaScript代码，弹出提示框显示“两次密码不一样!请重新输入密码！”
+ // 并将页面重定向到密码重置页面（/view/frontweb/deptadmforgetpsw.jsp），同时关闭当前窗口
+ resp.getWriter().write("");
}
-
- 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,}$");
+ }
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/MoreNewsServlet.java b/src/com/controller/frontweb/MoreNewsServlet.java
index ec136f0..4bc4fcd 100644
--- a/src/com/controller/frontweb/MoreNewsServlet.java
+++ b/src/com/controller/frontweb/MoreNewsServlet.java
@@ -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 newsArrayList = new ArrayList();
+ // 从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("");
+ // 终止当前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("");
+ // 终止当前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("");
+ // 终止当前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("");
+ }else {
+ // 如果受影响的行数不大于0，说明密码更新操作失败
+ // 通过响应向客户端发送一段JavaScript代码
+ // 该代码会弹出一个提示框，显示“修改密码失败！请联系管理员”
+ // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp）
+ resp.getWriter().write("");
+ }
+ }else {
+ // 如果用户输入的新密码和确认密码不相等
+ // 通过响应向客户端发送一段JavaScript代码
+ // 该代码会弹出一个提示框，显示“两次密码不一样!请重新输入密码！”
+ // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp），同时关闭当前窗口
+ resp.getWriter().write("");
+ }
}
@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,}$");
+ }
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/PubNewsServlet.java b/src/com/controller/frontweb/PubNewsServlet.java
index 95a2dcb..f4bdc16 100644
--- a/src/com/controller/frontweb/PubNewsServlet.java
+++ b/src/com/controller/frontweb/PubNewsServlet.java
@@ -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("");
+ // 从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("");
+ // 终止当前doGet方法的执行，不再继续后续操作
+ return;
+ }
+
+ // 判断用户输入的新密码和确认密码是否相等
+ if (adpsw.equals(adpsw1)){
+ // 如果相等，则进行密码强度验证，调用isPasswordValid方法来检查密码是否符合要求
+ if (!isPasswordValid(adpsw)) {
+ // 如果密码强度不符合要求（例如长度不足8位或不包含字母和数字）
+ // 通过响应向客户端发送一段JavaScript代码
+ // 该代码会弹出一个提示框，显示“密码强度不足！至少8位，包含字母和数字”
+ // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp）
+ resp.getWriter().write("");
+ // 终止当前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("");
+ // 终止当前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("");
}else {
- resp.getWriter().write("");
+ // 如果受影响的行数不大于0，说明密码更新操作失败
+ // 通过响应向客户端发送一段JavaScript代码
+ // 该代码会弹出一个提示框，显示“修改密码失败！请联系管理员”
+ // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp）
+ resp.getWriter().write("");
}
- }else {//否则不能发布
- resp.getWriter().write("");
+ }else {
+ // 如果用户输入的新密码和确认密码不相等
+ // 通过响应向客户端发送一段JavaScript代码
+ // 该代码会弹出一个提示框，显示“两次密码不一样!请重新输入密码！”
+ // 并将页面重定向到密码重置页面（路径为/view/frontweb/deptadmforgetpsw.jsp），同时关闭当前窗口
+ resp.getWriter().write("");
}
-
}
@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,}$");
+ }
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/SchoAdmAlterPswServlet.java b/src/com/controller/frontweb/SchoAdmAlterPswServlet.java
index 1eab15c..59ad613 100644
--- a/src/com/controller/frontweb/SchoAdmAlterPswServlet.java
+++ b/src/com/controller/frontweb/SchoAdmAlterPswServlet.java
@@ -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("");
}else {
+ // 如果受影响的行数不大于0，说明密码修改失败
+ // 通过响应输出一段JavaScript代码，弹出提示框提示修改密码失败，并让用户重新输入密码
+ // 同时将页面重定向到学校管理员修改密码页面，并关闭当前窗口
resp.getWriter().write("");
}
- }else {//不同则重新输入密码
+ }else {
+ // 如果两次输入的密码不同
+ // 通过响应输出一段JavaScript代码，弹出提示框提示两次密码不一样，并让用户重新输入密码
+ // 同时将页面重定向到学校管理员修改密码页面，并关闭当前窗口
resp.getWriter().write("");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+ // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求
+ // 直接调用doGet方法来处理POST请求，复用doGet方法中的逻辑
this.doGet(req, resp);
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/SchoAdmForgetPswServlet.java b/src/com/controller/frontweb/SchoAdmForgetPswServlet.java
index b256fd8..7af77ad 100644
--- a/src/com/controller/frontweb/SchoAdmForgetPswServlet.java
+++ b/src/com/controller/frontweb/SchoAdmForgetPswServlet.java
@@ -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("");
}else {
+ // 如果受影响的行数不大于0，说明密码更新操作失败
+ // 通过响应输出一段JavaScript代码，弹出提示框显示“修改密码失败！请重新输入密码！”
+ // 并将页面重定向到学校管理员忘记密码重置页面，同时关闭当前窗口
resp.getWriter().write("");
}
- }else {//不同则重新输入密码
+ }else {
+ // 如果用户输入的新密码和确认密码不相等
+ // 通过响应输出一段JavaScript代码，弹出提示框显示“两次密码不一样!请重新输入密码！”
+ // 并将页面重定向到学校管理员忘记密码重置页面，同时关闭当前窗口
resp.getWriter().write("");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+ // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求
+ // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/SchoAdmLoginServlet.java b/src/com/controller/frontweb/SchoAdmLoginServlet.java
index b7fff58..191d90c 100644
--- a/src/com/controller/frontweb/SchoAdmLoginServlet.java
+++ b/src/com/controller/frontweb/SchoAdmLoginServlet.java
@@ -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);
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/StuAlterPswServlet.java b/src/com/controller/frontweb/StuAlterPswServlet.java
index adb9a73..26a0033 100644
--- a/src/com/controller/frontweb/StuAlterPswServlet.java
+++ b/src/com/controller/frontweb/StuAlterPswServlet.java
@@ -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("");
}else {
+ // 如果受影响的行数不大于0，说明密码修改失败
+ // 通过响应输出一段JavaScript代码，弹出提示框提示修改密码失败，并让学生重新输入密码
+ // 同时将页面重定向到学生修改密码页面，并关闭当前窗口
resp.getWriter().write("");
}
- }else {//不同则重新输入密码
+ }else {
+ // 如果两次输入的密码不同
+ // 通过响应输出一段JavaScript代码，弹出提示框提示两次密码不一样，并让学生重新输入密码
+ // 同时将页面重定向到学生修改密码页面，并关闭当前窗口
resp.getWriter().write("");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+ // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求
+ // 直接调用doGet方法来处理POST请求，复用doGet方法中的逻辑
this.doGet(req, resp);
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/StuForgetPswServlet.java b/src/com/controller/frontweb/StuForgetPswServlet.java
index f68f255..78f4347 100644
--- a/src/com/controller/frontweb/StuForgetPswServlet.java
+++ b/src/com/controller/frontweb/StuForgetPswServlet.java
@@ -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("");
}else {
+ // 如果受影响的行数不大于0，说明密码更新操作失败
+ // 通过响应输出一段JavaScript代码，弹出提示框显示“修改密码失败！请重新输入密码！”
+ // 并将页面重定向到学生忘记密码重置页面，同时关闭当前窗口
resp.getWriter().write("");
}
- }else {//不同则重新输入密码
+ }else {
+ // 如果用户输入的新密码和确认密码不相等
+ // 通过响应输出一段JavaScript代码，弹出提示框显示“两次密码不一样!请重新输入密码！”
+ // 并将页面重定向到学生忘记密码重置页面，同时关闭当前窗口
resp.getWriter().write("");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+ // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求
+ // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/StuInfoServlet.java b/src/com/controller/frontweb/StuInfoServlet.java
index f69a61a..014a9e4 100644
--- a/src/com/controller/frontweb/StuInfoServlet.java
+++ b/src/com/controller/frontweb/StuInfoServlet.java
@@ -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);
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/StuLoginServlet.java b/src/com/controller/frontweb/StuLoginServlet.java
index b5f3398..e31762c 100644
--- a/src/com/controller/frontweb/StuLoginServlet.java
+++ b/src/com/controller/frontweb/StuLoginServlet.java
@@ -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);
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/StuPunchServlet.java b/src/com/controller/frontweb/StuPunchServlet.java
index dc1f864..1679e41 100644
--- a/src/com/controller/frontweb/StuPunchServlet.java
+++ b/src/com/controller/frontweb/StuPunchServlet.java
@@ -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("");
- }else {//已打卡
+ }else {
+ // 如果查询结果数量不为0，表示该学生今天已经打卡
+ // 通过响应输出一段JavaScript代码，弹出提示框提示今天已打卡，不能再次打卡
+ // 并将页面重定向到学生信息页面，同时关闭当前窗口
resp.getWriter().write("");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+ // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求
+ // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑
doGet(req, resp);
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/TeaAlterPswServlet.java b/src/com/controller/frontweb/TeaAlterPswServlet.java
index 33711d8..7d00e96 100644
--- a/src/com/controller/frontweb/TeaAlterPswServlet.java
+++ b/src/com/controller/frontweb/TeaAlterPswServlet.java
@@ -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("");
}else {
+ // 如果受影响的行数不大于0，说明密码修改失败
+ // 通过响应输出一段JavaScript代码，弹出提示框提示修改密码失败，并让教师重新输入密码
+ // 同时将页面重定向到教师修改密码页面，并关闭当前窗口
resp.getWriter().write("");
}
- }else {//不同则重新输入密码
+ }else {
+ // 如果两次输入的密码不同
+ // 通过响应输出一段JavaScript代码，弹出提示框提示两次密码不一样，并让教师重新输入密码
+ // 同时将页面重定向到教师修改密码页面，并关闭当前窗口
resp.getWriter().write("");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+ // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求
+ // 直接调用doGet方法来处理POST请求，复用doGet方法中的逻辑
this.doGet(req, resp);
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/TeaForgetPswServlet.java b/src/com/controller/frontweb/TeaForgetPswServlet.java
index 7ec4dab..c362266 100644
--- a/src/com/controller/frontweb/TeaForgetPswServlet.java
+++ b/src/com/controller/frontweb/TeaForgetPswServlet.java
@@ -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("");
}else {
+ // 如果受影响的行数不大于0，说明密码更新操作失败
+ // 通过响应输出一段JavaScript代码，弹出提示框显示“修改密码失败！请重新输入密码！”
+ // 并将页面重定向到教师忘记密码重置页面，同时关闭当前窗口
resp.getWriter().write("");
}
- }else {//不同则重新输入密码
+ }else {
+ // 如果教师输入的新密码和确认密码不相等
+ // 通过响应输出一段JavaScript代码，弹出提示框显示“两次密码不一样!请重新输入密码！”
+ // 并将页面重定向到教师忘记密码重置页面，同时关闭当前窗口
resp.getWriter().write("");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+ // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求
+ // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/TeaInfoServlet.java b/src/com/controller/frontweb/TeaInfoServlet.java
index 5d37852..b9809ed 100644
--- a/src/com/controller/frontweb/TeaInfoServlet.java
+++ b/src/com/controller/frontweb/TeaInfoServlet.java
@@ -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);
}
}
+``` 上述代码是重复的，因此只注释了一份。如果你还需要对第二份做特殊处理，请告诉我。
\ No newline at end of file
diff --git a/src/com/controller/frontweb/TeaLoginServlet.java b/src/com/controller/frontweb/TeaLoginServlet.java
index c832219..4761876 100644
--- a/src/com/controller/frontweb/TeaLoginServlet.java
+++ b/src/com/controller/frontweb/TeaLoginServlet.java
@@ -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);
}
-}
+}
\ No newline at end of file
diff --git a/src/com/controller/frontweb/TeaPunchServlet.java b/src/com/controller/frontweb/TeaPunchServlet.java
index 8bd8625..5192d10 100644
--- a/src/com/controller/frontweb/TeaPunchServlet.java
+++ b/src/com/controller/frontweb/TeaPunchServlet.java
@@ -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("");
- }else {//已经打卡
+ } else {
+ // 如果查询结果数量不为0，表示该教师今天已经打卡
+ // 通过响应输出一段JavaScript代码，弹出提示框提示今天已打卡，不能再次打卡
+ // 并将页面重定向到教师信息页面，同时关闭当前窗口
resp.getWriter().write("");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+ // 重写父类HttpServlet的doPost方法，用于处理HTTP POST请求
+ // 直接调用doGet方法来处理POST请求，复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
-}
+}
\ No newline at end of file