从小到大，如果你想碰数据库，JDBC几乎是绕不开的第一道门。网上有很多大而全的视频教程，但是真正自己写下来的东西少得可怜。今天要聊的这个“JDBC + MySQL 图书馆迷你图书管理系统”，是我个人非常推荐拿来当练习的入门小项目，没有网页，没有框架，就一个控制台，能查询、新增、修改、删除、退出。把它手敲一遍，你会比看十期教程都明白什么叫做“数据库应用”。

这个项目到底解决什么问题？说白了，它就是让你把脑子里零散的 JDBC 知识点，串成一条完整的线：怎么连数据库、怎么写 SQL、怎么处理结果集、怎么关资源、怎么在控制台里组织一套能跑起来的业务逻辑。适合正在学 Java 基础、刚接触数据库的同学，也适合那些想复习 JDBC 的老手——毕竟很多细节隔一段时间不看真的会忘。

1. 这个“迷你”系统为什么值得手敲一遍

1.1 控制台应用是学习阶段的正确选择

很多同学一上来就想写 Web 项目，Spring Boot 一套基础框架搭起来，连接池配好，MVC 分层一铺，然后就发现自己连最基础的数据流都没搞明白：请求是怎么进来的，参数是怎么传的，SQL 是怎么发的，结果又是怎么返回到界面上的。框架把这些东西全都藏掉了，出了问题你根本不知道是框架的锅还是自己的锅。

控制台项目完全没有这个问题。没有隐藏的封装，没有自动配置，你写的每一行 Java 代码都直接对应最终发生的事。用户输入一个数字，代码就去执行操作；查出来的数据，用 System.out.println 一行一行打出来。这种“所见即所得”的方式，对建立底层认知特别重要。等你有过几次从 null 查到、从 SQLException 里看 stack trace 排查的经历，再去碰框架，会有完全不同的底气。

1.2 程序整体流程：一个循环，五个选项

这个系统的骨架并不复杂，核心就是一个 while 循环加 switch 分支判断。用户在控制台键入“1”到“5”，程序分别走到查询、新增、修改、删除、对应的处理逻辑，然后重新回到菜单，直到用户输入“5”退出。

Scanner scanner = new Scanner(System.in); while (true) { System.out.println("======= 迷你图书馆管理系统 ======="); System.out.println("1. 查询全部书籍"); System.out.println("2. 新增书籍"); System.out.println("3. 修改书籍"); System.out.println("4. 删除书籍"); System.out.println("5. 退出系统"); System.out.print("请选择操作："); String option = scanner.nextLine(); switch (option) { case "1" -> listAllBooks(); case "2" -> addBook(scanner); case "3" -> updateBook(scanner); case "4" -> deleteBook(scanner); case "5" -> { System.out.println("感谢使用，再见。"); System.exit(0); } default -> System.out.println("输入有误，请选择 1 - 5 之间的数字。"); } }

你可能会问，为什么不直接用 int 接收数字，然后用 switch 匹配？因为用户真的会输入各种奇怪的东西，比如“abc”“空格”之类。用 nextLine() 接收字符串，可以更好地容错。我见过很多人在这上面踩坑：用 nextInt() 接收选项，结果下次再用 nextLine() 读书籍标题的时候，就会吞掉那个换行符，导致输入直接错乱。所以从一开始就统一用 nextLine() 读字符串，是最省心的做法。

1.3 代码分层：不搞架构，但要有一点边界感

练习项目不需要整高深的分层架构，但建议还是把代码拆成几个类，而不是全部怼进一个 main 方法里。我自己写的时候，习惯至少分成三层：

• 实体类 Book，对应数据库表的一行数据，属性就是表的字段；
• 数据访问类 BookDao，里面封装所有 JDBC 操作，每个方法负责一条 SQL 该干的事；
• 主类 Main，负责控制台菜单和用户交互。

