准备一：maven 工程 + 驱动依赖#

新建 maven 工程（工程坐标、pom.xml 的结构见 25 篇），在 pom.xml 的 <dependencies> 里加一段：

1
<dependency>
2
    <groupId>com.mysql</groupId>
3
    <artifactId>mysql-connector-j</artifactId>
4
    <version>8.0.33</version>
5
</dependency>

三个坐标的含义：

• com.mysql —— 提供者（MySQL 官方）；
• mysql-connector-j —— 驱动 jar 的名字（MySQL 8.x 的驱动即 Connector/J）；
• 8.0.33 —— 课件用的版本。

准备二：数据库表 user#

课程资料 01. JDBC-数据库表/user.txt 里给了建表和数据：

1
create table user(
2
    id int unsigned primary key auto_increment comment 'ID,主键',
3
    username varchar(20) comment '用户名',
4
    password varchar(32) comment '密码',
5
    name varchar(10) comment '姓名',
6
    age tinyint unsigned comment '年龄'
7
) comment '用户表';
8

9
insert into user(id, username, password, name, age) values (1, 'daqiao', '123456', '大乔', 22),
10
                                                           (2, 'xiaoqiao', '123456', '小乔', 18),
11
                                                           (3, 'diaochan', '123456', '貂蝉', 24),
12
                                                           (4, 'lvbu', '123456', '吕布', 28),
13
                                                           (5, 'zhaoyun', '12345678', '赵云', 27);

准备三：程序写在哪里#

课件把它写成一个 JUnit 测试方法：新建类 JdbcTest，要跑的那段代码放在 @Test 标注的方法里，点方法左边的绿色箭头运行（JUnit 的用法见 27 篇）。

1
public class JdbcTest {
2

3
    @Test
4
    public void testUpdate() throws Exception {
5
        // 这里写 JDBC 的代码
6
    }
7
}

用测试方法（而不是 main 方法）的好处：一个类里可以放好几个方法，一个一个跑（testUpdate 跑完再跑 testSelect），不用为了跑第二件事去改主方法。

第 1 步：注册驱动#

Class.forName(全限定类名) 是 Java 反射里”加载这个类”的写法。MySQL 的驱动类在被加载的时候，会执行它自己的静态代码块，把自己”登记”到 DriverManager 那里——这一步就是把驱动叫醒。

类名要写全：com.mysql.cj.jdbc.Driver。cj 是 Connector/J 的缩写，这是 MySQL 8.x 驱动的类名；老版本（5.x）的驱动类名是 com.mysql.jdbc.Driver，别混。

第 2 步：获取连接#

DriverManager 是 JDBC 提供的”驱动管理器”（它知道有哪些驱动被注册过），getConnection(url, username, password) 三个参数给全就能拿到一个连好的 Connection。

URL 就一串字符串，逐段拆开看：

第 3 步：获取 SQL 语句执行对象#

connection.createStatement() 返回一个 Statement 对象，它是”用来把 SQL 语句发给数据库”的东西。第 4 步要写的那句 SQL，就是交给它去执行的。

记住这个 Statement ——下一篇要讲它的一个致命缺点（把参数拼进 SQL 字符串里会出安全问题），解决方案是把这一步换成另一个对象。

第 4 步：执行 SQL#

1
int i = statement.executeUpdate("update user set age = 25 where id = 1");//DML

executeUpdate(String sql) 专门执行 DML（增删改），返回值是 int——这次执行影响的记录数。用一个 int i 接住它，就相当于跟数据库确认了一句”到底改了几行”：

• 条件写对了（id = 1 存在）→ 返回 1；
• 条件没命中（比如 id 写成了表里没有的 100）→ 返回 0（不报错，只是没改到任何行）；
• 一次改到多行（比如 where age > 20）→ 返回命中的行数。

第 5 步：释放资源#

1
statement.close();
2
connection.close();

顺序是后开先关：先关 Statement，再关 Connection。连接是很珍贵的资源（一台数据库的并发连接数是有限的、建连接也很慢），不用了必须还回去——连接池（53 篇）要解决的问题正是”别把连接漏掉”。

