连接池实现代码

 

1、连接池模型

本文讨论的连接池包括一个连接池类(DBConnectionPool)和一个连接池管理类 (DBConnetionPoolManager)。

——连接池类是连接的“缓冲池”：

①从连接池获取或创建可用连接;

② 使用完毕之后，把连接返还给连接池;

③在系统关闭前，断开所有连接并释放连接占用的系统资源;

④还能够处理无效连接(原来登记为可用的连接，由于某种原因不再可用，如超时，通讯问题)，并能够限制连接池中的连接总数不低于某个预定值和不超过某个预定值。

 

 

连接池管理类是连接池类的外覆类(wrapper),符合单例模式，即系统中只能有一个连接池管理类的实例。其主要用于对多个连接池对象的管理：

①装载并注册特定数据库的JDBC驱动程序;

②根据属性文件给定的信息，创建连接池对象;

③为方便管理多个连接池对象，为每一个连接池 对象取一个名字，实现连接池名字与其实例之间的映射;

④跟踪客户使用连接情况，以便需要时关闭连接释放资源。

 

连接池管理类的引入主要是为了方便对多个连接池的使用和管理，如系统需要连接不同的数据库，或连接相同的数据库但由于安全性问题，需要不同的用户使用不同的名称和密码。

public class DBConnectionPool implements TimerListener{  

        private int checkedOut;//已被分配出去的连接数  

        private ArrayList freeConnections=new ArrayList();   //空闲池，根据创建时间顺序存放已创建但尚未分配出去的连接

 

        private int minConn;//连接池里连接的最小数量  

        private int maxConn;//连接池里允许存在的最大连接数  

 

        private String name;//为这个连接池取个名字，方便管理  

        private String password;//连接数据库时需要的密码  

        private String url;//所要创建连接的数据库的地址  

        private String user;//连接数据库时需要的用户名  

        public Timer timer;//定时器

 

【关键接口】

        public DBConnectionPool(String name,String URL,String user,   String password,int maxConn)//公开的构造函数  

 

        public synchronized void freeConnection(Connection con)  //使用完毕之后，把连接返还给空闲池  

        public synchronized Connection getConnection(long timeout)  //得到一个连接，timeout是等待时间  

        public synchronized void release() //断开所有连接，释放占用的系统资源  

        private Connection newConnection() //新建一个数据库连接  

