diff --git a/Reader_注释 b/Reader_注释 new file mode 100644 index 0000000..6c2dfa5 --- /dev/null +++ b/Reader_注释 @@ -0,0 +1,4243 @@ +// 声明该类所在的包名为 javabean +package javabean; + +// 导入// 声明该类所在的包名为 javabean + package javabean; + + // 导入 java.sql 包中的 Connection 类，用于建立与数据库的连接 + import java.sql.Connection; + // 导入 java.sql 包中的 PreparedStatement 类，用于执行预编译的 SQL 语句 + import java.sql.PreparedStatement; + // 导入 java.sql 包中的 ResultSet 类，用于存储数据库查询结果 + import java.sql.ResultSet; + // 导入 java.sql 包中的 SQLException 类，用于处理 SQL 操作中可能出现的异常 + import java.sql.SQLException; + + // 定义一个名为 Reader 的公共类，用于处理读者登录相关操作 + public class Reader { + // 抑制“可能存在空指针引用”的警告 + @SuppressWarnings("null") + /** + * 该方法用于处理读者的登录逻辑 + * @param user 读者的账号 + * @param psw 读者的密码 + * @return 返回登录结果的提示信息 + * @throws ClassNotFoundException 如果在加载数据库驱动类时出现问题，抛出该异常 + * @throws SQLException 如果在执行 SQL 操作时出现问题，抛出该异常 + */ + public String login(String user, String psw) throws ClassNotFoundException, SQLException { + + // 检查账号是否为空或仅包含空白字符 + if (user == null || user.trim().equals("")) { + // 如果账号为空，返回提示信息 + return "账号不能为空"; + } + // 检查密码是否为空或仅包含空白字符 + else if (psw == null || psw.trim().equals("")) { + // 如果密码为空，返回提示信息 + return "密码不能为空"; + } + + // 声明一个 Connection 对象，用于存储与数据库的连接，初始值为 null + Connection connection = null; + // 声明一个 PreparedStatement 对象，用于执行预编译的 SQL 语句，初始值为 null + PreparedStatement pstmt = null; + // 声明一个 ResultSet 对象，用于存储数据库查询结果，初始值为 null + ResultSet resultSet = null; + + // 定义一个 SQL 查询语句，使用占位符 ? 来防止 SQL 注入 + String sql = "select * from borrow_card where ID=? and PASSWORD=?"; + + // 调用 Base 类的 getConnection 方法获取数据库连接，并将其赋值给 connection 对象 + connection = Base.getConnection(); + + // 使用 connection 对象创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句 + pstmt = (PreparedStatement) connection.prepareStatement(sql); + + // 为 SQL 语句中的第一个占位符（即 ID）设置值，值为传入的 user 参数 + pstmt.setString(1, user); + // 为 SQL 语句中的第二个占位符（即 PASSWORD）设置值，值为传入的 psw 参数 + pstmt.setString(2, psw); + + // 执行 SQL 查询语句，并将查询结果存储在 resultSet 对象中 + resultSet = pstmt.executeQuery(); + + // 检查结果集中是否有下一行记录 + if (resultSet.next()) { + // 如果有记录，说明账号和密码匹配，返回 "1" 表示登录成功 + return "1"; + } + + // 如果结果集中没有记录，说明账号或密码错误，返回提示信息 + return "账号或密码错误"; + } + } + // 声明该 Servlet 类所在的包名为 servlet.reader + package servlet.reader; + + import java.io.IOException; + import java.io.PrintWriter; + import java.sql.Connection; + import java.sql.PreparedStatement; + import java.sql.ResultSet; + import java.sql.SQLException; + + 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 javabean.Base; + import net.sf.json.JSONArray; + import net.sf.json.JSONObject; + + /** + * Servlet implementation class Book + * 该 Servlet 用于处理读者相关的书籍查询请求，返回符合条件的书籍信息的 JSON 数据 + */ + @WebServlet("/reader/book") + public class Book extends HttpServlet { + // 重写 doGet 方法，处理 HTTP GET 请求 + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 设置响应的内容类型为 JSON 格式，并指定字符编码为 UTF-8 + resp.setContentType("application/json; charset=utf8"); + + // 接收客户端传递的参数 + // limit 表示每页显示的记录数 + String limit = req.getParameter("limit"); + // page 表示当前页码 + String page = req.getParameter("page"); + // condition 表示查询的条件字段 + String condition = (String) req.getParameter("condition"); + // conditionValue 表示查询条件字段的值 + String conditionValue = (String) req.getParameter("conditionValue"); + + // 初始化 SQL 查询的 WHERE 子句为空，表示无限制条件 + String where = ""; + + // 如果 page 参数为空，默认设置为第 1 页 + if (page == null) { + page = "1"; + } + // 如果 limit 参数为空，默认设置每页显示 10 条记录 + if (limit == null) { + limit = "10"; + } + + // 准备数据库操作所需的对象 + // 数据库连接对象 + Connection connection = null; + // 用于执行查询书籍信息的预编译 SQL 语句对象 + PreparedStatement pstmt = null; + // 用于执行查询书籍总数的预编译 SQL 语句对象 + PreparedStatement countPstmt = null; + // 存储查询书籍信息的结果集 + ResultSet resultSet = null; + // 存储查询书籍总数的结果集 + ResultSet countSet = null; + // 存储查询书籍信息的 SQL 语句 + String sql = ""; + // 存储查询书籍总数的 SQL 语句 + String countSql = ""; + + // 准备返回给客户端的参数 + // 状态码，1 表示无数据，0 表示查询成功 + int code = 1; + // 提示信息，默认提示无数据 + String msg = "无数据"; + // 符合条件的书籍总数，初始化为 0 + int count = 0; + + // 用于存储单条书籍信息的 JSON 对象 + JSONObject jsonData = new JSONObject(); + // 用于存储所有书籍信息的 JSON 数组 + JSONArray jsonArray = new JSONArray(); + // 用于存储最终返回给客户端的 JSON 数据，包含状态码、总数、提示信息和书籍信息数组 + JSONObject jsonResult = new JSONObject(); + + // 进行数据库查询操作 + try { + // 通过 Base 类的 getConnection 方法获取数据库连接 + connection = (Connection) Base.getConnection(); + // 初始化查询书籍信息的 SQL 语句，从 books 表中查询所有字段 + sql = "select * from books "; + // 如果查询条件字段和条件值都不为空，则添加 WHERE 子句到 SQL 语句中 + if (condition != null && conditionValue != null && !condition.equals("") && !conditionValue.equals("")) { + where = " where " + condition + " like '%" + conditionValue + "%' "; + sql += where; + } + // 添加分页查询的 LIMIT 子句到 SQL 语句中 + sql += " limit ?,?"; + // 预编译 SQL 语句 + pstmt = connection.prepareStatement(sql); + // 设置 LIMIT 子句的第一个参数，计算当前页的起始记录索引 + pstmt.setInt(1, (Integer.parseInt(page) - 1) * Integer.parseInt(limit)); + // 设置 LIMIT 子句的第二个参数，即每页显示的记录数 + pstmt.setInt(2, Integer.parseInt(limit)); + // 执行查询操作，获取结果集 + resultSet = pstmt.executeQuery(); + + // 遍历结果集 + while (resultSet.next()) { + // 获取书籍所在图书馆的 ID + String library = resultSet.getString("library_id"); + // 构建查询图书馆名称的 SQL 语句 + String sql1 = "select * from library where ID =" + library; + // 预编译该 SQL 语句 + PreparedStatement pstmt1 = connection.prepareStatement(sql1); + // 执行查询操作，获取结果集 + ResultSet rs1 = pstmt1.executeQuery(); + // 存储图书馆名称，初始为空 + String lib = ""; + // 遍历结果集，获取图书馆名称 + while (rs1.next()) { + lib = rs1.getString("name"); + } + + // 获取书籍的分类 ID + String sortid = resultSet.getString("sort_id"); + // 构建查询书籍分类名称的 SQL 语句 + String sql2 = "select * from book_sort where ID =" + sortid; + // 预编译该 SQL 语句 + PreparedStatement pstmt2 = connection.prepareStatement(sql2); + // 执行查询操作，获取结果集 + ResultSet rs2 = pstmt2.executeQuery(); + // 存储书籍分类名称，初始为空 + String sort = ""; + // 遍历结果集，获取书籍分类名称 + while (rs2.next()) { + sort = rs2.getString("name"); + } + + // 将书籍信息添加到 JSON 对象中 + jsonData.put("id", resultSet.getString("id")); + jsonData.put("name", resultSet.getString("name")); + jsonData.put("author", resultSet.getString("author")); + jsonData.put("library_id", lib); + jsonData.put("sort_id", sort); + jsonData.put("position", resultSet.getString("position")); + jsonData.put("status", resultSet.getString("status")); + jsonData.put("description", resultSet.getString("description")); + // 将单条书籍信息的 JSON 对象添加到 JSON 数组中 + jsonArray.add(jsonData); + // 清空 JSON 对象，以便存储下一条书籍信息 + jsonData = new JSONObject(); + } + + // 构建查询书籍总数的 SQL 语句 + countSql = "select count(*) as count from books "; + // 添加 WHERE 子句到总数查询的 SQL 语句中 + countSql += where; + // 预编译该 SQL 语句 + countPstmt = connection.prepareStatement(countSql); + // 执行查询操作，获取结果集 + countSet = countPstmt.executeQuery(); + // 从结果集中获取书籍总数 + if (countSet.next()) { + count = countSet.getInt("count"); + } + + // 如果 JSON 数组不为空，说明查询到了数据，将状态码设置为 0，提示信息设置为查询成功 + if (!jsonArray.isEmpty()) { + code = 0; + msg = "查询成功"; + } + + } catch (ClassNotFoundException e) { + // 如果在加载数据库驱动类时出现异常，将提示信息设置为 class 没找到 + msg = "class没找到"; + } catch (SQLException e) { + // 如果在执行 SQL 语句时出现异常，将提示信息设置为 sql 错误 + msg = "sql错误"; + } finally { + try { + // 关闭数据库资源，包括 PreparedStatement 和 ResultSet + Base.closeResource(null, pstmt, resultSet); + Base.closeResource(connection, countPstmt, countSet); + } catch (SQLException e) { + // 如果在关闭资源时出现异常，将提示信息设置为关闭资源失败 + msg = "关闭资源失败"; + } + } + + // 将状态码、总数、提示信息和书籍信息数组添加到最终的 JSON 对象中 + jsonResult.put("code", code); + jsonResult.put("count", count); + jsonResult.put("msg", msg); + jsonResult.put("data", jsonArray.toArray()); + // 获取响应的输出流 + PrintWriter out = resp.getWriter(); + // 将最终的 JSON 对象转换为字符串并输出到客户端 + out.print(jsonResult.toString()); + } + } + // 包声明，表明该类属于servlet.reader包 + package servlet.reader; + + // 导入处理输入输出异常的类 + import java.io.IOException; + // 导入用于向客户端发送字符文本的类 + import java.io.PrintWriter; + // 导入表示数据库连接的类 + import java.sql.Connection; + // 导入用于执行预编译SQL语句的类 + import java.sql.PreparedStatement; + // 导入用于存储数据库查询结果的类 + import java.sql.ResultSet; + // 导入处理SQL操作异常的类 + import java.sql.SQLException; + + // 导入处理Servlet异常的类 + import javax.servlet.ServletException; + // 导入用于注解Servlet映射路径的类 + import javax.servlet.annotation.WebServlet; + // 导入HttpServlet类，用于创建Servlet + import javax.servlet.http.HttpServlet; + // 导入表示HTTP请求的类 + import javax.servlet.http.HttpServletRequest; + // 导入表示HTTP响应的类 + import javax.servlet.http.HttpServletResponse; + // 导入用于管理用户会话的类 + import javax.servlet.http.HttpSession; + + // 导入自定义的数据库连接管理类 + import javabean.Base; + // 导入用于处理JSON数组的类 + import net.sf.json.JSONArray; + // 导入用于处理JSON对象的类 + import net.sf.json.JSONObject; + + /** + * Servlet实现类Borrow + * 该Servlet用于处理读者借阅记录的查询请求，返回符合条件的借阅记录的JSON数据 + */ + @WebServlet("/reader/borrow") + public class Borrow extends HttpServlet { + // 重写doGet方法，用于处理HTTP GET请求 + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 设置响应的内容类型为JSON格式，并指定字符编码为UTF-8 + resp.setContentType("application/json; charset=utf8"); + + // 接收客户端传递的参数 + // limit表示每页显示的记录数 + String limit = req.getParameter("limit"); + // page表示当前页码 + String page = req.getParameter("page"); + // condition表示查询的条件字段 + String condition = (String) req.getParameter("condition"); + // conditionValue表示查询条件字段的值 + String conditionValue = (String) req.getParameter("conditionValue"); + + // 初始化SQL查询的WHERE子句为空，表示无限制条件 + String where = ""; + + // 如果page参数为空，默认设置为第1页 + if (page == null) { + page = "1"; + } + // 如果limit参数为空，默认设置每页显示10条记录 + if (limit == null) { + limit = "10"; + } + + // 准备数据库操作所需的对象 + // 数据库连接对象 + Connection connection = null; + // 用于执行查询借阅记录的预编译SQL语句对象 + PreparedStatement pstmt = null; + // 用于执行查询借阅记录总数的预编译SQL语句对象 + PreparedStatement countPstmt = null; + // 存储查询借阅记录的结果集 + ResultSet resultSet = null; + // 存储查询借阅记录总数的结果集 + ResultSet countSet = null; + // 存储查询借阅记录的SQL语句 + String sql = ""; + // 存储查询借阅记录总数的SQL语句 + String countSql = ""; + + // 准备返回给客户端的参数 + // 状态码，1表示无数据，0表示查询成功 + int code = 1; + // 提示信息，默认提示无数据 + String msg = "无数据"; + // 符合条件的借阅记录总数，初始化为0 + int count = 0; + + // 获取当前请求的会话对象 + HttpSession session = req.getSession(); + + // 用于存储单条借阅记录信息的JSON对象 + JSONObject jsonData = new JSONObject(); + // 用于存储所有借阅记录信息的JSON数组 + JSONArray jsonArray = new JSONArray(); + // 用于存储最终返回给客户端的JSON数据，包含状态码、总数、提示信息和借阅记录信息数组 + JSONObject jsonResult = new JSONObject(); + + // 进行数据库查询操作 + try { + // 通过Base类的getConnection方法获取数据库连接 + connection = (Connection) Base.getConnection(); + // 初始化查询借阅记录的SQL语句，从borrow_books表中查询所有字段，并且只查询当前读者的记录 + sql = "select * from borrow_books where card_id = " + session.getAttribute("reader"); + // 如果查询条件字段和条件值都不为空，则添加额外的WHERE子句到SQL语句中 + if (condition != null && conditionValue != null && !condition.equals("") && !conditionValue.equals("")) { + where = " and " + condition + " like '%" + conditionValue + "%' "; + sql += where; + } + // 添加分页查询的LIMIT子句到SQL语句中 + sql += " limit ?,?"; + // 打印生成的SQL语句，方便调试 + System.out.println("???" + sql); + // 预编译SQL语句 + pstmt = connection.prepareStatement(sql); + // 设置LIMIT子句的第一个参数，计算当前页的起始记录索引 + pstmt.setInt(1, (Integer.parseInt(page) - 1) * Integer.parseInt(limit)); + // 设置LIMIT子句的第二个参数，即每页显示的记录数 + pstmt.setInt(2, Integer.parseInt(limit)); + // 执行查询操作，获取结果集 + resultSet = pstmt.executeQuery(); + // 遍历结果集 + while (resultSet.next()) { + // 将借阅记录的各个字段信息添加到JSON对象中 + jsonData.put("id", resultSet.getString("id")); + jsonData.put("card_id", resultSet.getString("card_id")); + jsonData.put("book_id", resultSet.getString("book_id")); + jsonData.put("borrow_date", resultSet.getString("borrow_date")); + jsonData.put("end_date", resultSet.getString("end_date")); + jsonData.put("return_date", resultSet.getString("return_date")); + // 将单条借阅记录信息的JSON对象添加到JSON数组中 + jsonArray.add(jsonData); + // 清空JSON对象，以便存储下一条借阅记录信息 + jsonData = new JSONObject(); + } + // 构建查询借阅记录总数的SQL语句，同样只查询当前读者的记录 + countSql = "select count(*) as count from borrow_books where card_id = " + + req.getSession().getAttribute("reader"); + // 添加额外的WHERE子句到总数查询的SQL语句中 + countSql += where; + // 预编译该SQL语句 + countPstmt = connection.prepareStatement(countSql); + // 执行查询操作，获取结果集 + countSet = countPstmt.executeQuery(); + // 从结果集中获取借阅记录总数 + if (countSet.next()) { + count = countSet.getInt("count"); + } + // 如果JSON数组不为空，说明查询到了数据，将状态码设置为0，提示信息设置为查询成功 + if (!jsonArray.isEmpty()) { + code = 0; + msg = "查询成功"; + } + } catch (ClassNotFoundException e) { + // 如果在加载数据库驱动类时出现异常，将提示信息设置为class没找到 + msg = "class没找到"; + } catch (SQLException e) { + // 如果在执行SQL语句时出现异常，将提示信息设置为sql错误 + msg = "sql错误"; + } finally { + try { + // 关闭数据库资源，包括PreparedStatement和ResultSet + Base.closeResource(null, pstmt, resultSet); + Base.closeResource(connection, countPstmt, countSet); + } catch (SQLException e) { + // 如果在关闭资源时出现异常，将提示信息设置为关闭资源失败 + msg = "关闭资源失败"; + } + } + // 将状态码、总数、提示信息和借阅记录信息数组添加到最终的JSON对象中 + jsonResult.put("code", code); + jsonResult.put("count", count); + jsonResult.put("msg", msg); + jsonResult.put("data", jsonArray.toArray()); + // 获取响应的输出流 + PrintWriter out = resp.getWriter(); + // 将最终的JSON对象转换为字符串并输出到客户端 + out.print(jsonResult.toString()); + } + } + // 包声明：该Servlet属于servlet.reader包（读者相关Servlet） + package servlet.reader; + + import java.io.IOException; + + import javax.servlet.ServletException; + import javax.servlet.annotation.WebServlet; + import javax.servlet.http.HttpServlet; + import javax.servlet.http.HttpServletRequest; + import javax.servlet.http.HttpServletResponse; + import javax.servlet.http.HttpSession; + + /** + * Servlet实现类：退出登录处理 + * 功能：处理读者退出登录请求，销毁会话信息并跳转回登录页面 + */ + @WebServlet("/reader/exit") // 声明Servlet映射路径：/reader/exit + public class Exit extends HttpServlet { + // 序列化版本号（IDE自动生成，用于保证反序列化兼容性） + private static final long serialVersionUID = 1L; + + // 处理HTTP GET请求（退出操作一般通过GET发起） + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) + throws ServletException, IOException { + + // 获取当前用户会话 + HttpSession session = req.getSession(); + + // 检查会话中是否存在读者登录信息（"reader"为登录时存储的会话属性） + if (session.getAttribute("reader") != null) { + // 移除会话中的读者登录信息，实现退出 + session.removeAttribute("reader"); + } + + // 重定向回读者登录页面（使用动态上下文路径保证部署灵活性） + // req.getContextPath() 获取当前应用的上下文路径（如：/LibrarySystem） + // 跳转目标：/reader/04readerFrame.jsp（读者登录页面） + resp.sendRedirect(req.getContextPath() + "/reader/04readerFrame.jsp"); + } + } + // 声明该Servlet类所在的包，用于处理读者相关的Servlet操作 + package servlet.reader; + + // 导入处理输入输出异常的类 + import java.io.IOException; + // 导入用于向客户端发送字符文本的类 + import java.io.PrintWriter; + // 导入表示数据库连接的类 + import java.sql.Connection; + // 导入用于执行预编译SQL语句的类 + import java.sql.PreparedStatement; + // 导入用于存储数据库查询结果的类 + import java.sql.ResultSet; + // 导入处理SQL操作异常的类 + import java.sql.SQLException; + + // 导入处理Servlet异常的类 + import javax.servlet.ServletException; + // 导入用于注解Servlet映射路径的类 + import javax.servlet.annotation.WebServlet; + // 导入HttpServlet类，用于创建Servlet + import javax.servlet.http.HttpServlet; + // 导入表示HTTP请求的类 + import javax.servlet.http.HttpServletRequest; + // 导入表示HTTP响应的类 + import javax.servlet.http.HttpServletResponse; + // 导入用于管理用户会话的类 + import javax.servlet.http.HttpSession; + + // 导入自定义的数据库连接管理类 + import javabean.Base; + // 导入用于处理JSON数组的类 + import net.sf.json.JSONArray; + // 导入用于处理JSON对象的类 + import net.sf.json.JSONObject; + + /** + * Servlet实现类Illegal + * 该Servlet用于处理读者违规借阅记录的查询请求，返回符合条件的违规借阅记录的JSON数据 + */ + @WebServlet("/reader/illegal") + public class Illegal extends HttpServlet { + // 重写doGet方法，用于处理HTTP GET请求 + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + // 设置响应的内容类型为JSON格式，并指定字符编码为UTF-8 + resp.setContentType("application/json; charset=utf8"); + + // 接收客户端传递的参数 + // limit表示每页显示的记录数 + String limit = req.getParameter("limit"); + // page表示当前页码 + String page = req.getParameter("page"); + // condition表示查询的条件字段 + String condition = (String) req.getParameter("condition"); + // conditionValue表示查询条件字段的值 + String conditionValue = (String) req.getParameter("conditionValue"); + + // 初始化SQL查询的WHERE子句为空，表示无限制条件 + String where = ""; + + // 如果page参数为空，默认设置为第1页 + if (page == null) { + page = "1"; + } + // 如果limit参数为空，默认设置每页显示10条记录 + if (limit == null) { + limit = "10"; + } + + // 准备数据库操作所需的对象 + // 数据库连接对象 + Connection connection = null; + // 用于执行查询违规借阅记录的预编译SQL语句对象 + PreparedStatement pstmt = null; + // 用于执行查询违规借阅记录总数的预编译SQL语句对象 + PreparedStatement countPstmt = null; + // 存储查询违规借阅记录的结果集 + ResultSet resultSet = null; + // 存储查询违规借阅记录总数的结果集 + ResultSet countSet = null; + // 存储查询违规借阅记录的SQL语句 + String sql = ""; + // 存储查询违规借阅记录总数的SQL语句 + String countSql = ""; + + // 准备返回给客户端的参数 + // 状态码，1表示无数据，0表示查询成功 + int code = 1; + // 提示信息，默认提示无数据 + String msg = "无数据"; + // 符合条件的违规借阅记录总数，初始化为0 + int count = 0; + + // 获取当前请求的会话对象 + HttpSession session = req.getSession(); + + // 用于存储单条违规借阅记录信息的JSON对象 + JSONObject jsonData = new JSONObject(); + // 用于存储所有违规借阅记录信息的JSON数组 + JSONArray jsonArray = new JSONArray(); + // 用于存储最终返回给客户端的JSON数据，包含状态码、总数、提示信息和违规借阅记录信息数组 + JSONObject jsonResult = new JSONObject(); + + // 进行数据库查询操作 + try { + // 通过Base类的getConnection方法获取数据库连接 + connection = (Connection) Base.getConnection(); + // 初始化查询违规借阅记录的SQL语句，从borrow_books表中查询所有字段， + // 筛选出违规信息不为空且长度大于0的记录，并且只查询当前读者的记录 + sql = "select * from borrow_books where ILLEGAL is not null and length(trim(illegal))>0 AND CARD_ID = " + + session.getAttribute("reader"); + // 如果查询条件字段和条件值都不为空，则添加额外的WHERE子句到SQL语句中 + if (condition != null && conditionValue != null && !condition.equals("") && !conditionValue.equals("")) { + where = " and " + condition + " like '%" + conditionValue + "%' "; + sql += where; + } + // 添加分页查询的LIMIT子句到SQL语句中 + sql += " limit ?,?"; + // 打印生成的SQL语句，方便调试 + System.out.println("???" + sql); + // 预编译SQL语句 + pstmt = connection.prepareStatement(sql); + // 设置LIMIT子句的第一个参数，计算当前页的起始记录索引 + pstmt.setInt(1, (Integer.parseInt(page) - 1) * Integer.parseInt(limit)); + // 设置LIMIT子句的第二个参数，即每页显示的记录数 + pstmt.setInt(2, Integer.parseInt(limit)); + // 执行查询操作，获取结果集 + resultSet = pstmt.executeQuery(); + // 遍历结果集 + while (resultSet.next()) { + // 将违规借阅记录的各个字段信息添加到JSON对象中 + jsonData.put("id", resultSet.getString("id")); + jsonData.put("card_id", resultSet.getString("card_id")); + jsonData.put("book_id", resultSet.getString("book_id")); + jsonData.put("borrow_date", resultSet.getString("borrow_date")); + jsonData.put("end_date", resultSet.getString("end_date")); + jsonData.put("return_date", resultSet.getString("return_date")); + jsonData.put("illegal", resultSet.getString("illegal")); + jsonData.put("manager_id", resultSet.getString("manager_id")); + // 将单条违规借阅记录信息的JSON对象添加到JSON数组中 + jsonArray.add(jsonData); + // 清空JSON对象，以便存储下一条违规借阅记录信息 + jsonData = new JSONObject(); + } + // 构建查询违规借阅记录总数的SQL语句，同样筛选出违规信息不为空且长度大于0的记录， + // 并且只查询当前读者的记录 + countSql = "select count(*) as count from borrow_books where ILLEGAL is not null and length(trim(illegal))>0 AND CARD_ID = " + + session.getAttribute("reader"); + // 添加额外的WHERE子句到总数查询的SQL语句中 + countSql += where; + // 预编译该SQL语句 + countPstmt = connection.prepareStatement(countSql); + // 执行查询操作，获取结果集 + countSet = countPstmt.executeQuery(); + // 从结果集中获取违规借阅记录总数 + if (countSet.next()) { + count = countSet.getInt("count"); + } + // 如果JSON数组不为空，说明查询到了数据，将状态码设置为0，提示信息设置为查询成功 + if (!jsonArray.isEmpty()) { + code = 0; + msg = "查询成功"; + } + } catch (ClassNotFoundException e) { + // 如果在加载数据库驱动类时出现异常，将提示信息设置为class没找到 + msg = "class没找到"; + } catch (SQLException e) { + // 如果在执行SQL语句时出现异常，将提示信息设置为sql错误 + msg = "sql错误"; + } finally { + try { + // 关闭数据库资源，包括PreparedStatement和ResultSet + Base.closeResource(null, pstmt, resultSet); + Base.closeResource(connection, countPstmt, countSet); + } catch (SQLException e) { + // 如果在关闭资源时出现异常，将提示信息设置为关闭资源失败 + msg = "关闭资源失败"; + } + } + // 将状态码、总数、提示信息和违规借阅记录信息数组添加到最终的JSON对象中 + jsonResult.put("code", code); + jsonResult.put("count", count); + jsonResult.put("msg", msg); + jsonResult.put("data", jsonArray.toArray()); + // 获取响应的输出流 + PrintWriter out = resp.getWriter(); + // 将最终的JSON对象转换为字符串并输出到客户端 + out.print(jsonResult.toString()); + } + } + // 声明该Servlet类所在的包，用于处理读者相关的Servlet操作 + package servlet.reader; + + // 导入处理输入输出异常的类 + import java.io.IOException; + // 导入用于向客户端发送字符文本的类 + import java.io.PrintWriter; + // 导入处理SQL操作异常的类 + import java.sql.SQLException; + // 导入HashMap类，用于存储键值对，方便组织响应数据 + import java.util.HashMap; + + // 导入处理Servlet异常的类 + import javax.servlet.ServletException; + // 导入用于注解Servlet映射路径的类 + import javax.servlet.annotation.WebServlet; + // 导入HttpServlet类，用于创建Servlet + import javax.servlet.http.HttpServlet; + // 导入表示HTTP请求的类 + import javax.servlet.http.HttpServletRequest; + // 导入表示HTTP响应的类 + import javax.servlet.http.HttpServletResponse; + // 导入用于管理用户会话的类 + import javax.servlet.http.HttpSession; + + // 导入自定义的Reader类，用于处理读者登录逻辑 + import javabean.Reader; + // 导入用于处理JSON对象的类 + import net.sf.json.JSONObject; + + /** + * 该Servlet用于处理读者的登录请求。 + * 当客户端发送POST请求到 /readerLogin 路径时，会验证读者的账号和密码， + * 并根据验证结果返回相应的JSON数据给客户端。 + */ + @WebServlet("/readerLogin") + public class ReaderLogin extends HttpServlet { + + /** + * 处理HTTP GET请求。 + * 此方法在该Servlet中只是简单地将当前应用的上下文路径返回给客户端， + * 一般登录操作不使用GET请求，这里只是一个默认的处理。 + * + * @param request 客户端的HTTP请求对象 + * @param response 服务器的HTTP响应对象 + * @throws ServletException 如果在处理请求过程中出现Servlet相关的错误 + * @throws IOException 如果在输入输出过程中出现错误 + */ + protected void doGet(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + response.getWriter().append("Served at: ").append(request.getContextPath()); + } + + /** + * 处理HTTP POST请求，实现读者登录功能。 + * + * @param request 客户端的HTTP请求对象，包含读者输入的账号和密码 + * @param response 服务器的HTTP响应对象，用于返回登录结果的JSON数据 + * @throws ServletException 如果在处理请求过程中出现Servlet相关的错误 + * @throws IOException 如果在输入输出过程中出现错误 + */ + protected void doPost(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + // 设置响应的内容类型为JSON格式，并指定字符编码为UTF-8 + response.setContentType("application/json; charset=utf8"); + // 获取用于向客户端输出响应内容的PrintWriter对象 + PrintWriter out = response.getWriter(); + + // 从HTTP请求中获取读者输入的账号和密码 + String user = request.getParameter("user"); + String psw = request.getParameter("psw"); + + // 创建一个HashMap对象，用于存储要返回给客户端的响应信息， + // 键为字符串类型，值为对象类型 + HashMap hashMap = new HashMap(); + + // 创建Reader类的实例，用于调用登录验证方法 + Reader reader = new Reader(); + // 用于存储登录验证结果的变量 + String result = null; + try { + // 调用Reader类的login方法进行登录验证，传入账号和密码 + result = reader.login(user, psw); + } catch (ClassNotFoundException | SQLException e) { + // 捕获可能出现的类未找到异常或SQL异常，并打印异常堆栈信息 + e.printStackTrace(); + } + + // 判断登录验证结果是否为 "1"，"1" 表示登录成功 + if (result != null && result.equals("1")) { + // 获取当前请求的会话对象，如果不存在则创建一个新的会话 + HttpSession session = request.getSession(); + // 将登录的读者账号存储到会话中，方便后续使用 + session.setAttribute("reader", user); + // 设置一个标志，表示读者是首次登录（这里假设 "1" 表示登录状态） + session.setAttribute("reader_first", "1"); + // 向HashMap中添加登录成功的状态码 + hashMap.put("code", 0); + // 向HashMap中添加登录成功的提示信息 + hashMap.put("msg", "登录成功"); + // 向HashMap中添加登录成功后要跳转的页面URL + hashMap.put("url", request.getContextPath() + "/reader/01main.jsp"); + } else { + // 登录失败，向HashMap中添加登录失败的状态码 + hashMap.put("code", 1); + // 向HashMap中添加登录失败的提示信息，即登录验证结果中的错误信息 + hashMap.put("msg", result); + } + + // 将HashMap对象转换为JSON对象 + JSONObject json = JSONObject.fromObject(hashMap); + // 将JSON对象转换为字符串并通过PrintWriter输出到客户端 + out.write(json.toString()); + } + } + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + 图书馆欢迎页 + + + + + + + + + + + + + + <%-- 会话校验与自动跳转逻辑 --%> + <% + // 检查是否已登录且为首次访问（通过reader_first标记判断） + if (session.getAttribute("reader") != null + && session.getAttribute("reader_first") != null + && session.getAttribute("reader_first").equals("1")) { + + // 更新标记为已访问（防止重复跳转） + session.setAttribute("reader_first", "2"); + + // 首次登录时，通过JS跳转至框架页（使用parent.location实现嵌套页面跳转） + %> + + <% + } + %> + + + + + + + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + 读者导航栏 + + + + + + + + + + + + + + + + + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ + + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + + + + + 借阅者页面 + + + + + + + + + + + + + + + + + + <% + // 检查会话中是否存在"reader"属性，即判断用户是否已登录 + if(session.getAttribute("reader") == null){ + %> + + + <% + } else { + %> + + + <% + } + %> + + + + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + 图书查询管理 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + Insert title here + + + + + + + + + + + + + + + + + + + <% + // 检查会话中是否存在"reader"属性，若不存在则表示用户未登录 + if(session.getAttribute("reader")==null){%> + + <% + } + %> + +
+ + + + + + + + <%@ page import="java.sql.*" %> + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + + + + + + + + + + + + + + + +
+ + + + ❤图书馆公告栏，记得查收公告呀！❤ + +
+ + +
+ +

