[转]Java使用commons-dbcp2.0

原文地址:http://blog.csdn.net/jiutianhe/article/details/39670817

dbcp 是 apache 上的一个 java 连接池项目，也是 tomcat 使用的连接池组件。单独使用dbcp需要3个包：common-dbcp.jar,common-pool.jar,common-collections.jar。

commons-pool的实现类来进行配置。

commons-pool1.6和commons-pool2.2分属commons-pool中两个不同的大版本，按照commons-pool官网上的介绍，Apache Commons Pool 2.2 (Java 6.0+)，Apache Commons Pool 1.6 (Java 5.0+)，即不同版本要求的JDK最低版本不同。

而commons-dbcp现在分成了3个大版本，不同的版本要求的JDK不同：

DBCP now comes in three different versions to support different versions of JDBC. Here is how it works:

Java
7 only (JDBC 4.1)

Java
6 only (JDBC 4)

Java
1.4-5 only (JDBC 3)

commons-dbcp2参数配置

由于commons-dbcp所用的连接池出现版本升级，因此commons-dbcp2中的数据库池连接配置也发生了变化，具体的参数配置说明如下：

---

Parameter Description

username

password

url

driverClassName

connectionProperties

Format of the string must be [propertyName=property;]*

---

Parameter Default Description

defaultAutoCommit
defaultReadOnly
defaultTransactionIsolation

The default auto-commit state of connections created by this pool. If not set then the setAutoCommit method will not be called.
The default read-only state of connections created by this pool. If not set then the setReadOnly method will not be called. (Some drivers don't support read only mode, ex: Informix)
The default TransactionIsolation state of connections created by this pool. One of the following: (see READ_COMMITTED REPEATABLE_READ defaultCatalog		cacheState	If true, the pooled connection will cache the current readOnly and autoCommit settings when first read or written and on all subsequent writes. This removes the need for additional database queries for any further calls to the getter. If the underlying connection is accessed directly and the readOnly and/or autoCommit settings changed the cached values will not reflect the current state. In this case, caching should be disabled by setting this attribute to false.

1. package dbcp;
2. import java.sql.Connection;
3. import java.sql.ResultSet;
4. import java.sql.SQLException;
5. import java.sql.Statement;
6. import java.util.HashMap;
7. import java.util.Map;
8. import javax.sql.DataSource;
9. import org.apache.commons.dbcp2.BasicDataSource;
10. /**
11. * @author
12. * @date
13. *
14. *       dbcp 实用类，提供了dbcp连接，不允许继承；
15. *
16. *       该类需要有个地方来初始化 DS ，通过调用initDS 方法来完成， 可以在通过调用带参数的构造函数完成调用，
17. *       可以在其它类中调用，也可以在本类中加一个static{}来完成；
18. */
19. public final class DbcpBean {
20. /** 数据源，static */
21. private static DataSource DS;
22. /** 从数据源获得一个连接 */
23. public Connection getConn() {
24. Connection con = null;
25. if (DS != null) {
26. try {
27. con = DS.getConnection();
28. } catch (Exception e) {
29. e.printStackTrace(System.err);
30. }
31. try {
32. con.setAutoCommit(false);
33. } catch (SQLException e) {
34. e.printStackTrace();
35. }
36. return con;
37. }
38. return con;
39. }
40. /** 默认的构造函数 */
41. public DbcpBean() {
42. }
43. /** 构造函数，初始化了 DS ，指定 数据库 */
44. public DbcpBean(String connectURI) {
45. initDS(connectURI);
46. }
47. /** 构造函数，初始化了 DS ，指定 所有参数 */
48. public DbcpBean(String connectURI, String username, String pswd,
49. String driverClass, int initialSize, int maxActive, int maxIdle,
50. int maxWait, int minIdle) {
51. initDS(connectURI, username, pswd, driverClass, initialSize, maxActive,
52. maxIdle, maxWait, minIdle);
53. }
54. /**
55. * 创建数据源，除了数据库外，都使用硬编码默认参数；
56. *
57. * @param connectURI
58. *            数据库
59. * @return
60. */
61. public static void initDS(String connectURI) {
62. initDS(connectURI, "root", "password", "com.mysql.jdbc.Driver", 5, 100,
63. 30, 10000, 1);
64. }
65. /**
66. * 指定所有参数连接数据源
67. *
68. * @param connectURI
69. *            数据库
70. * @param username
71. *            用户名
72. * @param pswd
73. *            密码
74. * @param driverClass
75. *            数据库连接驱动名
76. * @param initialSize
77. *            初始连接池连接个数
78. * @param maxtotal
79. *            最大活动连接数
80. * @param maxIdle
81. *            最大连接数
82. * @param maxWaitMillis
83. *            获得连接的最大等待毫秒数
84. * @param minIdle
85. *            最小连接数
86. * @return
87. */
88. public static void initDS(String connectURI, String username, String pswd,
89. String driverClass, int initialSize, int maxtotal, int maxIdle,
90. int maxWaitMillis , int minIdle) {
91. BasicDataSource ds = new BasicDataSource();
92. ds.setDriverClassName(driverClass);
93. ds.setUsername(username);
94. ds.setPassword(pswd);
95. ds.setUrl(connectURI);
96. ds.setInitialSize(initialSize); // 初始的连接数；
97. ds.setMaxTotal(maxtotal);
98. ds.setMaxIdle(maxIdle);
99. ds.setMaxWaitMillis(maxWaitMillis);
100. ds.setMinIdle(minIdle);
101. DS = ds;
102. }
103. /** 获得数据源连接状态 */
104. public static Map<String, Integer> getDataSourceStats() throws SQLException {
105. BasicDataSource bds = (BasicDataSource) DS;
106. Map<String, Integer> map = new HashMap<String, Integer>(2);
107. map.put("active_number", bds.getNumActive());
108. map.put("idle_number", bds.getNumIdle());
109. return map;
110. }
111. /** 关闭数据源 */
112. protected static void shutdownDataSource() throws SQLException {
113. BasicDataSource bds = (BasicDataSource) DS;
114. bds.close();
115. }
116. public static void main(String[] args) {
117. DbcpBean db = new DbcpBean("jdbc:mysql://localhost:3306/testit");
118. Connection conn = null;
119. Statement stmt = null;
120. ResultSet rs = null;
121. try {
122. conn = db.getConn();
123. stmt = conn.createStatement();
124. rs = stmt.executeQuery("select * from test limit 1 ");
125. System.out.println("Results:");
126. int numcols = rs.getMetaData().getColumnCount();
127. while (rs.next()) {
128. for (int i = 1; i <= numcols; i++) {
129. System.out.print("\t" + rs.getString(i) + "\t");
130. }
131. System.out.println("");
132. }
133. System.out.println(getDataSourceStats());
134. } catch (SQLException e) {
135. e.printStackTrace();
136. } finally {
137. try {
138. if (rs != null)
139. rs.close();
140. if (stmt != null)
141. stmt.close();
142. if (conn != null)
143. conn.close();
144. if (db != null)
145. shutdownDataSource();
146. } catch (Exception e) {
147. e.printStackTrace();
148. }
149. }
150. }
151. }