直接把用户输入拼进 SQL，会出什么事#

用 Statement 拼字符串的写法通常是这样的：

1
// 危险写法：把参数直接拼进 SQL
2
String sql = "select id, username, password, name, age from user " +
3
             "where username = '" + username + "' and password = '" + password + "'";
4
ResultSet rs = statement.executeQuery(sql);

正常输入（daqiao / 123456）看上去一切正常。但如果有人在用户名和密码里都填：

1
' or '1'='1

拼出来的 SQL 就变成了另一条语句——本机实测的对照结果如下。

1
实际执行的 SQL：select id, username, password, name, age from user where username = '' or '1'='1' and password = '' or '1'='1'
2
  查到：1 daqiao 大乔 22
3
  查到：2 xiaoqiao 小乔 18
4
  查到：3 diaochan 貂蝉 24
5
  查到：4 lvbu 吕布 28
6
  查到：5 zhaoyun 赵云 27
7
共 5 行

1
实际执行的 SQL：select ... where username = ? and password = ? （参数：username=' or '1'='1 , password=' or '1'='1）
2
共 0 行

拼字符串为什么会被打穿#

关键在那条被拼出来的 SQL 上：

1
select id, username, password, name, age from user
2
where username = '' or '1'='1' and password = '' or '1'='1'

输入的 ' or '1'='1 里的第一个单引号，把原来那个字符串提前结束了——本来 username = ' 后面的内容是要填”用户名的值”的，结果提前收尾，or '1'='1' 就跑出来变成了语法的一部分。

再把这段条件按优先级拆开（SQL 里 and 的优先级高于 or）：

用 or 连起来：只要有一段为真，整条条件就为真——第三段 '1'='1' 永远为真，所以每一行都符合条件，5 条全被查出来。

预编译为什么能防住#

预编译的写法里，SQL 从一开始就是带 ? 的形状：

1
PreparedStatement pstmt = conn.prepareStatement(
2
        "select id, username, password, name, age from user where username = ? and password = ?");
3
pstmt.setString(1, "' or '1'='1");
4
pstmt.setString(2, "' or '1'='1");
5
ResultSet rs = pstmt.executeQuery();

区别在于：这条语句在”编译”的时候，结构就已经定死了——? 的位置在数据库眼里”只能是一个值”，不是”一段可以当语法解析的文本”。 所以 setString 给进去的 ' or '1'='1 只会被当成一个普通的字符串值（就是”用户名等于这个奇怪字符串的人”），表里没有这样的用户 → 查出 0 行。

一句话记住这个区别：

静态 SQL 里，参数是”SQL 的一部分”；预编译 SQL 里，参数是”值”。

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

1. 查询和增删改在第 4 步的分岔：DML 用 executeUpdate(sql)（返回 int 影响行数）；DQL 用 executeQuery(sql)（返回 ResultSet 结果集对象）
2. next() 的作用：把光标从当前位置向前移动一行，并判断当前行是否为有效行，返回值 boolean——true 是有效行（当前行有数据）、false 是无效行；所以配 while (resultSet.next()) 能一行行读完
3. getXxx() 的作用与取值方式：获取字段数据，可以按列的编号（从 1 开始）取，也可以按列名取，推荐列名（可读、表的列顺序变了也不受影响）
4. 解析结果集的完整写法：while (resultSet.next()) { int id = resultSet.getInt("id"); String username = resultSet.getString("username"); … User user = new User(id, username, password, name, age); System.out.println(user); }——注意类型要对（整数列 getInt、字符串列 getString）
5. 实测查询输出：User(id=1, username=daqiao, password=123456, name=大乔, age=22)（lombok 的 @Data 自动生成的 toString）
6. PPT 第 10 页两问：DML 语句 → int rowsAffected = statement.executeUpdate();；DQL 语句 → ResultSet rs = statement.executeQuery();；结果集解析 → resultSet.next()（光标往下移动一行）+ resultSet.getXxx()（获取字段数据）
7. 资源释放：查询版要多关一个 ResultSet，顺序是 rs → statement → connection（后开先关）；课程用 try ... finally，三个对象先声明为 null、finally 里判断非空再关
8. 两种 SQL 的写法对照：静态 SQL 用 connection.createStatement()，参数硬编码/拼进字符串，执行时还要传 SQL；预编译 SQL 用 connection.prepareStatement(sql)，SQL 里用 ? 占位符，用 setXxx(序号, 值) 给参数（序号从 1 开始、类型要匹配、个数要对齐），执行时不用再传 SQL
9. SQL 注入的定义与实测：通过控制输入来修改事先定义好的 SQL 语句，以达到执行代码对服务器进行攻击的方法；实测同样输入 ' or '1'='1——拼接写法查出 5 行（密码错误却全表被查出，登录绕过）、预编译写法 0 行、正常登录（daqiao/123456）两种写法都是 1 行
10. 预编译的两大优势与原因：安全——语句结构已定死，? 只能填”一个值”，参数里的引号/or 不会变成语法（参数是”值”，不是”SQL 的一部分”）；性能更高——静态 SQL 每次都是新语句（三条 delete 要编译 3 次），预编译 SQL 结构固定只编译 1 次、结果可缓存复用（前提是同一条 SQL 被重复执行）

