【Java】JDBC快速入门及详解（MySQL版）

1. JDBC概述

1.JDBC概念：全称 Java DataBase Connectivity，即Java 数据库连接 是用Java操作关系型数据库的一套API。

驱动：SUN公司指定了一套标准接口（JDBC），JDBC中定义了所有操作关系型数据库的规则，而接口的实现类由各自的数据库厂商给出，这套实现类称之为驱动。想要使用同一套Java代码操作不同的关系型数据库，只需要加载该数据库厂商对应的驱动即可。

2.JDBC本质：

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

3.Java操作数据库的流程：

• 编写Java代码
• Java代码将SQL发送到MySQL服务端
• MySQL服务端接收到SQL语句并执行该SQL语句
• 将SQL语句执行的结果返回给Java代码

2. JDBC快速入门

2.1 下载驱动jar包

1.首先查询自己本地安装的MySQL版本，此处我的MySQL版本是 8.0.32

mysql -V

2.根据自己本地的MySQL版本，去MySQL官网下载对应的版本的zip压缩包

MySQL官网下载地址：https://dev.mysql.com/downloads/connector/j/

点击Archives，进入历史版本

选择好版本和操作系统后，点击Download下载zip压缩包

• 版本：选择本地安装的数据库版本，此处为 8.0.32
• 操作系统：选择 Platform Independent，不依赖平台

3.解压zip包以后，拿出里面的jar包即可，此处解压后得到 mysql-connector-j-8.0.32.jar

2.2 数据准备

准备一张account表，插入两条数据如下：

-- 删除账户表
drop table if exists account;

-- 创建账户表
create table account
(
    id    int primary key AUTO_INCREMENT comment 'ID',
    name  varchar(10) comment '姓名',
    money double(10, 2) comment '余额'
) comment '账户表';

-- 向账户表插入数据
insert into account(name, money) VALUES ('张三', 2000), ('李四', 2000);

-- 查询账户表
select * from account;

2.3 创建工程

1.创建新的项目，定义项目的名称，并指定位置。

2.生成的项目结构如下，首先删除src文件夹下Main.java，然后在项目下新建一个目录，一般取名叫lib，用于存放jar包。

将下载好的 mysql-connector-j-8.0.32.jar 拖到该 lib 目录下，最终得到的项目结构如下：

3.右键lib目录，点击 Add as Library，将该 jar 包添加为库文件

在添加为库文件的时候，有如下三个选项

• Global Library ： 全局有效
• Project Library : 项目有效
• Module Library ： 模块有效

4.src文件夹下，新建一个java文件，此处取名JDBCDemo

2.4 编写代码

编写代码一共分为以下七步：

1. 注册驱动
2. 获取连接
3. 定义SQL语句
4. 获取执行SQL对象
5. 执行SQL
6. 处理返回结果
7. 释放资源

将以下代码复制到 JDBCDemo.java 中运行：

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

public class JDBCDemo {
    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/itheima"; // 数据库URL
        String username = "root"; // 用户名
        String password = "123456"; // 密码
        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); // 受影响的行数

        // 6.处理结果
        System.out.println(count);
        
        // 7.释放资源
        stmt.close();
        conn.close();
    }
}

运行结束后，查询account表，张三的余额变成了3000，说明JDBC运行成功了：

3. JDBC API详解

3.1 DriverManager

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

• 注册驱动
• 获取数据库连接

1.注册驱动：registerDriver​(Driver driver)方法用于注册驱动

MySQL提供的Driver类，实现注册驱动的源码如下：

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

Class.forName("com.mysql.jdbc.Driver"); // 注册驱动

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

2.获取数据库连接：getConnection()方法

getConnection​(String url, String user, String password);

参数说明：

• url ： 数据库连接路径
  • 语法：jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2…
  • 示例：jdbc:mysql://127.0.0.1:3306/itheima
• user ：用户名
• poassword ：密码

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

3.2 Connection

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

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

3.2.1 获取执行SQL对象

1.普通执行SQL对象

Statement createStatement()

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

PreparedStatement  prepareStatement(sql)

3.执行存储过程的对象

CallableStatement prepareCall(sql)

3.2.2 管理事务

MySQL事务管理的操作命令：

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

注：MySQL默认自动提交事务

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

1.开启事务 ：setAutoCommit​(boolean autoCommit)
其中参数 autoCommit 表示是否自动提交事务，true表示自动提交事务，false表示手动提交事务。而开启事务需要将该参数设为为false。