这样拆的好处有两个。第一，main 方法里不会堆几十行 JDBC 代码，看着清爽。第二，当你后面想扩展功能，比如加一个“按出版社查询”的方法，只需要在 BookDao 里加方法，不会牵一发动全身。

实体类的写法很简单，就是私有属性加 getter/setter。有些人觉得这种类没有技术含量，但它其实是后面所有框架里实体映射的基础，老老实实写一遍没有坏处。

2. 动手前准备：环境、建库建表与命名习惯

2.1 版本搭配与驱动下载，别在第一步卡住

环境这块其实没什么玄学。JDK 用 8 以上就好，我现在用得比较多的是 JDK 11，往下兼容基本没什么问题。MySQL 用 5.7 或 8.0 都可以，这个项目用到的功能非常基础，不会触及版本间差异太大的特性。

真正要注意的是 JDBC 驱动 jar 包的版本。MySQL 8.0 之后，驱动类名变成了com.mysql.cj.jdbc.Driver，而老版本是com.mysql.jdbc.Driver。你如果拿一个旧的 5.x 驱动 jar 去连 MySQL 8，很可能会报各种奇怪的兼容错误。

我个人建议直接引入较新版本的驱动 jar，下载之后把它放到项目的 lib 目录，然后在 IDE 里 Add as Library。这一步看似简单，但 90% 的初学者卡住都是因为这个 jar 没放进去，或者放进去没生效。判断方法也很简单：代码里用到Class.forName("com.mysql.cj.jdbc.Driver")，如果运行时报了ClassNotFoundException，那就说明驱动类根本没被加载进来，先检查 jar 是否真的被依赖上，再去查别的问题。

2.2 建库建表，字段类型不要乱选

接下来是数据库设计。这个小系统的表结构非常容易：

