DbUtils学习(一)

以前用惯了Hibernate，一下不用很不习惯，因为Hibernate的确为程序员省下了很多事。很多小的项目都在用Hibernate，暂且不说有没有跨数据库的特性，也不说对象关系映射是否重要，基本的SQL 动作处理也是一件很麻烦的事。 

总结一下，至少有三方面比较麻烦： 
1. 异常处理。如果直接用JDBC，几乎每个操作都要抛出几个异常，因此代码看起来很不优雅。 
2. 创建的对象很多。大多数操作都要显示的建立statement，ResultSet对象，致使代码看起 来很长，其实这些都可以再封装。 
3. JavaBean与ResultSet对象的转化。这是一个很枯燥的工作，而且这样的工作还会重复做很多次，严重影响了开发速度。 

本来自己计划在有空的时候自己来尝试封装一下的，但哪知前人早把这些事做了，的确令自己汗颜。那就是commons的DbUtils组件。这个组件很小，做的事也不多，但几乎把上面几个问题都处理好了。因此只要花许时间学习一下就可以了，自己何必再去造轮子呢？ 

下面简单的介绍一下其用法，用JDBC开发，最好建立一件连接池，由于以前在博客里面也介绍过C3P0组件的用法，因此现在直接拿来用就行了。 

环境： 
commons-dbutils-1.2 
junit4.5 
c3p0-0.9.1.2 
mysql-connector-java-5.1.7 


由于DbUtils组件中有一个DbUtils类专门用来处理数据连接的关闭问题，因此以前的那个类也可以去掉一些代码，为了方便阅读，还是把它放在这里吧！ 

Java代码  

1. public class ConnectionPool {  
2.   
3.     public static void destroy() throws SQLException {  
4.         _instance._destroy();  
5.     }  
6.     public static Connection getConnection() throws SQLException {  
7.         return _instance._getConnection();  
8.     }  
9.     public static Properties getProperties() {  
10.         return _instance._props;  
11.     }  
12.     private ConnectionPool() {  
13.         try {  
14.   
15.             // Properties  
16.             ClassLoader classLoader = getClass().getClassLoader();  
17.             _props = new Properties();  
18.             _props.load(classLoader  
19.                     .getResourceAsStream("connection-pool.properties"));  
20.   
21.             _props.list(System.out);  
22.   
23.             // Pooled data source  
24.   
25.             String driverClass = _props.getProperty("driver.class");  
26.             String jdbcUrl = _props.getProperty("jdbc.url");  
27.             String user = _props.getProperty("user");  
28.             String password = _props.getProperty("password");  
29.   
30.             int minPoolSize = 5;  
31.             try {  
32.                 minPoolSize = Integer.parseInt(_props  
33.                         .getProperty("min.pool.size"));  
34.             } catch (Exception e) {  
35.             }  
36.             int maxPoolSize = 5;  
37.             try {  
38.                 maxPoolSize = Integer.parseInt(_props  
39.                         .getProperty("max.pool.size"));  
40.             } catch (Exception e) {  
41.             }  
42.             int acquireIncrement = 5;  
43.             try {  
44.                 acquireIncrement = Integer.parseInt(_props  
45.                         .getProperty("acquire.increment"));  
46.             } catch (Exception e) {  
47.             }  
48.             _cpds = new ComboPooledDataSource();  
49.   
50.             _cpds.setDriverClass(driverClass);  
51.             _cpds.setJdbcUrl(jdbcUrl);  
52.             _cpds.setUser(user);  
53.             _cpds.setPassword(password);  
54.   
55.             _cpds.setMinPoolSize(minPoolSize);  
56.             _cpds.setMaxPoolSize(maxPoolSize);  
57.             _cpds.setAcquireIncrement(acquireIncrement);  
58.         } catch (Exception e) {  
59.             _log.error(e);  
60.         }  
61.     }  
62.     private void _destroy() throws SQLException {  
63.         DataSources.destroy(_cpds);  
64.     }  
65.     private Connection _getConnection() throws SQLException {  
66.         return _cpds.getConnection();  
67.     }  
68.     private DataSource _getDataSource(){  
69.         return _cpds;  
70.     }  
71.     public static DataSource getDataSource(){  
72.         return _instance._getDataSource();  
73.     }  
74.       
75.     private static Log _log = LogFactory.getLog(ConnectionPool.class);  
76.     private static ConnectionPool _instance = new ConnectionPool();  
77.     private Properties _props;  
78.     private ComboPooledDataSource _cpds;  
79.   
80. }  

更详细的说明可见以前的博客。 
要进行基本的查询，也非常的容易，主要用到的对象是DbUtils,QueryRunner,ResultSetHandler 

具体用法见如下代码： 

Java代码  

1. .......................  
2.        Connection conn = null;  
3.       
4.     @Before  
5.     public void init(){  
6.         try {  
7.             conn = ConnectionPool.getConnection();  
8.         } catch (SQLException e) {  
9.             // TODO Auto-generated catch block  
10.             e.printStackTrace();  
11.         }  
12.     }  
13.       
14.     @Test  
15.     public void testWithConnParamQuery() throws SQLException{  
16.         String sql = "select * from user";  
17.         QueryRunner query = new QueryRunner();  
18.         ResultSetHandler bean = new BeanListHandler(User.class);  
19.           
20.         @SuppressWarnings("unchecked")  
21.         List<User> list = (List<User>) query.query(conn, sql, bean);  
22.           
23.         for(User user:list){  
24.             System.out.println(user.getName());  
25.         }  
26.     }  
27.       
28.     @After  
29.     public void close(){  
30.         DbUtils.closeQuietly(conn);  
31.     }  
32. ............  

上面的代码相对直接用JDBC操作的确简化了很多，主要作用就是查询一个User对象列表。 
值得注意的是，上面查询参数加入了conn对象，如果每次查询都要conn，可能也不太好。 
所以QueryRunner还一个不需要conn参数的查询，但在创建QueryRunner对象的时候必须要加上一个DataSource对象，这也很简单，因为ComboPooledDataSource 类实现了DataSource接口，所以上面有一个返回DataSource的方法，直接拿来用即可： 

Java代码  

1. ..........  
2.         @Test  
3.     public void testNoConnParamQuery() throws SQLException{  
4.         String sql = "select * from user";  
5.         QueryRunner query = new QueryRunner(ConnectionPool.getDataSource());  
6.         ResultSetHandler bean = new BeanListHandler(User.class);  
7.           
8.         @SuppressWarnings("unchecked")  
9.         List<User> list = (List<User>) query.query(conn, sql, bean);  
10.           
11.         for(User user:list){  
12.             System.out.println(user.getName());  
13.         }  
14.     }  
15. ..............  

值得一提的是，query有几种形式： 

Java代码  

1. query(Connection conn, String sql, ResultSetHandler rsh)   
2. query(Connection conn, String sql, ResultSetHandler rsh, Object[] params) query(String sql, ResultSetHandler rsh)   
3. query(String sql, ResultSetHandler rsh, Object[] params)   

如果需要加参数，只需要选择有参数的方法即可。当然对应的update方法与此方法完全类似，不毕多说。