Apache的DBUtils使用详解

一、commons-dbutils简介　

　　commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。

1. org.apache.commons.dbutils （该包中的类主要帮助我们更便捷的操作JDBC）
2. org.apache.commons.dbutils.handlers（该包中的类都是实现org.apache.commons.dbutils.ResultSetHandler接口的实现类）
3. org.apache.commons.dbutils.wrappers（该包中的类主要是封装了对Sql结果集的操作）

二、QueryRunner类使用讲解

　　该类简单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。
　　QueryRunner类提供了两个构造方法：

• 默认的构造方法
• 需要一个 javax.sql.DataSource 来作参数的构造方法。

2.1、QueryRunner类的主要方法

　　public Object query(Connection conn, String sql, Object[] params, ResultSetHandler rsh) throws SQLException：执行一个查询操作，在这个查询中，对象数组中的每个元素值被用来作为查询语句的置换参数。该方法会自行处理 PreparedStatement 和 ResultSet 的创建和关闭。
　　public Object query(String sql, Object[] params, ResultSetHandler rsh) throws SQLException:　几乎与第一种方法一样；唯一的不同在于它不将数据库连接提供给方法，并且它是从提供给构造方法的数据源(DataSource) 或使用的setDataSource 方法中重新获得 Connection。
　　public Object query(Connection conn, String sql, ResultSetHandler rsh) throws SQLException : 执行一个不需要置换参数的查询操作。
　　public int update(Connection conn, String sql, Object[] params) throws SQLException:用来执行一个更新（插入、更新或删除）操作。
　　public int update(Connection conn, String sql) throws SQLException：用来执行一个不需要置换参数的更新操作。

2.2、使用QueryRunner类实现CRUD（增删查改）

以下使用SQLServer2008版数据库

[java]  view plain  copy

1. package org.apache.commons.dbutils;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.SQLException;  
6. import java.util.ArrayList;  
7.   
8. import javax.sql.DataSource;  
9.   
10. import org.apache.commons.dbutils.handlers.BeanHandler;  
11. import org.apache.commons.dbutils.handlers.BeanListHandler;  
12.   
13.   
14.   
15. /** 
16.  * 使用QueryRunner 类实现CRUD（create，read,update,delete） 
17.  * @author Administrator 
18.  * 
19.  */  
20. public class QueryRunnerTest {  
21.   
22.     /* 
23.      测试表 
24.      create table stuInfo 
25.     ( 
26.         stuNo int primary key identity (1,1),--学号 
27.         stuName nvarchar(10) not null,--学生姓名 
28.         stuSex nvarchar(2) not null,--学生性别 
29.         stuAge int not null,--学生年龄 
30.         stuSeat int not null,--学生座位 
31.         stuAddress nvarchar(20) --学生住址 
32.          
33.     )*/  
34.       
35.     public static void main(String[] args) {  
36.         QueryRunnerTest test = new QueryRunnerTest();  
37.         test.add();  
38.         test.delete();  
39.         test.update();  
40.         test.find();  
41.         test.getAll();  
42.   
43.     }  
44.       
45.     private static Connection getConnection() {  
46.         Connection conn = null;  
47.         try {  
48.             Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");  
49.             conn = DriverManager.getConnection("jdbc:sqlserver://localhost:1433;Database=student", "sa", "sasa");  
50.         } catch (SQLException e) {  
51.             // TODO Auto-generated catch block  
52.             e.printStackTrace();  
53.         } catch (ClassNotFoundException e) {  
54.             // TODO Auto-generated catch block  
55.             e.printStackTrace();  
56.         }  
57.         System.out.println(conn);  
58.         return conn;  
59.           
60.     }  
61.       
62.     //添加方法  
63.     public void add () {  
64.         Connection conn = getConnection();  
65.         QueryRunner qr = new QueryRunner();  
66.         String sql = "insert into stuInfo (stuName,stuSex,stuAge,stuSeat,stuAddress) values (?,?,?,?,?)";  
67.         Object param[] = {"张良","男",20,11,"韩国"};  
68.         int i;  
69.         try {  
70.             i = qr.update(conn, sql, param);  
71.             System.out.println("添加成功："+i);  
72.         } catch (SQLException e) {  
73.             // TODO Auto-generated catch block  
74.             e.printStackTrace();  
75.         }  
76.     }  
77.       
78.     //删除方法  
79.     public void delete() {  
80.         Connection conn = getConnection();  
81.         QueryRunner qr = new QueryRunner();  
82.         String sql ="delete from stuInfo where stuNo=?";  
83.         try {  
84.             int i = qr.update(conn, sql, 7);  
85.             System.out.println("删除成功："+i);  
86.         } catch (SQLException e) {  
87.             // TODO Auto-generated catch block  
88.             e.printStackTrace();  
89.         }  
90.     }  
91.       
92.     //修改方法  
93.     public void update() {  
94.         Connection conn = getConnection();  
95.         QueryRunner qr = new QueryRunner();  
96.         String sql = "update stuInfo set stuName=? where stuNo=?";  
97.         Object params[] = {"胡歌",3};  
98.         try {  
99.             int i = qr.update(conn, sql, params);  
100.             System.out.println("修改成功："+i);  
101.         } catch (SQLException e) {  
102.             // TODO Auto-generated catch block  
103.             e.printStackTrace();  
104.         }  
105.     }  
106.       
107.     //查询方法  
108.     public void find() {  
109.         Connection conn = getConnection();  
110.         QueryRunner qr = new QueryRunner();  
111.         String sql = "select * from stuInfo where stuNo=?";  
112.         Object params[] = {5};  
113.         try {  
114.             StuInfo stuInfo = (StuInfo)qr.query(conn, sql, new BeanHandler<StuInfo>(StuInfo.class), params);  
115.             System.out.println("查询成功："+stuInfo);  
116.         } catch (SQLException e) {  
117.             // TODO Auto-generated catch block  
118.             e.printStackTrace();  
119.         }  
120.     }  
121.       
122.     //查询所有  
123.     public void getAll() {  
124.         Connection conn = getConnection();  
125.         QueryRunner qr = new QueryRunner();  
126.         String sql ="select * from stuInfo";  
127.         ArrayList<StuInfo> list;  
128.         try {  
129.             list = (ArrayList<StuInfo>) qr.query(conn, sql, new BeanListHandler<StuInfo>(StuInfo.class));  
130.             for (StuInfo stuInfo : list) {  
131.                 System.out.println(stuInfo);  
132.             }  
133.         } catch (SQLException e) {  
134.             // TODO Auto-generated catch block  
135.             e.printStackTrace();  
136.         }  
137.           
138.     }  
139.       
140.       
141.       
142.       
143.       
144.       
145.   
146. }  

