本专栏将从基础开始，循序渐进，讲解数据库的基本概念以及使用，希望大家都能够从中有所收获，也请大家多多支持。
专栏地址: 数据库必知必会
相关软件地址:软件地址
如果文章知识点有错误的地方，请指正！大家一起学习，一起进步。

文章目录

1 自定义连接池
2 第三方连接池

1 自定义连接池

1.1 连接池概念

1.1.1 为什么要使用连接池

Connection对象在JDBC使用的时候就会去创建一个对象,使用结束以后就会将这个对象给销毁了(close)，每次创建和销毁对象都是耗时操作，需要使用连接池对其进行优化.

程序初始化的时候，初始化多个连接,将多个连接放入到池(集合)中，每次获取的时候，都可以直接从连接池中进行获取，使用结束以后,将连接归还到池中。

1.1.2 生活里面的连接池例子

老方式:

下了地铁需要骑车, 跑去生产一个, 然后骑完之后,直接把车销毁了。
连接池方式摩拜单车:

骑之前, 有一个公司生产了很多的自行车, 下了地铁需要骑车, 直接扫码使用就好了, 然后骑完之后, 还回去。

1.1.3 连接池原理

程序一开始就创建一定数量的连接，放在一个容器(集合)中，这个容器称为连接池。
使用的时候直接从连接池中取一个已经创建好的连接对象, 使用完成之后归还到池子
如果池子里面的连接使用完了, 还有程序需要使用连接, 先等待一段时间(eg: 3s), 如果在这段时间之内有连接归还, 就拿去使用; 如果还没有连接归还, 新创建一个, 但是新创建的这一个不会归还了(销毁)
集合选择LinkedList
- 增删比较快
- LinkedList里面的removeFirst()和addLast()方法和连接池的原理吻合

使用连接池的目的: 可以让连接得到复用, 避免浪费

1.2 自定义连接池-初级版本

目标

根据连接池的原理, 使用LinkedList自定义连接池

分析

创建一个类MyDataSource, 定义一个集合LinkedList
程序初始化的时候, 创建5个连接存到LinkedList
定义getConnection() 从LinkedList取出Connection返回
定义addBack()方法归还Connection到LinkedList

实现

JDBCUtils.java

package com.hashnode.utils;

import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;


public class JDBCUtils {
    
    

    private static String driver;
    private static String url;
    private static String user;
    private static String password;