2.提交事务：commit()

3.回滚事务 ：rollback()

代码实现如下：

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

public class JDBCDemo {
    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/itheima?useSSL=false";
        String username = "root";
        String password = "123456";
        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);

             int i = 3/0; // 构造程序异常，如需正常运行，注释该行即可

            //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();
    }
}

3.3 Statement

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

方法分类如下：

• executeUpdate​(String sql)：执行DDL、DML语句，返回受影响的行数，或者不返回内容。
• executeQuery​(String sql)：执行DQL语句，返回单个 ResultSet对象。

注：DQL语句涉及ResultSet对象，放到3.4节再讲述

3.3.1 执行DML语句

执行DML语句：使用executeUpdate​(String sql)方法执行DML语句，返回受影响的行数

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

public class JDBCDemo {
    public static void main(String[] args) throws Exception {

        // 1.注册驱动，mysql8的驱动会自动加载注册，此行可以注释掉
        // Class.forName("com.mysql.jdbc.Driver");

        // 2.获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/itheima?useSSL=false";
        String username = "root";
        String password = "123456";
        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.处理结果
        if(count > 0){
            System.out.println("修改成功~");
        }else{
            System.out.println("修改失败~");
        }

        //7. 释放资源
        stmt.close();
        conn.close();
    }
}

3.3.2 执行DDL语句

执行DDL语句：使用executeUpdate​(String sql)方法执行DDL语句，不返回内容

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

public class JDBCDemo {
    public static void main(String[] args) throws Exception {

        // 1.注册驱动，mysql8的驱动会自动加载注册，此行可以注释掉
        // Class.forName("com.mysql.jdbc.Driver");

        // 2.获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/itheima?useSSL=false";
        String username = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url, username, password);

        // 3.定义sql
        String sql = "alter table account add remark varchar(20)"; // 添加字段remark

        // 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();
    }
}

3.4 ResultSet

ResultSet（结果集对象）的作用：封装了SQL查询语句的结果，ResultSet executeQuery(sql)执行DQL 语句，返回 ResultSet 对象。

3.4.1 ResultSet对象方法

ResultSet 对象提供了操作查询结果数据的方法：

1.boolean next()：

• 将光标从当前位置向前移动一行
• 判断当前行是否为有效行
  • 返回true表示该行有效，即当前行有数据
  • 返回false表示该行无效，即当前行没有数据

2.xxx getXxx(参数)：获取该字段的数据，如 String getString​(String columnLabel) 、String getString​(int columnIndex)

• xxx : 表示数据类型
• 参数：
  • int类型的参数：列的编号，从1开始
  • String类型的参数： 列的名称

注：此处要注意，列的编号是从1开始的，而不是0

示例：一开始光标指定于第一行前，也就是指向表头行，当调用了 next() 方法后，光标就下移到第一行数据，并且方法返回true。
此时就可以通过 getInt("id") 获取当前行id字段的值，也可以通过 getString("name") 获取当前行name字段的值。
如果想获取下一行的数据，需要继续调用 next() 方法，以此类推。

3.4.2 执行DQL语句

执行DQL语句：使用executeQuery​(String sql)方法执行DQL语句，返回结果集

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

public class JDBCDemo {
    public static void main(String[] args) throws Exception {

        // 1.注册驱动，mysql8的驱动会自动加载注册，此行可以注释掉
        // Class.forName("com.mysql.jdbc.Driver");

        // 2.获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/itheima?useSSL=false";
        String username = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url, username, password);

        // 3.定义sql
        String sql = "select * from account";

        // 4.获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();

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

        // 6.处理结果，遍历rs中的所有数据
        // 光标向下移动一行，并且判断当前行是否有数据
        while (rs.next()){
            // 获取数据  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();
    }
}

运行结果如下：

对比数据库中查询的语句如下：

注：获取数据的方法也可以替换为以下

// 使用参数为列的名称
int id = rs.getInt("id");
String name = rs.getString("name");
double money = rs.getDouble("money");

// 使用参数为列的编号
int id = rs.getInt(1);
String name = rs.getString(2);
double money = rs.getDouble(3);

3.4.3 封装实体类

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

1.创建Account实体类，对应account账户表数据

public class Account {

    private Integer id; // ID
    private String name; // 姓名
    private Double money; // 余额

    public Integer getId() {
        return id;
    }