二、裸写题#

• 2-1 查出 daqiao 的信息，封装成 User 对象打印 需求：写一个程序连上 web01 库，把 user 表里用户名是 daqiao、密码是 123456 的那条记录查出来，封装成一个对象并打印到控制台（打印出来应该是一行 User(...) 的样子）。 要求：查出来的每一个字段都要按列名取值；方法里最后把三个资源都关掉；写完后在文件末尾回答：① 为什么这里取值推荐用列名而不是列号？② 这条 SQL 最终只查到了几行，while 循环里的代码执行了几次？ （练习文件 test_50_查询封装User.java 里给了题目注释、表结构、User 实体类和写作区。）

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

  一级 · 思路：五步不变，只有第 4 步换成”查询 + 解析”——先拿到结果集，再让光标往下走一行、把这一行的值一格一格取出来装进对象 二级 · 方法：statement.executeQuery(sql) 返回 ResultSet；用 resultSet.next() 判断有没有数据，用 resultSet.getInt("id") / resultSet.getString("username") 取字段；最后 rs.close()、statement.close()、connection.close()（仍然可以先用 Statement + SQL 里写死参数，下一题再换预编译） 三级 · 骨架：ResultSet rs = statement.____("select id, username, password, name, age from user where username = 'daqiao' and password = '123456'"); while (rs.____()) { User user = new User(rs.____("id"), rs.____("username"), rs.____("password"), rs.____("name"), rs.____("age")); System.out.println(user); }

  参考答案（做完再点开）

  1
  package com.itheima;
  2
  
  3
  import com.itheima.pojo.User;
  4
  import org.junit.jupiter.api.Test;
  5
  
  6
  import java.sql.*;
  7
  
  8
  public class JdbcQueryTest {
  9
  
  10
      @Test
  11
      public void testSelect() throws Exception {
  12
          //1. 注册驱动
  13
          Class.forName("com.mysql.cj.jdbc.Driver");
  14
          //2. 获取连接
  15
          Connection conn = DriverManager.getConnection(
  16
                  "jdbc:mysql://localhost:3306/web01", "root", "1234"); // 密码换成你自己的
  17
          //3. 获取SQL语句执行对象
  18
          Statement statement = conn.createStatement();
  19
          //4. 执行SQL（DQL：executeQuery 返回结果集）
  20
          ResultSet rs = statement.executeQuery(
  21
                  "select id, username, password, name, age from user where username = 'daqiao' and password = '123456'");
  22
          //5. 解析结果集：先 next() 往下走一行，再按列名取值封装
  23
          while (rs.next()) {
  24
              User user = new User(
  25
                      rs.getInt("id"),
  26
                      rs.getString("username"),
  27
                      rs.getString("password"),
  28
                      rs.getString("name"),
  29
                      rs.getInt("age"));
  30
              System.out.println(user);
  31
          }
  32
          //6. 释放资源（后开先关）
  33
          rs.close();
  34
          statement.close();
  35
          conn.close();
  36
      }
  37
  }

  显示更多显示更少

  本机实测控制台输出：

  1
  User(id=1, username=daqiao, password=123456, name=大乔, age=22)

  两问两答：① 按列名取值可读性最好，而且抗改动——表的列顺序调整了、或者中间插了新列，列名不用改；用列号则要重新数一遍（而且列号从 1 开始，很容易数错一格）；② 条件命中 1 行，所以 while 里的代码执行了 1 次，打印出 1 行 User(...)；如果没有命中的行，next() 第一次就返回 false，循环体一次都不会执行（不报错）。

