【JavaWeb】JDBC快速入门

川长思鸟来 2024-04-26 03:22 74阅读 0赞

> ?一个人走得远了，就会忘记自己为了什么而出发，希望你可以不忘初心，不要随波逐流，一直走下去?  
> ? 欢迎关注?点赞?收藏?留言?  
> ? 本文由 [程序喵正在路上][Link 1] 原创，CSDN首发！  
> ? 系列专栏：[?JavaWeb从入门到实战][JavaWeb]  
> ? 首发时间：2022年8月24日  
> ✅ 如果觉得博主的文章还不错的话，希望小伙伴们三连支持一下哦

#### 阅读指南 ####

*  一、JDBC学习目标
 *  二、JDBC概述
 *   *  1 - JDBC的概念
     *  2 - JDBC的本质
     *  3 - JDBC的优点
 *  三、JDBC快速上手
 *   *  1 - 编写代码步骤
     *  2 - 具体操作
     *  3 - JDBC API详解
     *   *  (1) DriverManager
         *  (2) Connection
         *  (3) Statement
         *  (4) ResultSet
         *  (5) 案例
         *  (6) PreparedStatement

## 一、JDBC学习目标 ##

*  掌握 **JDBC** 的的 **CRUD**
 *  理解 **JDBC** 中各个对象的作用
 *  掌握 **Druid** 的使用

## 二、JDBC概述 ##

在开发中，我们使用的是 **Java** 语言，那么势必要通过 **Java** 语言操作数据库中的数据，这就是我们接下来要学习的 **JDBC**

### 1 - JDBC的概念 ###

**JDBC** (**Java DataBase Connectivity**)，中文为 **Java** 数据库连接，就是使用 **Java** 语言操作关系型数据库的一套 **API**

![在这里插入图片描述][9ebe6ef6536d4e96aaa90532a85fdf70.png]

我们开发的同一套 **Java** 代码是无法操作不同的关系型数据库，因为每一个关系型数据库的底层实现细节都不一样。如果这样，问题就很大了，在公司中可以在开发阶段使用的是 **MySQL** 数据库，而上线时公司最终选用 **Oracle** 数据库，我们就需要对代码进行大批量修改，这显然并不是我们想看到的

我们要做到的是同一套 **Java** 代码操作不同的关系型数据库，所以 **sun** 公司就指定了一套标准接口（**JDBC**），**JDBC** 中定义了所有操作关系型数据库的规则。众所周知，接口是无法直接使用的，我们需要使用接口的实现类，而这套实现类（称之为：驱动）就由各自的数据库厂商给出

### 2 - JDBC的本质 ###

*  官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口
 *  各个数据库厂商去实现这套接口，提供数据库驱动jar包
 *  我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类

### 3 - JDBC的优点 ###

*  各数据库厂商使用相同的接口，**Java** 代码不需要针对不同数据库分别开发
 *  可随时替换底层数据库，访问数据库的 **Java** 代码基本不变

以后编写操作数据库的代码只需要面向 **JDBC**（接口），操作哪个关系型数据库就需要导入该数据库的驱动包，如需要操作 **MySQL** 数据库，就需要再项目中导入 **MySQL** 数据库的驱动包

下图所示就是 **MySQL** 的驱动包：

![在这里插入图片描述][aa145ff0c0a949559dcfce09680b7116.png]

## 三、JDBC快速上手 ##

我们先来看看通过 **Java** 操作数据库的流程

![在这里插入图片描述][cc7968031912494493d12dce3d9bbcbe.png]

第一步：编写 **Java** 代码

第二步：**Java** 代码将 **SQL** 发送到 **MySQL** 服务端

第三步：**MySQL** 服务端接收到 **SQL** 语句并执行该 **SQL** 语句

第四步：将 **SQL** 语句执行的结果返回给 **Java** 代码

### 1 - 编写代码步骤 ###