近期公告

+ + + + <% + // 定义SQL查询语句，从announcement表中查询所有记录 + String sql="select*from announcement"; + // 调用JavaBean的executeQuery方法执行SQL查询，并将结果存储在ResultSet对象中 + ResultSet rs = check.executeQuery(sql); + // 遍历ResultSet对象，处理每一条查询结果 + while (rs.next()) { + %> + +
+ +
+ + <%=rs.getString("TITLE") %> + + <%=rs.getString("PUBLISH_DATE") %> +
+ +
+ +

<%=rs.getString("DETAIL") %>

+
+
+ <% + } + %> +
+ + + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + Insert title here + + + + + + + + + + + + + + + + + + <% + // 检查会话中是否存在 "reader" 属性，如果不存在则表示用户未登录 + if(session.getAttribute("reader") == null){ + %> + + <% + } + %> + + + +
+ + + + + + + + <%@ page import="java.sql.*"%> + <%@ page import="java.util.*"%> + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + 修改密码 + + + + + + + + + <% + // 从请求中获取用户输入的新密码（第一次输入） + String psw1 = request.getParameter("psw1"); + // 从请求中获取用户输入的新密码（第二次输入） + String psw2 = request.getParameter("psw2"); + + // 输出两次输入的密码，用于调试，此处注释掉了 + //out.println(psw1 + " " + psw2); + + // 从会话中获取当前登录读者的ID，并将其转换为字符串类型 + String id = session.getAttribute("reader").toString(); + + // 检查两次输入的密码是否相同，且不为空或仅包含空格 + if (psw1.equals(psw2) && psw1 != null && psw2 != null && !psw1.trim().equals("") + && !psw2.trim().equals("")) { + // 构建SQL更新语句，将borrow_card表中对应ID的用户密码更新为新密码 + String sql = "update borrow_card set PASSWORD ='" + psw1 + "' where ID=" + id; + try { + // 调用JavaBean的executeUpdate方法执行SQL更新语句，并获取受影响的行数 + int i = check.executeUpdate(sql); + // 判断受影响的行数是否为1，即是否成功更新了一条记录 + if (i == 1) { + %> + + + <% + } else { + %> + + + <% + } + } catch (Exception e) { + %> + + + <% + } + } else { + %> + + + <% + } + %> + + + <%@ page import="java.sql.*" %> + <%@ page import="java.util.*" %> + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + + + + + + + + + + + + + + + + + + + + +

