lsepidemicsituationsystem8/zp.txt

package com.controller.schoadmin;
// 包声明，指定该 Java 类所属的包为 com.controller.schoadmin

import com.dao.DeptAdminDao;
// 导入自定义的数据访问对象类 DeptAdminDao，用于执行数据库操作

import javax.servlet.ServletException;
// 导入 Servlet 异常类，用于处理 Servlet 相关的异常

import javax.servlet.annotation.WebServlet;
// 导入用于声明 Servlet 的注解类

import javax.servlet.http.HttpServlet;
// 导入 HttpServlet 类，这是所有 HTTP Servlet 的基类

import javax.servlet.http.HttpServletRequest;
// 导入用于处理 HTTP 请求的类

import javax.servlet.http.HttpServletResponse;
// 导入用于处理 HTTP 响应的类

import java.io.IOException;
// 导入用于处理输入输出异常的类

@WebServlet("/SchoDeleteStuServlet")
// 使用注解声明该 Servlet 的访问路径为 /SchoDeleteStuServlet

public class SchoDeleteStuServlet extends HttpServlet {
    // 定义一个名为 SchoDeleteStuServlet 的公共类，继承自 HttpServlet

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 重写父类 HttpServlet 的 doGet 方法，处理 HTTP GET 请求，可能会抛出 ServletException 和 IOException 异常

        req.setCharacterEncoding("utf-8");
        // 设置请求的字符编码为 UTF-8

        resp.setCharacterEncoding("utf-8");
        // 设置响应的字符编码为 UTF-8

        resp.setContentType("text/html;charset=utf-8");
        // 设置响应的内容类型为 HTML，字符编码为 UTF-8

        String sno = req.getParameter("sno");
        // 从请求中获取名为 "sno" 的参数值，并赋值给字符串变量 sno

        System.out.println(sno);
        // 在控制台打印输出 sno 的值

        String sql = null;
        // 声明一个字符串变量 sql 并初始化为 null，用于存储 SQL 语句

        Object[] objects = {sno};
        // 创建一个 Object 类型的数组 objects，包含一个元素 sno

        //查询是否存在此人
        // 注释，说明下面 SQL 语句的作用是查询是否存在该学生

        sql = "select count(*) as num from student where sno = ?";
        // 构建 SQL 语句，用于统计 student 表中 sno 等于指定值的记录数量，将结果别名为 num

        int count = DeptAdminDao.findTotalCount(sql, objects);
        // 调用 DeptAdminDao 类的 findTotalCount 方法执行 SQL 查询，传入 SQL 语句和参数数组，将返回的记录数量赋值给变量 count

        if (count > 0) { //有则继续操作
            // 如果 count 大于 0，说明存在该学生，执行下面的操作

            //删除stupunchin中的该导游信息
            // 注释，说明下面 SQL 语句的作用是删除 stupunchin 表中该学生的信息

            sql = "delete from stupunchin where sno = ?";
            // 构建 SQL 语句，用于从 stupunchin 表中删除 sno 等于指定值的记录

            int num1 = DeptAdminDao.executeUpdate(sql, objects);
            // 调用 DeptAdminDao 类的 executeUpdate 方法执行 SQL 删除操作，传入 SQL 语句和参数数组，将受影响的行数赋值给变量 num1

            System.out.println(num1);
            // 在控制台打印输出 num1 的值

            //删除student表中该导游信息
            // 注释，说明下面 SQL 语句的作用是删除 student 表中该学生的信息

            sql = "delete from student where sno = ?";
            // 构建 SQL 语句，用于从 student 表中删除 sno 等于指定值的记录

            int num2 = DeptAdminDao.executeUpdate(sql, objects);
            // 调用 DeptAdminDao 类的 executeUpdate 方法执行 SQL 删除操作，传入 SQL 语句和参数数组，将受影响的行数赋值给变量 num2

            System.out.println(num2);
            // 在控制台打印输出 num2 的值

            req.getRequestDispatcher("/SchoQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=").forward(req, resp);
            // 创建请求转发器，将请求转发到 /SchoQueryStuByPageServlet，并附带一些查询参数，然后将请求和响应对象传递给转发器进行转发

        }else {
            // 如果 count 不大于 0，即不存在该学生

            req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);
            // 创建请求转发器，将请求转发到 /view/alluse/noexistdataofdelete.jsp 页面，并将请求和响应对象传递给转发器进行转发
        }

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 重写父类 HttpServlet 的 doPost 方法，处理 HTTP POST 请求，可能会抛出 ServletException 和 IOException 异常

        doGet(req, resp);
        // 调用 doGet 方法来处理 POST 请求，即让 POST 请求的处理逻辑和 GET 请求一致
    }
}

// 声明该类所在的包为 com.controller.schoadmin
package com.controller.schoadmin;

// 导入 DeptAdminDao 类，该类可能封装了与部门管理员相关的数据库操作方法
import com.dao.DeptAdminDao;

// 导入 Servlet 异常类，用于处理 Servlet 操作过程中可能出现的异常
import javax.servlet.ServletException;
// 导入 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径
import javax.servlet.annotation.WebServlet;
// 导入 HttpServlet 类，这是所有 Servlet 类的基类
import javax.servlet.http.HttpServlet;
// 导入 HttpServletRequest 类，用于获取客户端的请求信息
import javax.servlet.http.HttpServletRequest;
// 导入 HttpServletResponse 类，用于向客户端发送响应信息
import javax.servlet.http.HttpServletResponse;
// 导入输入输出异常类，用于处理输入输出操作中可能出现的异常
import java.io.IOException;

// 使用 WebServlet 注解将该类映射到 /SchoDeleteTeaPunchServlet 路径，客户端可通过此路径访问该 Servlet
@WebServlet("/SchoDeleteTeaPunchServlet")
// 定义 SchoDeleteTeaPunchServlet 类，继承自 HttpServlet，表明这是一个处理 HTTP 请求的 Servlet
public class SchoDeleteTeaPunchServlet extends HttpServlet {

    // 重写 doGet 方法，用于处理客户端的 GET 请求
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 设置请求的字符编码为 UTF-8，防止中文乱码
        req.setCharacterEncoding("utf-8");
        // 设置响应的字符编码为 UTF-8，防止中文乱码
        resp.setCharacterEncoding("utf-8");
        // 设置响应的内容类型为 HTML，字符编码为 UTF-8
        resp.setContentType("text/html;charset=utf-8");

        // 从请求中获取名为 tnodate 的参数，该参数可能包含教师编号和打卡日期
        String tnodate = req.getParameter("tnodate");

        // 将获取到的 tnodate 参数打印到控制台，用于调试
        System.out.println(tnodate);

        // 使用逗号作为分隔符，将 tnodate 字符串拆分成一个字符串数组
        String[] params = tnodate.split(",");
        // 数组的第一个元素赋值给 tno 变量，代表教师编号
        String tno = params[0];
        // 数组的第二个元素赋值给 tpunchdate 变量，代表打卡日期
        String tpunchdate = params[1];

        // 将教师编号打印到控制台，用于调试
        System.out.println(tno);
        // 将打卡日期打印到控制台，用于调试
        System.out.println(tpunchdate);

        // 以下两行代码被注释掉，原计划将字符串类型的日期转换为 Date 类型，但未实际使用
        // Date spunchdate1 = new Date(spunchdate);
        // SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
        // Date spunchdate1 = ft.format(spunchdate);

        // 声明一个 SQL 语句变量，用于后续存储 SQL 语句
        String sql = null;
        // 创建一个 Object 数组，用于存储 SQL 查询或更新语句中的参数
        Object[] objects = {tno, tpunchdate};

        // 构建 SQL 查询语句，用于查询在 teapunchin 表中，指定教师编号和打卡日期的记录数量
        sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?";
        // 调用 DeptAdminDao 类的 findTotalCount 方法执行查询，返回符合条件的记录数量
        int count = DeptAdminDao.findTotalCount(sql, objects);

        // 如果查询到的记录数量大于 0，说明存在该教师在指定日期的打卡记录
        if (count > 0) {
            // 构建 SQL 删除语句，用于删除 teapunchin 表中指定教师编号和打卡日期的记录
            sql = "delete from teapunchin where tno = ? and tpunchdate = ?";
            // 调用 DeptAdminDao 类的 executeUpdate 方法执行删除操作，返回受影响的行数
            int num1 = DeptAdminDao.executeUpdate(sql, objects);
            // 将受影响的行数打印到控制台，用于调试
            System.out.println(num1);

            // 将请求转发到 SchoQueryTeaPunchByPageServlet，并传递分页和查询参数，刷新教师打卡记录页面
            req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp);
        } else {
            // 如果查询到的记录数量为 0，说明不存在该教师在指定日期的打卡记录
            // 将请求转发到 noexistdataofdelete.jsp 页面，提示用户要删除的数据不存在
            req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);
        }
    }

    // 重写 doPost 方法，用于处理客户端的 POST 请求
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 调用 doGet 方法处理 POST 请求，实现 GET 和 POST 请求的统一处理
        doGet(req, resp);
    }
}

// 声明该类所属的包为com.controller.schoadmin，通常用于存放与学校管理员相关的控制器类
package com.controller.schoadmin;

// 导入数据访问对象类，用于执行与部门管理员操作相关的数据访问，如数据库查询和更新
import com.dao.DeptAdminDao;

// 导入处理Servlet异常的类，当Servlet执行过程中出现异常时会抛出该异常
import javax.servlet.ServletException;
// 导入用于将Servlet映射到特定URL的注解
import javax.servlet.annotation.WebServlet;
// 导入所有HTTP Servlet的基类
import javax.servlet.http.HttpServlet;
// 导入用于封装HTTP请求信息的类
import javax.servlet.http.HttpServletRequest;
// 导入用于封装HTTP响应信息的类
import javax.servlet.http.HttpServletResponse;
// 导入用于管理用户会话的类，可获取和设置会话中的属性
import javax.servlet.http.HttpSession;
// 导入处理输入输出异常的类，当在输入输出操作中发生错误时会抛出该异常
import java.io.IOException;

// 使用WebServlet注解将该Servlet映射到/SchoDeleteTeaPunchServlet1路径
@WebServlet("/SchoDeleteTeaPunchServlet1")
// 定义一个名为SchoDeleteTeaPunchServlet1的类，继承自HttpServlet，用于处理学校管理员删除教师打卡信息的请求
public class SchoDeleteTeaPunchServlet1 extends HttpServlet {

    // 重写doGet方法，用于处理HTTP GET请求
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 设置请求的字符编码为UTF - 8，确保能正确处理包含中文字符等的请求参数
        req.setCharacterEncoding("utf-8");
        // 设置响应的字符编码为UTF - 8，保证响应内容中的中文字符能正确显示
        resp.setCharacterEncoding("utf-8");
        // 设置响应的内容类型为HTML，字符编码为UTF - 8，告知客户端返回的是HTML格式的数据
        resp.setContentType("text/html;charset=utf-8");

        // 从请求中获取名为tno的参数，代表教师编号
        String tno = req.getParameter("tno");
        // 从请求中获取名为tpunchdate的参数，代表打卡日期
        String tpunchdate = req.getParameter("tpunchdate");

        // 在控制台打印获取到的教师编号，用于调试，查看是否正确获取参数
        System.out.println(tno);
        // 在控制台打印获取到的打卡日期，用于调试
        System.out.println(tpunchdate);

        // 获取当前请求对应的会话对象
        HttpSession session = req.getSession();
        // 以下两行代码被注释掉，原本用于从会话中获取用户名和学号，这里未使用
//        String userName = (String) session.getAttribute("userName");
//        String sno = (String) session.getAttribute("sno");
        // 从会话中获取名为belong的属性值，可能代表教师所属部门
        String belong = (String) session.getAttribute("belong");

        // 以下注释掉的代码原本用于将字符串类型的日期转换为日期类型，但存在错误，转换方式不正确
        // 字符串转为日期类型
//        Date spunchdate1 = new Date(spunchdate);
        // 或
//        SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
//        Date spunchdate1 = ft.format(spunchdate);

        // 声明一个用于存储SQL语句的变量，初始值为null
        String sql = null;
        // 创建一个Object数组，用于存储SQL语句中的参数值，包含教师编号和打卡日期
        Object[] objects = {tno, tpunchdate};

        // 构建SQL查询语句，用于查询数据库中是否存在指定教师编号和打卡日期的记录，count(*) as num用于统计符合条件的记录数
        sql = "select count(*) as num from teacher t,teapunchin tp where t.tno = tp.tno and tp.tno = ? and tp.tpunchdate = ?";
        // 调用DeptAdminDao类的findTotalCount方法执行SQL查询，获取符合条件的记录数
        int count = DeptAdminDao.findTotalCount(sql, objects);

        // 如果count大于0，说明存在该教师编号和打卡日期对应的记录，可以继续进行删除操作
        if (count > 0) {
            // 构建SQL删除语句，用于从teapunchin表中删除指定教师编号和打卡日期的记录
            sql = "delete from teapunchin where tno = ? and tpunchdate = ?";
            // 调用DeptAdminDao类的executeUpdate方法执行SQL删除操作，并返回受影响的行数
            int num1 = DeptAdminDao.executeUpdate(sql, objects);
            // 在控制台打印受影响的行数，用于调试，查看删除操作是否成功
            System.out.println(num1);

            // 将请求转发到/SchoQueryTeaPunchByPageServlet，并传递一些参数，可能用于重新查询教师打卡信息列表，当前页码为1，每页显示7条记录，其他查询参数为空
            req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp);
        } else {
            // 如果count不大于0，说明不存在该教师编号和打卡日期对应的记录，将请求转发到提示不存在要删除数据的页面
            req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);
        }
    }

    // 重写doPost方法，用于处理HTTP POST请求，这里直接调用doGet方法，即POST请求的处理逻辑与GET请求相同
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
// 声明该类所在的包名为 com.controller.schoadmin
package com.controller.schoadmin;

// 导入 DeptAdminDao 类，该类可能包含了与部门管理相关的数据库操作方法
import com.dao.DeptAdminDao;

// 导入 Servlet 异常类，用于处理 Servlet 执行过程中可能出现的异常
import javax.servlet.ServletException;
// 导入 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径
import javax.servlet.annotation.WebServlet;
// 导入 HttpServlet 类，这是所有 Servlet 类的基类
import javax.servlet.http.HttpServlet;
// 导入 HttpServletRequest 类，用于获取客户端发送的请求信息
import javax.servlet.http.HttpServletRequest;
// 导入 HttpServletResponse 类，用于向客户端发送响应信息
import javax.servlet.http.HttpServletResponse;
// 导入输入输出异常类，用于处理输入输出操作可能产生的异常
import java.io.IOException;

// 使用 WebServlet 注解将该类映射到 /SchoDeleteTeaServlet 路径，客户端可通过此路径访问该 Servlet
@WebServlet("/SchoDeleteTeaServlet")
// 定义 SchoDeleteTeaServlet 类，继承自 HttpServlet，表明这是一个处理 HTTP 请求的 Servlet
public class SchoDeleteTeaServlet extends HttpServlet {

    // 重写 doGet 方法，用于处理客户端发送的 HTTP GET 请求
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 设置请求的字符编码为 UTF-8，防止中文等字符出现乱码
        req.setCharacterEncoding("utf-8");
        // 设置响应的字符编码为 UTF-8，防止响应信息出现乱码
        resp.setCharacterEncoding("utf-8");
        // 设置响应的内容类型为 HTML，并且字符编码为 UTF-8
        resp.setContentType("text/html;charset=utf-8");

        // 从请求参数中获取教师编号 tno
        String tno = req.getParameter("tno");

        // 将获取到的教师编号打印到控制台，方便调试
        System.out.println(tno);

        // 声明一个字符串变量 sql，用于存储 SQL 语句
        String sql = null;
        // 创建一个 Object 类型的数组 objects，用于存储 SQL 语句中的参数
        Object[] objects = {tno};

        // 构建一个 SQL 查询语句，用于查询 teacher 表中是否存在指定教师编号的记录
        sql = "select count(*) as num from teacher where tno = ?";
        // 调用 DeptAdminDao 类的 findTotalCount 方法执行上述 SQL 查询，返回符合条件的记录数量
        int count = DeptAdminDao.findTotalCount(sql, objects);

        // 如果查询到的记录数量大于 0，说明该教师记录存在
        if (count > 0) {
            // 构建 SQL 删除语句，用于删除 teapunchin 表中该教师的打卡信息
            sql = "delete from teapunchin where tno = ?";
            // 调用 DeptAdminDao 类的 executeUpdate 方法执行删除操作，返回受影响的行数
            int num1 = DeptAdminDao.executeUpdate(sql, objects);
            // 将受影响的行数打印到控制台，方便调试
            System.out.println(num1);

            // 构建 SQL 删除语句，用于删除 teacher 表中该教师的信息
            sql = "delete from teacher where tno = ?";
            // 调用 DeptAdminDao 类的 executeUpdate 方法执行删除操作，返回受影响的行数
            int num2 = DeptAdminDao.executeUpdate(sql, objects);
            // 将受影响的行数打印到控制台，方便调试
            System.out.println(num2);

            // 将请求转发到 SchoQueryTeaByPageServlet 并携带分页和查询参数，刷新教师列表页面
            req.getRequestDispatcher("/SchoQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=").forward(req, resp);
        } else {
            // 如果查询到的记录数量为 0，说明该教师记录不存在
            // 将请求转发到 noexistdataofdelete.jsp 页面，提示用户要删除的数据不存在
            req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);
        }
    }

    // 重写 doPost 方法，用于处理客户端发送的 HTTP POST 请求
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 调用 doGet 方法处理 POST 请求，实现 GET 和 POST 请求的统一处理
        doGet(req, resp);
    }
}
package com.controller.schoadmin;
// 声明该类所在的包为 com.controller.schoadmin

