开头

每年实训季我都会看到大量JDBC数据库编程的实训报告，大部分翻来覆去就是贴代码、放截图，本质上是一份代码说明书，而不是实训报告。JDBC这个主题，实训真正要考察的其实是三件事：对JDBC API执行流程的理解、对数据库交互工程结构的拆分能力、对资源管理和异常处理的基本功。我在辅导实训时反复强调一句话：JDBC并不难，难的是用工程化的思维去写JDBC代码。这篇文章把我带实训时梳理的完整思路放出来，讲清楚JDBC从连接建立到结果处理的底层逻辑、一个合格的数据访问层应该怎么拆分、实训报告里哪些内容才是加分项。无论你是正在准备Java实训报告的学生，还是刚入行想把数据访问这块基础补扎实的开发者，这篇都值得读一读。

1. 实训报告不是代码清单，而是工程方案说明

1.1 一篇合格的实训报告要回答哪四个问题

很多同学写JDBC实训报告，习惯从DriverManager开始贴代码，一直贴到关闭连接，再加个运行截图就收工。这种写法在课程设计里能及格，但离“合格”还有很大距离。我评审实训报告时，会重点看四个问题有没有交代清楚：第一，这个实训到底要解决什么问题，业务背景是什么；第二，用的什么数据库、什么驱动、什么连接方式，为什么这样选；第三，数据访问层的结构是怎么设计的，每个类和接口承担的职责是什么；第四，异常和资源是怎么处理的，出了故障怎么排查。

如果你把实训报告当作一份工程方案说明来写，而不是代码清单，思路就会清晰很多。JDBC实训的本质，是用Java语言通过标准API去操作关系型数据库，完成增删改查这一整套流程。但标准API只是最底层的地基，真正值钱的是你在这上面搭建的工程结构——连接怎么管理、SQL怎么组织、结果怎么转换、异常怎么兜底。这些才是实训报告应该重点展开的内容。

1.2 环境选型和版本匹配

环境部分每个人都写，但很少有人写清楚为什么是这个版本。实训报告里建议把环境信息用表格列出来，这样导师一眼就能看清你的运行环境：

版本匹配是特别容易踩坑的地方。MySQL 5.x用的驱动类是com.mysql.jdbc.Driver，8.x改成了com.mysql.cj.jdbc.Driver。URL参数也不一样，8.x必须带serverTimezone，否则会出现时区报错。很多实训项目的报错，根因就是驱动版本和数据库版本对不上。

我建议实训环境统一采用MySQL 8.0 + mysql-connector-java 8.0.33这套组合，相对来说最稳定。如果你所在实训机房装的是MySQL 5.7，那驱动就用5.1.49，不要把高版本驱动硬塞到低版本数据库上，反之亦然。

2. JDBC执行流程拆解：从驱动加载到结果集遍历

2.1 驱动加载的底层逻辑

JDBC的第一步是驱动加载，通常写Class.forName("com.mysql.cj.jdbc.Driver")。很多同学只是背了这行代码，完全不知道它在干什么，也不知道从JDBC 4.0开始这行代码其实可以省略。

Class.forName的作用是让类加载器把Driver类加载进JVM，触发类中的静态代码块执行。MySQL的Driver类里有一个静态块，会主动创建一个Driver实例，并且调用DriverManager.registerDriver把这个实例注册到DriverManager的驱动列表中。DriverManager维护一个CopyOnWriteArrayList存放所有注册进来的驱动，后面调用getConnection时，它就遍历这个列表，让每个驱动尝试去解析URL，谁能解析谁就负责建立连接。

这里有一个非常有用的机制：URL解析。DriverManager会根据jdbc:mysql前缀来匹配驱动，如果你引入多个数据库的驱动，比如MySQL、Oracle、PostgreSQL的jar包都在classpath里，它也是靠这个前缀找到正确驱动的。所以URL不是随便写的，前缀就是驱动注册时的匹配密钥。

从JDBC 4.0开始，只要我们通过Maven或手动引入驱动jar包，并且保证它在classpath中，ServiceLoader机制会自动加载META-INF/services/java.sql.Driver文件里声明的驱动类，Class.forName这行代码可以省略。但实训报告里我仍然建议保留，原因有两个：一是显式加载能让人一眼看懂你用的是哪种数据库，二是兼容老版本JDK环境，毕竟实训机房的JDK版本不一定由你说了算。

