DriverManager

DriverManager（驱动管理类）作用：

• 注册驱动

API文档中提供的方法：

DriverManager.registerDriver(new Driver());

但在代码中写成：

Class.forName("com.mysql.jdbc.Driver");

为什么要这样写？在idea中按住Ctrl，再点击com.mysql.jdbc.Driver中的Driver，会跳转到相关源码位置：

static {
    try {
        DriverManager.registerDriver(new Driver());
    } catch (SQLException var1) {
        throw new RuntimeException("Can't register driver!");
    }
}

可以看到，在该类中的静态代码块中已经执行了 DriverManager 对象的 registerDriver() 方法进行驱动的注册了，那么我们只需要加载 Driver 类，该静态代码块就会执行。而 Class.forName("com.mysql.jdbc.Driver"); 就可以加载 Driver 类。

注意：MySQL 5之后的驱动包，可以省略注册驱动的步骤
自动加载jar包中META-INF/services/java.sql.Driver文件中的驱动类

• 获取数据库连接

Connection con = DriverManager.getConnection(url,username,password);

参数说明
url ： 连接路径

语法：jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2…

示例：jdbc:mysql://127.0.0.1:3306/db1

• 如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称?参数键值对
• 配置 useSSL=false 参数，禁用安全连接方式，解决警告提示
  如: jdbc:mysql://ip地址(域名):端口号/数据库名称 ? useSSL=false

user ：用户名

password ：密码

Connection

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

• 获取执行对象

普通执行SQL对象

Statement createStatement()

预编译SQL的执行SQL对象：防止SQL注入

PreparedStatement 
prepareStatement(sql)

后面重点讲 prepareStatement(sql)
执行存储过程的对象

CallableStatement 
prepareCall(sql)

通过这种方式获取的 CallableStatement 执行对象是用来执行存储过程的，而存储过程在MySQL中不常用

• 事务管理

先回顾一下MySQL事务管理的操作：
开启事务 ： BEGIN; 或者 START TRANSACTION;
提交事务 ： COMMIT;
回滚事务 ： ROLLBACK;

注意：MySQL默认是自动提交事务

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

开启事务

void setAutoCommit(boolean autoCommit)

参与autoCommit 表示是否自动提交事务，true表示自动提交事务，false表示手动提交事务。而开启事务需要将该参数设为为false。
提交事务

void commit()

回滚事务

void rollback()

代码

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

/**
 * JDBC Connection
 */
public class JDBCDemo3_Connection {
    public static void main(String[] args) throws Exception {
        // 注册驱动
        Class.forName("com.mysql.jdbc.Driver");

        // 获取连接
        String url = "jdbc:mysql:///mydatabase?useSSL=false";
        String username = "root";
        String password = "****";
        Connection con = DriverManager.getConnection(url,username,password);

        // 定义sql
        String sql1 = "UPDATE tb_user set password = '456' where id = 2";
        String sql2 = "UPDATE tb_user set password = '789' where id = 1";

        // 获取指向sql的对象statement
        Statement sta = con.createStatement();

        try{
            // 开启事务
            con.setAutoCommit(false);      // 设置手动开启
            // 执行sql
            int count1 = sta.executeUpdate(sql1);  // 受影响的行数

            System.out.println(count1);

            // 执行sql
            int count2 = sta.executeUpdate(sql2);  // 受影响的行数

            System.out.println(count2);

            // 提交事务
            con.commit();
        }catch(Exception e){
            e.printStackTrace();
            con.rollback();     // 出现异常则回滚
        }

        // 释放资源
        sta.close();    // 先释放指向SQL的对象
        con.close();    // 再释放SQL连接
    }
}

简要说明：try 语句中如果出现异常，会跳转到 catch 中执行 rollback ，撤销操作

Statement

• 概述

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

执行DDL、DML语句

int executeUpdate(String sql)

返回值：（1）DML语句影响的行数
（2）DDL语句执行后，执行成功也可能返回 0
执行DQL语句

ResultSet executeQuery(String sql)

返回值： ResultSet 结果集对象

• 代码

执行DML语句