import com.dao.DeptAdminDao;
// 导入自定义的数据访问对象类 DeptAdminDao，用于与数据库进行交互

import javax.servlet.ServletException;
// 导入 Servlet 异常类，用于处理 Servlet 操作中可能出现的异常

import javax.servlet.annotation.WebServlet;
// 导入用于标注 Servlet 映射路径的注解类

import javax.servlet.http.HttpServlet;
// 导入 HttpServlet 类，是所有 HTTP Servlet 的基类

import javax.servlet.http.HttpServletRequest;
// 导入用于处理 HTTP 请求的类

import javax.servlet.http.HttpServletResponse;
// 导入用于处理 HTTP 响应的类

import java.io.IOException;
// 导入输入输出异常类，用于处理输入输出操作时可能出现的异常

@WebServlet("/SchoDelSelectedStuPunchServlet")
// 使用注解指定该 Servlet 的访问路径为 /SchoDelSelectedStuPunchServlet

public class SchoDelSelectedStuPunchServlet extends HttpServlet {
    // 定义一个名为 SchoDelSelectedStuPunchServlet 的公共类，继承自 HttpServlet

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 重写 HttpServlet 类的 doGet 方法，用于处理 HTTP GET 请求，可能会抛出 ServletException 和 IOException 异常

        req.setCharacterEncoding("utf-8");
        // 设置请求的字符编码为 UTF-8，以正确处理中文字符等

        resp.setCharacterEncoding("utf-8");
        // 设置响应的字符编码为 UTF-8

        resp.setContentType("text/html;charset=utf-8");
        // 设置响应的内容类型为 HTML，字符编码为 UTF-8

        //获取请求时复选框有选中的状态参数
        String[] snodates = req.getParameterValues("snodates");
        // 从请求中获取名为 "snodates" 的多个参数值，存储在字符串数组 snodates 中

        System.out.println(snodates);
        // 在控制台打印 snodates 数组的引用信息

        if(snodates.length > 0 && snodates != null){
            // 检查 snodates 数组不为空且有元素

            //遍历并删除选中的sno,y一个一个删除
            for (String snodate: snodates) {
                // 遍历 snodates 数组中的每个元素

                //分离两个参数
                String[] params = snodate.split(",");
                // 将每个 snodate 字符串按逗号分隔成字符串数组 params

                String sno = params[0];
                // 取出分隔后的第一个元素作为学生编号 sno

                String spunchdate = params[1];
                // 取出分隔后的第二个元素作为打卡日期 spunchdate

                System.out.println(sno);
                // 在控制台打印学生编号 sno

                System.out.println(spunchdate);
                // 在控制台打印打卡日期 spunchdate

                //字符串转为日期类型
//        Date spunchdate1 = new Date(spunchdate);
                // 注释掉的代码，尝试将字符串 spunchdate 转换为 Date 类型
                //或
//        SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
//        Date spunchdate1 = ft.format(spunchdate);
                // 注释掉的代码，使用 SimpleDateFormat 将字符串 spunchdate 格式化为日期类型

                String sql = null;
                // 声明一个字符串变量 sql 并初始化为 null，用于存储 SQL 语句

                Object[] objects = {sno, spunchdate};
                // 创建一个 Object 类型的数组 objects，包含学生编号和打卡日期

                //删除stupunchin中的该导游信息
                sql = "delete from stupunchin where sno = ? and spunchdate = ?";
                // 构建 SQL 语句，用于从 stupunchin 表中删除指定学生编号和打卡日期的记录

                int num1 = DeptAdminDao.executeUpdate(sql, objects);
                // 调用 DeptAdminDao 类的 executeUpdate 方法执行 SQL 删除操作，传入 SQL 语句和参数数组，返回受影响的行数并存储在 num1 中

                System.out.println(num1);
                // 在控制台打印受影响的行数

            }

            req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp);
            // 创建请求转发器，将请求转发到 /SchoQueryStuPunchByPageServlet 并附带一些查询参数，然后将请求和响应对象传递给转发器进行转发
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 重写 HttpServlet 类的 doPost 方法，用于处理 HTTP POST 请求，可能会抛出 ServletException 和 IOException 异常

        doGet(req, resp);
        // 调用 doGet 方法处理 POST 请求，即让 POST 请求的处理逻辑和 GET 请求相同
    }
}
package com.controller.schoadmin;
// 声明该类所在的包为 com.controller.schoadmin

import com.dao.DeptAdminDao;
// 导入自定义的数据访问对象类 DeptAdminDao，用于与数据库进行交互

import javax.servlet.ServletException;
// 导入 Servlet 异常类，用于处理 Servlet 操作中可能出现的异常

import javax.servlet.annotation.WebServlet;
// 导入用于标注 Servlet 映射路径的注解类

import javax.servlet.http.HttpServlet;
// 导入 HttpServlet 类，是所有 HTTP Servlet 的基类

import javax.servlet.http.HttpServletRequest;
// 导入用于处理 HTTP 请求的类

import javax.servlet.http.HttpServletResponse;
// 导入用于处理 HTTP 响应的类

import java.io.IOException;
// 导入输入输出异常类，用于处理输入输出操作时可能出现的异常

@WebServlet("/SchoDelSelectedStuPunchServlet")
// 使用注解指定该 Servlet 的访问路径为 /SchoDelSelectedStuPunchServlet

public class SchoDelSelectedStuPunchServlet extends HttpServlet {
    // 定义一个名为 SchoDelSelectedStuPunchServlet 的公共类，继承自 HttpServlet

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 重写 HttpServlet 类的 doGet 方法，用于处理 HTTP GET 请求，可能会抛出 ServletException 和 IOException 异常

        req.setCharacterEncoding("utf-8");
        // 设置请求的字符编码为 UTF-8，以正确处理中文字符等

        resp.setCharacterEncoding("utf-8");
        // 设置响应的字符编码为 UTF-8

        resp.setContentType("text/html;charset=utf-8");
        // 设置响应的内容类型为 HTML，字符编码为 UTF-8

        //获取请求时复选框有选中的状态参数
        String[] snodates = req.getParameterValues("snodates");
        // 从请求中获取名为 "snodates" 的多个参数值，存储在字符串数组 snodates 中

        System.out.println(snodates);
        // 在控制台打印 snodates 数组的引用信息

        if(snodates.length > 0 && snodates != null){
            // 检查 snodates 数组不为空且有元素

            //遍历并删除选中的sno,y一个一个删除
            for (String snodate: snodates) {
                // 遍历 snodates 数组中的每个元素

                //分离两个参数
                String[] params = snodate.split(",");
                // 将每个 snodate 字符串按逗号分隔成字符串数组 params

                String sno = params[0];
                // 取出分隔后的第一个元素作为学生编号 sno

                String spunchdate = params[1];
                // 取出分隔后的第二个元素作为打卡日期 spunchdate

                System.out.println(sno);
                // 在控制台打印学生编号 sno

                System.out.println(spunchdate);
                // 在控制台打印打卡日期 spunchdate

                //字符串转为日期类型
//        Date spunchdate1 = new Date(spunchdate);
                // 注释掉的代码，尝试将字符串 spunchdate 转换为 Date 类型
                //或
//        SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
//        Date spunchdate1 = ft.format(spunchdate);
                // 注释掉的代码，使用 SimpleDateFormat 将字符串 spunchdate 格式化为日期类型

                String sql = null;
                // 声明一个字符串变量 sql 并初始化为 null，用于存储 SQL 语句

                Object[] objects = {sno, spunchdate};
                // 创建一个 Object 类型的数组 objects，包含学生编号和打卡日期

                //删除stupunchin中的该导游信息
                sql = "delete from stupunchin where sno = ? and spunchdate = ?";
                // 构建 SQL 语句，用于从 stupunchin 表中删除指定学生编号和打卡日期的记录

                int num1 = DeptAdminDao.executeUpdate(sql, objects);
                // 调用 DeptAdminDao 类的 executeUpdate 方法执行 SQL 删除操作，传入 SQL 语句和参数数组，返回受影响的行数并存储在 num1 中

                System.out.println(num1);
                // 在控制台打印受影响的行数

            }

            req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp);
            // 创建请求转发器，将请求转发到 /SchoQueryStuPunchByPageServlet 并附带一些查询参数，然后将请求和响应对象传递给转发器进行转发
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 重写 HttpServlet 类的 doPost 方法，用于处理 HTTP POST 请求，可能会抛出 ServletException 和 IOException 异常

        doGet(req, resp);
        // 调用 doGet 方法处理 POST 请求，即让 POST 请求的处理逻辑和 GET 请求相同
    }
}
package com.controller.schoadmin;

import com.dao.DeptAdminDao;

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 java.io.IOException;

@WebServlet("/SchoDelSelectedTeaPunchServlet")
public class SchoDelSelectedTeaPunchServlet extends HttpServlet {
// 声明该类所属的包，表明该类用于处理学校管理员相关的控制器逻辑
package com.controller.schoadmin;

// 导入部门管理员数据访问对象类，用于执行数据库操作
import com.dao.DeptAdminDao;

// 导入Servlet异常类，用于处理Servlet执行过程中可能出现的异常
import javax.servlet.ServletException;
// 导入Servlet注解，用于将该Servlet映射到指定的URL路径
import javax.servlet.annotation.WebServlet;
// 导入HttpServlet基类，该类继承自它以处理HTTP请求
import javax.servlet.http.HttpServlet;
// 导入HTTP请求对象类，用于获取请求中的参数、属性等信息
import javax.servlet.http.HttpServletRequest;
// 导入HTTP响应对象类，用于设置响应的内容、状态码等信息
import javax.servlet.http.HttpServletResponse;
// 导入输入输出异常类，用于处理输入输出操作中可能出现的异常
import java.io.IOException;

    // 使用注解将该Servlet映射到指定的URL路径，客户端通过此路径访问该Servlet
    @WebServlet("/SchoDelSelectedTeaPunchServlet")
// 定义一个继承自HttpServlet的类，用于处理学校管理员删除选中教师打卡信息的请求
    public class SchoDelSelectedTeaPunchServlet extends HttpServlet {

        // 重写doGet方法，用于处理HTTP GET请求
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            // 设置请求的字符编码为UTF-8，确保能正确处理包含中文等特殊字符的请求参数
            req.setCharacterEncoding("utf-8");
            // 设置响应的字符编码为UTF-8，保证响应内容中的特殊字符能正确显示
            resp.setCharacterEncoding("utf-8");
            // 设置响应的内容类型为HTML，字符编码为UTF-8，告知客户端返回的是HTML格式的数据
            resp.setContentType("text/html;charset=utf-8");

            // 从请求中获取名为tnodates的参数数组，该数组包含了用户在复选框中选中的教师编号和打卡日期组合
            String[] tnodates = req.getParameterValues("tnodates");

            // 在控制台打印获取到的参数数组，用于调试
            System.out.println(tnodates);

            // 判断参数数组是否不为空且长度大于0，即是否有选中的记录
            if (tnodates.length > 0 && tnodates != null) {
                // 遍历参数数组，对每个选中的记录进行处理
                for (String tnodate : tnodates) {
                    // 将每个组合字符串按逗号分隔成教师编号和打卡日期两个参数
                    String[] params = tnodate.split(",");
                    // 获取教师编号
                    String tno = params[0];
                    // 获取打卡日期
                    String tpunchdate = params[1];

                    // 在控制台打印教师编号，用于调试
                    System.out.println(tno);
                    // 在控制台打印打卡日期，用于调试
                    System.out.println(tpunchdate);

                    // 以下注释掉的代码原本用于将字符串类型的日期转换为日期类型，但存在错误，转换方式不正确
                    // 字符串转为日期类型
//        Date spunchdate1 = new Date(spunchdate);
                    // 或
//        SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
//        Date spunchdate1 = ft.format(spunchdate);

                    // 声明一个用于存储SQL语句的变量
                    String sql = null;
                    // 创建一个包含SQL语句参数的对象数组，分别为教师编号和打卡日期
                    Object[] objects = {tno, tpunchdate};

                    // 构建SQL删除语句，用于删除教师打卡信息表中指定教师编号和打卡日期的记录
                    sql = "delete from teapunchin where tno = ? and tpunchdate = ?";
                    // 调用部门管理员数据访问对象的方法，执行SQL删除操作，并返回受影响的行数
                    int num1 = DeptAdminDao.executeUpdate(sql, objects);
                    // 在控制台打印受影响的行数，用于调试
                    System.out.println(num1);
                }

                // 将请求转发到分页查询教师打卡信息的Servlet，同时传递一些默认的查询参数，如当前页码为1，每页显示7条记录等
                req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp);
            }
        }

        // 重写doPost方法，用于处理HTTP POST请求，这里直接调用doGet方法，即POST请求的处理逻辑与GET请求相同
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req, resp);
        }
    }
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;charset=utf-8");

        //获取请求时复选框有选中的状态参数
        String[] tnodates = req.getParameterValues("tnodates");

        System.out.println(tnodates);

        if(tnodates.length > 0 && tnodates != null){
            //遍历并删除选中的sno,y一个一个删除
            for (String tnodate: tnodates) {

                //分离两个参数
                String[] params = tnodate.split(",");
                String tno = params[0];
                String tpunchdate = params[1];

                System.out.println(tno);
                System.out.println(tpunchdate);

                //字符串转为日期类型
//        Date spunchdate1 = new Date(spunchdate);
                //或
//        SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
//        Date spunchdate1 = ft.format(spunchdate);

                String sql = null;
                Object[] objects = {tno, tpunchdate};

                //删除stupunchin中的该信息
                sql = "delete from teapunchin where tno = ? and tpunchdate = ?";
                int num1 = DeptAdminDao.executeUpdate(sql, objects);
                System.out.println(num1);
            }

            req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp);
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
// 声明该类所在的包为 com.controller.schoadmin
package com.controller.schoadmin;

// 导入 com.dao 包下的 DeptAdminDao 类，用于数据访问操作
import com.dao.DeptAdminDao;
// 导入 com.entity 包下的 Student 类，用于表示学生实体
import com.entity.Student;
// 导入 com.utils 包下的 JDBCUtils 类，用于处理 JDBC 相关操作，如关闭资源等
import com.utils.JDBCUtils;

// 导入 Servlet 相关的异常类，用于处理 Servlet 操作中可能出现的异常
import javax.servlet.ServletException;
// 导入用于将 Servlet 映射到特定 URL 模式的注解
import javax.servlet.annotation.WebServlet;
// 导入 HttpServlet 类，这是所有 Servlet 类的基类
import javax.servlet.http.HttpServlet;
// 导入 HttpServletRequest 类，用于处理 HTTP 请求
import javax.servlet.http.HttpServletRequest;
// 导入 HttpServletResponse 类，用于处理 HTTP 响应
import javax.servlet.http.HttpServletResponse;
// 导入 IOException 类，用于处理输入输出异常
import java.io.IOException;
// 导入 ResultSet 类，用于处理 SQL 查询结果集
import java.sql.ResultSet;

// 使用 WebServlet 注解将该 Servlet 映射到 "/SchoQueryStuByIdServlet" 路径，
// 当客户端请求访问该路径时，该 Servlet 会被触发执行
@WebServlet("/SchoQueryStuByIdServlet")
// 定义 SchoQueryStuByIdServlet 类，继承自 HttpServlet 类，表明这是一个 Servlet 类
public class SchoQueryStuByIdServlet extends HttpServlet {

    // 重写 doGet 方法，用于处理 HTTP GET 请求
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 设置请求的字符编码为 UTF-8，以正确处理中文等字符
        req.setCharacterEncoding("utf-8");
        // 设置响应的字符编码为 UTF-8，以正确返回中文等字符
        resp.setCharacterEncoding("utf-8");//ugu
        // 设置响应的内容类型为 HTML，字符编码为 UTF-8
        resp.setContentType("text/html;charset=utf-8");

        // 从请求参数中获取名为 "sno" 的参数值，该值代表学生的学号
        String sno = req.getParameter("sno");

        // 声明一个 SQL 语句变量，初始化为 null
        String sql = null;
        // 创建一个对象数组，用于存储 SQL 查询中的参数，这里存储了学号
        Object[] objects = {sno};

        // 查询是否存在该学号对应的学生
        // 构造 SQL 语句，使用 count(*) 统计满足条件的记录数量，并将结果命名为 num
        sql = "select count(*) as num from student where sno = ?";
        // 调用 DeptAdminDao 类的 findTotalCount 方法，执行 SQL 查询并返回记录数量
        int count = DeptAdminDao.findTotalCount(sql, objects);

        // 如果查询到的记录数量大于 0，说明存在该学生
        if (count > 0){
            // 构造 SQL 语句，查询该学号对应的学生的所有信息
            sql = "select * from student where sno = ?";
            // 调用 DeptAdminDao 类的 qureyInfo 方法，执行 SQL 查询并返回结果集
            ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects);
            // 创建一个 Student 对象，用于存储查询到的学生信息
            Student student = new Student();

