Java图书管理系统实战：从JDBC到Swing的完整开发指南

1. 项目概述与核心价值

最近在整理过去的项目代码，翻到了这个基于Java和MySQL的图书管理系统。这几乎是每个Java开发者入门企业级应用开发的“必修课”，也是面试官最喜欢问的课程设计或毕业设计项目之一。它麻雀虽小，五脏俱全，涵盖了从数据库设计、后端业务逻辑、到简单前端交互的完整流程。今天，我就把这个项目的完整实现代码和背后的设计思路，结合我踩过的坑和积累的经验，系统地分享出来。无论你是正在做课程设计的学生，还是希望巩固Java SE和JDBC基础的开发者，这篇文章都能给你提供一个清晰、可运行、可直接复现的参考模板。

这个系统本质上是一个典型的CRUD（增删改查）应用，核心功能围绕图书和借阅者的信息管理展开。它需要连接MySQL数据库进行持久化存储，通过Java Swing或JavaFX构建图形用户界面，并使用JDBC作为数据库连接的桥梁。在实现过程中，你会深刻理解到分层架构的思想（尽管在小型项目中可能不那么严格）、SQL语句的编写、事务处理、以及如何让代码更健壮。接下来，我将从设计思路开始，一步步拆解这个系统的构建过程。

2. 系统整体设计与架构拆解

2.1 需求分析与功能模块定义

在动手写代码之前，明确需求是关键。一个基础的图书管理系统通常需要管理两类核心实体：图书和借阅者（或用户），以及它们之间产生的借阅行为。基于此，我们可以梳理出以下核心功能模块：

1. 图书信息管理：包括图书的录入（ISBN、书名、作者、出版社、价格、库存数量等）、查询（支持按书名、作者等条件模糊查询）、修改（如图书信息更正）、删除（图书下架）。这里“删除”通常采用逻辑删除（标记为无效）而非物理删除，以保留历史记录。
2. 借阅者信息管理：管理借阅者的基本信息（卡号、姓名、联系方式等）的增删改查。
3. 借阅与归还管理：这是系统的业务核心。包括办理借书手续（检查图书库存、读者借阅数量上限、是否超期未还等）、办理还书手续（计算是否超期及滞纳金）、续借功能。
4. 数据统计与查询：如图书借阅排行榜、超期未还图书清单、借阅历史记录查询等。

注意：在实际课程设计中，功能可以酌情简化，但“借阅”和“归还”这个核心业务流程必须完整实现，它涉及多个数据库表的联动更新（如books表的库存、borrow_records表的新增记录），是理解数据库事务的绝佳场景。

2.2 技术栈选型与理由

为什么选择这个技术组合？每个选择背后都有其考量。

• Java SE：作为后端逻辑实现的语言，其面向对象特性非常适合对“图书”、“借阅记录”等实体进行建模。跨平台性也保证了项目可以在不同操作系统上运行。
• MySQL：轻量级、开源、免费的关系型数据库，是学习数据库操作的绝佳选择。其清晰的表结构设计能帮助我们理解实体关系映射（ORM的雏形）。
• JDBC：Java连接数据库的标准API。虽然现在流行MyBatis、JPA等框架，但直接从JDBC开始学习，能让你真正理解Java程序是如何与数据库“对话”的，包括连接池、SQL执行、结果集处理等底层机制，这对夯实基础至关重要。
• Swing / JavaFX：用于构建图形用户界面。Swing是Java传统的GUI工具包，资料丰富；JavaFX是现代选择，界面更美观。对于课程设计，Swing完全够用且更容易上手。本文将基于Swing进行演示。

2.3 数据库设计：表结构规划

数据库设计是系统的基石。设计不当，后期编码会困难重重。我们至少需要三张核心表：

表1:books(图书表)

表2:readers(读者表)

表3:borrow_records(借阅记录表)

实操心得：books表中将total_quantity（总数量）和current_quantity（当前数量）分开是非常关键的设计。借书时current_quantity减1，还书时加1，而total_quantity不变。这样便于库存管理和统计。status字段用于逻辑删除，避免物理删除导致的历史记录断裂。