/**
     * 执行DML语句
     * @throws Exception
     */
    public static void testDML() throws Exception {
        // 注册驱动
        // Class.forName("com.mysql.jdbc.Driver");

        // 获取连接
        String url = "jdbc:mysql:///mydatabase?useSSL=false";
        String username = "root";
        String password = "****";
        Connection con = DriverManager.getConnection(url,username,password);

        // 定义sql
        String sql1 = "UPDATE tb_user set password = '456' where id = 2";

        // 获取指向sql的对象statement
        Statement sta = con.createStatement();

        try{
            // 开启事务
            con.setAutoCommit(false);      // 设置手动开启
            // 执行sql
            int count1 = sta.executeUpdate(sql1);  // 受影响的行数

            // 处理结果
            if (count1 > 0){
                System.out.println("修改成功！");
            }else{
                System.out.println("修改失败！");
            }

            // 提交事务
            con.commit();
        }catch(Exception e){
            e.printStackTrace();
            con.rollback();     // 出现异常则回滚
        }

        // 释放资源
        sta.close();    // 先释放指向SQL的对象
        con.close();    // 再释放SQL连接
    }

执行DDL语句

/**
     * 执行DDL语句
     * @throws Exception
     */
    public static void testDDL() throws Exception {
        // 注册驱动
        // Class.forName("com.mysql.jdbc.Driver");

        // 获取连接
        String url = "jdbc:mysql:///mydatabase?useSSL=false";
        String username = "root";
        String password = "****";
        Connection con = DriverManager.getConnection(url,username,password);

        // 定义sql
        String sql1 = "create database db2;";

        // 获取指向sql的对象statement
        Statement sta = con.createStatement();

        try{
            // 开启事务
            con.setAutoCommit(false);      // 设置手动开启
            // 执行sql
            int count1 = sta.executeUpdate(sql1);  // 受影响的行数可能为 0

            // 处理结果
            // 不报异常一般执行成功

            // 提交事务
            con.commit();
        }catch(Exception e){
            e.printStackTrace();
            con.rollback();     // 出现异常则回滚
        }

        // 释放资源
        sta.close();    // 先释放指向SQL的对象
        con.close();    // 再释放SQL连接
    }

ResultSet

ResultSet（结果集对象）作用：封装了SQL查询语句的结果。

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

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

boolean next()

• 将光标从当前位置向前移动一行
• 判断当前行是否为有效行

方法返回值说明：

• true ： 有效航，当前行有数据
• false ： 无效行，当前行没有数据

xxx getXxx(参数)：获取数据

• xxx : 数据类型；如： int getInt(参数) ；String getString(参数)

• 参数

  • int类型的参数：列的编号，从1开始
  • String类型的参数： 列的名称

• 代码（详见代码注释）

/**
 * 执行DQL语句
 * @throws Exception
 */
public static void testDQL() throws Exception {
    // 注册驱动
    // Class.forName("com.mysql.jdbc.Driver");

    // 获取连接
    String url = "jdbc:mysql:///mydatabase?useSSL=false";
    String username = "root";
    String password = "****";
    Connection con = DriverManager.getConnection(url, username, password);

    // 定义sql
    String sql1 = "select * from tb_user";

    // 获取指向sql的对象statement
    Statement sta = con.createStatement();

    // 执行
    ResultSet rs = sta.executeQuery(sql1);

    // ArrayList 容器存 User 对象
    ArrayList list = new ArrayList<User>();

    // 处理结果 ResultSet
    while(rs.next()){
        /*
        // 这种直接按列序号查找也行
        int id = rs.getInt(1);
        String name = rs.getString(2);
        String word = rs.getString(3);*/

        int id = rs.getInt("id");
        String name = rs.getString("username");
        String word = rs.getString("password");

        // System.out.println(id + "\t" + name + "\t" + word);
        list.add(new User(id,name,word));
    }

    // 打印
    for(Object user : list){
        System.out.println((User)user);
    }

    // 释放资源
    rs.close();     // ResultSet 也需要释放
    sta.close();
    con.close();
}

PreparedStatement

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

• 代码模拟SQL注入问题

/**
 * 演示Login
 * @throws Exception
 */
public static void testLogin_Inject() throws Exception {
    // 注册驱动
    // Class.forName("com.mysql.jdbc.Driver");

    // 获取连接
    String url = "jdbc:mysql:///mydatabase?useSSL=false";
    String username = "root";
    String password = "****";
    Connection con = DriverManager.getConnection(url, username, password);

    // 接收用户名和密码
    String name = "fgahnoieu";
    String pwd = "' or '1' = '1";

    // 定义sql
    String sql = "select * from tb_user where username = '" + name + "' and password ='"+ pwd +"'";

    // System.out.println(sql);

    // 获取指向sql的对象statement
    Statement sta = con.createStatement();

    // 执行
    ResultSet rs = sta.executeQuery(sql);

    // 判断登录是否成功
    if(rs.next()){
        System.out.println("登陆成功！");
    }else{

        System.out.println("登陆失败！");
    }

    // 释放资源
    rs.close();     // ResultSet 也需要释放
    sta.close();
    con.close();
}