        public synchronized void TimerEvent()  {//定时器事件处理函数  }  

 

 

public class DBConnectionManager {  

static private DBConnectionManager instance;  //连接池管理类的唯一实例  

static private int clients;//客户数量  

private ArrayList drivers=new ArrayList();  //容器，存放数据库驱动程序  

private HashMap pools = new HashMap();  //以name/value的形式存取连接池对象的名字及连接池对象  

static synchronized public DBConnectionManager getInstance()  /**如果instance已经创建，直接返回这个实例;否则，调用私有构造函数，创建连接池管理类的唯一实例*/  

private DBConnectionManager() //私有构造函数,在其中调用初始化函数init()  

public void freeConnection(String name,Connection con)  //释放一个连接，name是一个连接池对象的名字  

public Connection getConnection(String name)  //从名字为name的连接池对象中得到一个连接  

public Connection getConnection(String name,long time)  //从名字为name的连接池对象中取得一个连接，time是等待时间  

public synchronized void release()//释放所有资源  

private void createPools(Properties props)  //根据属性文件提供的信息，创建一个或多个连接池  

private void init()//初始化连接池管理类的唯一实例，由私有构造函数调用  

private void loadDrivers(Properties props)//装载数据库驱动程序 

}

---

 

1. package book.util;  
2. import java.sql.Connection;  
3. import java.sql.DatabaseMetaData;  
4. import java.sql.Date;  
5. import java.sql.Driver;  
6. import java.sql.DriverManager;  
7. import java.sql.PreparedStatement;  
8. import java.sql.ResultSet;  
9. import java.sql.SQLException;  
10. import java.sql.Statement;  
11. import java.util.Vector;  
13. public class Pool {  
14.     public static void main(String[] args) {  
15.         Pool pool = new Pool("com.microsoft.sqlserver.jdbc.SQLServerDriver","jdbc:sqlserver://localhost:1433;DataBaseName=Book","sa","aaaaaa");  
16.         try {  
17.             pool.createConnections(4);                
18.         } catch (SQLException e) {  
19.             e.printStackTrace();  
20.         }  
21.         Connection conn = pool.getConnection();   
22.         try {  
23.             String sql = "select * from allbook";  
24.             PreparedStatement ps;  
25.             ps = conn.prepareStatement(sql);  
26.             ResultSet rs=ps.executeQuery();  
27.             while(rs.next()){  
28.                 System.out.println(rs.getString("BOOKNAME"));  
29.             }  
30.         } catch (SQLException e) {  
31.             // TODO Auto-generated catch block  
32.             e.printStackTrace();  
33.         }finally{  
34.             pool.returnConnection(conn);  
35.         }  
36.         //long startTime=System.currentTimeMillis();
37.         //long endTime=System.currentTimeMillis();   
38.         //System.out.println("程序运行时间： "+(endTime-startTime)+"ms");   
39.     }  
40.       
41.     private String jdbcDriver = "";//数据库驱动  
42.     private String dbUrl = "";//数据库url  
43.     private String dbUsername = "";//数据库用户名  
44.     private String dbPassword = "";//数据库密码  
45.     private String testTable = "";  
46.     private int initialConnectionsNum = 10;//连接池初始连接数  
47.     private int maxConnectionsNum = 50;//连接池最大连接数  
48.     private int incrementalConnections = 5;//每次动态添加的连接数  
49.     private Vector<PooledConnection> connections = null;//向量，存放连接池中的连接，初始为空  
50.       
51.     /*无参构造函数*/  
52.     public Pool()  
53.     {}  
54.       
55.     /*带参数的构造函数 
56.      * 初始化数据库驱动、数据库url、数据库用户名、数据库密码、测试表 
57.      * */  
58.     public Pool(String driver, String url, String name, String pass)  
59.     {  
60.         this.jdbcDriver = driver;  
61.         this.dbUrl = url;  
62.         this.dbUsername = name;  
63.         this.dbPassword = pass;  
64.         //this.testTable = table;  
65.         try {  
66.             this.createPool();  
67.         } catch (InstantiationException e) {  
68.             // TODO Auto-generated catch block  
69.             e.printStackTrace();  
70.         } catch (IllegalAccessException e) {  
71.             // TODO Auto-generated catch block  
72.             e.printStackTrace();  
73.         } catch (ClassNotFoundException e) {  
74.             // TODO Auto-generated catch block  
75.             e.printStackTrace();  
76.         } catch (SQLException e) {  
77.             // TODO Auto-generated catch block  
78.             e.printStackTrace();  
79.         }  
80.     }  
81.       
82.     /*函数，创建连接池*/  
83.     public synchronized void createPool()   
84.     throws InstantiationException, IllegalAccessException,   
85.     ClassNotFoundException, SQLException  
86.     {  
87.         /*确保连接池为创建，如果已经创建，则保存连接的向量不为空 
88.          * */  
89.         if (this.connections != null)  
90.         {  
91.             return ;  
92.         }  
93.         //驱动器实例化  
94.         Driver driver = (Driver)(Class.forName(this.jdbcDriver).newInstance());  
95.         //注册驱动器  
96.         DriverManager.registerDriver(driver);
97.         //创建保存连接的向量  
98.         this.connections = new Vector<PooledConnection>();  
99.         //创建数据库连接  
100.         this.createConnections(this.initialConnectionsNum);  
101.     }  
102.       
103.     /*函数，创建数据库连接 
104.      * */  
105.     private void createConnections (int num) throws SQLException  
106.     {  
107.         /*循环创建连接 
108.          * 需要首先检查当前连接数是否已经超出连接池最大连接数 
109.          * */  
110.         for (int i = 0; i < num; ++i)  
111.         {  
112.             //检查  
113.             if (this.connections.size() >= this.maxConnectionsNum)  
114.             {  
115.                 return;  
116.             }  
117.             //创建单个连接  
118.             this.connections.addElement  
119.             (new PooledConnection(newConnection()));  
120.         }  
121.           
122.     }  
123.       
124.     /*函数,创建一个数据库连接*/  
125.     private Connection newConnection() throws SQLException  
126.     {  
127.         /*创建连接*/  
128.         Connection con = DriverManager.getConnection(this.dbUrl,   
129.                 this.dbUsername, this.dbPassword);  
130.         /*如果是第一次创建连接，则检查所连接的数据库的允许最大连接数是否小于 
131.          * 我们所设定的最大连接数*/  
132.         if (this.connections.size() == 0)  
133.         {  
134.             DatabaseMetaData metadata = con.getMetaData();  
135.             //得到数据库最大连接数  
136.             int dbMaxConnectionsNum = metadata.getMaxConnections();  
137.             //如果数据库最大连接数更小，则更改我们所设定的连接池最大连接数  
138.             if (dbMaxConnectionsNum > 0   
139.                     && this.maxConnectionsNum > dbMaxConnectionsNum)  
140.             {  
141.                 this.maxConnectionsNum = dbMaxConnectionsNum;  
142.             }  
143.         }  
144.         return con;  
145.     }  
146.       
147.     /*函数，得到一个可用连接 
148.      * */  
149.     public synchronized Connection getConnection ()   
150.     {  
151.         Connection con = null;  
152.         /*检查连接池是否已经建立*/  
153.         if (this.connections == null)  
154.         {  
155.             return con;  
156.         }  
157.         //得到一个可用连接  
158.         try {  
159.             con = this.getFreeConnection();  
160.         } catch (SQLException e) {  
161.             // TODO Auto-generated catch block  
162.             e.printStackTrace();  
163.         }  
164.         //如果未找到合适连接，循环等待、查找，直到找到合适连接  
165.         while(con == null)  
166.         {  
167.             this.wait(30);  
168.             try {  
169.                 con = this.getFreeConnection();  
170.             } catch (SQLException e) {  
171.                 // TODO Auto-generated catch block  
172.                 e.printStackTrace();  
173.             }  
174.         }  
175.           
176.         return con;  
177.     }  
178.       
179.       
180.     /*函数，得到一个可用连接*/  
181.     private Connection getFreeConnection() throws SQLException  
182.     {  
183.         Connection con = null;  
184.         //查找一个可用连接  
185.         con = this.findFreeConnection();  
186.         //如果未找到可用连接，就建立一些新的连接，再次查找  
187.         if (con == null)  
188.         {  
189.             this.createConnections(this.incrementalConnections);  
190.             //再次查找  
191.             con = this.findFreeConnection();  
192.         }  
193.         return con;  
194.     }  
195.       
196.       
197.     /*函数，从现有连接中查找一个可用连接 
198.      * 在现有的连接中（向量connections中）找到一个空闲连接， 
199.      * 并测试这个链接是否可用，若不可用则重新建立连接，替换原来的连接*/  
200.     private Connection findFreeConnection () throws SQLException  
201.     {  
202.         Connection con = null;  
203.         for (int i = 0; i < this.connections.size(); ++i)  
204.         {  
205.             PooledConnection pol = (PooledConnection)this.connections.get(i);  
206.             if (!pol.isBusy())  
207.             {  
208.                 /*如果此链接未被使用，则返回这个连接并，设置正在使用标志*/  
209.                 con = pol.getCon();  
210.                 pol.setBusy(true);  
211.                 /*测试连接是否可用*/  
212.                 if (!this.testCon(con))  
213.                 {  
214.                     con = this.newConnection();  
215.                     pol.setCon(con);  
216.                 }  
217.                 break;  
218.             }  
219.         }  
220.         return con;  
221.     }  
222.       
223.     /*函数，测试连接是否可用 
224.      * */  
225.     private boolean testCon (Connection con)  
226.     {  
227.         boolean useable = true;  
228.         try  
229.         {  
230.             Statement st = con.createStatement();  
231.             ResultSet rs = st.executeQuery("select count(*) from " + this.testTable);  
232.             rs.next();  
233.         }  
234.         catch(SQLException e)  
235.         {  
236.             /*上面抛出异常，连接不可用，关闭*/  
237.             useable = false;  
238.             this.closeConnection(con);  
239.         }  
240.         return useable;  
241.     }  
242.       
243.     /*函数，将使用完毕的连接放回连接池中 
244.      * */  
245.     public void returnConnection(Connection con)  
246.     {  
247.         /*确保连接池存在*/  
248.         if (this.connections == null)  
249.         {  
250.             return ;  
251.         }  
252.         for (int i = 0; i < this.connections.size(); ++i)  
253.         {  
254.             PooledConnection pool = this.connections.get(i);  
255.             //找到相应连接，设置正在使用标志为false  
256.             if (con == pool.getCon())  
257.             {  
258.                 pool.setBusy(false);  
259.             }  
260.         }  
261.           
262.     }  
263.       
264.     /*函数，刷新连接池中的连接*/  
265.     public synchronized void refreshConneciontPool () throws SQLException  
266.     {  
267.         /*确保连接池存在*/  
268.         if (this.connections == null)  
269.         {  
270.             return ;  
271.         }  
272.         for (int i = 0; i < this.connections.size(); ++i)  
273.         {  
274.             PooledConnection pool = this.connections.get(i);  
275.             if (pool.isBusy())  
276.             {  
277.                 this.wait(5000);  
278.             }  
279.             this.closeConnection(pool.getCon());  
280.             pool.setCon(this.newConnection());  
281.             pool.setBusy(false);  
282.         }  
283.     }  
284.   
285.     /*函数，关闭连接池*/  
286.     public void closeConnectionPool()  
287.     {  
288.         /*确保连接池存在*/  
289.         if (this.connections == null)  
290.         {  
291.             return ;  
292.         }  
293.         for (int i = 0; i < this.connections.size(); ++i)  
294.         {  
295.             PooledConnection pool = this.connections.get(i);  
296.             if (pool.isBusy())  
297.             {  
298.                 this.wait(5000);  
299.             }  
300.             this.closeConnection(pool.getCon());  
301.             this.connections.remove(i);  
302.         }  
303.         this.connections = null;  
304.     }  
305.       
306.     /*函数，暂时无可用连接，进入等待队列等待m秒，再试 
307.      * */  
308.     private void wait(int mSecond)  
309.     {  
310.         try {  
311.             Thread.sleep(mSecond);  
312.         } catch (InterruptedException e) {  
313.             // TODO Auto-generated catch block  
314.             e.printStackTrace();  
315.         }  
316.     }  
317.       
318.     /** 
319.      * @return the jdbcDriver 
320.      */  
321.     public String getJdbcDriver() {  
322.         return jdbcDriver;  
323.     }  
324.   
325.     /** 
326.      * @param jdbcDriver the jdbcDriver to set 
327.      */  
328.     public void setJdbcDriver(String jdbcDriver) {  
329.         this.jdbcDriver = jdbcDriver;  
330.     }  
331.   
332.     /** 
333.      * @return the dbUrl 
334.      */  
335.     public String getDbUrl() {  
336.         return dbUrl;  
337.     }  
338.   
339.     /** 
340.      * @param dbUrl the dbUrl to set 
341.      */  
342.     public void setDbUrl(String dbUrl) {  
343.         this.dbUrl = dbUrl;  
344.     }  
345.   
346.     /** 
347.      * @return the dbUsername 
348.      */  
349.     public String getDbUsername() {  
350.         return dbUsername;  
351.     }  
352.   
353.     /** 
354.      * @param dbUsername the dbUsername to set 
355.      */  
356.     public void setDbUsername(String dbUsername) {  
357.         this.dbUsername = dbUsername;  
358.     }  
359.   
360.     /** 
361.      * @return the dbPassword 
362.      */  
363.     public String getDbPassword() {  
364.         return dbPassword;  
365.     }  
366.   
367.     /** 
368.      * @param dbPassword the dbPassword to set 
369.      */  
370.     public void setDbPassword(String dbPassword) {  
371.         this.dbPassword = dbPassword;  
372.     }  
373.   
374.     /** 
375.      * @return the testTable 
376.      */  
377.     public String getTestTable() {  
378.         return testTable;  
379.     }  
380.   
381.     /** 
382.      * @param testTable the testTable to set 
383.      */  
384.     public void setTestTable(String testTable) {  
385.         this.testTable = testTable;  
386.     }  
387.   
388.     /** 
389.      * @return the initialConnectionsNum 
390.      */  
391.     public int getInitialConnectionsNum() {  
392.         return initialConnectionsNum;  
393.     }  
394.   
395.     /** 
396.      * @param initialConnectionsNum the initialConnectionsNum to set 
397.      */  
398.     public void setInitialConnectionsNum(int initialConnectionsNum) {  
399.         this.initialConnectionsNum = initialConnectionsNum;  
400.     }  
401.   
402.     /** 
403.      * @return the maxConnectionsNum 
404.      */  
405.     public int getMaxConnectionsNum() {  
406.         return maxConnectionsNum;  
407.     }  
408.   
409.     /** 
410.      * @param maxConnectionsNum the maxConnectionsNum to set 
411.      */  
412.     public void setMaxConnectionsNum(int maxConnectionsNum) {  
413.         this.maxConnectionsNum = maxConnectionsNum;  
414.     }  
415.   
416.     /** 
417.      * @return the incrementalConnections 
418.      */  
419.     public int getIncrementalConnections() {  
420.         return incrementalConnections;  
421.     }  
422.   
423.     /** 
424.      * @param incrementalConnections the incrementalConnections to set 
425.      */  
426.     public void setIncrementalConnections(int incrementalConnections) {  
427.         this.incrementalConnections = incrementalConnections;  
428.     }  
429.   
430.     /** 
431.      * @return the connections 
432.      */  
433.     public Vector<PooledConnection> getConnections() {  
434.         return connections;  
435.     }  
436.   
437.     /** 
438.      * @param connections the connections to set 
439.      */  
440.     public void setConnections(Vector<PooledConnection> connections) {  
441.         this.connections = connections;  
442.     }  
443.   
444.     /*函数，连接使用完毕，关闭连接*/  
445.     private void closeConnection (Connection con)  
446.     {  
447.         try  
448.         {  
449.             con.close();  
450.         }  
451.         catch(SQLException e)  
452.         {  
453.             e.printStackTrace();  
454.         }  
455.     }  
456.       
457.       
458.     /*内部使用的保存数据库连接的类 
459.      * 两个成员变量：连接、是否正在使用*/  
460.     class PooledConnection  
461.     {  
462.         private Connection con = null;//连接  
463.         private boolean busy = false;//是否正在使用，默认为非  
464.           
465.         /*构造函数*/  
466.         public PooledConnection(Connection con)  
467.         {  
468.             this.con = con;  
469.         }  
470.   
471.         /** 
472.          * @return the con 
473.          */  
474.         public Connection getCon() {  
475.             return con;  
476.         }  
477.   
478.         /** 
479.          * @param con the con to set 
480.          */  
481.         public void setCon(Connection con) {  
482.             this.con = con;  
483.         }  
484.   
485.         /** 
486.          * @return the busy 
487.          */  
488.         public boolean isBusy() {  
489.             return busy;  
490.         }  
491.   
492.         /** 
493.          * @param busy the busy to set 
494.          */  
495.         public void setBusy(boolean busy) {  
496.             this.busy = busy;  
497.         }  
498.     }  
499.   
500. }