JDBC系列（上篇）——数据连接池的应用

前言

我们在开发过程中，所有业务数据最终都是要持久化到数据库中的，java为了方便管理推出了jdbc接口供其他数据库厂商去实现，数据落库的需求虽然得到了解决，但开发持久层的过程中还是有一些问题暴露了出来，本篇文章将围绕JDBC频繁连接数据库消耗资源的问题，引出数据连接池DataSource的使用。希望能够给各位读者提供参考。

想要了解更多原始JDBC的其他优化，可以参考同系列下篇：
JDBC系列（下篇）——JDBC Template的使用

---

一、使用数据连接池的背景

在聊DataSource之前，我们先来回顾一下我们使用原生的数据库API是如何查询数据的。
我们每次执行sql时需要完成的步骤大致有以下几步：

1. 注册数据库驱动

2. 创建数据库连接对象

3. 执行sql

4. 封装数据

5. 关闭连接资源

public class UserDaoImpl implements UserDao {


    public List<User> queryUserByName(String name) throws IOException {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;
        // 读取配置文件获取配置
        String driver = getValueFromProperty("driver");
        String url = getValueFromProperty("url");
        String user = getValueFromProperty("user");
        String password = getValueFromProperty("password");
        //注册mysql驱动
        try {
            Class.forName(driver);
            // 获取连接
            connection = DriverManager.getConnection(url, user, password);
            ps = connection.prepareStatement("select * from user where username = ?");
            ps.setString(1, name);
            resultSet = ps.executeQuery();
            // 封装List对象
            List<User> list = new ArrayList<User>();
            while (resultSet.next()) {
                Integer uid = resultSet.getInt(1);
                String username = resultSet.getString(2);
                String uPassword = resultSet.getString(3);
                list.add(new User(uid, username, uPassword));
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            this.close(resultSet, ps, connection);
        }
        return null;
    }

    private String getValueFromProperty(String key) throws IOException {
        Properties pro = new Properties();
        //获取src路径下的文件的方式--->ClassLoader 类加载器
        ClassLoader classLoader = UserDaoImpl.class.getClassLoader();
        URL res = classLoader.getResource("jdbc.properties");
        String path = res.getPath();
        //2. 加载文件
        pro.load(new FileReader(path));
        //3. 获取数据，赋值
        return pro.getProperty(key);
    }

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

}

我们可以发现，除了执行sql外会有不同之外，注册驱动、创建连接对象和释放资源的动作都是一样的，我们虽然可以通过封装成工具类来简化开发，资源的创建和释放问题还是没有得到解决。每次执行sql语句时数据库都需要去创建一个连接进行使用，用完连接后直接关闭。
对于数据库来说频繁的创建和关闭会非常消耗资源，而且耗费时间。会导致程序执行效率降低，连接也不会复用。
在这种背景下，使用数据库连接池，控制和减少对数据库不必要的资源浪费的想法就产生了。

二、数据库连接池的作用过程

数据库连接池的含义其实很好理解，在原先我们是每次请求都会创建一个连接资源，而使用连接池之后，我们在系统初始化的时候会先初始化一个连接池容器，容器中存放着若干个连接资源，后续每次执行一个sql请求时，都先从容器（数据库连接池）中获取连接资源，再访问数据库。当sql执行完成后，就将连接资源归还到数据库连接池中，给其他资源使用。

传统的数据库连接方式
使用数据库连接池后的工作流程

数据库连接池的概念其实比较好理解，而Java中也针对这种思想，定义出了相关的接口javax.sql.DataSource。后续所有的数据库连接池厂商或者组织想要实现这个功能，都必须要实现这个接口。

public interface DataSource  extends CommonDataSource, Wrapper {

  Connection getConnection() throws SQLException;

  Connection getConnection(String username, String password)  throws SQLException;
}

三、常见的数据库连接池介绍

当前市场上已经有很多组织提供了数据库连接池的实现，常见的有C3P0、Durid、DBCP和Hikaricp等等，本篇文章将对C3P0、Durid两种数据库连接池进行介绍。

C3P0 连接池

C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate、Spring等。从C3P0被知名的框架使用我们也可以看出这款连接池的可靠性。
下面我们就演示一下如何使用C3P0连接池来优化之前的代码吧

步骤一：创建在项目根路径下（src下或者resource下都可以）创建名称为c3p0-config.xml或者c3p0.properties的配置文件

<?xml version="1.0"?>
<c3p0-config>
<!-- 使用默认的配置读取连接池对象 -->
    <default-config>
        <!-- 连接参数 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db4</property>
        <property name="user">root</property>
        <property name="password">root</property>
        <!-- 连接池参数 -->
        <!--初始化申请的连接数量-->
        <property name="initialPoolSize">5</property>
        <!--最大的连接数量-->
        <property name="maxPoolSize">10</property>
        <!--超时时间-->
        <property name="checkoutTimeout">3000</property>
    </default-config>

