数据库连接池

一、应用程序直接获取数据库连接的缺点（为何要使用数据库连接池）

　　用户每次需要操作数据库就建立一个连接，操作完成后释放连接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天有很大的访问量，数据库服务器就需要为每次连接创建一次数据库连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、拓机。

二、使用数据库连接池--优化程序性能

2.1、数据库连接池的基本概念

 

连接池的优势

　　数据库连接池（Connection pooling）是程序启动时建立足够的数据库连接，并将这些连接组成一个连接池，由程序动态地对池中的连接进行申请，使用，释放。在程序初始化的时候，集中创建多个数据库连接，并把他们集中管理，供程序使用，可以保证较快的数据库读写速度，还更加安全可靠。数据库连接池负责分配，管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。　

连接池的优势

 第一、减少连接创建时间。连接池中的连接是已准备好的、可重复使用的，获取后可以直接访问数据库，因此减少了连接创建的次数和时间。

 第二、简化的编程模式。当使用连接池时，每一个单独的线程能够像创建一个自己的JDBC连接一样操作，允许用户直接使用JDBC编程技术。

 第三、控制资源的使用。如果不使用连接池，每次访问数据库都需要创建一个连接，这样系统的稳定性受系统连接需求影响很大，很容易产生资源浪费和高负载异常。连接池能够使性能最大化，将资源利用控制在一定的水平之下。连接池能控制池中的连接数量，增强了系统在大量用户应用时的稳定性。

 连接池的基本原理

在程序初始化的时候，将数据库连接作为对象存储在内存中，当用户需要访问数据库时，并非建立一个新的连接，而是从连接池中取出一个已建立的空闲连接对象。使用完毕后，用户也并非将连接关闭，而是将连接放回连接池中，以供下一个请求访问使用。而连接的建立、断开都由连接池自身来管理。同时，还可以通过设置连接池的参数来控制连接池中的初始连接数、连接的上下限数以及每个连接的最大使用次数、最大空闲时间等等。也可以通过其自身的管理机制来监视数据库连接的数量、使用情况等。

使用数据库连接池的关键点

1、并发问题

　　为了使连接管理服务具有最大的通用性，必须考虑多线程环境，即并发问题。这个问题相对比较好解决，因为各个语言自身提供了对并发管理的支持像java等，使用synchronized(java)关键字即可确保线程是同步的。使用方法可以参考，相关文献。

２、事务处理

　　DB连接池必须要确保某一时间内一个 conn 只能分配给一个线程。不同 conn 的事务是相互独立的。 

　　为此我们可以使用每一个事务独占一个连接来实现，虽然这种方法有点浪费连接池资源但是可以大大降低事务管理的复杂性。

３、连接池的分配与释放

　　连接池的分配与释放，对系统的性能有很大的影响。合理的分配与释放，可以提高连接的复用度，从而降低建立新连接的开销，同时还可以加快用户的访问速度。 
　　对于连接的管理可使用一个List。即把已经创建的连接都放入List中去统一管理。每当用户请求一个连接时，系统检查这个List中有没有可以分配的连接。如果有就把那个最合适的连接分配给他（如何能找到最合适的连接文章将在关键议题中指出）；如果没有就抛出一个异常给用户，List中连接是否可以被分配由一个线程来专门管理捎后我会介绍这个线程的具体实现。

４、连接池的配置与维护

　　连接池中到底应该放置多少连接，才能使系统的性能最佳？系统可采取设置最小连接数（minConnection）和最大连接数（maxConnection）等参数来控制连接池中的连接。比方说，最小连接数是系统启动时连接池所创建的连接数。如果创建过多，则系统启动就慢，但创建后系统的响应速度会很快；如果创建过少，则系统启动的很快，响应起来却慢。这样，可以在开发时，设置较小的最小连接数，开发起来会快，而在系统实际使用时设置较大的，因为这样对访问客户来说速度会快些。最大连接数是连接池中允许连接的最大数目，具体值要看系统的访问量，要经过不断测试取一个平衡值。 如果最小连接数与最大连接数相差很大:那么最先连接请求将会获利,之后超过最小连接数量的连接请求等价于建立一个新的数据库连接.不过,这些大于最小连接数的数据库连接在使用完不会马上被释放,他将被放到连接池中等待重复使用或是空间超时后被释放.
如何确保连接池中的最小连接数？动态和静态两种策略：