三、ResultSetHandler接口使用讲解

　　该接口用于处理java.sql.ResultSet，将数据按要求转换为另一种形式。
　　ResultSetHandler接口提供了一个单独的方法：Object handle (java.sql.ResultSet .rs)

3.1、ResultSetHandler接口的实现类

• ArrayHandler：把结果集中的第一行数据转成对象数组。
• ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
• BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
• BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
• ColumnListHandler：将结果集中某一列的数据存放到List中。
• KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里，再把这些map再存到一个map里，其key为指定的key。
• MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
• MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List

3.2、测试dbutils各种类型的处理器

JavaBean类

[java]  view plain  copy

1. package org.apache.commons.dbutils;  
2.   
3. public class StuInfo {  
4.     private String stuName;  
5.     private String stuSex;  
6.     private int stuAge;  
7.     private int stuSeat;  
8.     private String stuAddress;  
9.       
10.       
11.       
12.     public String getStuName() {  
13.         return stuName;  
14.     }  
15.     public void setStuName(String stuName) {  
16.         this.stuName = stuName;  
17.     }  
18.     public String getStuSex() {  
19.         return stuSex;  
20.     }  
21.     public void setStuSex(String stuSex) {  
22.         this.stuSex = stuSex;  
23.     }  
24.     public int getStuAge() {  
25.         return stuAge;  
26.     }  
27.     public void setStuAge(int stuAge) {  
28.         this.stuAge = stuAge;  
29.     }  
30.     public int getStuSeat() {  
31.         return stuSeat;  
32.     }  
33.     public void setStuSeat(int stuSeat) {  
34.         this.stuSeat = stuSeat;  
35.     }  
36.     public String getStuAddress() {  
37.         return stuAddress;  
38.     }  
39.     public void setStuAddress(String stuAddress) {  
40.         this.stuAddress = stuAddress;  
41.     }  
42.       
43.       
44.     //重写toString方法  
45.     //当需要将一个对象输出到显示器时,通常要调用他的toString()方法,将对象的内容转换为字符串.java中的所有类默认都有一个toString()方法  
46.     //默认情况下 System.out.println(对象名)或者System.out.println(对象名.toString())输出的是此对象的类名和此对象对应内存的首地址如果想自定义输出信息必须重写toString()方法  
47.     @Override  
48.     public String toString() {  
49.         // TODO Auto-generated method stub  
50.         return ("姓名："+stuName+"\n"+"年龄："+stuAge+";"+"性别："+stuSex+";"+"座位："+stuSeat+";"+"地址："+stuAddress);  
51.     }  
52.       
53.       
54.       
55.       
56.   
57. }  