读者规则信息查看

+ +
+ <% + // 定义SQL查询语句，从rules表中查询所有记录 + String sql = "select * from rules"; + // 调用JavaBean的executeQuery方法执行SQL查询，并将结果存储在ResultSet对象中 + ResultSet rs = msg.executeQuery(sql); + // 遍历ResultSet对象，处理每一条查询结果 + while (rs.next()) { + // 判断借阅证规则编号是否为奇数 + if(Integer.parseInt(rs.getString("ID")) % 2== 1){ + %> + +

+ <% + } else { + %> + +

+ <% + } + } + %> +
+ + + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ +
+ + + + + + + + +

+ +
+ +     + +     + + +
+
+
+
+ + + <%@ page import="java.sql.*" %> + <%@ page import="java.util.*" %> + <%@ page import="javabean.DateTime"%> + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + + + + + + + + + + + + + + + + + + + + <% + // 创建 DateTime 类的实例，用于获取日期时间 + DateTime date = new DateTime(); + // 获取当前日期时间 + String time = date.show(); + + // 从请求中获取用户输入的留言内容 + String mes = request.getParameter("msg"); + + try { + // 从会话中获取读者的借阅证编号，并转换为字符串 + String card = session.getAttribute("reader").toString(); + // 构建 SQL 插入语句，将读者的借阅证编号、留言内容和留言时间插入到 message 表中 + String sql = "insert into message(card_id,detail,public_date)values('" + card + "','" + mes + "','" + time + "');"; + + // 检查借阅证编号和留言内容是否不为空，且留言内容不是仅包含空白字符 + if (card != null && mes != null && !mes.trim().equals("")) { + // 调用 JDBCBean 实例的 executeUpdate 方法执行 SQL 插入语句，并获取受影响的行数 + int i = msg.executeUpdate(sql); + + // 如果受影响的行数为 1，说明插入成功 + if (i == 1) { + %> + + <% + } else { + %> + + <% + } + } else { + %> + + <% + } + %> + <% + // 捕获异常，当出现异常时执行以下操作 + } catch (Exception e) { + %> + + <% + } + %> + + + <%@ page import="java.sql.*" %> + <%@ page import="java.util.*" %> + <%@ page import="javabean.DateTime"%> + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + + + + + + + + + + + + + + + + + + + + + +