            try {
                // 遍历结果集
                while (resultSet.next()){
                    // 从结果集中获取学生的学号，并设置到 Student 对象中
                    student.setSno(resultSet.getString("sno"));
                    // 从结果集中获取学生的姓名，并设置到 Student 对象中
                    student.setSname(resultSet.getString("sname"));
                    // 从结果集中获取学生的性别，并设置到 Student 对象中
                    student.setSsex(resultSet.getString("ssex"));
                    // 从结果集中获取学生的年龄，并设置到 Student 对象中
                    student.setSage(resultSet.getInt("sage"));
                    // 从结果集中获取学生的班级，并设置到 Student 对象中
                    student.setSclass(resultSet.getString("sclass"));
                    // 从结果集中获取学生的专业，并设置到 Student 对象中
                    student.setSpecialty(resultSet.getString("specialty"));
                    // 从结果集中获取学生的系别，并设置到 Student 对象中
                    student.setSdept(resultSet.getString("sdept"));
                    // 从结果集中获取学生的电话号码，并设置到 Student 对象中
                    student.setSphone(resultSet.getString("sphone"));
                    // 从结果集中获取学生的密码，并设置到 Student 对象中
                    student.setSpsw(resultSet.getString("spsw"));
                }
            } catch (Exception e) {
                // 捕获并打印异常堆栈信息
                e.printStackTrace();
            } finally {
                // 无论是否发生异常，都关闭结果集以释放资源
                JDBCUtils.close(resultSet);
            }

            // 打印学生的性别信息，用于调试
            System.out.println(student.getSsex());

            // 将 Student 对象存储到请求属性中，以便在后续页面中使用
            req.setAttribute("student", student);

            // 使用请求转发将请求转发到 "/view/schoadmin/alterstu.jsp" 页面，
            // 并携带请求和响应对象，用于修改学生信息
            req.getRequestDispatcher("/view/schoadmin/alterstu.jsp").forward(req, resp);
        } else {
            // 如果查询到的记录数量为 0，说明不存在该学生
            // 使用请求转发将请求转发到 "/view/alluse/noexistdataofalter.jsp" 页面，
            // 提示用户要修改的数据不存在
            req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp);
        }
    }

    // 重写 doPost 方法，用于处理 HTTP POST 请求
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 对于 POST 请求，直接调用 doGet 方法进行处理，实现请求方法的统一处理
        doGet(req, resp);
    }
}
package com.controller.schoadmin;
// 声明该类所属的包为 com.controller.schoadmin，用于组织和管理学校管理员相关的控制器类

import com.dao.DeptAdminDao;
// 导入 com.dao 包下的 DeptAdminDao 类，该类可能包含与部门管理相关的数据访问方法

import com.entity.Student;
// 导入 com.entity 包下的 Student 类，该类是学生实体类，用于封装学生的相关信息

import com.utils.JDBCUtils;
// 导入 com.utils 包下的 JDBCUtils 类，该类可能包含与 JDBC 操作相关的工具方法，如关闭数据库连接等

import javax.servlet.ServletException;
// 导入 javax.servlet 包下的 ServletException 类，用于处理 Servlet 操作中可能出现的异常

import javax.servlet.annotation.WebServlet;
// 导入 javax.servlet.annotation 包下的 WebServlet 注解，用于将 Servlet 映射到指定的 URL 路径

import javax.servlet.http.HttpServlet;
// 导入 javax.servlet.http 包下的 HttpServlet 类，该类是所有 HTTP Servlet 的基类

import javax.servlet.http.HttpServletRequest;
// 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于封装客户端的 HTTP 请求信息

import javax.servlet.http.HttpServletResponse;
// 导入 javax.servlet.http 包下的 HttpServletResponse 类，用于封装服务器对客户端的 HTTP 响应信息

import java.io.IOException;
// 导入 java.io 包下的 IOException 类，用于处理输入输出操作中可能出现的异常

import java.sql.ResultSet;
// 导入 java.sql 包下的 ResultSet 类，用于表示数据库查询的结果集

@WebServlet("/SchoQueryStuByIdServlet")
// 使用 WebServlet 注解将该 Servlet 映射到 /SchoQueryStuByIdServlet 路径，当客户端访问该路径时，会调用该 Servlet 的相应方法

public class SchoQueryStuByIdServlet extends HttpServlet {
    // 继承自 HttpServlet 类，并重写 doGet 和 doPost 方法来处理 HTTP 的 GET 和 POST 请求

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 重写 doGet 方法，用于处理 HTTP GET 请求

        req.setCharacterEncoding("utf-8");
        // 设置请求的字符编码为 UTF-8，以正确处理中文等字符

        resp.setCharacterEncoding("utf-8");
        // 设置响应的字符编码为 UTF-8，确保响应内容能正确显示中文等字符

        resp.setContentType("text/html;charset=utf-8");
        // 设置响应的内容类型为 text/html，并指定字符编码为 UTF-8

        String sno = req.getParameter("sno");
        // 从请求参数中获取名为 sno 的值，该值可能是要查询的学生的学号

        String sql = null;
        // 声明一个字符串类型的变量 sql，用于存储 SQL 语句，初始化为 null

        Object[] objects = {sno};
        // 创建一个包含学号的对象数组，用于作为 SQL 查询的参数

        // 查询是否存在此人
        sql = "select count(*) as num from student where sno = ?";
        // 构造一个 SQL 查询语句，用于统计 student 表中学号等于传入学号的记录数量

        int count = DeptAdminDao.findTotalCount(sql, objects);
        // 调用 DeptAdminDao 类的 findTotalCount 方法执行 SQL 查询，并将结果存储在 count 变量中

        if (count > 0) { // 有则继续操作
            // 如果查询结果大于 0，说明存在该学号的学生

            sql = "select * from student where sno = ?";
            // 构造一个 SQL 查询语句，用于查询 student 表中学号等于传入学号的所有记录

            ResultSet resultSet = DeptAdminDao.qureyInfo(sql, objects);
            // 调用 DeptAdminDao 类的 qureyInfo 方法执行 SQL 查询，并将结果集存储在 resultSet 变量中

            Student student = new Student();
            // 创建一个 Student 对象，用于存储查询到的学生信息

            try {
                while (resultSet.next()) {
                    // 遍历结果集

                    student.setSno(resultSet.getString("sno"));
                    // 从结果集中获取学号，并设置到 Student 对象中

                    student.setSname(resultSet.getString("sname"));
                    // 从结果集中获取姓名，并设置到 Student 对象中

                    student.setSsex(resultSet.getString("ssex"));
                    // 从结果集中获取性别，并设置到 Student 对象中

                    student.setSage(resultSet.getInt("sage"));
                    // 从结果集中获取年龄，并设置到 Student 对象中

                    student.setSclass(resultSet.getString("sclass"));
                    // 从结果集中获取班级，并设置到 Student 对象中

                    student.setSpecialty(resultSet.getString("specialty"));
                    // 从结果集中获取专业，并设置到 Student 对象中

                    student.setSdept(resultSet.getString("sdept"));
                    // 从结果集中获取系部，并设置到 Student 对象中

                    student.setSphone(resultSet.getString("sphone"));
                    // 从结果集中获取电话号码，并设置到 Student 对象中

                    student.setSpsw(resultSet.getString("spsw"));
                    // 从结果集中获取密码，并设置到 Student 对象中
                }
            } catch (Exception e) {
                e.printStackTrace();
                // 捕获异常并打印异常堆栈信息
            } finally {
                JDBCUtils.close(resultSet);
                // 无论是否发生异常，都关闭结果集，释放资源
            }

            System.out.println(student.getSsex());
            // 打印查询到的学生的性别信息

            req.setAttribute("student", student);
            // 将查询到的 Student 对象存储在请求属性中，以便在后续的 JSP 页面中使用

            req.getRequestDispatcher("/view/schoadmin/alterstu.jsp").forward(req, resp);
            // 将请求转发到 /view/schoadmin/alterstu.jsp 页面，将查询到的学生信息传递给该页面

        } else {
            req.getRequestDispatcher("/view/alluse/noexistdataofalter.jsp").forward(req, resp);
            // 如果查询结果为 0，说明不存在该学号的学生，将请求转发到 /view/alluse/noexistdataofalter.jsp 页面，提示用户数据不存在
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 重写 doPost 方法，用于处理 HTTP POST 请求

        doGet(req, resp);
        // 调用 doGet 方法处理 POST 请求，即对 POST 请求的处理逻辑与 GET 请求相同
    }
}
// 声明该类所属的包为 com.controller.tea，通常用于存放与教师相关的控制器类
package com.controller.tea;

// 导入 com.dao 包下的 StuDao 类，可能用于处理学生相关的数据访问操作，不过在本类中未使用
import com.dao.StuDao;
// 导入 com.dao 包下的 TeaDao 类，用于处理教师相关的数据访问操作，如查询教师信息
import com.dao.TeaDao;
// 导入 com.entity 包下的 Student 类，代表学生实体，在本类中未使用
import com.entity.Student;
// 导入 com.entity 包下的 Teacher 类，代表教师实体，用于封装教师的各种属性
import com.entity.Teacher;
// 导入 com.utils 包下的 JDBCUtils 类，通常用于处理 JDBC 操作的工具类，如关闭数据库连接、结果集等
import com.utils.JDBCUtils;

// 导入 javax.servlet 包下的 ServletException 类，用于处理 Servlet 操作过程中可能出现的异常
import javax.servlet.ServletException;
// 导入 javax.servlet.annotation 包下的 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径
import javax.servlet.annotation.WebServlet;
// 导入 javax.servlet.http 包下的 HttpServlet 类，这是所有 HTTP Servlet 的基类，该类继承自它以处理 HTTP 请求
import javax.servlet.http.HttpServlet;
// 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息
import javax.servlet.http.HttpServletRequest;
// 导入 javax.servlet.http 包下的 HttpServletResponse 类，用于封装服务器发送给客户端的 HTTP 响应信息
import javax.servlet.http.HttpServletResponse;
// 导入 javax.servlet.http 包下的 HttpSession 类，用于管理用户会话，存储用户的会话信息
import javax.servlet.http.HttpSession;
// 导入 java.io 包下的 IOException 类，用于处理输入输出操作中可能出现的异常
import java.io.IOException;
// 导入 java.sql 包下的 ResultSet 类，用于存储数据库查询操作返回的结果集
import java.sql.ResultSet;
// 导入 java.util 包下的 ArrayList 类，这是一个动态数组，用于存储 Teacher 对象
import java.util.ArrayList;

// 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /TeaQueryInfoServlet
@WebServlet("/TeaQueryInfoServlet")
// 定义一个名为 TeaQueryInfoServlet 的类，继承自 HttpServlet，用于处理教师信息查询的请求
public class TeaQueryInfoServlet extends HttpServlet {

    // 重写 doGet 方法，用于处理 HTTP GET 请求
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 设置请求对象的字符编码为 UTF-8，确保能正确处理中文字符等
        req.setCharacterEncoding("utf-8");
        // 设置响应对象的字符编码为 UTF-8，确保返回给客户端的内容能正确显示中文字符等
        resp.setCharacterEncoding("utf-8");
        // 设置响应的内容类型为 text/html，字符编码为 UTF-8，告知客户端返回的是 HTML 内容且使用 UTF-8 编码
        resp.setContentType("text/html;charset=utf-8");

        // 从请求对象中获取当前的会话对象
        HttpSession session = req.getSession();
        // 从会话对象中获取名为 userName 的属性值，并将其转换为 String 类型
        String userName = (String) session.getAttribute("userName");
        // 从会话对象中获取名为 tno 的属性值，并将其转换为 String 类型，tno 代表教师编号
        String tno = (String) session.getAttribute("tno");

        // 在控制台打印用户名
        System.out.println(userName);
        // 在控制台打印教师编号
        System.out.println(tno);
        // 在控制台打印一段调试信息
        System.out.println("hdghghjg");

        // 定义一个 SQL 查询语句，用于从 teacher 表中查询教师编号等于指定值的所有记录
        String sql = "select * from teacher where tno = ?";
        // 定义一个 Object 类型的数组，用于存储 SQL 查询语句中的参数值，这里存储的是教师编号
        Object[] objects = {tno};

        // 调用 TeaDao 类的 qureyInfo 方法执行 SQL 查询，并将查询结果存储在 ResultSet 对象中
        ResultSet resultSet = TeaDao.qureyInfo(sql, objects);
        // 创建一个 ArrayList 对象，用于存储查询到的 Teacher 对象
        ArrayList<Teacher> teaArrayList = new ArrayList<Teacher>();
        try {
            // 遍历结果集，判断是否还有下一条记录
            while (resultSet.next()){
                // 创建一个新的 Teacher 对象
                Teacher teacher = new Teacher();
                // 从结果集中获取教师编号，并设置到 Teacher 对象中
                teacher.setTno(resultSet.getString("tno"));
                // 从结果集中获取教师姓名，并设置到 Teacher 对象中
                teacher.setTname(resultSet.getString("tname"));
                // 从结果集中获取教师性别，并设置到 Teacher 对象中
                teacher.setTsex(resultSet.getString("tsex"));
                // 从结果集中获取教师年龄，并设置到 Teacher 对象中
                teacher.setTage(resultSet.getInt("tage"));
                // 从结果集中获取教师所在部门，并设置到 Teacher 对象中
                teacher.setTdept(resultSet.getString("tdept"));
                // 从结果集中获取教师电话号码，并设置到 Teacher 对象中
                teacher.setTphone(resultSet.getString("tphone"));
                // 从结果集中获取教师密码，并设置到 Teacher 对象中
                teacher.setTpsw(resultSet.getString("tpsw"));
                // 将填充好信息的 Teacher 对象添加到 ArrayList 中
                teaArrayList.add(teacher);
            }
        } catch (Exception e) {
            // 若在遍历结果集过程中出现异常，打印异常堆栈信息
            e.printStackTrace();
        } finally {
            // 无论是否出现异常，最后都调用 JDBCUtils 类的 close 方法关闭结果集
            JDBCUtils.close(resultSet);
        }

        // 在控制台打印存储教师信息的 ArrayList
        System.out.println(teaArrayList);

        // 将存储教师信息的 ArrayList 作为属性添加到请求对象中，以便在后续的 JSP 页面中使用
        req.setAttribute("teaArrayList", teaArrayList);

        // 调用请求对象的 getRequestDispatcher 方法获取请求转发器，将请求转发到 /view/tea/teainfo.jsp 页面
        req.getRequestDispatcher("/view/tea/teainfo.jsp").forward(req, resp);
    }

    // 重写 doPost 方法，用于处理 HTTP POST 请求，这里直接调用 doGet 方法，即 POST 请求的处理逻辑与 GET 请求相同
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
// 声明该类所属的包为 com.controller.tea，通常用于存放与教师相关的控制器类
package com.controller.tea;

// 导入 com.dao 包下的 StuDao 类，不过在当前代码中未使用该类，可能后续有扩展需求
import com.dao.StuDao;
// 导入 com.dao 包下的 TeaDao 类，该类用于处理与教师相关的数据访问操作，如查询、统计等
import com.dao.TeaDao;
// 导入 com.entity 包下的 PageBean 类，用于封装分页信息，辅助实现分页查询功能
import com.entity.PageBean;
// 导入 com.entity 包下的 StuPunch 类，代表学生打卡信息实体，此处虽使用但类型可能有误，实际应是 TeaPunch 类型
import com.entity.StuPunch;
// 导入 com.entity 包下的 TeaPunch 类，代表教师打卡信息实体，用于封装教师打卡的各项属性
import com.entity.TeaPunch;
// 导入 com.utils 包下的 JDBCUtils 类，这是一个工具类，通常用于处理 JDBC 操作，如关闭数据库连接、结果集等
import com.utils.JDBCUtils;

// 导入 javax.servlet 包下的 ServletException 类，用于处理 Servlet 操作过程中可能出现的异常
import javax.servlet.ServletException;
// 导入 javax.servlet.annotation 包下的 WebServlet 注解，用于将该类标记为一个 Servlet，并指定其访问路径
import javax.servlet.annotation.WebServlet;
// 导入 javax.servlet.http 包下的 HttpServlet 类，这是所有 HTTP Servlet 的基类，该类继承自它以处理 HTTP 请求
import javax.servlet.http.HttpServlet;
// 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于封装客户端发送的 HTTP 请求信息
import javax.servlet.http.HttpServletRequest;
// 导入 javax.servlet.http 包下的 HttpServletResponse 类，用于封装服务器发送给客户端的 HTTP 响应信息
import javax.servlet.http.HttpServletResponse;
// 导入 javax.servlet.http 包下的 HttpSession 类，用于管理用户会话，存储用户的会话信息
import javax.servlet.http.HttpSession;
// 导入 java.io 包下的 IOException 类，用于处理输入输出操作中可能出现的异常
import java.io.IOException;
// 导入 java.sql 包下的 ResultSet 类，用于存储数据库查询操作返回的结果集
import java.sql.ResultSet;
// 导入 java.util 包下的 ArrayList 类，这是一个动态数组，用于存储 TeaPunch 对象
import java.util.ArrayList;

// 使用 WebServlet 注解将该类标记为一个 Servlet，并指定其访问路径为 /TeaQueryPunchByPageServlet
@WebServlet("/TeaQueryPunchByPageServlet")
// 定义一个名为 TeaQueryPunchByPageServlet 的类，继承自 HttpServlet，用于处理教师分页查询打卡信息的请求
public class TeaQueryPunchByPageServlet extends HttpServlet {

    // 重写 doGet 方法，用于处理 HTTP GET 请求
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 设置请求对象的字符编码为 UTF-8，确保能正确处理中文字符等
        req.setCharacterEncoding("utf-8");
        // 设置响应对象的字符编码为 UTF-8，确保返回给客户端的内容能正确显示中文字符等
        resp.setCharacterEncoding("utf-8");
        // 设置响应的内容类型为 text/html，字符编码为 UTF-8，告知客户端返回的是 HTML 内容且使用 UTF-8 编码
        resp.setContentType("text/html;charset=utf-8");

        // 从请求对象中获取名为 tpunchdate 的参数，该参数用于作为查询教师打卡日期的条件
        String tpunchdate = req.getParameter("tpunchdate");

        // 如果获取到的 tpunchdate 为 null，则将其赋值为空字符串
        if (tpunchdate == null) {
            tpunchdate = "";
        }

