java常用工具类之数据库连接类（可以连接多种数据库）

依赖包下载

数据库连接类源码：

1. package com.itjh.javaUtil; 
2.   
3. import java.sql.Connection; 
4. import java.sql.DriverManager; 
5. import java.sql.PreparedStatement; 
6. import java.sql.ResultSet; 
7. import java.sql.ResultSetMetaData; 
8. import java.sql.SQLException; 
9. import java.util.ArrayList; 
10. import java.util.Collections; 
11. import java.util.HashMap; 
12. import java.util.List; 
13. import java.util.Map; 
14.   
15. import org.apache.commons.dbcp.ConnectionFactory; 
16. import org.apache.commons.dbcp.DriverManagerConnectionFactory; 
17. import org.apache.commons.dbcp.PoolableConnectionFactory; 
18. import org.apache.commons.dbcp.PoolingDriver; 
19. import org.apache.commons.dbutils.DbUtils; 
20. import org.apache.commons.dbutils.QueryRunner; 
21. import org.apache.commons.dbutils.handlers.MapListHandler; 
22. import org.apache.commons.pool.ObjectPool; 
23. import org.apache.commons.pool.impl.GenericObjectPool; 
24.   
25. /** 
26.  * 连接数据库的综合类。</br> 
27.  * 依赖jar包：commons.dbcp-1.4，commons.dbutils-1.3，commons.pool-1.5.4包。 
28.  *  
29.  * @author 宋立君 
30.  * @date 2014年07月03日 
31.  */ 
32.   
33. public class DBUtil { 
34.   
35.     private String dri = null; 
36.     private String url = null; 
37.     private String username = null; 
38.     private String password = null; 
39.     private String poolName = null; // 连接池名称 
40.     private ObjectPool connectionPool = null; // 连接池 
41.     // 对应的定时查询类 
42.     private QueryThread queryThread = null; 
43.   
44.     /** 
45.      * 功能：构造函数 
46.      *  
47.      * @author 宋立君 
48.      * @date 2014年07月03日 
49.      * @param dri 
50.      *      驱动全类名，例如：com.mysql.jdbc.Driver。 
51.      * @param url 
52.      *      数据库url连接，例如： 
53.      *      "jdbc:mysql://127.0.0.1:3306/test?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8" 
54.      * @param userName 
55.      *      数据库用户名，例如：root 
56.      * @param password 
57.      *      数据库密码，例如：abc 
58.      * @param poolName 
59.      *      创建的数据库连接池的名称，例如mypool，注意一个web容器此名称不能重复。 
60.      */ 
61.     public DBUtil(String dri, String url, String userName, String password, 
62.             String poolName) { 
63.         this.dri = dri; 
64.         this.url = url; 
65.         this.username = userName; 
66.         this.password = password; 
67.         this.poolName = poolName; 
68.     } 
69.   
70.     /** 
71.      * 执行sql。 
72.      *  
73.      * @param conn 
74.      *      连接 
75.      * @param pstm 
76.      *      PreparedStatement 
77.      * @return int 执行sql对应的影响行。 
78.      * @throws SQLException 
79.      * @author 宋立君 
80.      * @date 2014年07月03日 
81.      */ 
82.     public int execute(Connection conn, PreparedStatement pstm) 
83.             throws SQLException { 
84.         try { 
85.             return pstm.executeUpdate(); 
86.         } finally { 
87.             Close(conn); 
88.         } 
89.     } 
90.   
91.     /** 
92.      * 查询sql。 
93.      *  
94.      * @param conn 
95.      *      连接 
96.      * @param pstm 
97.      *      PreparedStatement 
98.      * @return List<Map<String,Object>> 查询的结果集 
99.      * @throws SQLException 
100.      * @author 宋立君 
101.      * @date 2014年07月03日 
102.      */ 
103.     public List<Map<String, Object>> query(Connection conn, 
104.             PreparedStatement pstm) throws SQLException { 
105.         try { 
106.             return resultSetToList(pstm.executeQuery()); 
107.         } finally { 
108.             Close(conn); 
109.         } 
110.     } 
111.   
112.     /** 
113.      * 功能：ResultSet 转为List<Map<String,Object>> 
114.      *  
115.      *  
116.      * @param rs 
117.      *      ResultSet 原始数据集 
118.      * @return List<Map<String,Object>> 
119.      * @throws java.sql.SQLException 
120.      * @author 宋立君 
121.      * @date 2014年07月03日 
122.      */ 
123.     private List<Map<String, Object>> resultSetToList(ResultSet rs) 
124.             throws java.sql.SQLException { 
125.         if (rs == null) 
126.             return Collections.EMPTY_LIST; 
127.   
128.         ResultSetMetaData md = rs.getMetaData(); // 得到结果集(rs)的结构信息，比如字段数、字段名等 
129.         int columnCount = md.getColumnCount(); // 返回此 ResultSet 对象中的列数 
130.         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>(); 
131.         Map<String, Object> rowData = new HashMap<String, Object>(); 
132.         while (rs.next()) { 
133.             rowData = new HashMap<String, Object>(columnCount); 
134.             for (int i = 1; i <= columnCount; i++) { 
135.                 rowData.put(md.getColumnName(i), rs.getObject(i)); 
136.             } 
137.             list.add(rowData); 
138.         } 
139.         return list; 
140.     } 
141.   
142.     /** 
143.      * 查询sql语句。 
144.      *  
145.      * @param sql 
146.      *      被执行的sql语句 
147.      * @return List<Map<String,Object>> 
148.      * @throws SQLException 
149.      * @author 宋立君 
150.      * @date 2014年07月03日 
151.      */ 
152.     public List<Map<String, Object>> query(String sql) throws SQLException { 
153.         List<Map<String, Object>> results = null; 
154.         Connection conn = null; 
155.         try { 
156.             conn = getConnection(); 
157.             QueryRunner qr = new QueryRunner(); 
158.             results = qr.query(conn, sql, new MapListHandler()); 
159.         } finally { 
160.             Close(conn); 
161.         } 
162.         return results; 
163.     } 
164.   
165.     /** 
166.      * 根据参数查询sql语句 
167.      *  
168.      * @param sql 
169.      *      sql语句 
170.      * @param param 
171.      *      参数 
172.      * @return List<Map<String,Object>> 
173.      * @throws SQLException 
174.      * @author 宋立君 
175.      * @date 2014年07月03日 
176.      */ 
177.     public List<Map<String, Object>> query(String sql, Object param) 
178.             throws SQLException { 
179.         List<Map<String, Object>> results = null; 
180.         Connection conn = null; 
181.         try { 
182.             conn = getConnection(); 
183.             QueryRunner qr = new QueryRunner(); 
184.             results = (List<Map<String, Object>>) qr.query(conn, sql, param, 
185.                     new MapListHandler()); 
186.         } catch (SQLException e) { 
187.             e.printStackTrace(); 
188.         } finally { 
189.             Close(conn); 
190.         } 
191.         return results; 
192.     } 
193.   
194.     /** 
195.      * 执行sql语句 
196.      *  
197.      * @param sql 
198.      *      被执行的sql语句 
199.      * @return 受影响的行 
200.      * @throws Exception 
201.      * @author 宋立君 
202.      * @date 2014年07月03日 
203.      */ 
204.     public int execute(String sql) throws Exception { 
205.         Connection conn = getConnection(); 
206.         int rows = 0; 
207.         try { 
208.             QueryRunner qr = new QueryRunner(); 
209.             rows = qr.update(conn, sql); 
210.         } finally { 
211.             Close(conn); 
212.         } 
213.         return rows; 
214.     } 
215.   
216.     /** 
217.      * 执行含参数的sql语句 
218.      *  
219.      * @param sql 
220.      *      被执行的sql语句 
221.      * @param params 
222.      *      参数 
223.      * @return 返回受影响的行 
224.      * @throws Exception 
225.      * @author 宋立君 
226.      * @date 2014年07月03日 
227.      */ 
228.     public int execute(String sql, Object[] params) throws Exception { 
229.         Connection conn = getConnection(); 
230.         int rows = 0; 
231.         try { 
232.             QueryRunner qr = new QueryRunner(); 
233.             rows = qr.update(conn, sql, params); 
234.         } finally { 
235.             Close(conn); 
236.         } 
237.         return rows; 
238.     } 
239.   
240.     /** 
241.      * 关闭连接 
242.      *  
243.      * @param conn 
244.      * @throws SQLException 
245.      * @author 宋立君 
246.      * @date 2014年07月03日 
247.      */ 
248.     public void Close(Connection conn) throws SQLException { 
249.         if (conn != null) { 
250.             conn.close(); 
251.         } 
252.         DbUtils.closeQuietly(conn); 
253.     } 
254.   
255.     /** 
256.      * 启动连接池 
257.      *  
258.      * @author 宋立君 
259.      * @date 2014年07月03日 
260.      */ 
261.     private void StartPool() { 
262.         try { 
263.             Class.forName(dri); 
264.         } catch (ClassNotFoundException e1) { 
265.             e1.printStackTrace(); 
266.         } 
267.         if (connectionPool != null) { 
268.             ShutdownPool(); 
269.         } 
270.         try { 
271.             connectionPool = new GenericObjectPool(null); 
272.             ConnectionFactory connectionFactory = new DriverManagerConnectionFactory( 
273.                     url, username, password); 
274.             PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory( 
275.                     connectionFactory, connectionPool, null, "SELECT 1", false, 
276.                     true); 
277.             Class.forName("org.apache.commons.dbcp.PoolingDriver"); 
278.             PoolingDriver driver = (PoolingDriver) DriverManager 
279.                     .getDriver("jdbc:apache:commons:dbcp:"); 
280.             driver.registerPool(poolName, poolableConnectionFactory.getPool()); 
281.   
282.         } catch (Exception e) { 
283.             e.printStackTrace(); 
284.         } 
285.         // 开启查询程序 
286.         queryThread = new QueryThread(this); 
287.         queryThread.start(); 
288.     } 
289.   
290.     /** 
291.      * 关闭连接池 
292.      *  
293.      * @author 宋立君 
294.      * @date 2014年07月03日 
295.      */ 
296.     private void ShutdownPool() { 
297.         try { 
298.             PoolingDriver driver = (PoolingDriver) DriverManager 
299.                     .getDriver("jdbc:apache:commons:dbcp:"); 
300.             driver.closePool(poolName); 
301.             // 关闭定时查询 
302.             queryThread.setStartQuery(false); 
303.         } catch (SQLException e) { 
304.             e.printStackTrace(); 
305.         } 
306.     } 
307.   
308.     /** 
309.      * 得到一个连接 
310.      *  
311.      * @return 
312.      * @author 宋立君 
313.      * @date 2014年07月03日 
314.      */ 
315.     public synchronized Connection getConnection() { 
316.         Connection conn = null; 
317.         try { 
318.             if (connectionPool == null) 
319.                 StartPool(); 
320.             conn = DriverManager.getConnection("jdbc:apache:commons:dbcp:" 
321.                     + poolName); 
322.         } catch (Exception e) { 
323.             e.printStackTrace(); 
324.         } 
325.         return conn; 
326.     } 
327. } 
328.   
329. /** 
330.  * 当连接池启动后会自动定时查询数据库，防止数据库连接超时。 
331.  *  
332.  * @author 宋立君 
333.  * @date 2014年07月03日 
334.  */ 
335. class QueryThread extends Thread { 
336.   
337.     private DBUtil dbUtil = null; 
338.     // 是否开启查询 
339.     private boolean startQuery = true; 
340.   
341.     /** 
342.      * 功能：对应的数据库连接。 
343.      *  
344.      * @author 宋立君 
345.      * @date 2014年07月03日 
346.      * @param dbUtil 
347.      *      数据库连接 
348.      */ 
349.     public QueryThread(DBUtil dbUtil) { 
350.         this.dbUtil = dbUtil; 
351.     } 
352.   
353.     public void run() { 
354.         while (true) { 
355.             try { 
356.                 if (startQuery) { 
357.                     this.dbUtil.query("select 1"); 
358.                 } 
359.                 // System.out.println(startQuery+"  123"); 
360.             } catch (Exception e) { 
361.                 e.printStackTrace(); 
362.             } finally { 
363.                 try { 
364.                     Thread.sleep(120000); 
365.                 } catch (InterruptedException e) { 
366.                     e.printStackTrace(); 
367.                 } 
368.             } 
369.         } 
370.     } 
371.   
372.     public void setStartQuery(boolean startQuery) { 
373.         // System.out.println("startQuery shut:"+startQuery); 
374.         this.startQuery = startQuery; 
375.     } 
376. }