☆★留言板★☆

+ <% + // 定义 SQL 查询语句，从 message 表中查询 CARD_ID、DETAIL 和 PUBLIC_DATE 字段，并按 PUBLIC_DATE 降序排列 + String sql = "select CARD_ID,DETAIL,PUBLIC_DATE from message order by PUBLIC_DATE desc"; + // 调用 JavaBean 的 executeQuery 方法执行 SQL 查询，并将结果存储在 ResultSet 对象中 + ResultSet rs = msg.executeQuery(sql); + // 遍历 ResultSet 对象，处理每一条查询结果 + while (rs.next()) { + %> + +
+ +
+ +

<%=rs.getString("CARD_ID")%>

+ +
+ +

<%=rs.getString("DETAIL")%>

+
+ +

<%=rs.getString("PUBLIC_DATE")%>

+
+
+ +
+ <% + } + %> + + + <%@ page import="java.sql.*"%> + <%@ page language="java" contentType="text/html; charset=UTF-8" + pageEncoding="UTF-8"%> + + + + + + + + + + + Nifty Modal Window Effects + + + + + + + + + + + + + + + + + + + + + + + <% + // 检查会话中是否存在 "reader" 属性，如果不存在则表示用户未登录 + if (session.getAttribute("reader") == null) { + %> + + <% + } + %> + + + + + +
+ +
+ +

个人信息 + + +