动态即每隔一定时间就对连接池进行检测，如果发现连接数量小于最小连接数，则补充相应数量的新连接,以保证连接池的正常运转。

静态是发现空闲连接不够时再去检查。

2.2、传统的连接机制与数据库连接池的运行机制区别

传统连接： 一般来说，Java应用程序访问数据库的过程是：

　　（1）装载数据库驱动程序；

　　（2）通过JDBC建立数据库连接；

　　（3）访问数据库，执行SQL语句；

　　（4）断开数据库连接。

使用了数据库连接池的机制：
（1）  程序初始化时创建连接池
（2） 使用时向连接池申请可用连接
（3） 使用完毕，将连接返还给连接池
（4） 程序退出时，断开所有连接，并释放资源

2.3、编写数据库连接池

　　编写连接池需实现java.sql.DataSource接口。DataSource接口中定义了两个重载的getConnection方法：

  • Connection getConnection()
  • Connection getConnection(String username, String password)

　　实现DataSource接口，并实现连接池功能的步骤：

  1. 在DataSource构造函数中批量创建与数据库的连接，并把创建的连接加入LinkedList对象中。
  2. 实现getConnection方法，让getConnection方法每次调用时，从LinkedList中取一个Connection返回给用户。
  3. 当用户使用完Connection，调用Connection.close()方法时，Collection对象应保证将自己返回到LinkedList中,而不要把conn还给数据库。Collection保证将自己返回到LinkedList中是此处编程的难点。

 数据库连接池核心代码

　　使用动态代理技术构建连接池中的connection

proxyConn = (Connection) Proxy.newProxyInstance(this.getClass()
            .getClassLoader(), conn.getClass().getInterfaces(),
            new InvocationHandler() {
        //此处为内部类，当close方法被调用时将conn还回池中,其它方法直接执行
            public Object invoke(Object proxy, Method method,
                      Object[] args) throws Throwable {
                if (method.getName().equals("close")) {
                    pool.addLast(conn);
                    return null;
            }
            return method.invoke(conn, args);
        }
    });

数据库连接池编写范例：

package me.gacl.demo;

import java.io.InputStream;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.Properties;
import javax.sql.DataSource;

/**
* @ClassName: JdbcPool
* @Description:编写数据库连接池
* @author: hdb
* @date: 2014-9-30 下午11:07:23
*
*/ 
public class JdbcPool implements DataSource{

    /**
    * @Field: listConnections
    *         使用LinkedList集合来存放数据库链接，
    *        由于要频繁读写List集合，所以这里使用LinkedList存储数据库连接比较合适
    */ 
    private static LinkedList<Connection> listConnections = new LinkedList<Connection>();
    
    static{
        //在静态代码块中加载db.properties数据库配置文件
        InputStream in = JdbcPool.class.getClassLoader().getResourceAsStream("db.properties");
        Properties prop = new Properties();
        try {
            prop.load(in);
            String driver = prop.getProperty("driver");
            String url = prop.getProperty("url");
            String username = prop.getProperty("username");
            String password = prop.getProperty("password");
            //数据库连接池的初始化连接数大小
            int jdbcPoolInitSize =Integer.parseInt(prop.getProperty("jdbcPoolInitSize"));
            //加载数据库驱动
            Class.forName(driver);
            for (int i = 0; i < jdbcPoolInitSize; i++) {
                Connection conn = DriverManager.getConnection(url, username, password);
                System.out.println("获取到了链接" + conn);
                //将获取到的数据库连接加入到listConnections集合中，listConnections集合此时就是一个存放了数据库连接的连接池
                listConnections.add(conn);
            }
            
        } catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
    }
    
