DBCP-C3P0连接池

1、 数据库连接池

数据库的连接测试，一般的流程像开始--执行--关闭，这样频繁的连接关闭操作，非常的浪费系统资源，数据库连接池的使用，解决了这一问题，连接池是先准备一些资源，等待程序来连接数据库。连接池可以设置最大连接数、最小连接数、等待超时等操作。

怎么使用数据库连接池？

• 编写连接池，实现一个接口：DataSource

开源数据源实现： DBCP   C3P0    Druid  ，使用这些数据库连接池，可以让开发者在项目开发中不需要编写连接数据库代码。

2、DBCP 的使用

需要的依赖环境：

        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.4</version>
        </dependency>

DBCP配置文件

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true
username=root
password=123456

#<!-- 初始化连接 -->
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000


#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;]
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=gbk

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

实现代码：先创建一个maven项目，导入需要的开发环境。

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.6</version>
        </dependency>
    </dependencies>

工具类：

package com.DBCP.util;

import org.apache.commons.dbcp.BasicDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

public class jdbc_dbcp_Util {
    private  static  DataSource dataSource = null;
    static {
        try {
            //        连接配置文件
            InputStream in = jdbc_dbcp_Util.class.getClassLoader().getResourceAsStream("dbcp.properties");
            Properties properties = new Properties();
            properties.load(in);
            //      创建数据源 工厂模式------》创建
            dataSource = BasicDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 获取连接
    public static Connection getConnect() throws SQLException {
         return dataSource.getConnection();
    }
//    释放连接
    public static void release(Connection connection, Statement statement, ResultSet resultSet){
        if(resultSet!=null){
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(statement!=null){
            try {
                statement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(connection!=null){
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

实现类：

package com.DBCP;

import com.DBCP.util.jdbc_dbcp_Util;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class dbcpTest {
    private  static  Connection connect =null;
    private  static  PreparedStatement preparedStatement =null;
    private  static ResultSet resultSet =null;
    public static void main(String[] args) {
        try {
//            获取连接
            connect = jdbc_dbcp_Util.getConnect();
//            关闭事务自动提交，自动开启事务
            connect.setAutoCommit(false);
            String sql = "select * from account where id = ? ";
//            处理sql语句
            preparedStatement = connect.prepareStatement(sql);
            preparedStatement.setInt(1,1);
//            执行sql语句
            resultSet = preparedStatement.executeQuery();
            while(resultSet.next()) System.out.println(resultSet.getObject("NAME"));
//             事务提交
            connect.commit();
//          开启事务自动提交
            connect.setAutoCommit(true);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
//            关闭连接
            jdbc_dbcp_Util.release(connect,preparedStatement,resultSet);
        }
    }
}

3 、c3p0的使用

所需要的环境：

<!--        c3p0-->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>mchange-commons-java</artifactId>
            <version>0.2.11</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>

配置文件：

<!-- 自定义的c3p0-config.xml -->
<?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/bank</property>
    <property name="user">root</property>
    <property name="password">123456</property>
 
    <property name="initialPoolSize">10</property>
    <property name="maxIdleTime">30</property>
    <property name="maxPoolSize">100</property>
    <property name="minPoolSize">10</property>
  </default-config>

</c3p0-config>

工具类

package com.C3P0.util;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class C3p0_util {
    private  static ComboPooledDataSource dataSource = null;
    static {
        try {
            //      创建数据源 工厂模式------》创建
            dataSource = new ComboPooledDataSource();
            dataSource.setDriverClass("com.mysql.jdbc.Driver");
            dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/bank");
            dataSource.setUser("root");
            dataSource.setPassword("123456");
     //     dataSource = new ComboPooledDataSource();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    // 获取连接
    public static Connection getConnect() throws SQLException {
        return dataSource.getConnection();
    }
    //    释放连接
    public static void release(Connection connection, Statement statement, ResultSet resultSet){
        if(resultSet!=null){
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(statement!=null){
            try {
                statement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(connection!=null){
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

实现类

package com.C3P0;

import com.C3P0.util.C3p0_util;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class C3p0Test {

    private  static Connection connect =null;
    private  static PreparedStatement preparedStatement =null;
    private  static ResultSet resultSet =null;
    public static void main(String[] args) {
        try {
//            获取连接
            connect = C3p0_util.getConnect();
//            关闭事务自动提交，自动开启事务
            connect.setAutoCommit(false);
            String sql = "select * from account where id = ? ";
//            处理sql语句
            preparedStatement = connect.prepareStatement(sql);
            preparedStatement.setInt(1,1);
//            执行sql语句
            resultSet = preparedStatement.executeQuery();
            while(resultSet.next()) System.out.println(resultSet.getObject("NAME"));
//             事务提交
            connect.commit();
//          开启事务自动提交
            connect.setAutoCommit(true);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
//            关闭连接
            C3p0_util.release(connect,preparedStatement,resultSet);
        }
    }
}

结论：无论使用什么数据源，本质都是一样的，DataSource接口不会变，方法不会变