    public void setId(Integer 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;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

2.执行查询语句

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

/**
 * 查询account账户表数据，封装到Account对象中，并且存储到ArrayList集合中
 * 1. 定义实体类Account
 * 2. 查询数据，封装到Account对象中
 * 3. 将Account对象存入ArrayList集合中
 */
public class JDBCDemo {
    public static void main(String[] args) throws Exception {

        // 1.注册驱动，mysql8的驱动会自动加载注册，此行可以注释掉
        // Class.forName("com.mysql.jdbc.Driver");

        // 2.获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/itheima?useSSL=false";
        String username = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url, username, password);

        // 3.定义sql
        String sql = "select * from account";

        // 4.获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();

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

        List<Account> accountList = new ArrayList<>(); // 创建集合

        // 6.处理结果，遍历rs中的所有数据
        while (rs.next()){
            Account account = new Account(); // 创建account对象

            // 获取数据
            int id = rs.getInt("id");
            String name = rs.getString("name");
            double money = rs.getDouble("money");

            //给account对象赋值
            account.setId(id);
            account.setName(name);
            account.setMoney(money);
            
            accountList.add(account); // 存入集合
        }

        System.out.println(accountList);

        //7. 释放资源
        rs.close();
        stmt.close();
        conn.close();
    }
}

运行结果：

[Account{id=1, name='张三', money=3000.0}, Account{id=2, name='李四', money=2000.0}]

3.5 PreparedStatement

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

3.5.1 演示SQL注入

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

准备材料如下：百度网盘链接：https://pan.baidu.com/s/1vzYHt1y4fEvcnyTyiRRDDw ，提取码：d1wy

• sql.jar
• application.properties

1.修改application.properties文件，修改配置为自己本地的数据库用户名和密码

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/itheima?useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=123456

2.打开终端，输入命令运行程序

java -jar sql.jar

注：application.properties 和 sql.jar这两个文件需放在同一级目录下，否则会报错

3.运行后，会自动创建test数据库，并创建user表

user表内容如下：存放用户名和密码信息

4.在浏览器中输入 http://localhost:8080/login.html，进入登录页面，先测试登录页面是否有效。

输入正确的用户名和密码：zhangsan 和 123

输入错误的用户名和密码：

• zhangsan 和 1234
• abc 和 123

5.演示SQL注入，登录时用户名任意输入一个，但密码输入特定的字符串，发现可以登录成功。

输入用户名和密码如下：abc 和 ' or '1' ='1

3.5.2 分析SQL注入

代码模拟SQL注入的过程：

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

public class JDBCDemo {
    public static void main(String[] args) throws Exception {

        // 获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/test?useSSL=false";
        String username = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url, username, password);

        // 接收用户输入的用户名和密码，然后拼接成sql
        /*String name = "zhangsan";
        String pwd = "123";*/
        String name = "abc";
        String pwd = "' or '1' = '1";
        String sql = "select * from user where username = '"+name+"' and password = '"+pwd+"'";
        System.out.println(sql); // select * from user where username = 'abc' and password = '' or '1' = '1'

        // 获取Statement对象
        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 user where username = 'abc' and password = '' or '1' = '1'

从上面语句可以看出条件 username = 'abc' and password = '' 不管是否满足，而 or 后面的 '1' = '1' 是始终满足的，最终条件是成立的，就可以正常的进行登录了。

3.5.3 解决SQL注入

PreparedStatement：使用PreparedStatement对象，可以预防SQL注入问题。

PreparedStatement 对象的用法：

1.获取 PreparedStatement 对象

// SQL语句中的参数值，使用？占位符替代
String sql = "select * from user where username = ? and password = ?";

// 通过Connection对象获取，并传入对应的sql语句
PreparedStatement pstmt = conn.prepareStatement(sql);

2.设置参数值，也就是 ? 的值

上面的sql语句中参数使用 ? 进行占位，在执行sql之前肯定需要设置这些 ? 的值。

PreparedStatement对象提供了设置参数值的方法：setXxx(参数1，参数2)，如setString​(int parameterIndex, String x)

• Xxx：表示数据类型
• 参数：
  • 参数1： ? 的位置编号，从1 开始
  • 参数2： ? 的值

3.执行SQL语句

• executeUpdate()：执行DDL语句和DML语句
• executeQuery()：执行DQL语句

注：调用这两个方法时不需要传递SQL语句，因为获取SQL语句执行对象时已经对SQL语句进行预编译了

使用PreparedStatement改进：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class JDBCDemo {
    public static void main(String[] args) throws Exception {

        // 获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/test?useSSL=false";
        String username = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url, username, password);

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

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

        // 获取PreparedStatement对象
        PreparedStatement pstmt = conn.prepareStatement(sql);

        // 设置参数 ? 的值
        pstmt.setString(1,name);
        pstmt.setString(2,pwd);
        System.out.println(sql);

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

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

        // 释放资源
        rs.close();
        pstmt.close();
        conn.close();
    }
}

运行结果：SQL注入失败，登录失败

PreparedStatement是通过将特殊字符进行了转义，防止了SQL注入，转义的SQL语句如下：

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

3.5.4 PreparedStatement原理

PreparedStatement 好处：

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

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

Java代码操作数据库步骤如下：

• 将sql语句发送到MySQL服务器端

• MySQL服务端会对sql语句进行如下操作