        // 在 tpunchdate 前后添加 % 通配符，用于模糊查询
        String tpunchdate1 = "%" + tpunchdate + "%";
        // 在控制台打印处理后的 tpunchdate1
        System.out.println(tpunchdate1);

        // 将 tpunchdate 参数添加到请求对象的属性中，以便后续页面使用
        req.setAttribute("tpunchdate", tpunchdate);

        // 从请求对象中获取当前的会话对象
        HttpSession session = req.getSession();
        // 从会话对象中获取名为 userName 的属性值，并将其转换为 String 类型
        String userName = (String) session.getAttribute("userName");
        // 从会话对象中获取名为 tno 的属性值，并将其转换为 String 类型，tno 代表教师编号
        String tno = (String) session.getAttribute("tno");

        // 声明一个 String 类型的变量 sql，用于存储 SQL 查询语句
        String sql = null;

        // 在控制台打印用户名
        System.out.println(userName);
        // 在控制台打印教师编号
        System.out.println(tno);
        // 在控制台打印一段调试信息
        System.out.println("hdghghjg");

        // 从请求对象中获取名为 currentPage 的参数，该参数表示当前页码
        String currentPage = req.getParameter("currentPage");
        // 从请求对象中获取名为 rows 的参数，该参数表示每页显示的记录数
        String rows = req.getParameter("rows");

        // 如果当前页码参数为空或者为空字符串，则将当前页码设置为 1
        if (currentPage == null || "".equals(currentPage)) {
            currentPage = "1";
        }

        // 如果每页显示记录数参数为空或者为空字符串，则将每页显示记录数设置为 8
        if (rows == null || "".equals(rows)) {
            rows = "8";
        }

        // 将当前页码的字符串类型转换为整数类型
        int currentPage1 = Integer.parseInt(currentPage);
        // 将每页显示记录数的字符串类型转换为整数类型
        int rows1 = Integer.parseInt(rows);

        // 如果当前页码小于等于 0，则将当前页码设置为 1
        if (currentPage1 <= 0) {
            currentPage1 = 1;
        }

        // 创建一个 PageBean 类型的对象，泛型为 StuPunch（此处类型可能有误，应是 TeaPunch），用于封装分页信息和教师打卡信息
        PageBean<StuPunch> pageBean = new PageBean<StuPunch>();

        // 设置 PageBean 对象的当前页码属性
        pageBean.setCurrentPage(currentPage1);

        // 设置 PageBean 对象的每页记录数属性
        pageBean.setRows(rows1);

        // 定义一个 SQL 查询语句，用于查询满足条件的记录总数
        sql = " select count(*) as num from teacher t,teapunchin tp where t.tno = tp.tno and tp.tpunchdate like ? and t.tno = ?";
        // 定义一个 Object 类型的数组，用于存储 SQL 查询语句中的参数值
        Object[] objects = {tpunchdate1, tno};

        // 调用 TeaDao 类的 findTotalCount 方法，根据 SQL 语句和参数计算满足条件的总记录数
        int totalCount = TeaDao.findTotalCount(sql, objects);
        // 在控制台打印总记录数
        System.out.println(totalCount);
        // 设置 PageBean 对象的总记录数属性
        pageBean.setTotalCount(totalCount);

        // 如果总记录数大于 0，说明有符合条件的记录
        if (totalCount > 0) {
            // 计算总页数，如果总记录数能被每页记录数整除，则总页数为总记录数除以每页记录数，否则总页数为总记录数除以每页记录数再加 1
            int totalPage = (totalCount % rows1) == 0 ? totalCount / rows1 : (totalCount / rows1 + 1);
            // 设置 PageBean 对象的总页数属性
            pageBean.setTotalPage(totalPage);

            // 如果当前页码大于总页数，则将当前页码设置为总页数
            if (currentPage1 > pageBean.getTotalPage()) {
                currentPage1 = pageBean.getTotalPage();
                // 重新设置 PageBean 对象的当前页码属性
                pageBean.setCurrentPage(currentPage1);
            }

            // 计算当前页开始的记录索引
            int start = (currentPage1 - 1) * rows1;
            // 定义一个 SQL 查询语句，用于查询当前页的教师打卡信息
            sql = "select t.tname,tp.* from teacher t,teapunchin tp where t.tno = tp.tno and tp.tpunchdate like ? and tp.tno = ? limit ?, ?";
            // 定义一个 Object 类型的数组，用于存储 SQL 查询语句中的参数值
            Object[] objects1 = {tpunchdate1, tno, start, rows1};

            // 调用 TeaDao 类的 QureyInfoByPage 方法，根据 SQL 语句和参数查询当前页的教师打卡信息，并将结果存储在 ResultSet 对象中
            ResultSet resultSet = TeaDao.QureyInfoByPage(sql, objects1);
            // 创建一个 ArrayList 对象，用于存储查询到的教师打卡信息
            ArrayList teaPunchArrayList = new ArrayList();

            try {
                // 遍历结果集，判断是否还有下一条记录
                while (resultSet.next()) {
                    // 创建一个新的 TeaPunch 对象
                    TeaPunch teaPunch = new TeaPunch();
                    // 从结果集中获取教师姓名，并设置到 TeaPunch 对象中
                    teaPunch.setTname(resultSet.getString("tname"));
                    // 从结果集中获取是否打卡的信息，并设置到 TeaPunch 对象中
                    teaPunch.setTispunch(resultSet.getString("tispunch"));
                    // 从结果集中获取打卡日期，并设置到 TeaPunch 对象中
                    teaPunch.setTpunchdate(resultSet.getDate("tpunchdate"));
                    // 从结果集中获取打卡时间，并设置到 TeaPunch 对象中
                    teaPunch.setTpunchtime(resultSet.getString("tpunchtime"));
                    // 从结果集中获取是否发热的信息，并设置到 TeaPunch 对象中
                    teaPunch.setTishot(resultSet.getString("tishot"));
                    // 从结果集中获取是否咳嗽的信息，并设置到 TeaPunch 对象中
                    teaPunch.setTiscough(resultSet.getString("tiscough"));
                    // 从结果集中获取是否有症状的信息，并设置到 TeaPunch 对象中
                    teaPunch.setTisseem(resultSet.getString("tisseem"));
                    // 从结果集中获取是否确诊的信息，并设置到 TeaPunch 对象中
                    teaPunch.setTisdiagnose(resultSet.getString("tisdiagnose"));
                    // 从结果集中获取打卡状态的信息，并设置到 TeaPunch 对象中
                    teaPunch.setTstatus(resultSet.getString("tstatus"));
                    // 将填充好信息的 TeaPunch 对象添加到 ArrayList 中
                    teaPunchArrayList.add(teaPunch);
                }
            } catch (Exception e) {
                // 若在遍历结果集过程中出现异常，打印异常堆栈信息
                e.printStackTrace();
            } finally {
                // 无论是否出现异常，最后都调用 JDBCUtils 类的 close 方法关闭结果集
                JDBCUtils.close(resultSet);
            }
            // 将存储教师打卡信息的 ArrayList 设置到 PageBean 对象中
            pageBean.setArrayList(teaPunchArrayList);

            // 在控制台打印存储教师打卡信息的 ArrayList
            System.out.println(teaPunchArrayList);
            // 在控制台打印 PageBean 对象
            System.out.println(pageBean);

            // 将 PageBean 对象作为属性添加到请求对象中，以便在后续的 JSP 页面中使用
            req.setAttribute("pageBean", pageBean);

            // 调用请求对象的 getRequestDispatcher 方法获取请求转发器，将请求转发到 /view/tea/teapunchinfo.jsp 页面
            req.getRequestDispatcher("/view/tea/teapunchinfo.jsp").forward(req, resp);
        } else {
            // 如果总记录数为 0，说明没有符合条件的记录，将请求转发到 /view/alluse/nodata.jsp 页面
            req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp);
        }
    }

    // 重写 doPost 方法，用于处理 HTTP POST 请求，这里直接调用 doGet 方法，即 POST 请求的处理逻辑与 GET 请求相同
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
package com.dao;
// 声明该类所属的包为 com.dao，包用于组织和管理 Java 类

import com.utils.JDBCUtils;
// 导入 com.utils 包下的 JDBCUtils 类，这个类可能包含了一些与 JDBC 操作相关的工具方法，
// 例如获取数据库连接、关闭连接等

import java.sql.Connection;
// 导入 java.sql 包下的 Connection 类，用于表示与数据库的连接

import java.sql.PreparedStatement;
// 导入 java.sql 包下的 PreparedStatement 类，用于执行预编译的 SQL 语句，提高性能和安全性

import java.sql.ResultSet;
// 导入 java.sql 包下的 ResultSet 类，用于处理数据库查询返回的结果集

public class DeptAdminDao {
    // 定义一个静态的 Connection 类型变量，用于存储数据库连接对象，初始化为 null
    private static Connection connection = null;
    // 定义一个静态的 PreparedStatement 类型变量，用于存储预编译的 SQL 语句对象，初始化为 null
    private static PreparedStatement preparedStatement = null;
    // 定义一个静态的 ResultSet 类型变量，用于存储数据库查询的结果集对象，初始化为 null
    private static ResultSet resultSet = null;

    // 用于登录查找的方法，接收 SQL 语句和一个包含查询参数的对象数组作为参数，返回查询结果集
    public static ResultSet login(String sql, Object[] objects) {
        try {
            // 通过 JDBCUtils 类的 getConnection 方法获取数据库连接，并将其赋值给 connection 变量
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，预编译传入的 SQL 语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将每个参数设置到 PreparedStatement 对象的相应位置（索引从 1 开始）
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行预编译的 SQL 查询语句，并将查询结果存储在 resultSet 变量中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 如果在上述操作中发生异常，打印异常的堆栈跟踪信息，方便调试
            e.printStackTrace();
        }

        // 返回查询结果集
        return resultSet;
    }

    // 用于查询所有表（带限制条件或无限制条件）的数据的方法，接收 SQL 语句和参数数组，返回结果集
    public static ResultSet qureyInfo(String sql, Object[] objects){
        try {
            // 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译的 SQL 语句对象
            preparedStatement = connection.prepareStatement(sql);
            // 设置查询参数
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行查询并获取结果集
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 捕获并打印异常信息
            e.printStackTrace();
        }
        // 返回查询结果集
        return resultSet;
    }

    // 查询总记录数的方法，接收 SQL 语句和参数数组，返回查询到的总记录数
    public static int findTotalCount(String sql, Object[] objects){
        // 定义一个整型变量 num 用于存储总记录数，初始值为 0
        int num = 0;
        try {
            // 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译的 SQL 语句对象
            preparedStatement = connection.prepareStatement(sql);
            // 设置查询参数
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行查询并获取结果集
            resultSet = preparedStatement.executeQuery();
            // 将结果集的指针移动到第一行（因为查询的是总记录数，一般只有一行结果）
            resultSet.next();
            // 从结果集中获取名为 "num" 的列的值，并赋值给 num 变量
            num = resultSet.getInt("num");
            // 打印总记录数（可能用于调试或查看中间结果）
            System.out.println(num);
        } catch (Exception e) {
            // 捕获并打印异常信息
            e.printStackTrace();
        } finally {
            // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭结果集、预编译语句对象和数据库连接，释放资源
            JDBCUtils.close(resultSet, preparedStatement, connection);
        }

        // 返回总记录数
        return num;
    }

    // 查询每页内容的方法，接收 SQL 语句和参数数组，返回查询结果集
    public static ResultSet QureyInfoByPage(String sql, Object[] objects){
        try {
            // 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译的 SQL 语句对象
            preparedStatement = connection.prepareStatement(sql);
            // 设置查询参数
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行查询并获取结果集
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 捕获并打印异常信息
            e.printStackTrace();
        }
        // 返回查询结果集
        return resultSet;
    }

    // 执行更新语句（包括增、删、改操作）的方法，接收 SQL 语句和参数数组，返回受影响的行数
    public static int executeUpdate(String sql, Object[] objects){
        // 定义一个整型变量 num 用于存储受影响的行数，初始值为 0
        int num = 0;
        try {
            // 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译的 SQL 语句对象
            preparedStatement = connection.prepareStatement(sql);
            // 设置查询参数
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行更新操作，并将受影响的行数赋值给 num 变量
            num = preparedStatement.executeUpdate();
        } catch (Exception e) {
            // 捕获并打印异常信息
            e.printStackTrace();
        } finally {
            // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭预编译语句对象和数据库连接，释放资源
            JDBCUtils.close(preparedStatement, connection);
        }

        // 返回受影响的行数
        return num;
    }
}
package com.dao;
// 声明该类所属的包为 com.dao，包用于组织和管理 Java 类

import com.utils.JDBCUtils;
// 导入 com.utils 包下的 JDBCUtils 类，这个类可能包含了一些与 JDBC 操作相关的工具方法，
// 例如获取数据库连接、关闭连接等

import java.sql.Connection;
// 导入 java.sql 包下的 Connection 类，用于表示与数据库的连接

import java.sql.PreparedStatement;
// 导入 java.sql 包下的 PreparedStatement 类，用于执行预编译的 SQL 语句，提高性能和安全性

import java.sql.ResultSet;
// 导入 java.sql 包下的 ResultSet 类，用于处理数据库查询返回的结果集

public class DeptAdminDao {
    // 定义一个静态的 Connection 类型变量，用于存储数据库连接对象，初始化为 null
    private static Connection connection = null;
    // 定义一个静态的 PreparedStatement 类型变量，用于存储预编译的 SQL 语句对象，初始化为 null
    private static PreparedStatement preparedStatement = null;
    // 定义一个静态的 ResultSet 类型变量，用于存储数据库查询的结果集对象，初始化为 null
    private static ResultSet resultSet = null;

    // 用于登录查找的方法，接收 SQL 语句和一个包含查询参数的对象数组作为参数，返回查询结果集
    public static ResultSet login(String sql, Object[] objects) {
        try {
            // 通过 JDBCUtils 类的 getConnection 方法获取数据库连接，并将其赋值给 connection 变量
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，预编译传入的 SQL 语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将每个参数设置到 PreparedStatement 对象的相应位置（索引从 1 开始）
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行预编译的 SQL 查询语句，并将查询结果存储在 resultSet 变量中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 如果在上述操作中发生异常，打印异常的堆栈跟踪信息，方便调试
            e.printStackTrace();
        }

        // 返回查询结果集
        return resultSet;
    }

    // 用于查询所有表（带限制条件或无限制条件）的数据的方法，接收 SQL 语句和参数数组，返回结果集
    public static ResultSet qureyInfo(String sql, Object[] objects){
        try {
            // 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译的 SQL 语句对象
            preparedStatement = connection.prepareStatement(sql);
            // 设置查询参数
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行查询并获取结果集
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 捕获并打印异常信息
            e.printStackTrace();
        }
        // 返回查询结果集
        return resultSet;
    }

    // 查询总记录数的方法，接收 SQL 语句和参数数组，返回查询到的总记录数
    public static int findTotalCount(String sql, Object[] objects){
        // 定义一个整型变量 num 用于存储总记录数，初始值为 0
        int num = 0;
        try {
            // 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译的 SQL 语句对象
            preparedStatement = connection.prepareStatement(sql);
            // 设置查询参数
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行查询并获取结果集
            resultSet = preparedStatement.executeQuery();
            // 将结果集的指针移动到第一行（因为查询的是总记录数，一般只有一行结果）
            resultSet.next();
            // 从结果集中获取名为 "num" 的列的值，并赋值给 num 变量
            num = resultSet.getInt("num");
            // 打印总记录数（可能用于调试或查看中间结果）
            System.out.println(num);
        } catch (Exception e) {
            // 捕获并打印异常信息
            e.printStackTrace();
        } finally {
            // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭结果集、预编译语句对象和数据库连接，释放资源
            JDBCUtils.close(resultSet, preparedStatement, connection);
        }

        // 返回总记录数
        return num;
    }

    // 查询每页内容的方法，接收 SQL 语句和参数数组，返回查询结果集
    public static ResultSet QureyInfoByPage(String sql, Object[] objects){
        try {
            // 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译的 SQL 语句对象
            preparedStatement = connection.prepareStatement(sql);
            // 设置查询参数
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行查询并获取结果集
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 捕获并打印异常信息
            e.printStackTrace();
        }
        // 返回查询结果集
        return resultSet;
    }

    // 执行更新语句（包括增、删、改操作）的方法，接收 SQL 语句和参数数组，返回受影响的行数
    public static int executeUpdate(String sql, Object[] objects){
        // 定义一个整型变量 num 用于存储受影响的行数，初始值为 0
        int num = 0;
        try {
            // 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译的 SQL 语句对象
            preparedStatement = connection.prepareStatement(sql);
            // 设置查询参数
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行更新操作，并将受影响的行数赋值给 num 变量
            num = preparedStatement.executeUpdate();
        } catch (Exception e) {
            // 捕获并打印异常信息
            e.printStackTrace();
        } finally {
            // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭预编译语句对象和数据库连接，释放资源
            JDBCUtils.close(preparedStatement, connection);
        }

        // 返回受影响的行数
        return num;
    }
}
// 声明该类所在的包名为 com.dao
package com.dao;

// 导入自定义的 JDBC 工具类，该类应该包含了获取数据库连接、关闭资源等操作的方法
import com.utils.JDBCUtils;

// 导入 java.sql 包下的 Connection 类，用于表示与数据库的连接
import java.sql.Connection;
// 导入 java.sql 包下的 PreparedStatement 类，用于执行预编译的 SQL 语句
import java.sql.PreparedStatement;
// 导入 java.sql 包下的 ResultSet 类，用于存储 SQL 查询的结果集
import java.sql.ResultSet;