    @Override
    public PrintWriter getLogWriter() throws SQLException {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {
        // TODO Auto-generated method stub
        
    }

    @Override
    public int getLoginTimeout() throws SQLException {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        // TODO Auto-generated method stub
        return false;
    }

    /* 获取数据库连接
     * @see javax.sql.DataSource#getConnection()
     */
    @Override
    public Connection getConnection() throws SQLException {
        //如果数据库连接池中的连接对象的个数大于0
        if (listConnections.size()>0) {
            //从listConnections集合中获取一个数据库连接
            final Connection conn = listConnections.removeFirst();
            System.out.println("listConnections数据库连接池大小是" + listConnections.size());
            //返回Connection对象的代理对象
            return (Connection) Proxy.newProxyInstance(JdbcPool.class.getClassLoader(), conn.getClass().getInterfaces(), new InvocationHandler(){
                @Override
                public Object invoke(Object proxy, Method method, Object[] args)
                        throws Throwable {
                    if(!method.getName().equals("close")){
                        return method.invoke(conn, args);
                    }else{
                        //如果调用的是Connection对象的close方法，就把conn还给数据库连接池
                        listConnections.add(conn);
                        System.out.println(conn + "被还给listConnections数据库连接池了！！");
                        System.out.println("listConnections数据库连接池大小为" + listConnections.size());
                        return null;
                    }
                }
            });
        }else {
            throw new RuntimeException("对不起，数据库忙");
        }
    }

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

 db.properties配置文件如下：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcStudy
username=root
password=XDP

jdbcPoolInitSize=10

写一个JdbcUtil测试数据库连接池

package me.gacl.utils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import me.gacl.demo.JdbcPool;

public class JdbcUtil {
    
    /**
    * @Field: pool
    *          数据库连接池
    */ 
    private static JdbcPool pool = new JdbcPool();
    
    /**
    * @Method: getConnection
    * @Description: 从数据库连接池中获取数据库连接对象
    * @Anthor:hdb
    * @return Connection数据库连接对象
    * @throws SQLException
    */ 
    public static Connection getConnection() throws SQLException{
        return pool.getConnection();
    }
    
    /**
    * @Method: release
    * @Description: 释放资源，
    * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
    * @Anthor:hdb
    *
    * @param conn
    * @param st
    * @param rs
    */ 
    public static void release(Connection conn,Statement st,ResultSet rs){
        if(rs!=null){
            try{
                //关闭存储查询结果的ResultSet对象
                rs.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
            rs = null;
        }
        if(st!=null){
            try{
                //关闭负责执行SQL命令的Statement对象
                st.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        if(conn!=null){
            try{
                //关闭Connection数据库连接对象
                conn.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

 三、开源数据库连接池

　　现在很多WEB服务器(Weblogic, WebSphere, Tomcat)都提供了DataSoruce的实现，即连接池的实现。通常我们把DataSource的实现，按其英文含义称之为数据源，数据源中都包含了数据库连接池的实现。
　　也有一些开源组织提供了数据源的独立实现：

  • DBCP 数据库连接池
  • C3P0 数据库连接池
  • Druid 数据库连接池

　　在使用了数据库连接池之后，在项目的实际开发中就不需要编写连接数据库的代码了，直接从数据源获得数据库的连接。

对比：

DBCP 可能是使用最多的开源连接池，原因大概是因为配置方便，而且很多开源和tomcat应用例子都是使用的这个连接池吧；在具体项目应用中，发现此连接池的持续运行的稳定性还是可以，不过速度稍慢，在大并发量的压力下稳定性有所下降，此外不提供连接池监控。

C3P0 在具体项目应用中，发现此连接池的持续运行的稳定性相当不错，在大并发量的压力下稳定性也有一定保证，此外不提供连接池监控。

Druid 据网上测试对比，比目前的DBCP或C3P0数据库连接池性能更好。

（另外，Proxool 在高并发时出现异常）

　　DBCP1.2版本性能一般，比c3p0差挺多。DBCP1.4和1.3，配合（依赖）commons pool 1.6的jar包,各方面功能、性能推进到新的高峰。相对1.2版本提高不少。

超越(或相当)了c3p0，建议使用DBCP1.4或1.3 +  commons pool 1.6 ，Tomcat7 中保留DBCP连接池，以兼容已有应用。并提供了新的Tomcat JDBC pool作为DBCP的可选替代。新出的Tomcat JDBC pool，据说比DBCP1.4要好。DBPool 最差，垫底。

个人认为连接池性能排行：Tomcat JDBC pool>DBCP1.4>c3p0>Proxool>DBCP1.42>DBPool

3.1、DBCP数据源

　　DBCP 是 Apache 软件基金组织下的开源连接池实现，要使用DBCP数据源，需要应用程序应在系统中增加如下两个 jar 文件：

  • Commons-dbcp.jar：连接池的实现
  • Commons-pool.jar：连接池实现的依赖库

　　Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。

参考：https://www.cnblogs.com/sunseine/p/5947448.html

3.2、在应用程序中加入dbcp连接池

　　导入相关jar包，创建数据库trswcmv7和表dbcp(int id)
   　　   commons-dbcp-1.4.jar、commons-pool.jar、commons-logging-1.2.jar、mysql-connector-java-5.1.23-bin.jar

实例一
　　在类目录下加入dbcp的配置文件：dbcpconfig.properties

　　　　dbcpconfig.properties的配置信息如下：

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/trswcmv7
username=root
password=trsadmin

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

#最大连接数量
maxActive=50

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

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

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


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

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

#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=

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

　　如下图所示：

　　

　　在获取数据库连接的工具类(如jdbcUtils)的静态代码块中创建池

package com.dbcp;

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

/**
* @ClassName: JdbcUtils_DBCP
* @Description: 数据库连接工具类
* @author: hdb
* @date: 2017-11-03 10:04:36
*
*/ 
public class JdbcUtils_DBCP {
    /**
     * 在java中，编写数据库连接池需实现java.sql.DataSource接口，每一种数据库连接池都是DataSource接口的实现
     * DBCP连接池就是java.sql.DataSource接口的一个具体实现
     */
    private static DataSource ds = null;
    //在静态代码块中创建数据库连接池
    static{
        try{
            //加载dbcpconfig.properties配置文件
            InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
            Properties prop = new Properties();
            prop.load(in);
            //创建数据源
            ds = BasicDataSourceFactory.createDataSource(prop);
        }catch (Exception e) {
            throw new ExceptionInInitializerError("初始化连接错误，请检查配置文件！");
        }
    }
    
    public static Connection getConnection() throws SQLException{
        //从数据源中获取数据库连接
        return ds.getConnection();
    }
    
    /**
    * @Method: release
    * @Description: 释放资源，
    * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
    * @Anthor:hdb
    */ 
    public static void release(Connection conn,Statement st,ResultSet rs){
        if(rs!=null){
            try{
            }catch (Exception e) {
                e.printStackTrace();
            }
            rs = null;
        }
        if(st!=null){
            try{
                st.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
        if(conn!=null){
            try{
                conn.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
View Code

　　测试DBCP数据源(每次测试后清空表dbcp)

package com.dbcp;

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

import org.junit.Test;

public class JdbcUtils_DBCPTest {

    @Test
    public void dbcpDataSourceTest() {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils_DBCP.getConnection();
            for (int i = 1; i <= 2000; i++) {
                String sql = "insert into dbcp values(?)";
                st = conn.prepareStatement(sql, st.RETURN_GENERATED_KEYS);
                st.setInt(1, i);
                st.executeUpdate();
                // 获取数据库自动生成的主键,需要数据库设置自动增长的主键,mysql驱动5.1.17之后需要加上st.RETURN_GENERATED_KEYS
                rs = st.getGeneratedKeys();
            }
            System.out.println("写入完成...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtils_DBCP.release(conn, st, rs);
        }
    }
}
View Code

 

实例二
　　在类目录下加入dbcp的配置文件：dbcp.properties

　　dbcp.properties的配置信息如下：　　

########DBCP配置文件##########
#驱动名
driverClassName=com.mysql.jdbc.Driver
#url
url=jdbc:mysql://127.0.0.1:3306/trswcmv7
#用户名
username=root
#密码
password=trsadmin
#初试连接数
initialSize=30
#最大活跃数
maxTotal=30
#最大idle数
maxIdle=10
#最小idle数
minIdle=5
#最长等待时间(毫秒)
maxWaitMillis=1000
#程序中的连接不使用后是否被连接池回收(该版本要使用removeAbandonedOnMaintenance和removeAbandonedOnBorrow)
#removeAbandoned=true
removeAbandonedOnMaintenance=true
removeAbandonedOnBorrow=true
#连接在所指定的秒数内未使用才会被删除(秒)(为配合测试程序才配置为1秒)
removeAbandonedTimeout=1
View Code

　　如下图所示：

　　　　

　在获取数据库连接的工具类(如DBCPUtil)的静态代码块中创建池

package com.dbcp;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSourceFactory;

/**
 * DBCP配置类
 * 
 * @author hdb
 */
public class DBCPUtil {

    private static Properties properties = new Properties();
    private static DataSource dataSource;
    // 加载DBCP配置文件
    static {

        try {
            // 加载dbcpconfig.properties配置文件
            InputStream in = DBCPUtil.class.getClassLoader()
                    .getResourceAsStream("dbcp.properties");
            properties.load(in);
            dataSource = BasicDataSourceFactory.createDataSource(properties);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 从连接池中获取一个连接
    public static Connection getConnection() {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            connection.setAutoCommit(false);//
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }
}
View Code

　不使用连接池（方便测试对比）

package com.dbcp;


import java.sql.Connection;
import java.sql.DriverManager;

/**
 * 使用JDBC获取数据库连接的类DBConn.java（用于和DBCP连接池对比）
 * @author Administrator
 *
 */
public class DBConn {
    private static Connection conn = null;
    
    //获取一个数据库连接
    public static Connection getConnection() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            DriverManager.registerDriver(new com.mysql.jdbc.Driver());
            String dbUrl = "jdbc:mysql://127.0.0.1:3306/trswcmv7";
            conn = DriverManager.getConnection(dbUrl, "root", "trsadmin");
            System.out.println("========数据库连接成功========");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("========数据库连接失败========");
            return null;
        }
        return conn;
    }
}
View Code

测试DBCP数据源(每次测试后清空表dbcp)

package com.dbcp;

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

import org.junit.Test;

public class DBCPTest {

    // 测试,使用连接池,每写一条数据前,从连接池中获取一个连接
    @Test
    public void testWriteDBByDBCP() throws Exception {
        for (int i = 0; i < 2000; i++) {
            String sql = "insert into dbcp values (" + i + ")";
            try {
                // 通过DBCP连接池写入数据
                Connection conn = DBCPUtil.getConnection();
                Statement stat = conn.createStatement();
                stat.executeUpdate(sql);
                conn.commit();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        System.out.println("写入完成...");
    }

    // 测试,不使用连接池,只建一条连接,写入所有数据
    @Test
    public void testWriteDBByOneConn() throws Exception {
        Connection conn = DBConn.getConnection();
        Statement stat = conn.createStatement();
        for (int i = 0; i < 2000; i++) {
            String sql = "insert into dbcp values (" + i + ")";
            try {
                stat.executeUpdate(sql);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        conn.close();
        System.out.println("写入完成...");
    }

    // 测试,不使用连接池,每写一条数据前,就新建一个连接
    @Test
    public void testWriteDBByEveryConn() throws Exception {
        for (int i = 0; i < 2000; i++) {
            String sql = "insert into dbcp values (" + i + ")";
            Connection conn = DBConn.getConnection();
            try {
                Statement stat = conn.createStatement();
                stat.executeUpdate(sql);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }

            }
        }
        System.out.println("写入完成...");
    }
}
View Code

 3.3、C3P0数据源

　　C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。C3P0数据源在项目开发中使用得比较多。每次新建连接都需要140毫秒左右的时间，所以耗费时间比较多。若使用C3P0连接池来池化连接，随时取用，则平均每次取用只需要10-20毫秒。这在高并发随机访问数据库的时候对效率的提升有很大帮助。

　　c3p0与dbcp区别
  1. dbcp没有自动回收空闲连接的功能
  2. c3p0有自动回收空闲连接功能

3.4、在应用程序中加入C3P0连接池

　　1.导入相关jar包
    　　　c3p0-0.9.2-pre1.jar、mchange-commons-0.2.jar，如果操作的是Oracle数据库，那么还需要导入c3p0-oracle-thin-extras-0.9.2-pre1.jar
　　2、在类目录下加入C3P0的配置文件：c3p0-config.xml（注意，必须是这个文件名）

　　　　c3p0-config.xml的配置信息如下：

<?xml version="1.0" encoding="UTF-8"?>
<!--
c3p0-config.xml必须位于类路径下面
private static ComboPooledDataSource ds;
static{
    try {
        ds = new ComboPooledDataSource("MySQL");
    } catch (Exception e) {
        throw new ExceptionInInitializerError(e);
    }
}
-->

<c3p0-config>
    <!--
    C3P0的缺省(默认)配置，
    如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource();”这样写就表示使用的是C3P0的缺省(默认)配置信息来创建数据源
    -->
    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/trswcmv7</property>
        <property name="user">root</property>
        <property name="password">trsadmin</property>
        
        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>

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

</c3p0-config>
View Code

  更细致化的参考以下配置：

<!--acquireIncrement：链接用完了自动增量3个。 -->
    <property name="acquireIncrement">3</property>

    <!--acquireRetryAttempts：链接失败后重新试30次。-->
    <property name="acquireRetryAttempts">30</property>
 
    <!--acquireRetryDelay；两次连接中间隔1000毫秒。 -->
    <property name="acquireRetryDelay">1000</property>
 
    <!--autoCommitOnClose：连接关闭时默认将所有未提交的操作回滚。 -->
    <property name="autoCommitOnClose">false</property>
 
    <!--automaticTestTable：c3p0测试表，没什么用。-->
    <property name="automaticTestTable">Test</property>
 
    <!--breakAfterAcquireFailure：出错时不把正在提交的数据抛弃。-->
    <property name="breakAfterAcquireFailure">false</property>
 
    <!--checkoutTimeout：100毫秒后如果sql数据没有执行完将会报错，如果设置成0，那么将会无限的等待。 --> 
    <property name="checkoutTimeout">100</property>
 
    <!--connectionTesterClassName：通过实现ConnectionTester或QueryConnectionTester的类来测试连接。类名需制定全路径。Default: com.mchange.v2.c3p0.impl.DefaultConnectionTester-->
    <property name="connectionTesterClassName"></property>
 
    <!--factoryClassLocation：指定c3p0 libraries的路径，如果（通常都是这样）在本地即可获得那么无需设置，默认null即可。-->
    <property name="factoryClassLocation">null</property>
 
    <!--forceIgnoreUnresolvedTransactions：作者强烈建议不使用的一个属性。--> 
    <property name="forceIgnoreUnresolvedTransactions">false</property>
 
    <!--idleConnectionTestPeriod：每60秒检查所有连接池中的空闲连接。--> 
    <property name="idleConnectionTestPeriod">60</property>
 
    <!--initialPoolSize：初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。 --> 
    <property name="initialPoolSize">3</property>
 
    <!--maxIdleTime：最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。-->
    <property name="maxIdleTime">60</property>
 
    <!--maxPoolSize：连接池中保留的最大连接数。 -->
    <property name="maxPoolSize">15</property>
 
    <!--maxStatements：最大链接数。-->
    <property name="maxStatements">100</property>
 
    <!--maxStatementsPerConnection：定义了连接池内单个连接所拥有的最大缓存statements数。Default: 0  -->
    <property name="maxStatementsPerConnection"></property>
 
    <!--numHelperThreads：异步操作，提升性能通过多线程实现多个操作同时被执行。Default: 3--> 
    <property name="numHelperThreads">3</property>
 
    <!--overrideDefaultUser：当用户调用getConnection()时使root用户成为去获取连接的用户。主要用于连接池连接非c3p0的数据源时。Default: null--> 
    <property name="overrideDefaultUser">root</property>
 
    <!--overrideDefaultPassword：与overrideDefaultUser参数对应使用的一个参数。Default: null-->
    <property name="overrideDefaultPassword">password</property>
 
    <!--password：密码。Default: null--> 
    <property name="password"></property>
 
    <!--preferredTestQuery：定义所有连接测试都执行的测试语句。在使用连接测试的情况下这个一显著提高测试速度。注意： 测试的表必须在初始数据源的时候就存在。Default: null-->
    <property name="preferredTestQuery">select id from test where id=1</property>
 
    <!--propertyCycle：用户修改系统配置参数执行前最多等待300秒。Default: 300 --> 
    <property name="propertyCycle">300</property>
 
    <!--testConnectionOnCheckout：因性能消耗大请只在需要的时候使用它。Default: false -->
    <property name="testConnectionOnCheckout">false</property>
 
    <!--testConnectionOnCheckin：如果设为true那么在取得连接的同时将校验连接的有效性。Default: false -->
    <property name="testConnectionOnCheckin">true</property>
 
    <!--user：用户名。Default: null-->
    <property name="user">root</property>
 
    <!--usesTraditionalReflectiveProxies：动态反射代理。Default: false-->
    <property name="usesTraditionalReflectiveProxies">false</property>
View Code

　　如下图所示：

　　

 

　　3、在获取数据库连接的工具类(如jdbcUtils)的静态代码块中创建池

package com.c3p0;

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

/**
* @ClassName: JdbcUtils_C3P0
* @Description: 数据库连接工具类
* @author: hdb
* @date: 2017-11-14 16:24:35
*
*/ 
public class JdbcUtils_C3P0 {
    
    private static ComboPooledDataSource ds = null;
    //在静态代码块中创建数据库连接池
    static{
        try{
            //通过代码创建C3P0数据库连接池
            /*ds = new ComboPooledDataSource();
            ds.setDriverClass("com.mysql.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/trswcmv7");
            ds.setUser("root");
            ds.setPassword("root");
            ds.setInitialPoolSize(10);
            ds.setMinPoolSize(5);
            ds.setMaxPoolSize(20);*/
            
            //通过读取C3P0的xml配置文件创建数据源，C3P0的xml配置文件c3p0-config.xml必须放在src目录下
            //ds = new ComboPooledDataSource();//使用C3P0的默认配置来创建数据源
            ds = new ComboPooledDataSource("MySQL");//使用C3P0的命名配置来创建数据源
            
        }catch (Exception e) {
            throw new ExceptionInInitializerError("数据库连接出错!");
        }
    }
    
    /**
    * @Method: getConnection
    * @Description: 从数据源中获取数据库连接
    * @Anthor:hdb
    * @return Connection
    * @throws SQLException
    */ 
    public static Connection getConnection() throws SQLException{
        //从数据源中获取数据库连接
        return ds.getConnection();
    }
    
    /**
    * @Method: release
    * @Description: 释放资源，
    * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
    */ 
    public static void release(Connection conn,Statement st,ResultSet rs){
        if(rs!=null){
            try{                
                rs.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
            rs = null;
        }
        if(st!=null){
            try{               
                st.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
        if(conn!=null){
            try{                
                conn.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
View Code

　　测试C3P0数据源

package com.c3p0;

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

import org.junit.Test;

public class DataSourceTest {

    @Test
    public void c3p0DataSourceTest() {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils_C3P0.getConnection();
            for (int i = 1; i <= 10; i++) {
                String sql = "insert into dbcp values(?)";
                st = conn.prepareStatement(sql, st.RETURN_GENERATED_KEYS);
                st.setInt(1, 1);
                st.executeUpdate();
                // 获取数据库自动生成的主键,需要数据库设置自动增长的主键,mysql驱动5.1.17之后需要加上st.RETURN_GENERATED_KEYS
                rs = st.getGeneratedKeys();
            }
            System.out.println("写入完成...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtils_C3P0.release(conn, st, rs);
        }
    }
}
View Code

 四、配置Tomcat数据源

　　在实际开发中，我们有时候还会使用服务器提供给我们的数据库连接池，比如我们希望Tomcat服务器在启动的时候可以帮我们创建一个数据库连接池，那么我们在应用程序中就不需要手动去创建数据库连接池，直接使用Tomcat服务器创建好的数据库连接池即可。要想让Tomcat服务器在启动的时候帮我们创建一个数据库连接池，那么需要简单配置一下Tomcat服务器。

4.1、JNDI技术简介

　　JNDI(Java Naming and Directory Interface)，Java命名和目录接口，它对应于J2SE中的javax.naming包，
　　这 套API的主要作用在于：它可以把Java对象放在一个容器中（JNDI容器），并为容器中的java对象取一个名称，以后程序想获得Java对象，只需 通过名称检索即可。其核心API为Context，它代表JNDI容器，其lookup方法为检索容器中对应名称的对象。

　　Tomcat服务器创建的数据源是以JNDI资源的形式发布的，所以说在Tomat服务器中配置一个数据源实际上就是在配置一个JNDI资源，通过查看Tomcat文档，我们知道使用如下的方式配置tomcat服务器的数据源：

<Context>
  <Resource name="jdbc/datasource" auth="Container"
            type="javax.sql.DataSource" username="root" password="XDP"
            driverClassName="com.mysql.jdbc.Driver" 
            url="jdbc:mysql://localhost:3306/jdbcstudy"
            maxActive="8" maxIdle="4"/>
</Context>

　　服务器创建好数据源之后，我们的应用程序又该怎么样得到这个数据源呢，Tomcat服务器创建好数据源之后是以JNDI的形式绑定到一个JNDI容器中的，我们可以把JNDI想象成一个大大的容器，我们可以往这个容器中存放一些对象，一些资源，JNDI容器中存放的对象和资源都会有一个独一无二的名称，应用程序想从JNDI容器中获取资源时，只需要告诉JNDI容器要获取的资源的名称，JNDI根据名称去找到对应的资源后返回给应用程序。我们平时做javaEE开发时，服务器会为我们的应用程序创建很多资源，比如request对象，response对象，服务器创建的这些资源有两种方式提供给我们的应用程序使用：第一种是通过方法参数的形式传递进来，比如我们在Servlet中写的doPost和doGet方法中使用到的request对象和response对象就是服务器以参数的形式传递给我们的。第二种就是JNDI的方式，服务器把创建好的资源绑定到JNDI容器中去，应用程序想要使用资源时，就直接从JNDI容器中获取相应的资源即可。

　　对于上面的name="jdbc/datasource"数据源资源，在应用程序中可以用如下的代码去获取

 Context initCtx = new InitialContext();
 Context envCtx = (Context) initCtx.lookup("java:comp/env");
 dataSource = (DataSource)envCtx.lookup("jdbc/datasource");

　　此种配置下，数据库的驱动jar文件需放置在tomcat的lib下

　　

4.2、配置Tomcat数据源

　　1、在Web项目的WebRoot目录下的META-INF目录创建一个context.xml文件

　　如下图所示：

　　

　　2、在context.xml文件配置tomcat服务器的数据源

<Context>
   <Resource 
       name="jdbc/datasource" 
       auth="Container"
       type="javax.sql.DataSource" 
       username="root" 
       password="trsadmin"
       driverClassName="com.mysql.jdbc.Driver" 
       url="jdbc:mysql://127.0.0.1:3306/trswcmv7"
       maxActive="8" 
       maxIdle="4"/>
</Context
View Code

　　3、将数据库的驱动jar文件需放置在tomcat的lib下

　　

　　4、在获取数据库连接的工具类(如jdbcUtils)的静态代码块中获取JNDI容器中的数据源

package com.jndi;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;

/**
* @ClassName: JdbcUtils_DBCP
* @Description: 数据库连接工具类
* @author: hdb
* @date: 2017-11-14 16:14:30
*
*/ 
public class JdbcUtils_JNDI {
    
    private static DataSource ds = null;
    //在静态代码块中创建数据库连接池
    static{
        try{
             //初始化JNDI
            Context initCtx = new InitialContext();
             //得到JNDI容器
            Context envCtx = (Context) initCtx.lookup("java:comp/env");
             //从JNDI容器中检索name为jdbc/datasource的数据源
            ds = (DataSource)envCtx.lookup("jdbc/datasource");
        }catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
    }
    
    /**
    * @Method: getConnection
    * @Description: 从数据源中获取数据库连接
    * @Anthor:hdb
    * @return Connection
    * @throws SQLException
    */ 
    public static Connection getConnection() throws SQLException{
        //从数据源中获取数据库连接
        return ds.getConnection();
    }
    
    /**
    * @Method: release
    * @Description: 释放资源，
    * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
    */ 
    public static void release(Connection conn,Statement st,ResultSet rs){
        if(rs!=null){
            try{
                rs.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
            rs = null;
        }
        if(st!=null){
            try{
                st.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        if(conn!=null){
            try{
                conn.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
View Code

　　写一个Servlet测试JNDI数据源

package com.jndi;

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

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import me.gacl.util.JdbcUtils_JNDI;

public class JNDITest extends HttpServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        try{
            //获取数据库连接
            conn = JdbcUtils_JNDI.getConnection();
            for (int i = 1; i <= 2000; i++) {
                String sql = "insert into dbcp values(?)";
                st = conn.prepareStatement(sql, st.RETURN_GENERATED_KEYS);
                st.setInt(1, 1);
                st.executeUpdate();
                // 获取数据库自动生成的主键,需要数据库设置自动增长的主键,mysql驱动5.1.17之后需要加上st.RETURN_GENERATED_KEYS
                rs = st.getGeneratedKeys();
            }
            System.out.println("写入完成...");
        }catch (Exception e) {
            e.printStackTrace();
        }finally{
            //释放资源
            JdbcUtils_JNDI.release(conn, st, rs);
        }
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }

}
View Code

 工程地址：下载工程

posted @ 2018-06-16 01:23  Coosee  阅读(437)  评论(0)  编辑  收藏  举报