    static {
    
    
        try {
    
    
            // 使用Properties对象加载配置文件
            // 创建Properties对象
            Properties pro = new Properties();

            // 读取配置文件中的数据
            //pro.load(new FileInputStream("my-code\\src\\db.properties"));
            // 返回的输入流的路径默认到src路径
            InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
            pro.load(is);

            // 通过pro对象给属性赋值
            url = pro.getProperty("url");
            user = pro.getProperty("username");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");

            // 1.加载驱动
            Class.forName(driver);

        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

    /**
     * 获得连接
     *
     * @return 连接
     * @throws Exception
     */
    public static Connection getConnection() throws Exception {
    
    
        // 2.获得连接
        Connection connection = DriverManager.getConnection(url, user, password);

        return connection;
    }

    /**
     * 释放资源
     *
     * @param resultSet
     * @param statement
     * @param connection
     */
    public static void release(ResultSet resultSet, Statement statement, Connection connection) {
    
    
        if (resultSet != null) {
    
    
            try {
    
    
                resultSet.close();
            } catch (SQLException e) {
    
    
                e.printStackTrace();
            }
        }

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

MyDataSource1.java

package com.hashnode.datapool;

import com.hashnode.utils.JDBCUtils;

import java.sql.Connection;
import java.util.LinkedList;

public class MyDataSource1 {
    
    
    // 1.定义一个LinkedList集合,用来存储初始化的连接
    private static LinkedList<Connection> list = new LinkedList<>();

    // 2.初始化5个连接,并存储到集合中
    static {
    
    
        for (int i = 0; i < 5; i++) {
    
    
            try {
    
    
                // 获得连接
                Connection connection = JDBCUtils.getConnection();
                // 添加到集合中
                list.add(connection);
            } catch (Exception e) {
    
    
                e.printStackTrace();
            }
        }
    }

    // 3.定义getAbc方法,用来获得连接
    public Connection getAbc(){
    
    
        Connection connection = list.removeFirst();
        return connection;
    }

    // 4.定义addBack方法,用来归还连接
    public void addBack(Connection connection){
    
    
        list.addLast(connection);
    }

    // 5.定义getCount方法,返回连接池中连接数量
    public static int getCount(){
    
    
        return list.size();
    }
}

CRUDTest1.java

package com.hashnode.datapool;

import com.hashnode.pojo.User;
import com.hashnode.utils.JDBCUtils;
import org.junit.Test;

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

// 测试
public class CRUDTest1 {
    
    
    // 查询记录
    @Test
    public void select() throws Exception {
    
    
        // 1.创建连接池对象
        MyDataSource1 dataSource = new MyDataSource1();
        System.out.println("获得连接之前,连接池中连接的数量:"+MyDataSource1.getCount());// 5

        // 2.获得连接
        Connection connection = dataSource.getAbc();

        // 2.书写sql语句,预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);
        // 3.设置参数
        ps.setInt(1,3);
        // 4.执行sql语句
        ResultSet resultSet = ps.executeQuery();
        // 封装,处理数据
        User user = null;
        while (resultSet.next()){
    
    
            user = new User();
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }
        System.out.println("获得连接之后,连接池中连接的数量:"+MyDataSource1.getCount());// 4
        System.out.println(user);

        // 5.释放资源
        // 归还连接
        dataSource.addBack(connection);
        JDBCUtils.release(resultSet,ps,null);

        System.out.println("归还连接之后,连接池中连接的数量:"+MyDataSource1.getCount());// 5

    }
}

小结

创建一个类MyDataSource, 定义一个集合LinkedList
程序初始化(静态代码块)里面创建5个连接存到LinkedList
定义提供Connection的方法
定义归还Connection的方法

1.3 自定义连接池-进阶版本

目标

实现datasource完成自定义连接池

分析

在初级版本版本中, 我们定义的方法是getAbc()，因为是自定义的，如果改用李四的自定义的连接池，李四定义的方法是getCon(), 那么我们的源码就需要修改, 这样不方便维护，所以sun公司定义了一个接口DataSource,让自定义连接池有了规范。

1.3.1 datasource接口概述

Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商(用户)需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池！

1.3.2 代码实现

public class MyDataSource2 implements DataSource {
    
    
    // 1.定义一个LinkedList集合,用来存储初始化的连接
    private static LinkedList<Connection> list = new LinkedList<>();

    // 2.初始化5个连接,并存储到集合中
    static {
    
    
        for (int i = 0; i < 5; i++) {
    
    
            try {
    
    
                // 获得连接
                Connection connection = JDBCUtils.getConnection();
                // 添加到集合中
                list.add(connection);
            } catch (Exception e) {
    
    
                e.printStackTrace();
            }
        }
    }

    /*// 3.定义getAbc方法,用来获得连接
    public Connection getAbc(){
        Connection connection = list.removeFirst();
        return connection;
    }*/

    // 4.定义addBack方法,用来归还连接
    public void addBack(Connection connection){
    
    
        list.addLast(connection);
    }

    // 5.定义getCount方法,返回连接池中连接数量
    public static int getCount(){
    
    
        return list.size();
    }

    @Override
    public Connection getConnection() throws SQLException {
    
    
        Connection connection = list.removeFirst();
        return connection;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
    
    
        return null;
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
    
    
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {
    
    

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {
    
    

    }

    @Override
    public int getLoginTimeout() throws SQLException {
    
    
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
    
    
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
    
    
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
    
    
        return false;
    }
}


// 测试
public class CRUDTest2 {
    
    

    // 查询记录
    @Test
    public void select() throws Exception {
    
    
        // 1.创建连接池对象
        DataSource dataSource = new MyDataSource2();
        System.out.println("获得连接之前,连接池中连接的数量:"+MyDataSource2.getCount());// 5

        // 2.获得连接
        Connection connection = dataSource.getConnection();

        // 2.书写sql语句,预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);
        // 3.设置参数
        ps.setInt(1,3);
        // 4.执行sql语句
        ResultSet resultSet = ps.executeQuery();
        // 封装,处理数据
        User user = null;
        while (resultSet.next()){
    
    
            user = new User();
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }
        System.out.println("获得连接之后,连接池中连接的数量:"+MyDataSource2.getCount());// 4
        System.out.println(user);

        // 5.释放资源
        // 归还连接
        // 解决办法: 1.向下转型  2.增强Connection的close方法(默认是销毁连接,增强后变成归还连接)
        ((MyDataSource2)dataSource).addBack(connection);
        JDBCUtils.release(resultSet,ps,null);

        System.out.println("归还连接之后,连接池中连接的数量:"+MyDataSource2.getCount());// 5

    }
}

1.3.2 编写连接池遇到的问题

实现DataSource接口后,addBack()不能调用了。
能不能不引入新的api,直接调用之前的connection.close(),但是这个close不是关闭,是归还

解决办法

继承
- 条件:可以控制父类, 最起码知道父类的名字
装饰者模式
- 作用：改写已存在的类的某个方法或某些方法
- 条件:
  - 增强类和被增强类实现的是同一个接口
  - 增强类里面要拿到被增强类的引用
动态代理

1.4 自定义连接池-终极版本

目标

使用装饰者模式改写connection的close()方法, 让connection归还

1.4.1 装饰者模式

1.4.1.1 概述

什么是装饰者模式

装饰者模式，是 23种常用的面向对象软件的设计模式之一，动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更加有弹性的替代方案。

装饰者的作用：改写已存在的类的某个方法或某些方法, 增强方法的逻辑
使用装饰者模式需要满足的条件
- 增强类和被增强类实现的是同一个接口
- 增强类里面要拿到被增强类的引用

1.4.1.2 装饰者模式的使用

实现步骤:

增强类和被增强类需要实现同一个接口
增强类里面需要得到被增强类的引用,
对于不需要改写的方法，调用被增强类原有的方法。
对于需要改写的方法写自己的代码

接口:

public interface Star {
    
    
    public void sing();
    public void dance();
}

被增强的类:

public class AAA implements Star {
    
    
    @Override
    public void sing() {
    
    
        System.out.println("AAA is sing...");
    }

    @Override
    public void dance() {
    
    
        System.out.println("AAA is dancing...");
    }
}

增强的类:

public class AAAWrapper implements Star {
    
    

    // 增强类中获得被增强类的引用
    LiuDeHua ldh;

    public LiuDeHuaWrapper(LiuDeHua ldh) {
    
    
        this.ldh = ldh;
    }

    @Override
    public void sing() {
    
    
        System.out.println("AAA is sing...");
        ldh.sing();
        System.out.println("AAA is practicing...");
    }

    @Override
    public void dance() {
    
    
        // 不增强
        ldh.dance();
    }
}

测试

public class Test {
      
      
    public static void main(String[] args) {
      
      
        // 没有使用装饰者
        LiuDeHua ldh = new LiuDeHua();
        //ldh.sing();
        //ldh.dance();

        // 使用装饰者
        AAAWrapper ldhw = new LiuDeHuaWrapper(ldh);
        ldhw.sing();
        ldhw.dance();
    }
}

1.4.2 自定义连接池终极版本

1.4.2.1 分析

增强connection的close()方法, 其它的方法逻辑不改

创建MyConnection实现Connection
在MyConnection里面需要得到被增强的connection对象(通过构造方法传进去)
改写close()的逻辑, 变成归还
其它方法的逻辑, 还是调用被增强connection对象之前的逻辑

1.4.2.2 实现

MyConnection

public class MyConnection implements Connection {
    
    

    // 获得被增强的连接对象的引用
    Connection con;

    // 获得连接池
    LinkedList<Connection> list;

    public MyConnection(Connection con, LinkedList<Connection> list) {
    
    
        this.con = con;
        this.list = list;
    }

    @Override
    public void close() throws SQLException {
    
    
        // 归还连接
        list.addLast(con);
    }

    @Override
    public Statement createStatement() throws SQLException {
    
    
        return con.createStatement();
    }
	// 必须写
    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
    
    
        return con.prepareStatement(sql);
    }
	// 剩余的重写方法,使用被增强的连接对象调用原有方法...
    // ...
}

MyDataSource03

public class MyDataSource3 implements DataSource {
    
    
    // 1.定义一个LinkedList集合,用来存储初始化的连接
    private static LinkedList<Connection> list = new LinkedList<>();

    // 2.初始化5个连接,并存储到集合中
    static {
    
    
        for (int i = 0; i < 5; i++) {
    
    
            try {
    
    
                // 获得连接
                Connection connection = JDBCUtils.getConnection();
                // 添加到集合中
                list.add(connection);
            } catch (Exception e) {
    
    
                e.printStackTrace();
            }
        }
    }

    /*// 3.定义getAbc方法,用来获得连接
    public Connection getAbc(){
        Connection connection = list.removeFirst();
        return connection;
    }*/

    /*// 4.定义addBack方法,用来归还连接
    public void addBack(Connection connection){
        list.addLast(connection);
    }*/

    // 5.定义getCount方法,返回连接池中连接数量
    public static int getCount(){
    
    
        return list.size();
    }

    @Override
    public Connection getConnection() throws SQLException {
    
    
        Connection connection = list.removeFirst();// 返回的是被增强的连接对象
        // 增强
        MyConnection myConnection = new MyConnection(connection,list);
        return myConnection;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
    
    
        return null;
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
    
    
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {
    
    

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {
    
    

    }

    @Override
    public int getLoginTimeout() throws SQLException {
    
    
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
    
    
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
    
    
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
    
    
        return false;
    }
}

JDBCUtils.java

package com.hashnode.utils;

import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;


public class JDBCUtils {
    
    

    private static String driver;
    private static String url;
    private static String user;
    private static String password;

    static {
    
    
        try {
    
    
            // 使用Properties对象加载配置文件
            // 创建Properties对象
            Properties pro = new Properties();

            // 读取配置文件中的数据
            //pro.load(new FileInputStream("my-code\\src\\db.properties"));
            // 返回的输入流的路径默认到src路径
            InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
            pro.load(is);

            // 通过pro对象给属性赋值
            url = pro.getProperty("url");
            user = pro.getProperty("username");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");

            // 1.加载驱动
            Class.forName(driver);

        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

    /**
     * 获得连接
     *
     * @return 连接
     * @throws Exception
     */
    public static Connection getConnection() throws Exception {
    
    
        // 2.获得连接
        Connection connection = DriverManager.getConnection(url, user, password);

        return connection;
    }

    /**
     * 释放资源
     *
     * @param resultSet
     * @param statement
     * @param connection
     */
    public static void release(ResultSet resultSet, Statement statement, Connection connection) {
    
    
        if (resultSet != null) {
    
    
            try {
    
    
                resultSet.close();
            } catch (SQLException e) {
    
    
                e.printStackTrace();
            }
        }

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

测试类

public class CRUDTest3 {
      
      

    // 查询记录
    @Test
    public void select() throws Exception {
      
      
        // 1.创建连接池对象
        DataSource dataSource = new MyDataSource3();
        System.out.println("获得连接之前,连接池中连接的数量:"+MyDataSource3.getCount());// 5

        // 2.获得连接
        Connection connection = dataSource.getConnection();// 返回的是增强的连接对象 MyConnection

        // 2.书写sql语句,预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);
        // 3.设置参数
        ps.setInt(1,3);
        // 4.执行sql语句
        ResultSet resultSet = ps.executeQuery();
        // 封装,处理数据
        User user = null;
        while (resultSet.next()){
      
      
            user = new User();
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }
        System.out.println("获得连接之后,连接池中连接的数量:"+MyDataSource3.getCount());// 4
        System.out.println(user);

        // 5.释放资源
        // 归还连接
        //connection.close();// 归还连接
        JDBCUtils.release(resultSet,ps,connection);

        System.out.println("归还连接之后,连接池中连接的数量:"+MyDataSource3.getCount());// 5

    }
}

小结

创建一个MyConnection实现Connection
在MyConnection得到被增强的connection对象
改写MyConnection里面的close()方法的逻辑为归还
MyConnection里面的其它方法调用被增强的connection对象之前的逻辑
在MyDataSource03的getConnection()方法里面返回了myConnection(增强的连接对象)（此时调用的是多态,即MyConnection中重写的close方法）

2 第三方连接池

2.1 常用连接池

通过前面的学习，我们已经能够使用所学的基础知识构建自定义的连接池了。其目的是锻炼大家的基本功，帮助大家更好的理解连接池的原理, 但现实是残酷的，我们所定义的连接池和第三方的连接池相比，还是显得渺小. 工作里面都会用第三方连接池.

常见的第三方连接池如下:

C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。C3P0是异步操作的，所以一些操作时间过长的JDBC通过其它的辅助线程完成。目前使用它的开源项目有Hibernate，Spring等。C3P0有自动回收空闲连接功能
阿里巴巴-德鲁伊druid连接池：Druid是阿里巴巴开源平台上的一个项目，整个项目由数据库连接池、插件框架和SQL解析器组成。该项目主要是为了扩展JDBC的一些限制，可以让程序员实现一些特殊的需求。
DBCP(DataBase Connection Pool)数据库连接池，是Apache上的一个Java连接池项目，也是Tomcat使用的连接池组件。dbcp没有自动回收空闲连接的功能。

我们工作里面用的比较多的是:

C3P0
druid
光连接池

2.2 C3P0

2.2.1 c3p0介绍

C3P0是开源免费的连接池，目前使用它的开源项目有：Spring、Hibernate等。使用第三方工具需要导入jar包，c3p0使用时还需要添加配置文件c3p0-config.xml.
使用C3P0需要添加c3p0-0.9.1.2.jar

2.2.2 c3p0的使用

2.2.2.1 通过硬编码来编写

步骤

拷贝jar
创建C3P0连接池对象
从C3P0连接池对象里面获得connection

实现:

package com.hashnode.test;

import com.hashnode.pojo.User;
import com.hashnode.utils.JDBCUtils;
import com.mchange.v2.c3p0.ComboPooledDataSource;

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

public class C3P0Test1 {
    
    
    public static void main(String[] args) throws Exception {
    
    
        // 1.拷贝c3p0jar包到模块下,并添加到classpath路径中
        // 2.创建连接池对象
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        // 连接池设置参数
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/hashnode");
        dataSource.setUser("root");
        dataSource.setPassword("root");
        // 设置初始化连接数量
        dataSource.setInitialPoolSize(5);

        // 3.获得连接
        Connection connection = dataSource.getConnection();

        // 4.书写sql语句,预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);

        // 5.设置参数
        ps.setInt(1, 3);

        // 6.执行sql语句
        ResultSet resultSet = ps.executeQuery();

        // 封装,处理数据
        User user = null;
        while (resultSet.next()) {
    
    
            user = new User();
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }
        System.out.println(user);

        // 7.释放资源---连接归还
        JDBCUtils.release(resultSet,ps,connection);
    }
}

2.2.2.2 通过配置文件来编写

步骤:

拷贝jar
拷贝配置文件(c3p0-config.xml)到src目录【名字不要改】
创建C3P0连接池对象【自动的读取】
从池子里面获得连接

实现:

编写配置文件c3p0-config.xml，放在src目录下（注：文件名一定不要改)

<c3p0-config>
	<default-config>
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://localhost:3306/hashnode</property>
		<property name="user">root</property>
		<property name="password">root</property>
		<property name="initialPoolSize">5</property>
	</default-config>
</c3p0-config>

编写Java代码 (会自动读取src目录下的c3p0-config.xml,所以不需要我们解析配置文件)

public class Test2_通过配置文件来编写 {
    
    
    public static void main(String[] args) throws Exception{
    
    
        // 1.拷贝c3p0jar包到模块下,并添加到classpath路径中
        // 2.创建连接池对象
        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        // 3.获得连接
        Connection connection = dataSource.getConnection();

        // 4.书写sql语句,预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);

        // 5.设置参数
        ps.setInt(1, 3);

        // 6.执行sql语句
        ResultSet resultSet = ps.executeQuery();

        // 封装,处理数据
        User user = null;
        while (resultSet.next()) {
    
    
            user = new User();
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }
        System.out.println(user);

        // 7.释放资源---连接归还
        JDBCUtils.release(resultSet,ps,connection);
    }
}

2.2.2.3 使用c3p0改写工具类

我们之前写的工具类(JdbcUtils)每次都会创建一个新的连接, 使用完成之后, 都给销毁了; 所以现在我们要使用c3p0来改写工具类. 也就意味着,我们从此告别了JdbcUtils. 后面会使用c3p0写的工具类

思路:

创建C3P0Utils这个类
定义DataSource, 保证DataSource全局只有一个
定义getConnection()方法从DataSource获得连接
定义closeAll()方法释放资源

package com.hashnode.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class C3P0Utils {
    
    
    // 创建c3p0连接池对象
    private static final ComboPooledDataSource DATA_SOURCE = new ComboPooledDataSource();

    /**
     * 获得连接的方法
     * @return  连接
     * @throws Exception
     */
    public static Connection getConnection() throws Exception{
    
    
        Connection connection = DATA_SOURCE.getConnection();
        return connection;
    }

    /**
     * 获得连接池的方法
     * @return
     */
    public static DataSource getDataSource(){
    
    
        return DATA_SOURCE;
    }

    /**
     * 释放资源
     *
     * @param resultSet
     * @param statement
     * @param connection
     */
    public static void release(ResultSet resultSet, Statement statement, Connection connection) {
    
    
        if (resultSet != null) {
    
    
            try {
    
    
                resultSet.close();
            } catch (SQLException e) {
    
    
                e.printStackTrace();
            }
        }

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

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

    }
}

使用

package com.hashnode.test;

import com.hashnode.pojo.User;
import com.hashnode.utils.JDBCUtils;
import com.mchange.v2.c3p0.ComboPooledDataSource;

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

public class C3P0Test2 {
    
    
    public static void main(String[] args) throws Exception{
    
    
        // 1.拷贝c3p0jar包到模块下,并添加到classpath路径中
        // 2.创建连接池对象
        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        // 3.获得连接
        Connection connection = dataSource.getConnection();

        // 4.书写sql语句,预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);

        // 5.设置参数
        ps.setInt(1, 3);

        // 6.执行sql语句
        ResultSet resultSet = ps.executeQuery();

        // 封装,处理数据
        User user = null;
        while (resultSet.next()) {
    
    
            user = new User();
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }
        System.out.println(user);

        // 7.释放资源---连接归还
        JDBCUtils.release(resultSet,ps,connection);
    }
}

小结

C3P0 配置文件方式使用
- 拷贝jar
- 拷贝配置文件到src【配置文件的名字不要改】
- 创建C3P0连接池对象
C3P0工具类
- 保证DataSource连接池只有一个【static】
- 提供connection
- 释放资源

2.3 DRUID

2.3.1 DRUID介绍

Druid是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是国内目前最好的数据库连接池。在功能、性能、扩展性方面，都超过其他数据库连接池。Druid已经在阿里巴巴部署了超过600个应用，经过一年多生产环境大规模部署的严苛考验。如：一年一度的双十一活动，每年春运的抢火车票。

Druid的下载地址：https://github.com/alibaba/druid

DRUID连接池使用的jar包：druid-1.0.9.jar

2.3.2 DRUID的使用

2.3.3 通过硬编码方式

步骤:

导入DRUID jar 包
创建Druid连接池对象, 配置4个基本参数
从Druid连接池对象获得Connection

实现:

package com.hashnode.test;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidPooledConnection;
import com.hashnode.pojo.User;
import com.hashnode.utils.JDBCUtils;
import org.junit.Test;

import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class DruidTest1 {
    
    
    @Test
    public void select() throws Exception{
    
    
        // 1.拷贝jar包,添加classpath路径
        // 2.创建Druid连接池对象
        DruidDataSource dataSource = new DruidDataSource();
        // 设置参数
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/hashnode");
        dataSource.setUsername("root");
        dataSource.setPassword("root");

        dataSource.setInitialSize(5);

        // 3.获得连接
        DruidPooledConnection connection = dataSource.getConnection();

        // 4.书写sql语句,预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);

        // 5.设置参数
        ps.setInt(1, 3);

        // 6.执行sql语句
        ResultSet resultSet = ps.executeQuery();

        // 封装,处理数据
        User user = null;
        while (resultSet.next()) {
    
    
            user = new User();
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }
        System.out.println(user);

        // 7.释放资源---连接归还
        JDBCUtils.release(resultSet,ps,connection);
    }
}

2.3.4 通过配置文件方式

步骤:

导入DRUID jar 包
拷贝配置文件到src目录
根据配置文件创建Druid连接池对象
从Druid连接池对象获得Connection

实现:

创建druid.properties, 放在src目录下

url=jdbc:mysql://localhost:3306/day21_1
username=root
password=root
driverClassName=com.mysql.jdbc.Driver

编写Java代码

package com.hashnode.test;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.hashnode.pojo.User;
import com.hashnode.utils.JDBCUtils;
import org.junit.Test;
import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;

public class DruidTest2 {
    
    
    @Test
    public void select() throws Exception{
    
    
        // 1.拷贝jar包,添加classpath路径
        // 2.创建Druid连接池对象
        Properties prop = new Properties();
        // 加载配置文件
        InputStream is = DruidTest2.class.getClassLoader().getResourceAsStream("druid.properties");
        prop.load(is);
        // 创建Druid连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        // 3.获得连接
        Connection connection = dataSource.getConnection();

        // 4.书写sql语句,预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);

        // 5.设置参数
        ps.setInt(1, 3);

        // 6.执行sql语句
        ResultSet resultSet = ps.executeQuery();

        // 封装,处理数据
        User user = null;
        while (resultSet.next()) {
    
    
            user = new User();
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }
        System.out.println(user);

        // 7.释放资源---连接归还
        JDBCUtils.release(resultSet,ps,connection);
    }
}

2.3.5 使用DruidUtils改写工具类

思路:

创建DruidUtils这个类
定义DruidDataSource, 保证DruidDataSource全局只有一个
定义getConnection()方法从DataSource获得连接
定义release()方法释放资源

package com.hashnode.utils;

import com.alibaba.druid.pool.DruidDataSource;

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

public class DruidUtils {
    
    
    // 创建c3p0连接池对象
    private static final DruidDataSource DATA_SOURCE = new DruidDataSource();

    static {
    
    
        // 设置参数
        DATA_SOURCE.setDriverClassName("com.mysql.jdbc.Driver");
        DATA_SOURCE.setUrl("jdbc:mysql://localhost:3306/hashnode");
        DATA_SOURCE.setUsername("root");
        DATA_SOURCE.setPassword("root");

        DATA_SOURCE.setInitialSize(5);
    }

    /**
     * 获得连接的方法
     * @return  连接
     * @throws Exception
     */
    public static Connection getConnection() throws Exception{
    
    
        Connection connection = DATA_SOURCE.getConnection();
        return connection;
    }

    /**
     * 获得连接池的方法
     * @return
     */
    public static DruidDataSource getDataSource(){
    
    
        return DATA_SOURCE;
    }

    /**
     * 释放资源
     *
     * @param resultSet
     * @param statement
     * @param connection
     */
    public static void release(ResultSet resultSet, Statement statement, Connection connection) {
    
    
        if (resultSet != null) {
    
    
            try {
    
    
                resultSet.close();
            } catch (SQLException e) {
    
    
                e.printStackTrace();
            }
        }

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

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

    }
}

使用

package com.hashnode.test;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.hashnode.pojo.User;
import com.hashnode.utils.DruidUtils;
import com.hashnode.utils.JDBCUtils;
import org.junit.Test;
import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;

public class DruidTest3 {
    
    
    @Test
    public void select() throws Exception{
    
    

        // 3.获得连接
        Connection connection = DruidUtils.getConnection();

        // 4.书写sql语句,预编译sql语句,得到预编译对象
        String sql = "select * from user where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);

        // 5.设置参数
        ps.setInt(1, 3);

        // 6.执行sql语句
        ResultSet resultSet = ps.executeQuery();

        // 封装,处理数据
        User user = null;
        while (resultSet.next()) {
    
    
            user = new User();
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setNickname(resultSet.getString("nickname"));
        }
        System.out.println(user);

        // 7.释放资源---连接归还
        DruidUtils.release(resultSet,ps,connection);
    }
}

小结

Druid配置文件使用
- 拷贝jar
- 拷贝配置文件到src
- 读取配置文件成properties对象
- 使用工厂根据properties创建DataSource
- 从DataSource获得Connection

【MySQL】数据库连接池的原理及实现