// 定义一个名为 SchoAdminDao 的公共类，用于封装与数据库交互的操作
public class SchoAdminDao {

    // 声明一个静态的 Connection 类型变量，用于存储数据库连接对象，初始化为 null
    private static Connection connection = null;
    // 声明一个静态的 PreparedStatement 类型变量，用于执行预编译的 SQL 语句，初始化为 null
    private static PreparedStatement preparedStatement = null;
    // 声明一个静态的 ResultSet 类型变量，用于存储 SQL 查询的结果集，初始化为 null
    private static ResultSet resultSet = null;

    /**
     * 用于登录查找的方法
     * @param sql 要执行的 SQL 查询语句
     * @param objects SQL 查询语句中的参数数组
     * @return 包含查询结果的 ResultSet 对象
     */
    public static ResultSet login(String sql, Object[] objects) {
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息
            e.printStackTrace();
        }

        // 返回包含查询结果的 ResultSet 对象
        return resultSet;
    }

    /**
     * 用于查询所有表（带限制条件或无限制条件）的数据，返回结果集
     * @param sql 要执行的 SQL 查询语句
     * @param objects SQL 查询语句中的参数数组
     * @return 包含查询结果的 ResultSet 对象
     */
    public static ResultSet qureyInfo(String sql, Object[] objects){
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息
            e.printStackTrace();
        }
        // 返回包含查询结果的 ResultSet 对象
        return resultSet;
    }

    /**
     * 查询总记录数，返回总记录数
     * @param sql 要执行的 SQL 查询语句
     * @param objects SQL 查询语句中的参数数组
     * @return 总记录数
     */
    public static int findTotalCount(String sql, Object[] objects){
        // 声明一个整型变量 num，用于存储总记录数，初始值为 0
        int num = 0;
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
            resultSet = preparedStatement.executeQuery();
            // 将 ResultSet 的指针移动到下一行（通常查询总记录数的结果只有一行）
            resultSet.next();
            // 从 ResultSet 中获取名为 "num" 的列的值，并赋值给 num 变量
            num = resultSet.getInt("num");
            // 打印总记录数
            System.out.println(num);
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息
            e.printStackTrace();
        } finally {
            // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 ResultSet、PreparedStatement 和 Connection 对象
            JDBCUtils.close(resultSet, preparedStatement, connection);
        }

        // 返回总记录数
        return num;
    }

    /**
     * 查询每页的内容
     * @param sql 要执行的 SQL 查询语句
     * @param objects SQL 查询语句中的参数数组
     * @return 包含查询结果的 ResultSet 对象
     */
    public static ResultSet QureyInfoByPage(String sql, Object[] objects){
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息
            e.printStackTrace();
        }
        // 返回包含查询结果的 ResultSet 对象
        return resultSet;
    }

    /**
     * 执行更新语句，包括增、删、改操作
     * @param sql 要执行的 SQL 更新语句
     * @param objects SQL 更新语句中的参数数组
     * @return 受影响的行数
     */
    public static int executeUpdate(String sql, Object[] objects){
        // 声明一个整型变量 num，用于存储受影响的行数，初始值为 0
        int num = 0;
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 更新语句，并将受影响的行数赋值给 num 变量
            num = preparedStatement.executeUpdate();
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息
            e.printStackTrace();
        } finally {
            // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 PreparedStatement 和 Connection 对象
            JDBCUtils.close(preparedStatement, connection);
        }

        // 返回受影响的行数
        return num;
    }
}
// 声明该类所属的包为 com.dao，包用于组织和管理 Java 类，避免命名冲突
package com.dao;

// 导入自定义的 JDBC 工具类，该工具类应该封装了获取数据库连接、关闭连接等操作
import com.utils.JDBCUtils;

// 导入 java.sql 包中的 Connection 类，用于表示与数据库的连接
import java.sql.Connection;
// 导入 java.sql 包中的 PreparedStatement 类，用于执行预编译的 SQL 语句，可防止 SQL 注入
import java.sql.PreparedStatement;
// 导入 java.sql 包中的 ResultSet 类，用于存储 SQL 查询操作返回的结果集
import java.sql.ResultSet;

// 定义一个公共类 StuDao，该类可能用于处理与学生相关的数据库操作
public class StuDao {

    // 声明一个静态的 Connection 类型变量，用于存储数据库连接对象，初始值为 null
    private static Connection connection = null;
    // 声明一个静态的 PreparedStatement 类型变量，用于执行预编译的 SQL 语句，初始值为 null
    private static PreparedStatement preparedStatement = null;
    // 声明一个静态的 ResultSet 类型变量，用于存储 SQL 查询结果集，初始值为 null
    private static ResultSet resultSet = null;

    /**
     * 用于登录查找的方法
     * @param sql 要执行的 SQL 查询语句，通常用于验证用户登录信息
     * @param objects SQL 查询语句中的参数数组，用于填充 SQL 语句中的占位符
     * @return 包含查询结果的 ResultSet 对象
     */
    public static ResultSet login(String sql, Object[] objects) {
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息，方便调试
            e.printStackTrace();
        }

        // 返回包含查询结果的 ResultSet 对象
        return resultSet;
    }

    /**
     * 用于查询所有表（带限制条件或无限制条件）的数据，返回结果集
     * @param sql 要执行的 SQL 查询语句
     * @param objects SQL 查询语句中的参数数组
     * @return 包含查询结果的 ResultSet 对象
     */
    public static ResultSet qureyInfo(String sql, Object[] objects){
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息，方便调试
            e.printStackTrace();
        }
        // 返回包含查询结果的 ResultSet 对象
        return resultSet;
    }

    /**
     * 查询总记录数，返回总记录数
     * @param sql 要执行的 SQL 查询语句，通常用于统计记录数量
     * @param objects SQL 查询语句中的参数数组
     * @return 总记录数
     */
    public static int findTotalCount(String sql, Object[] objects){
        // 声明一个整型变量 num，用于存储总记录数，初始值为 0
        int num = 0;
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
            resultSet = preparedStatement.executeQuery();
            // 将 ResultSet 的指针移动到下一行（通常查询总记录数的结果只有一行）
            resultSet.next();
            // 从 ResultSet 中获取名为 "num" 的列的值，并赋值给 num 变量
            num = resultSet.getInt("num");
            // 打印总记录数，方便调试
            System.out.println(num);
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息，方便调试
            e.printStackTrace();
        } finally {
            // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 ResultSet、PreparedStatement 和 Connection 对象
            JDBCUtils.close(resultSet, preparedStatement, connection);
        }

        // 返回总记录数
        return num;
    }

    /**
     * 查询每页的内容
     * @param sql 要执行的 SQL 查询语句，通常用于分页查询
     * @param objects SQL 查询语句中的参数数组
     * @return 包含查询结果的 ResultSet 对象
     */
    public static ResultSet QureyInfoByPage(String sql, Object[] objects){
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息，方便调试
            e.printStackTrace();
        }
        // 返回包含查询结果的 ResultSet 对象
        return resultSet;
    }

    /**
     * 执行更新语句，包括增、删、改操作
     * @param sql 要执行的 SQL 更新语句
     * @param objects SQL 更新语句中的参数数组
     * @return 受影响的行数
     */
    public static int executeUpdate(String sql, Object[] objects){
        // 声明一个整型变量 num，用于存储受影响的行数，初始值为 0
        int num = 0;
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 更新语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 更新语句，并将受影响的行数赋值给 num 变量
            num = preparedStatement.executeUpdate();
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息，方便调试
            e.printStackTrace();
        } finally {
            // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 PreparedStatement 和 Connection 对象
            JDBCUtils.close(preparedStatement, connection);
        }

        // 返回受影响的行数
        return num;
    }
}
// 声明该类所属的包为 com.dao，包用于组织和管理 Java 类，避免命名冲突
package com.dao;

// 导入自定义的 JDBC 工具类，该工具类应该封装了获取数据库连接、关闭连接等操作
import com.utils.JDBCUtils;

// 导入 java.sql 包中的 Connection 类，用于表示与数据库的连接
import java.sql.Connection;
// 导入 java.sql 包中的 PreparedStatement 类，用于执行预编译的 SQL 语句，可防止 SQL 注入
import java.sql.PreparedStatement;
// 导入 java.sql 包中的 ResultSet 类，用于存储 SQL 查询操作返回的结果集
import java.sql.ResultSet;

// 定义一个公共类 StuDao，该类可能用于处理与学生相关的数据库操作
public class StuDao {

    // 声明一个静态的 Connection 类型变量，用于存储数据库连接对象，初始值为 null
    private static Connection connection = null;
    // 声明一个静态的 PreparedStatement 类型变量，用于执行预编译的 SQL 语句，初始值为 null
    private static PreparedStatement preparedStatement = null;
    // 声明一个静态的 ResultSet 类型变量，用于存储 SQL 查询结果集，初始值为 null
    private static ResultSet resultSet = null;

    /**
     * 用于登录查找的方法
     * @param sql 要执行的 SQL 查询语句，通常用于验证用户登录信息
     * @param objects SQL 查询语句中的参数数组，用于填充 SQL 语句中的占位符
     * @return 包含查询结果的 ResultSet 对象
     */
    public static ResultSet login(String sql, Object[] objects) {
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息，方便调试
            e.printStackTrace();
        }

        // 返回包含查询结果的 ResultSet 对象
        return resultSet;
    }

    /**
     * 用于查询所有表（带限制条件或无限制条件）的数据，返回结果集
     * @param sql 要执行的 SQL 查询语句
     * @param objects SQL 查询语句中的参数数组
     * @return 包含查询结果的 ResultSet 对象
     */
    public static ResultSet qureyInfo(String sql, Object[] objects){
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息，方便调试
            e.printStackTrace();
        }
        // 返回包含查询结果的 ResultSet 对象
        return resultSet;
    }

    /**
     * 查询总记录数，返回总记录数
     * @param sql 要执行的 SQL 查询语句，通常用于统计记录数量
     * @param objects SQL 查询语句中的参数数组
     * @return 总记录数
     */
    public static int findTotalCount(String sql, Object[] objects){
        // 声明一个整型变量 num，用于存储总记录数，初始值为 0
        int num = 0;
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
            resultSet = preparedStatement.executeQuery();
            // 将 ResultSet 的指针移动到下一行（通常查询总记录数的结果只有一行）
            resultSet.next();
            // 从 ResultSet 中获取名为 "num" 的列的值，并赋值给 num 变量
            num = resultSet.getInt("num");
            // 打印总记录数，方便调试
            System.out.println(num);
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息，方便调试
            e.printStackTrace();
        } finally {
            // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 ResultSet、PreparedStatement 和 Connection 对象
            JDBCUtils.close(resultSet, preparedStatement, connection);
        }

        // 返回总记录数
        return num;
    }

    /**
     * 查询每页的内容
     * @param sql 要执行的 SQL 查询语句，通常用于分页查询
     * @param objects SQL 查询语句中的参数数组
     * @return 包含查询结果的 ResultSet 对象
     */
    public static ResultSet QureyInfoByPage(String sql, Object[] objects){
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 查询语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 查询语句，并将查询结果存储在 ResultSet 对象中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息，方便调试
            e.printStackTrace();
        }
        // 返回包含查询结果的 ResultSet 对象
        return resultSet;
    }

    /**
     * 执行更新语句，包括增、删、改操作
     * @param sql 要执行的 SQL 更新语句
     * @param objects SQL 更新语句中的参数数组
     * @return 受影响的行数
     */
    public static int executeUpdate(String sql, Object[] objects){
        // 声明一个整型变量 num，用于存储受影响的行数，初始值为 0
        int num = 0;
        try {
            // 调用 JDBCUtils 类的 getConnection 方法获取数据库连接
            connection = JDBCUtils.getConnection();
            // 使用获取到的数据库连接创建一个 PreparedStatement 对象，传入 SQL 更新语句
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到 PreparedStatement 对象中
            for (int i = 0; i < objects.length; i++) {
                // 注意：PreparedStatement 的参数索引从 1 开始，所以是 i + 1
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 更新语句，并将受影响的行数赋值给 num 变量
            num = preparedStatement.executeUpdate();
        } catch (Exception e) {
            // 若发生异常，打印异常堆栈信息，方便调试
            e.printStackTrace();
        } finally {
            // 无论是否发生异常，都调用 JDBCUtils 类的 close 方法关闭 PreparedStatement 和 Connection 对象
            JDBCUtils.close(preparedStatement, connection);
        }

        // 返回受影响的行数
        return num;
    }
}
// 声明该类所在的包为 com.dao
package com.dao;

// 导入 JDBCUtils 工具类，该类用于管理 JDBC 连接等操作
import com.utils.JDBCUtils;

// 导入 Java 数据库连接相关的类，用于操作数据库
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

// 定义 TeaDao 类，该类可能用于对教师相关数据进行数据库操作
public class TeaDao {

    // 声明静态的数据库连接对象，用于保持与数据库的连接
    private static Connection connection = null;
    // 声明静态的预编译语句对象，用于执行 SQL 语句
    private static PreparedStatement preparedStatement = null;
    // 声明静态的结果集对象，用于存储数据库查询结果
    private static ResultSet resultSet = null;

    // 定义 login 方法，用于执行登录相关的数据库查询操作，返回结果集
    // sql 参数表示要执行的 SQL 查询语句
    // objects 参数是一个包含查询参数的数组
    public static ResultSet login(String sql, Object[] objects) {
        try {
            // 通过 JDBCUtils 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译语句对象，将 SQL 语句传入
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到预编译语句中
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行查询操作，并将结果存储到结果集对象中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 如果在执行过程中出现异常，打印异常堆栈信息
            e.printStackTrace();
        }

        // 返回查询结果集
        return resultSet;
    }

    // 定义 qureyInfo 方法，用于执行带条件或不带条件的数据库查询操作，返回结果集
    // sql 参数表示要执行的 SQL 查询语句
    // objects 参数是一个包含查询参数的数组
    public static ResultSet qureyInfo(String sql, Object[] objects){
        try {
            // 通过 JDBCUtils 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译语句对象，将 SQL 语句传入
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到预编译语句中
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行查询操作，并将结果存储到结果集对象中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 如果在执行过程中出现异常，打印异常堆栈信息
            e.printStackTrace();
        }
        // 返回查询结果集
        return resultSet;
    }

    // 定义 findTotalCount 方法，用于查询符合条件的总记录数，返回总记录数
    // sql 参数表示要执行的 SQL 查询语句，用于统计记录数
    // objects 参数是一个包含查询参数的数组
    public static int findTotalCount(String sql, Object[] objects){
        // 初始化记录数变量为 0
        int num = 0;
        try {
            // 通过 JDBCUtils 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译语句对象，将 SQL 语句传入
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到预编译语句中
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行查询操作，并将结果存储到结果集对象中
            resultSet = preparedStatement.executeQuery();
            // 将结果集指针移动到第一行（因为结果集中只有一行记录，即统计的总记录数）
            resultSet.next();
            // 从结果集中获取名为 "num" 的列的值，即总记录数
            num = resultSet.getInt("num");
            // 打印总记录数到控制台，用于调试
            System.out.println(num);
        } catch (Exception e) {
            // 如果在执行过程中出现异常，打印异常堆栈信息
            e.printStackTrace();
        } finally {
            // 调用 JDBCUtils 的方法关闭结果集、预编译语句和数据库连接，释放资源
            JDBCUtils.close(resultSet, preparedStatement, connection);
        }

        // 返回总记录数
        return num;
    }

    // 定义 QureyInfoByPage 方法，用于查询每页的内容，返回结果集
    // sql 参数表示要执行的 SQL 查询语句，用于获取指定页的数据
    // objects 参数是一个包含查询参数的数组
    public static ResultSet QureyInfoByPage(String sql, Object[] objects){
        try {
            // 通过 JDBCUtils 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译语句对象，将 SQL 语句传入
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到预编译语句中
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行查询操作，并将结果存储到结果集对象中
            resultSet = preparedStatement.executeQuery();
        } catch (Exception e) {
            // 如果在执行过程中出现异常，打印异常堆栈信息
            e.printStackTrace();
        }
        // 返回查询结果集
        return resultSet;
    }

    // 定义 executeUpdate 方法，用于执行数据库的增、删、改操作，返回受影响的行数
    // sql 参数表示要执行的 SQL 语句，如插入、删除、更新语句
    // objects 参数是一个包含操作参数的数组
    public static int executeUpdate(String sql, Object[] objects){
        // 初始化受影响的行数变量为 0
        int num = 0;
        try {
            // 通过 JDBCUtils 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 创建预编译语句对象，将 SQL 语句传入
            preparedStatement = connection.prepareStatement(sql);
            // 遍历参数数组，将参数依次设置到预编译语句中
            for (int i = 0; i < objects.length; i++) {
                preparedStatement.setObject(i + 1, objects[i]);
            }
            // 执行更新操作，并返回受影响的行数
            num = preparedStatement.executeUpdate();
        } catch (Exception e) {
            // 如果在执行过程中出现异常，打印异常堆栈信息
            e.printStackTrace();
        } finally {
            // 调用 JDBCUtils 的方法关闭预编译语句和数据库连接，释放资源
            JDBCUtils.close(preparedStatement, connection);
        }

        // 返回受影响的行数
        return num;
    }
}
package com.entity;
// 声明该类所属的包为 com.entity，包用于对类进行组织和管理，方便代码的维护和复用

import java.util.Date;
// 导入 java.util 包下的 Date 类，用于表示日期和时间

public class News {
    // 定义一个私有字符串类型的变量 title，用于存储新闻的标题
    private String title;
    // 定义一个私有字符串类型的变量 url，用于存储新闻的链接地址
    private String url;
    // 定义一个私有 Date 类型的变量 pubdate，用于存储新闻的发布日期
    private Date pubdate;

