C3P0数据源使用

Java代码

1. package   C3P0;   
2. import   java.sql.Connection;   
3. import   java.sql.SQLException;   
4. import   java.beans.PropertyVetoException;   
5. import   com.mchange.v2.c3p0.ComboPooledDataSource;   
6. public   class   DBPool{         
7.     private   static   DBPool   dbPool;         
8.     private   ComboPooledDataSource   dataSource;       
9.   
10.     static   {         
11.             dbPool=new   DBPool();         
12.     }         
13.       
14.     public   DBPool(){         
15.             try   {         
16.                     dataSource=new   ComboPooledDataSource();         
17.                     dataSource.setUser( "id ");         
18.                     dataSource.setPassword( "pw ");         
19.                     dataSource.setJdbcUrl( "jdbc:mysql://127.0.0.1:3306/test?   
20.   
21. autoReconnect=true&useUnicode=true&characterEncoding=GB2312 ");   
22.                     dataSource.setDriverClass( "com.mysql.jdbc.Driver ");   
23.                     dataSource.setInitialPoolSize(2);   
24.                     dataSource.setMinPoolSize(1);   
25.                     dataSource.setMaxPoolSize(10);   
26.                     dataSource.setMaxStatements(50);   
27.                     dataSource.setMaxIdleTime(60);         
28.             }   catch   (PropertyVetoException   e)   {         
29.                 throw   new   RuntimeException(e);         
30.             }         
31.     }         
32.   
33.     public   final   static   DBPool   getInstance(){         
34.             return   dbPool;         
35.     }         
36.   
37.     public   final   Connection   getConnection()   {         
38.             try   {         
39.                     return   dataSource.getConnection();         
40.             }   catch   (SQLException   e)   {         
41.                     throw   new   RuntimeException( "无法从数据源获取连接 ",e);         
42.             }         
43.     }       
44.       
45.     public   static   void   main(String[]   args)   throws   SQLException   {   
46. Connection   con   =   null;   
47. try   {   
48. con   =   DBPool.getInstance().getConnection();   
49. }   catch   (Exception   e){   
50. }   finally   {   
51. if   (con   !=   null)   
52. con.close();   
53. }   
54. }   
55. }  

 

引用 8 楼 xyflash 的回复:
每用一次都要
Connection conn = DBPool.getInstance.getConnection();
一次。。感觉没起到连接池的作用啊

楼主，使用连接池的时候并不是在代码中不用获取/释放数据库连接，而是在代码中向连接池申请/释放连接，对于代码而言，可以把连接池看成数据库。

换句话说，连接池就是数据库的代理，之所以要使用这个代理是因为直接向数据库申请/释放连接是要降低性能的：如果每一次数据访问请求都必须经历建立数据库连接、打开数据库、存取数据和关闭数据库连接等步骤，而连接并打开数据库是一件既消耗资源又费时的工作，那么频繁发生这种数据库操作时，系统的性能必然会急剧下降。

连接池的作用是自己维护数据库连接，数据库连接池的主要操作如下：
　　（1）建立数据库连接池对象（服务器启动）。
　　（2）按照事先指定的参数创建初始数量的数据库连接（即：空闲连接数）。
　　（3）对于一个数据库访问请求，直接从连接池中得到一个连接。如果数据库连接池对象中没有空闲的连接，且连接数没有达到最大（即：最大活跃连接数），创建一个新的数据库连接。
　　（4）存取数据库。
　　（5）关闭数据库，释放所有数据库连接（此时的关闭数据库连接，并非真正关闭，而是将其放入空闲队列中。如实际空闲连接数大于初始空闲连接数则释放连接）。
　　（6）释放数据库连接池对象（服务器停止、维护期间，释放数据库连接池对象，并释放所有连接）。

 

 

 

 

 

 

 

我刚刚写了一个很简单的C3P0使用示例，分别测试了使用连接池和不使用连接池时的性能差异。

Java代码

1. package com.lnbdqn;  
2.   
3. import java.beans.PropertyVetoException;  
4. import java.sql.Connection;  
5. import java.sql.SQLException;  
6. import com.mchange.v2.c3p0.ComboPooledDataSource;  
7.   
8. public final class ConnectionManager {  
9.   
10.     private static ConnectionManager instance;  
11.     private static ComboPooledDataSource dataSource;  
12.   
13.     private ConnectionManager() throws SQLException, PropertyVetoException {  
14.         dataSource = new ComboPooledDataSource();  
15.   
16.         dataSource.setUser("loux");  
17.         dataSource.setPassword("loux");  
18.         dataSource.setJdbcUrl("jdbc:oracle:thin:@192.168.100.70:1521:orcl");  
19.         dataSource.setDriverClass("oracle.jdbc.driver.OracleDriver");  
20.         dataSource.setInitialPoolSize(5);  
21.         dataSource.setMinPoolSize(1);  
22.         dataSource.setMaxPoolSize(10);  
23.         dataSource.setMaxStatements(50);  
24.         dataSource.setMaxIdleTime(60);  
25.     }  
26.   
27.     public static final ConnectionManager getInstance() {  
28.         if (instance == null) {  
29.             try {  
30.                 instance = new ConnectionManager();  
31.             } catch (Exception e) {  
32.                 e.printStackTrace();  
33.             }  
34.         }  
35.         return instance;  
36.     }  
37.   
38.     public synchronized final Connection getConnection() {  
39.         Connection conn = null;  
40.         try {  
41.             conn = dataSource.getConnection();  
42.         } catch (SQLException e) {  
43.             e.printStackTrace();  
44.         }  
45.         return conn;  
46.     }  
47. }  

 

Java代码

1. package com.lnbdqn;  
2.   
3. import java.sql.Connection;  
4. import java.sql.PreparedStatement;  
5. import java.sql.ResultSet;  
6. import java.sql.SQLException;  
7.   
8. import oracle.jdbc.pool.OracleDataSource;  
9.   
10. public class ConnectionDemo {  
11.   
12.     public static void main(String[] args) throws SQLException {  
13.         System.out.println("使用连接池................................");  
14.         for (int i = 0; i < 20; i++) {  
15.             long beginTime = System.currentTimeMillis();  
16.             Connection conn = ConnectionManager.getInstance().getConnection();  
17.             try {  
18.                 PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM t_fmscpy200");  
19.                 ResultSet rs = pstmt.executeQuery();  
20.                 while (rs.next()) {  
21.                 }  
22.             } catch (SQLException e) {  
23.                 e.printStackTrace();  
24.             } finally {  
25.                 try {  
26.                     conn.close();  
27.                 } catch (SQLException e) {  
28.                     e.printStackTrace();  
29.                 }  
30.             }  
31.   
32.             long endTime = System.currentTimeMillis();  
33.             System.out.println("第" + (i + 1) + "次执行花费时间为:" + (endTime - beginTime));  
34.         }  
35.   
36.         System.out.println("不使用连接池................................");  
37.         for (int i = 0; i < 20; i++) {  
38.             long beginTime = System.currentTimeMillis();  
39.             OracleDataSource ods = new OracleDataSource();  
40.             ods.setUser("loux");  
41.             ods.setPassword("loux");  
42.             ods.setURL("jdbc:oracle:thin:@192.168.100.70:1521:orcl");  
43.             Connection conn = ods.getConnection();  
44.             try {  
45.                 PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM table_name");  
46.                 ResultSet rs = pstmt.executeQuery();  
47.                 while (rs.next()) {  
48.                                     // do nothing...  
49.                 }  
50.             } catch (SQLException e) {  
51.                 e.printStackTrace();  
52.             } finally {  
53.                 try {  
54.                     conn.close();  
55.                 } catch (SQLException e) {  
56.                     e.printStackTrace();  
57.                 }  
58.             }  
59.             long endTime = System.currentTimeMillis();  
60.             System.out.println("第" + (i + 1) + "次执行花费时间为:"  
61.                                 + (endTime - beginTime));  
62.         }  
63.   
64.     }  
65. }  

 

控制台输出的结果为：

使用连接池................................
第1次执行花费时间为:1469
第2次执行花费时间为:0
第3次执行花费时间为:16
第4次执行花费时间为:0
第5次执行花费时间为:0
第6次执行花费时间为:15
第7次执行花费时间为:0
第8次执行花费时间为:0
第9次执行花费时间为:0
第10次执行花费时间为:0
第11次执行花费时间为:16
第12次执行花费时间为:0
第13次执行花费时间为:0
第14次执行花费时间为:0
第15次执行花费时间为:0
第16次执行花费时间为:16
第17次执行花费时间为:0
第18次执行花费时间为:0
第19次执行花费时间为:15
第20次执行花费时间为:0
不使用连接池................................
第1次执行花费时间为:47
第2次执行花费时间为:31
第3次执行花费时间为:32
第4次执行花费时间为:46
第5次执行花费时间为:32
第6次执行花费时间为:31
第7次执行花费时间为:47
第8次执行花费时间为:31
第9次执行花费时间为:47
第10次执行花费时间为:31
第11次执行花费时间为:47
第12次执行花费时间为:31
第13次执行花费时间为:32
第14次执行花费时间为:46
第15次执行花费时间为:47
第16次执行花费时间为:32
第17次执行花费时间为:46
第18次执行花费时间为:47
第19次执行花费时间为:32
第20次执行花费时间为:31

可以看出，在使用连接池时，第一次执行花费的时间稍长，因为第一次初始化操作需要创建多个连接并放入池中，以后使用时将会大大缩短执行时间。
在不使用连接池时，每次花费的时间都比较长。