  • 检查SQL语句

    检查SQL语句的语法是否正确

  • 编译SQL语句，将SQL语句编译成可执行的函数

    检查SQL和编译SQL花费的时间比执行SQL的时间还要长。如果我们只是重新设置参数，那么检查SQL语句和编译SQL语句将不需要重复执行。这样就提高了性能。

  • 执行SQL语句

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

1.开启预编译功能

在编写url时需要加上以下参数即可：

useServerPrepStmts=true

2.配置MySQL执行日志（重启mysql服务后生效）

在MySQL安装路径下，找到my.ini，修改日志相关的内容如下：

# General and Slow logging.
log-output=FILE
general-log=1
general_log_file="D:\mysqlLog\mysql.log"
slow-query-log=1
slow_query_log_file="D:\mysqlLog\mysql-slow.log"
long_query_time=2

Win+R 输入services.msc 打开服务，找到MySQL服务重启后，查看刚刚配置的日志路径下，文件是否生成，如果生成说明配置生效了。

3.编写测试代码

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class JDBCDemo {
    public static void main(String[] args) throws Exception {

        // 获取连接，useServerPrepStmts=true 参数开启预编译功能
        String url = "jdbc:mysql://127.0.0.1:3306/test?useSSL=false&useServerPrepStmts=true&allowPublicKeyRetrieval=true";
        String username = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url, username, password);

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

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

        // 获取PreparedStatement对象
        PreparedStatement pstmt = conn.prepareStatement(sql);

        // 执行第一次查询
        // Thread.sleep(5000);
        ResultSet rs = null;
        pstmt.setString(1,name);
        pstmt.setString(2,pwd);
        rs = pstmt.executeQuery();

        // 执行第二次查询
        pstmt.setString(1,"abc");
        pstmt.setString(2,"123");
        rs = pstmt.executeQuery();

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

        // 释放资源
        rs.close();
        pstmt.close();
        conn.close();
    }
}

运行代码后，打开mysql.log文件，查看打印的内容：

下图圈中的三行语句中，第一行的 Prepare 是对SQL语句进行预编译。第二行和第三行是执行了两次SQL语句，而第二次执行前并没有对SQL进行预编译。

总结：

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

4. 数据库连接池

4.1 数据库连接池概述

1.数据库连接池的概念：

• 数据库连接池是个容器，负责分配、管理数据库连接(Connection)
• 它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个
• 释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏

2.使用数据库连接池的好处：

• 资源重用
• 提升系统响应速度
• 避免数据库连接遗漏

之前我们代码中使用连接是没有使用都创建一个Connection对象，使用完毕就会将其销毁。这样重复创建销毁的过程是特别耗费计算机的性能的及消耗时间的。而数据库使用了数据库连接池后，就能达到Connection对象的复用，如下图：

连接池是在一开始就创建好了一些连接（Connection）对象存储起来。用户需要连接数据库时，不需要自己创建连接，而只需要从连接池中获取一个连接进行使用，使用完毕后再将连接对象归还给连接池，这样就可以起到资源重用，也节省了频繁创建连接销毁连接所花费的时间，从而提升了系统响应的速度。

3.数据库连接池的实现

标准接口：DataSource

官方(SUN) 提供的数据库连接池标准接口，由第三方组织实现此接口。该接口提供了获取连接的功能：

Connection getConnection()

那么以后就不需要通过 DriverManager 对象获取 Connection 对象，而是通过连接池（DataSource）获取 Connection 对象。