    // 这是一个设置新闻标题的方法，接收一个字符串类型的参数 title
    public void setTitle(String title) {
        // 将传入的参数值赋给当前类的成员变量 title
        this.title = title;
    }

    // 这是一个设置新闻链接的方法，接收一个字符串类型的参数 url
    public void setUrl(String url) {
        // 将传入的参数值赋给当前类的成员变量 url
        this.url = url;
    }

    // 这是一个设置新闻发布日期的方法，接收一个 Date 类型的参数 pubdate
    public void setPubdate(Date pubdate) {
        // 将传入的参数值赋给当前类的成员变量 pubdate
        this.pubdate = pubdate;
    }

    // 这是一个获取新闻标题的方法，返回值类型为字符串
    public String getTitle() {
        // 返回当前类的成员变量 title 的值
        return title;
    }

    // 这是一个获取新闻链接的方法，返回值类型为字符串
    public String getUrl() {
        // 返回当前类的成员变量 url 的值
        return url;
    }

    // 这是一个获取新闻发布日期的方法，返回值类型为 Date
    public Date getPubdate() {
        // 返回当前类的成员变量 pubdate 的值
        return pubdate;
    }

    // 重写了父类 Object 的 toString 方法，用于将 News 对象以字符串的形式表示
    @Override
    public String toString() {
        // 返回一个包含新闻标题、链接和发布日期的字符串，格式为 "News{title='xxx', url='xxx', pubdate=xxx}"
        return "News{" +
                "title='" + title + '\'' +
                ", url='" + url + '\'' +
                ", pubdate=" + pubdate +
                '}';
    }
}
// 声明该类所属的包为 com.entity，包用于组织和管理 Java 类，避免命名冲突
package com.entity;

// 导入 java.util 包中的 ArrayList 类，用于存储每页的数据
import java.util.ArrayList;

/**
 * 泛型类 PageBean，用于封装分页信息
 * @param <T> 泛型类型，表示每页数据的类型
 */
public class PageBean<T> {

    // 定义一个整型变量 totalCount，用于存储总记录数
    private int totalCount;
    // 定义一个整型变量 totalPage，用于存储总页码数
    private int totalPage;
    // 定义一个泛型类型的 ArrayList 变量 arrayList，用于存储每页的数据
    private ArrayList<T> arrayList;
    // 定义一个整型变量 currentPage，用于存储当前页码
    private int currentPage;
    // 定义一个整型变量 rows，用于存储每页显示的记录数
    private int rows;

    /**
     * 设置总记录数的方法
     * @param totalCount 要设置的总记录数
     */
    public void setTotalCount(int totalCount) {
        // 将传入的总记录数赋值给类的成员变量 totalCount
        this.totalCount = totalCount;
    }

    /**
     * 设置总页码数的方法
     * @param totalPage 要设置的总页码数
     */
    public void setTotalPage(int totalPage) {
        // 将传入的总页码数赋值给类的成员变量 totalPage
        this.totalPage = totalPage;
    }

    /**
     * 设置每页数据的方法
     * @param arrayList 要设置的每页数据的 ArrayList
     */
    public void setArrayList(ArrayList<T> arrayList) {
        // 将传入的 ArrayList 赋值给类的成员变量 arrayList
        this.arrayList = arrayList;
    }

    /**
     * 设置当前页码的方法
     * @param currentPage 要设置的当前页码
     */
    public void setCurrentPage(int currentPage) {
        // 将传入的当前页码赋值给类的成员变量 currentPage
        this.currentPage = currentPage;
    }

    /**
     * 设置每页记录数的方法
     * @param rows 要设置的每页记录数
     */
    public void setRows(int rows) {
        // 将传入的每页记录数赋值给类的成员变量 rows
        this.rows = rows;
    }

    /**
     * 获取总记录数的方法
     * @return 总记录数
     */
    public int getTotalCount() {
        // 返回类的成员变量 totalCount 的值
        return totalCount;
    }

    /**
     * 获取总页码数的方法
     * @return 总页码数
     */
    public int getTotalPage() {
        // 返回类的成员变量 totalPage 的值
        return totalPage;
    }

    /**
     * 获取每页数据的方法
     * @return 存储每页数据的 ArrayList
     */
    public ArrayList<T> getArrayList() {
        // 返回类的成员变量 arrayList 的值
        return arrayList;
    }

    /**
     * 获取当前页码的方法
     * @return 当前页码
     */
    public int getCurrentPage() {
        // 返回类的成员变量 currentPage 的值
        return currentPage;
    }

    /**
     * 获取每页记录数的方法
     * @return 每页记录数
     */
    public int getRows() {
        // 返回类的成员变量 rows 的值
        return rows;
    }

    /**
     * 重写 toString 方法，用于将对象的信息以字符串形式输出
     * @return 包含对象属性信息的字符串
     */
    @Override
    public String toString() {
        return "PageBean1{" +
                // 拼接总记录数
                "totalCount=" + totalCount +
                // 拼接总页码数
                ", totalPage=" + totalPage +
                // 拼接每页数据的 ArrayList
                ", arrayList=" + arrayList +
                // 拼接当前页码
                ", currentPage=" + currentPage +
                // 拼接每页记录数
                ", rows=" + rows +
                '}';
    }
}
package com.entity;
// 声明该类所属的包为 com.entity，包用于对类进行组织和管理，方便在项目中找到和使用相关的类

public class Student {
    // 定义一个私有字符串类型的变量 sno，用于存储学生的学号
    private String sno;
    // 定义一个私有字符串类型的变量 sname，用于存储学生的姓名
    private String sname;
    // 定义一个私有字符串类型的变量 ssex，用于存储学生的性别
    private String ssex;
    // 定义一个私有整数类型的变量 sage，用于存储学生的年龄
    private int sage;
    // 定义一个私有字符串类型的变量 sclass，用于存储学生的班级
    private String sclass;
    // 定义一个私有字符串类型的变量 specialty，用于存储学生的专业
    private String specialty;
    // 定义一个私有字符串类型的变量 sdept，用于存储学生的所在系部
    private String sdept;
    // 定义一个私有字符串类型的变量 sphone，用于存储学生的电话号码
    private String sphone;
    // 定义一个私有字符串类型的变量 spsw，用于存储学生的密码
    private String spsw;

    // 这是一个设置学生学号的方法，接收一个字符串类型的参数 sno
    public void setSno(String sno) {
        // 将传入的参数值赋给当前类的成员变量 sno
        this.sno = sno;
    }

    // 这是一个设置学生姓名的方法，接收一个字符串类型的参数 sname
    public void setSname(String sname) {
        // 将传入的参数值赋给当前类的成员变量 sname
        this.sname = sname;
    }

    // 这是一个设置学生性别的方法，接收一个字符串类型的参数 ssex
    public void setSsex(String ssex) {
        // 将传入的参数值赋给当前类的成员变量 ssex
        this.ssex = ssex;
    }

    // 这是一个设置学生年龄的方法，接收一个整数类型的参数 sage
    public void setSage(int sage) {
        // 将传入的参数值赋给当前类的成员变量 sage
        this.sage = sage;
    }

    // 这是一个设置学生班级的方法，接收一个字符串类型的参数 sclass
    public void setSclass(String sclass) {
        // 将传入的参数值赋给当前类的成员变量 sclass
        this.sclass = sclass;
    }

    // 这是一个设置学生专业的方法，接收一个字符串类型的参数 specialty
    public void setSpecialty(String specialty) {
        // 将传入的参数值赋给当前类的成员变量 specialty
        this.specialty = specialty;
    }

    // 这是一个设置学生所在系部的方法，接收一个字符串类型的参数 sdept
    public void setSdept(String sdept) {
        // 将传入的参数值赋给当前类的成员变量 sdept
        this.sdept = sdept;
    }

    // 这是一个设置学生电话号码的方法，接收一个字符串类型的参数 sphone
    public void setSphone(String sphone) {
        // 将传入的参数值赋给当前类的成员变量 sphone
        this.sphone = sphone;
    }

    // 这是一个设置学生密码的方法，接收一个字符串类型的参数 spsw
    public void setSpsw(String spsw) {
        // 将传入的参数值赋给当前类的成员变量 spsw
        this.spsw = spsw;
    }

    // 这是一个获取学生学号的方法，返回值类型为字符串
    public String getSno() {
        // 返回当前类的成员变量 sno 的值
        return sno;
    }

    // 这是一个获取学生姓名的方法，返回值类型为字符串
    public String getSname() {
        // 返回当前类的成员变量 sname 的值
        return sname;
    }

    // 这是一个获取学生性别的方法，返回值类型为字符串
    public String getSsex() {
        // 返回当前类的成员变量 ssex 的值
        return ssex;
    }

    // 这是一个获取学生年龄的方法，返回值类型为整数
    public int getSage() {
        // 返回当前类的成员变量 sage 的值
        return sage;
    }

    // 这是一个获取学生班级的方法，返回值类型为字符串
    public String getSclass() {
        // 返回当前类的成员变量 sclass 的值
        return sclass;
    }

    // 这是一个获取学生专业的方法，返回值类型为字符串
    public String getSpecialty() {
        // 返回当前类的成员变量 specialty 的值
        return specialty;
    }

    // 这是一个获取学生所在系部的方法，返回值类型为字符串
    public String getSdept() {
        // 返回当前类的成员变量 sdept 的值
        return sdept;
    }

    // 这是一个获取学生电话号码的方法，返回值类型为字符串
    public String getSphone() {
        // 返回当前类的成员变量 sphone 的值
        return sphone;
    }

    // 这是一个获取学生密码的方法，返回值类型为字符串
    public String getSpsw() {
        // 返回当前类的成员变量 spsw 的值
        return spsw;
    }

    // 重写了父类 Object 的 toString 方法，用于将 Student 对象以字符串的形式表示
    @Override
    public String toString() {
        // 返回一个包含学生各项信息的字符串，格式为 "Student{sno='xxx', sname='xxx', ssex='xxx', sage=xxx, sclass='xxx', specialty='xxx', sdept='xxx', sphone='xxx', spsw='xxx'}"
        return "Student{" +
                "sno='" + sno + '\'' +
                ", sname='" + sname + '\'' +
                ", ssex='" + ssex + '\'' +
                ", sage=" + sage +
                ", sclass='" + sclass + '\'' +
                ", specialty='" + specialty + '\'' +
                ", sdept='" + sdept + '\'' +
                ", sphone='" + sphone + '\'' +
                ", spsw='" + spsw + '\'' +
                '}';
    }
}
// 声明该类所属的包为 com.entity，包用于组织和管理 Java 类，避免命名冲突
package com.entity;

// 导入 java.sql 包中的 Date 类，用于表示日期
import java.sql.Date;
// 导入 java.sql 包中的 Timestamp 类，用于表示包含日期和时间的时间戳（这里未使用到）
import java.sql.Timestamp;
// 导入 java.text 包中的 SimpleDateFormat 类，用于格式化日期和时间（这里未使用到）
import java.text.SimpleDateFormat;

/**
 * 定义一个名为 StuPunch 的类，用于表示学生打卡相关信息的实体类
 */
public class StuPunch {

    // 学生学号，字符串类型
    private String sno;
    // 学生姓名，字符串类型
    private String sname;
    // 学生所在班级，字符串类型
    private String sclass;
    // 学生专业，字符串类型
    private String specialty;
    // 学生所在系部，字符串类型
    private String sdept;
    // 学生是否打卡的标识，字符串类型（例如 "是" 或 "否" 等）
    private String sispunch;
    // 学生打卡日期，Date 类型
    private Date spunchdate;
    // 学生打卡时间，字符串类型
    private String spunchtime;
    // 学生是否发热的标识，字符串类型（例如 "是" 或 "否" 等）
    private String sishot;
    // 学生是否咳嗽的标识，字符串类型（例如 "是" 或 "否" 等）
    private String siscough;
    // 学生的表观症状描述，字符串类型
    private String sisseem;
    // 学生的诊断结果，字符串类型
    private String sisdiagnose;
    // 学生的状态，字符串类型
    private String sstatus;

    /**
     * 设置学生学号的方法
     * @param sno 要设置的学生学号
     */
    public void setSno(String sno) {
        // 将传入的学号赋值给类的成员变量 sno
        this.sno = sno;
    }

    /**
     * 设置学生姓名的方法
     * @param sname 要设置的学生姓名
     */
    public void setSname(String sname) {
        // 将传入的姓名赋值给类的成员变量 sname
        this.sname = sname;
    }

    /**
     * 设置学生所在班级的方法
     * @param sclass 要设置的学生所在班级
     */
    public void setSclass(String sclass) {
        // 将传入的班级赋值给类的成员变量 sclass
        this.sclass = sclass;
    }

    /**
     * 设置学生所在系部的方法
     * @param sdept 要设置的学生所在系部
     */
    public void setSdept(String sdept) {
        // 将传入的系部赋值给类的成员变量 sdept
        this.sdept = sdept;
    }

    /**
     * 设置学生专业的方法
     * @param specialty 要设置的学生专业
     */
    public void setSpecialty(String specialty) {
        // 将传入的专业赋值给类的成员变量 specialty
        this.specialty = specialty;
    }

    /**
     * 设置学生是否打卡标识的方法
     * @param sispunch 要设置的学生是否打卡标识
     */
    public void setSispunch(String sispunch) {
        // 将传入的是否打卡标识赋值给类的成员变量 sispunch
        this.sispunch = sispunch;
    }

    /**
     * 设置学生打卡日期的方法
     * @param spunchdate 要设置的学生打卡日期
     */
    public void setSpunchdate(Date spunchdate) {
        // 将传入的打卡日期赋值给类的成员变量 spunchdate
        this.spunchdate = spunchdate;
    }

    /**
     * 设置学生打卡时间的方法
     * @param spunchtime 要设置的学生打卡时间
     */
    public void setSpunchtime(String spunchtime) {
        // 将传入的打卡时间赋值给类的成员变量 spunchtime
        this.spunchtime = spunchtime;
    }

    /**
     * 设置学生是否发热标识的方法
     * @param sishot 要设置的学生是否发热标识
     */
    public void setSishot(String sishot) {
        // 将传入的是否发热标识赋值给类的成员变量 sishot
        this.sishot = sishot;
    }

    /**
     * 设置学生是否咳嗽标识的方法
     * @param siscough 要设置的学生是否咳嗽标识
     */
    public void setSiscough(String siscough) {
        // 将传入的是否咳嗽标识赋值给类的成员变量 siscough
        this.siscough = siscough;
    }

    /**
     * 设置学生表观症状描述的方法
     * @param sisseem 要设置的学生表观症状描述
     */
    public void setSisseem(String sisseem) {
        // 将传入的表观症状描述赋值给类的成员变量 sisseem
        this.sisseem = sisseem;
    }

    /**
     * 设置学生诊断结果的方法
     * @param sisdiagnose 要设置的学生诊断结果
     */
    public void setSisdiagnose(String sisdiagnose) {
        // 将传入的诊断结果赋值给类的成员变量 sisdiagnose
        this.sisdiagnose = sisdiagnose;
    }

    /**
     * 设置学生状态的方法
     * @param sstatus 要设置的学生状态
     */
    public void setSstatus(String sstatus) {
        // 将传入的学生状态赋值给类的成员变量 sstatus
        this.sstatus = sstatus;
    }

    /**
     * 获取学生学号的方法
     * @return 学生学号
     */
    public String getSno() {
        // 返回类的成员变量 sno 的值
        return sno;
    }

    /**
     * 获取学生姓名的方法
     * @return 学生姓名
     */
    public String getSname() {
        // 返回类的成员变量 sname 的值
        return sname;
    }

    /**
     * 获取学生所在班级的方法
     * @return 学生所在班级
     */
    public String getSclass() {
        // 返回类的成员变量 sclass 的值
        return sclass;
    }

    /**
     * 获取学生专业的方法
     * @return 学生专业
     */
    public String getSpecialty() {
        // 返回类的成员变量 specialty 的值
        return specialty;
    }

    /**
     * 获取学生所在系部的方法
     * @return 学生所在系部
     */
    public String getSdept() {
        // 返回类的成员变量 sdept 的值
        return sdept;
    }

    /**
     * 获取学生是否打卡标识的方法
     * @return 学生是否打卡标识
     */
    public String getSispunch() {
        // 返回类的成员变量 sispunch 的值
        return sispunch;
    }

    /**
     * 获取学生打卡日期的方法
     * @return 学生打卡日期
     */
    public Date getSpunchdate() {
        // 返回类的成员变量 spunchdate 的值
        return spunchdate;
    }

    /**
     * 获取学生打卡时间的方法
     * @return 学生打卡时间
     */
    public String getSpunchtime() {
        // 返回类的成员变量 spunchtime 的值
        return spunchtime;
    }

    /**
     * 获取学生是否发热标识的方法
     * @return 学生是否发热标识
     */
    public String getSishot() {
        // 返回类的成员变量 sishot 的值
        return sishot;
    }

    /**
     * 获取学生是否咳嗽标识的方法
     * @return 学生是否咳嗽标识
     */
    public String getSiscough() {
        // 返回类的成员变量 siscough 的值
        return siscough;
    }

    /**
     * 获取学生表观症状描述的方法
     * @return 学生表观症状描述
     */
    public String getSisseem() {
        // 返回类的成员变量 sisseem 的值
        return sisseem;
    }

    /**
     * 获取学生诊断结果的方法
     * @return 学生诊断结果
     */
    public String getSisdiagnose() {
        // 返回类的成员变量 sisdiagnose 的值
        return sisdiagnose;
    }

    /**
     * 获取学生状态的方法
     * @return 学生状态
     */
    public String getSstatus() {
        // 返回类的成员变量 sstatus 的值
        return sstatus;
    }