CREATE DATABASE library_db DEFAULT CHARACTER SET utf8mb4; USE library_db; CREATE TABLE book ( id INT AUTO_INCREMENT PRIMARY KEY COMMENT '图书编号', title VARCHAR(200) NOT NULL COMMENT '书名', author VARCHAR(100) NOT NULL COMMENT '作者', price DECIMAL(8, 2) DEFAULT 0.00 COMMENT '价格', publisher VARCHAR(100) COMMENT '出版社', publish_date DATE COMMENT '出版日期' ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

这里有几个细节值得拿出来说。

第一，价格字段别用 FLOAT 或 DOUBLE。二进制浮点数存十进制小数会产生精度问题，比如存 39.9，读出来可能是 39.900000001。DBA 看到这种设计会皱眉，做练习的时候就应该养成用 DECIMAL 的习惯。

第二，日期字段用 DATE，而不是 VARCHAR。有些教程为了省事，把日期当字符串存，程序里面也能跑，但你后面一旦要做日期范围查询，就会非常痛苦，字面比较和日期比较的逻辑完全不同。

第三，主键用自增 INT 就好。别去搞那种“业务编号”，比如什么“ISBN”，ISBN 本身有数据录入错误的风险，不适合当主键。小型练习项目里，代理主键就是最省事的解。

2.3 字符集与存储引擎，这两个坑你在代码里感受不到

在 MySQL 里，utf8mb4和utf8的差别很多人一直没搞清楚。MySQL 的utf8最多只能存 3 字节编码的字符，这意味着像 emoji 这类 4 字节字符它会报错或者存成乱码。utf8mb4是真正兼容完整 Unicode 的字符集。书名里如果出现特殊符号，用utf8mb4就不会出幺蛾子。

存储引擎建议显式写成 InnoDB。MySQL 5.5 以后默认就是 InnoDB，但作为练习，最好知道为什么要选它：只有 InnoDB 支持事务和外键。本项目里用到的事务不多，但你在建表的时候把它当成默认标准，后续做转账练习、订单练习就会顺手很多。

建表之后顺手插几条测试数据，方便后面调试查询功能：

INSERT INTO book (title, author, price, publisher, publish_date) VALUES ('Java核心技术', '某作者', 139.00, '某出版社', '2022-01-15'), ('代码整洁之道', '某作者', 59.00, '某出版社', '2020-06-30'), ('数据库系统概论', '某作者', 49.50, '某出版社', '2019-03-20');

3. JDBC 连接：新手翻车总数最多的一道门槛

3.1 用 Properties 文件管理连接参数，别在代码里写死密码

刚开始练习的时候，很多人会把连接参数直接写在 Java 代码里，图省事：

String url = "jdbc:mysql://localhost:3306/library_db?useSSL=false&serverTimezone=Asia/Shanghai"; String username = "root"; String password = "123456";

这样写不是不能跑，但有一个非常现实的坏处：改数据库密码、换库名的时候，你得跑回代码里改，改完还要重新编译。这还算小事，更麻烦的是代码一旦提交到团队仓库，等于把数据库密码暴露给所有人。从练习第一天开始养成好习惯，把连接信息放到jdbc.properties文件里：

driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/library_db?useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=utf8 username=root password=123456

在 Java 里用Properties类加载：

Properties props = new Properties(); try (InputStream in = DBUtil.class.getClassLoader().getResourceAsStream("jdbc.properties")) { props.load(in); }

这样数据库配置和代码就完全分开了。以后不管换环境还是调参数，都只需要改一个配置文件，比在代码里找连接字符串舒服得多。

3.2 连接参数里那几段神秘字符串，逐个解释

URL 里那串useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=utf8看起来很劝退，其实每一段都有原因。

• useSSL=false：本机调试阶段根本不需要加密，加上等于告诉驱动不用做证书校验，省去一堆握手时间。生产环境再考虑开 SSL，那又是另一套话题。
• serverTimezone=Asia/Shanghai：MySQL 8 驱动要求明确指定时区，否则会报一个关于 CST 时区的歧义异常。不管你的机器在哪，写明确时区是最稳妥的。
• characterEncoding=utf8：这个要和建表时的utf8mb4区分开。它管的是客户端和服务器之间传输字符的编码方式，如果不加，中文写入后很容易变成问号。

3.3 连接资源：抓住 try-with-resources 这个救命语法

JDBC 最容易被忽视但又最致命的问题，就是资源泄漏。每个操作都要拿到 Connection，用完如果不关，数据库连接池里的连接就会被耗尽，系统最终表现为“越来越慢，然后直接挂掉”。

所以从写第一版代码开始，就一定要用 try-with-resources 语法。它会在 try 代码块结束时自动关闭所有实现了AutoCloseable的资源。

public List<Book> findAll() { String sql = "SELECT id, title, author, price, publisher, publish_date FROM book"; List<Book> books = new ArrayList<>(); try (Connection conn = DBUtil.getConnection(); PreparedStatement ps = conn.prepareStatement(sql); ResultSet rs = ps.executeQuery()) { while (rs.next()) { Book book = new Book(); book.setId(rs.getInt("id")); book.setTitle(rs.getString("title")); book.setAuthor(rs.getString("author")); book.setPrice(rs.getBigDecimal("price")); book.setPublisher(rs.getString("publisher")); book.setPublishDate(rs.getDate("publish_date")); books.add(book); } } catch (SQLException e) { e.printStackTrace(); } return books; }

你可能会想，既然 try-with-resources 这么方便，是不是完全不用手动写 close 了？其实不是，如果你用一个Connection对象执行多个操作，比如用同一个连接先查再改，那你不能把连接写在方法内部的 try 里，否则一个方法结束连接就关了。对于这个迷你系统，每次操作独立开一个连接，用完即关，是最清醒简单的模型。

3.4 每次操作都连接一次，会不会太浪费？

会有一点浪费，但这是练习项目，优先级不是性能，而是结构清晰。每次操作都新建连接，意味着每次操作都是独立的、可预测的，不会出现一个连接状态影响另一个操作的情景。

真到性能有要求的时候，再去引入连接池，比如 HikariCP。连接池的原理很好理解：预先创建一批连接放在池子里，程序要连接时从池子里拿，用完放回去，而不是真的断开。你在这个练习项目里理解了 Connection 的生命周期，再去看连接池的配置参数，就完全不会懵了。

4. 四个核心功能的一次性实现与常遇易错点

4.1 查询：先写出不带条件的，再写模糊查询

查询功能是四个功能里最直接的，但依然有值得注意的地方。第一步先实现“查询全部”，就是上面代码里那段，跑起来能在控制台看到表格里已有的数据。

第二步可以在菜单里加一个“按书名模糊查询”的选项。这里有一个很重要的知识点：为什么用PreparedStatement而不是Statement。

public List<Book> findByTitle(String keyword) { String sql = "SELECT id, title, author, price, publisher, publish_date FROM book WHERE title LIKE ?"; List<Book> books = new ArrayList<>(); try (Connection conn = DBUtil.getConnection(); PreparedStatement ps = conn.prepareStatement(sql)) { ps.setString(1, "%" + keyword + "%"); try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { Book book = new Book(); book.setId(rs.getInt("id")); book.setTitle(rs.getString("title")); book.setAuthor(rs.getString("author")); book.setPrice(rs.getBigDecimal("price")); book.setPublisher(rs.getString("publisher")); book.setPublishDate(rs.getDate("publish_date")); books.add(book); } } } catch (SQLException e) { e.printStackTrace(); } return books; }