入门程序为了看清楚五步，close 是直接写在方法末尾的（中途出异常就漏掉了）。课件里紧接着的查询程序（testSelect）就换成了 try ... finally 的写法，保证无论出不出异常都会关——下一篇会带你看这个版本。

一、知识回顾（读完直接做下面的实践题）#

1. JDBC 全称与定义：Java DataBase Connectivity，就是使用 Java 语言操作关系型数据库的一套 API；它是 sun 公司官方定义的规范（接口）——配套的完整说法是”sun 定义一套操作所有关系型数据库的规范，即接口；各厂商去实现这套接口并提供数据库驱动 jar 包；我们使用这套接口编程，真正执行的代码是驱动 jar 中的实现类”
2. 各个角色的分工：sun 定标准（接口）、数据库厂商做实现（驱动 jar）、我们写代码（面向接口）；所以换数据库时只需要换驱动 jar 和一行 URL，JDBC 代码一行都不用改
3. 技术全景与学习范围：java 操作数据库有 JDBC、MyBatis、MyBatisPlus、SpringData JPA、Hibernate；PPT 的占比图里 MyBatis 46%、MyBatis-Plus 24.2%、Spring Data JPA 11.7%、Hibernate 7.3%；本课只学前两个（MyBatis 是持久层框架，用途是简化 JDBC）
4. 驱动依赖坐标：com.mysql : mysql-connector-j : 8.0.33（MySQL 8.x 的驱动即 Connector/J）；驱动类是 com.mysql.cj.jdbc.Driver（老版本 5.x 才是 com.mysql.jdbc.Driver）；本机 MySQL 是 9.0.1，用 8.0.33 的驱动照样跑通
5. 五步（必须背下来）：① 注册驱动 Class.forName("com.mysql.cj.jdbc.Driver")；② 获取连接 DriverManager.getConnection(url, username, password)；③ 获取 SQL 语句执行对象 connection.createStatement()；④ 执行 SQL statement.executeUpdate(sql)；⑤ 释放资源 statement.close(); connection.close();
6. URL 的每一段：jdbc:mysql://localhost:3306/web01 = 协议 jdbc: + 子协议 mysql + 主机 localhost + 端口 3306 + 数据库名 web01
7. DML 用哪个方法、返回什么：executeUpdate(String sql)，返回 int 影响记录数；命中 1 行返回 1、没命中返回 0（不报错）、命中多行返回多行
8. 实测输出原文：SQL执行完毕影响的记录数为: 1（执行的是 update user set age = 25 where id = 1；同一次测试 Tests run: 2, Failures: 0, Errors: 0；本机运行时连接对象的实现类是 com.mysql.cj.jdbc.ConnectionImpl）
9. 释放资源的顺序：后开先关——statement.close() 在前、connection.close() 在后；查询场景里 ResultSet 也要关（下一篇），课件查询程序用 try ... finally 保证一定关
10. PPT 第 8 页两个必答问答：什么是 JDBC → sun 公司提供的一套操作关系型数据库的 API（规范）；JDBC 操作数据库步骤 → 注册驱动、获取连接、获取 SQL 语句执行对象、执行 SQL、释放资源（DML 用 executeUpdate，DQL 用 executeQuery）

二、裸写题#