2.4 项目工程结构规划

一个清晰的项目结构能极大提升代码的可维护性。我们采用分层的思想来组织代码，尽管是小型项目，但养成好习惯很重要。

src/ ├── main/ │ ├── java/ │ │ ├── com/ │ │ │ └── library/ │ │ │ ├── model/ // 数据模型，对应数据库表的JavaBean │ │ │ │ ├── Book.java │ │ │ │ ├── Reader.java │ │ │ │ └── BorrowRecord.java │ │ │ ├── dao/ // 数据访问层，封装所有数据库操作 │ │ │ │ ├── BaseDao.java // 公共的数据库连接和关闭方法 │ │ │ │ ├── BookDao.java │ │ │ │ ├── ReaderDao.java │ │ │ │ └── BorrowRecordDao.java │ │ │ ├── service/ // 业务逻辑层，处理复杂业务规则 │ │ │ │ ├── BookService.java │ │ │ │ ├── ReaderService.java │ │ │ │ └── BorrowService.java // 核心：处理借还书逻辑 │ │ │ ├── util/ // 工具类 │ │ │ │ ├── DBUtil.java // 数据库连接工具（重点！） │ │ │ │ └── DateUtil.java │ │ │ └── view/ // 视图层，Swing界面 │ │ │ ├── MainFrame.java // 主窗口 │ │ │ ├── BookPanel.java // 图书管理面板 │ │ │ ├── ReaderPanel.java │ │ │ └── BorrowPanel.java │ │ └── resources/ // 资源文件 │ │ └── db.properties // 数据库配置文件 │ └── ... (其他目录) └── test/ // 测试代码（可选）

3. 核心模块代码实现详解

3.1 基石：数据库连接工具类 DBUtil

这是所有数据库操作的起点。一个健壮的DBUtil能避免连接泄漏，提升性能。我们使用Properties文件来配置数据库信息，实现解耦。

1. 配置文件db.properties

# 数据库连接配置 jdbc.driver=com.mysql.cj.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/library_db?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai jdbc.username=root jdbc.password=your_password

2. 工具类DBUtil.java