各种结果集处理方法

[java]  view plain  copy

1. package org.apache.commons.dbutils;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.SQLException;  
6. import java.util.Arrays;  
7. import java.util.List;  
8. import java.util.Map;  
9.   
10. import org.apache.commons.dbutils.handlers.ArrayHandler;  
11. import org.apache.commons.dbutils.handlers.ArrayListHandler;  
12. import org.apache.commons.dbutils.handlers.BeanHandler;  
13. import org.apache.commons.dbutils.handlers.BeanListHandler;  
14. import org.apache.commons.dbutils.handlers.BeanMapHandler;  
15. import org.apache.commons.dbutils.handlers.ColumnListHandler;  
16. import org.apache.commons.dbutils.handlers.KeyedHandler;  
17. import org.apache.commons.dbutils.handlers.MapHandler;  
18. import org.apache.commons.dbutils.handlers.MapListHandler;  
19. import org.apache.commons.dbutils.handlers.ScalarHandler;  
20.   
21. /** 
22.  * Dbutils结果集实例 
23.  * 单行数据处理：ScalarHandler     ArrayHandler        MapHandler      BeanHandler 
24.  * 多行数据处理：BeanListHandler       AbstractkeyedHandler(KeyedHandler   BeanMapHandler) 
25.  *           AbstractListHandler(ArrayListHandler   MapListHandler  ColumnListHandler) 
26.  * 可供扩展的类：BaseResultSetHandler 
27.  * @author Administrator 
28.  * 
29.  */  
30. public class ResultSetHandlerTest {  
31.   
32.     public static void main(String[] args) {  
33.         // TODO Auto-generated method stub  
34.         ResultSetHandlerTest test = new ResultSetHandlerTest();  
35.         //test.testColumnListHandler();  
36.         test.testScalarHandler();  
37.         test.testColumnListHandler();  
38.         test.testArrayHandler();  
39.         test.testArrayListHandler();  
40.         test.testMapHandler();  
41.         test.testMapListHandler();  
42.         test.testKeyedHandler();  
43.         test.testBeanHandler();  
44.         test.testBeanListHandler();  
45.         test.testBeanMapHandler();  
46.   
47.     }  
48.       
49.     private static Connection getConnection() {  
50.         Connection conn = null;  
51.         try {  
52.             Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");  
53.             conn = DriverManager.getConnection("jdbc:sqlserver://localhost:1433;Database=student", "sa", "sasa");  
54.         } catch (SQLException e) {  
55.             // TODO Auto-generated catch block  
56.             e.printStackTrace();  
57.         } catch (ClassNotFoundException e) {  
58.             // TODO Auto-generated catch block  
59.             e.printStackTrace();  
60.         }  
61.         System.out.println(conn);  
62.         return conn;  
63.           
64.     }  
65.       
66.     //ScalarHandler<T>用于获取结果集中第一行某列的数据并转换成T表示的实际对象。（ 该类对结果集的处理直接在 handle 方法中进行，不涉及 dbutils 库的其他类）  
67.     public void testScalarHandler() {  
68.         Connection conn = getConnection();  
69.         QueryRunner qr = new QueryRunner();  
70.         String sql = "select * from stuInfo";  
71.           
72.         try {  
73.             //ScalarHandler的参数为空或null时，返回第一行第一列的数据  
74.             int i = qr.query(conn, sql, new ScalarHandler<Integer>());  
75.             System.out.println("Scalarhandler："+i);  
76.               
77.             //ScalarHandler的参数可以是列的索引（从1开始）或是列名  
78.             String name = qr.query(conn, sql, new ScalarHandler<String>(2));  
79.             System.out.println("学生姓名："+name);  
80.             String stuName = qr.query(conn, sql, new ScalarHandler<String>("stuName"));  
81.             System.out.println("stuName:"+stuName);  
82.         } catch (SQLException e) {  
83.             // TODO Auto-generated catch block  
84.             e.printStackTrace();  
85.         }  
86.     }  
87.       
88.     //ColumnListHandler<T>:根据列索引或列名获取结果集中某列的所有数据，并添加到ArrayList中。可以看成ScalarHandler<T>的加强版  
89.         public void testColumnListHandler() {  
90.             Connection conn = getConnection();  
91.             QueryRunner qr = new QueryRunner();  
92.             String sql = "select * from stuInfo";  
93.             try {  
94.                 List<String> list = (List) qr.query(conn, sql, new ColumnListHandler<String>("stuName"));  
95.                 //List<String> list = (List) qr.query(conn, sql, new ColumnListHandler<String>(2));  
96.                 for (String string : list) {  
97.                     System.out.println(string);  
98.                 }  
99.                 System.out.println(list);  
100.             } catch (SQLException e) {  
101.                 // TODO Auto-generated catch block  
102.                 e.printStackTrace();  
103.             }   
104.         }  
105.       
106.     //ArrayHandler：把结果集中的第一行数据转成对象数组(用于获取结果集中的第一行数据，并将其封装到数组中，一列值对应一个数组元素)  
107.     public void testArrayHandler() {  
108.         Connection conn = getConnection();  
109.         QueryRunner qr = new QueryRunner();  
110.         String sql = "select * from stuInfo";  
111.         try {  
112.             Object result[] = qr.query(conn, sql, new ArrayHandler());  
113.             System.out.println("ArrayHandler:"+Arrays.asList(result));  
114.             System.out.println("ArrayHandler:"+Arrays.toString(result));  
115.         } catch (SQLException e) {  
116.             // TODO Auto-generated catch block  
117.             e.printStackTrace();  
118.         }  
119.     }  
120.       
121.       
122.     //ArrayListHandler：把结果集中的每一行数据都转成一个Object数组(处理过程等同于ArrayHandler)，再将该数组添加到ArrayList中。  
123.     //简单点，就是将每行数据经ArrayHandler处理后，添加到ArrayListhandler中  
124.     public void testArrayListHandler() {  
125.         Connection conn = getConnection();  
126.         QueryRunner qr = new QueryRunner();  
127.         String sql = "select * from stuInfo";  
128.         try {  
129.             List<Object[]> list = (List) qr.query(conn, sql, new ArrayListHandler());  
130.             for (Object[] objects : list) {  
131.                 System.out.println(Arrays.asList(objects));  
132.                 System.out.println(Arrays.toString((Object[])objects));  
133.             }  
134.         } catch (SQLException e) {  
135.             // TODO Auto-generated catch block  
136.             e.printStackTrace();  
137.         }  
138.     }  
139.       
140.       
141.     //KeyedHandler：用于获取所有结果集，将每行结果集转换为Map<String,Object>,并指定某列为Key。  
142.     //可以简单认为是一个双层Map，相当于先对每行数据执行MapHandler，再为其指定Key添加到HashMap中.  
143.     //KeyedHadler<K>中的<K>是指定的列值得类型  
144.     public void testKeyedHandler() {  
145.         Connection conn = getConnection();  
146.         QueryRunner qr = new QueryRunner();  
147.         String sql = "select * from stuInfo";  
148.           
149.         try {  
150.             //在这里，指定主键stuNo为结果Key  
151.             //注意：也可指定其他列作为Key,如果选取的列值存在重复，则后面的会覆盖前面的，以保证HashMaP中Key值是唯一的   
152.             Map<Integer,Map> map = (Map)qr.query(conn, sql, new KeyedHandler("stuNo"));  
153.             //Map<Integer,Map> map = (Map)qr.query(conn, sql, new KeyedHandler(1));  
154.             for (Map.Entry<Integer, Map> element : map.entrySet()) {//entrySet()返回此映射中包含的映射关系的 Set 视图。  
155.                 int stuNo = element.getKey();  
156.                   
157.                 Map<String,Object> innermap = element.getValue();  
158.                 for (Map.Entry<String, Object> innerelement : innermap.entrySet()) {  
159.                     String columnName = innerelement.getKey();  
160.                     Object value = innerelement.getValue();  
161.                     System.out.println(columnName+"="+value);  
162.                     System.out.println("-------------------");  
163.                 }  
164.             }  
165.         } catch (SQLException e) {  
166.             // TODO Auto-generated catch block  
167.             e.printStackTrace();  
168.         }  
169.     }  
170.       
171.     //MapHandler:将结果集的第一行数据封装到一个Map里，Map中key是列名，value就是对应的值  
172.     public void testMapHandler() {  
173.         Connection conn = getConnection();  
174.         QueryRunner qr = new QueryRunner();  
175.         String sql = "select * from stuInfo";  
176.           
177.         try {  
178.             Map<String,Object> map = (Map)qr.query(conn, sql, new MapHandler());  
179.             for (Map.Entry<String, Object> me : map.entrySet()) {  
180.                 System.out.println(me.getKey()+"="+me.getValue());  
181.             }  
182.         } catch (SQLException e) {  
183.             // TODO Auto-generated catch block  
184.             e.printStackTrace();  
185.         }  
186.     }  
187.       
188.     //MapListHandler:将结果集每行数据转换为Map(处理结果等同于MapHandler),再将Map添加到ArrayList中  
189.     public void testMapListHandler() {  
190.         Connection conn = getConnection();  
191.         QueryRunner qr = new QueryRunner();  
192.         String sql = "select * from stuInfo";  
193.           
194.         try {  
195.             List<Map> list = (List)qr.query(conn, sql, new MapListHandler());  
196.             for (Map<String,Object> map : list) {  
197.                 System.out.println((Map<String,Object>) map);  
198.                 /*for (Map.Entry<String, Object> me : map.entrySet()) { 
199.                     System.out.println(me.getKey()+"="+me.getValue()); 
200.                 }*/  
201.             }  
202.         } catch (SQLException e) {  
203.             // TODO Auto-generated catch block  
204.             e.printStackTrace();  
205.         }  
206.     }  
207.       
208.     //BeanHandler<T>:将结果集的第一行数据封装到对应的JavaBean实例中  
209.     //注意：数据库中表中字段要和JavaBean中属性保持一致  
210.     public void testBeanHandler() {  
211.         Connection conn = getConnection();  
212.         QueryRunner qr = new QueryRunner();  
213.         String sql = "select * from stuInfo";  
214.           
215.         try {  
216.             StuInfo stuInfo = qr.query(conn, sql, new BeanHandler<StuInfo>(StuInfo.class));  
217.             System.out.println("BeanHandler:"+stuInfo);  
218.         } catch (SQLException e) {  
219.             // TODO Auto-generated catch block  
220.             e.printStackTrace();  
221.         }  
222.     }  
223.       
224.     //BeanListHandler<T>:用于将结果集的每一行数据转换为JavaBean，再将这个JavaBean添加到ArrayList中,可以看成BeanHandler的高级版  
225.     public void testBeanListHandler() {  
226.         Connection conn = getConnection();  
227.         QueryRunner qr = new QueryRunner();  
228.         String sql = "select * from stuInfo";  
229.           
230.         try {  
231.             List<StuInfo> list = (List)qr.query(conn, sql, new BeanListHandler<StuInfo>(StuInfo.class));  
232.             System.out.println("BeanListHandler:"+list);  
233.         } catch (SQLException e) {  
234.             // TODO Auto-generated catch block  
235.             e.printStackTrace();  
236.         }  
237.     }  
238.       
239.     //BeanMapHandler:用于获取所有结果集，将每行结果集转换为JavaBean作为value,并指定某列为Key,封装到HashMap中。  
240.     //相当于，对每行数据做BeanHandler一样的处理后，再指定列值为key封装到HashMap中。  
241.     public void testBeanMapHandler() {  
242.         Connection conn = getConnection();  
243.         QueryRunner qr = new QueryRunner();  
244.         String sql = "select * from stuInfo";  
245.           
246.         try {  
247.             Map<Integer,StuInfo> map = qr.query(conn, sql, new BeanMapHandler<Integer,StuInfo>(StuInfo.class, 1));  
248.             System.out.println("BeanMapHandler:"+map);  
249.         } catch (SQLException e) {  
250.             // TODO Auto-generated catch block  
251.             e.printStackTrace();  
252.         }  
253.     }  
254.   
255. }  

四、DbUtils类使用讲解

　　DbUtils ：提供如关闭连接、装载JDBC驱动程序等常规工作的工具类，里面的所有方法都是静态的。主要方法如下：
　　public static void close(…) throws java.sql.SQLException：　DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL，如果不是的话，它们就关闭Connection、Statement和ResultSet。
　　public static void closeQuietly(…): 这一类方法不仅能在Connection、Statement和ResultSet为NULL情况下避免关闭，还能隐藏一些在程序中抛出的SQLEeception。
　　public static void commitAndCloseQuietly(Connection conn)： 用来提交连接，然后关闭连接，并且在关闭连接时不抛出SQL异常。 
　　public static boolean loadDriver(java.lang.String driverClassName)：这一方装载并注册JDBC驱动程序，如果成功就返回true。使用该方法，你不需要捕捉这个异常ClassNotFoundException。