• 2-1 把 user 表里 id 为 1 的年龄改成 25 需求：写一个程序连上本机 MySQL 的 web01 库，把 user 表里 id 为 1 的那条记录的年龄改成 25，并在控制台打印出”这次改了几行”。 要求：按”连接数据库要做的五个动作”的顺序写，每一步用一行中文注释标出来；跑完把控制台输出抄到练习文件末尾的空位里，并回答两个问题：① 打印出来的这个数字代表什么？② 如果把条件里的 id 换成 100（表里没有这个 id），这个数字会变成多少、会不会报错？ （练习文件 test_49_JDBC五步.java 里给了题目注释、pom 依赖片段、表结构、运行方式和写作区。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：五个动作是固定顺序——把驱动”叫醒”、拿到连接、拿到一个能发 SQL 的东西、把 SQL 发出去接住返回值、最后把用过的都关掉 二级 · 方法：Class.forName("com.mysql.cj.jdbc.Driver") → DriverManager.getConnection(url, username, password) → connection.createStatement() → statement.executeUpdate(sql) → statement.close() + connection.close()；方法上用 JUnit 的 @Test 标注，方便单独跑 三级 · 骨架：Class.forName("____"); Connection conn = ____.____("jdbc:mysql://localhost:3306/web01", "root", "你自己的密码"); Statement st = conn.____(); int i = st.____("update user set age = 25 where id = 1"); System.out.println("____" + i); st.close(); conn.close();

  参考答案（做完再点开）

  1
  package com.itheima;
  2
  
  3
  import org.junit.jupiter.api.Test;
  4
  
  5
  import java.sql.Connection;
  6
  import java.sql.DriverManager;
  7
  import java.sql.Statement;
  8
  
  9
  public class JdbcUpdateTest {
  10
  
  11
      @Test
  12
      public void testUpdate() throws Exception {
  13
          //1. 注册驱动
  14
          Class.forName("com.mysql.cj.jdbc.Driver");
  15
  
  16
          //2. 获取数据库连接
  17
          String url = "jdbc:mysql://localhost:3306/web01";
  18
          String username = "root";
  19
          String password = "1234";   // 换成你自己 MySQL 的密码
  20
          Connection connection = DriverManager.getConnection(url, username, password);
  21
  
  22
          //3. 获取SQL语句执行对象
  23
          Statement statement = connection.createStatement();
  24
  
  25
          //4. 执行SQL（DML）
  26
          int i = statement.executeUpdate("update user set age = 25 where id = 1");
  27
          System.out.println("SQL执行完毕影响的记录数为: " + i);
  28
  
  29
          //5. 释放资源（后开先关）
  30
          statement.close();
  31
          connection.close();
  32
      }
  33
  }

  显示更多显示更少

  本机实测输出：SQL执行完毕影响的记录数为: 1。 两问两答：① 这个数字是 executeUpdate 的返回值——这条 SQL 影响的记录数，1 表示 id = 1 那一行被改动了（count 表示”改动了几行”，不是”成功还是失败”）；② 换成 id = 100 会输出 0，而且不会报错——条件没命中任何一行，SQL 本身执行成功了，只是没有数据被改。所以看到 0 时先怀疑”条件写错了/数据不在了”，而不是”程序坏了”。 顺便提醒：这条语句真的会改数据，跑完想恢复，用课程资料的 user.txt 重新导入一遍。