测试结果：登陆成功！

登录密码：pwd = "' or '1' = '1";，密码明显不对为什么会登录成功？问题出现在定义 sql 时的字符串的拼接上！我们把sql输出：

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

不难看出，'1' = '1'为恒等式，所以select * from tb_user一定会执行，查到了符合条件的结果，那么也就“登陆成功”了。为了避免出现这种 sql 注入问题，便采取了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语句进行预编译了。

• 代码

/**
 * testLogin_Inject
 * @throws Exception
 */
public static void testLogin_Inject() throws Exception {
    // 注册驱动
    // Class.forName("com.mysql.jdbc.Driver");

    // 获取连接
    String url = "jdbc:mysql:///mydatabase?useSSL=false";
    String username = "root";
    String password = "****";
    Connection con = DriverManager.getConnection(url, username, password);

    // 接收用户名和密码
    String name = "zhangsan";
    String pwd = "' or '1' = '1";

    // 定义sql
    String sql = "select * from tb_user where username = ? and password = ?";

    // 获取指向sql的对象PreparedStatement
    PreparedStatement psta = con.prepareStatement(sql);

    // 设置 ？的值
    psta.setString(1,name);
    psta.setString(2,pwd);

    // 执行
    ResultSet rs = psta.executeQuery();     // 上面已经传过sql了，不要再传

    // 判断登录是否成功
    if(rs.next()){
        System.out.println("登陆成功！");
    }else{

        System.out.println("登陆失败！");
    }

    // 释放资源
    rs.close();     // ResultSet 也需要释放
    psta.close();
    con.close();
}

测试结果：登陆失败！

可以看到，String pwd = "' or '1' = '1";的方法已失效，不会出现SQL注入漏洞问题了。那么PreparedStatement又是如何解决的呢？它是将特殊字符进行了转义，转义的SQL如下：

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

PreparedStatement原理

• PreparedStatement 好处：

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

将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

测试代码

public static void testLogin_Inject() throws Exception {
    // 注册驱动
    // Class.forName("com.mysql.jdbc.Driver");

    // 获取连接
    // 开启预编译，需要加参数 useServerPrepStmts=true
    // 参数之间要用 & 隔开
    String url = "jdbc:mysql:///mydatabase?useSSL=false&useServerPrepStmts=true";
    String username = "root";
    String password = "****";
    Connection con = DriverManager.getConnection(url, username, password);

    // 接收用户名和密码
    String name = "zhangsan";
    String pwd = "' or '1' = '1";

    // 定义sql
    String sql = "select * from tb_user where username = ? and password = ?";

    // 获取指向sql的对象PreparedStatement
    PreparedStatement psta = con.prepareStatement(sql);

    // 设置 ？的值
    psta.setString(1,name);
    psta.setString(2,pwd);

    ResultSet rs = null;

    // 执行
    rs = psta.executeQuery();     // 上面已经传过sql了，不要再传

    // 设置 ？的值
    psta.setString(1,"aaa");
    psta.setString(2,"bbb");

    // 执行
    rs = psta.executeQuery();

    // 判断登录是否成功
    if(rs.next()){
        System.out.println("登陆成功！");
    }else{

        System.out.println("登陆失败！");
    }

    // 释放资源
    rs.close();     // ResultSet 也需要释放
    psta.close();
    con.close();
}

执行SQL语句，查看 D:\mysql.log 日志如下

2022-01-04T02:20:59.912223Z    5 Connect   root@localhost on mydatabase using TCP/IP
2022-01-04T02:20:59.916211Z    5 Query    /* mysql-connector-java-5.1.48 ( Revision: 
........
2022-01-04T02:20:59.936209Z    5 Query    SET character_set_results = NULL
2022-01-04T02:20:59.937209Z    5 Query    SET autocommit=1
2022-01-04T02:20:59.952227Z    5 Prepare    select * from tb_user where username = ? and password = ?
2022-01-04T02:20:59.952227Z    5 Execute    select * from tb_user where username = 'zhangsan' and password = '\' or \'1\' = \'1'
2022-01-04T02:20:59.953220Z    5 Execute    select * from tb_user where username = 'aaa' and password = 'bbb'
2022-01-04T02:20:59.954226Z    5 Close stmt    
2022-01-04T02:20:59.956227Z    5 Quit    

日志分析：password = '\' or \'1\' = \'1':对敏感字符的确进行了转义；
Java程序中分别执行了两次 SQL 语句（模板相同，只是替换了？的值），但日志中只进行了一次Prepare。

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