*  **创建工程，导入驱动 jar 包**
    
    包的获取：[https://pan.baidu.com/s/1HVOir\_iYz8ml1-HtWwqBcA?pwd=667n][https_pan.baidu.com_s_1HVOir_iYz8ml1-HtWwqBcA_pwd_667n]

![在这里插入图片描述][aa145ff0c0a949559dcfce09680b7116.png]

*  **注册驱动**
    
        Class.forName("com.mysql.jdbc.Driver");
 *  **获取连接**
    
        Connection conn = DriverManager.getConnection(url, username, password);
    
    我们的 **Java** 代码想要发送 **SQL** 给 **MySQL** 服务端，就需要先建立连接
 *  **定义SQL语句**
    
        String sql =  "update…" ;
 *  **获取执行SQL对象**
    
    执行 **SQL** 语句需要 **SQL** 执行对象，而这个执行对象就是 **Statement** 对象
    
        Statement stmt = conn.createStatement();
 *  **执行SQL**
    
        stmt.executeUpdate(sql);
 *  **处理返回结果**
 *  **释放资源**

### 2 - 具体操作 ###

*  **创建一个空项目**
    
    ![在这里插入图片描述][201625fa811244e999ab3b1894e88dde.png]
 *  **定义项目的名称，并指定位置**
    
    ![在这里插入图片描述][660c7a7019d844a9bdda47efa07b9e1d.png]
 *  **对项目进行设置，JDK版本、编译版本**
    
    ![在这里插入图片描述][b0851e52f4b44dc29d911e7f64fa3d0c.png]
 *  **创建模块，指定模块的名称及位置**
    
    ![在这里插入图片描述][f403262c4b764f76835e05283530a781.png]
 *  **导入驱动包**
    
    将 **mysql** 的驱动包放在模块下自己创建的一个 **lib** 目录（随意命名）下，并将该 **jar** 包添加为库文件
    
    ![在这里插入图片描述][6aeac4acb94343f2afc4c67b1f70da67.png]
 *  **在添加为库文件的时候，有如下三个选项**
    
     *  **Global Library** ： 全局有效
     *  **Project Library** : 项目有效
     *  **Module Library** ： 模块有效

![在这里插入图片描述][22bbb78815e5490987a112437c98e235.png]

*  **在src下创建一个类 JDBC\_Demo**
    
    编写代码如下
    
        import java.sql.*;
        
        public class JDBC_Demo {
              
            public static void main(String[] args) throws Exception {
              
                //1. 注册驱动
                Class.forName("com.mysql.jdbc.Driver");
                
                //2. 获取连接
                String url = "jdbc:mysql://127.0.0.1:3306/db1";
                String username = "root";
                String password = "1234";
                Connection conn = DriverManager.getConnection(url, username, password);
                
                //3. 定义sql
                String sql = "update account set money = 2000 where id = 1";
                
                //4. 获取执行sql的对象 Statement
                Statement stmt = conn.createStatement();
                
                //5. 执行sql
                int count = stmt.executeUpdate(sql);//受影响的行数
                
                //6. 处理结果
                System.out.println(count);
                
                //7. 释放资源
                stmt.close();
                conn.close();
            }
        }

### 3 - JDBC API详解 ###

#### (1) DriverManager ####

**DriverManager**（驱动管理类）作用：

*  **注册驱动**
    
    在[使用手册][Link 2]中查询该类，我们可以看到有一个 **registerDriver** 方法：
    
    ![在这里插入图片描述][da078cd1cedf4becb2ab72a13c336a2f.png]
    
    **registerDriver** 方法是用于注册驱动的，但是我们之前写的入门案例并不是这样写的，而是通过下面的语句来实现
    
        Class.forName("com.mysql.jdbc.Driver");
    
    查询一下 **MySQL** 提供的 **Driver** 类，源码如下：  
    ![在这里插入图片描述][b91333d6e1984266a2c8e39729108812.png]
    
    在该类中的静态代码块中已经执行了 `DriverManager` 对象的 `registerDriver()` 方法进行驱动的注册了，那么我们只需要加载 `Driver` 类，该静态代码块就会执行，而 `Class.forName("com.mysql.jdbc.Driver");` 就可以加载 `Driver` 类
    
    > 提示：
    > 
    >  *  **MySQL 5之后的驱动包，可以省略注册驱动的步骤**
    >  *  **自动加载jar包中META-INF/services/java.sql.Driver文件中的驱动类**
 *  **获取数据库连接**
    
    ![在这里插入图片描述][f180f7cb9e5643f0a9a5298ca1dc8568.png]
    
    参数说明：
    
     *  **url** ： 连接路径
        
        > 语法：jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2…
        > 
        > 示例：jdbc:mysql://127.0.0.1:3306/db1
        > 
        > 细节：
        > 
        >  *  **如果连接的是本机 mysql 服务器，并且 mysql 服务默认端口是 3306，则url可以简写为：jdbc:mysql://数据库名称?参数键值对**
        >  *  **配置 useSSL=false 参数，禁用安全连接方式，解决警告提示**
     *  **user** ：用户名
     *  **poassword** ：密码

#### (2) Connection ####

**Connection**（数据库连接对象）作用：

*  获取执行 **SQL** 的对象
 *  管理事务

获取执行对象

*  **普通执行 SQL 对象**
    
        Statement createStatement()
    
    入门案例中就是通过该方法获取的执行对象
 *  **预编译 SQL 的执行 SQL 对象：防止 SQL 注入**
    
        PreparedStatement  prepareStatement(sql)
    
    通过这种方式获取的 `PreparedStatement` **SQL** 语句执行对象是我们一会重点要进行讲解的，它可以防止 **SQL** 注入
 *  **执行存储过程的对象**
    
        CallableStatement prepareCall(sql)
    
    通过这种方式获取的 `CallableStatement` 执行对象是用来执行存储过程的，而存储过程在 **MySQL** 中不常用，所以这个我们不进行讲解

事务管理

我们先回顾一下 **MySQL** 事务管理的操作：

*  开启事务 ： `BEGIN;` 或者 `START TRANSACTION;`
 *  提交事务 ： `COMMIT;`
 *  回滚事务 ： `ROLLBACK;`

MySQL默认是自动提交事务

接下来我们学习 **JDBC** 事务管理的方法

**Connection** 接口中定义了 **3** 个对应的方法：

*  **开启事务**
    
    ![在这里插入图片描述][afb6d11c863641f5840683772c525bce.png]
    
    参与 **autoCommit** 表示是否自动提交事务，**true** 表示自动提交事务，**false** 表示手动提交事务，而开启事务需要将该参数设置为 **false**
 *  **提交事务**
    
    ![在这里插入图片描述][1f48f3ba45d04fa29c576a6c364209e6.png]
 *  **回滚事务**
    
    ![在这里插入图片描述][a4097bbc4e62428bb6003e70f9f03c95.png]

具体代码实现如下：

import java.sql.*;
    
    public class JDBCDemo_Connection {
    
        public static void main(String[] args) throws Exception {
            //1. 注册驱动
            //Class.forName("com.mysql.jdbc.Driver");
            //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
            String url = "jdbc:mysql:///db1?useSSL=false";
            String username = "root";
            String password = "1234";
            Connection conn = DriverManager.getConnection(url, username, password);
            //3. 定义sql
            String sql1 = "update account set money = 3000 where id = 1";
            String sql2 = "update account set money = 3000 where id = 2";
            //4. 获取执行sql的对象 Statement
            Statement stmt = conn.createStatement();
    
            try {
                // ============开启事务==========
                conn.setAutoCommit(false);
                //5. 执行sql
                int count1 = stmt.executeUpdate(sql1);//受影响的行数
                //6. 处理结果
                System.out.println(count1);
                
                //5. 执行sql
                int count2 = stmt.executeUpdate(sql2);//受影响的行数
                //6. 处理结果
                System.out.println(count2);
    
                // ============提交事务==========
                //程序运行到此处，说明没有出现任何问题，则需求提交事务
                conn.commit();
            } catch (Exception e) {
                // ============回滚事务==========
                //程序在出现异常时会执行到这个地方，此时就需要回滚事务
                conn.rollback();
                e.printStackTrace();
            }
    
            //7. 释放资源
            stmt.close();
            conn.close();
        }
    }

![在这里插入图片描述][aed8609d1df245e988bead31edc5294d.png]

#### (3) Statement ####

概述

**Statement** 对象的作用就是用来执行 **SQL** 语句，而针对不同类型的 **SQL** 语句使用的方法也不一样

*  **执行DDL、DML语句**
    
    ![在这里插入图片描述][ec76a23f926b4506a419b0e737b83806.png]
 *  **执行DQL语句**
    
    ![在这里插入图片描述][7a22275172eb43e8a3913510cb56afe0.png]
    
    该方法涉及到了 `ResultSet` 对象，而这个对象我们还没有学习，一会再重点讲解

代码实现

*  **执行DML语句**
    
        public void testDML() throws  Exception {
              
            //1. 注册驱动
            //Class.forName("com.mysql.jdbc.Driver");
            //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
            String url = "jdbc:mysql:///db1?useSSL=false";
            String username = "root";
            String password = "1234";
            Connection conn = DriverManager.getConnection(url, username, password);
            //3. 定义sql
            String sql = "update account set money = 3000 where id = 1";
            //4. 获取执行sql的对象 Statement
            Statement stmt = conn.createStatement();
            //5. 执行sql
            int count = stmt.executeUpdate(sql);//执行完DML语句，受影响的行数
            //6. 处理结果
            //System.out.println(count);
            if(count > 0){
              
                System.out.println("修改成功~");
            }else{
              
                System.out.println("修改失败~");
            }
            //7. 释放资源
            stmt.close();
            conn.close();
        }
 *  **执行DDL语句**
    
        public void testDDL() throws  Exception {
              
            //1. 注册驱动
            //Class.forName("com.mysql.jdbc.Driver");
            //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
            String url = "jdbc:mysql:///db1?useSSL=false";
            String username = "root";
            String password = "1234";
            Connection conn = DriverManager.getConnection(url, username, password);
            //3. 定义sql
            String sql = "drop database db2";
            //4. 获取执行sql的对象 Statement
            Statement stmt = conn.createStatement();
            //5. 执行sql
            int count = stmt.executeUpdate(sql);//执行完DDL语句，可能是0
            //6. 处理结果
            System.out.println(count);
        
            //7. 释放资源
            stmt.close();
            conn.close();
        }
    
    > **注意：以后开发很少使用 Java 代码操作 DDL 语句**

#### (4) ResultSet ####

概述

**ResultSet**（结果集对象）作用：

*  **封装了SQL查询语句的结果**

而执行了 **DQL** 语句后就会返回该对象，对应执行 **DQL** 语句的方法如下：

ResultSet executeQuery(sql)：执行DQL 语句，返回 ResultSet 对象

那么我们就需要从 `ResultSet` 对象中获取我们想要的数据，`ResultSet` 对象提供了操作查询结果数据的方法，如下：

> boolean next()
> 
>  *  **将光标从当前位置向前移动一行**
>  *  **判断当前行是否为有效行**
> 
> 方法返回值说明：
> 
>  *  **true** ： **有效行，当前行有数据**
>  *  **false** ： **无效行，当前行没有数据**

> xxx getXxx(参数)：获取数据
> 
>  *  **xxx** : **数据类型；如： int getInt(参数) ；String getString(参数)**
>  *  **参数**
>     
>      *  **int类型的参数：列的编号，从1开始**
>      *  **String类型的参数： 列的名称**

如下图为执行 **SQL** 语句后的结果

![在这里插入图片描述][1d070d0d4a5e4e668932e43375d35bb9.png]  
一开始光标指定于第一行前，如图所示红色箭头指向于表头行。当我们调用了 `next()` 方法后，光标就下移到第一行数据，并且方法返回 **true**，此时就可以通过 `getInt("id")` 获取当前行 **id** 字段的值，也可以通过 `getString("name")` 获取当前行 **name** 字段的值。如果想获取下一行的数据，继续调用 `next()` 方法，以此类推

代码实现

public void testResultSet() throws  Exception {
        
        //1. 注册驱动
        //Class.forName("com.mysql.jdbc.Driver");
        //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
        String url = "jdbc:mysql:///db1?useSSL=false";
        String username = "root";
        String password = "1234";
        Connection conn = DriverManager.getConnection(url, username, password);
        //3. 定义sql
        String sql = "select * from account";
        //4. 获取statement对象
        Statement stmt = conn.createStatement();
        //5. 执行sql
        ResultSet rs = stmt.executeQuery(sql);
        //6. 处理结果， 遍历rs中的所有数据
        // 6.1 光标向下移动一行，并且判断当前行是否有数据
        while (rs.next()){
        
            //6.2 获取数据  getXxx()
            int id = rs.getInt("id");
            String name = rs.getString("name");
            double money = rs.getDouble("money");
    
            System.out.println(id);
            System.out.println(name);
            System.out.println(money);
    
            System.out.println("--------------");
        }
    
        //7. 释放资源
        rs.close();
        stmt.close();
        conn.close();
    }

#### (5) 案例 ####

*  需求：查询 **account** 账户表数据，封装为 **Account** 对象中，并且存储到 **ArrayList** 集合中

![在这里插入图片描述][2d902a379cbb4495a46c92bfbf09e667.png]

*  代码实现
    
    创建一个 **Account** 类来存储信息，便于存进集合
    
        package pojo;
        
        public class Account {
              
            private int id;
            private String name;
            private double money;
        
            public int getId() {
              
                return id;
            }
        
            public void setId(int id) {
              
                this.id = id;
            }
        
            public String getName() {
              
                return name;
            }
        
            public void setName(String name) {
              
                this.name = name;
            }
        
            public double getMoney() {
              
                return money;
            }
        
            public void setMoney(double money) {
              
                this.money = money;
            }
        }
    
        import java.sql.*;
        import java.util.*;
        import pojo.Account;
        
        public class JDBCDemo_ResultSet {
              
            /*
             * 查询account账户表数据，封装为Account对象中，并且存储到ArrayList集合中
             * 1. 定义实体类Account
             * 2. 查询数据，封装到Account对象中
             * 3. 将Account对象存入ArrayList集合中
             */
            public static void testResultSet2() throws  Exception {
              
                //1. 注册驱动
                //Class.forName("com.mysql.jdbc.Driver");
                //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
                String url = "jdbc:mysql:///db1?useSSL=false";
                String username = "root";
                String password = "1234";
                Connection conn = DriverManager.getConnection(url, username, password);
        
                //3. 定义sql
                String sql = "select * from account";
        
                //4. 获取statement对象
                Statement stmt = conn.createStatement();
        
                //5. 执行sql
                ResultSet rs = stmt.executeQuery(sql);
        
                //6.处理结果，遍历rs中的所有数据
                // 6.1 光标向下移动一行，并且判断当前行是否有数据
                // 创建集合
                List<Account> list = new ArrayList<>();
        
                while (rs.next()){
              
                    Account account = new Account();
        
                    //6.2 获取数据  getXxx()
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    double money = rs.getDouble("money");
        
                    //赋值
                    account.setId(id);
                    account.setName(name);
                    account.setMoney(money);
        
                    // 存入集合
                    list.add(account);
                }
        
                for(Account a:list){
              
                    System.out.println(a.getId());
                    System.out.println(a.getName());
                    System.out.println(a.getMoney());
                }
        
                //7. 释放资源
                rs.close();
                stmt.close();
                conn.close();
            }
        
            public static void main(String[] args) {
              
                try {
              
                    testResultSet2();
                } catch (Exception e) {
              
                    e.printStackTrace();
                }
            }
        }
    
    执行结果如下：
    
    ![在这里插入图片描述][336df54468954f25b06237b20491e6ec.png]

#### (6) PreparedStatement ####

作用：预编译 **SQL** 语句并执行，预防 **SQL** 注入问题

对上面的作用中 **SQL** 注入问题你可能不理解，接下来我们先对 **SQL** 注入进行说明

① 什么是SQL注入

> **SQL注入是通过操作输入来修改事先定义好的SQL语句，用以达到执行代码对服务器进行攻击的方法**

② 代码模拟SQL注入问题

*  首先准备数据：
    
        CREATE TABLE tb_user(
        	id int PRIMARY KEY auto_increment,
        	username varchar(10),
        	password int(10)
        );
        
        -- 添加数据
        INSERT INTO tb_user(username,password) VALUES('zhangsan',123),('lisi',123);
        
        SELECT * FROM tb_user;
    
    ![在这里插入图片描述][b1d27e69aaa547a4bb56f0cd1bc688f8.png]
 *  看一下这段代码
    
        public void testLogin() throws  Exception {
              
            //获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
            String url = "jdbc:mysql:///db1?useSSL=false";
            String username = "root";
            String password = "1234";
            Connection conn = DriverManager.getConnection(url, username, password);
        
            // 接收用户输入 用户名和密码
            String name = "sjdljfld";
            String pwd = "' or '1' = '1";
            String sql = "select * from tb_user where username = '"+name+"' and password = '"+pwd+"'";
            // 获取stmt对象
            Statement stmt = conn.createStatement();
            // 执行sql
            ResultSet rs = stmt.executeQuery(sql);
            // 判断登录是否成功
            if(rs.next()){
              
                System.out.println("登录成功~");
            }else{
              
                System.out.println("登录失败~");
            }
        
            //释放资源
            rs.close();
            stmt.close();
            conn.close();
        }
    
    上面代码是将用户名和密码拼接到 **sql** 语句中，拼接后的 **sql** 语句如下
    
        select * from tb_user where username = 'sjdljfld' and password = ''or '1' = '1'
    
    从上面语句可以看出条件 `username = 'sjdljfld' and password = ''` 不管是否满足，而 `or` 后面的 `'1' = '1'` 是始终满足的，最终条件是成立的，就可以正常的进行登陆了。如果此时有一个登录系统是这样写的，那么很容易就被人入侵

接下来我们来学习 **PreparedStatement** 对象

③ PreparedStatement概述

*  **获取 PreparedStatement 对象**
    
        // SQL语句中的参数值，使用？占位符替代
        String sql = "select * from user where username = ? and password = ?";
        // 通过Connection对象获取，并传入对应的sql语句
        PreparedStatement pstmt = conn.prepareStatement(sql);
 *  **设置参数值**
    
    上面的 **sql** 语句中参数使用 **?** 进行占位，在之前肯定要设置这些 **?** 的值
    
    > PreparedStatement对象：setXxx(参数1，参数2)：给 ? 赋值
    > 
    >  *  Xxx：数据类型 ； 如 setInt (参数1，参数2)
    >  *  参数：
    >     
    >      *  参数1： ？的位置编号，从1 开始
    >      *  参数2： ？的值
 *  **执行SQL语句**
    
    > executeUpdate()：执行DDL语句和DML语句
    > 
    > executeQuery()：执行DQL语句
    > 
    > 注意：
    > 
    >  *  调用这两个方法时不需要传递SQL语句，因为获取SQL语句执行对象时已经对SQL语句进行预编译了。

④ 使用PreparedStatement改进

import java.sql.*;
    
    public class JDBC_PreparedStatement {
        
        public static void testPreparedStatement() throws  Exception {
        
            //获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
            String url = "jdbc:mysql:///db1?useSSL=false";
            String username = "root";
            String password = "1234";
            Connection conn = DriverManager.getConnection(url, username, password);
    
            // 接收用户输入 用户名和密码
            String name = "zhangsan";
            String pwd = "' or '1' = '1";
    
            // 定义sql
            String sql = "select * from tb_user where username = ? and password = ?";
            // 获取pstmt对象
            PreparedStatement pstmt = conn.prepareStatement(sql);
            // 设置？的值
            pstmt.setString(1,name);
            pstmt.setString(2,pwd);
            // 执行sql
            ResultSet rs = pstmt.executeQuery();
            // 判断登录是否成功
            if(rs.next()){
        
                System.out.println("登录成功~");
            }else{
        
                System.out.println("登录失败~");
            }
            //释放资源
            rs.close();
            pstmt.close();
            conn.close();
        }
    
        public static void main(String[] args) throws Exception {
        
            testPreparedStatement();
        }
    }

执行结果如下：

![在这里插入图片描述][e4de8dd459c34af0a535391b0439743a.png]

此时以无法登录成功，说明执行上面语句就不会出现 **SQL** 注入漏洞问题了

那么 **PreparedStatement** 又是如何解决的呢？

其实它是将特殊字符进行了转义，转义的 **SQL** 如下：

select * from tb_user where username = 'sjdljfld' and password = '\'or \'1\' = \'1'

⑤ PreparedStatement原理

**PreparedStatement** 好处：

*  **预编译SQL，性能更高**
 *  **防止SQL注入：将敏感字符进行转义**

![在这里插入图片描述][ca499caad67547e9a046aa87cc48ad32.png]

**Java** 代码操作数据库流程如上图所示：

*  将 **sql** 语句发送到 **MySQL** 服务器端
 *  **MySQL** 服务端会对 **sql** 语句进行如下操作
    
     *  检查 **SQL** 语句
        
        检查 **SQL** 语句的语法是否正确
     *  编译 **SQL** 语句，将 **SQL** 语句编译成可执行的函数
        
        检查 **SQL** 和编译 **SQL** 花费的时间比执行 **SQL** 的时间还要长。如果我们只是重新设置参数，那么检查 **SQL** 语句和编译 **SQL** 语句将不需要重复执行，这样就提高了性能
     *  执行 **SQL** 语句

接下来我们通过查询日志来看一下原理

*  **开启预编译功能**
    
    在代码中编写 **url** 时需要加上以下参数，而我们之前根本就没有开启预编译功能，只是解决了 **SQL** 注入漏洞
    
        useServerPrepStmts=true
 *  **配置MySQL执行日志（重启mysql服务后生效）**
    
    在 **mysql** 配置文件 **(my.ini)** 中添加如下配置
    
        log-output=FILE
        general-log=1
        general_log_file="D:\mysql.log"
        slow-query-log=1
        slow_query_log_file="D:\mysql_slow.log"
        long_query_time=2
 *  **Java测试代码如下**
    
        public void testPreparedStatement2() throws  Exception {
              
            //获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
            // useServerPrepStmts=true 参数开启预编译功能
            String url = "jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true";
            String username = "root";
            String password = "1234";
            Connection conn = DriverManager.getConnection(url, username, password);
        
            // 接收用户输入 用户名和密码
            String name = "zhangsan";
            String pwd = "' or '1' = '1";
        
            // 定义sql
            String sql = "select * from tb_user where username = ? and password = ?";
        
            // 获取pstmt对象
            PreparedStatement pstmt = conn.prepareStatement(sql);
        
            // 设置？的值
            pstmt.setString(1,name);
            pstmt.setString(2,pwd);
            ResultSet rs = null;
            // 执行sql
            rs = pstmt.executeQuery();
        
            // 设置？的值
            pstmt.setString(1,"aaa");
            pstmt.setString(2,"bbb");
            // 执行sql
            rs = pstmt.executeQuery();
        
            // 判断登录是否成功
            if(rs.next()){
              
                System.out.println("登录成功~");
            }else{
              
                System.out.println("登录失败~");
            }
        
            //释放资源
            rs.close();
            pstmt.close();
            conn.close();
        }
 *  **执行SQL语句，查看 `D:\mysql.log` 日志如下**
    
    ![在这里插入图片描述][35c1ea11a2e14073b1fea1858042575b.png]
    
    上图中第三行中的 `Prepare` 是对 **SQL** 语句进行预编译，第四行和第五行是执行了两次 **SQL** 语句，而第二次执行前并没有对 **SQL** 进行预编译

> 小结：
> 
>  *  **在获取 PreparedStatement 对象时，将sql语句发送给mysql服务器进行检查，编译（这些步骤很耗时）**
>  *  **执行时就不用再进行这些步骤了，速度更快**
>  *  **如果sql模板一样，则只需要进行一次检查、编译**

> ? 这次的分享就到这里啦，继续加油哦^^  
> ? 我是[程序喵][Link 1]，陪你一点点进步  
> ? 有出错的地方欢迎在评论区指出来，共同进步，谢谢啦

[Link 1]: https://blog.csdn.net/weixin_62511863?spm=1011.2421.3001.5343
[JavaWeb]: https://blog.csdn.net/weixin_62511863/category_11971664.html?spm=1001.2014.3001.5482
[9ebe6ef6536d4e96aaa90532a85fdf70.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/1bb55a176fad4bbfa1fb2df0ccf546e0.png
[aa145ff0c0a949559dcfce09680b7116.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/00b4b17437f546f08589b3ec3cbee043.png
[cc7968031912494493d12dce3d9bbcbe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/fb4c87d006ef464ab078ed9ef758e634.png
[https_pan.baidu.com_s_1HVOir_iYz8ml1-HtWwqBcA_pwd_667n]: https://pan.baidu.com/s/1HVOir_iYz8ml1-HtWwqBcA?pwd=667n
[201625fa811244e999ab3b1894e88dde.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/0052b09b879f4a1ebea8185f951369ee.png
[660c7a7019d844a9bdda47efa07b9e1d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/cef8d09243e749639bd26c528d154fc5.png
[b0851e52f4b44dc29d911e7f64fa3d0c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/59f33590f2174aa380ca87abbc99147a.png
[f403262c4b764f76835e05283530a781.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/054b47d8453a4b80aea34e96b259ec68.png
[6aeac4acb94343f2afc4c67b1f70da67.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/5127239af3384ebd9b6b9d9e500acfb7.png
[22bbb78815e5490987a112437c98e235.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/45b1ff7188e246ce857a94f772e3aae7.png
[Link 2]: https://pan.baidu.com/s/1G-EmmoFOeH4iuptaKtozMw?pwd=tixm
[da078cd1cedf4becb2ab72a13c336a2f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7c24c3bd741f4e6a9d8d7426b2cded22.png
[b91333d6e1984266a2c8e39729108812.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/1145a95060174bd6b71c02d7435b7cf7.png
[f180f7cb9e5643f0a9a5298ca1dc8568.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/19dc204e9f184b15b3ad927b6ee127c2.png
[afb6d11c863641f5840683772c525bce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/4adb39a6a0f14af6bfbb783ee8ef92eb.png
[1f48f3ba45d04fa29c576a6c364209e6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/17867cb26722475e89623d64b373b1f5.png
[a4097bbc4e62428bb6003e70f9f03c95.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/13a5be70247f452380bc452da194c9f1.png
[aed8609d1df245e988bead31edc5294d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/42b688c5768c49f6a51be763099fc362.png
[ec76a23f926b4506a419b0e737b83806.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8593ddd440184fb79b98d613cd4a5768.png
[7a22275172eb43e8a3913510cb56afe0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/3deeb7ffadbd44c3ab530d8101796e8d.png
[1d070d0d4a5e4e668932e43375d35bb9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/2117bd509de949879a90526651e45ecc.png
[2d902a379cbb4495a46c92bfbf09e667.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/3901d7f302ce41239e2f24b69fee349f.png
[336df54468954f25b06237b20491e6ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/79ff80076c5e498abd078f6ac4d9ae94.png
[b1d27e69aaa547a4bb56f0cd1bc688f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/db1255e06e4b48b6962bf0356fa53512.png
[e4de8dd459c34af0a535391b0439743a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/34ff3c43da2641b9b1d576c55f4620a7.png
[ca499caad67547e9a046aa87cc48ad32.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c21ae768bd104221bfd1d121505fd54b.png
[35c1ea11a2e14073b1fea1858042575b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/92cd8ce35c6a45e0967e597bd20c6b0b.png