概念

数据库连接池其实就是一个容器，而这个容器其实就是一个集合，这个集合存放着多个数据库连接对象。
系统在初始化的时候，将创建一定数量的数据库连接放到连接池中。当应用程序要访问数据库的时候，会向连接池请求连接对象，访问结束后会将连接对象还给连接池。当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。

数据库连接池也叫数据源，英文名叫 DataSource。

比方说创建连接池对象后，会创建 30 个连接对象放入连接池（连接池是一个集合）中，那么请求过来要和数据库取得连接，就只能从连接池获取连接对象和数据库通讯，用完后再放回连接池中，也就是说所有的用户请求共享池中30个连接对象，可以同时保持30个连接，如果连接池没有对象了，其它的连接请求只能处于等待中直到池中有连接对象为止。

好处

节约资源、数据库访问高效

以前每个请求就创建一个连接对象，那么100 万个请求就创建 100 万个连接对象，数据库可能无法承受；另外如果很多连接对象创建完后不关闭，那么就会严重占用服务器内存，当请求数量急剧上升，数据库就会崩溃掉。

因为这样的方式创建的连接对象是无法提供给其它请求使用，没有关闭就闲置在内存中，即便同一个用户发送相同的请求还是会创建一个新的连接对象，造成严重的资源浪费。另外频繁创建新的连接对象会耗费没有必要的时间和资源！

实现

标准接口：DataSource，在 javax. sql 包下的。

提供的方法：
1.获取连接：getConnection()
2.归还连接：close()。如果连接对象 Connection 是从连接池中获取的，那么调用 close() 方法则不会再关闭连接了。而是归还连接

一般我们不去实现它，由数据库厂商来实现。

1.C3P0：数据库连接池实现技术
2.Druid：数据库连接池实现技术，由阿里巴巴提供的，全球最好的连接池技术之一

C3P0

使用步骤：
1.导入jar包(两个) c3p0-0.9.5.2.jar 和 mchange - commons -java-0.2.12.jar，注意别忘了导入数据库驱动包
2.定义配置文件：
名称： c3p0.properties 或者 c3p0- config.xml
路径：将文件放在src目录下即可。
3.创建数据库连接池对象 ComboPool edDataSource
4.获取连接：getConnection

基本使用

public static void main(String[] args) {
        // 创建连接池对象
        DataSource ds = new ComboPooledDataSource();
        // 获取连接对象
        try {
            Connection conn = ds.getConnection();
            System.out.println(conn);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

配置文件

<?xml version="1.0" encoding="utf-8"?>
<c3p0-config>
    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/test</property>
        <property name="user">root</property>
        <property name="password">123</property>
		<!--连接池初始化的时候创建5个连接对象-->
        <property name="initialPoolSize">5</property>
        <!--连接池中最多存放10个连接对象-->
        <property name="maxPoolSize">10</property>
        <property name="checkoutTimeout">3000</property>
    </default-config>

    <!--其它连接配置-->
    <named-config name="otherc3p0">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/test</property>
        <property name="user">root</property>
        <property name="password">lwx83129LWX@!</property>

        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">10</property>
        <property name="checkoutTimeout">3000</property>
    </named-config>
</c3p0-config>

<named-config> 可以配置其它数据库连接信息，那么在 Java 代码中，可以指定名称来获取对应的数据库连接配置信息创建连接池对象，从而达到动态切换数据库的目的。

// 创建连接池对象
DataSource ds = new ComboPooledDataSource("otherc3p0");

druid

数据库连接池实现技术，由阿里巴巴提供的

步骤:
1.导入 jar 包 druid-1.2.8.jar
2.定义配置文件：是 properties 形式的。可以叫任意名称，可以放在任意目录下，需要手动指定文件路径
3.加载配置文件
4.获取数据库连接池对象：通过工厂类 DruidDataSourceFactory 来获取
5.获取连接对象：getConnection

下载 jar 包

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

配置文件

# driverClassName=com.mysql.jdbc.Driver 这个驱动类已经过时了
# driverClassName=com.mysql.cj.jdbc.Driver 这个驱动类是最新的，但是驱动程序通过SPI自动注册，通常不需要手动加载驱动程序类。
# 如果是数据库在本地，且端口号是3306，则可以简写成：jdbc:mysql:///test
url=jdbc:mysql://localhost:3306/test
username=root
password=123

# 连接池初始化时会生成5个连接对象
initialSize=5
# 连接池中最多10个连接对象，已经达到10个连接对象了，若继续向连接池申请连接对象会报错
maxActive=10

# 等待时间，向连接池申请连接对象时，最多等待3秒种，3秒内没有获取到连接对象会报错
maxWait=3000

演示代码

 public static void main(String[] args) {
        // 导入jar包
        // 定义配置文件
        // 加载配置文件
        Properties prop = new Properties();
        Class<DruidDemo01> dd = DruidDemo01.class;
        InputStream is = dd.getClassLoader().getResourceAsStream("druid.properties");
        try {
            prop.load(is);
            // 创建连接池对象
            DataSource ds = DruidDataSourceFactory.createDataSource(prop);
            Connection conn = ds.getConnection();
            System.out.println(conn);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

定义工具类

1.定义一个类 JDBCUtils
2.提供静态代码块加载配置文件，初始化连接池对象
3.提供方法
3.1.获取连接对象方法:通过数据库连接池获取连接对象
3.2.释放资源，归还连接对象
3.3.获取连接池对象的方法

示例代码

package priv.lwx.javaex.datasource.util;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * 使用druid连接池实现的JDBC工具类
 *
 * @author liaowenxiong
 * @date 2021/11/18 15:30
 */

public class JDBCUtils {
    // 声明静态变量
    private static DataSource ds;

    // 通过静态代码块初始化连接池
    static {
        // 1.加载配置文件
        InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
        Properties prop = new Properties();
        try {
            prop.load(is);
            // 2.获取连接池对象
            ds = DruidDataSourceFactory.createDataSource(prop);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取连接对象
     *
     * @return java.sql.Connection
     * @author liaowenxiong
     * @date 2021/11/18 15:40
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    /**
     * 关闭语句对象和连接对象
     *
     * @param stmt 被关闭的语句对象
     * @param conn 被关闭的连接对象
     * @return void
     * @author liaowenxiong
     * @date 2021/11/16 17:57
     */
    public static void close(Statement stmt, Connection conn) {

        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 关闭语句对象，释放语句对象资源
     *
     * @param stmt 关闭的语句对象
     * @return 无
     * @author liaowenxiong
     * @date 2021/11/17 18:08
     */
    public static void close(Statement stmt) {

        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }


    public static void close(ResultSet rs, Statement stmt, Connection conn) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 释放一个连接对象，多个语句对象资源
     *
     * @param conn  释放的连接对象
     * @param stmts 释放的多个语句对象
     * @return 无
     * @author liaowenxiong
     * @date 2021/11/17 18:09
     */

    public static void close(Connection conn, Statement... stmts) {

        if (stmts != null && stmts.length != 0) {
            for (int i = 0; i < stmts.length; i++) {
                Statement stmt = stmts[i];
                close(stmt);
            }
        }


        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 获取连接池
     *
     * @return javax.sql.DataSource
     * @author liaowenxiong
     * @date 2021/11/18 15:53
     */
    public static DataSource getDataSource() {

        return ds;
    }

    public static void main(String[] args) throws SQLException {

    }
}