    /**
     * 重写 toString 方法，用于将对象的信息以字符串形式输出
     * @return 包含对象属性信息的字符串
     */
    @Override
    public String toString() {
        return "StuPunch{" +
                // 拼接学生学号
                "sno='" + sno + '\'' +
                // 拼接学生姓名
                ", sname='" + sname + '\'' +
                // 拼接学生所在班级
                ", sclass='" + sclass + '\'' +
                // 拼接学生专业
                ", specialty='" + specialty + '\'' +
                // 拼接学生所在系部
                ", sdept='" + sdept + '\'' +
                // 拼接学生是否打卡标识
                ", sispunch='" + sispunch + '\'' +
                // 拼接学生打卡日期
                ", spunchdate=" + spunchdate +
                // 拼接学生打卡时间
                ", spunchtime='" + spunchtime + '\'' +
                // 拼接学生是否发热标识
                ", sishot='" + sishot + '\'' +
                // 拼接学生是否咳嗽标识
                ", siscough='" + siscough + '\'' +
                // 拼接学生表观症状描述
                ", sisseem='" + sisseem + '\'' +
                // 拼接学生诊断结果
                ", sisdiagnose='" + sisdiagnose + '\'' +
                // 拼接学生状态
                ", sstatus='" + sstatus + '\'' +
                '}';
    }
}
// 声明该类所属的包，通常用于存放实体类
package com.entity;

// 定义一个名为Teacher的类，用于表示教师实体
public class Teacher {

    // 定义私有属性tno，用于存储教师编号
    private String tno;
    // 定义私有属性tname，用于存储教师姓名
    private String tname;
    // 定义私有属性tsex，用于存储教师性别
    private String tsex;
    // 定义私有属性tage，用于存储教师年龄
    private int tage;
    // 定义私有属性tdept，用于存储教师所属部门
    private String tdept;
    // 定义私有属性tphone，用于存储教师联系电话
    private String tphone;
    // 定义私有属性tpsw，用于存储教师密码
    private String tpsw;

    // 定义setTno方法，用于设置教师编号
    public void setTno(String tno) {
        // 将传入的参数tno赋值给类的私有属性tno
        this.tno = tno;
    }

    // 定义setTname方法，用于设置教师姓名
    public void setTname(String tname) {
        // 将传入的参数tname赋值给类的私有属性tname
        this.tname = tname;
    }

    // 定义setTsex方法，用于设置教师性别
    public void setTsex(String tsex) {
        // 将传入的参数tsex赋值给类的私有属性tsex
        this.tsex = tsex;
    }

    // 定义setTage方法，用于设置教师年龄
    public void setTage(int tage) {
        // 将传入的参数tage赋值给类的私有属性tage
        this.tage = tage;
    }

    // 定义setTdept方法，用于设置教师所属部门
    public void setTdept(String tdept) {
        // 将传入的参数tdept赋值给类的私有属性tdept
        this.tdept = tdept;
    }

    // 定义setTphone方法，用于设置教师联系电话
    public void setTphone(String tphone) {
        // 将传入的参数tphone赋值给类的私有属性tphone
        this.tphone = tphone;
    }

    // 定义setTpsw方法，用于设置教师密码
    public void setTpsw(String tpsw) {
        // 将传入的参数tpsw赋值给类的私有属性tpsw
        this.tpsw = tpsw;
    }

    // 定义getTno方法，用于获取教师编号
    public String getTno() {
        // 返回类的私有属性tno的值
        return tno;
    }

    // 定义getTname方法，用于获取教师姓名
    public String getTname() {
        // 返回类的私有属性tname的值
        return tname;
    }

    // 定义getTsex方法，用于获取教师性别
    public String getTsex() {
        // 返回类的私有属性tsex的值
        return tsex;
    }

    // 定义getTage方法，用于获取教师年龄
    public int getTage() {
        // 返回类的私有属性tage的值
        return tage;
    }

    // 定义getTdept方法，用于获取教师所属部门
    public String getTdept() {
        // 返回类的私有属性tdept的值
        return tdept;
    }

    // 定义getTphone方法，用于获取教师联系电话
    public String getTphone() {
        // 返回类的私有属性tphone的值
        return tphone;
    }

    // 定义getTpsw方法，用于获取教师密码
    public String getTpsw() {
        // 返回类的私有属性tpsw的值
        return tpsw;
    }

    // 重写toString方法，用于将教师对象的属性信息以字符串形式输出
    @Override
    public String toString() {
        return "Teacher{" +
                // 输出教师编号
                "tno='" + tno + '\'' +
                // 输出教师姓名
                ", tname='" + tname + '\'' +
                // 输出教师性别
                ", tsex='" + tsex + '\'' +
                // 输出教师年龄
                ", tage=" + tage +
                // 输出教师所属部门
                ", tdept='" + tdept + '\'' +
                // 输出教师联系电话
                ", tphone='" + tphone + '\'' +
                // 输出教师密码
                ", tpsw='" + tpsw + '\'' +
                '}';
    }
}
// 声明该类所属的包为 com.entity
package com.entity;

// 导入 java.sql.Date 类，用于表示日期（只包含年、月、日）
import java.sql.Date;
// 导入 java.sql.Timestamp 类，用于表示包含日期和时间（精确到纳秒）的数据类型（虽然在当前代码中未使用到该类，但导入了）
import java.sql.Timestamp;

// 定义 TeaPunch 类，该类用于封装教师打卡信息
public class TeaPunch {

    // 定义私有属性 tno，表示教师编号
    private String tno;
    // 定义私有属性 tname，表示教师姓名
    private String tname;
    // 定义私有属性 tdept，表示教师所在部门
    private String tdept;
    // 定义私有属性 tispunch，表示教师是否打卡（可能是“是”或“否”等）
    private String tispunch;
    // 定义私有属性 tpunchdate，表示教师打卡日期
    private Date tpunchdate;
    // 定义私有属性 tpunchtime，表示教师打卡时间
    private String tpunchtime;
    // 定义私有属性 tishot，表示教师是否发热（可能是“是”或“否”等）
    private String tishot;
    // 定义私有属性 tiscough，表示教师是否咳嗽（可能是“是”或“否”等）
    private String tiscough;
    // 定义私有属性 tisseem，表示教师是否有疑似症状（可能是“是”或“否”等）
    private String tisseem;
    // 定义私有属性 tisdiagnose，表示教师是否确诊（可能是“是”或“否”等）
    private String tisdiagnose;
    // 定义私有属性 tstatus，表示教师的状态（可能包含其他相关状态信息）
    private String tstatus;

    // 定义 tno 属性的 setter 方法，用于设置教师编号
    public void setTno(String tno) {
        this.tno = tno;
    }

    // 定义 tname 属性的 setter 方法，用于设置教师姓名
    public void setTname(String tname) {
        this.tname = tname;
    }

    // 定义 tdept 属性的 setter 方法，用于设置教师所在部门
    public void setTdept(String tdept) {
        this.tdept = tdept;
    }

    // 定义 tispunch 属性的 setter 方法，用于设置教师是否打卡
    public void setTispunch(String tispunch) {
        this.tispunch = tispunch;
    }

    // 定义 tpunchdate 属性的 setter 方法，用于设置教师打卡日期
    public void setTpunchdate(Date tpunchdate) {
        this.tpunchdate = tpunchdate;
    }

    // 定义 tpunchtime 属性的 setter 方法，用于设置教师打卡时间
    public void setTpunchtime(String tpunchtime) {
        this.tpunchtime = tpunchtime;
    }

    // 定义 tishot 属性的 setter 方法，用于设置教师是否发热
    public void setTishot(String tishot) {
        this.tishot = tishot;
    }

    // 定义 tiscough 属性的 setter 方法，用于设置教师是否咳嗽
    public void setTiscough(String tiscough) {
        this.tiscough = tiscough;
    }

    // 定义 tisseem 属性的 setter 方法，用于设置教师是否有疑似症状
    public void setTisseem(String tisseem) {
        this.tisseem = tisseem;
    }

    // 定义 tisdiagnose 属性的 setter 方法，用于设置教师是否确诊
    public void setTisdiagnose(String tisdiagnose) {
        this.tisdiagnose = tisdiagnose;
    }

    // 定义 tstatus 属性的 setter 方法，用于设置教师的状态
    public void setTstatus(String tstatus) {
        this.tstatus = tstatus;
    }

    // 定义 tno 属性的 getter 方法，用于获取教师编号
    public String getTno() {
        return tno;
    }

    // 定义 tname 属性的 getter 方法，用于获取教师姓名
    public String getTname() {
        return tname;
    }

    // 定义 tdept 属性的 getter 方法，用于获取教师所在部门
    public String getTdept() {
        return tdept;
    }

    // 定义 tispunch 属性的 getter 方法，用于获取教师是否打卡
    public String getTispunch() {
        return tispunch;
    }

    // 定义 tpunchdate 属性的 getter 方法，用于获取教师打卡日期
    public Date getTpunchdate() {
        return tpunchdate;
    }

    // 定义 tpunchtime 属性的 getter 方法，用于获取教师打卡时间
    public String getTpunchtime() {
        return tpunchtime;
    }

    // 定义 tishot 属性的 getter 方法，用于获取教师是否发热
    public String getTishot() {
        return tishot;
    }

    // 定义 tiscough 属性的 getter 方法，用于获取教师是否咳嗽
    public String getTiscough() {
        return tiscough;
    }

    // 定义 tisseem 属性的 getter 方法，用于获取教师是否有疑似症状
    public String getTisseem() {
        return tisseem;
    }

    // 定义 tisdiagnose 属性的 getter 方法，用于获取教师是否确诊
    public String getTisdiagnose() {
        return tisdiagnose;
    }

    // 定义 tstatus 属性的 getter 方法，用于获取教师的状态
    public String getTstatus() {
        return tstatus;
    }

    // 重写 toString 方法，返回该对象的字符串表示形式，方便输出和调试
    @Override
    public String toString() {
        return "TeaPunch{" +
                "tno='" + tno + '\'' +
                ", tname='" + tname + '\'' +
                ", tdept='" + tdept + '\'' +
                ", tispunch='" + tispunch + '\'' +
                ", tpunchdate=" + tpunchdate +
                ", tpunchtime='" + tpunchtime + '\'' +
                ", tishot='" + tishot + '\'' +
                ", tiscough='" + tiscough + '\'' +
                ", tisseem='" + tisseem + '\'' +
                ", tisdiagnose='" + tisdiagnose + '\'' +
                ", tstatus='" + tstatus + '\'' +
                '}';
    }
}
package com.entity;
// 声明该类所属的包为 com.entity，用于对相关实体类进行组织和管理，便于代码的模块化和维护

public class WebStu {
    // 定义一个私有字符串类型的变量 sdept，用于存储系部名称
    private String sdept;
    // 定义一个私有整型变量 sishotNum，用于存储与发热相关的数量（可能是发热学生的数量等）
    private int sishotNum;
    // 定义一个私有整型变量 siscoughNum，用于存储与咳嗽相关的数量（可能是咳嗽学生的数量等）
    private int siscoughNum;
    // 定义一个私有整型变量 sstatusNum，用于存储与某种状态相关的数量（具体状态需根据上下文确定）
    private int sstatusNum;
    // 定义一个私有整型变量 sisseemNum，用于存储与某种表现相关的数量（可能是有特定症状表现的学生数量等）
    private int sisseemNum;
    // 定义一个私有整型变量 sisdiagnoseNum，用于存储与诊断结果相关的数量（可能是已诊断学生的数量等）
    private int sisdiagnoseNum;

    // 这是一个设置系部名称的方法，接收一个字符串类型的参数 sdept
    public void setSdept(String sdept) {
        // 将传入的参数值赋给当前类的成员变量 sdept
        this.sdept = sdept;
    }

    // 这是一个设置与发热相关数量的方法，接收一个整型参数 sishotNum
    public void setSishotNum(int sishotNum) {
        // 将传入的参数值赋给当前类的成员变量 sishotNum
        this.sishotNum = sishotNum;
    }

    // 这是一个设置与咳嗽相关数量的方法，接收一个整型参数 siscoughNum
    public void setSiscoughNum(int siscoughNum) {
        // 将传入的参数值赋给当前类的成员变量 siscoughNum
        this.siscoughNum = siscoughNum;
    }

    // 这是一个设置与某种状态相关数量的方法，接收一个整型参数 sstatusNum
    public void setSstatusNum(int sstatusNum) {
        // 将传入的参数值赋给当前类的成员变量 sstatusNum
        this.sstatusNum = sstatusNum;
    }

    // 这是一个设置与某种表现相关数量的方法，接收一个整型参数 sisseemNum
    public void setSisseemNum(int sisseemNum) {
        // 将传入的参数值赋给当前类的成员变量 sisseemNum
        this.sisseemNum = sisseemNum;
    }

    // 这是一个设置与诊断结果相关数量的方法，接收一个整型参数 sisdiagnoseNum
    public void setSisdiagnoseNum(int sisdiagnoseNum) {
        // 将传入的参数值赋给当前类的成员变量 sisdiagnoseNum
        this.sisdiagnoseNum = sisdiagnoseNum;
    }

    // 这是一个获取系部名称的方法，返回值类型为字符串
    public String getSdept() {
        // 返回当前类的成员变量 sdept 的值
        return sdept;
    }

    // 这是一个获取与发热相关数量的方法，返回值类型为整型
    public int getSishotNum() {
        // 返回当前类的成员变量 sishotNum 的值
        return sishotNum;
    }

    // 这是一个获取与咳嗽相关数量的方法，返回值类型为整型
    public int getSiscoughNum() {
        // 返回当前类的成员变量 siscoughNum 的值
        return siscoughNum;
    }

    // 这是一个获取与某种状态相关数量的方法，返回值类型为整型
    public int getSstatusNum() {
        // 返回当前类的成员变量 sstatusNum 的值
        return sstatusNum;
    }

    // 这是一个获取与某种表现相关数量的方法，返回值类型为整型
    public int getSisseemNum() {
        // 返回当前类的成员变量 sisseemNum 的值
        return sisseemNum;
    }

    // 这是一个获取与诊断结果相关数量的方法，返回值类型为整型
    public int getSisdiagnoseNum() {
        // 返回当前类的成员变量 sisdiagnoseNum 的值
        return sisdiagnoseNum;
    }

    // 重写了父类 Object 的 toString 方法，用于将 WebStu 对象以字符串的形式表示
    @Override
    public String toString() {
        // 返回一个包含系部名称以及各类数量信息的字符串，格式为 "WebStu{sdept='xxx', sishotNum=xxx, siscoughNum=xxx, sstatusNum=xxx, sisseemNum=xxx, sisdiagnoseNum=xxx}"
        return "WebStu{" +
                "sdept='" + sdept + '\'' +
                ", sishotNum=" + sishotNum +
                ", siscoughNum=" + siscoughNum +
                ", sstatusNum=" + sstatusNum +
                ", sisseemNum=" + sisseemNum +
                ", sisdiagnoseNum=" + sisdiagnoseNum +
                '}';
    }
}
package com.entity;
// 声明该类所属的包为 com.entity，通常用于存放实体类，方便代码的组织和管理

public class WebTea {
    // 定义一个私有字符串类型的变量 tdept，用于存储教师所在的系部
    private String tdept;
    // 定义一个私有整型变量 tishotNum，用于存储教师中发热的人数
    private int tishotNum;
    // 定义一个私有整型变量 tiscoughNum，用于存储教师中咳嗽的人数
    private int tiscoughNum;
    // 定义一个私有整型变量 tstatusNum，用于存储处于某种特定状态的教师人数
    private int tstatusNum;
    // 定义一个私有整型变量 tisseemNum，用于存储有某种特定表现的教师人数
    private int tisseemNum;
    // 定义一个私有整型变量 tisdiagnoseNum，用于存储已被诊断的教师人数
    private int tisdiagnoseNum;

    // 设置教师所在系部的方法，接收一个字符串类型的参数 tdept
    public void setTdept(String tdept) {
        // 将传入的参数值赋给当前对象的 tdept 成员变量
        this.tdept = tdept;
    }

    // 设置教师中发热人数的方法，接收一个整型参数 tishotNum
    public void setTishotNum(int tishotNum) {
        // 将传入的参数值赋给当前对象的 tishotNum 成员变量
        this.tishotNum = tishotNum;
    }

    // 设置教师中咳嗽人数的方法，接收一个整型参数 tiscoughNum
    public void setTiscoughNum(int tiscoughNum) {
        // 将传入的参数值赋给当前对象的 tiscoughNum 成员变量
        this.tiscoughNum = tiscoughNum;
    }

    // 设置处于特定状态的教师人数的方法，接收一个整型参数 tstatusNum
    public void setTstatusNum(int tstatusNum) {
        // 将传入的参数值赋给当前对象的 tstatusNum 成员变量
        this.tstatusNum = tstatusNum;
    }

    // 设置有特定表现的教师人数的方法，接收一个整型参数 tisseemNum
    public void setTisseemNum(int tisseemNum) {
        // 将传入的参数值赋给当前对象的 tisseemNum 成员变量
        this.tisseemNum = tisseemNum;
    }

    // 设置已被诊断的教师人数的方法，接收一个整型参数 tisdiagnoseNum
    public void setTisdiagnoseNum(int tisdiagnoseNum) {
        // 将传入的参数值赋给当前对象的 tisdiagnoseNum 成员变量
        this.tisdiagnoseNum = tisdiagnoseNum;
    }

    // 获取教师所在系部的方法，返回值类型为字符串
    public String getTdept() {
        // 返回当前对象的 tdept 成员变量的值
        return tdept;
    }

