一、 直接建立數據庫連接
應用程序直接每次訪問數據庫時，都建立創建一個數據庫的鏈接，這樣每次建立這樣的連接都需要耗費的資源，當同時有很多用戶在使用時可能會導致應用程序崩潰。
圖為直接建立數據庫連接
二、使用數據庫連接池連接
數據庫連接池的基本思路是，平時建立適量的數據庫的連接，放在一個集合中，當有用戶需要建立數據庫連接的時候，直接到集合中取出一個數據庫連接對象（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
JdbcConnectionsPool.java
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; } }
三、兩個開源的數據庫連接池
在使用了數據庫連接池之后，在項目的實際開發中就不需要編寫連接數據庫的代碼了，直接從數據源獲得數據庫的連接。
1、dbcp連接
（1）導入相關jar包
commons-dbcp2-2.1.1.jar
commons-pool2-2.4.2.jar
commoms-logging-1.2.jar
（2）在項目根目錄增加配置文件dbcp.properties
1 #連接設置 2 driverClassName=com.mysql.jdbc.Driver 3 url=jdbc:mysql://localhost:3306/jdbcstudy 4 username=root 5 password=XDP 6 7 #<!-- 初始化連接 --> 8 initialSize=10 9 10 #最大連接數量 11 maxActive=50 12 13 #<!-- 最大空閑連接 --> 14 maxIdle=20 15 16 #<!-- 最小空閑連接 --> 17 minIdle=5 18 19 #<!-- 超時等待時間以毫秒為單位 6000毫秒/1000等於60秒 --> 20 maxWait=60000 21 22 23 #JDBC驅動建立連接時附帶的連接屬性屬性的格式必須為這樣：[屬性名=property;] 24 #注意："user" 與 "password" 兩個屬性會被明確地傳遞，因此這里不需要包含他們。 25 connectionProperties=useUnicode=true;characterEncoding=UTF8 26 27 #指定由連接池所創建的連接的自動提交（auto-commit）狀態。 28 defaultAutoCommit=true 29 30 #driver default 指定由連接池所創建的連接的只讀（read-only）狀態。 31 #如果沒有設置該值，則“setReadOnly”方法將不被調用。（某些驅動並不支持只讀模式，如：Informix） 32 defaultReadOnly= 33 34 #driver default 指定由連接池所創建的連接的事務級別（TransactionIsolation）。 35 #可用值為下列之一：（詳情可見javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE 36 defaultTransactionIsolation=READ_UNCOMMITTED
（3）程序實現dbcp連接
代碼演示：
數據庫對象的代理類（封裝Connection類的一些方法）
1 package DBCP;
2
3 import java.io.IOException;
4 import java.io.InputStream;
5 import java.sql.Connection;
6 import java.sql.ResultSet;
7 import java.sql.SQLException;
8 import java.sql.Statement;
9 import java.util.Properties;
10
11 import javax.sql.DataSource;
12
13 import org.apache.commons.dbcp.BasicDataSourceFactory;
14
15 public class DBCPUtil {
16 private static DataSource ds;
17 private static final String configFile="/dbcp.properties";
18
19 public DBCPUtil(){
20 //實例化properties對象用於加載配置文件
21 Properties prop=new Properties();
22 InputStream is=DBCPUtil.class.getResourceAsStream(configFile);
23 try {
24 prop.load(is);
25 ds=BasicDataSourceFactory.createDataSource(prop);
26 } catch (IOException e) {
27 // TODO Auto-generated catch block
28 e.printStackTrace();
29 } catch (Exception e) {
30 // TODO Auto-generated catch block
31 e.printStackTrace();
32 }
33 }
34 /*
35 * 獲取數據庫連接對象
36 */
37 public Connection getConn(){
38 Connection conn=null;
39 if(ds!=null){
40 try {
41 conn=ds.getConnection();
42 conn.setAutoCommit(false);//設置禁止操作自動提交的情況
43 } catch (SQLException e) {
44 // TODO Auto-generated catch block
45 e.printStackTrace();
46 }
47 return conn;
48 }
49 return conn;
50 }
51 /*
52 * 封裝數據庫相關資源的關閉工作
53 */
54 public void close(ResultSet rs,Statement st,Connection conn) throws SQLException{
55 if(rs!=null){
56 rs.close();
57 }
58 if(st!=null){
59 st.close();
60 }
61 if(conn!=null){
62 conn.close();
63 }
64 }
65 }
代碼調用：
1 package DBCP;
2
3 import java.sql.Blob;
4 import java.sql.CallableStatement;
5 import java.sql.Connection;
6 import java.sql.ResultSet;
7 import java.sql.SQLException;
8 import java.sql.Types;
9
10 public class DbcpTest {
11
12 public static void main(String[] args) throws SQLException {
13 //實例化數據庫連接的代理類
14 DBCPUtil dbcpUtil=new DBCPUtil();
15 //獲得數據庫連接對象
16 Connection conn=dbcpUtil.getConn();
17 //下面代碼是存儲過程的調用
18 String s="call SP_select_nofilter6(?,?,?) ";
19 CallableStatement cst=conn.prepareCall(s);
20 cst.setInt(2, 2);
21 cst.registerOutParameter(1, Types.VARCHAR);
22 cst.registerOutParameter(3, Types.BLOB);
23 ResultSet rs=cst.executeQuery();
24 String name=cst.getString(1);
25 Blob b=cst.getBlob(3);
26
27 System.out.println("name:"+name+" Blob:"+b);
28 //關閉資源
29 dbcpUtil.close(rs, cst, conn);
30 }
31
32 }
運行結果：
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的參數 ##[注意] 整數值不能有空格 #連接設置 c3p0.driverClass=com.mysql.cj.jdbc.Driver c3p0.jdbcUrl=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=UTF-8 c3p0.user=root c3p0.password=a123456 #初始化時獲取三個連接，取值應在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文檔
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!--
3 c3p0-config.xml必須位於類路徑下面
4 private static ComboPooledDataSource ds;
5 static{
6 try {
7 ds = new ComboPooledDataSource("MySQL");
8 } catch (Exception e) {
9 throw new ExceptionInInitializerError(e);
10 }
11 }
12 -->
13
14 <c3p0-config>
15 <!--
16 C3P0的缺省(默認)配置，
17 如果在代碼中“ComboPooledDataSource ds = new ComboPooledDataSource();”這樣寫就表示使用的是C3P0的缺省(默認)配置信息來創建數據源
18 -->
19 <default-config>
20 <property name="driverClass">com.mysql.jdbc.Driver</property>
21 <property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8</property>
22 <property name="user">root</property>
23 <property name="password">tiger</property>
24
25 <property name="acquireIncrement">5</property>
26 <property name="initialPoolSize">10</property>
27 <property name="minPoolSize">5</property>
28 <property name="maxPoolSize">20</property>
29 </default-config>
30
31 <!--
32 C3P0的命名配置，
33 如果在代碼中“ComboPooledDataSource ds = new ComboPooledDataSource("MySQL");”這樣寫就表示使用的是name是MySQL的配置信息來創建數據源
34 -->
35 <named-config name="MySQL">
36 <property name="driverClass">com.mysql.jdbc.Driver</property>
37 <property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8</property>
38 <property name="user">root</property>
39 <property name="password">tiger</property>
40
41 <property name="acquireIncrement">5</property>
42 <property name="initialPoolSize">10</property>
43 <property name="minPoolSize">5</property>
44 <property name="maxPoolSize">20</property>
45 </named-config>
46
47 </c3p0-config>
（3）編寫類文件，創建連接池
1）c3p0.properties配置文件情況下
數據庫對象的代理類（封裝Connection類的一些方法）
1 package C3P0;
2
3 import java.sql.Connection;
4 import java.sql.ResultSet;
5 import java.sql.SQLException;
6 import java.sql.Statement;
7
8 import com.mchange.v2.c3p0.ComboPooledDataSource;
9
10 public class C3P0Util {
11
12 private static ComboPooledDataSource ds=new ComboPooledDataSource();
13
14 /*
15 * 獲取數據庫連接對象
16 */
17 public static Connection getConnection() throws SQLException{
18 return ds.getConnection();
19 }
20
21 /*
22 * 封裝數據庫相關資源的關閉工作
23 */
24 public void close(ResultSet rs,Statement st,Connection conn) throws SQLException{
25 if(rs!=null){
26 rs.close();
27 }
28 if(st!=null){
29 st.close();
30 }
31 if(conn!=null){
32 conn.close();
33 }
34 }
35 }
代碼調用：
1 package C3P0;
2
3 import java.sql.Blob;
4 import java.sql.CallableStatement;
5 import java.sql.Connection;
6 import java.sql.ResultSet;
7 import java.sql.SQLException;
8 import java.sql.Types;
9
10 public class C3P0Test {
11
12 public static void main(String[] args) throws SQLException {
13 C3P0Util c3p0Util=new C3P0Util();
14 Connection conn=c3p0Util.getConnection();
15 //下面代碼是存儲過程的調用
16 String s="call SP_select_nofilter6(?,?,?) ";
17 CallableStatement cst=conn.prepareCall(s);
18 cst.setInt(2, 2);
19 cst.registerOutParameter(1, Types.VARCHAR);
20 cst.registerOutParameter(3, Types.BLOB);
21 ResultSet rs=cst.executeQuery();
22 String name=cst.getString(1);
23 Blob b=cst.getBlob(3);
24
25 System.out.println("name:"+name+" Blob:"+b);
26 //關閉資源
27 c3p0Util.close(rs, cst, conn);
28 }
29 }
運行結果：
1 二月 14, 2017 7:36:12 下午 com.mchange.v2.log.MLog
2 信息: MLog clients using java 1.4+ standard logging.
3 二月 14, 2017 7:36:13 下午 com.mchange.v2.c3p0.C3P0Registry
4 信息: Initializing c3p0-0.9.5.2 [built 08-December-2015 22:06:04 -0800; debug? true; trace: 10]
5 二月 14, 2017 7:36:13 下午 com.mchange.v2.c3p0.impl.AbstractPoolBackedDataSource
6 信息: 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 ]
7 name:xiao Blob:com.mysql.jdbc.Blob@31b7dea0
2） c3p0-config.xml配置文檔情況下
數據庫對象的代理類（封裝Connection類的一些方法）
1 package C3P0;
2
3 import java.sql.Connection;
4 import java.sql.ResultSet;
5 import java.sql.SQLException;
6 import java.sql.Statement;
7
8 import com.mchange.v2.c3p0.ComboPooledDataSource;
9
10 public class C3P0Util1 {
11
12 private static ComboPooledDataSource ds;
13
14 /*
15 * 獲取數據庫連接對象
16 */
17 public static Connection getConnection() throws SQLException{
18 //通過代碼創建C3P0數據庫連接池
19 /*ds = new ComboPooledDataSource();
20 ds.setDriverClass("com.mysql.jdbc.Driver");
21 ds.setJdbcUrl("jdbc:mysql://localhost:3306/jdbcstudy");
22 ds.setUser("root");
23 ds.setPassword("XDP");
24 ds.setInitialPoolSize(10);
25 ds.setMinPoolSize(5);
26 ds.setMaxPoolSize(20);*/
27
28 //通過讀取C3P0的xml配置文件創建數據源，C3P0的xml配置文件c3p0-config.xml必須放在src目錄下
29 //ds = new ComboPooledDataSource();//使用C3P0的默認配置來創建數據源
30 ds = new ComboPooledDataSource("MySQL");//使用C3P0的命名配置來創建數據源
31 return ds.getConnection();
32 }
33
34 /*
35 * 封裝數據庫相關資源的關閉工作
36 */
37 public void close(ResultSet rs,Statement st,Connection conn) throws SQLException{
38 if(rs!=null){
39 rs.close();
40 }
41 if(st!=null){
42 st.close();
43 }
44 if(conn!=null){
45 conn.close();
46 }
47 }
48 }
代碼調用：
1 package C3P0;
2
3 import java.sql.Blob;
4 import java.sql.CallableStatement;
5 import java.sql.Connection;
6 import java.sql.ResultSet;
7 import java.sql.SQLException;
8 import java.sql.Types;
9
10 public class C3P0Test1 {
11
12 public static void main(String[] args) throws SQLException {
13 C3P0Util1 c3p0Util1=new C3P0Util1();
14 Connection conn=c3p0Util1.getConnection();
15 //下面代碼是存儲過程的調用
16 String s="call SP_select_nofilter6(?,?,?) ";
17 CallableStatement cst=conn.prepareCall(s);
18 cst.setInt(2, 2);
19 cst.registerOutParameter(1, Types.VARCHAR);
20 cst.registerOutParameter(3, Types.BLOB);
21 ResultSet rs=cst.executeQuery();
22 String name=cst.getString(1);
23 Blob b=cst.getBlob(3);
24
25 System.out.println("name:"+name+" Blob:"+b);
26 //關閉資源
27 c3p0Util1.close(rs, cst, conn);
28 }
29 }
運行結果：
1 二月 14, 2017 8:06:03 下午 com.mchange.v2.log.MLog
2 信息: MLog clients using java 1.4+ standard logging.
3 二月 14, 2017 8:06:03 下午 com.mchange.v2.c3p0.C3P0Registry
4 信息: Initializing c3p0-0.9.5.2 [built 08-December-2015 22:06:04 -0800; debug? true; trace: 10]
5 二月 14, 2017 8:06:03 下午 com.mchange.v2.c3p0.impl.AbstractPoolBackedDataSource
6 信息: 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 ]
7 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操作速度 |