4.常见的数据库连接池

• DBCP
• C3P0
• Druid（常用）

4.2 Driud的使用

Druid（德鲁伊）：

• Druid连接池是阿里巴巴开源的数据库连接池项目
• 功能强大，性能优秀，是Java语言最好的数据库连接池之一

Driud的使用步骤如下：

• 导入jar包，如 druid-1.2.9.jar
• 定义配置文件
• 加载配置文件
• 获取数据库连接池对象
• 获取连接

1.jar包下载

Driud jar包下载地址：https://repo1.maven.org/maven2/com/alibaba/druid/

拉到最后，找到最新版本的jar包，点击下载：druid-1.2.9.jar

2.导入jar包，也就是将druid-1.2.9.jar拖入到项目的lib文件夹下并添加为库文件

3.src目录下，新建一个 driud.properties配置文件

4.编写driud.properties配置文件，内容如下：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/itheima?useSSL=false&useServerPrepStmts=true
username=root
password=123456
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000

5.编写druid的代码

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.util.Properties;

/**
 * Druid数据库连接池演示
 */
public class JDBCDemo {
    public static void main(String[] args) throws Exception {

        // 获取用户当前的工作目录
        // System.out.println(System.getProperty("user.dir"));

        // 1.导入jar包
        // 2.定义配置文件
        // 3.加载配置文件
        Properties prop = new Properties();
        prop.load(new FileInputStream("src/driud.properties"));

        // 4.获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        // 5.获取数据库连接 Connection
        Connection connection = dataSource.getConnection();
        System.out.println(connection); // 获取到了连接后就可以继续做其他操作了

    }
}

小技巧：可以通过 System.getProperty("user.dir")，获取用户当前的工作目录，从而知道加载文件的相对路径。

5. 案例练习

5.1 数据准备

需求：完成商品品牌数据的增删改查操作

• 查询：查询所有数据
• 添加：添加品牌
• 修改：根据id修改
• 删除：根据id删除

1.创建数据库表 tb_brand

-- 删除tb_brand表
drop table if exists tb_brand;

-- 创建tb_brand表
create table tb_brand (
    id int primary key auto_increment, -- id主键
    brand_name varchar(20), -- 品牌名称
    company_name varchar(20), -- 企业名称
    ordered int, -- 排序字段
    description varchar(100), -- 描述信息
    status int -- 状态：0：禁用  1：启用
);