    // 获取教师中发热人数的方法，返回值类型为整型
    public int getTishotNum() {
        // 返回当前对象的 tishotNum 成员变量的值
        return tishotNum;
    }

    // 获取教师中咳嗽人数的方法，返回值类型为整型
    public int getTiscoughNum() {
        // 返回当前对象的 tiscoughNum 成员变量的值
        return tiscoughNum;
    }

    // 获取处于特定状态的教师人数的方法，返回值类型为整型
    public int getTstatusNum() {
        // 返回当前对象的 tstatusNum 成员变量的值
        return tstatusNum;
    }

    // 获取有特定表现的教师人数的方法，返回值类型为整型
    public int getTisseemNum() {
        // 返回当前对象的 tisseemNum 成员变量的值
        return tisseemNum;
    }

    // 获取已被诊断的教师人数的方法，返回值类型为整型
    public int getTisdiagnoseNum() {
        // 返回当前对象的 tisdiagnoseNum 成员变量的值
        return tisdiagnoseNum;
    }

    // 重写 Object 类的 toString 方法，用于将对象的信息以字符串形式输出
    @Override
    public String toString() {
        // 构建并返回包含对象各成员变量信息的字符串
        return "WebTea{" +
                "tdept='" + tdept + '\'' +
                ", tishotNum=" + tishotNum +
                ", tiscoughNum=" + tiscoughNum +
                ", tstatusNum=" + tstatusNum +
                ", tisseemNum=" + tisseemNum +
                ", tisdiagnoseNum=" + tisdiagnoseNum +
                '}';
    }
}
// 声明该类所属的包为 com.filter，包用于组织和管理 Java 类，避免命名冲突
package com.filter;

// 导入 javax.servlet 包下的 Servlet、ServletRequest、ServletResponse、FilterChain 等接口，用于创建和处理 Servlet 相关操作
import javax.servlet.*;
// 导入 javax.servlet.annotation 包下的 WebFilter 注解，用于将该类标记为一个 Servlet 过滤器，并指定过滤的 URL 模式
import javax.servlet.annotation.WebFilter;
// 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于处理 HTTP 请求
import javax.servlet.http.HttpServletRequest;
// 导入 java.io 包下的 IOException 类，用于处理输入输出相关的异常
import java.io.IOException;

// 使用 WebFilter 注解将该类标记为一个 Servlet 过滤器，指定过滤的 URL 模式为 "/view/deptadmin/deptmainview.jsp"
@WebFilter("/view/deptadmin/deptmainview.jsp")
// 定义一个名为 DeptAdmLoginFilter 的类，实现 Filter 接口，用于实现部门管理员登录过滤功能
public class DeptAdmLoginFilter implements Filter {

    /**
     * 过滤器的初始化方法，在过滤器实例化后被调用，用于初始化过滤器的配置信息
     * @param filterConfig 包含过滤器配置信息的 FilterConfig 对象
     * @throws ServletException 当初始化过程中发生错误时抛出
     */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 目前该方法为空，可在需要时添加初始化相关的代码
    }

    /**
     * 过滤器的核心方法，用于对请求进行过滤处理
     * @param servletRequest 表示客户端的请求
     * @param servletResponse 表示对客户端的响应
     * @param filterChain 用于调用过滤器链中的下一个过滤器或目标资源
     * @throws IOException 当处理输入输出操作发生错误时抛出
     * @throws ServletException 当处理 Servlet 相关操作发生错误时抛出
     */
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // 将 ServletRequest 强制转换为 HttpServletRequest，以便使用 HTTP 相关的方法
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        // 3. 从获取的 session 中获取名为 "deptadno" 的属性值，该属性可能用于标识部门管理员是否已登录
        Object deptadno = request.getSession().getAttribute("deptadno");
        // 打印获取到的 "deptadno" 属性值，用于调试和查看信息
        System.out.println(deptadno);
        // 判断获取到的 "deptadno" 属性值是否不为空
        if (deptadno != null){
            // 用户已登录，将请求和响应传递给过滤器链中的下一个过滤器或目标资源，即放行请求
            filterChain.doFilter(servletRequest, servletResponse);
        }else {
            // 用户没有登录，通过 RequestDispatcher 将请求转发到 "/view/frontweb/deptadmlogin.jsp" 页面，即跳转到登录页面
            request.getRequestDispatcher("/view/frontweb/deptadmlogin.jsp").forward(servletRequest, servletResponse);
        }
    }

    /**
     * 过滤器的销毁方法，在过滤器实例被销毁前调用，用于释放过滤器占用的资源
     */
    @Override
    public void destroy() {
        // 目前该方法为空，可在需要时添加释放资源相关的代码
    }
}
// 声明该类所属的包为 com.filter，用于组织和管理过滤器相关的类
package com.filter;

// 导入 javax.servlet 包下的 Servlet、ServletRequest、ServletResponse、FilterChain 等接口，
// 这些接口是创建和使用 Servlet 过滤器所必需的基础接口
import javax.servlet.*;
// 导入 javax.servlet.annotation 包下的 WebFilter 注解，
// 该注解用于将一个类标记为 Servlet 过滤器，并指定过滤器所应用的 URL 模式
import javax.servlet.annotation.WebFilter;
// 导入 javax.servlet.http 包下的 HttpServletRequest 类，
// 用于处理 HTTP 请求相关的操作，这里主要用于获取 HTTP 请求中的会话信息
import javax.servlet.http.HttpServletRequest;
// 导入 java.io 包下的 IOException 类，用于处理输入输出相关的异常
import java.io.IOException;

// 使用 WebFilter 注解将该类标记为一个 Servlet 过滤器，
// 并指定该过滤器应用于 "/view/schoadmin/schomainview.jsp" 这个 URL 模式
@WebFilter("/view/schoadmin/schomainview.jsp")
// 定义一个名为 SchoAdmLoginFilter 的类，实现 Filter 接口，
// 用于实现学校管理员登录状态的过滤功能
public class SchoAdmLoginFilter implements Filter {

    /**
     * 过滤器的初始化方法，在过滤器实例化时被调用，
     * 用于初始化过滤器的配置信息等资源。
     * 这里目前为空实现，后续如有需要可以添加初始化相关的代码逻辑。
     * @param filterConfig 包含过滤器配置信息的 FilterConfig 对象
     * @throws ServletException 当初始化过程中发生异常时抛出
     */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    /**
     * 过滤器的核心方法，用于对请求进行过滤处理。
     * 该方法会在每次请求经过该过滤器时被调用。
     * @param servletRequest 表示客户端发送的请求对象
     * @param servletResponse 表示服务器对客户端请求的响应对象
     * @param filterChain 用于调用过滤器链中的下一个过滤器或目标资源
     * @throws IOException 当在处理请求或响应过程中发生输入输出异常时抛出
     * @throws ServletException 当在处理 Servlet 相关操作时发生异常时抛出
     */
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // 将 ServletRequest 类型的对象强制转换为 HttpServletRequest 类型，
        // 以便使用 HttpServletRequest 中特有的方法，如获取会话（session）信息等。
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        // 从当前请求的会话（session）中获取名为 "schoadno" 的属性值，
        // 这里的 "schoadno" 可能是用于标识学校管理员登录状态的一个属性。
        Object schoadno = request.getSession().getAttribute("schoadno");
        // 打印获取到的 "schoadno" 属性值，主要用于调试，方便查看该属性是否正确获取。
        System.out.println(schoadno);
        // 判断获取到的 "schoadno" 属性值是否不为空，
        // 如果不为空，则认为用户已经登录。
        if (schoadno != null){
            // 用户已登录，将请求和响应传递给过滤器链中的下一个过滤器或目标资源，
            // 即放行该请求，让其继续处理。
            filterChain.doFilter(servletRequest, servletResponse);
        }else {
            // 用户未登录，通过 RequestDispatcher 将请求转发到 "/view/frontweb/schoadmlogin.jsp" 页面，
            // 从而实现将未登录用户重定向到学校管理员登录页面的功能。
            request.getRequestDispatcher("/view/frontweb/schoadmlogin.jsp").forward(servletRequest, servletResponse);
        }
    }

    /**
     * 过滤器的销毁方法，在过滤器实例被销毁之前调用，
     * 用于释放过滤器所占用的资源，如关闭数据库连接、释放文件句柄等。
     * 这里目前为空实现，后续如有需要可以添加资源释放相关的代码逻辑。
     */
    @Override
    public void destroy() {

    }
}
package com.filter;
// 声明该类所属的包为 com.filter，用于组织和管理过滤器相关的类

import javax.servlet.*;
// 导入 javax.servlet 包下的 Servlet 相关接口和类，用于创建和处理 Servlet 相关操作

import javax.servlet.annotation.WebFilter;
// 导入用于将 Servlet 过滤器映射到特定 URL 模式的注解

import javax.servlet.http.HttpServletRequest;
// 导入 javax.servlet.http 包下的 HttpServletRequest 类，用于处理 HTTP 请求

import java.io.IOException;
// 导入用于处理输入输出异常的类

@WebFilter("/view/frontweb/stuinfo.jsp")
// 使用 WebFilter 注解将该过滤器映射到 "/view/frontweb/stuinfo.jsp" 这个 URL 路径上，
// 当客户端请求访问该路径时，此过滤器会被触发执行

public class StuLoginFilter implements Filter {
    // 实现 Filter 接口的 init 方法，该方法在过滤器初始化时被调用，
    // 用于执行一些初始化操作，这里为空实现
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    // 实现 Filter 接口的 doFilter 方法，该方法是过滤器的核心方法，
    // 用于对请求和响应进行过滤处理
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // 将 ServletRequest 强转为 HttpServletRequest，以便使用 HTTP 相关的方法
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        // 从当前请求的 session 中获取名为 "sno" 的属性值，这里假设 "sno" 是用于标识用户登录状态的信息
        Object sno = request.getSession().getAttribute("sno");
        // 打印获取到的 "sno" 属性值，主要用于调试，查看是否获取到了正确的信息
        System.out.println(sno);
        // 判断获取到的 "sno" 属性值是否不为 null
        if (sno != null){
            // 如果不为 null，说明用户已经登录，调用 filterChain 的 doFilter 方法放行请求，
            // 让请求继续传递到后续的过滤器或目标资源（如 JSP 页面）
            filterChain.doFilter(servletRequest, servletResponse);
        }else {
            // 如果为 null，说明用户没有登录，使用 request 的 getRequestDispatcher 方法获取一个请求转发器，
            // 将请求转发到 "/view/frontweb/stulogin.jsp" 页面，即跳转到登录页面
            request.getRequestDispatcher("/view/frontweb/stulogin.jsp").forward(servletRequest, servletResponse);
        }
    }

    // 实现 Filter 接口的 destroy 方法，该方法在过滤器销毁时被调用，
    // 用于执行一些清理资源等操作，这里为空实现
    @Override
    public void destroy() {

    }
}
// 声明该类所属的包，表明该类是用于过滤相关功能的类，属于com.filter包
package com.filter;

// 导入Servlet相关的接口和类，用于实现过滤器的功能
import javax.servlet.*;
// 导入Servlet注解，用于将过滤器映射到特定的URL路径
import javax.servlet.annotation.WebFilter;
// 导入HTTP请求相关的类，用于处理HTTP请求相关操作
import javax.servlet.http.HttpServletRequest;
// 导入处理输入输出异常的类，当在过滤器执行过程中出现输入输出相关错误时会抛出该异常
import java.io.IOException;

// 使用注解将该过滤器映射到/StuInfoServlet路径，对访问该路径的请求进行过滤操作
@WebFilter("/StuInfoServlet")
// 定义一个名为StuLoginFilter1的类，实现Filter接口，用于实现学生登录相关的过滤逻辑
public class StuLoginFilter1 implements Filter {

    // 重写init方法，在过滤器初始化时调用，这里为空实现，目前没有在初始化时需要执行的操作
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    // 重写doFilter方法，这是过滤器的核心方法，用于处理请求和响应
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // 将ServletRequest类型的请求对象强转为HttpServletRequest类型，以便使用HTTP相关的方法和属性
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        // 从当前请求的会话（session）中获取名为sno的属性值，sno可能代表学生学号，用于判断学生是否登录
        Object sno = request.getSession().getAttribute("sno");
        // 在控制台打印获取到的sno属性值，用于调试，查看是否成功获取该属性
        System.out.println(sno);
        // 判断获取到的sno属性值是否不为空，若不为空则表示学生已登录
        if (sno != null) {
            // 如果学生已登录，调用过滤器链的doFilter方法，将请求和响应传递给下一个过滤器或目标资源，即放行请求
            filterChain.doFilter(servletRequest, servletResponse);
        } else {
            // 如果学生未登录，使用请求的getRequestDispatcher方法获取一个请求转发器
            // 将请求转发到/view/frontweb/stulogin.jsp页面，即跳转到学生登录页面
            request.getRequestDispatcher("/view/frontweb/stulogin.jsp").forward(servletRequest, servletResponse);
        }
    }

    // 重写destroy方法，在过滤器销毁时调用，这里为空实现，目前没有在过滤器销毁时需要执行的清理操作
    @Override
    public void destroy() {

    }
}
// 声明该类所属的包，表明该类是一个过滤器类，通常用于处理请求和响应的过滤逻辑
package com.filter;

// 导入Servlet相关的接口和类，用于处理Servlet请求和响应
import javax.servlet.*;
// 导入Servlet注解，用于将过滤器映射到指定的URL路径
import javax.servlet.annotation.WebFilter;
// 导入HTTP请求相关的类，用于处理HTTP请求
import javax.servlet.http.HttpServletRequest;
// 导入处理输入输出异常的类，当进行输入输出操作时可能会抛出该异常
import java.io.IOException;

// 使用注解将该过滤器映射到/view/frontweb/teainfo.jsp路径，对访问该路径的请求进行过滤
@WebFilter("/view/frontweb/teainfo.jsp")
// 定义一个名为TeacherLoginFilter的类，实现Filter接口，用于过滤教师登录相关的请求
public class TeacherLoginFilter implements Filter {

    // 重写init方法，在过滤器初始化时调用，这里为空实现，未做任何初始化操作
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    // 重写doFilter方法，这是过滤器的核心方法，用于处理请求和响应
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // 将ServletRequest强制转换为HttpServletRequest，以便使用HTTP相关的方法
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        // 从当前请求的会话（session）中获取名为tno的属性值，tno可能代表教师编号，用于判断用户是否登录
        Object tno = request.getSession().getAttribute("tno");
        // 在控制台打印获取到的tno属性值，用于调试
        System.out.println(tno);
        // 判断获取到的tno属性值是否不为空，若不为空则表示用户已登录
        if (tno != null) {
            // 如果用户已登录，调用过滤器链的doFilter方法，将请求和响应传递给下一个过滤器或目标资源，即放行请求
            filterChain.doFilter(servletRequest, servletResponse);
        } else {
            // 如果用户未登录，使用请求的getRequestDispatcher方法获取一个请求转发器
            // 将请求转发到/view/frontweb/tealogin.jsp页面，即跳转到教师登录页面
            request.getRequestDispatcher("/view/frontweb/tealogin.jsp").forward(servletRequest, servletResponse);
        }
    }

    // 重写destroy方法，在过滤器销毁时调用，这里为空实现，未做任何清理操作
    @Override
    public void destroy() {

    }
}
// 声明该类所在的包为 com.filter
package com.filter;

// 导入 Servlet 相关的接口和类，用于创建过滤器和处理 Servlet 请求/响应
import javax.servlet.*;
// 导入用于将过滤器映射到特定 URL 模式的注解
import javax.servlet.annotation.WebFilter;
// 导入 HttpServletRequest 类，用于处理 HTTP 请求
import javax.servlet.http.HttpServletRequest;
// 导入 IOException 类，用于处理输入输出异常
import java.io.IOException;

// 使用 WebFilter 注解将该过滤器映射到 "/TeaInfoServlet" 路径，
// 当客户端请求访问该路径时，该过滤器会被触发执行
@WebFilter("/TeaInfoServlet")
// 定义 TeacherLoginFilter1 类，实现 Filter 接口，表明这是一个过滤器类
public class TeacherLoginFilter1 implements Filter {

    // 重写 init 方法，该方法在过滤器初始化时被调用，
    // 通常用于初始化一些资源或配置信息。
    // 这里为空实现，可能不需要在初始化时进行特殊操作
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    // 重写 doFilter 方法，这是过滤器的核心方法，
    // 每次请求经过该过滤器时都会调用此方法来处理请求和响应。
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // 将 ServletRequest 强转为 HttpServletRequest，以便使用 HTTP 相关的方法
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        // 从当前请求的会话（session）中获取名为 "tno" 的属性值，
        // 这里假设 "tno" 是用于标识教师登录状态的属性
        Object tno = request.getSession().getAttribute("tno");
        // 将获取到的 "tno" 属性值打印到控制台，用于调试
        System.out.println(tno);
        // 判断获取到的 "tno" 属性值是否不为 null，
        // 如果不为 null 则表示用户已登录
        if (tno != null){
            // 用户已登录，调用 filterChain 的 doFilter 方法放行请求，
            // 让请求继续传递到后续的 Servlet 或过滤器进行处理
            filterChain.doFilter(servletRequest, servletResponse);
        } else {
            // 用户未登录，使用请求转发将请求转发到 "/view/frontweb/tealogin.jsp" 页面，
            // 即跳转到教师登录页面，让用户进行登录操作
            request.getRequestDispatcher("/view/frontweb/tealogin.jsp").forward(servletRequest, servletResponse);
        }
    }

    // 重写 destroy 方法，该方法在过滤器销毁时被调用，
    // 通常用于释放初始化时创建的资源。
    // 这里为空实现，可能不需要在销毁时进行特殊操作
    @Override
    public void destroy() {

    }
}