dbcp的简单使用_数据库连接池

1. 一.package dbutil;
3. import javax.sql.*;
4. import java.sql.*;
6. import org.apache.commons.dbcp.BasicDataSource;
8. /**
9.  * 数据库连接类,使用了DBCP 数据库连接池
10.  * 
11.  */
13. public class DBConnection {
15.     private static DataSource ds = null;
16.     private static boolean poolOK = false;
18.     final static String DBDRIVER = "com.mysql.jdbc.Driver";
19.     final static String DBURL = "jdbc:mysql://localhost:3306/test";
20.     final static String DBUSER = "root";
21.     final static String DBPWD = "root";
22.     /**
23.      * 取得数据库连接
24.      * 
25.      * @return 一个数据池中的连接
26.      */
27.     public static Connection getConnection() {
28.         // 如果连接池未安装 或 连接池坏死, 安装连接池
29.         if (null == ds || false == poolOK) {
30.             ds = setupDataSource();
31.         }
33.         Connection con = null;
34.         
35.         try {
36.             con = ds.getConnection();
37.             poolOK = true;
38.             //检测连接是否有效，如果无效，会抛出异常
39.             //con.prepareStatement("select * from tab");
40.         } catch (SQLException e) {
41.             poolOK = false;
42.             shutdownDataSource(ds);
43.             System.out.println("数据库意外关闭" + e);
44.         }
45.         return con;
46.     }
48.     /**
49.      * 安装连接池
50.      * 
51.      * @return 连接池对象
52.      * 
53.      */
54.     private static DataSource setupDataSource() {
55.         BasicDataSource bds = new BasicDataSource();
56.         bds.setDriverClassName(DBDRIVER);
57.         bds.setUrl(DBURL);
58.         bds.setUsername(DBUSER);
59.         bds.setPassword(DBPWD);
60.         bds.setInitialSize(10);
61.         bds.setMaxActive(30);
62.         return bds;
63.     }
65.     /**
66.      * 关闭连接池
67.      */
68.     private static void shutdownDataSource(DataSource ds) {
69.         BasicDataSource bds = (BasicDataSource) ds;
70.         try {
71.             bds.close();
72.         } catch (SQLException e) {
73.             e.printStackTrace();
74.         }
75.     }
76.     /**
77.      * 打印 数据库连接池状态
78.      * @param ds
79.      * @throws SQLException
80.      */
81.      public static void printDataSourceStats()  {
82.             BasicDataSource bds = (BasicDataSource) ds;
83.             System.out.println("NumActive: " + bds.getNumActive());
84.             System.out.println("NumIdle: " + bds.getNumIdle());
85.         }
87.     private DBConnection() {
88.     }
89.     public static void main(String[] args) {
90.         getConnection();
91.         getConnection();
92.         printDataSourceStats();
93.     }
94. }
96. 二.
97. package dbcp;
99. import java.sql.*;
101. import org.apache.commons.pool.ObjectPool;
102. import org.apache.commons.pool.impl.GenericObjectPool;
103. import org.apache.commons.dbcp.ConnectionFactory;
104. import org.apache.commons.dbcp.PoolingDriver;
105. import org.apache.commons.dbcp.PoolableConnectionFactory;
106. import org.apache.commons.dbcp.DriverManagerConnectionFactory;
108. /*the class connect to oracle with thin methord*/
109. public class DBPoolUtil {
110.     // the orcale jdbc dirver
111.     //static String driver = "oracle.jdbc.driver.OracleDriver";
112.     static String driver = "com.mysql.jdbc.Driver";
113.     // the connection is used to connect to database or dbcp
114.     private Connection conn = null;
116.     // the statement is used to execute SQL statement in database
117.     private Statement stmt = null;
119.     // the exact database URI locate in database
120.     //private static String sqlJdbc = "jdbc:oracle:thin:@192.168.0.77:1521:OEMTEP";
121.     private static String sqlJdbc = "jdbc:mysql://localhost:3306/test";
123.     // use name
124.     private static String sqlUser = "root";
126.     // password
127.     private static String sqlPwd = "root";
129.     // the class file of oracle jdbc make it get .class file dynamiclly
130.     private static Class driverClass = null;
132.     // the pointer which presents DBPC
133.     private static ObjectPool connectionPool = null;
135.     // the construct methord is automaticlly connect to the database for user
136.     public DBPoolUtil() {
137.         initDataSource();
138.     }
140.     // connect to oracle and print some information about it
141.     // and synchronized make the pool used a user one time
142.     private synchronized static void initDataSource() {
143.         if (driverClass == null) {
144.             try {
145.                 // load the  jdbc
146.                 driverClass = Class.forName(driver);
147.             } catch (ClassNotFoundException e) {
148.                 e.printStackTrace();
149.             }
150.         }
152.         if (connectionPool == null) {
153.             try {
154.                 setupDriver(sqlJdbc);
155.             } catch (Exception e) {
156.                 e.printStackTrace();
157.             }
158.         }
160.         // Display some pool statistics
161.         try {
162.             printDriverStats();
163.         } catch (Exception e) {
164.             e.printStackTrace();
165.         }
166.     }
168.     private static void setupDriver(String connectURI) throws Exception {
169.         // get pool connection of DBPC
170.         connectionPool = new GenericObjectPool(null);
172.         ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(
173.                 connectURI, sqlUser, sqlPwd);
175.         PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(
176.                 connectionFactory, connectionPool, null, null, false, true);
178.         Class.forName("org.apache.commons.dbcp.PoolingDriver");
180.         PoolingDriver driver = (PoolingDriver) DriverManager
181.                 .getDriver("jdbc:apache:commons:dbcp:");
182.         //   
183.         driver.registerPool("auxdbpoll", connectionPool);
184.     }
186.     private static void printDriverStats() throws Exception {
187.         PoolingDriver driver = (PoolingDriver) DriverManager
188.                 .getDriver("jdbc:apache:commons:dbcp:");
189.         ObjectPool connectionPool = driver.getConnectionPool("auxdbpoll");
190.         System.out.println("active connection: "
191.                 + connectionPool.getNumActive());
192.         System.out.println("idle connection:  " + connectionPool.getNumIdle());
193.     }
195.     // the a connection from the pool
196.     public Connection getConnection() {
197.         try {
198.             conn = DriverManager
199.                     .getConnection("jdbc:apache:commons:dbcp:auxdbpoll");
200.         } catch (SQLException e) {
201.             e.printStackTrace();
202.         }
203.         return conn;
204.     }
205.     /** 
206.      * 释放连接池 
207.      */ 
208.     public static void ShutdownPool() { 
209.         try { 
210.             PoolingDriver driver = (PoolingDriver) DriverManager 
211.                     .getDriver("jdbc:apache:commons:dbcp:"); 
212.             driver.closePool("auxdbpoll"); 
213.         } catch (SQLException e) { 
214.             e.printStackTrace();
215.         } 
216.     } 
218. }