• 2-2 往 user 表里新增一个用户 需求：还是”五个动作”，这次执行一条新增语句，往 user 表里插一条记录——用户名 zhouyu、密码 123456、姓名 周瑜、年龄 20（id 是自增主键，不用管它）。 要求：把影响行数打印出来；跑完去客户端（DataGrip / 命令行）里 select 一下，确认这行真的进去了；然后回答三个问题：① 这条记录最终分到的 id 是多少？② 为什么不需要自己写 id？③ 这条语句的影响行数应该是多少？ （练习文件 test_49_新增用户.java 里给了题目注释和写作区。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：五个动作一个都不变，唯一要换的是”第 4 步那句 SQL”——insert 和 update 一样都是 DML，还是用同一个执行方法 二级 · 方法：SQL 写成 insert into user(username, password, name, age) values('zhouyu', '123456', '周瑜', 20)，还是 statement.executeUpdate(sql)；字段名后面的括号里只写要赋值的列 三级 · 骨架：int i = st.____("insert into user(username, password, name, age) values('____', '____', '____', ____)"); System.out.println("____" + i);

  参考答案（做完再点开）

  1
  package com.itheima;
  2
  
  3
  import org.junit.jupiter.api.Test;
  4
  
  5
  import java.sql.Connection;
  6
  import java.sql.DriverManager;
  7
  import java.sql.Statement;
  8
  
  9
  public class JdbcInsertTest {
  10
  
  11
      @Test
  12
      public void testInsert() throws Exception {
  13
          //1. 注册驱动
  14
          Class.forName("com.mysql.cj.jdbc.Driver");
  15
  
  16
          //2. 获取连接
  17
          Connection connection = DriverManager.getConnection(
  18
                  "jdbc:mysql://localhost:3306/web01", "root", "1234"); // 密码换成你自己的
  19
  
  20
          //3. 获取SQL语句执行对象
  21
          Statement statement = connection.createStatement();
  22
  
  23
          //4. 执行SQL（insert 也是 DML，还是用 executeUpdate）
  24
          int i = statement.executeUpdate(
  25
                  "insert into user(username, password, name, age) values('zhouyu', '123456', '周瑜', 20)");
  26
          System.out.println("SQL执行完毕影响的记录数为: " + i);
  27
  
  28
          //5. 释放资源
  29
          statement.close();
  30
          connection.close();
  31
      }
  32
  }

  显示更多显示更少

  输出：SQL执行完毕影响的记录数为: 1。三问三答： ① （第 1 问是”确认这行进去了”，select * from user where username = 'zhouyu'; 能查到就对了）； ② 因为 id 是 auto_increment（自增主键）——插入时不写它，数据库会自动分配一个（本机这张表原来的数据是 1~5，新插入的一般就是 6，具体以你查到的那一行为准）；insert 语句里也不能把自增列硬写成一个已经存在的 id（会撞主键）； ③ 插入一条记录，影响行数就是 1——insert 的返回值同样是”影响了几行”。 跑完记得清场：delete from user where username = 'zhouyu';（或者用 user.txt 重新导入把表恢复原样）。

• 2-3 找错：这段 JDBC 代码有 5 处问题 下面是同学交上来的代码，编译能过、跑起来却连不上也改不动。请指出每一处问题，并把它改写成能跑通的版本：

  1
  public class JdbcBrokenTest {
  2
  
  3
      @Test
  4
      public void testUpdate() throws Exception {
  5
          Class.forName("com.mysql.jdbc.Driver");
  6
          String url = "jdbc:mysql://localhost:3306";
  7
          Connection connection = DriverManager.getConnection(url, "root", "123456");
  8
          Statement statement = connection.prepareStatement("update user set age = 25 where id = 1");
  9
          ResultSet rs = statement.executeQuery("update user set age = 25 where id = 1");
  10
          statement.close();
  11
      }
  12
  }

  要求：把 5 处问题按行号/顺序写清”哪里错、错了会怎样”，再写出改好的完整方法。 （练习文件 test_49_找错.java 里给了题目注释和写作区。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：五处问题正好分布在”五个动作”里——注册驱动的类名、URL、拿执行对象的方法、执行 DML 的方法、最后的收尾 二级 · 方法：8.x 的驱动类是 com.mysql.cj.jdbc.Driver；URL 要带上库名 web01；拿普通执行对象用 connection.createStatement()（prepareStatement 是下一篇的预编译用法）；DML 用 executeUpdate（没有结果集可拿）；Connection 也要关 三级 · 骨架：Class.forName("com.mysql.____.jdbc.Driver"); String url = "jdbc:mysql://localhost:3306/____"; Statement statement = connection.____(); int i = statement.____("update user set age = 25 where id = 1"); statement.close(); connection.____();

  参考答案（做完再点开）

  五处问题：

  1. 驱动类名是 5.x 的老名字：com.mysql.jdbc.Driver 在 MySQL 8.x 的驱动里已经没有了（8.x 是 com.mysql.cj.jdbc.Driver），运行时会报 ClassNotFoundException；
  2. URL 少写了数据库名：jdbc:mysql://localhost:3306 只连到 MySQL 服务器、没指定库，后面的 SQL 里写 user 表就会报”表不存在”（要写 jdbc:mysql://localhost:3306/web01）；
  3. 第 3 步拿错了工具：connection.prepareStatement(...) 是预编译用的创建方式（SQL 要在创建时交进去、之后靠 setXxx 填参数），它返回的是 PreparedStatement；这里要的是”普通执行对象”，应该用 connection.createStatement()——两种对象是给两种写法配套的（预编译那一套在下一篇）；
  4. 第 4 步用错了方法：update 是 DML，要用 statement.executeUpdate(sql)（返回值是影响行数）；executeQuery 是给查询用的（返回结果集），DML 不该用它；
  5. 第 5 步漏了 connection.close()：Statement 关了、连接没关，连接就漏掉了（后开先关，两个都要关）。

  改好的版本：

  1
  public class JdbcBrokenTest {
  2
  
  3
      @Test
  4
      public void testUpdate() throws Exception {
  5
          //1. 注册驱动（8.x 的类名带 cj）
  6
          Class.forName("com.mysql.cj.jdbc.Driver");
  7
  
  8
          //2. 获取连接（URL 末尾要带库名 web01）
  9
          String url = "jdbc:mysql://localhost:3306/web01";
  10
          Connection connection = DriverManager.getConnection(url, "root", "1234"); // 密码换成你自己的
  11
  
  12
          //3. 获取SQL语句执行对象（普通执行对象用 createStatement）
  13
          Statement statement = connection.createStatement();
  14
  
  15
          //4. 执行SQL（DML 用 executeUpdate，接住影响行数）
  16
          int i = statement.executeUpdate("update user set age = 25 where id = 1");
  17
          System.out.println("SQL执行完毕影响的记录数为: " + i);
  18
  
  19
          //5. 释放资源（后开先关，两个都要关）
  20
          statement.close();
  21
          connection.close();
  22
      }
  23
  }

  显示更多显示更少

  一句话总结这五处：驱动类名要对（cj）、URL 要带库名、普通执行对象用 createStatement（不是 prepareStatement）、DML 用 executeUpdate、连接一定要关。

