JDBC基础

1、JDBC概述

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

1.1 JDBC概念

JDBC 就是使用Java语言操作关系型数据库的一套API

全称：( Java DataBase Connectivity ) Java 数据库连接

我们开发的同一套Java代码是无法操作不同的关系型数据库，因为每一个关系型数据库的底层实现细节都不一样。如果这样，问题就很大了，在公司中可以在开发阶段使用的是MySQL数据库，而上线时公司最终选用oracle数据库，我们就需要对代码进行大批量修改，这显然并不是我们想看到的。我们要做到的是同一套Java代码操作不同的关系型数据库，而此时sun公司就指定了一套标准接口（JDBC），JDBC中定义了所有操作关系型数据库的规则。众所周知接口是无法直接使用的，我们需要使用接口的实现类，而这套实现类（称之为：驱动）就由各自的数据库厂商给出。

1.2 JDBC本质

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

1.3 JDBC好处

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

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

2、JDBC快速入门

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

第一步：编写Java代码
第二步：Java代码将SQL发送到MySQL服务端
第三步：MySQL服务端接收到SQL语句并执行该SQL语句
第四步：将SQL语句执行的结果返回给Java代码

2.1 步骤分析

2.2 环境搭建

创建一个新工程：day03-jdbc

定义项目的名称，并指定位置，工程名称规范一些，时间长了不好管理的。

对项目进行设置，JDK版本、编译版本

导入驱动包：将mysql的驱动包放在工程下的lib目录（随意命名，建议用lib）下，并将该jar包添加为库文件

在添加为库文件的时候，有如下三个选项，选 Project Library。这个区别不大
- Global Library ：全局有效
- Project Library : 项目有效
- Module Library ：模块有效

在 src 下创建 com.itheima.jdbc.JdbcDemo1 类

2.3 完整代码

package com.itheima.jdbc;

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

/**
 * JDBC入门案例 步骤：
 * ***** 1.注册驱动，告诉程序使用哪个jar包
 * ***** 2.获取连接
 * ***** 3.获取执行SQL语句的执行者对象
 * ***** 4.执行SQL语句
 * ***** 5.处理结果
 * ***** 6.释放资源
 */
public class JdbcDemo01 {

    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1 注册驱动，告诉程序使用哪个jar包
        Class.forName("com.mysql.jdbc.Driver"); //加载class文件进内存

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

        //3 获取执行SQL语句的执行者对象
        PreparedStatement ps = conn.prepareStatement("update account set money=1000 where id=1");

        //4 执行SQL语句
        int count = ps.executeUpdate();

        //5 处理结果
        System.out.println("影响的行数 " + count);

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

3、JDBC API详解

3.1 DriverManager 对象

DriverManager（驱动管理类）

3.1.1 作用一：注册驱动

registerDriver方法是用于注册驱动的，但是我们之前做的入门案例并不是这样写的。而是如下实现

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

我们查询MySQL提供的Driver类，看它是如何实现的，源码如下：

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

==提示：==

MySQL 5之后的驱动包，可以省略注册驱动的步骤

自动加载jar包中META-INF/services/java.sql.Driver文件中的驱动类

3.1.2 作用二：获取数据库连接

参数说明：

url ：连接路径

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

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

==细节：==

如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称?参数键值对

配置 useSSL=false 参数，禁用安全连接方式，解决警告提示

user ：用户名

poassword ：密码

3.1.3 代码实现

package com.itheima.jdbc;

import com.mysql.jdbc.Driver;

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

/**
 * DriverManager 对象详解
 */
public class JdbcDemo02_DriverManager {

    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1 注册驱动，告诉程序使用哪个jar包
        Class.forName("com.mysql.jdbc.Driver"); //加载class文件进内存
        DriverManager.registerDriver(new Driver());   //会注册两次

        //2 获取连接
        //String url="jdbc:mysql://localhost:3306/d2?useSSL=false";
        //连接本地数据库，url可以简写，省略localhost:3306
        String url = "jdbc:mysql:///db2?useSSL=false";
        String username = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, username, password);