-- 向tb_brand表插入数据
insert into tb_brand (brand_name, company_name, ordered, description, status)
values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
       ('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),
       ('小米', '小米科技有限公司', 50, 'are you ok', 1);
       
-- 查询tb_brand表
select * from tb_brand;

2.在pojo包下创建实体类 Brand

package com.itheima.pojo;

/**
 * 品牌
 * 在实体类中，基本数据类型建议使用其对应的包装类型
 */
public class Brand {

    private Integer id; // id 主键
    private String brandName;  // 品牌名称
    private String companyName; // 企业名称
    private Integer ordered; // 排序字段
    private String description; // 描述信息
    private Integer status;  // 状态：0：禁用  1：启用

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getBrandName() {
        return brandName;
    }

    public void setBrandName(String brandName) {
        this.brandName = brandName;
    }

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    public Integer getOrdered() {
        return ordered;
    }

    public void setOrdered(Integer ordered) {
        this.ordered = ordered;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "Brand{" +
                "id=" + id +
                ", brandName='" + brandName + '\'' +
                ", companyName='" + companyName + '\'' +
                ", ordered=" + ordered +
                ", description='" + description + '\'' +
                ", status=" + status +
                '}';
    }
}

项目结构如下：

5.2 查询所有

/**
 * 查询所有
 * 1. SQL：select * from tb_brand;
 * 2. 参数：不需要
 * 3. 结果：List<Brand>
 */
@Test
public void selectAll() throws Exception{

    // 加载配置文件，并获取连接池对象
    Properties prop = new Properties();
    prop.load(new FileInputStream("src/driud.properties"));
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

    // 获取数据库连接
    Connection conn = dataSource.getConnection();

    // 定义sql
    String sql = "select * from tb_brand";

    // 获取PreparedStatement对象
    PreparedStatement pstmt = conn.prepareStatement(sql);

    // 执行查询语句
    ResultSet rs = pstmt.executeQuery();
    List<Brand> brandList = new ArrayList<>();
    Brand brand = null;

    while (rs.next()){
        // 获取数据
        int id = rs.getInt("id");
        String brandName = rs.getString("brand_name");
        String companyName = rs.getString("company_name");
        int ordered = rs.getInt("ordered");
        String description = rs.getString("description");
        int status = rs.getInt("status");

        //封装Brand对象
        brand = new Brand();
        brand.setId(id);
        brand.setBrandName(brandName);
        brand.setCompanyName(companyName);
        brand.setOrdered(ordered);
        brand.setDescription(description);
        brand.setStatus(status);

        // 存入集合
        brandList.add(brand);
    }

    System.out.println(brandList);

    // 释放资源
    rs.close();
    pstmt.close();
    conn.close();
}
    

运行结果如下：

5.3 添加数据

/**
 * 添加
 * 1. SQL：insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);
 * 2. 参数：需要，除了id之外的所有参数信息
 * 3. 结果：boolean
 */
@Test
public void add() throws Exception{

    // 页面提交的数据
    String brandName = "香飘飘";
    String companyName = "香飘飘";
    int ordered = 1;
    String description = "绕地球一圈";
    int status = 1;

    // 加载配置文件，并获取连接池对象
    Properties prop = new Properties();
    prop.load(new FileInputStream("src/driud.properties"));
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

    // 获取数据库连接
    Connection conn = dataSource.getConnection();

    // 定义sql
    String sql = "insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?)";

    // 获取PreparedStatement对象
    PreparedStatement pstmt = conn.prepareStatement(sql);

    // 设置参数
    pstmt.setString(1,brandName);
    pstmt.setString(2,companyName);
    pstmt.setInt(3,ordered);
    pstmt.setString(4,description);
    pstmt.setInt(5,status);

    // 执行插入语句
    int count = pstmt.executeUpdate();
    System.out.println(count > 0);

    // 释放资源
    pstmt.close();
    conn.close();
}

运行上述代码后，查询品牌表：

5.4 修改数据

/**
 * 修改
 * 1. SQL：
 update tb_brand
 set brand_name = ?, company_name  = ?, ordered = ?, description = ?, status = ?
 where id = ?
 * 2. 参数：需要，所有数据
 * 3. 结果：boolean
 */
@Test
public void update() throws Exception{

    // 页面提交的数据
    String brandName = "香飘飘";
    String companyName = "香飘飘";
    int ordered = 1000;
    String description = "绕地球三圈";
    int status = 1;
    int id = 4;

    // 加载配置文件，并获取连接池对象
    Properties prop = new Properties();
    prop.load(new FileInputStream("src/driud.properties"));
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

    // 获取数据库连接
    Connection conn = dataSource.getConnection();

    // 定义sql
    String sql = "update tb_brand\n" +
            "set brand_name = ?, company_name  = ?, ordered = ?, description = ?, status = ?\n" +
            "where id = ?";

    // 获取PreparedStatement对象
    PreparedStatement pstmt = conn.prepareStatement(sql);

    // 设置参数
    pstmt.setString(1,brandName);
    pstmt.setString(2,companyName);
    pstmt.setInt(3,ordered);
    pstmt.setString(4,description);
    pstmt.setInt(5,status);
    pstmt.setInt(6,id);

    // 执行更新语句
    int count = pstmt.executeUpdate();
    System.out.println(count > 0);

    // 释放资源
    pstmt.close();
    conn.close();
}

运行上述代码后，查询品牌表：

5.5 删除数据

/**
 * 删除
 * 1. SQL：delete from tb_brand where id = ?
 * 2. 参数：需要，id
 * 3. 结果：boolean
 */
@Test
public void deleteById() throws Exception{

    // 页面提交的数据
    int id = 4;

    // 加载配置文件，并获取连接池对象
    Properties prop = new Properties();
    prop.load(new FileInputStream("src/driud.properties"));
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

    // 获取数据库连接
    Connection conn = dataSource.getConnection();

    // 定义sql
    String sql = "delete from tb_brand where id = ?";

    // 获取PreparedStatement对象
    PreparedStatement pstmt = conn.prepareStatement(sql);

    // 设置参数
    pstmt.setInt(1,id);

    // 执行删除语句
    int count = pstmt.executeUpdate();
    System.out.println(count > 0);

    // 释放资源
    pstmt.close();
    conn.close();
}

运行上述代码后，查询品牌表：