// 显式加载驱动，让连接过程意图更清晰 Class.forName("com.mysql.cj.jdbc.Driver"); String url = "jdbc:mysql://localhost:3306/student_db?useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=utf8"; String username = "root"; String password = "123456"; Connection conn = DriverManager.getConnection(url, username, password);

2.2 Connection、Statement、ResultSet三者如何协同

JDBC的核心执行链条就三步：Connection负责创建会话，Statement负责承载SQL，ResultSet负责接收查询结果。

Connection是重量级资源，底层对应一条数据库的物理网络连接，创建它需要经过TCP握手、身份认证、权限校验，开销很大。这也是为什么高并发场景必须用连接池，而不是每操作一次就新建一条连接。

Statement有两个子接口需要区分：PreparedStatement和CallableStatement。实训中绝大多数场景用PreparedStatement。它有两个关键能力，第一是预编译，SQL骨架先发给数据库编译，后面只传参数，重复执行时性能更好；第二是参数化查询，用问号占位符代替字符串拼接，从根上杜绝SQL注入。

很多同学疑惑：为什么PreparedStatement能防SQL注入？我给你拆开看。如果用字符串拼接：

String sql = "SELECT * FROM user WHERE name = '" + input + "'";

用户输入"admin' OR '1'='1"，拼出来后就是：

SELECT * FROM user WHERE name = 'admin' OR '1'='1'

条件恒成立，整张表都被查出来了，这就是SQL注入。而PreparedStatement是先用问号占位：

String sql = "SELECT * FROM user WHERE name = ?"; PreparedStatement ps = conn.prepareStatement(sql); ps.setString(1, input);

SQL骨架发送给数据库后，参数值通过二进制协议单独传输，数据库把输入当作纯数据而不是SQL片段处理，所以不管用户输入什么，都不可能改变SQL的执行语义。

ResultSet是结果集，它本质上是一个指向数据行的游标。刚查询完，游标指向第一行的前一行，调用next()方法才会把游标移到第一行，返回boolean表示是否还有下一行。用getString("columnName")或getInt(1)可以取出当前行某一列的数据，既有列名方式也有索引方式。列名方式可读性更好，索引方式性能略好一点点，实训代码里推荐列名方式，别人看代码的时候不用去数第几列是什么字段。

// 标准查询流程：Connection → PreparedStatement → ResultSet String sql = "SELECT id, name, age FROM student WHERE age > ?"; try (Connection conn = DriverManager.getConnection(url, username, password); PreparedStatement ps = conn.prepareStatement(sql)) { ps.setInt(1, 18); try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { int id = rs.getInt("id"); String name = rs.getString("name"); int age = rs.getInt("age"); System.out.println("id=" + id + ", name=" + name + ", age=" + age); } } } catch (SQLException e) { e.printStackTrace(); }

2.3 executeQuery和executeUpdate的适用边界

Statement系列有两个执行方法很容易混淆：executeQuery和executeUpdate。executeQuery专门执行SELECT语句，返回值是ResultSet；executeUpdate执行INSERT、UPDATE、DELETE以及DDL语句，返回值是int，代表受影响的行数。

有个边界情况：如果SQL是CREATE TABLE这类DDL语句，executeUpdate也会返回0，是“正常影响0行”，和 UPDATE 操作WHERE条件未命中影响0行在返回值上是一样的。所以要判断操作是否成功，不能只看返回0就觉得失败，更稳妥的方式是结合逻辑判断或检查数据库的实际状态。

还有个冷门但实用的方法execute，它可以执行任意SQL，返回boolean表示是否是ResultSet。如果返回true，就用getResultSet拿结果集；如果是false，就用getUpdateCount拿影响行数。这个方法在写通用SQL执行工具类时会用到，实训里不需要深挖，但知道它存在就够了。

3. 实训项目实战：用DAO模式写一个不烧脑的数据访问层

3.1 建表、Javabean、DAO三者的对应关系

实训项目需要一个具体场景，我推荐用“学生信息管理”作为载体，它足够简单，又覆盖了完整的CRUD操作。第一步是建表：

