java程序员从笨鸟到菜鸟之（七）一—java数据库操作

本文来自：曹胜欢博客专栏。转载请注明出处： http://blog.csdn.net/csh624366188

数据库访问几乎每一个稍微成型的程序都要用到的知识，怎么高效的访问数据库也是我们学习的一个重点，今天的任务就是总结java访问数据库的方法和有关API，java访问数据库主要用的方法是JDBC,它是java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法，下面我们就具体来总结一下JDBC

一：Java访问数据库的具体步骤：

1 加载（注册）数据库

　驱动加载就是把各个数据库提供的访问数据库的API加载到我们程序进来，加载JDBC驱动，并将其注册到DriverManager中，每一种数据库提供的数据库驱动不一样，加载驱动时要把jar包添加到lib文件夹下，下面看一下一些主流数据库的JDBC驱动加裁注册的代码:

//Oracle8/8i/9iO数据库(thin模式)

Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();

//Sql Server7.0/2000数据库 Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

//Sql Server2005/2008数据库 Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

//DB2数据库

Class.froName("com.ibm.db2.jdbc.app.DB2Driver").newInstance();

//MySQL数据库 Class.forName("com.mysql.jdbc.Driver").newInstance();

2 建立链接 　　

建立数据库之间的连接是访问数据库的必要条件，就像南水北调调水一样，要想调水首先由把沟通的河流打通。建立连接对于不同数据库也是不一样的，下面看一下一些主流数据库建立数据库连接，取得Connection对象的不同方式：

//Oracle8/8i/9i数据库(thin模式)

String url="jdbc:oracle:thin:@localhost:1521:orcl";

String user="scott";

String password="tiger";

Connection conn=DriverManager.getConnection(url,user,password);

//Sql Server7.0/2000/2005/2008数据库

String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=pubs";

String user="sa";

String password="";

Connection conn=DriverManager.getConnection(url,user,password);

//DB2数据库

String url="jdbc:db2://localhost:5000/sample";

String user="amdin"

String password=-"";

Connection conn=DriverManager.getConnection(url,user,password);

//MySQL数据库

String url="jdbc:mysql://localhost:3306/testDB?user=root&password=root&useUnicode=true&characterEncoding=gb2312";

Connection conn=DriverManager.getConnection(url);

3. 执行SQL语句 　

数据库连接建立好之后，接下来就是一些准备工作和执行sql语句了，准备工作要做的就是建立Statement对象PreparedStatement对象，例如：

//建立Statement对象

Statement stmt=conn.createStatement();

//建立PreparedStatement对象

String sql="select * from user where userName=? and password=?";

PreparedStatement pstmt=Conn.prepareStatement(sql);

pstmt.setString(1,"admin");

pstmt.setString(2,"liubin");

做好准备工作之后就可以执行sql语句了，执行sql语句：

String sql="select * from users";

ResultSet rs=stmt.executeQuery(sql);

//执行动态SQL查询

ResultSet rs=pstmt.executeQuery();

//执行insert update delete等语句，先定义sql

stmt.executeUpdate(sql);

4 处理结果集 　

　访问结果记录集ResultSet对象。例如：

while(rs.next)

{

out.println("你的第一个字段内容为："+rs.getString("Name"));

out.println("你的第二个字段内容为："+rs.getString(2));

}

5 关闭数据库

依次将ResultSet、Statement、PreparedStatement、Connection对象关 闭，释放所占用的资源.例如:

rs.close();

stmt.clost();

pstmt.close();

con.close();

二：JDBC事务

什么是事务:

首先,说说什么事务。我认为事务，就是一组操作数据库的动作集合。

事务是现代数据库理论中的核心概念之一。如果一组处理步骤或者全部发生或者一步也不执行，我们称该组处理步骤为一个事务。当所有的步骤像一个操 作一样被完整地执行，我们称该事务被提交。由于其中的一部分或多步执行失败，导致没有步骤被提交，则事务必须回滚到最初的系统状态。

事务必须服从ISO/IEC所制定的ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性 （isolation）和持久性（durability）的缩写。事务的原子性表示事务执行过程中的任何失败都将导致事务所做的任何修改失效。一致性表示 当事务执行失败时，所有被该事务影响的数据都应该恢复到事务执行前的状态。隔离性表示在事务执行过程中对数据的修改，在事务提交之前对其他事务不可见。持 久性表示当系统或介质发生故障时，确保已提交事务的更新不能丢失。持久性通过数据库备份和恢复来保证。

JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口( java.sql.Connection )提供了两种事务模式：自动提交和手工提交。 java.sql.Connection 提供了以下控制事务的方法：
public void setAutoCommit(boolean)
public boolean getAutoCommit()
public void commit()
public void rollback()
使用 JDBC 事务界定时，您可以将多个 SQL 语句结合到一个事务中。JDBC 事务的一个缺点是事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库。

三：java操作数据库连接池

在总结java操作数据库连接池发现一篇很好的文章，所以就不做具体总结了，直接上地址：

http://www.blogjava.net/chunkyo/archive/2007/01/16/94266.html

最后附一段比较经典的代码吧：

[java] view plain copy print ?

1. import java.sql.Connection;
2. import java.sql.DatabaseMetaData;
3. import java.sql.Driver;
4. import java.sql.DriverManager;
5. import java.sql.SQLException;
6. import java.sql.Statement;
7. import java.util.Enumeration;
8. import java.util.Vector;
9. public class ConnectionPool {
10. private String jdbcDriver = ""; // 数据库驱动
11. private String dbUrl = ""; // 数据 URL
12. private String dbUsername = ""; // 数据库用户名
13. private String dbPassword = ""; // 数据库用户密码
14. private String testTable = ""; // 测试连接是否可用的测试表名，默认没有测试表
15. private int initialConnections = 10; // 连接池的初始大小
16. private int incrementalConnections = 5;// 连接池自动增加的大小
17. private int maxConnections = 50; // 连接池最大的大小
18. private Vector connections = null; // 存放连接池中数据库连接的向量 , 初始时为 null
20. // 它中存放的对象为 PooledConnection 型
22. /**
23. * 构造函数
24. *
25. * @param jdbcDriver String JDBC 驱动类串
26. * @param dbUrl String 数据库 URL
27. * @param dbUsername String 连接数据库用户名
28. * @param dbPassword String 连接数据库用户的密码
29. *
30. */
32. public ConnectionPool(String jdbcDriver,String dbUrl,String dbUsername,String dbPassword) {
33. this.jdbcDriver = jdbcDriver;
34. this.dbUrl = dbUrl;
35. this.dbUsername = dbUsername;
36. this.dbPassword = dbPassword;
37. }
39. /**
41. * 返回连接池的初始大小
42. *
43. * @return 初始连接池中可获得的连接数量
44. */
45. public int getInitialConnections() {
47. return this.initialConnections;
48. }
50. /**
52. * 设置连接池的初始大小
54. *
56. * @param 用于设置初始连接池中连接的数量
58. */
60. public void setInitialConnections(int initialConnections) {
61. this.initialConnections = initialConnections;
62. }
64. /**
66. * 返回连接池自动增加的大小 、
67. *
68. * @return 连接池自动增加的大小
69. */
70. public int getIncrementalConnections() {
72. return this.incrementalConnections;
74. }
76. /**
77. * 设置连接池自动增加的大小
78. * @param 连接池自动增加的大小
79. */
81. public void setIncrementalConnections(int incrementalConnections) {
83. this.incrementalConnections = incrementalConnections;
85. }
87. /**
88. * 返回连接池中最大的可用连接数量
89. * @return 连接池中最大的可用连接数量
90. */
92. public int getMaxConnections() {
93. return this.maxConnections;
94. }
96. /**
98. * 设置连接池中最大可用的连接数量
100. *
102. * @param 设置连接池中最大可用的连接数量值
104. */
106. public void setMaxConnections(int maxConnections) {
108. this.maxConnections = maxConnections;
110. }
112. /**
114. * 获取测试数据库表的名字
115. *
116. * @return 测试数据库表的名字
117. */
118. public String getTestTable() {
120. return this.testTable;
122. }
124. /**
125. * 设置测试表的名字
126. * @param testTable String 测试表的名字
127. */
128. public void setTestTable(String testTable) {
129. this.testTable = testTable;
130. }
132. /**
134. *
135. * 创建一个数据库连接池，连接池中的可用连接的数量采用类成员
136. * initialConnections 中设置的值
137. */
138. public synchronized void createPool() throws Exception {
140. // 确保连接池没有创建
142. // 如果连接池己经创建了，保存连接的向量 connections 不会为空
144. if (connections != null) {
146. return; // 如果己经创建，则返回
148. }
150. // 实例化 JDBC Driver 中指定的驱动类实例
152. Driver driver = (Driver) (Class.forName(this.jdbcDriver).newInstance());
154. DriverManager.registerDriver(driver); // 注册 JDBC 驱动程序
156. // 创建保存连接的向量 , 初始时有 0 个元素
158. connections = new Vector();
160. // 根据 initialConnections 中设置的值，创建连接。
162. createConnections(this.initialConnections);
164. System.out.println(" 数据库连接池创建成功！ ");
166. }
168. /**
170. * 创建由 numConnections 指定数目的数据库连接 , 并把这些连接
172. * 放入 connections 向量中
173. *
174. * @param numConnections 要创建的数据库连接的数目
175. */
176. @SuppressWarnings("unchecked")
177. private void createConnections(int numConnections) throws SQLException {
179. // 循环创建指定数目的数据库连接
181. for (int x = 0; x < numConnections; x++) {
183. // 是否连接池中的数据库连接的数量己经达到最大？最大值由类成员 maxConnections
185. // 指出，如果 maxConnections 为 0 或负数，表示连接数量没有限制。
187. // 如果连接数己经达到最大，即退出。
189. if (this.maxConnections > 0 && this.connections.size() >= this.maxConnections) {
191. break;
193. }
195. //add a new PooledConnection object to connections vector
197. // 增加一个连接到连接池中（向量 connections 中）
199. try{
201. connections.addElement(new PooledConnection(newConnection()));
203. }catch(SQLException e){
205. System.out.println(" 创建数据库连接失败！ "+e.getMessage());
207. throw new SQLException();
209. }
211. System.out.println(" 数据库连接己创建 ......");
213. }
214. }
216. /**
218. * 创建一个新的数据库连接并返回它
219. *
220. * @return 返回一个新创建的数据库连接
221. */
222. private Connection newConnection() throws SQLException {
224. // 创建一个数据库连接
226. Connection conn = DriverManager.getConnection(dbUrl, dbUsername, dbPassword);
228. // 如果这是第一次创建数据库连接，即检查数据库，获得此数据库允许支持的
230. // 最大客户连接数目
232. //connections.size()==0 表示目前没有连接己被创建
234. if (connections.size() == 0) {
236. DatabaseMetaData metaData = conn.getMetaData();
238. int driverMaxConnections = metaData.getMaxConnections();
240. // 数据库返回的 driverMaxConnections 若为 0 ，表示此数据库没有最大
242. // 连接限制，或数据库的最大连接限制不知道
244. //driverMaxConnections 为返回的一个整数，表示此数据库允许客户连接的数目
246. // 如果连接池中设置的最大连接数量大于数据库允许的连接数目 , 则置连接池的最大
248. // 连接数目为数据库允许的最大数目
250. if (driverMaxConnections > 0 && this.maxConnections > driverMaxConnections) {
252. this.maxConnections = driverMaxConnections;
254. }
255. }
256. return conn; // 返回创建的新的数据库连接
258. }
260. /**
262. * 通过调用 getFreeConnection() 函数返回一个可用的数据库连接 ,
264. * 如果当前没有可用的数据库连接，并且更多的数据库连接不能创
266. * 建（如连接池大小的限制），此函数等待一会再尝试获取。
268. *
270. * @return 返回一个可用的数据库连接对象
272. */
274. public synchronized Connection getConnection() throws SQLException {
276. // 确保连接池己被创建
278. if (connections == null) {
280. return null; // 连接池还没创建，则返回 null
282. }
284. Connection conn = getFreeConnection(); // 获得一个可用的数据库连接
286. // 如果目前没有可以使用的连接，即所有的连接都在使用中
288. while (conn == null){
290. // 等一会再试
292. wait(250);
294. conn = getFreeConnection(); // 重新再试，直到获得可用的连接，如果
296. //getFreeConnection() 返回的为 null
298. // 则表明创建一批连接后也不可获得可用连接
300. }
302. return conn;// 返回获得的可用的连接
303. }
305. /**
307. * 本函数从连接池向量 connections 中返回一个可用的的数据库连接，如果
309. * 当前没有可用的数据库连接，本函数则根据 incrementalConnections 设置
311. * 的值创建几个数据库连接，并放入连接池中。
313. * 如果创建后，所有的连接仍都在使用中，则返回 null
315. * @return 返回一个可用的数据库连接
317. */
319. private Connection getFreeConnection() throws SQLException {
321. // 从连接池中获得一个可用的数据库连接
323. Connection conn = findFreeConnection();
325. if (conn == null) {
327. // 如果目前连接池中没有可用的连接
329. // 创建一些连接
331. createConnections(incrementalConnections);
333. // 重新从池中查找是否有可用连接
335. conn = findFreeConnection();
337. if (conn == null) {
339. // 如果创建连接后仍获得不到可用的连接，则返回 null
341. return null;
343. }
345. }
347. return conn;
349. }
351. /**
353. * 查找连接池中所有的连接，查找一个可用的数据库连接，
355. * 如果没有可用的连接，返回 null
357. *
359. * @return 返回一个可用的数据库连接
361. */
363. private Connection findFreeConnection() throws SQLException {
365. Connection conn = null;
367. PooledConnection pConn = null;
369. // 获得连接池向量中所有的对象
371. Enumeration enumerate = connections.elements();
373. // 遍历所有的对象，看是否有可用的连接
375. while (enumerate.hasMoreElements()) {
377. pConn = (PooledConnection) enumerate.nextElement();
379. if (!pConn.isBusy()) {
381. // 如果此对象不忙，则获得它的数据库连接并把它设为忙
383. conn = pConn.getConnection();
385. pConn.setBusy(true);
387. // 测试此连接是否可用
389. if (!testConnection(conn)) {
391. // 如果此连接不可再用了，则创建一个新的连接，
393. // 并替换此不可用的连接对象，如果创建失败，返回 null
395. try{
397. conn = newConnection();
399. }catch(SQLException e){
401. System.out.println(" 创建数据库连接失败！ "+e.getMessage());
403. return null;
405. }
407. pConn.setConnection(conn);
409. }
411. break; // 己经找到一个可用的连接，退出
413. }
415. }
417. return conn;// 返回找到到的可用连接
419. }
421. /**
423. * 测试一个连接是否可用，如果不可用，关掉它并返回 false
425. * 否则可用返回 true
427. *
429. * @param conn 需要测试的数据库连接
431. * @return 返回 true 表示此连接可用， false 表示不可用
433. */
435. private boolean testConnection(Connection conn) {
437. try {
439. // 判断测试表是否存在
441. if (testTable.equals("")) {
443. // 如果测试表为空，试着使用此连接的 setAutoCommit() 方法
445. // 来判断连接否可用（此方法只在部分数据库可用，如果不可用 ,
447. // 抛出异常）。注意：使用测试表的方法更可靠
449. conn.setAutoCommit(true);
451. } else {// 有测试表的时候使用测试表测试
453. //check if this connection is valid
455. Statement stmt = conn.createStatement();
457. stmt.execute("select count(*) from " + testTable);
459. }
461. } catch (SQLException e) {
463. // 上面抛出异常，此连接己不可用，关闭它，并返回 false;
465. closeConnection(conn);
467. return false;
469. }
471. // 连接可用，返回 true
473. return true;
475. }
477. /**
479. * 此函数返回一个数据库连接到连接池中，并把此连接置为空闲。
481. * 所有使用连接池获得的数据库连接均应在不使用此连接时返回它。
483. *
485. * @param 需返回到连接池中的连接对象
487. */
489. public void returnConnection(Connection conn) {
491. // 确保连接池存在，如果连接没有创建（不存在），直接返回
493. if (connections == null) {
495. System.out.println(" 连接池不存在，无法返回此连接到连接池中 !");
497. return;
499. }
501. PooledConnection pConn = null;
503. Enumeration enumerate = connections.elements();
505. // 遍历连接池中的所有连接，找到这个要返回的连接对象
507. while (enumerate.hasMoreElements()) {
509. pConn = (PooledConnection) enumerate.nextElement();
511. // 先找到连接池中的要返回的连接对象
513. if (conn == pConn.getConnection()) {
515. // 找到了 , 设置此连接为空闲状态
517. pConn.setBusy(false);
519. break;
521. }
523. }
525. }
527. /**
529. * 刷新连接池中所有的连接对象
531. *
533. */
535. public synchronized void refreshConnections() throws SQLException {
537. // 确保连接池己创新存在
539. if (connections == null) {
541. System.out.println(" 连接池不存在，无法刷新 !");
543. return;
545. }
547. PooledConnection pConn = null;
549. Enumeration enumerate = connections.elements();
551. while (enumerate.hasMoreElements()) {
553. // 获得一个连接对象
555. pConn = (PooledConnection) enumerate.nextElement();
557. // 如果对象忙则等 5 秒 ,5 秒后直接刷新
559. if (pConn.isBusy()) {
561. wait(5000); // 等 5 秒
563. }
565. // 关闭此连接，用一个新的连接代替它。
567. closeConnection(pConn.getConnection());
569. pConn.setConnection(newConnection());
571. pConn.setBusy(false);
573. }
575. }
577. /**
579. * 关闭连接池中所有的连接，并清空连接池。
581. */
583. public synchronized void closeConnectionPool() throws SQLException {
585. // 确保连接池存在，如果不存在，返回
587. if (connections == null) {
589. System.out.println(" 连接池不存在，无法关闭 !");
591. return;
593. }
595. PooledConnection pConn = null;
597. Enumeration enumerate = connections.elements();
599. while (enumerate.hasMoreElements()) {
601. pConn = (PooledConnection) enumerate.nextElement();
603. // 如果忙，等 5 秒
605. if (pConn.isBusy()) {
607. wait(5000); // 等 5 秒
609. }
611. //5 秒后直接关闭它
613. closeConnection(pConn.getConnection());
615. // 从连接池向量中删除它
617. connections.removeElement(pConn);
619. }
621. // 置连接池为空
623. connections = null;
625. }
627. /**
629. * 关闭一个数据库连接
631. *
633. * @param 需要关闭的数据库连接
635. */
637. private void closeConnection(Connection conn) {
639. try {
641. conn.close();
643. }catch (SQLException e) {
645. System.out.println(" 关闭数据库连接出错： "+e.getMessage());
647. }
649. }
651. /**
653. * 使程序等待给定的毫秒数
655. *
657. * @param 给定的毫秒数
659. */
661. private void wait(int mSeconds) {
663. try {
665. Thread.sleep(mSeconds);
667. } catch (InterruptedException e) {
669. }
671. }
673. /**
675. *
677. * 内部使用的用于保存连接池中连接对象的类
679. * 此类中有两个成员，一个是数据库的连接，另一个是指示此连接是否
681. * 正在使用的标志。
683. */
685. class PooledConnection {
687. Connection connection = null;// 数据库连接
689. boolean busy = false; // 此连接是否正在使用的标志，默认没有正在使用
691. // 构造函数，根据一个 Connection 构告一个 PooledConnection 对象
693. public PooledConnection(Connection connection) {
695. this.connection = connection;
697. }
699. // 返回此对象中的连接
701. public Connection getConnection() {
703. return connection;
705. }
707. // 设置此对象的，连接
709. public void setConnection(Connection connection) {
711. this.connection = connection;
713. }
715. // 获得对象连接是否忙
717. public boolean isBusy() {
719. return busy;
721. }
723. // 设置对象的连接正在忙
725. public void setBusy(boolean busy) {
727. this.busy = busy;
729. }
731. }
733. }
735. =======================================
737. 这个例子是根据POSTGRESQL数据库写的，
738. 请用的时候根据实际的数据库调整。
740. 调用方法如下：
742. ①　ConnectionPool connPool
743. = new ConnectionPool("org.postgresql.Driver"
744. ,"jdbc:postgresql://dbURI:5432/DBName"
745. ,"postgre"
746. ,"postgre");
748. ②　connPool .createPool();
749. 　　Connection conn = connPool .getConnection();

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Enumeration;
import java.util.Vector;
public class ConnectionPool {
private String jdbcDriver = ""; // 数据库驱动
private String dbUrl = ""; // 数据 URL
private String dbUsername = ""; // 数据库用户名
private String dbPassword = ""; // 数据库用户密码
private String testTable = ""; // 测试连接是否可用的测试表名，默认没有测试表
private int initialConnections = 10; // 连接池的初始大小
private int incrementalConnections = 5;// 连接池自动增加的大小
private int maxConnections = 50; // 连接池最大的大小
private Vector connections = null; // 存放连接池中数据库连接的向量 , 初始时为 null

// 它中存放的对象为 PooledConnection 型

/**
* 构造函数
*
* @param jdbcDriver String JDBC 驱动类串
* @param dbUrl String 数据库 URL
* @param dbUsername String 连接数据库用户名
* @param dbPassword String 连接数据库用户的密码
*
*/

public ConnectionPool(String jdbcDriver,String dbUrl,String dbUsername,String dbPassword) {
         this.jdbcDriver = jdbcDriver;
         this.dbUrl = dbUrl;
         this.dbUsername = dbUsername; 
         this.dbPassword = dbPassword;
}

/**

* 返回连接池的初始大小
*
* @return 初始连接池中可获得的连接数量
*/
public int getInitialConnections() {

         return this.initialConnections;
}

/**

* 设置连接池的初始大小

*

* @param 用于设置初始连接池中连接的数量

*/

public void setInitialConnections(int initialConnections) {
         this.initialConnections = initialConnections;
}

/**

* 返回连接池自动增加的大小 、
*
* @return 连接池自动增加的大小
*/
public int getIncrementalConnections() {

         return this.incrementalConnections;

}

/**
* 设置连接池自动增加的大小
* @param 连接池自动增加的大小
*/

public void setIncrementalConnections(int incrementalConnections) {

         this.incrementalConnections = incrementalConnections;

}

/**
* 返回连接池中最大的可用连接数量
* @return 连接池中最大的可用连接数量
*/

public int getMaxConnections() {
         return this.maxConnections;
}

/**

* 设置连接池中最大可用的连接数量

*

* @param 设置连接池中最大可用的连接数量值

*/

public void setMaxConnections(int maxConnections) {

         this.maxConnections = maxConnections;

}

/**

* 获取测试数据库表的名字
*
* @return 测试数据库表的名字
*/
public String getTestTable() {

         return this.testTable;

}

/**
* 设置测试表的名字
* @param testTable String 测试表的名字
*/
public void setTestTable(String testTable) {
         this.testTable = testTable;
}

/**

*
* 创建一个数据库连接池，连接池中的可用连接的数量采用类成员
* initialConnections 中设置的值
*/
public synchronized void createPool() throws Exception {

         // 确保连接池没有创建
  
         // 如果连接池己经创建了，保存连接的向量 connections 不会为空
  
         if (connections != null) {
  
          return; // 如果己经创建，则返回
  
         }
  
         // 实例化 JDBC Driver 中指定的驱动类实例
  
         Driver driver = (Driver) (Class.forName(this.jdbcDriver).newInstance());
  
         DriverManager.registerDriver(driver); // 注册 JDBC 驱动程序
  
         // 创建保存连接的向量 , 初始时有 0 个元素
  
         connections = new Vector();
  
         // 根据 initialConnections 中设置的值，创建连接。
  
         createConnections(this.initialConnections);
  
         System.out.println(" 数据库连接池创建成功！ ");

}

/**

* 创建由 numConnections 指定数目的数据库连接 , 并把这些连接

* 放入 connections 向量中
*
* @param numConnections 要创建的数据库连接的数目
*/
@SuppressWarnings("unchecked")
private void createConnections(int numConnections) throws SQLException {

         // 循环创建指定数目的数据库连接
  
         for (int x = 0; x < numConnections; x++) {
  
          // 是否连接池中的数据库连接的数量己经达到最大？最大值由类成员 maxConnections
   
          // 指出，如果 maxConnections 为 0 或负数，表示连接数量没有限制。
   
          // 如果连接数己经达到最大，即退出。
   
          if (this.maxConnections > 0 && this.connections.size() >= this.maxConnections) {
   
           break;
   
          }
  
          //add a new PooledConnection object to connections vector
   
          // 增加一个连接到连接池中（向量 connections 中）
   
          try{
   
           connections.addElement(new PooledConnection(newConnection()));
   
          }catch(SQLException e){
   
           System.out.println(" 创建数据库连接失败！ "+e.getMessage());
   
          throw new SQLException();
   
          }
   
          System.out.println(" 数据库连接己创建 ......");
   
         }
}

/**

* 创建一个新的数据库连接并返回它
*
* @return 返回一个新创建的数据库连接
*/
private Connection newConnection() throws SQLException {

         // 创建一个数据库连接
  
         Connection conn = DriverManager.getConnection(dbUrl, dbUsername, dbPassword);
  
         // 如果这是第一次创建数据库连接，即检查数据库，获得此数据库允许支持的
  
         // 最大客户连接数目
  
         //connections.size()==0 表示目前没有连接己被创建
  
         if (connections.size() == 0) {
  
          DatabaseMetaData metaData = conn.getMetaData();
   
          int driverMaxConnections = metaData.getMaxConnections();
   
          // 数据库返回的 driverMaxConnections 若为 0 ，表示此数据库没有最大
   
          // 连接限制，或数据库的最大连接限制不知道
   
          //driverMaxConnections 为返回的一个整数，表示此数据库允许客户连接的数目
   
          // 如果连接池中设置的最大连接数量大于数据库允许的连接数目 , 则置连接池的最大
   
          // 连接数目为数据库允许的最大数目
   
          if (driverMaxConnections > 0 && this.maxConnections > driverMaxConnections) {
   
           this.maxConnections = driverMaxConnections;
   
          }
         } 
         return conn; // 返回创建的新的数据库连接

}

/**

* 通过调用 getFreeConnection() 函数返回一个可用的数据库连接 ,

* 如果当前没有可用的数据库连接，并且更多的数据库连接不能创

* 建（如连接池大小的限制），此函数等待一会再尝试获取。

*

* @return 返回一个可用的数据库连接对象

*/

public synchronized Connection getConnection() throws SQLException {

         // 确保连接池己被创建
  
         if (connections == null) {
  
          return null; // 连接池还没创建，则返回 null
  
         }
  
         Connection conn = getFreeConnection(); // 获得一个可用的数据库连接
  
         // 如果目前没有可以使用的连接，即所有的连接都在使用中
  
         while (conn == null){
  
          // 等一会再试
   
          wait(250);
   
          conn = getFreeConnection(); // 重新再试，直到获得可用的连接，如果
   
          //getFreeConnection() 返回的为 null
   
          // 则表明创建一批连接后也不可获得可用连接
  
         }
  
         return conn;// 返回获得的可用的连接
}

/**

* 本函数从连接池向量 connections 中返回一个可用的的数据库连接，如果

* 当前没有可用的数据库连接，本函数则根据 incrementalConnections 设置

* 的值创建几个数据库连接，并放入连接池中。

* 如果创建后，所有的连接仍都在使用中，则返回 null

* @return 返回一个可用的数据库连接

*/

private Connection getFreeConnection() throws SQLException {

         // 从连接池中获得一个可用的数据库连接
  
         Connection conn = findFreeConnection();
  
         if (conn == null) {
  
          // 如果目前连接池中没有可用的连接
   
          // 创建一些连接
   
          createConnections(incrementalConnections);
   
          // 重新从池中查找是否有可用连接
   
          conn = findFreeConnection();
   
          if (conn == null) {
   
           // 如果创建连接后仍获得不到可用的连接，则返回 null
    
           return null;
   
          }
  
         }
  
         return conn;

}

/**

* 查找连接池中所有的连接，查找一个可用的数据库连接，

* 如果没有可用的连接，返回 null

*

* @return 返回一个可用的数据库连接

*/

private Connection findFreeConnection() throws SQLException {

         Connection conn = null;
  
         PooledConnection pConn = null;
  
         // 获得连接池向量中所有的对象
  
         Enumeration enumerate = connections.elements();
  
         // 遍历所有的对象，看是否有可用的连接
  
         while (enumerate.hasMoreElements()) {
  
          pConn = (PooledConnection) enumerate.nextElement();
   
          if (!pConn.isBusy()) {
   
           // 如果此对象不忙，则获得它的数据库连接并把它设为忙
    
           conn = pConn.getConnection();
    
           pConn.setBusy(true);
    
           // 测试此连接是否可用
    
           if (!testConnection(conn)) {
    
            // 如果此连接不可再用了，则创建一个新的连接，
     
            // 并替换此不可用的连接对象，如果创建失败，返回 null
     
            try{
     
             conn = newConnection();
     
            }catch(SQLException e){
     
             System.out.println(" 创建数据库连接失败！ "+e.getMessage());
     
             return null;
     
            }
    
            pConn.setConnection(conn);
    
           }
    
           break; // 己经找到一个可用的连接，退出
   
          }
  
         }
  
         return conn;// 返回找到到的可用连接

}

/**

* 测试一个连接是否可用，如果不可用，关掉它并返回 false

* 否则可用返回 true

*

* @param conn 需要测试的数据库连接

* @return 返回 true 表示此连接可用， false 表示不可用

*/

private boolean testConnection(Connection conn) {

         try {
  
          // 判断测试表是否存在
   
          if (testTable.equals("")) {
   
           // 如果测试表为空，试着使用此连接的 setAutoCommit() 方法
    
           // 来判断连接否可用（此方法只在部分数据库可用，如果不可用 ,
    
           // 抛出异常）。注意：使用测试表的方法更可靠
    
           conn.setAutoCommit(true);
   
          } else {// 有测试表的时候使用测试表测试
   
           //check if this connection is valid
    
           Statement stmt = conn.createStatement();
    
           stmt.execute("select count(*) from " + testTable);
   
          }
  
         } catch (SQLException e) {
  
          // 上面抛出异常，此连接己不可用，关闭它，并返回 false;
  
          closeConnection(conn);
  
          return false;
  
         }
  
         // 连接可用，返回 true
  
         return true;

}

/**

* 此函数返回一个数据库连接到连接池中，并把此连接置为空闲。

* 所有使用连接池获得的数据库连接均应在不使用此连接时返回它。

*

* @param 需返回到连接池中的连接对象

*/

public void returnConnection(Connection conn) {

         // 确保连接池存在，如果连接没有创建（不存在），直接返回
  
         if (connections == null) {
  
          System.out.println(" 连接池不存在，无法返回此连接到连接池中 !");
   
          return;
  
         }

         PooledConnection pConn = null;
  
         Enumeration enumerate = connections.elements();
  
         // 遍历连接池中的所有连接，找到这个要返回的连接对象
  
         while (enumerate.hasMoreElements()) {

          pConn = (PooledConnection) enumerate.nextElement();
   
          // 先找到连接池中的要返回的连接对象
   
          if (conn == pConn.getConnection()) {
   
           // 找到了 , 设置此连接为空闲状态
    
           pConn.setBusy(false);
    
           break;
   
          }

         }

}

/**

* 刷新连接池中所有的连接对象

*

*/

public synchronized void refreshConnections() throws SQLException {

         // 确保连接池己创新存在
  
         if (connections == null) {
  
          System.out.println(" 连接池不存在，无法刷新 !");
  
          return;
  
         }
  
         PooledConnection pConn = null;
  
         Enumeration enumerate = connections.elements();
  
         while (enumerate.hasMoreElements()) {

          // 获得一个连接对象
   
          pConn = (PooledConnection) enumerate.nextElement();
   
          // 如果对象忙则等 5 秒 ,5 秒后直接刷新
   
          if (pConn.isBusy()) {
   
           wait(5000); // 等 5 秒
   
          }
   
          // 关闭此连接，用一个新的连接代替它。
   
          closeConnection(pConn.getConnection());
   
          pConn.setConnection(newConnection());
   
          pConn.setBusy(false);
   
         }

}

/**

* 关闭连接池中所有的连接，并清空连接池。

*/

public synchronized void closeConnectionPool() throws SQLException {

         // 确保连接池存在，如果不存在，返回
  
         if (connections == null) {
  
          System.out.println(" 连接池不存在，无法关闭 !");
  
          return;
  
         }
  
         PooledConnection pConn = null;
  
         Enumeration enumerate = connections.elements();
  
         while (enumerate.hasMoreElements()) {
  
          pConn = (PooledConnection) enumerate.nextElement();
  
          // 如果忙，等 5 秒
  
          if (pConn.isBusy()) {
  
           wait(5000); // 等 5 秒
  
          }
  
         //5 秒后直接关闭它
  
         closeConnection(pConn.getConnection());
  
         // 从连接池向量中删除它
  
         connections.removeElement(pConn);
  
         }
  
         // 置连接池为空
  
         connections = null;

}

/**

* 关闭一个数据库连接

*

* @param 需要关闭的数据库连接

*/

private void closeConnection(Connection conn) {

         try {
  
          conn.close();
  
         }catch (SQLException e) {
  
          System.out.println(" 关闭数据库连接出错： "+e.getMessage());
  
         }

}

/**

* 使程序等待给定的毫秒数

*

* @param 给定的毫秒数

*/

private void wait(int mSeconds) {

         try {
  
          Thread.sleep(mSeconds);
  
         } catch (InterruptedException e) {
  
         }

}

/**

*

* 内部使用的用于保存连接池中连接对象的类

* 此类中有两个成员，一个是数据库的连接，另一个是指示此连接是否

* 正在使用的标志。

*/

class PooledConnection {

         Connection connection = null;// 数据库连接
  
         boolean busy = false; // 此连接是否正在使用的标志，默认没有正在使用
  
         // 构造函数，根据一个 Connection 构告一个 PooledConnection 对象
  
         public PooledConnection(Connection connection) {
  
          this.connection = connection;
  
         }
  
         // 返回此对象中的连接
  
         public Connection getConnection() {
  
          return connection;

         }

         // 设置此对象的，连接
  
         public void setConnection(Connection connection) {
  
          this.connection = connection;
   
         }
   
         // 获得对象连接是否忙
   
         public boolean isBusy() {
   
          return busy;
   
         }
   
         // 设置对象的连接正在忙
   
         public void setBusy(boolean busy) {
   
          this.busy = busy;
   
         }

}

}

=======================================

这个例子是根据POSTGRESQL数据库写的，
请用的时候根据实际的数据库调整。

调用方法如下：

①　ConnectionPool connPool
                                     = new ConnectionPool("org.postgresql.Driver"
                                                                         ,"jdbc:postgresql://dbURI:5432/DBName"
                                                                         ,"postgre"
                                                                         ,"postgre");

②　connPool .createPool();
　　Connection conn = connPool .getConnection();