        //3 获取执行SQL语句的执行者对象
        PreparedStatement ps = conn.prepareStatement("update account set money=1000 where id=1");

        //4 执行SQL语句
        int count = ps.executeUpdate();

        //5 处理结果
        System.out.println("影响的行数 " + count);

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

3.2 Connection 对象

Connection（数据库连接对象）

3.2.1 作用一：获取执行SQL对象

普通执行SQL对象
```
Statement createStatement()
```

预编译SQL的执行SQL对象：防止SQL注入
```
PreparedStatement  prepareStatement(sql)
```
通过这种方式获取的 PreparedStatement SQL语句执行对象是我们重点要进行讲解的，它可以防止SQL注入。

执行存储过程的对象

CallableStatement prepareCall(sql)

通过这种方式获取的 CallableStatement 执行对象是用来执行存储过程的，而存储过程在MySQL中不常用，所以这个我们将不进行讲解。

3.2.2 作用二：事务管理

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

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

MySQL默认是自动提交事务

接下来学习JDBC事务管理的方法。Connection几口中定义了3个对应的方法：

开启事务

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

回滚事务

3.2.3 代码实现

package com.itheima.jdbc;

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

/**
 * Connection 对象详解
 */
public class JdbcDemo03_Connection {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1 注册驱动，告诉程序使用哪个jar包
        Class.forName("com.mysql.jdbc.Driver"); //加载class文件进内存

        //2 获取连接
        String url = "jdbc:mysql://localhost:3306/db2?useSSL=false";
        String username = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, username, password);
        PreparedStatement ps1 = null;
        PreparedStatement ps2 = null;
        //ctrl+alt+t
        try {
            // ============开启事务==========
            conn.setAutoCommit(false);
            //需求：事务管理：  张三向李四借500元
            //3 获取执行SQL语句的执行者对象
            ps1 = conn.prepareStatement("update account set money=money-500 where id=2");
            ps2 = conn.prepareStatement("update account set money=money+500 where id=1");
            //4 执行SQL语句
            ps1.executeUpdate();
            int i = 1 / 0;  //制造异常
            ps2.executeUpdate();
            // ============提交事务==========
            //程序运行到此处，说明没有出现任何问题，则需求提交事务
            conn.commit();
        } catch (Exception ex) {   //出现任何异常都要回滚
            ex.printStackTrace();
            // ============回滚事务==========
            //程序在出现异常时会执行到这个地方，此时就需要回滚事务
            conn.rollback();
        }
        //5 释放资源
        ps1.close();
        ps2.close();
        conn.close();
    }
}

3.3 PreparedStatement 对象

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

3.3.1 作用一：执行DML语句

3.3.2 作用二：执行DQL语句

该方法涉及到了 ResultSet 对象，而这个对象我们还没有学习，一会再重点讲解。

3.3.3 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语句进行预编译了。

3.3.4 代码实现

package com.itheima.jdbc;

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

/**
 * PreparedStatement 对象详解
 */
public class JdbcDemo04_PreparedStatement {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1 注册驱动，告诉程序使用哪个jar包
        Class.forName("com.mysql.jdbc.Driver"); //加载class文件进内存

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

        //3 获取执行SQL语句的执行者对象
        //3.1 在SQL语句中使用?作为参数的占位符
        PreparedStatement ps = conn.prepareStatement("update account set money=? where id=?");
        //3.2 给SQL中的？设置参数值
        ps.setDouble(1, 3000);  //参数1表示第几个?。参数2表示给?设置的值
        ps.setInt(2, 2);

        //4 执行SQL语句
        int count = ps.executeUpdate();
        System.out.println("影响的行数 " + count);

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

3.4 ResultSet 对象

ResultSet（结果集对象）作用：封装了SQL查询语句的结果。而执行了DQL语句后就会返回该对象，对应执行DQL语句的方法如下：

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

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

3.4.1 作用一：获取下一行数据

boolean next()

将光标从当前位置向前移动一行

判断当前行是否为有效行

方法返回值说明：

true ：有效航，当前行有数据

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

3.4.2 作用二：获取某一列的值

xxx getXxx(参数)：获取数据

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

参数

int类型的参数：列的编号，从1开始

String类型的参数：列的名称

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

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

3.4.2 代码实现

package com.itheima.jdbc;

import java.sql.*;

/**
 * ResultSet 对象详解
 */
public class JdbcDemo05_ResultSet {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1 注册驱动，告诉程序使用哪个jar包
        Class.forName("com.mysql.jdbc.Driver"); //加载class文件进内存

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