• 2-2 把符合条件的多行都查出来，装成一个集合打印 需求：查出 user 表里年龄大于 20 的所有用户，把每一条都封装成对象、放进一个集合里，最后把集合打印出来。 要求：用循环解析结果集（不要只取第一行）；打印时能看出集合里有几条数据；跑完回答：如果一条都没查到，这个集合里应该是什么？ （练习文件 test_50_查询用户列表.java 里给了题目注释、表结构、User 实体类和写作区。）

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

  一级 · 思路：和上一题的差别就在”要装的不止一个对象”——所以要准备一个能装多个对象的容器，每读到一行就往里放一个 二级 · 方法：List<User> userList = new ArrayList<>();，循环里 userList.add(user)；结果集还是 while (resultSet.next()) 一行行读；条件写在 SQL 的 where age > 20 里 三级 · 骨架：List<User> userList = new ____<>(); ResultSet rs = statement.____("select * from user where age > 20"); while (rs.next()) { User user = new User(…); userList.____(user); } System.out.println(userList); System.out.println("共 " + userList.size() + " 条");

  参考答案（做完再点开）

  1
  package com.itheima;
  2
  
  3
  import com.itheima.pojo.User;
  4
  import org.junit.jupiter.api.Test;
  5
  
  6
  import java.sql.*;
  7
  import java.util.ArrayList;
  8
  import java.util.List;
  9
  
  10
  public class JdbcQueryListTest {
  11
  
  12
      @Test
  13
      public void testSelectList() throws Exception {
  14
          Class.forName("com.mysql.cj.jdbc.Driver");
  15
          Connection conn = DriverManager.getConnection(
  16
                  "jdbc:mysql://localhost:3306/web01", "root", "1234"); // 密码换成你自己的
  17
          Statement statement = conn.createStatement();
  18
  
  19
          // 查询：年龄大于 20 的用户
  20
          ResultSet rs = statement.executeQuery("select id, username, password, name, age from user where age > 20");
  21
  
  22
          // 每读到一行就封装一个对象，放进集合
  23
          List<User> userList = new ArrayList<>();
  24
          while (rs.next()) {
  25
              userList.add(new User(
  26
                      rs.getInt("id"),
  27
                      rs.getString("username"),
  28
                      rs.getString("password"),
  29
                      rs.getString("name"),
  30
                      rs.getInt("age")));
  31
          }
  32
          System.out.println(userList);
  33
          System.out.println("共 " + userList.size() + " 条");
  34
  
  35
          rs.close();
  36
          statement.close();
  37
          conn.close();
  38
      }
  39
  }

  显示更多显示更少

  按课程资料 user.txt 那张表的数据算一遍：5 条里年龄大于 20 的是 daqiao(22)、diaochan(24)、lvbu(28)、zhaoyun(27)，所以会输出 4 个 User(...) 和一句 共 4 条——循环体执行了 4 次。 第三问的答案：集合是一个空集合（size() 为 0），打印出来是 []——没查到数据是正常情况，不是错误；要判断”有没有查到”，看 userList.isEmpty() 或 size() 就行，千万别拿 null 当”没查到”（空集合和 null 是两件事）。

• 2-3 把一个能被人钻空子的登录查询改成预编译 下面这段代码是某个登录功能的核心：用户在登录页填的帐号密码，被直接拼进了 SQL。请把它改成预编译写法，并在文件末尾回答：① 攻击者填 ' or '1'='1 时，原来的写法为什么会把整张表都查出来？② 改完之后同样的输入为什么查不到东西？

  1
  // 原来的写法（危险）
  2
  String username = "daqiao";      // 实际上来自登录页的输入
  3
  String password = "123456";      // 实际上来自登录页的输入
  4
  String sql = "select id, username, password, name, age from user where username = '" + username + "' and password = '" + password + "'";
  5
  Statement statement = connection.createStatement();
  6
  ResultSet rs = statement.executeQuery(sql);

  要求：参数位置一个都不许再拼字符串；setXxx 的序号和类型都写对；执行时不再传 SQL。 （练习文件 test_50_预编译查询.java 里给了题目注释和写作区。）

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

  一级 · 思路：把”会变的两个值”从 SQL 里拿出去，SQL 里给它们留两个空位；值改从”填空”的方式给进去 二级 · 方法：connection.prepareStatement("… = ? and … = ?")；两个参数用 setString(1, username)、setString(2, password)（从 1 开始）；执行用 pstmt.executeQuery()（不传 SQL） 三级 · 骨架：PreparedStatement pstmt = conn.____("select id, username, password, name, age from user where username = ? and password = ?"); pstmt.____(1, username); pstmt.____(2, password); ResultSet rs = pstmt.____();

  参考答案（做完再点开）

  1
  // 改完：预编译写法
  2
  String sql = "select id, username, password, name, age from user where username = ? and password = ?";
  3
  PreparedStatement pstmt = conn.prepareStatement(sql);
  4
  pstmt.setString(1, username);   // 第 1 个 ? —— 序号从 1 开始
  5
  pstmt.setString(2, password);   // 第 2 个 ?
  6
  ResultSet rs = pstmt.executeQuery();   // 注意：不用再传 SQL

  两问两答： ① 原来的写法把用户输入当成 SQL 文本的一部分——' or '1'='1 里开头的单引号把用户名那个字符串提前闭合，后面的 or '1'='1' 就变成了真正的 SQL 语法。本机实测这条拼出来的 SQL 是 … where username = '' or '1'='1' and password = '' or '1'='1'：and 比 or 先算，条件被切成三段，最后一段 '1'='1' 恒为真，用 or 连起来整条条件就恒真——5 行全被查出来，密码填错也能”登录成功”。 ② 预编译时 SQL 的结构（哪里是列、哪里是值）已经定死，? 的位置只能填”一个值”。setString 把 ' or '1'='1 当作普通的字符串值传进去（它就是”用户名等于这串字符的人”），表里没有这样的用户名 → 查出 0 行。一句话：静态 SQL 里参数是”SQL 的一部分”，预编译 SQL 里参数是”值”。