    <!--
    C3P0的命名配置，
    如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource("otherc3p0");”这样写就表示使用的是name是MySQL的配置信息来创建数据源
    -->
    <named-config name="otherc3p0">
    <!-- 连接参数 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db3</property>
        <property name="user">root</property>
        <property name="password">root</property>
        <!-- 连接池参数 -->
        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">8</property>
        <property name="checkoutTimeout">1000</property>
    </named-config>
</c3p0-config>

步骤二：创建ComboPooledDataSource数据库连接池对象

    public List<User> queryUserByName(String name) throws IOException {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;
        //注册mysql驱动
        try {
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            // 获取连接
            connection = dataSource.getConnection();
            ps = connection.prepareStatement("select * from user where username = ?");
            ps.setString(1, name);
            resultSet = ps.executeQuery();
            // 封装List对象
            List<User> list = new ArrayList<User>();
            while (resultSet.next()) {
                Integer uid = resultSet.getInt(1);
                String username = resultSet.getString(2);
                String uPassword = resultSet.getString(3);
                list.add(new User(uid, username, uPassword));
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            this.close(resultSet, ps, connection);
        }
        return null;
    }

我们可以看到，使用C3P0连接池后，我们简化了获取数据库资源的代码，同时需要注意的是，调用connection的close之后，相关的连接资源并不会被销毁，而是回到了数据库连接池中。

这里在加一个小测试，我们请求比最大连接数还多的请求，会怎么样呢？

    public static void main(String[] args) throws SQLException {
        ComboPooledDataSource c3p0DataSource = new ComboPooledDataSource();
        for (int i = 0; i < 21; i++) {
            Connection connection = c3p0DataSource.getConnection();
            System.out.println(connection);
        }
    }

测试结果图
我们可以看到，由于前面的连接资源没有释放，如果此时又有了新的连接资源，那么在超时时间结束后，程序就会抛出超时异常。所以在实际开发过程中，我们要根据项目的实际需要和合理地设置最大链接数量和超时时间。

Druid连接池

Druid是Java语言中最好的数据库连接池（这个笔者不确定是不是最好，性能上Hikaricp似乎更胜一筹），在功能、性能、扩展性方面，都超过其他数据库连接池，包括DBCP、C3P0、Proxool、JBoss DataSource。Druid已经在阿里巴巴部署了超过600个应用，经过生产环境大规模部署的严苛考验。
下面我们就来简单使用以下Druid连接池吧~

步骤一：引入依赖

步骤二：创建druid.properties配置文件

配置文件的文件名可以自定义，位置也可以自己选择

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/db3
username=root
password=root
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000

步骤三：获取数据库连接池对象∶通过工厂来来获取DruidDataSourceFactory，我们这里定义一个工具类

public class DruidPoolUtils {
    //1.定义成员变量 DataSource
    private static DataSource ds ;

    static{
        try {
            //1.加载配置文件
            Properties pro = new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            //2.获取DataSource
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取连接
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    /**
     * 释放资源
     */
    public static void close(Statement stmt, Connection conn){
        close(null,stmt,conn);
    }


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

    /**
     * 获取连接池方法
     */

    public static DataSource getDataSource(){
        return  ds;
    }
}

步骤四：调用工具类

  public List<User> queryUserByName(String name) throws IOException {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;
        //注册mysql驱动
        try {
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            // 获取连接
            connection = DruidPoolUtils.getConnection();
            ps = connection.prepareStatement("select * from user where username = ?");
            ps.setString(1, name);
            resultSet = ps.executeQuery();
            // 封装List对象
            List<User> list = new ArrayList<User>();
            while (resultSet.next()) {
                Integer uid = resultSet.getInt(1);
                String username = resultSet.getString(2);
                String uPassword = resultSet.getString(3);
                list.add(new User(uid, username, uPassword));
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DruidPoolUtils.close(resultSet, ps, connection);
        }
        return null;
    }

总的来说，两种数据库连接池在使用上其实是大同小异的，更多的差异是体现在二者的拓展性、性能、功能性方面，客观来讲的话，Druid连接池的功能会更加全面一些。

小结

到这里，本篇文章的介绍就已经结束了，最后再对文章的内容做一下总结。首先，我们介绍了数据库连接池技术出现的背景，然后我们介绍了数据库连接池的作用流程，知道了连接池本质上是对原生数据库连接方式的改良和优化，再后面我们主要介绍了两种应用较多、比较成熟的数据库连接池产品，C3P0和Druid，并介绍了两者的用法。数据库连接池的出现并没有解决原生方式封装结果集复杂的问题，要想知道如何解决可以参考本系列的下篇文章。