PreparedStatement最大的好处是用占位符?先把 SQL 结构定下来，用户输入的内容只能作为参数传进去。如果你图省事，直接拼接字符串：

String sql = "SELECT * FROM book WHERE title LIKE '%" + keyword + "%'";

这时候用户如果输入一个单引号，SQL 语句就变了，这就是传说中的 SQL 注入。别觉得练习项目不用考虑安全问题，养成正确的习惯比什么都重要，写 SQL 就用占位符，永远不要在 SQL 字符串里直接拼接用户输入。

4.2 新增：别只写 INSERT，带上返回主键

新增功能看起来就是往表里插入一行：

public int insert(Book book) { String sql = "INSERT INTO book (title, author, price, publisher, publish_date) VALUES (?, ?, ?, ?, ?)"; try (Connection conn = DBUtil.getConnection(); PreparedStatement ps = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) { ps.setString(1, book.getTitle()); ps.setString(2, book.getAuthor()); ps.setBigDecimal(3, book.getPrice()); ps.setString(4, book.getPublisher()); // setDate 需要 java.sql.Date，这里做个转换 if (book.getPublishDate() != null) { ps.setDate(5, new java.sql.Date(book.getPublishDate().getTime())); } else { ps.setDate(5, null); } int rows = ps.executeUpdate(); try (ResultSet keys = ps.getGeneratedKeys()) { if (keys.next()) { int id = keys.getInt(1); book.setId(id); System.out.println("新增成功，生成的主键 ID = " + id); } } return rows; } catch (SQLException e) { e.printStackTrace(); return 0; } }

这里有个很多人不会在小项目里注意的点：prepareStatement(sql)和prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)的区别。默认情况下，PreparedStatement 执行完 INSERT 不会拿回自增主键，如果你后面需要这个新记录的 id 去操作关联表，比如插入“图书借阅记录”，主键就非常有用。所以养成一个习惯：新增操作尽量考虑是否需要返回主键。

插入操作还要注意 NULL 的处理。用户在控制台可能把出版日期留空了，那么你就不能强制调用ps.setDate(5, date)而没有 null 判断。JDBC 规定，如果你传入 null，必须显式调用setDate(5, null)，直接传 Java null 进去有时候会抛异常。

4.3 修改：注意“只更新用户填了的那部分”要怎么做

修改功能比新增稍微复杂一点点，因为它面临一个选择：是把所有字段都更新一遍，还是只更新用户填写的字段。

最省事的方案是：让用户把 id 和所有字段都重输一遍，然后整行更新：

public int update(Book book) { String sql = "UPDATE book SET title = ?, author = ?, price = ?, publisher = ?, publish_date = ? WHERE id = ?"; try (Connection conn = DBUtil.getConnection(); PreparedStatement ps = conn.prepareStatement(sql)) { ps.setString(1, book.getTitle()); ps.setString(2, book.getAuthor()); ps.setBigDecimal(3, book.getPrice()); ps.setString(4, book.getPublisher()); if (book.getPublishDate() != null) { ps.setDate(5, new java.sql.Date(book.getPublishDate().getTime())); } else { ps.setDate(5, null); } ps.setInt(6, book.getId()); return ps.executeUpdate(); } catch (SQLException e) { e.printStackTrace(); return 0; } }

另一种方案是“动态 SQL”：只更新用户传入的非空字段。但是用纯 JDBC 写动态 SQL 非常啰嗦，你需要根据不同的情况拼接 SQL 语句和参数。初学者很容易在这里写出字符串拼接，而且容易漏掉逗号。所以对于这个迷你项目，我建议就选整行更新的方案，逻辑清楚、代码短小。等以后学了 MyBatis，会发现动态 SQL 是框架帮你解决的问题，而这里先把静态 SQL 写熟练更重要。

4.4 删除：执行成功不一定代表真的删掉了东西

删除操作是四个操作里代码最短的：

public int deleteById(int id) { String sql = "DELETE FROM book WHERE id = ?"; try (Connection conn = DBUtil.getConnection(); PreparedStatement ps = conn.prepareStatement(sql)) { ps.setInt(1, id); return ps.executeUpdate(); } catch (SQLException e) { e.printStackTrace(); return 0; } }

这里的关键是：executeUpdate()返回的“受影响行数”是 0，不代表执行出错，而是说没有匹配到对应的记录。所以在控制台层面，你应该根据这个返回值给用户不同的反馈：

int rows = bookDao.deleteById(id); if (rows > 0) { System.out.println("删除成功"); } else { System.out.println("没有找到 ID 对应的书籍，请检查后重试"); }

这种看似微不足道的反馈，恰恰是系统可用性的体现。直接把“删除成功”打印出去，但实际什么都没删，用户会非常困惑。

5. 实战中的故障排查——这些坑我替你踩过了

5.1 高频报错速查表

我把练习过程中最容易撞到的几个问题和排查方法整理成了一张表，新手照着查就行：

5.2 最容易忽略的根因：IDE 与文件编码

中文乱码还有一个特别隐蔽的来源，就是你的 Java 源文件本身的编码不对。IDE 默认可能是 GBK，但是编译的时候又按 UTF-8 去解码，中文字符串直接变成乱码。这个和数据库一点关系都没有。

解决办法很简单：统一把整个项目的字符编码设置为 UTF-8。在 IDE 里找到编码设置，把项目全局、文件的默认编码都改成 UTF-8。数据库那边确认表是 utf8mb4，连接 URL 带 characterEncoding=utf8，这样一套组合下来中文就非常稳。

5.3 排查问题的标准流程

5.3 排查问题的标准流程

遇到报错不要急着到处找答案，我给你一套百试百灵的方法。先把异常信息完整读一遍，找到 “Caused by” 那一行，那通常才是真正的病根。然后按下面顺序检查：

1. 确认 MySQL 服务正常：命令行执行SELECT 1，如果能查出结果，说明服务端没问题。
2. 确认驱动 jar 确实在 classpath：手动在代码里新建一个驱动类看看能不能编译过。
3. 确认 SQL 语法本身没问题：把我上面写的 SQL 直接复制到数据库客户端执行，比如用 Navicat 或命令行，看看能不能跑。这一步能帮你把“SQL 错误”和“Java 代码错误”快速区分开。
4. 确认参数绑定顺序：?占位符的顺序和setXxx的顺序必须一一对应，这个错误很难肉眼发现，建议一行一行对。

这套流程走一遍，可以说覆盖了 90% 的 JDBC 连接与执行问题。

6. 做完之后，下一步还能怎么练

6.1 用“三层结构”重写一遍

如果你把第一个版本写出来并且跑通了，别急着发朋友圈庆祝，我先给你留一个作业：把项目拆成 Service 层、DAO 层、实体层，然后给 DAO 加一个接口。

为什么要做接口？因为你现在的 BookDao 是直接实现代码，接口的意义在于，你定义“这个系统需要哪些数据操作能力”，然后在实现类里做具体的事情。以后你想把 BookDao 的实现换成别的数据库，比如换成 PostgreSQL，只需要再写一个新的实现类，控制台主程序几乎不用动。

这个练习不需要新的框架，就是纯 Java 就能做：建一个接口BookDao，里面放List<Book> findAll()、int insert(Book book)、int update(Book book)、int deleteById(int id)这些方法，然后让BookDaoImpl去实现它。改完之后你会发现，面向接口编程并没有想象中那么玄学，就是你平时做事的一种方式：先定好规矩，再谈具体怎么做。

6.2 试着加一个“借书还书”场景，练练事务

如果你觉得 CRUD 已经手到擒来了，可以在这个图书馆系统里加一个借书还书的功能，专门用来练事务。

场景是这样的：图书馆里每一本书有库存数量，用户借一本书，不仅要往“借阅记录表”里插入一条记录，还要把书的库存减一。这两个操作必须同时成功或者同时失败，否则就会出现“记录借出去了，但库存没减”这种数据不一致。

在 JDBC 里面，事务代码的正规写法是这样的：

public boolean borrowBook(int bookId) { Connection conn = null; try { conn = DBUtil.getConnection(); conn.setAutoCommit(false); String updateStock = "UPDATE book SET stock = stock - 1 WHERE id = ? AND stock > 0"; String insertRecord = "INSERT INTO borrow_record (book_id, borrow_time) VALUES (?, NOW())"; try (PreparedStatement ps = conn.prepareStatement(updateStock)) { ps.setInt(1, bookId); int rows = ps.executeUpdate(); if (rows == 0) { throw new SQLException("库存不足或书籍不存在"); } } try (PreparedStatement ps = conn.prepareStatement(insertRecord)) { ps.setInt(1, bookId); ps.executeUpdate(); } conn.commit(); return true; } catch (SQLException e) { if (conn != null) { try { conn.rollback(); } catch (SQLException ex) { ex.printStackTrace(); } } e.printStackTrace(); return false; } finally { if (conn != null) { try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } }

注意这里我没有用 try-with-resources 来管理 Connection，因为事务要求连接在多个操作之间保持一致，try-with-resources 放在外围会把连接提前关掉。你要手工控制 commit 和 rollback，以及确保 finally 里把连接关掉。

练完这个小场景，你会对事务、原子性、回滚这些东西有非常直观的理解，比单纯背概念强十倍。

7. 我把这个项目重新做一遍的体会

说起来，这个项目我已经不是第一次写了。每次重新写，都会发现一些之前没注意的细节，比如 DECIMAL 和 DOUBLE 的差别，比如设置RETURN_GENERATED_KEYS，比如字符集统一。技术这东西就是这样，光看永远觉得简单，真正动手才会暴露自己的盲区。

如果你正要开始做这个练习，我建议你给自己定一个硬指标：不要直接复制本文任何代码，全部手打，每一行都要能说出它是干什么的。遇到不会的，先查 Java 文档，再看别人怎么写，最后回来自己写一遍。这个过程会比较慢，但每解决一个问题，你就积攒了一个真实的经验，这种经验是你刷再多的题都换不来的。

最后再分享一个小技巧：写完之后，把项目的运行截图和过程总结保存下来，哪怕只是扔在自己的博客里。过三个月再回头看，你会发现这些记录提醒你自己的成长到底有多大。继续往下走，就把这个书架上的第一本“书”，越做越厚。