package com.library.util; import java.io.InputStream; import java.sql.*; import java.util.Properties; public class DBUtil { private static String driver; private static String url; private static String username; private static String password; // 静态代码块，在类加载时读取配置 static { try { InputStream is = DBUtil.class.getClassLoader().getResourceAsStream("db.properties"); Properties props = new Properties(); props.load(is); driver = props.getProperty("jdbc.driver"); url = props.getProperty("jdbc.url"); username = props.getProperty("jdbc.username"); password = props.getProperty("jdbc.password"); Class.forName(driver); // 注册驱动 } catch (Exception e) { e.printStackTrace(); throw new RuntimeException("数据库配置初始化失败！", e); } } // 获取数据库连接 public static Connection getConnection() throws SQLException { return DriverManager.getConnection(url, username, password); } // 关闭资源，重载方法以应对不同情况 public static void close(Connection conn, Statement stmt, ResultSet rs) { try { if (rs != null) rs.close(); } catch (SQLException e) { e.printStackTrace(); } try { if (stmt != null) stmt.close(); } catch (SQLException e) { e.printStackTrace(); } try { if (conn != null) conn.close(); } catch (SQLException e) { e.printStackTrace(); } } public static void close(Connection conn, Statement stmt) { close(conn, stmt, null); } }

注意事项：

1. MySQL 8.0+驱动：务必使用com.mysql.cj.jdbc.Driver，旧版com.mysql.jdbc.Driver已被弃用。
2. 连接参数：serverTimezone=Asia/Shanghai是解决时区问题的关键，否则可能报错。useSSL=false在本地开发环境通常关闭。
3. 资源关闭：务必在finally块或使用try-with-resources语句关闭Connection、Statement、ResultSet，否则会导致连接泄漏，数据库连接池耗尽。
4. 生产环境考虑：这个简单工具类每次操作都新建连接，实际项目中应使用数据库连接池（如HikariCP）来管理连接，大幅提升性能。

3.2 数据模型层：实体类编写

实体类是数据库表在Java中的映射，通常是一个简单的JavaBean（POJO）。

Book.java示例

package com.library.model; import java.math.BigDecimal; public class Book { private Integer id; private String isbn; private String title; private String author; private String publisher; private BigDecimal price; // 使用BigDecimal处理金额，避免精度丢失 private Integer totalQuantity; private Integer currentQuantity; private Integer status; // 1-可用， 0-下架 // 无参构造器、全参构造器、getter和setter方法 // 这里省略，可以使用IDE（如IntelliJ IDEA）的Generate功能快速生成 // 务必重写toString()方法，便于调试打印 @Override public String toString() { return "Book{" + "id=" + id + ", title='" + title + '\'' + ", author='" + author + '\'' + ", currentQuantity=" + currentQuantity + '}'; } }

实操心得：对于价格、金额等字段，强烈建议使用BigDecimal而不是double或float，因为后者在进行浮点数计算时会有精度损失问题，这在金融或计费场景是致命的。BigDecimal提供了精确的算术运算。

3.3 数据访问层：DAO模式实现

DAO（Data Access Object）模式将数据库操作封装起来，业务层无需关心SQL细节。我们先写一个BaseDao提供公共方法。

BaseDao.java(简化版，聚焦查询和更新)

package com.library.dao; import com.library.util.DBUtil; import java.lang.reflect.Field; import java.sql.*; import java.util.ArrayList; import java.util.List; public class BaseDao { // 通用的增删改操作 (Insert, Update, Delete) public int executeUpdate(String sql, Object... params) { Connection conn = null; PreparedStatement pstmt = null; try { conn = DBUtil.getConnection(); pstmt = conn.prepareStatement(sql); // 设置参数 for (int i = 0; i < params.length; i++) { pstmt.setObject(i + 1, params[i]); } return pstmt.executeUpdate(); } catch (SQLException e) { e.printStackTrace(); return -1; } finally { DBUtil.close(conn, pstmt); } } // 通用的查询多个对象 (例如：SELECT * FROM books) public <T> List<T> executeQuery(Class<T> clazz, String sql, Object... params) { List<T> list = new ArrayList<>(); Connection conn = null; PreparedStatement pstmt = null; ResultSet rs = null; try { conn = DBUtil.getConnection(); pstmt = conn.prepareStatement(sql); for (int i = 0; i < params.length; i++) { pstmt.setObject(i + 1, params[i]); } rs = pstmt.executeQuery(); ResultSetMetaData metaData = rs.getMetaData(); int columnCount = metaData.getColumnCount(); while (rs.next()) { T obj = clazz.newInstance(); for (int i = 1; i <= columnCount; i++) { String columnName = metaData.getColumnLabel(i); // 获取列名/别名 Object columnValue = rs.getObject(i); // 使用反射将值设置到对象的对应属性中 Field field = clazz.getDeclaredField(columnName); field.setAccessible(true); // 允许访问私有属性 field.set(obj, columnValue); } list.add(obj); } } catch (Exception e) { e.printStackTrace(); } finally { DBUtil.close(conn, pstmt, rs); } return list; } // 通用的查询单个对象 (例如：SELECT * FROM books WHERE id = ?) public <T> T executeQueryForOne(Class<T> clazz, String sql, Object... params) { List<T> list = executeQuery(clazz, sql, params); if (list != null && list.size() > 0) { return list.get(0); } return null; } }

BookDao.java(继承BaseDao，实现具体操作)

package com.library.dao; import com.library.model.Book; import java.util.List; public class BookDao extends BaseDao { // 新增图书 public int addBook(Book book) { String sql = "INSERT INTO books (isbn, title, author, publisher, price, total_quantity, current_quantity, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"; return executeUpdate(sql, book.getIsbn(), book.getTitle(), book.getAuthor(), book.getPublisher(), book.getPrice(), book.getTotalQuantity(), book.getCurrentQuantity(), book.getStatus()); } // 根据ID删除图书（逻辑删除，更新状态） public int deleteBookById(Integer id) { String sql = "UPDATE books SET status = 0 WHERE id = ?"; return executeUpdate(sql, id); } // 更新图书信息 public int updateBook(Book book) { String sql = "UPDATE books SET title=?, author=?, publisher=?, price=?, total_quantity=?, current_quantity=? WHERE id=?"; return executeUpdate(sql, book.getTitle(), book.getAuthor(), book.getPublisher(), book.getPrice(), book.getTotalQuantity(), book.getCurrentQuantity(), book.getId()); } // 根据ID查询图书 public Book getBookById(Integer id) { String sql = "SELECT * FROM books WHERE id = ? AND status = 1"; return executeQueryForOne(Book.class, sql, id); } // 根据书名模糊查询 public List<Book> getBooksByTitle(String keyword) { String sql = "SELECT * FROM books WHERE title LIKE ? AND status = 1"; return executeQuery(Book.class, sql, "%" + keyword + "%"); } // 查询所有可借图书 public List<Book> getAllAvailableBooks() { String sql = "SELECT * FROM books WHERE status = 1 AND current_quantity > 0"; return executeQuery(Book.class, sql); } }

踩坑记录：

1. SQL注入：BaseDao中全部使用PreparedStatement而不是Statement，通过setObject方法设置参数，这是防止SQL注入攻击的最基本、最有效的手段。绝对不要用字符串拼接的方式来构造SQL。
2. 反射性能：BaseDao中的通用查询使用了反射，这在小型项目和学习中没问题，但反射有一定性能开销。在生产环境或大型项目中，更推荐使用专门的ORM框架（如MyBatis）或手动编写每一行的结果集映射代码。
3. 异常处理：示例中简单打印了异常栈，实际项目中应该根据业务需要，将检查异常转换为运行时异常，或者记录日志后向上抛出，由统一的地方处理。

3.4 业务逻辑层：Service层封装

Service层负责协调多个DAO操作，实现复杂的业务规则。这是体现你业务理解能力的地方。

BorrowService.java(核心业务逻辑)

package com.library.service; import com.library.dao.BookDao; import com.library.dao.BorrowRecordDao; import com.library.dao.ReaderDao; import com.library.model.Book; import com.library.model.BorrowRecord; import com.library.model.Reader; import com.library.util.DBUtil; import java.sql.Connection; import java.sql.SQLException; import java.util.Date; public class BorrowService { private BookDao bookDao = new BookDao(); private ReaderDao readerDao = new ReaderDao(); private BorrowRecordDao borrowRecordDao = new BorrowRecordDao(); // 借书操作：涉及多个表的更新，必须使用事务！ public boolean borrowBook(Integer bookId, Integer readerId, Date dueDate) { Connection conn = null; try { conn = DBUtil.getConnection(); conn.setAutoCommit(false); // 开启事务 // 1. 检查图书是否存在且可借 Book book = bookDao.getBookById(bookId); if (book == null || book.getCurrentQuantity() <= 0) { throw new RuntimeException("图书不存在或库存不足"); } // 2. 检查读者是否存在且未超借阅上限 Reader reader = readerDao.getReaderById(readerId); if (reader == null) { throw new RuntimeException("读者不存在"); } int currentBorrowed = borrowRecordDao.countBorrowingRecords(readerId); if (currentBorrowed >= reader.getMaxBorrowLimit()) { throw new RuntimeException("该读者借阅数量已达上限"); } // 3. 检查读者是否有超期未还图书（简化逻辑，实际可能更复杂） boolean hasOverdue = borrowRecordDao.hasOverdueRecord(readerId); if (hasOverdue) { throw new RuntimeException("该读者有超期未还图书，无法借阅新书"); } // 4. 减少图书当前库存 book.setCurrentQuantity(book.getCurrentQuantity() - 1); int updateResult = bookDao.updateBook(book); if (updateResult <= 0) { throw new RuntimeException("更新图书库存失败"); } // 5. 创建借阅记录 BorrowRecord record = new BorrowRecord(); record.setBookId(bookId); record.setReaderId(readerId); record.setBorrowDate(new Date()); record.setDueDate(dueDate); // return_date 和 overdue_fine 默认为null和0 int insertResult = borrowRecordDao.addRecord(record); if (insertResult <= 0) { throw new RuntimeException("创建借阅记录失败"); } conn.commit(); // 所有操作成功，提交事务 return true; } catch (Exception e) { e.printStackTrace(); if (conn != null) { try { conn.rollback(); // 任何一步失败，回滚事务 } catch (SQLException ex) { ex.printStackTrace(); } } return false; } finally { if (conn != null) { try { conn.setAutoCommit(true); // 恢复自动提交模式 conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } } // 还书操作 public boolean returnBook(Integer recordId) { // 逻辑类似：1. 查找借阅记录 2. 计算是否超期及滞纳金 3. 更新记录（设置归还日期和滞纳金）4. 增加图书库存 // 同样需要使用事务保证“更新记录”和“增加库存”的原子性 // 代码略，结构与borrowBook类似 return false; } }

核心要点解析：

1. 事务（Transaction）：借书和还书是典型的需要事务管理的操作。它们涉及对books表和borrow_records表的同时更新，必须保证要么全部成功，要么全部失败。通过conn.setAutoCommit(false)、conn.commit()和conn.rollback()手动控制事务。
2. 业务规则校验：在真正执行更新前，进行了多层校验（图书状态、读者状态、借阅上限、超期检查）。这些校验是业务逻辑的核心，应该在Service层完成，DAO层只负责最纯粹的数据访问。
3. 异常处理：事务中任何一步失败，都应抛出异常，在catch块中进行回滚，确保数据一致性。

4. 图形界面实现与事件处理

4.1 主界面框架搭建

使用Swing的JFrame作为主窗口，采用JTabbedPane来组织不同的功能模块面板。

MainFrame.java

package com.library.view; import javax.swing.*; import java.awt.*; public class MainFrame extends JFrame { public MainFrame() { setTitle("图书管理系统 v1.0"); setSize(1000, 700); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setLocationRelativeTo(null); // 窗口居中 // 创建选项卡面板 JTabbedPane tabbedPane = new JTabbedPane(); tabbedPane.addTab("图书管理", new BookPanel()); tabbedPane.addTab("读者管理", new ReaderPanel()); tabbedPane.addTab("借阅/归还", new BorrowPanel()); tabbedPane.addTab("数据统计", new StatisticsPanel()); // 假设有统计面板 add(tabbedPane, BorderLayout.CENTER); // 添加菜单栏（可选） JMenuBar menuBar = new JMenuBar(); JMenu systemMenu = new JMenu("系统"); JMenuItem exitItem = new JMenuItem("退出"); exitItem.addActionListener(e -> System.exit(0)); systemMenu.add(exitItem); menuBar.add(systemMenu); setJMenuBar(menuBar); } public static void main(String[] args) { // 使用SwingUtilities确保GUI创建是线程安全的 SwingUtilities.invokeLater(() -> { MainFrame frame = new MainFrame(); frame.setVisible(true); }); } }

4.2 图书管理面板实现示例

以图书管理面板为例，展示如何将Swing组件与后台Service结合。

BookPanel.java(核心部分)

package com.library.view; import com.library.model.Book; import com.library.service.BookService; import javax.swing.*; import javax.swing.table.DefaultTableModel; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.math.BigDecimal; import java.util.List; public class BookPanel extends JPanel { private BookService bookService = new BookService(); private JTable bookTable; private DefaultTableModel tableModel; private JTextField searchField; public BookPanel() { setLayout(new BorderLayout()); // 1. 顶部：搜索和操作按钮区域 JPanel topPanel = new JPanel(new FlowLayout(FlowLayout.LEFT)); searchField = new JTextField(20); JButton searchBtn = new JButton("搜索"); JButton addBtn = new JButton("新增"); JButton editBtn = new JButton("修改"); JButton deleteBtn = new JButton("删除"); topPanel.add(new JLabel("书名:")); topPanel.add(searchField); topPanel.add(searchBtn); topPanel.add(Box.createHorizontalStrut(20)); // 添加间距 topPanel.add(addBtn); topPanel.add(editBtn); topPanel.add(deleteBtn); // 2. 中部：图书列表（使用JTable） String[] columnNames = {"ID", "ISBN", "书名", "作者", "出版社", "价格", "总数量", "可借数量", "状态"}; tableModel = new DefaultTableModel(columnNames, 0) { @Override public boolean isCellEditable(int row, int column) { return false; // 表格不可直接编辑 } }; bookTable = new JTable(tableModel); JScrollPane scrollPane = new JScrollPane(bookTable); loadBookData(""); // 初始化加载所有数据 // 3. 底部：状态栏或留空 JPanel bottomPanel = new JPanel(); add(topPanel, BorderLayout.NORTH); add(scrollPane, BorderLayout.CENTER); add(bottomPanel, BorderLayout.SOUTH); // 4. 绑定按钮事件 searchBtn.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { String keyword = searchField.getText().trim(); loadBookData(keyword); } }); addBtn.addActionListener(e -> showAddBookDialog()); editBtn.addActionListener(e -> showEditBookDialog()); deleteBtn.addActionListener(e -> deleteSelectedBook()); } // 加载图书数据到表格 private void loadBookData(String keyword) { tableModel.setRowCount(0); // 清空旧数据 List<Book> books; if (keyword.isEmpty()) { books = bookService.getAllBooks(); // 假设Service有这个方法 } else { books = bookService.searchBooksByTitle(keyword); } for (Book book : books) { Object[] row = { book.getId(), book.getIsbn(), book.getTitle(), book.getAuthor(), book.getPublisher(), book.getPrice(), book.getTotalQuantity(), book.getCurrentQuantity(), book.getStatus() == 1 ? "可借" : "下架" }; tableModel.addRow(row); } } // 显示新增图书对话框 private void showAddBookDialog() { // 使用JDialog或JOptionPane创建一个表单对话框 // 包含ISBN、书名、作者、出版社、价格、总数量等输入框 // 收集用户输入，构造Book对象，调用bookService.addBook(book) // 操作成功后，刷新表格 loadBookData("") JDialog dialog = new JDialog((Frame) SwingUtilities.getWindowAncestor(this), "新增图书", true); dialog.setSize(400, 400); dialog.setLayout(new GridLayout(0, 2, 10, 10)); JTextField isbnField = new JTextField(); JTextField titleField = new JTextField(); // ... 其他字段 dialog.add(new JLabel("ISBN:")); dialog.add(isbnField); dialog.add(new JLabel("书名:")); dialog.add(titleField); // ... 添加其他组件 JButton submitBtn = new JButton("提交"); submitBtn.addActionListener(e -> { try { Book newBook = new Book(); newBook.setIsbn(isbnField.getText()); newBook.setTitle(titleField.getText()); newBook.setAuthor(authorField.getText()); newBook.setPublisher(publisherField.getText()); newBook.setPrice(new BigDecimal(priceField.getText())); newBook.setTotalQuantity(Integer.parseInt(quantityField.getText())); newBook.setCurrentQuantity(newBook.getTotalQuantity()); // 初始可借数等于总数 newBook.setStatus(1); boolean success = bookService.addBook(newBook); if (success) { JOptionPane.showMessageDialog(dialog, "新增成功！"); dialog.dispose(); loadBookData(""); // 刷新列表 } else { JOptionPane.showMessageDialog(dialog, "新增失败，请检查数据！", "错误", JOptionPane.ERROR_MESSAGE); } } catch (NumberFormatException ex) { JOptionPane.showMessageDialog(dialog, "请输入正确的数字格式！", "输入错误", JOptionPane.WARNING_MESSAGE); } catch (Exception ex) { JOptionPane.showMessageDialog(dialog, "发生错误：" + ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE); } }); dialog.add(new JLabel()); // 占位 dialog.add(submitBtn); dialog.setLocationRelativeTo(this); dialog.setVisible(true); } // showEditBookDialog 和 deleteSelectedBook 方法类似，需要先获取表格选中的行数据 }

界面开发心得：

1. 事件分发线程（EDT）：所有Swing组件的创建和更新都必须在事件分发线程中进行。SwingUtilities.invokeLater()是保证这一点的标准做法。
2. 模态对话框：新增、编辑等操作使用模态JDialog，可以阻塞父窗口的输入，直到对话框关闭，非常适合表单提交场景。
3. 数据绑定：示例中手动将List<Book>转换为Object[][]再加载到DefaultTableModel。对于更复杂的界面，可以考虑使用TableModel的自定义实现或第三方绑定库。
4. 输入验证：在submitBtn的事件处理中，对数字格式进行了验证（NumberFormatException）。在实际项目中，应在UI层进行更全面的验证（如非空、格式、范围），避免无效数据提交到Service层。

5. 项目部署、运行与常见问题排查

5.1 环境准备与项目运行步骤

1. 安装Java开发环境：确保已安装JDK 8或以上版本，并配置好JAVA_HOME环境变量。
2. 安装与配置MySQL：
   • 下载安装MySQL 8.0+。
   • 启动MySQL服务。
   • 使用命令行或MySQL Workbench连接，执行建库建表SQL脚本。

   CREATE DATABASE IF NOT EXISTS `library_db` DEFAULT CHARACTER SET utf8mb4; USE `library_db`; -- 依次执行前面“数据库设计”部分的建表语句

3. 导入项目与依赖：
   • 如果你使用IDE（如IntelliJ IDEA或Eclipse），创建一个新的Java项目。
   • 将上述代码按包结构放入src目录。
   • 将MySQL的JDBC驱动JAR包（如mysql-connector-java-8.0.33.jar）添加到项目的构建路径（Build Path）中。在IDEA中，可以将JAR包放入lib目录，然后右键选择“Add as Library”。
4. 修改数据库配置：编辑src/main/resources/db.properties文件，将jdbc.url中的localhost、3306、library_db以及username和password改为你自己的配置。
5. 运行程序：找到MainFrame类的main方法，运行即可启动图形界面。

5.2 常见问题与解决方案速查表

在开发和运行过程中，你几乎一定会遇到以下问题：

5.3 性能优化与扩展建议

当这个基础版本运行起来后，你可以从以下几个方向进行优化和扩展，这会让你的项目更接近企业级应用：

1. 引入数据库连接池：使用HikariCP或Druid等连接池替代DBUtil中的简单连接管理。这能显著提升数据库访问性能，特别是在并发场景下。只需修改DBUtil.getConnection()方法，从连接池获取连接即可。
2. 使用日志框架：用Log4j2或SLF4J+Logback替代System.out.println和e.printStackTrace()。可以灵活控制日志级别、输出格式和目的地（文件、控制台等）。
3. 升级数据访问层：用MyBatis或Spring Data JPA替换手写的JDBC和DAO。它们能极大简化数据库操作代码，提供强大的SQL映射和声明式事务管理。
4. 重构为MVC或三层架构：将当前Swing界面（View）与事件监听器（Controller）更清晰地分离。可以考虑使用观察者模式或更现代的框架（如JavaFX的MVVM模式）来管理界面与数据的绑定。
5. 增加Web版本：使用Spring Boot + Thymeleaf/Vue.js开发一个前后端分离的Web版图书管理系统。这是目前更主流的技术方向。
6. 完善业务功能：实现更复杂的统计报表（使用JFreeChart生成图表）、图书分类管理、借阅规则配置（如不同读者类型借阅时长不同）、邮件提醒超期等功能。

这个项目就像一把钥匙，帮你打开了Java企业应用开发的大门。从JDBC到事务，从DAO到分层架构，从Swing到事件驱动，每一个环节都值得深入琢磨。我建议你在能熟练运行这个基础版本后，选择上述一两个扩展方向动手实践，遇到的每一个错误和解决的每一个问题，都会成为你宝贵的经验。编程没有捷径，就是多看、多写、多思考、多总结。希望这份详细的实现和解析能对你有所帮助。