Java中JDBC連接池的基本原理及實現方式
一、 應用程序直接建立數據庫連接模型
應用程序直接每次訪問數據庫時，都建立創建一個數據庫的鏈接，這樣每次建立這樣的連接都需要耗費的資源，當同時有很多用戶在使用應用程序時，可能會導致應用程序崩潰。
圖為應用程序直接建立數據庫連接模型
二、使用數據庫連接池優化模型
數據庫連接池的基本思路是，平時建立適量的數據庫的連接，放在一個集合中，當有用戶需要建立數據庫連接的時候，直接到集合中取出一個數據庫連接對象（Connection），這樣不用再需要重新創建，這樣會節省大量的資源，當用戶不需要在對數據庫進行訪問瞭，那麼就將數據庫連接對象（Connection）重新放回到集合中，以便方便下次使用。
數據庫連接池優化模型圖
1、關於連接池中的連接數量的一些規定：
- （1）最小連接數:是連接池一直保持的數據庫連接,所以如果應用程序對數據庫連接的使用量不大,將會有大量的數據庫連接資源被浪費（適量）.
- （2）最大連接數:是連接池能申請的最大連接數,如果數據庫連接請求超過次數,後面的數據庫連接請求將被加入到等待隊列中,這會影響以後的數據庫操作。通常在使用完起始集合中的連接後，會再重新創建一些數據庫連接對象，用來滿足用戶需求，但是這種新建並不是無限制的。
- （3）當使用完的連接對象需要重新放回到集合中以備使用，但是超過最小連接數的連接在使用完不會馬上被釋放,他將被放到連接池中等待重復使用或是超時後最終被釋放。
2、編寫數據庫連接池
簡單思路為：創建一個類繼承DataSource接口，在類中實現靜態的加載出配置文檔db.properties文檔，並創建最小連接量的數據庫連接對象(Connection)，添加到Linkedlist（選擇Linkedlist集合原因是便於增刪）集合中。重寫getConnection()函數，在getConnection()函數中實現數據庫連接對象的獲取。
db.properties文檔
driver=com.mysql.jdbc.Driver url=jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8 username=root password=tiger jdbcConnectionInitSize=10
創建數據庫連接池：
package JDBC;
import java.io.IOException;
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.sql.SQLFeatureNotSupportedException;
import java.util.LinkedList;
import java.util.Properties;
import java.util.logging.Logger;
import javax.sql.DataSource;
public class JdbcConnectionsPool implements DataSource {
/*
* 使用靜態塊代碼，初始化連接池，創建連接池的中最小鏈接數量連接，
* 創建linkedlist集合，將這些連接放入集合中
*/
//創建linkedlist集合
private static LinkedList<Connection> linkedlist1=new LinkedList<Connection>();
private static String driver;//
private static String url;//
private static String username;//數據庫登陸名
private static String password;//數據庫的登陸密碼
private static int jdbcConnectionInitSize;//最小連接數量
private static int max=1; //當前最大連接數量=max*jdbcConnectionInitSize
static{
//通過反射機制獲取訪問db.properties文件
InputStream is=JdbcConnectionsPool.class.getResourceAsStream("/db.properties");
Properties prop=new Properties();
try {
//加載db.properties文件
prop.load(is);
//獲取db.properties文件中的數據庫連接信息
driver=prop.getProperty("driver");
url=prop.getProperty("url");
username=prop.getProperty("username");
password=prop.getProperty("password");
jdbcConnectionInitSize=Integer.parseInt(prop.getProperty("jdbcConnectionInitSize"));
Class.forName("com.mysql.jdbc.Driver");
//創建最小連接數個數據庫連接對象以備使用
for(int i=0;i<jdbcConnectionInitSize;i++){
Connection conn=DriverManager.getConnection(url, username, password);
System.out.println("獲取到瞭鏈接" + conn);
//將創建好的數據庫連接對象添加到Linkedlist集合中
linkedlist1.add(conn);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@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 Logger getParentLogger() throws SQLFeatureNotSupportedException {
// TODO Auto-generated method stub
return null;
}
@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;
}
/*
* 實現數據庫連接的獲取和新創建
*/
@Override
public Connection getConnection() throws SQLException {
//如果集合中沒有數據庫連接對象瞭，且創建的數據庫連接對象沒有達到最大連接數量，可以再創建一組數據庫連接對象以備使用
if(linkedlist1.size()==0&&max<=5){
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for(int i=0;i<jdbcConnectionInitSize;i++){
Connection conn=DriverManager.getConnection(url, username, password);
System.out.println("獲取到瞭鏈接" + conn);
//將創建好的數據庫連接對象添加到Linkedlist集合中
linkedlist1.add(conn);
}
max++;
}
if(linkedlist1.size()>0){
//從linkedlist集合中取出一個數據庫鏈接對象Connection使用
Connection conn1=linkedlist1.removeFirst();
System.out.println("linkedlist1數據庫連接池大小是" + linkedlist1.size());
/*返回一個Connection對象，並且設置Connection對象方法調用的限制，
*當調用connection類對象的close()方法時會將Connection對象重新收集放入linkedlist集合中。
*/
return (Connection) Proxy.newProxyInstance(conn1.getClass().getClassLoader(),//這裡換成JdbcConnectionsPool.class.getClassLoader();也行
conn1.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if(!method.getName().equalsIgnoreCase("close")){
return method.invoke(conn1, args);
}else{
linkedlist1.add(conn1);
System.out.println(conn1+"對象被釋放，重新放回linkedlist集合中！");
System.out.println("此時Linkedlist集合中有"+linkedlist1.size()+"個數據庫連接對象！");
return null;
}
}
});
}else{
System.out.println("連接數據庫失敗！");
}
return null;
}
@Override
public Connection getConnection(String username, String password) throws SQLException {
return null;
}
}
進一步封裝一些相關數據庫的類的方法
package JDBC;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JdbcConnectionPoolTest {
/**
* @Field: pool
* 數據庫連接池
*/
private static JdbcConnectionsPool pool = new JdbcConnectionsPool();
/**
* @Method: getConnection
* @Description: 從數據庫連接池中獲取數據庫連接對象
* @return Connection數據庫連接對象
* @throws SQLException
*/
public static Connection getConnection() throws SQLException{
return pool.getConnection();
}
/**
* @Method: release
* @Description: 釋放資源，
* 釋放的資源包括Connection數據庫連接對象，負責執行SQL命令的Statement對象，存儲查詢結果的ResultSet對象
* @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();
}
}
}
}
調試代碼：
package JDBC;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
public class TestJdbcPool {
public static void main(String[] args) throws SQLException {
//實例化封裝瞭有關數據庫類方法類的對象
JdbcConnectionPoolTest jcpt=new JdbcConnectionPoolTest();
//獲得數據庫連接對象
Connection conn=jcpt.getConnection();
//下面代碼是存儲過程的調用
String s="call SP_select_nofilter6(?,?,?) ";
CallableStatement cst=conn.prepareCall(s);
cst.setInt(2, 2);
cst.registerOutParameter(1, Types.VARCHAR);
cst.registerOutParameter(3, Types.BLOB);
ResultSet rs=cst.executeQuery();
String name=cst.getString(1);
Blob b=cst.getBlob(3);
System.out.println("name:"+name+" Blob:"+b);
//關閉所有的數據庫資源
jcpt.release(conn, cst, rs);
}
}
運行結果：
獲取到瞭鏈接com.mysql.jdbc.Connection@5f184fc6 獲取到瞭鏈接com.mysql.jdbc.Connection@723279cf 獲取到瞭鏈接com.mysql.jdbc.Connection@4e50df2e 獲取到瞭鏈接com.mysql.jdbc.Connection@7cc355be 獲取到瞭鏈接com.mysql.jdbc.Connection@52cc8049 獲取到瞭鏈接com.mysql.jdbc.Connection@7530d0a 獲取到瞭鏈接com.mysql.jdbc.Connection@4fca772d 獲取到瞭鏈接com.mysql.jdbc.Connection@7cd84586 獲取到瞭鏈接com.mysql.jdbc.Connection@70177ecd 獲取到瞭鏈接com.mysql.jdbc.Connection@cc34f4d linkedlist1數據庫連接池大小是9 name:xiao Blob:com.mysql.jdbc.Blob@5197848c com.mysql.jdbc.Connection@5f184fc6對象被釋放，重新放回linkedlist集合中！ 此時Linkedlist集合中有10個數據庫連接對象！
標紅的代碼是比較重要的代碼段~，其中Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)，返回一個指定接口的代理類實例，該接口可以將方法調用指派到指定的調用處理程序，loader參數定義代理類的類加載器，interfaces – 代理類要實現的接口列表，h – 指派方法調用的調用處理程序 。
三、兩個開源的數據庫連接池
在使用瞭數據庫連接池之後，在項目的實際開發中就不需要編寫連接數據庫的代碼瞭，直接從數據源獲得數據庫的連接。
1、dbcp連接
（1）導入相關jar包
commons-dbcp2-2.1.1.jar
commons-pool2-2.4.2.jar
commoms-logging-1.2.jar
（2）在項目根目錄增加配置文件dbcp.properties
#連接設置 driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/jdbcstudy username=root password=XDP #<!-- 初始化連接 --> 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
（3）程序實現dbcp連接
代碼演示：
數據庫對象的代理類（封裝Connection類的一些方法）
package DBCP;
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;
import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
public class DBCPUtil {
private static DataSource ds;
private static final String configFile="/dbcp.properties";
public DBCPUtil(){
//實例化properties對象用於加載配置文件
Properties prop=new Properties();
InputStream is=DBCPUtil.class.getResourceAsStream(configFile);
try {
prop.load(is);
ds=BasicDataSourceFactory.createDataSource(prop);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/*
* 獲取數據庫連接對象
*/
public Connection getConn(){
Connection conn=null;
if(ds!=null){
try {
conn=ds.getConnection();
conn.setAutoCommit(false);//設置禁止操作自動提交的情況
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return conn;
}
return conn;
}
/*
* 封裝數據庫相關資源的關閉工作
*/
public void close(ResultSet rs,Statement st,Connection conn) throws SQLException{
if(rs!=null){
rs.close();
}
if(st!=null){
st.close();
}
if(conn!=null){
conn.close();
}
}
}
代碼調用：
package DBCP;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
public class DbcpTest {
public static void main(String[] args) throws SQLException {
//實例化數據庫連接的代理類
DBCPUtil dbcpUtil=new DBCPUtil();
//獲得數據庫連接對象
Connection conn=dbcpUtil.getConn();
//下面代碼是存儲過程的調用
String s="call SP_select_nofilter6(?,?,?) ";
CallableStatement cst=conn.prepareCall(s);
cst.setInt(2, 2);
cst.registerOutParameter(1, Types.VARCHAR);
cst.registerOutParameter(3, Types.BLOB);
ResultSet rs=cst.executeQuery();
String name=cst.getString(1);
Blob b=cst.getBlob(3);
System.out.println("name:"+name+" Blob:"+b);
//關閉資源
dbcpUtil.close(rs, cst, conn);
}
}
運行結果：
name:xiao Blob:com.mysql.jdbc.Blob@30946e09
2、c3p0連接池
c3p0是一個開源的JDBC連接池，它實現瞭數據源和JNDI綁定支持JDBC3和JDBC2的標準擴展
（1）導入相關的jar包
cc3p0-0.9.2-pre4.jar
mchange-commons-java-0.2.2.jar
如果是oracle數據庫還需要添加c3p0-oracle-thin-extras-0.9.2-pre1.jar
（2）在項目根目錄下增加配置文件
1）c3p0.properties
##配置除user,password,minpoolsize,maxpoolsize的參數 ##[註意] 整數值不能有空格 #連接設置 driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8 username=root password=tiger #初始化時獲取三個連接，取值應在minPoolSize與maxPoolSize之間。Default: 3 c3p0.initialPoolSize=10 #當連接池中的連接耗盡的時候c3p0一次同時獲取的連接數。Default: 3 c3p0.acquireIncrement=3 #最大空閑時間,60秒內未使用則連接被丟棄。若為0則永不丟棄。Default: 0 #maxIdleTime應該小於MySQL的wait_timeout的值 c3p0.maxIdleTime=600 #定義在從數據庫獲取新連接失敗後重復嘗試的次數。Default: 30 c3p0.acquireRetryAttempts=5 #兩次連接中間隔時間，單位毫秒。Default: 1000 c3p0.acquireRetryDelay=1000 #連接關閉時默認將所有未提交的操作回滾。Default: false c3p0.autoCommitOnClose=false #c3p0將建一張名為Test的空表，並使用其自帶的查詢語句進行測試。如果定義瞭這個參數那麼 #屬性preferredTestQuery將被忽略。你不能在這張Test表上進行任何操作，它將隻供c3p0測試 #使用。Default: null #c3p0.automaticTestTable= #獲取連接失敗將會引起所有等待連接池來獲取連接的線程拋出異常。但是數據源仍有效 #保留，並在下次調用getConnection()的時候繼續嘗試獲取連接。如果設為true，那麼在嘗試 #獲取連接失敗後該數據源將申明已斷開並永久關閉。Default: false #c3p0.breakAfterAcquireFailure=false #當連接池用完時客戶端調用getConnection()後等待獲取新連接的時間，超時後將拋出 #SQLException,如設為0則無限期等待。單位毫秒。Default: 0 c3p0.checkoutTimeout=10000 #每60秒檢查所有連接池中的空閑連接。Default: 0 c3p0.idleConnectionTestPeriod=600 #JDBC的標準參數，用以控制數據源內加載的PreparedStatements數量。但由於預緩存的statements #屬於單個connection而不是整個連接池。所以設置這個參數需要考慮到多方面的因素。 #如果maxStatements與maxStatementsPerConnection均為0，則緩存被關閉。Default: 0 c3p0.maxStatements=100 #maxStatementsPerConnection定義瞭連接池內單個連接所擁有的最大緩存statements數。Default: 0 c3p0.maxStatementsPerConnection=0 #c3p0是異步操作的，緩慢的JDBC操作通過幫助進程完成。擴展這些操作可以有效的提升性能 #通過多線程實現多個操作同時被執行。Default: 3 c3p0.numHelperThreads=3
2）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/imooc?useUnicode=true&characterEncoding=utf-8</property>
<property name="user">root</property>
<property name="password">tiger</property>
<property name="acquireIncrement">5</property>
<property name="initialPoolSize">10</property>
<property name="minPoolSize">5</property>
<property name="maxPoolSize">20</property>
</default-config>
<!--
C3P0的命名配置，
如果在代碼中“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/imooc?useUnicode=true&characterEncoding=utf-8</property>
<property name="user">root</property>
<property name="password">tiger</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>
（3）編寫類文件，創建連接池
1）c3p0.properties配置文件情況下
數據庫對象的代理類（封裝Connection類的一些方法）
package C3P0;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class C3P0Util {
private static ComboPooledDataSource ds=new ComboPooledDataSource();
/*
* 獲取數據庫連接對象
*/
public static Connection getConnection() throws SQLException{
return ds.getConnection();
}
/*
* 封裝數據庫相關資源的關閉工作
*/
public void close(ResultSet rs,Statement st,Connection conn) throws SQLException{
if(rs!=null){
rs.close();
}
if(st!=null){
st.close();
}
if(conn!=null){
conn.close();
}
}
}
代碼調用：
package C3P0;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
public class C3P0Test {
public static void main(String[] args) throws SQLException {
C3P0Util c3p0Util=new C3P0Util();
Connection conn=c3p0Util.getConnection();
//下面代碼是存儲過程的調用
String s="call SP_select_nofilter6(?,?,?) ";
CallableStatement cst=conn.prepareCall(s);
cst.setInt(2, 2);
cst.registerOutParameter(1, Types.VARCHAR);
cst.registerOutParameter(3, Types.BLOB);
ResultSet rs=cst.executeQuery();
String name=cst.getString(1);
Blob b=cst.getBlob(3);
System.out.println("name:"+name+" Blob:"+b);
//關閉資源
c3p0Util.close(rs, cst, conn);
}
}
運行結果：
二月 14, 2017 7:36:12 下午 com.mchange.v2.log.MLog
信息: MLog clients using java 1.4+ standard logging.
二月 14, 2017 7:36:13 下午 com.mchange.v2.c3p0.C3P0Registry
信息: Initializing c3p0-0.9.5.2 [built 08-December-2015 22:06:04 -0800; debug? true; trace: 10]
二月 14, 2017 7:36:13 下午 com.mchange.v2.c3p0.impl.AbstractPoolBackedDataSource
信息: Initializing c3p0 pool... com.mchange.v2.c3p0.ComboPooledDataSource [ acquireIncrement -> 3, acquireRetryAttempts -> 5, acquireRetryDelay -> 1000, autoCommitOnClose -> false, automaticTestTable -> null, breakAfterAcquireFailure -> false, checkoutTimeout -> 10000, connectionCustomizerClassName -> null, connectionTesterClassName -> com.mchange.v2.c3p0.impl.DefaultConnectionTester, contextClassLoaderSource -> caller, dataSourceName -> 2y4pm69mgrekqw18rvmvn|7aec35a, debugUnreturnedConnectionStackTraces -> false, description -> null, driverClass -> com.mysql.jdbc.Driver, extensions -> {}, factoryClassLocation -> null, forceIgnoreUnresolvedTransactions -> false, forceSynchronousCheckins -> false, forceUseNamedDriverClass -> false, identityToken -> 2y4pm69mgrekqw18rvmvn|7aec35a, idleConnectionTestPeriod -> 600, initialPoolSize -> 10, jdbcUrl -> jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8, maxAdministrativeTaskTime -> 0, maxConnectionAge -> 0, maxIdleTime -> 600, maxIdleTimeExcessConnections -> 0, maxPoolSize -> 15, maxStatements -> 100, maxStatementsPerConnection -> 0, minPoolSize -> 3, numHelperThreads -> 3, preferredTestQuery -> null, privilegeSpawnedThreads -> false, properties -> {user=******, password=******}, propertyCycle -> 0, statementCacheNumDeferredCloseThreads -> 0, testConnectionOnCheckin -> false, testConnectionOnCheckout -> false, unreturnedConnectionTimeout -> 0, userOverrides -> {}, usesTraditionalReflectiveProxies -> false ]
name:xiao Blob:com.mysql.jdbc.Blob@31b7dea0
2）c3p0-config.xml配置文檔情況下
數據庫對象的代理類（封裝Connection類的一些方法）
package C3P0;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class C3P0Util1 {
private static ComboPooledDataSource ds;
/*
* 獲取數據庫連接對象
*/
public static Connection getConnection() throws SQLException{
//通過代碼創建C3P0數據庫連接池
/*ds = new ComboPooledDataSource();
ds.setDriverClass("com.mysql.jdbc.Driver");
ds.setJdbcUrl("jdbc:mysql://localhost:3306/jdbcstudy");
ds.setUser("root");
ds.setPassword("XDP");
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的命名配置來創建數據源
return ds.getConnection();
}
/*
* 封裝數據庫相關資源的關閉工作
*/
public void close(ResultSet rs,Statement st,Connection conn) throws SQLException{
if(rs!=null){
rs.close();
}
if(st!=null){
st.close();
}
if(conn!=null){
conn.close();
}
}
}
代碼調用：
package C3P0;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
public class C3P0Test1 {
public static void main(String[] args) throws SQLException {
C3P0Util1 c3p0Util1=new C3P0Util1();
Connection conn=c3p0Util1.getConnection();
//下面代碼是存儲過程的調用
String s="call SP_select_nofilter6(?,?,?) ";
CallableStatement cst=conn.prepareCall(s);
cst.setInt(2, 2);
cst.registerOutParameter(1, Types.VARCHAR);
cst.registerOutParameter(3, Types.BLOB);
ResultSet rs=cst.executeQuery();
String name=cst.getString(1);
Blob b=cst.getBlob(3);
System.out.println("name:"+name+" Blob:"+b);
//關閉資源
c3p0Util1.close(rs, cst, conn);
}
}
運行結果：
二月 14, 2017 8:06:03 下午 com.mchange.v2.log.MLog
信息: MLog clients using java 1.4+ standard logging.
二月 14, 2017 8:06:03 下午 com.mchange.v2.c3p0.C3P0Registry
信息: Initializing c3p0-0.9.5.2 [built 08-December-2015 22:06:04 -0800; debug? true; trace: 10]
二月 14, 2017 8:06:03 下午 com.mchange.v2.c3p0.impl.AbstractPoolBackedDataSource
信息: Initializing c3p0 pool... com.mchange.v2.c3p0.ComboPooledDataSource [ acquireIncrement -> 5, acquireRetryAttempts -> 5, acquireRetryDelay -> 1000, autoCommitOnClose -> false, automaticTestTable -> null, breakAfterAcquireFailure -> false, checkoutTimeout -> 10000, connectionCustomizerClassName -> null, connectionTesterClassName -> com.mchange.v2.c3p0.impl.DefaultConnectionTester, contextClassLoaderSource -> caller, dataSourceName -> MySQL, debugUnreturnedConnectionStackTraces -> false, description -> null, driverClass -> com.mysql.jdbc.Driver, extensions -> {}, factoryClassLocation -> null, forceIgnoreUnresolvedTransactions -> false, forceSynchronousCheckins -> false, forceUseNamedDriverClass -> false, identityToken -> 2y4pm69mgsgybs1qf3g8s|6e5e91e4, idleConnectionTestPeriod -> 600, initialPoolSize -> 10, jdbcUrl -> jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8, maxAdministrativeTaskTime -> 0, maxConnectionAge -> 0, maxIdleTime -> 600, maxIdleTimeExcessConnections -> 0, maxPoolSize -> 20, maxStatements -> 100, maxStatementsPerConnection -> 0, minPoolSize -> 5, numHelperThreads -> 3, preferredTestQuery -> null, privilegeSpawnedThreads -> false, properties -> {user=******, password=******}, propertyCycle -> 0, statementCacheNumDeferredCloseThreads -> 0, testConnectionOnCheckin -> false, testConnectionOnCheckout -> false, unreturnedConnectionTimeout -> 0, userOverrides -> {}, usesTraditionalReflectiveProxies -> false ]
name:xiao Blob:com.mysql.jdbc.Blob@c39f790
總結：其實不管配置文件是c3p0.properties還是c3p0-config.xml，其代碼實現部分沒有多大區別，唯一區別可能就是c3p0-config.xml情況下可以調用含參的ComboPooledDataSource(String s)構造函數，兩個都可以調用其默認的無參構造函數。
3、dbcp和c3p0不同之處
| dbcp | c3p0 |
|---|---|
| spring組織推薦使用 | Hibernate組織推薦使用 |
| 強制關閉連接或者數據庫重啟後無法自動重連 | 強制關閉連接或者數據庫重啟可以自動連接 |
| 沒有自動的去回收空閑連接的功能 | 自動回收空閑的功能 |
| DBCP提供最大連接數 |
c3p0提供最大空閑時間 |
| dbcp並沒用相應功能 | c3p0可以控制數據源加載的prepareedstatement數量，並且可以設置幫助線程的數量來提升JDBC操作速度 |
以上所述是小編給大傢介紹的Java中JDBC連接池的基本原理及實現方式，希望對大傢有所幫助。在此也非常感謝大傢對WalkonNet網站的支持！
推薦閱讀：
- JDBC連接的六步實例代碼（與mysql連接）
- JDBC連接MySQL並實現模糊查詢
- Java 如何使用JDBC連接數據庫
- Java JDBC自定義封裝工具類的步驟和完整代碼
- MySQL安裝與idea的連接實現