三、综合题#

• 3-1 从零跑通第一个 JDBC 程序（照课程做一遍） 把 PPT 第 7 页那两段”准备工作 + 代码实现”从头到尾走一遍，每一步都留下记录：

  1. 建 maven 工程：新建工程，在 pom.xml 里加上 MySQL 驱动依赖（com.mysql 的 mysql-connector-j，版本 8.0.33）和 JUnit 依赖；
  2. 准备数据库表：用课程资料的建表语句在 web01 库里建 user 表，并插入那 5 条数据（也可以直接跑 user.txt 里的全部 SQL）；
  3. 准备实体类：写一个 User 类，属性 id / username / password / name / age（后面查询要用它装数据，这一步先把类建好就行）；
  4. 写第一个测试方法：按五个动作执行 update user set age = 25 where id = 1，把影响行数打印出来；
  5. 跑一次：把控制台输出原样抄到练习文件末尾的空位里；
  6. 跑第二次做对照：把条件改成 id = 100（表里没有这个 id）再跑一次，记下影响行数，并解释为什么这次没有报错；
  7. 回去验证数据：在客户端里执行 select * from user where id = 1;，确认年龄真的变成了 25，把查到的这一行抄下来；
  8. 收尾回答：这五个动作里，哪一步是”真正把 SQL 送到数据库去”的那一步？剩下那几步分别在干什么？如果做的是查询（DQL），哪一步要换、换成什么？ （练习文件 test_49_综合_跑通第一个程序.java 里按这 8 步给了写作区。）

  涉及知识点

  知识点	在这里的应用
  驱动依赖	第 1 步——com.mysql:mysql-connector-j:8.0.33
  数据库与建表	第 2 步——web01.user 的建表语句 + 5 条数据
  实体类	第 3 步——User 的属性要和表字段对得上
  五步流程	第 4 步——注册驱动、获取连接、获取执行对象、执行 SQL、释放资源
  executeUpdate 的返回值	第 5、6 步——命中 1 行是 1、没命中是 0（不报错）
  数据验证	第 7 步——用 select 回头确认改动的结果
  DML 与 DQL 的区别	第 8 步——DML 用 executeUpdate，DQL 要换成 executeQuery（下一篇）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：这一题就是把”准备工作两件 + 代码五步”照顺序落地；第 6 步和第 7 步是”自己给自己找证据”——同一个程序跑两次、再去库里看一眼，比只看控制台更有说服力 二级 · 方法：pom 里写 mysql-connector-j 8.0.33；测试方法用 @Test；五步用 Class.forName / DriverManager.getConnection / createStatement / executeUpdate / close；验证用 select * from user where id = 1; 三级 · 骨架：第 4 步 int i = statement.____("update user set age = ____ where id = 1");；第 6 步把 id = 1 改成 id = ____；第 7 步 select * from ____ where id = 1;

  参考答案（做完再点开）

  1~4 步 的成品（工程坐标、pom 依赖、建表语句见上面正文里贴过的课程原文）：

  1
  <!-- pom.xml 里要加的依赖 -->
  2
  <dependency>
  3
      <groupId>com.mysql</groupId>
  4
      <artifactId>mysql-connector-j</artifactId>
  5
      <version>8.0.33</version>
  6
  </dependency>

  1
  // User 实体类（课程用 lombok 的 @Data 自动生成 getter/setter/toString）
  2
  package com.itheima.pojo;
  3
  
  4
  import lombok.AllArgsConstructor;
  5
  import lombok.Data;
  6
  import lombok.NoArgsConstructor;
  7
  
  8
  @Data
  9
  @AllArgsConstructor
  10
  @NoArgsConstructor
  11
  public class User {
  12
      private Integer id;
  13
      private String username;
  14
      private String password;
  15
      private String name;
  16
      private Integer age;
  17
  }

  显示更多显示更少

  1
  package com.itheima;
  2
  
  3
  import org.junit.jupiter.api.Test;
  4
  
  5
  import java.sql.Connection;
  6
  import java.sql.DriverManager;
  7
  import java.sql.Statement;
  8
  
  9
  public class JdbcLabTest {
  10
  
  11
      @Test
  12
      public void testUpdate() throws Exception {
  13
          //1. 注册驱动
  14
          Class.forName("com.mysql.cj.jdbc.Driver");
  15
          //2. 获取连接
  16
          Connection connection = DriverManager.getConnection(
  17
                  "jdbc:mysql://localhost:3306/web01", "root", "1234"); // 密码换成你自己的
  18
          //3. 获取SQL语句执行对象
  19
          Statement statement = connection.createStatement();
  20
          //4. 执行SQL
  21
          int i = statement.executeUpdate("update user set age = 25 where id = 1");
  22
          System.out.println("SQL执行完毕影响的记录数为: " + i);
  23
          //5. 释放资源
  24
          statement.close();
  25
          connection.close();
  26
      }
  27
  }

  显示更多显示更少

  5. 本机实测第 5 步的输出：SQL执行完毕影响的记录数为: 1；
  6. 把条件换成 where id = 100 之后输出 SQL执行完毕影响的记录数为: 0——没有报错。因为这条 SQL 本身是合法且执行成功的，只是表里没有 id = 100 这行，一行都没被改动，所以影响行数是 0。0 是”条件没命中”，不是”程序出错”，这正是排查”数据怎么没变”时的第一线索；
  7. select * from user where id = 1; 查到的这一行应该是 1, daqiao, 123456, 大乔, 25——年龄从 22 变成了 25，说明改动真的落到库里了（想恢复就重新导入 user.txt）；
  8. 五步里第 4 步（statement.executeUpdate）才是把 SQL 送到数据库去执行的那一步：第 1 步是把驱动加载进来（让 DriverManager 认识 MySQL 驱动），第 2 步是建立连接（连到哪个库、用哪个账号），第 3 步是拿到一个”能发 SQL 的东西”，第 5 步是把用掉的资源还回去。如果做的是查询（DQL），第 4 步要换成 executeQuery——它返回的不是影响行数，而是一个结果集对象，还得把里面的数据一行行取出来，这就是下一篇要干的事。