• 2-4 找错：这份预编译代码写不对 同学想用预编译查 daqiao 的登录信息，代码如下。请指出每一处问题并给出改正后的写法：

  1
  PreparedStatement pstmt = connection.prepareStatement("select * from user where username = ? and password = ?");
  2
  pstmt.setString(0, "daqiao");
  3
  pstmt.setInt(2, 123456);
  4
  ResultSet rs = pstmt.executeUpdate();

  要求：把每处问题的”哪里错、会发生什么”写清楚，再写出改好的完整代码（连资源释放一起写）。 （练习文件 test_50_预编译排错.java 里给了题目注释和写作区。）

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

  一级 · 思路：从”序号、类型、执行方法、收尾”四个角度逐个检查——预编译的坑几乎都在这四处 二级 · 方法：setXxx 的序号从 1 开始（第 1 个 ? 是 1）；参数是字符串就用 setString（密码列是 varchar，写 123456 也要当字符串）；查询要用 executeQuery() 拿结果集（executeUpdate() 是给 DML 用的）；PreparedStatement、ResultSet、Connection 都要关 三级 · 骨架：pstmt.____(1, "daqiao"); pstmt.____(2, "123456"); ResultSet rs = pstmt.____(); … rs.close(); pstmt.close(); connection.close();

  参考答案（做完再点开）

  四处问题：

  1. 序号从 0 开始写了：pstmt.setString(0, …) 是错的——? 的序号从 1 开始，第 1 个 ? 要写 setString(1, …)；写 0 运行时会报”参数索引超出范围”这类错误；
  2. 类型给错了：密码列是 varchar(32)（字符串），要用 setString(2, "123456")；setInt(2, 123456) 既把序号跳到了 2（第 1 个 ? 没赋值），又给了个数字类型，执行时不是报错就是查不到；
  3. 执行方法用错了：查询（DQL）要用 executeQuery() 拿 ResultSet；executeUpdate() 是给增删改用的（返回影响行数），用它接 ResultSet 直接编译不过；
  4. 资源没关：ResultSet、PreparedStatement、Connection 三个都没关（后开先关）。

  改好的完整代码：

  1
  package com.itheima;
  2
  
  3
  import org.junit.jupiter.api.Test;
  4
  
  5
  import java.sql.*;
  6
  
  7
  public class JdbcPreparedTest {
  8
  
  9
      @Test
  10
      public void testPrepared() throws Exception {
  11
          Class.forName("com.mysql.cj.jdbc.Driver");
  12
          Connection connection = DriverManager.getConnection(
  13
                  "jdbc:mysql://localhost:3306/web01", "root", "1234"); // 密码换成你自己的
  14
  
  15
          // SQL 里只用 ? 占位，参数不拼字符串
  16
          String sql = "select id, username, password, name, age from user where username = ? and password = ?";
  17
          PreparedStatement pstmt = connection.prepareStatement(sql);
  18
  
  19
          pstmt.setString(1, "daqiao");    // 第 1 个 ?（序号从 1 开始）
  20
          pstmt.setString(2, "123456");    // 第 2 个 ?（字符串列用 setString）
  21
  
  22
          ResultSet rs = pstmt.executeQuery();   // 查询用 executeQuery
  23
          while (rs.next()) {
  24
              System.out.println(rs.getInt("id") + " " + rs.getString("username")
  25
                      + " " + rs.getString("name") + " " + rs.getInt("age"));
  26
          }
  27
  
  28
          // 资源释放：后开先关
  29
          rs.close();
  30
          pstmt.close();
  31
          connection.close();
  32
      }
  33
  }

  显示更多显示更少

  本机实测输出：1 daqiao 大乔 22（正常登录那种情况，两种写法都是这一行）。 记一条口诀：序号从 1、类型要对、查询用 executeQuery、三个资源都要关。