CREATE DATABASE IF NOT EXISTS student_db DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci; USE student_db; CREATE TABLE student ( id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(50) NOT NULL, age INT NOT NULL, gender VARCHAR(10) DEFAULT '男', major VARCHAR(100), create_time DATETIME DEFAULT CURRENT_TIMESTAMP ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

建表语言里不建议写任何编码格式为utf8mb4的字段，数据库整体字符集在库级别设置就好了。有个细节：MySQL的utf8字符集最多3字节，存不了emoji和一些生僻字，utf8mb4才是真正的4字节UTF-8。实训里虽然存emoji的概率不高，但库和表统一用utf8mb4，配合连接参数characterEncoding=utf8，基本能规避所有中文乱码问题。

Javabean是与student表字段一一对应的Java类，属性名尽量与数据库列名保持一致：

public class Student { private Integer id; private String name; private Integer age; private String gender; private String major; private Date createTime; // 无参构造、全参构造 // getter、setter方法 // toString方法 }

DAO，即Data Access Object，是隔离业务逻辑与数据库访问的中间层。它的价值在于：业务层只需要面对DAO接口，不关心SQL怎么写、数据库连接怎么管理。以后换数据库或者修改表结构，只改DAO实现类，业务层代码不用动。

接口定义五个核心方法，覆盖增删改查和列表查询：

public interface StudentDao { int insert(Student student); // 新增 int deleteById(Integer id); // 按ID删除 int update(Student student); // 更新 Student selectById(Integer id); // 按ID查询 List<Student> selectAll(); // 查询所有 }

3.2 DAO实现类中的SQL与参数绑定细节

DAO实现类一方面要完成SQL执行，另一方面还要实现ResultSet到Javabean的映射。这个映射过程在MyBatis里叫ORM，在JDBC原生环境里只能你自己写。写多了之后你会发现这是整个JDBC编程中最枯燥但最核心的部分。

public class StudentDaoImpl implements StudentDao { private static final String URL = "jdbc:mysql://localhost:3306/student_db?useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=utf8"; private static final String USERNAME = "root"; private static final String PASSWORD = "123456"; @Override public int insert(Student student) { String sql = "INSERT INTO student(name, age, gender, major) VALUES(?, ?, ?, ?)"; try (Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD); PreparedStatement ps = conn.prepareStatement(sql)) { ps.setString(1, student.getName()); ps.setInt(2, student.getAge()); ps.setString(3, student.getGender()); ps.setString(4, student.getMajor()); return ps.executeUpdate(); } catch (SQLException e) { throw new RuntimeException("新增学生数据失败", e); } } @Override public Student selectById(Integer id) { String sql = "SELECT id, name, age, gender, major, create_time FROM student WHERE id = ?"; try (Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD); PreparedStatement ps = conn.prepareStatement(sql)) { ps.setInt(1, id); try (ResultSet rs = ps.executeQuery()) { if (rs.next()) { Student student = new Student(); student.setId(rs.getInt("id")); student.setName(rs.getString("name")); student.setAge(rs.getInt("age")); student.setGender(rs.getString("gender")); student.setMajor(rs.getString("major")); student.setCreateTime(rs.getTimestamp("create_time")); return student; } } return null; } catch (SQLException e) { throw new RuntimeException("按ID查询学生数据失败", e); } } }

这里有个参数绑定的细节：setString、setInt是根据Java类型选择的方法，数据库端的类型转换由驱动完成。比如Java的String映射到MySQL的VARCHAR或TEXT都能处理，Java的int映射到INT或BIGINT也可以。但需要注意setTimestamp对应MySQL的DATETIME/TIMESTAMP，如果Javabean用java.util.Date，在传给setTimestamp时要先转成java.sql.Timestamp，这是新手最容易忽略的。

createTime字段在数据库里是DATETIME，同时有DEFAULT CURRENT_TIMESTAMP。insert时我们没有手动设置它，数据库会自动填当前时间。selectById中返回时用rs.getTimestamp("create_time")取出java.sql.Timestamp，它是java.util.Date的子类，所以直接setCreateTime没问题。

3.3 资源释放：为什么建议用try-with-resources

JDBC编程有一条铁律：Connection、Statement、ResultSet用完后必须关闭。原因很实在，Connection是网络连接，Statement和ResultSet在数据库端也有对应的资源占用，不释放的话，轻则连接数打满，重则数据库直接被拖垮。

传统写法是在finally块里逐个关闭，判断是否为null，还要处理close方法自身的异常。代码难看且容易漏。从JDK 7开始，try-with-resources语法可以自动关闭实现了AutoCloseable接口的资源，代码干净很多。

// 传统写法：finally块里关闭资源 Connection conn = null; PreparedStatement ps = null; ResultSet rs = null; try { conn = DriverManager.getConnection(URL, USERNAME, PASSWORD); ps = conn.prepareStatement(sql); rs = ps.executeQuery(); // 处理结果集 } catch (SQLException e) { e.printStackTrace(); } finally { try { if (rs != null) rs.close(); } catch (SQLException e) { e.printStackTrace(); } try { if (ps != null) ps.close(); } catch (SQLException e) { e.printStackTrace(); } try { if (conn != null) conn.close(); } catch (SQLException e) { e.printStackTrace(); } }

finally块里三个try-catch嵌套，占了将近十行。而try-with-resources写法把资源的声明放在try后面的括号里，方法结束时自动逆序关闭，也就是先关ResultSet再关Statement最后关Connection：

try (Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD); PreparedStatement ps = conn.prepareStatement(sql); ResultSet rs = ps.executeQuery()) { // 处理结果集 } catch (SQLException e) { e.printStackTrace(); }

还有一层隐藏的逻辑：如果你手动关闭了Connection，它底层的Statement和ResultSet也会被级联关闭。但依赖这种级联是很危险的习惯，因为一旦使用连接池，Connection.close()不真正关闭物理连接，而是归还给连接池，此时Statement和ResultSet如果不显式关闭，就会一直在数据库端残留。连接池环境下，“只关Connection就够”的偷懒做法绝对是坑。

实训报告里我建议专门用一个小节来写资源释放策略，这比多写十个CRUD方法更让老师认可。

4. 实训里的“加分项”：SQL注入防护、连接池与事务边界

4.1 参数化查询如何把SQL注入扼杀在摇篮里

SQL注入是老生常谈，但每次实训里总有同学用字符串拼接，而且觉得自己写得挺好的。这里我强烈建议在实训报告里把防SQL注入这个点明确写出来，体现你不仅会写代码，还有安全意识。

参数化查询的原理前面已经提过：SQL骨架与参数分离传输，参数永远作为数据处理，不会参与SQL解析。只要SQL中使用?占位符，并且通过setXxx方法绑定参数，就不存在注入的可能。

还要注意一个细节：Order by子句后面的部分和表名字段名这类结构性的元素，不能用问号占位符。因为预编译是把值作为参数绑定，而表名、列名、排序方式属于SQL结构的一部分，参数化机制不覆盖这些位置。如果需要动态传入排序字段，必须用白名单校验：

// 不安全的写法 String sql = "SELECT * FROM student ORDER BY " + orderBy; // 安全的做法：对排序字段做白名单校验 String orderBy = "age"; if (!Arrays.asList("id", "name", "age", "create_time").contains(orderBy)) { throw new IllegalArgumentException("非法排序字段"); } String sql = "SELECT * FROM student ORDER BY " + orderBy;

4.2 为什么实训中要主动引入Druid连接池

实训报告里如果出现了连接池，已经算是一个亮点了。很多同学会问：实训项目的并发量又不高，学连接池有必要吗？

我的回答是：有必要。因为连接池不仅仅是性能优化手段，更是一种资源管理思想。驱动自带的DriverManager每次getConnection都新建物理连接，在高并发下性能极差，而连接池预先创建一批连接放在池里，需要时直接取，用完归还，省去重复建连和断连的开销。

Druid是Java生态中用得非常广泛的连接池，功能全面，自带监控页面。实训里用Druid意义在于让你提前接触生产级的连接管理方式，而且配置非常简单。你需要引入druid的jar包，然后写一个工具类：

public class JdbcUtils { private static DruidDataSource dataSource; static { try { dataSource = new DruidDataSource(); dataSource.setUrl("jdbc:mysql://localhost:3306/student_db?useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=utf8"); dataSource.setUsername("root"); dataSource.setPassword("123456"); dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver"); dataSource.setInitialSize(5); // 初始连接数 dataSource.setMinIdle(5); // 最小空闲 dataSource.setMaxActive(20); // 最大活跃连接数 dataSource.setMaxWait(10000); // 获取连接的最大等待时间，毫秒 } catch (Exception e) { e.printStackTrace(); } } public static Connection getConnection() throws SQLException { return dataSource.getConnection(); } }

代码里两个地方最容易出错。一是setUrl时不带参数，后续中文乱码或者时区不对又要回头改；二是maxWait如果设成0，表示无限等待，在数据库连接池耗尽时会导致线程一直卡死，生产环境一般不推荐。实训项目设成10000毫秒，超过等待时间直接抛异常，问题暴露得反而快。

4.3 事务的ACID在JDBC里怎么落地

事务是数据库编程绕不开的话题。JDBC中Connection默认是自动提交模式，也就是autocommit为true，每执行一条DML自动提交。如果要让多条SQL组成一个原子操作，必须手动关闭自动提交，执行完成后提交或回滚。

经典的实训案例是转账操作：扣钱和加钱是两条UPDATE，必须保证同时成功或同时失败。如果第一条执行成功、第二条执行失败，不回滚的话钱就凭空消失了。

Connection conn = null; try { conn = JdbcUtils.getConnection(); conn.setAutoCommit(false); // 关闭自动提交，开启事务 // 扣款 String sql1 = "UPDATE account SET balance = balance - 100 WHERE id = 1"; try (PreparedStatement ps1 = conn.prepareStatement(sql1)) { ps1.executeUpdate(); } // 入账 String sql2 = "UPDATE account SET balance = balance + 100 WHERE id = 2"; try (PreparedStatement ps2 = conn.prepareStatement(sql2)) { ps2.executeUpdate(); } conn.commit(); // 全部成功，提交事务 } catch (SQLException e) { try { if (conn != null) conn.rollback(); // 任一失败，回滚事务 } catch (SQLException ex) { ex.printStackTrace(); } throw new RuntimeException("转账失败", e); } finally { try { if (conn != null) { conn.setAutoCommit(true); // 恢复自动提交，避免影响连接池下一次使用 conn.close(); } } catch (SQLException e) { e.printStackTrace(); } }

事务的边界往往是从业务层决定的。什么时候开始事务，什么时候提交，需要根据业务操作涉及的SQL范围来确定。有一个常见错误：把事务控制的代码写在DAO层单个方法内部，但一次业务操作横跨多个DAO方法，导致事务被切碎，无法保证整体原子性。正确的做法是事务放在Service层开启，DAO层只负责SQL执行。实训报告里如果能写到这一层抽象，说明你真的理解了事务的本质。

5. 实训中必然踩到的坑与排查链路

5.1 ClassNotFoundException和SQLException：两种异常，两套排查思路

JDBC编程最常见的异常是ClassNotFoundException和SQLException，但它们的排查方向完全不同。

ClassNotFoundException是Java层面的问题，说明JVM在classpath里找不到驱动类。可能的原因：jar包没有导入、jar包导入失败、jar包版本不对导致包路径不存在。排查链路是，先检查项目依赖中是否存在mysql-connector-java，再检查驱动类名是否正确，MySQL 5.x是com.mysql.jdbc.Driver，8.x是com.mysql.cj.jdbc.Driver，八点零以后老类名仍然保留但会打印警告，偶尔还会遇到新驱动彻底移除老类名的情况，所以最好统一用新类名。

SQLException是数据库层面的通讯问题，具体原因千奇百怪。最常见的几个是：

5.2 中文乱码：多级都可能是元凶

中文乱码问题涉及四级环节：数据库表字符集、连接参数字符集、IDE文件编码、控制台输出编码。任何一个不一致，都会导致乱码。

排查链路要从下往上逐层确认。先检查数据库表字符集，执行SHOW CREATE TABLE student，确认CHARSET是utf8mb4。再检查连接参数里的characterEncoding=utf8。接着检查IDE的项目编码，IDEA在Settings > Editor > File Encodings里，全局和项目都设为UTF-8。最后如果控制台打印中文乱码但数据库里正常，那是控制台编码问题，IDEA的Help > Edit Custom VM Options里加-Dfile.encoding=UTF-8，重启生效。

最常见的场景是：数据库里中文正常，Java代码里中文常量也正常，就是查询结果打印出来乱码。这种基本就是连接参数没带characterEncoding=utf8，或者带了但数据库表本身是latin1字符集。

5.3 连接泄漏与连接池耗尽：写代码时看不见，跑起来要命

连接泄漏是JDBC内存管理里最隐蔽的坑。表现是：单次执行没问题，程序跑一会儿就报“连接数不足”或“连接池超时”。原因是某处的Connection获取了没关闭，连接被永久占用。

在没有连接池的年代，Connection不关就是socket不释放，程序跑久了系统文件句柄耗尽。有了连接池之后，Connection不close只是归还失败，池里的连接被占着不放，最终池耗尽。

排查方法很朴素：如果你的项目里用了Druid，开启监控页面就能看到活跃连接数持续不降，就是泄漏了。不用连接池的话，可以在finally块里打日志观察close方法是否被执行。最直接的自查方式是全项目搜索new Connection或者getConnection，然后逐个确认是否都在try-with-resources或finally中关闭了。

这里我还会专门提醒一个点：如果写了like查询，通配符要在参数里拼而不是直接拼进SQL。比如查询所有姓张的同学：

// 推荐写法 String sql = "SELECT * FROM student WHERE name LIKE ?"; ps.setString(1, "张%"); // 而不是 String sql = "SELECT * FROM student WHERE name LIKE '张%'"; ps.setString(1, name); // 错误，参数被忽略或拼接成二维SQL

这个细节在实训答辩中很容易被老师追问，提前掌握能让你省去很多尴尬。

5.4 流式查询：大结果集下的内存保护机制

实训里查询所有学生可能只有几十条数据，感受不出问题。但如果你以后工作中用JDBC查询几百万行数据，默认方式下ResultSet会一次性把所有结果加载到JVM堆内存，内存直接被打爆是常有的事。

流式查询是一种边读边取的方式，设置fetchSize并让连接不自动提交时，MySQL的驱动会一条一条或按批次从数据库取数据，而不是一次性加载全部结果。用法：

Connection conn = JdbcUtils.getConnection(); conn.setAutoCommit(false); // 流式查询要求关闭自动提交 String sql = "SELECT * FROM big_table"; try (PreparedStatement ps = conn.prepareStatement(sql)) { ps.setFetchSize(Integer.MIN_VALUE); // MySQL驱动流式查询的触发条件 try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { // 逐行处理，内存占用稳定 } } }

这个点实训不需要做，但如果报告里能作为扩展知识点提到，再配合连接池的讲解，整个实训报告的深度就会拉开一个档次。

6. 实训报告的写作结构：照着搭就能拿高分

6.1 报告各章节怎么安排

实训报告的评分标准虽然各校不同，但核心逻辑是相通的，就是要看你是否真正理解了技术方案。我建议按下面这个结构组织内容：

核心代码实现这一段，只贴关键代码和注释，不要整个项目源码都塞进去。每一段代码前面写清楚这段代码要解决什么问题，后面写清楚运行效果。我评审报告时最反感的就是大段大段贴代码却不加解释。

6.2 报告里哪些内容能体现“我不仅会写，还懂原理”

实训报告想拿高分，光是写对还不够，要写出“为什么是这样”的理解。我总结几个很有效的加分位：

第一，在数据库设计部分，主动说明为什么把create_time字段设成DEFAULT CURRENT_TIMESTAMP，减少应用层的一次赋值操作。第二，在DAO设计部分，说明为什么用接口来定义数据访问契约，这样未来可以从StudentDaoImpl替换成MyBatis或JPA实现，而业务层不用变化。第三，在异常处理部分，说明为什么SQLException运行时需要被包装成RuntimeException抛出，因为受检异常会让业务层代码被try-catch淹没，而业务层不应该处理数据库层面的异常。

第四也是最容易被忽略的，放一个“项目目录结构”说明，展示你的代码是如何分包的：entity包放Javabean，dao包放接口，dao.impl包放实现，util包放工具类。一个清晰的包结构，比你在文档里写一百遍“我遵循分层设计”都有说服力。

7. 实训做完之后，JDBC的学习还差哪一步

实训报告交上去不代表这轮学习就结束了。JDBC是理解Java操作数据库的底层通道，在JDBC基础上再往上走，你会接触到连接池的更多实现、MyBatis这种ORM框架，以及Spring管理事务的方式。但不管框架怎么封装，最终落到数据库操作，还是走Connection、PreparedStatement、ResultSet这套核心链路。

如果你学有余力，我推荐实训后做两件事：一是把项目中的DAO层换成MyBatis实现，对比一下CRUD代码量从几十行降到几个注解之后的差异，感受框架解决的是哪一部分重复劳动；二是把连接池从Druid换成HikariCP，对比两者的配置参数差异，理解为什么HikariCP被Spring Boot选为默认连接池。理解了差异，才算真正理解了数据库访问这一层的设计逻辑。

这次实训做到最后，我自己最有感触的一个点是：JDBC写的CRUD本身并不复杂，复杂的是资源管理、事务边界和异常处理这些“看不见”的部分。实训的价值不在于完成一个可以运行的小项目，而在于让你第一次认真面对这些问题。把这些基础打扎实了，后面学MyBatis、学Spring的声明式事务都会轻松不少。