+
+ +
+
+ <% + try { + // 从会话中获取当前登录读者的借阅证编号 + String cardId = session.getAttribute("reader").toString(); + // 构建 SQL 查询语句，从 borrow_card 表中查询当前读者的信息 + String sql = "select*from borrow_card where ID = '" + cardId + "';"; + // 调用 JavaBean 的 executeQuery 方法执行 SQL 查询，并将结果存储在 ResultSet 对象中 + ResultSet rs = check.executeQuery(sql); + // 遍历查询结果 + while (rs.next()) { + // 获取借阅证编号 + int id = rs.getInt(1); + %> + +

 借阅证编号：<%=rs.getString("ID")%>


+ +

 借阅证姓名：<%=rs.getString("READER")%>


+ +

 规则编号：<%=rs.getString("RULE_ID")%>


+ +

 状态： + <% + // 根据 STATUS 字段的值判断借阅证状态 + if (rs.getString("STATUS").equals("1")) { + out.println("可用"); + } else { + out.println("挂失"); + } + %> +

+ <% + } + } catch (Exception e) { + // 异常处理，可根据实际需求添加日志记录等操作 + } + %> +
+
+ + +
+
+
+ +
+ + + + + + + + + + + + + package javabean; + + // 导入 java.sql 包中的相关类，用于与数据库进行交互 + import java.sql.Connection; + import java.sql.DriverManager; + import java.sql.PreparedStatement; + import java.sql.ResultSet; + import java.sql.SQLException; + + /** + * 该类提供了与数据库交互的基础方法，包括获取数据库连接、执行查询、执行更新以及释放资源等操作。 + */ + public class Base { + // 从 DBConstants 类中获取数据库驱动信息，并将其设置为常量，后续不可修改 + private static final String driver = DBConstants.driver; + // 从 DBConstants 类中获取数据库连接的 URL 信息，并将其设置为常量，后续不可修改 + private static final String url = DBConstants.url; + // 从 DBConstants 类中获取数据库用户名信息，并将其设置为常量，后续不可修改 + private static final String username = DBConstants.username; + // 从 DBConstants 类中获取数据库密码信息，并将其设置为常量，后续不可修改 + private static final String password = DBConstants.password; + + /** + * 获取数据库连接 + * + * @return 返回一个数据库连接对象，如果连接失败则返回 null + * @throws ClassNotFoundException 如果找不到数据库驱动类，抛出该异常 + */ + public static Connection getConnection() throws ClassNotFoundException { + // 初始化数据库连接对象为 null + Connection connection = null; + try { + // 加载数据库驱动类 + Class.forName(driver); + // 通过 DriverManager 获取数据库连接 + connection = (Connection) DriverManager.getConnection(url, username, password); + } catch (SQLException e) { + // 若发生 SQL 异常，打印异常堆栈信息 + e.printStackTrace(); + } + // 返回数据库连接对象 + return connection; + } + + /** + * 公共查询方法，用于执行 SQL 查询语句 + * + * @param connection 数据库连接对象，用于与数据库建立连接 + * @param preparedStatement 预编译的 SQL 语句对象，用于执行带参数的 SQL 语句 + * @param resultSet 结果集对象，用于存储查询结果 + * @param sql 要执行的 SQL 查询语句 + * @param params SQL 语句中的参数数组 + * @return 返回包含查询结果的结果集对象 + * @throws SQLException 如果执行 SQL 语句时发生错误，抛出该异常 + */ + public static ResultSet executequery(Connection connection, PreparedStatement preparedStatement, + ResultSet resultSet, String sql, Object[] params) throws SQLException { + // 如果预编译的 SQL 语句对象为空，则创建一个新的预编译对象 + if (preparedStatement == null) { + preparedStatement = (PreparedStatement) connection.prepareStatement(sql); + } + // 遍历参数数组，将参数设置到预编译的 SQL 语句中 + for (int i = 0; params != null && i < params.length; i++) { + preparedStatement.setObject(i + 1, params[i]); + } + // 执行查询语句，并将结果存储在结果集对象中 + resultSet = preparedStatement.executeQuery(); + // 返回结果集对象 + return resultSet; + } + + /** + * 公共修改方法，用于执行 SQL 更新、插入、删除等语句 + * + * @param connection 数据库连接对象，用于与数据库建立连接 + * @param preparedStatement 预编译的 SQL 语句对象，用于执行带参数的 SQL 语句 + * @param sql 要执行的 SQL 修改语句 + * @param params SQL 语句中的参数数组 + * @return 返回受影响的行数 + * @throws SQLException 如果执行 SQL 语句时发生错误，抛出该异常 + */ + public static int executeUpdate(Connection connection, PreparedStatement preparedStatement, String sql, + Object[] params) throws SQLException { + // 如果预编译的 SQL 语句对象为空，则创建一个新的预编译对象 + if (preparedStatement == null) { + preparedStatement = (PreparedStatement) connection.prepareStatement(sql); + } + // 遍历参数数组，将参数设置到预编译的 SQL 语句中 + for (int i = 0; params != null && i < params.length; i++) { + preparedStatement.setObject(i + 1, params[i]); + } + // 执行更新语句，并返回受影响的行数 + int updateRows = preparedStatement.executeUpdate(); + // 返回受影响的行数 + return updateRows; + } + + /** + * 释放数据库资源，包括结果集、预编译语句和数据库连接 + * + * @param connection 数据库连接对象 + * @param preparedStatement 预编译的 SQL 语句对象 + * @param resultSet 结果集对象 + * @return 如果所有资源都成功释放，返回 true；否则返回 false + * @throws SQLException 如果关闭资源时发生错误，抛出该异常 + */ + public static boolean closeResource(Connection connection, PreparedStatement preparedStatement, ResultSet resultSet) + throws SQLException { + // 初始化标志位为 true，表示资源释放成功 + boolean flag = true; + // 如果结果集对象不为空，则尝试关闭结果集 + if (resultSet != null) { + try { + resultSet.close(); + // 关闭后将结果集对象置为 null，便于垃圾回收 + resultSet = null; + } catch (SQLException e) { + // 若关闭结果集时发生异常，打印异常堆栈信息，并将标志位设为 false + e.printStackTrace(); + flag = false; + } + } + // 如果预编译语句对象不为空，则尝试关闭预编译语句 + if (preparedStatement != null) { + try { + preparedStatement.close(); + // 关闭后将预编译语句对象置为 null，便于垃圾回收 + preparedStatement = null; + } catch (SQLException e) { + // 若关闭预编译语句时发生异常，打印异常堆栈信息，并将标志位设为 false + e.printStackTrace(); + flag = false; + } + } + // 如果数据库连接对象不为空，则尝试关闭数据库连接 + if (connection != null) { + try { + connection.close(); + // 关闭后将数据库连接对象置为 null，便于垃圾回收 + connection = null; + } catch (SQLException e) { + // 若关闭数据库连接时发生异常，打印异常堆栈信息，并将标志位设为 false + e.printStackTrace(); + flag = false; + } + } + // 返回标志位 + return flag; + } + } + package javabean; + + import java.sql.Connection; + import java.sql.PreparedStatement; + import java.sql.ResultSet; + import java.sql.SQLException; + import java.util.HashMap; + import java.util.TreeMap; + + /** + * Common 类提供了一些通用的数据库操作方法，例如获取指定表的行数和获取图书馆信息的映射。 + */ + public class Common { + + /** + * 获取指定表的行总数。 + * + * @param table 要查询的表名 + * @return 表中的行数，如果表名为空或者查询过程中出现异常则返回 0 + * @throws SQLException 如果在执行 SQL 语句时发生数据库访问错误 + * @throws ClassNotFoundException 如果无法找到数据库驱动类 + */ + public static int getCount(String table) throws SQLException, ClassNotFoundException { + // 检查传入的表名是否为空或 null，如果是则直接返回 0 + if (table == null || table.equals("")) { + return 0; + } + // 声明数据库连接对象 + Connection connection = null; + // 声明预编译 SQL 语句对象 + PreparedStatement pstmt = null; + // 声明结果集对象 + ResultSet resultSet = null; + // 通过 Base 类的 getConnection 方法获取数据库连接 + connection = Base.getConnection(); + try { + // 准备 SQL 查询语句，用于统计指定表的行数 + pstmt = connection.prepareStatement("select count(*) as count from " + table); + // 执行查询操作，将结果存储在结果集对象中 + resultSet = pstmt.executeQuery(); + // 将结果集指针移动到第一行 + resultSet.next(); + // 从结果集中获取名为 "count" 的列的值，并返回该值 + return resultSet.getInt("count"); + } catch (Exception e) { + // 如果查询过程中出现异常，返回 0 + return 0; + } finally { + // 无论查询是否成功，都调用 Base 类的 closeResource 方法关闭数据库连接、预编译语句和结果集 + Base.closeResource(connection, pstmt, resultSet); + } + } + + /** + * 获取图书馆信息的映射，键为图书馆的 ID，值为图书馆的名称。 + * + * @return 包含图书馆信息的 TreeMap，如果出现异常则返回 null + * @throws SQLException 如果在执行 SQL 语句时发生数据库访问错误 + */ + public static TreeMap getLibraryMap() throws SQLException { + // 声明数据库连接对象 + Connection connection = null; + // 声明用于查询图书馆信息的预编译 SQL 语句对象 + PreparedStatement libraryPstmt = null; + // 声明用于存储图书馆信息查询结果的结果集对象 + ResultSet librarySet = null; + // 定义查询图书馆信息的 SQL 语句 + String librarySql = "select id,name from library"; + + // 创建一个 TreeMap 用于存储图书馆信息，TreeMap 会根据键的自然顺序进行排序 + TreeMap map = new TreeMap(); + // 获取图书馆信息 + try { + // 通过 Base 类的 getConnection 方法获取数据库连接 + connection = (Connection) Base.getConnection(); + // 准备查询图书馆信息的 SQL 语句 + libraryPstmt = connection.prepareStatement(librarySql); + // 执行查询操作，将结果存储在结果集对象中 + librarySet = libraryPstmt.executeQuery(); + // 遍历结果集 + while (librarySet.next()) { + // 将图书馆的 ID 作为键，图书馆的名称作为值，存入 TreeMap 中 + map.put(librarySet.getString("id"), librarySet.getString("name")); + } + } catch (ClassNotFoundException e) { + // 如果找不到数据库驱动类，返回 null + return null; + } catch (SQLException e) { + // 如果执行 SQL 语句时发生异常，返回 null + return null; + } finally { + // 无论查询是否成功，都调用 Base 类的 closeResource 方法关闭数据库连接、预编译语句和结果集 + Base.closeResource(connection, libraryPstmt, librarySet); + } + // 返回存储图书馆信息的 TreeMap + return map; + } + + /** + * 主方法，用于测试 getLibraryMap 方法。 + * + * @param args 命令行参数 + * @throws SQLException 如果在执行 SQL 语句时发生数据库访问错误 + */ + public static void main(String[] args) throws SQLException { + // 调用 getLibraryMap 方法并打印结果 + System.out.println(Common.getLibraryMap()); + } + } + package javabean; + + import java.text.ParseException; + import java.text.SimpleDateFormat; + import java.util.Date; + + /** + * CompareDate 类用于比较两个日期字符串所表示的日期之间的天数差。 + */ + public class CompareDate { + /** + * 该方法用于计算两个日期字符串所表示的日期之间相差的天数。 + * + * @param Str1 第一个日期字符串，格式必须为 "yyyy-MM-dd HH:mm:ss" + * @param Str2 第二个日期字符串，格式必须为 "yyyy-MM-dd HH:mm:ss" + * @return 两个日期之间相差的天数，如果解析日期字符串时发生异常则返回 0 + */ + public static long show(String Str1, String Str2) { + // 用于存储两个日期之间的毫秒差值 + long between = 0; + // 创建一个 SimpleDateFormat 对象，指定日期字符串的格式为 "yyyy-MM-dd HH:mm:ss" + SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + try { + // 将第一个日期字符串解析为 Date 对象 + Date date1 = format.parse(Str1); + // 将第二个日期字符串解析为 Date 对象 + Date date2 = format.parse(Str2); + // 计算两个日期对象之间的毫秒差值 + between = (date2.getTime() - date1.getTime()); + // 打印第一个日期对象，方便调试查看 + System.out.println(date1); + // 打印第二个日期对象，方便调试查看 + System.out.println(date2); + } catch (ParseException e) { + // 如果在解析日期字符串时发生异常，打印异常堆栈信息 + e.printStackTrace(); + } + // 将毫秒差值转换为天数，一天有 24 小时，每小时 60 分钟，每分钟 60 秒，每秒 1000 毫秒 + long days = between / (24 * 60 * 60 * 1000); + // 返回计算得到的天数差值 + return days; + } + } + package javabean; + + import java.text.SimpleDateFormat; + import java.util.Calendar; + import java.util.Date; + + /** + * DateTime 类提供了一系列用于日期和时间处理的静态方法， + * 可以获取当前日期时间、计算指定天数偏移后的日期时间等。 + */ + public class DateTime { + + /** + * 获取当前日期和时间，格式为 "yyyy-MM-dd HH:mm:ss"。 + * + * @return 格式化后的当前日期和时间字符串 + */ + public static String show() { + // 创建一个 SimpleDateFormat 对象，指定日期时间的格式为 "yyyy-MM-dd HH:mm:ss" + SimpleDateFormat myFmt2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + // 获取当前日期和时间 + Date now = new Date(); + // 使用指定格式将当前日期和时间转换为字符串并返回 + return myFmt2.format(now); + } + + /** + * 获取指定天数偏移后的日期和时间，格式为 "yyyy-MM-dd HH:mm:ss"。 + * + * @param n 要偏移的天数，正数表示未来的日期，负数表示过去的日期 + * @return 格式化后的偏移日期和时间字符串 + */ + public static String show(int n) { + // 获取当前日期和时间 + Date d = new Date(); + // 创建一个 SimpleDateFormat 对象，指定日期时间的格式为 "yyyy-MM-dd HH:mm:ss" + SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + // 将当前日期和时间按照指定格式转换为字符串 + String currdate = format.format(d); + // 获取一个 Calendar 实例，用于日期计算 + Calendar ca = Calendar.getInstance(); + // 在当前日期的基础上增加或减少指定的天数 + ca.add(Calendar.DATE, n); + // 获取计算后的日期 + d = ca.getTime(); + // 将计算后的日期按照指定格式转换为字符串 + String enddate = format.format(d); + // 返回计算后的日期和时间字符串 + return enddate; + } + + /** + * 获取指定天数偏移后的日期，只包含年、月、日，格式为 "yyyy-MM-dd"。 + * + * @param n 要偏移的天数，正数表示未来的日期，负数表示过去的日期 + * @return 格式化后的偏移日期字符串 + */ + public static String showDate(int n) { + // 获取当前日期和时间 + Date d = new Date(); + // 创建一个 SimpleDateFormat 对象，指定日期的格式为 "yyyy-MM-dd" + SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); + // 将当前日期按照指定格式转换为字符串 + String currdate = format.format(d); + // 获取一个 Calendar 实例，用于日期计算 + Calendar ca = Calendar.getInstance(); + // 在当前日期的基础上增加或减少指定的天数 + ca.add(Calendar.DATE, n); + // 获取计算后的日期 + d = ca.getTime(); + // 将计算后的日期按照指定格式转换为字符串 + String enddate = format.format(d); + // 返回计算后的日期字符串 + return enddate; + } + + /** + * 获取指定天数偏移后的日期，只包含月和日，格式为 "MM-dd"。 + * + * @param n 要偏移的天数，正数表示未来的日期，负数表示过去的日期 + * @return 格式化后的偏移日期字符串 + */ + public static String showMD(int n) { + // 获取当前日期和时间 + Date d = new Date(); + // 创建一个 SimpleDateFormat 对象，指定日期的格式为 "MM-dd" + SimpleDateFormat format = new SimpleDateFormat("MM-dd"); + // 将当前日期按照指定格式转换为字符串 + String currdate = format.format(d); + // 获取一个 Calendar 实例，用于日期计算 + Calendar ca = Calendar.getInstance(); + // 在当前日期的基础上增加或减少指定的天数 + ca.add(Calendar.DATE, n); + // 获取计算后的日期 + d = ca.getTime(); + // 将计算后的日期按照指定格式转换为字符串 + String enddate = format.format(d); + // 返回计算后的日期字符串 + return enddate; + } + } + package javabean; + + /** + * DBConstants 类用于存储数据库连接所需的常量信息， + * 这些常量包含了数据库驱动、连接 URL、用户名和密码， + * 方便在项目中统一管理和使用数据库连接相关的配置。 + */ + public class DBConstants { + /** + * 数据库驱动类的全限定名。这里使用的是 MySQL 8.x 及以上版本的 JDBC 驱动， + * 如果使用的是 MySQL 5.x 版本，驱动类名应为 "com.mysql.jdbc.Driver"。 + */ + public static final String driver = "com.mysql.cj.jdbc.Driver"; + + /** + * 数据库连接的 URL。该 URL 指定了要连接的数据库的地址、端口、数据库名以及一些连接参数。 + * - "jdbc:mysql://"：表示使用 JDBC 连接 MySQL 数据库的协议。 + * - "localhost:3306"：表示数据库服务器的地址为本地主机（localhost），端口号为 3306。 + * - "library"：表示要连接的数据库名。 + * - "&useSSL=false"：表示不使用 SSL 加密连接。 + * - "serverTimezone=UTC"：指定数据库服务器的时区为协调世界时（UTC），避免时间处理上的问题。 + * - "useUnicode=true&characterEncoding=UTF-8"：表示使用 Unicode 字符集，并将字符编码设置为 UTF-8， + * 确保能够正确处理各种语言的字符。 + */ + public static final String url = "jdbc:mysql://localhost:3306/library?&useSSL=false&serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8"; + + /** + * 连接数据库时使用的用户名。这里使用的是 MySQL 的默认超级用户 "root"， + * 在实际项目中，建议使用具有适当权限的普通用户来连接数据库，以提高安全性。 + */ + public static final String username = "root"; + + /** + * 连接数据库时使用的密码。这里的密码为 "123456"， + * 在实际项目中，应使用更复杂、安全的密码，并妥善保管，避免泄露。 + */ + public static final String password = "123456"; + } + package javabean; + + import java.text.SimpleDateFormat; + import java.util.Calendar; + import java.util.Date; + + /** + * EndTime 类提供了一个静态方法，用于计算从当前日期开始经过指定天数后的日期和时间。 + */ + public class EndTime { + + /** + * 计算从当前日期开始经过指定天数后的日期和时间。 + * + * @param n 要增加的天数，可以是正数（表示未来的日期）或负数（表示过去的日期）。 + * @return 经过指定天数后的日期和时间，格式为 "yyyy-MM-dd HH:mm:ss"。 + */ + public static String show(int n) { + // 获取当前日期和时间 + Date d = new Date(); + // 创建一个 SimpleDateFormat 对象，用于格式化日期和时间，格式为 "yyyy-MM-dd HH:mm:ss" + SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + // 将当前日期和时间格式化为字符串 + String currdate = format.format(d); + // 打印当前日期和时间 + System.out.println("现在的日期是：" + currdate); + + // 获取一个 Calendar 实例，用于进行日期计算 + Calendar ca = Calendar.getInstance(); + // 在当前日期的基础上增加指定的天数 + ca.add(Calendar.DATE, n); + // 获取增加天数后的日期 + d = ca.getTime(); + // 将增加天数后的日期格式化为字符串 + String enddate = format.format(d); + // 返回增加天数后的日期和时间字符串 + return enddate; + } + } + package javabean; + + import java.sql.Connection; + import java.sql.DriverManager; + import java.sql.ResultSet; + import java.sql.Statement; + + /** + * JDBCBean 类封装了与数据库交互的基本操作，包括建立连接、执行更新、执行查询以及关闭连接等功能。 + */ + public class JDBCBean { + // 从 DBConstants 类中获取数据库驱动信息，使用 static final 修饰确保其不可变 + private static final String driver = DBConstants.driver; + // 从 DBConstants 类中获取数据库连接的 URL 信息，使用 static final 修饰确保其不可变 + private static final String url = DBConstants.url; + // 从 DBConstants 类中获取数据库用户名信息，使用 static final 修饰确保其不可变 + private static final String username = DBConstants.username; + // 从 DBConstants 类中获取数据库密码信息，使用 static final 修饰确保其不可变 + private static final String password = DBConstants.password; + // 数据库连接对象，用于与数据库建立连接 + private Connection conn = null; + // 用于执行 SQL 语句的 Statement 对象 + private Statement stmt = null; + + /** + * 构造函数，在创建 JDBCBean 对象时自动尝试与数据库建立连接。 + */ + public JDBCBean() { + try { + // 加载数据库驱动类 + Class.forName(driver); + // 通过 DriverManager 获取数据库连接 + conn = DriverManager.getConnection(url, username, password); + // 创建一个 Statement 对象，用于执行 SQL 语句 + stmt = conn.createStatement(); + // 若连接成功，打印提示信息 + System.out.println("同数据库建立连接！"); + } catch (Exception ex) { + // 若连接过程中出现异常，打印错误提示信息 + System.out.println("无法同数据库建立连接！"); + } + } + + /** + * 执行 SQL 更新语句（如 INSERT、UPDATE、DELETE）。 + * + * @param s 要执行的 SQL 更新语句 + * @return 执行更新操作后受影响的行数，若执行出错则返回 0 + */ + public int executeUpdate(String s) { + // 用于存储执行更新操作后受影响的行数 + int result = 0; + try { + // 打印要执行的 SQL 语句和 Statement 对象信息，方便调试 + System.out.println(s + "------" + stmt + "-----"); + // 执行 SQL 更新语句，并将受影响的行数赋值给 result + result = stmt.executeUpdate(s); + } catch (Exception e) { + // 若执行更新操作时出现异常，打印错误提示信息 + System.out.println("执行更新错误！"); + } + // 返回受影响的行数 + return result; + } + + /** + * 执行 SQL 查询语句（如 SELECT）。 + * + * @param s 要执行的 SQL 查询语句 + * @return 包含查询结果的 ResultSet 对象，若执行出错则返回 null + */ + public ResultSet executeQuery(String s) { + // 用于存储查询结果的 ResultSet 对象 + ResultSet rs = null; + try { + // 执行 SQL 查询语句，并将结果存储在 rs 中 + rs = stmt.executeQuery(s); + } catch (Exception e) { + // 若执行查询操作时出现异常，打印错误提示信息和异常信息 + System.out.println("执行查询错误！ " + e.getMessage()); + } + // 返回包含查询结果的 ResultSet 对象 + return rs; + } + + /** + * 关闭数据库连接和 Statement 对象，释放资源。 + */ + public void close() { + try { + // 关闭 Statement 对象 + stmt.close(); + // 关闭数据库连接 + conn.close(); + } catch (Exception e) { + // 若关闭过程中出现异常，不做处理 + } + } + } + package javabean; + + import java.math.BigInteger; + import java.security.MessageDigest; + import java.security.NoSuchAlgorithmException; + import java.text.SimpleDateFormat; + import java.util.Date; + + import net.sf.json.JSONObject; + + /** + * Util 类提供了一系列实用工具方法，涵盖字符串处理、日期格式化、JSON 数据生成和 MD5 加密等功能。 + */ + public class Util { + + /** + * 计算字符串中指定子字符串的出现次数。 + * 此方法可用于计算 JSON 字符串中特定对象标识的数量。 + * + * @param str 要进行检查的原始字符串 + * @param contain 要查找的子字符串 + * @return 子字符串在原始字符串中出现的次数 + */ + public static int getCountString(String str, String contain) { + // 通过替换子字符串后计算长度差，再除以子字符串长度得到出现次数 + int count = (str.length() - str.replace(contain, "").length()) / contain.length(); + return count; + } + + /** + * 格式化从数据库取出的日期时间字符串，去除可能存在的 ".0" 后缀。 + * + * @param dateTime 从数据库取出的日期时间字符串 + * @return 去除 ".0" 后缀后的日期时间字符串，如果原字符串无 ".0" 或为空则返回原字符串或 null + */ + public static String getFormatDateTime(String dateTime) { + // 若日期时间字符串不为空且包含 ".0" + if (dateTime != null && dateTime.indexOf(".0") != -1) { + // 截取去除 ".0" 后的部分并返回 + return dateTime.substring(0, dateTime.length() - 2); + } else if (dateTime != null) { + // 若不包含 ".0" 且不为空，直接返回原字符串 + return dateTime; + } + // 若为空则返回 null + return null; + } + + /** + * 获取当前时间的字符串表示，格式为 "yyyy-MM-dd hh:mm:ss"。 + * + * @return 当前时间的格式化字符串 + */ + public static String getCurrentTimeString() { + // 获取当前日期对象 + Date date = new Date(); + // 定义日期时间格式化模式 + SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); + // 将日期对象按指定格式转换为字符串并返回 + return dateFormat.format(date); + } + + /** + * 生成包含状态码、消息和数据的 JSON 格式字符串响应。 + * + * @param code 状态码 + * @param msg 消息内容 + * @param data 附带的数据，如果为 null 则不包含在 JSON 中 + * @return 生成的 JSON 格式字符串 + */ + public static String jsonResponse(int code, String msg, String data) { + // 创建一个 JSONObject 对象 + JSONObject jsonObject = new JSONObject(); + // 向 JSON 对象中添加状态码 + jsonObject.put("code", code); + // 向 JSON 对象中添加消息内容 + jsonObject.put("msg", msg); + // 若数据不为空，则添加到 JSON 对象中 + if (data != null) { + jsonObject.put("data", data); + } + // 将 JSON 对象转换为字符串并返回 + return jsonObject.toString(); + } + + /** + * 对输入的字符串进行 MD5 加密。 + * + * @param plainText 待加密的明文字符串 + * @return 加密后的 32 位 MD5 字符串 + */ + public static String stringToMD5(String plainText) { + byte[] secretBytes = null; + try { + // 获取 MD5 算法的 MessageDigest 实例 + MessageDigest md = MessageDigest.getInstance("md5"); + // 对输入字符串的字节数组进行加密处理 + secretBytes = md.digest(plainText.getBytes()); + } catch (NoSuchAlgorithmException e) { + // 若指定的 MD5 算法不存在，抛出运行时异常 + throw new RuntimeException("没有这个md5算法！"); + } + // 将加密后的字节数组转换为 16 进制字符串 + String md5code = new BigInteger(1, secretBytes).toString(16); + // 补齐到 32 位 + for (int i = 0; i < 32 - md5code.length(); i++) { + md5code = "0" + md5code; + } + return md5code; + } + + /** + * 对密码进行加盐后的 MD5 加密。 + * + * @param password 原始密码 + * @return 加盐加密后的 MD5 字符串 + */ + public static String passMd5(String password) { + // 定义盐值 + String salt = "ew!.E"; + // 将密码和盐值拼接后进行 MD5 加密并返回结果 + return Util.stringToMD5(password + salt); + } + + /** + * 主方法，用于测试 passMd5 方法。 + * + * @param args 命令行参数 + */ + public static void main(String[] args) { + // 打印对 "admin" 密码加盐加密后的 MD5 结果 + System.out.println(Util.passMd5("admin")); + // 以下代码为注释掉的测试获取当前时间功能的代码 + // Date date = new Date(); + // SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); + // System.out.println(dateFormat.format(date)); + } + } + /*! + * classie - class helper functions + * from bonzo https://github.com/ded/bonzo + * + * classie.has( elem, 'my-class' ) -> true/false + * classie.add( elem, 'my-new-class' ) + * classie.remove( elem, 'my-unwanted-class' ) + * classie.toggle( elem, 'my-class' ) + */ + + /*jshint browser: true, strict: true, undef: true */ + /*global define: false */ + + // 立即执行函数表达式 (IIFE)，将 window 对象作为参数传入，避免全局作用域污染 + ( function( window ) { + + // 使用严格模式，开启更严格的语法检查 + 'use strict'; + + // 从 bonzo 库借鉴的类操作辅助函数 + // 该函数用于生成一个正则表达式，用于匹配元素类名中的指定类名 + function classReg( className ) { + // 正则表达式解释： + // (^|\\s+) 匹配字符串的开头或者一个或多个空白字符 + // className 是要匹配的类名 + // (\\s+|$) 匹配一个或多个空白字符或者字符串的结尾 + return new RegExp("(^|\\s+)" + className + "(\\s+|$)"); + } + + // 用于管理元素类名的函数声明 + // 这些函数将根据浏览器是否支持 classList 属性来实现不同的逻辑 + var hasClass, addClass, removeClass; + + // 检查浏览器是否支持 classList 属性 + if ( 'classList' in document.documentElement ) { + // 如果支持 classList 属性 + // hasClass 函数用于检查元素是否包含指定的类名 + hasClass = function( elem, c ) { + // 使用 classList 的 contains 方法检查元素是否包含指定类名 + return elem.classList.contains( c ); + }; + // addClass 函数用于给元素添加指定的类名 + addClass = function( elem, c ) { + // 使用 classList 的 add 方法添加指定类名 + elem.classList.add( c ); + }; + // removeClass 函数用于从元素中移除指定的类名 + removeClass = function( elem, c ) { + // 使用 classList 的 remove 方法移除指定类名 + elem.classList.remove( c ); + }; + } + else { + // 如果浏览器不支持 classList 属性 + // hasClass 函数使用正则表达式来检查元素是否包含指定的类名 + hasClass = function( elem, c ) { + // 使用 classReg 函数生成的正则表达式来测试元素的 className 属性 + return classReg( c ).test( elem.className ); + }; + // addClass 函数用于给元素添加指定的类名 + addClass = function( elem, c ) { + // 先检查元素是否已经包含指定的类名 + if ( !hasClass( elem, c ) ) { + // 如果不包含，则在元素的 className 属性后面添加该类名 + elem.className = elem.className + ' ' + c; + } + }; + // removeClass 函数用于从元素中移除指定的类名 + removeClass = function( elem, c ) { + // 使用 classReg 函数生成的正则表达式来替换元素 className 属性中的指定类名 + elem.className = elem.className.replace( classReg( c ), ' ' ); + }; + } + + // toggleClass 函数用于切换元素的指定类名 + function toggleClass( elem, c ) { + // 根据元素是否包含指定类名来选择调用 removeClass 或 addClass 函数 + var fn = hasClass( elem, c ) ? removeClass : addClass; + // 调用选择的函数来切换类名 + fn( elem, c ); + } + + // 创建一个 classie 对象，包含所有的类操作函数 + var classie = { + // 完整的函数名 + hasClass: hasClass, + addClass: addClass, + removeClass: removeClass, + toggleClass: toggleClass, + // 简短的函数名，方便使用 + has: hasClass, + add: addClass, + remove: removeClass, + toggle: toggleClass + }; + + // 模块加载机制的处理 + if ( typeof define === 'function' && define.amd ) { + // 如果使用 AMD 模块加载器（如 RequireJS），则使用 define 函数定义模块 + define( classie ); + } else { + // 如果没有使用 AMD 模块加载器，则将 classie 对象添加到 window 对象上，作为全局变量使用 + window.classie = classie; + } + + })( window ); + /*! + * css-filters-polyfill.js + * + * Author: Christian Schepp Schaefer + * Summary: A polyfill for CSS filter effects + * License: MIT + * Version: 0.22 + * + * URL: + * https://github.com/Schepp/ + * + */ + // 立即执行函数表达式，将 window 对象作为参数传入，避免全局变量污染 + ;(function(window){ + // 创建一个名为 polyfilter 的对象，用于封装所有与 CSS 滤镜填充相关的功能和属性 + var polyfilter = { + // Detect if we are dealing with IE <= 9 + // http://james.padolsey.com/javascript/detect-_ie-in-js-using-conditional-comments/ + // 检测当前浏览器是否为 IE 9 及以下版本 + _ie: (function(){ + var undef; + // 初始化版本号为 3 + var v = 3; + // 创建一个 div 元素 + var div = document.createElement('div'); + // 获取 div 元素内的所有 i 元素 + var all = div.getElementsByTagName('i'); + + // 通过条件注释来检测 IE 版本 + // 不断增加版本号 v，直到条件注释不满足（即当前 IE 版本不大于 v） + while( + // 设置 div 的 innerHTML 为条件注释 + div.innerHTML = '', + // 如果条件注释生效，会创建一个 i 元素，此时 all[0] 存在 + all[0] + ); + + // 如果 v 大于 4，说明检测到了 IE 版本，返回该版本号；否则返回 undefined + return v > 4 ? v : undef; + })(), + + // 用于缓存创建的 SVG 元素，避免重复创建 + _svg_cache: {}, + + // 创建 SVG 元素的辅助函数 + _create_svg_element: function(tagname,attributes){ + // SVG 的命名空间 + var xmlns = 'http://www.w3.org/2000/svg'; + // 使用 createElementNS 方法创建 SVG 元素 + var elem = document.createElementNS(xmlns,tagname); + // 遍历传入的属性对象 + for(var key in attributes){ + // 为 SVG 元素设置属性 + elem.setAttributeNS(null,key,attributes[key]); + } + + return elem; + }, + + // 创建完整 SVG 滤镜定义的函数 + _create_svg: function(id,filterelements){ + // SVG 的命名空间 + var xmlns = 'http://www.w3.org/2000/svg'; + // 创建一个 SVG 元素 + var svg = document.createElementNS(xmlns,'svg'); + // 设置 SVG 元素的宽度为 0 + svg.setAttributeNS(null,'width','0'); + // 设置 SVG 元素的高度为 0 + svg.setAttributeNS(null,'height','0'); + // 设置 SVG 元素的样式为绝对定位，避免影响页面布局 + svg.setAttributeNS(null,'style','position:absolute'); + + // 创建一个 filter 元素 + var svg_filter = document.createElementNS(xmlns,'filter'); + // 为 filter 元素设置 id + svg_filter.setAttributeNS(null,'id',id); + // 将 filter 元素添加到 SVG 元素中 + svg.appendChild(svg_filter); + + // 遍历传入的滤镜元素数组 + for(var i = 0; i < filterelements.length; i++){ + // 将每个滤镜元素添加到 filter 元素中 + svg_filter.appendChild(filterelements[i]); + } + + return svg; + }, + + // 记录待处理的外部样式表数量 + _pending_stylesheets: 0, + + // 存储所有样式表（内联和外部）的信息 + _stylesheets: [], + + // 判断是否处于开发模式 + _development_mode: (function(){ + // 检查当前页面的主机名是否为 localhost 或者以 .local 结尾，或者是 IP 地址 + if(location.hostname === 'localhost' || location.hostname.search(/.local$/) !== -1 || location.hostname.search(/\d+\.\d+\.\d+\.\d+/) !== -1){ + // 如果处于开发模式，在控制台输出提示信息 + if(window.console) console.log('Detected localhost or IP address. Assuming you are a developer. Caching of stylesheets is disabled.'); + return true; + } + // 如果不是开发模式，在控制台输出提示信息 + if(window.console) console.log('Caching of stylesheets is enabled. You need to refresh twice to see any changes.'); + return false; + })(), + + // 处理页面上所有样式表的函数 + process_stylesheets: function(){ + var xmlHttp = []; + + // 延迟 2 秒后检查库文件路径是否正确，避免干扰初始处理 + window.setTimeout(function(){ + var xmlHttpCheck; + // 根据浏览器支持情况创建 XMLHttpRequest 对象 + if (window.XMLHttpRequest) { + xmlHttpCheck = new XMLHttpRequest(); + } else if (window.ActiveXObject) { + xmlHttpCheck = new ActiveXObject("Microsoft.XMLHTTP"); + } + // 打开一个 GET 请求，检查 sepia.htc 文件是否存在 + xmlHttpCheck.open('GET', window.polyfilter_scriptpath + 'htc/sepia.htc', true); + // 监听请求状态变化 + xmlHttpCheck.onreadystatechange = function(){ + // 当请求完成且状态码不是 200 时，说明路径可能有误 + if(xmlHttpCheck.readyState == 4 && xmlHttpCheck.status != 200){ + // 弹出提示框，提示用户配置正确的绝对路径 + alert('The configured path \r\rvar polyfilter_scriptpath = "' + window.polyfilter_scriptpath + '"\r\rseems wrong!\r\rConfigure the polyfill\'s correct absolute(!) script path before referencing the css-filters-polyfill.js, like so:\r\rvar polyfilter_scriptpath = "/js/css-filters-polyfill/";\r\rLeaving IE dead in the water is no option. You damn Mac user... ;)'); + } + }; + try{ + // 发送请求 + xmlHttpCheck.send(null); + } catch(e){} + },2000); + + // 获取页面上所有的样式表元素 + var stylesheets = document.querySelectorAll ? document.querySelectorAll('style,link[rel="stylesheet"]') : document.getElementsByTagName('*'); + + // 遍历所有样式表元素 + for(var i = 0; i < stylesheets.length; i++){ + // 使用立即执行函数避免闭包问题 + (function(i){ + // 根据元素的节点名进行不同处理 + switch(stylesheets[i].nodeName){ + default: + // 如果节点名不是 STYLE 或 LINK，不做处理，直接跳出 + break; + + case 'STYLE': + // 当节点名是 STYLE 时，说明是内联样式表 + polyfilter._stylesheets.push({ + // 获取样式表的媒体查询属性，如果没有则默认为 'all' + media: stylesheets[i].media || 'all', + // 获取样式表的内容 + content: stylesheets[i].innerHTML + }); + break; + + case 'LINK': + // 当节点名是 LINK 时 + if(stylesheets[i].rel === 'stylesheet'){ + // 且该 LINK 元素的 rel 属性为 'stylesheet'，说明是外部样式表 + var index = polyfilter._stylesheets.length; + + // 将该外部样式表的信息添加到 _stylesheets 数组中 + polyfilter._stylesheets.push({ + // 获取样式表的媒体查询属性，如果没有则默认为 'all' + media: stylesheets[i].media || 'all' + }); + + // 待处理的外部样式表数量加 1 + polyfilter._pending_stylesheets++; + + // 获取外部样式表的链接地址 + var href = stylesheets[i].href; + + // 如果不是开发模式，且浏览器支持 localStorage，并且 localStorage 中已经缓存了该样式表 + if(!polyfilter._development_mode && window.localStorage && window.localStorage.getItem('polyfilter_' + href)){ + // 待处理的外部样式表数量减 1 + polyfilter._pending_stylesheets--; + // 从 localStorage 中获取缓存的样式表内容，并赋值给 _stylesheets 数组中对应的元素 + polyfilter._stylesheets[index].content = localStorage.getItem('polyfilter_' + href); + // 如果所有待处理的外部样式表都已处理完毕 + if(polyfilter._pending_stylesheets === 0){ + // 调用 process 方法进行后续处理 + polyfilter.process(); + } + } + + // 无论是否有缓存，都要发起请求获取最新的样式表内容 + try{ + // 根据浏览器支持情况创建 XMLHttpRequest 对象 + if(window.XMLHttpRequest) { + var xmlHttp = new XMLHttpRequest(); + } else if(window.ActiveXObject) { + var xmlHttp = new ActiveXObject("Microsoft.XMLHTTP"); + } + // 打开一个 GET 请求，请求外部样式表 + xmlHttp.open('GET', href, true); + // 监听请求状态变化 + xmlHttp.onreadystatechange = function(){ + // 当请求完成时 + if(xmlHttp.readyState === 4){ + // 如果状态码为 0，可能是跨域问题导致请求失败 + if(xmlHttp.status === 0){ + if(window.console) console.log('Could not fetch external CSS via HTTP-Request ' + href + '. Probably because of cross origin.'); + // 如果 _stylesheets 数组中对应的元素还没有内容 + if(!polyfilter._stylesheets[index].content){ + // 待处理的外部样式表数量减 1 + polyfilter._pending_stylesheets--; + // 将响应内容赋值给 _stylesheets 数组中对应的元素 + polyfilter._stylesheets[index].content = xmlHttp.responseText; + // 如果所有待处理的外部样式表都已处理完毕 + if(polyfilter._pending_stylesheets === 0){ + // 调用 process 方法进行后续处理 + polyfilter.process(); + } + } + } else { + // 如果状态码正常 + if(!polyfilter._stylesheets[index].content){ + // 待处理的外部样式表数量减 1 + polyfilter._pending_stylesheets--; + // 将响应内容赋值给 _stylesheets 数组中对应的元素 + polyfilter._stylesheets[index].content = xmlHttp.responseText; + // 如果所有待处理的外部样式表都已处理完毕 + if(polyfilter._pending_stylesheets === 0){ + // 调用 process 方法进行后续处理 + polyfilter.process(); + } + } + // 如果不是开发模式，且浏览器支持 localStorage + if(!polyfilter._development_mode && window.localStorage){ + try{ + // 将样式表内容缓存到 localStorage 中 + window.localStorage.setItem('polyfilter_' + href, polyfilter._stylesheets[index].content); + } + catch(e){ + // 如果 localStorage 空间不足，输出提示信息 + if(window.console) console.log('Local storage quota have been exceeded. Caching of stylesheet ' + href + ' is not possible'); + } + } + } + } + }; + try{ + // 发送请求 + xmlHttp.send(null); + } catch(e){ + // 如果请求发送失败，可能是使用 file:// 协议进行测试导致的 + if(window.console) console.log('Could not fetch external CSS via HTTP-Request ' + href + '. Are you maybe testing using the file://-protocol?'); + if(!polyfilter._stylesheets[index].content){ + // 待处理的外部样式表数量减 1 + polyfilter._pending_stylesheets--; + if(polyfilter._pending_stylesheets === 0){ + // 调用 process 方法进行后续处理 + polyfilter.process(); + } + } + } + } catch(e){} + } + break; + } + })(i); + } + // 如果所有待处理的外部样式表都已处理完毕 + if(this._pending_stylesheets === 0){ + // 调用 process 方法进行后续处理 + this.process(); + } + }, + + // 处理 CSS 规则声明的函数 + _processDeclarations: function(rule){ + var newstyles = ''; + // 遍历规则中的所有声明 + for(var k in rule.declarations){ + var declaration = rule.declarations[k]; + + // 如果声明的属性是 'filter' + if(declaration.property === 'filter'){ + if(document.querySelectorAll){ + // 检查浏览器是否支持 document.querySelectorAll 方法 + // 使用选择器 rule.mSelectorText 获取匹配的元素集合 + var elems = document.querySelectorAll(rule.mSelectorText); + for(var k = 0; k < elems.length; k++){ + // 遍历匹配的元素集合，将当前 filter 声明的值存储到元素的 style.polyfilterStore 属性中 + // 方便后续可能的使用 + elems[k].style.polyfilterStore = declaration.valueText; + } + } + + // 获取 filter 属性声明的原始值 + var gluedvalues = declaration.valueText; + // 将原始值按 ")" 后面跟着一个或多个空白字符进行分割，得到每个单独的滤镜值 + var values = gluedvalues.split(/\)\s+/), + // 初始化一个对象，用于存储不同浏览器支持的滤镜属性值 + properties = { + filtersW3C: [], // 存储 W3C 标准的滤镜属性值 + filtersWebKit: [], // 存储 WebKit 内核浏览器（如 Safari、旧版 Chrome）的滤镜属性值 + filtersSVG: [], // 存储 SVG 滤镜属性值 + filtersIE: [], // 存储 Internet Explorer 浏览器的滤镜属性值 + behaviorsIE: [] // 存储 Internet Explorer 浏览器的行为属性值（用于模拟滤镜效果） + }; + + // 遍历分割后的每个滤镜值 + for(var idx in values){ + var value = values[idx] + ')'; // 恢复完整的滤镜值 + + // 调用 polyfilter 对象的 convert 方法，将单个滤镜值转换为不同浏览器支持的属性值 + var currentproperties = polyfilter.convert(value); + + // 遍历转换后的属性值对象 + for(var key in currentproperties){ + if(typeof properties[key] !== 'undefined'){ + // 如果当前属性在 properties 对象中存在，则将转换后的属性值追加到对应数组中 + properties[key] = properties[key].concat(currentproperties[key]); + } + } + } + + // 开始构建新的样式规则字符串，添加选择器和左花括号 + newstyles += rule.mSelectorText + '{'; + if(properties['filtersW3C'].length > 0){ + // 如果存在 W3C 标准的滤镜属性值 + var filter = + webkitFilter = + mozFilter = + oFilter = + msFilter = + properties['filtersW3C'].join(' '); // 将 W3C 标准的滤镜属性值用空格连接成一个字符串 + + if(properties['filtersWebKit'] && properties['filtersWebKit'].length > 0){ + // 如果存在 WebKit 内核浏览器的滤镜属性值，则使用这些值替换 webkitFilter + webkitFilter = properties['filtersWebKit'].join(' '); + } + + if(typeof this._ie === 'undefined'){ + // 如果不是 Internet Explorer 浏览器，则添加 -ms-filter 属性 + newstyles += '-ms-filter:' + msFilter + ';'; + } + + // 添加不同浏览器前缀的 filter 属性 + newstyles += '-webkit-filter:' + webkitFilter + ';'; + newstyles += '-moz-filter:' + mozFilter + ';'; + newstyles += '-o-filter:' + oFilter + ';'; + } + if(properties['filtersSVG'].length > 0){ + if(properties['filtersSVG'][0] != 'none'){ + // 如果 SVG 滤镜属性值不为 'none' + // 生成一个唯一的 ID，用于标识 SVG 滤镜 + var id = gluedvalues.replace(/[^a-z0-9]/g,''); + + if(typeof this._svg_cache[id] === 'undefined'){ + // 如果 SVG 滤镜缓存中不存在该 ID 对应的 SVG 元素 + // 创建一个新的 SVG 元素，并将其存储到缓存中 + this._svg_cache[id] = this._create_svg(id,properties['filtersSVG']); + + if(typeof XMLSerializer === 'undefined'){ + // 如果浏览器不支持 XMLSerializer，则直接将 SVG 元素添加到 body 中 + document.body.appendChild(this._svg_cache[id]); + } + else { + // 如果浏览器支持 XMLSerializer + var s = new XMLSerializer(); + // 将 SVG 元素序列化为字符串 + var svgString = s.serializeToString(this._svg_cache[id]); + if(svgString.search('SourceGraphic') != -1){ + // 如果 SVG 字符串中包含 'SourceGraphic'，则将 SVG 元素添加到 body 中 + document.body.appendChild(this._svg_cache[id]); + } + } + } + + if(typeof XMLSerializer === 'undefined'){ + // 如果浏览器不支持 XMLSerializer，则使用 url(#id) 形式引用 SVG 滤镜 + newstyles += 'filter: url(#' + id + ')'; + } + else { + var s = new XMLSerializer(); + // 将 SVG 元素序列化为字符串 + var svgString = s.serializeToString(this._svg_cache[id]); + + if(svgString.search('SourceGraphic') != -1){ + // 如果 SVG 字符串中包含 'SourceGraphic'，则使用 url(#id) 形式引用 SVG 滤镜 + newstyles += 'filter: url(#' + id + ')'; + } + else { + // 否则，使用 data URI 形式引用 SVG 滤镜 + newstyles += 'filter: url(\'data:image/svg+xml;utf8,' + svgString + '#' + id + '\')'; + } + } + } + else { + // 如果 SVG 滤镜属性值为 'none'，则添加 filter: none; + newstyles += 'filter: none;'; + } + } + if(typeof this._ie !== 'undefined'){ + // 如果是 Internet Explorer 浏览器 + if(properties['filtersIE'].length > 0){ + // 如果存在 Internet Explorer 浏览器的滤镜属性值 + var filtersIE = properties['filtersIE'].join(' '); + // 添加 filter 属性 + newstyles += 'filter:' + filtersIE + ';'; + } + if(properties['behaviorsIE'].length > 0){ + // 如果存在 Internet Explorer 浏览器的行为属性值 + var behaviorsIE = properties['behaviorsIE'].join(' '); + // 添加 behavior 属性 + newstyles += 'behavior:' + behaviorsIE + ';'; + } + } + // 完成当前选择器样式规则的构建，添加右花括号和换行符 + newstyles += '}\r\n'; + } + } + // 返回新生成的样式规则字符串 + return newstyles; + }, + + // 存储 .htc 文件的绝对路径 + scriptpath: window.polyfilter_scriptpath ? window.polyfilter_scriptpath : (function(){ + // 如果没有在 window 对象中配置 polyfilter_scriptpath + // 弹出提示框，提醒用户在引用 css - filters - polyfill.js 之前配置正确的绝对路径 + alert('Please configure the polyfill\'s absolute(!) script path before referencing the css-filters-polyfill.js, like so:\r\nvar polyfilter_scriptpath = "/js/css-filters-polyfill/";'); + // 默认返回当前目录 + return './' + })(), + + // 处理样式表的主函数 + process: function(){ + // 创建一个 CSS 解析器实例 + var parser = new CSSParser(); + + // 遍历存储的所有样式表 + for(var i = 0; i < this._stylesheets.length; i++){ + // 初始化新样式字符串 + var newstyles = ''; + // 使用解析器解析当前样式表的内容 + var sheet = parser.parse(this._stylesheets[i].content, false, true); + // 如果解析结果不为空 + if(sheet !== null) for(var j in sheet.cssRules){ + var rule = sheet.cssRules[j]; + + // 根据规则类型进行不同处理 + switch(rule.type){ + default: + // 默认情况不做处理 + break; + + case 1: + // 类型 1 通常表示普通的样式规则 + // 调用 _processDeclarations 方法处理该规则，并将结果添加到新样式字符串中 + newstyles += this._processDeclarations(rule); + break; + + case 4: + // 类型 4 通常表示 @media 媒体查询规则 + // 构建媒体查询的开头部分 + newstyles += '@media ' + rule.media.join(',') + '{'; + // 遍历媒体查询内的子规则 + for(var k in rule.cssRules){ + var mediarule = rule.cssRules[k]; + // 调用 _processDeclarations 方法处理子规则，并将结果添加到新样式字符串中 + newstyles += this._processDeclarations(mediarule); + } + // 构建媒体查询的结尾部分 + newstyles += '}'; + break; + } + } + // 创建一个新的