三、综合题#

• 3-1 亲手把 SQL 注入实验做一遍（两种写法对照） 这是这一节最有说服力的一次实验：同一个登录查询，分别用”拼字符串”和”预编译”两种写法跑，输入同一段攻击字符串，对比结果。

  1. 准备：写一个测试类，写好一个”连接数据库”的公共方法（或者像本机实测那样写成两个私有方法，一个 Statement 版、一个 PreparedStatement 版），都针对 web01.user 表做登录查询 select id, username, password, name, age from user where username = ? and password = ? 这件事；
  2. 跑正常登录：输入 daqiao / 123456，两种写法各跑一次，记下各自查到几行；
  3. 跑攻击输入：输入都改成 ' or '1'='1，再各跑一次——在拼接写法里把拼出来的 SQL 也打印出来（这是理解漏洞的关键），记下各自查到几行、查到了哪些记录；
  4. 解释漏洞：对着第 3 步打印出来的 SQL，说明那段输入是怎么”改写”成 SQL 语法的一部分的（提示：注意单引号的位置，以及 and 和 or 谁先算）；
  5. 解释防线：说明预编译写法为什么同样的输入查不到东西（提示：? 的位置只能是什么）；
  6. 收尾回答：这次实验里，哪一条写法的输出说明”密码错了也能登录成功”？如果以后你觉得”这个参数反正不会有人乱填”，请用这次实验的结果反驳一下自己；
  7. 拓展记账：把预编译的两大优势各写一句话（安全、性能），并说明”性能更高”成立的前提是什么。 （练习文件 test_50_综合_SQL注入实验.java 里按上面的步骤给了写作区。）

  涉及知识点

  知识点	在这里的应用
  五步流程	第 1 步——两种写法都要注册驱动、获取连接、关资源
  executeQuery + ResultSet	第 1～3 步——每查到一行都封装成对象并打印
  静态 SQL 拼接	第 2、3 步——把参数拼进 SQL 字符串（要能看见拼好的 SQL）
  SQL 注入	第 3、4 步——' or '1'='1 让条件恒真，5 行全被查出
  预编译 SQL	第 3、5 步——? 占位符 + setXxx，同样输入查出 0 行
  运算符优先级	第 4 步——and 先算、or 后算，所以整条条件为真
  两大优势	第 7 步——安全（防注入）+ 性能更高（结构编译 1 次可复用）

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

  一级 · 思路：这一题不比写代码，比”设计对照实验”——同一张表、同一条查询、同一个输入，只让”写法”这一个变量不同；抓证据的方式是把实际执行的 SQL 打印出来 二级 · 方法：拼接版 String sql = "… where username = '" + username + "' and password = '" + password + "'"; 再 statement.executeQuery(sql)；预编译版 connection.prepareStatement("… = ? and … = ?") + 两次 setString；两种写法各自记行数 三级 · 骨架：queryByStatement("' or '1'='1", "' or '1'='1"); / queryByPrepared("' or '1'='1", "' or '1'='1");，每个方法里 while (rs.next()) { rows++; … } 最后打印 共 X 行

  参考答案（做完再点开）

  参考实现（本机实测就是照这个思路跑的）：两个方法都接收 username / password 参数，一个用 Statement 拼接、一个用 PreparedStatement 预编译，各自统计行数并打印。

  1
  package com.itheima;
  2
  
  3
  import java.sql.*;
  4
  
  5
  public class InjectionTest {
  6
  
  7
      private static final String URL = "jdbc:mysql://localhost:3306/web01";
  8
      private static final String USER = "root";
  9
      private static final String PASSWORD = "1234";   // 换成你自己 MySQL 的密码
  10
  
  11
      // 写法一：Statement 拼接（有漏洞）
  12
      private void queryByStatement(String username, String password) throws Exception {
  13
          Class.forName("com.mysql.cj.jdbc.Driver");
  14
          try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
  15
               Statement stmt = conn.createStatement()) {
  16
              String sql = "select id, username, password, name, age from user where username = '"
  17
                      + username + "' and password = '" + password + "'";
  18
              System.out.println("实际执行的 SQL：" + sql);
  19
              ResultSet rs = stmt.executeQuery(sql);
  20
              int rows = 0;
  21
              while (rs.next()) {
  22
                  rows++;
  23
                  System.out.println("  查到：" + rs.getInt("id") + " " + rs.getString("username")
  24
                          + " " + rs.getString("name") + " " + rs.getInt("age"));
  25
              }
  26
              System.out.println("共 " + rows + " 行");
  27
              rs.close();
  28
          }
  29
      }
  30
  
  31
      // 写法二：PreparedStatement 预编译（防住）
  32
      private void queryByPrepared(String username, String password) throws Exception {
  33
          Class.forName("com.mysql.cj.jdbc.Driver");
  34
          try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
  35
               PreparedStatement pstmt = conn.prepareStatement(
  36
                       "select id, username, password, name, age from user where username = ? and password = ?")) {
  37
              pstmt.setString(1, username);
  38
              pstmt.setString(2, password);
  39
              System.out.println("实际执行的 SQL：select ... where username = ? and password = ? （参数：username="
  40
                      + username + " , password=" + password + "）");
  41
              ResultSet rs = pstmt.executeQuery();
  42
              int rows = 0;
  43
              while (rs.next()) {
  44
                  rows++;
  45
                  System.out.println("  查到：" + rs.getInt("id") + " " + rs.getString("username")
  46
                          + " " + rs.getString("name") + " " + rs.getInt("age"));
  47
              }
  48
              System.out.println("共 " + rows + " 行");
  49
              rs.close();
  50
          }
  51
      }
  52
  }

  显示更多显示更少

  2~3. 本机实测结果（用户本机 MySQL 9.0.1，库 web01、表 user）：

  • 正常登录（daqiao / 123456）：拼接写法 1 行、预编译写法 1 行（输出 1 daqiao 大乔 22）；
  • 攻击输入（两边都填 ' or '1'='1）：

    1
    # Statement 拼接
    2
    实际执行的 SQL：select id, username, password, name, age from user where username = '' or '1'='1' and password = '' or '1'='1'
    3
      查到：1 daqiao 大乔 22
    4
      查到：2 xiaoqiao 小乔 18
    5
      查到：3 diaochan 貂蝉 24
    6
      查到：4 lvbu 吕布 28
    7
      查到：5 zhaoyun 赵云 27
    8
    共 5 行
    9
    
    10
    # PreparedStatement 预编译
    11
    实际执行的 SQL：select ... where username = ? and password = ? （参数：username=' or '1'='1 , password=' or '1'='1）
    12
    共 0 行

  4. 漏洞解释：输入的 ' or '1'='1 开头的单引号把 username = ' 这个字符串提前闭合，后面的 or '1'='1' 脱离了”值”的身份、变成真正的 SQL 语法。拼出来的条件是 username = '' or '1'='1' and password = '' or '1'='1'——按优先级先算 and，条件被切成三段（username = ''、'1'='1' and password = ''、'1'='1'），最后一段恒为真，再用 or 一连，整条条件恒真 → 每一行都符合条件，5 行全被查出来。
  5. 防线解释：预编译把语句结构固定死了——? 的位置只能填”一个值”，驱动把参数当纯字符串值交给数据库，即使值里带着引号和 or，也只是这个字符串的字符，不会升级成语法。所以 ' or '1'='1 被当成”用户名等于这一串字符”，表里没有 → 0 行。
  6. 第 5 条输出（共 5 行 那一次）就是”密码是错的，却把 5 条全查出来”——也就是密码校验被整个跳过了。所以”参数是内部用的、不会有人乱填”这种想法站不住脚：只要有一个输入口通向 SQL 字符串，那个口子就是入口。
  7. 两大优势各一句话：安全——预编译的参数只能当”值”，从根上堵住 SQL 注入；性能更高——预编译 SQL 的语句结构只需要编译一次、编译结果可缓存复用，而同一条语句如果用拼接写法，参数一变就是一条”新语句”，每次都要重新解析、优化、编译（PPT 那三条 delete：3 次 vs 1 次）。性能优势的前提是”同一条 SQL 被反复执行”（参数不同），项目里一条 SQL 被大量请求复用正是常态。