        //3 获取执行SQL语句的执行者对象
        PreparedStatement ps = conn.prepareStatement("select * from account");

        //4 执行SQL语句
        ResultSet rs = ps.executeQuery();   //结果集

        //5 处理结果，遍历获取结果
        while (rs.next()) {  //返回true表示有数据
            //获取每一行的数据
            int id = rs.getInt("id");
            String name = rs.getString("name");
            double money = rs.getDouble("money");
            System.out.println(id + "," + name + "," + money);
        }

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

4、JDBC练习

4.1 需求：商品品牌管理

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

查询：查询所有数据

添加：添加品牌

修改：根据id修改

删除：根据id删除

4.2 案例功能实现

4.2.1 环境准备

数据库 db2

create database if not exists db2;

数据库表 tb_brand

use db2;
-- 删除tb_brand表
drop table if exists tb_brand;
-- 创建tb_brand表
create table tb_brand (
    -- id 主键
    id int primary key auto_increment,
    -- 品牌名称
    brand_name varchar(20),
    -- 企业名称
    company_name varchar(20),
    -- 排序字段
    ordered int,
    -- 描述信息
    description varchar(100),
    -- 状态：0：禁用  1：启用
    status int
);
-- 添加数据
insert into tb_brand (brand_name, company_name, ordered, description, status)
values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
       ('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),
       ('小米', '小米科技有限公司', 50, 'are you ok', 1);

在 com.itheima.pojo 包下实体类 Brand

为什么要创建一个实体Brand类？因为将来要操作tb_brand表，数据封装会方便一些。

package com.itheima.pojo;

/**
 * 品牌
 * alt + 鼠标左键：整列编辑
 * 在实体类中，基本数据类型建议使用其对应的包装类型
 */
public class Brand {

    private int id; //主键
    private String brandName; //品牌名称
    private String companyName; //公司名称
    private int ordered; //排序
    private String description; //描述
    private int status; //状态

    //省略 set、get方法
}

4.2.2 查询所有品牌

我们需要先创建一个 BrandDao 的类，后续在类中添加增删改查的方法

4.2.2.1 编写BrandDao的selectAll方法

/**
 * dao：表示数据访问层，这一层的代码将来都是和数据库打交道的。
 * 也就是说，这个类中将来会提供很多方法，这些方法都是做增删改查的。
 * 其他类调用方式如下：
 *      BrandDao brandDao=new BrandDao();
 *      brandDao.xxxx方法(参数);
 */
public class BrandDao {

    /**
       * 查询所有
       * 1. SQL：select * from tb_brand;
       * 2. 参数：不需要
       * 3. 结果：List<Brand>
       */
    public List<Brand> selectAll() throws Exception {
        //1 注册驱动，获取连接对象 Connection
        Class.forName("com.mysql.jdbc.Driver");
        String url="jdbc:mysql://localhost:3306/db2";   //连接路径，表示连接哪个数据库
        String username="root";
        String password="root";
        Connection conn = DriverManager.getConnection(url,username,password);
        //2 定义SQL
        String sql="select * from tb_brand";
        //3 获取PreparedStatement对象，预编译SQL
        PreparedStatement pstmt = conn.prepareStatement(sql);
        //4 如果SQL用有？占位符，就设置参数
        //5 执行SQL，获取结果
        ResultSet rs = pstmt.executeQuery();
        //6 处理结果
        List<Brand> brands=new ArrayList<>();
        while (rs.next()){
            //6.1 获取每一行数据
            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");
            //6.2 封装成Brand对象
            Brand brand=new Brand();
            brand.setId(id);
            brand.setBrandName(brandName);
            brand.setCompanyName(companyName);
            brand.setOrdered(ordered);
            brand.setDescription(description);
            brand.setStatus(status);
            //6.3 保存到List集合中
            brands.add(brand);
        }
        //7 释放资源
        rs.close();
        pstmt.close();
        conn.close();
        //返回结果
        return brands;
    } 
}

4.2.2.2 编写测试类方法

/**
 * 测试品牌的增删改查操作
 */
public class BrandTest {

    /**
     * 测试查询所有品牌信息
     */
    @Test
    public void testSelectAll() throws Exception {
        //1 创建BrandDao对象
        BrandDao brandDao = new BrandDao();
        //2 调用方法，获取结果
        List<Brand> brandList = brandDao.selectAll();
        //3 打印结果
        brandList.forEach(brand -> System.out.println(brand));
    }
}

4.2.3 添加数据

4.2.3.1 编写BrandDao的add方法

/**
     * 添加品牌信息
     SQL：insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);
     * @param brand 要添加的品牌对象
     * @return true表示添加成功，false表示添加失败
     */
public boolean add(Brand brand) throws Exception {
    //1 注册驱动，获取连接对象 Connection
    Class.forName("com.mysql.jdbc.Driver");
    String url="jdbc:mysql://localhost:3306/db2";   //连接路径，表示连接哪个数据库
    String username="root";
    String password="root";
    Connection conn = DriverManager.getConnection(url,username,password);
    //2 定义SQL
    String sql="insert into tb_brand values(null,?,?,?,?,?)";
    //3 获取PreparedStatement对象，预编译SQL
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4 如果SQL用有？占位符，就设置参数
    pstmt.setString(1,brand.getBrandName());
    pstmt.setString(2,brand.getCompanyName());
    pstmt.setInt(3,brand.getOrdered());
    pstmt.setString(4,brand.getDescription());
    pstmt.setInt(5,brand.getStatus());
    //5 执行SQL，获取结果
    int count = pstmt.executeUpdate();
    //6 处理结果
    //boolean flag=count>0;
    //7 释放资源
    pstmt.close();
    conn.close();
    //返回结果
    return count>0;
}

4.2.3.2 编写测试类方法

@Test
public void testAdd() throws Exception {
    //1 创建BrandDao对象
    BrandDao brandDao = new BrandDao();
    //2 调用add方法
    Brand brand = new Brand();
    brand.setBrandName("鸿星尔克");
    brand.setCompanyName("鸿星尔克有限公司");
    brand.setOrdered(100);
    brand.setDescription("to be No.1");
    brand.setStatus(1);
    boolean flag = brandDao.add(brand);
    //3 打印结果
    System.out.println(flag ? "添加成功~" : "添加失败~");
}

4.2.4 修改数据

4.2.4.1 编写BrandDao的update方法

/**
     * 修改品牌信息
     SQL： update tb_brand
             set brand_name  = ?,
             company_name= ?,
             ordered     = ?,
             description = ?,
             status      = ?
         where id = ?
     * @param brand 要修改的品牌对象
     * @return true表示修改成功，false表示修改失败
     */
public boolean update(Brand brand) throws Exception {
    //1 注册驱动，获取连接对象 Connection
    Class.forName("com.mysql.jdbc.Driver");
    String url="jdbc:mysql://localhost:3306/db2";   //连接路径，表示连接哪个数据库
    String username="root";
    String password="root";
    Connection conn = DriverManager.getConnection(url,username,password);
    //2 定义SQL
    String sql="update tb_brand set brand_name= ?,company_name=?,ordered= ?,description = ?,status= ? where id=?";
    //3 获取PreparedStatement对象，预编译SQL
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4 如果SQL用有？占位符，就设置参数
    pstmt.setString(1,brand.getBrandName());
    pstmt.setString(2,brand.getCompanyName());
    pstmt.setInt(3,brand.getOrdered());
    pstmt.setString(4,brand.getDescription());
    pstmt.setInt(5,brand.getStatus());
    pstmt.setInt(6,brand.getId());
    //5 执行SQL，获取结果
    int count = pstmt.executeUpdate();
    //6 处理结果
    //boolean flag=count>0;
    //7 释放资源
    pstmt.close();
    conn.close();
    //返回结果
    return count>0;
}

4.2.4.2 编写测试类代码

@Test
public void testUpdate() throws Exception {
    //1 创建BrandDao对象
    BrandDao brandDao = new BrandDao();
    //2 调用update方法
    Brand brand = new Brand();
    brand.setId(4);
    brand.setBrandName("海澜之家");
    brand.setCompanyName("海澜之家有限公司");
    brand.setOrdered(100);
    brand.setDescription("男人的衣柜");
    brand.setStatus(2);
    boolean flag = brandDao.update(brand);
    //3 打印结果
    System.out.println(flag ? "修改成功~" : "修改失败~");
}

4.2.5 删除数据

4.2.5.1 编写BrandDao的delete方法

/**
     * 删除品牌信息
     SQL：delete from tb_brand where id = ?
     * @param id 要删除的品牌id
     * @return true表示删除成功，false表示删除失败
     */
public boolean delete(int id) throws Exception {
    //1 注册驱动，获取连接对象 Connection
    Class.forName("com.mysql.jdbc.Driver");
    String url="jdbc:mysql://localhost:3306/db2";   //连接路径，表示连接哪个数据库
    String username="root";
    String password="root";
    Connection conn = DriverManager.getConnection(url,username,password);
    //2 定义SQL
    String sql="delete from tb_brand where id=?";
    //3 获取PreparedStatement对象，预编译SQL
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4 如果SQL用有？占位符，就设置参数
    pstmt.setInt(1,id);
    //5 执行SQL，获取结果
    int count = pstmt.executeUpdate();
    //6 处理结果
    //boolean flag=count>0;
    //7 释放资源
    pstmt.close();
    conn.close();
    //返回结果
    return count>0;
}

4.2.5.2 编写测试类代码

@Test
public void testDelete() throws Exception {
    //1 创建BrandDao对象
    BrandDao brandDao = new BrandDao();
    //2 调用delete方法
    boolean flag = brandDao.delete(4);
    //3 打印结果
    System.out.println(flag ? "删除成功~" : "删除失败~");
}

5、数据库连接池

5.1 数据库连接池简介

数据库连接池是个容器，负责分配、管理数据库连接(Connection)

它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；

资源重用

提升系统响应速度

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

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

5.2 数据库连接池实现

标准接口：==DataSource==
- 官方(SUN) 提供的数据库连接池标准接口，由第三方组织实现此接口。该接口提供了获取连接的功能：
- 那么以后就不需要通过 DriverManager 对象获取 Connection 对象，而是通过连接池（DataSource）获取 Connection 对象。
```
Connection getConnection()
```
常见的数据库连接池，我们现在使用更多的是Druid，它的性能比其他两个会好一些。
- DBCP
- C3P0
- Druid
Druid（德鲁伊）
- Druid连接池是阿里巴巴开源的数据库连接池项目
- 功能强大，性能优秀，是Java语言最好的数据库连接池之一

5.3 Driud使用

导入jar包 druid-1.1.12.jar

定义配置文件

加载配置文件

获取数据库连接池对象

获取连接

现在通过代码实现，首先需要先将druid的jar包放到项目下的lib下并添加为库文件

项目结构如下：

在 src 目录下，创建配置文件 druid.properties ，如下：

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

使用druid的代码如下：

package com.itheima.druid;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Properties;

/**
 * Druid数据库连接池演示
 */
public class DruidDemo {

    public static void main(String[] args) throws Exception {
        //1.导入jar包
        //2.定义配置文件
        //3. 加载配置文件
        Properties properties = new Properties();
        //读取文件，得到inputStream输入流
        InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        //加载数据
        properties.load(is);
        //4. 获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);

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

        //6. 获取执行SQL语句的执行者对象
        PreparedStatement ps = conn.prepareStatement("update account set money=1000 where id=1");

        //7. 执行SQL语句
        int count = ps.executeUpdate();

        //8. 处理结果
        System.out.println("影响的行数 " + count);

        //9. 归还连接到连接池
        ps.close();
        conn.close();
    }
}