数据库DBUtils基本使用

Apache—DBUtils简介

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

org.apache.commons.dbutils.QueryRunner
org.apache.commons.dbutils.ResultSetHandler

工具类

org.apache.commons.dbutils.DbUtils

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：用来执行一个不需要置换参数的更新操作。

代码示例：

 1   @Test
 2     public void testQuery(){
 3 
 4         //2 使用期update方法
 5         String sql = "select * from t_user";
 6         Connection connection = null;
 7 
 8         try {
 9             connection = MysqlUtils.getConnection();
10             /**
11              * query方法的返回值取决于其ResultSetHandler参数的handle方法的返回值
12              */
13             List<User> list = queryRunner.query(connection, sql, new BeanListHandler<User>(User.class));
14             System.out.println(list.size());
15         } catch (SQLException e) {
16             e.printStackTrace();
17         }finally {
18             try {
19                 connection.close();
20             } catch (SQLException e) {
21                 e.printStackTrace();
22             }
23         }
24     }
25 
26     @Test
27     public void testUpdate(){
28 
29         //2 使用期update方法
30         String sql = "update t_user set password = ? where username = ?";
31         Connection connection = null;
32 
33         try {
34             connection = MysqlUtils.getConnection();
35             queryRunner.update(connection, sql,"cheng", "zhong");
36         } catch (SQLException e) {
37             e.printStackTrace();
38         }finally {
39             try {
40                 connection.close();
41             } catch (SQLException e) {
42                 e.printStackTrace();
43             }
44         }
45 
46     }

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

其中选择比较重要的做示例：

BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。

 1     /**
 2      * BeanHandler: 把结果集的第一条记录转为创建 BeanHandler 对象时传入的 Class
 3      * 参数对应的对象.
 4      */
 5     @Test
 6     public void testBeanHanlder(){
 7         Connection connection = null;
 8 
 9         try {
10             connection = MysqlUtils.getConnection();
11             String sql = "select * from t_user WHERE uid >= ?";
12 
13             User user = queryRunner.query(connection, sql, new BeanHandler<User>(User.class), 5);
14 
15             System.out.println(user.toString());
16         } catch (Exception e) {
17             e.printStackTrace();
18         } finally{
19             try {
20                 connection.close();
21             } catch (SQLException e) {
22                 e.printStackTrace();
23             }
24         }
25     }

BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。

 1   /**
 2      * BeanListHandler: 把结果集转为一个 List, 该 List 不为 null, 但可能为
 3      * 空集合(size() 方法返回 0)
 4      * 若 SQL 语句的确能够查询到记录, List 中存放创建 BeanListHandler 传入的 Class
 5      * 对象对应的对象.
 6      */
 7     @Test
 8     public void testBeanListHandler(){
 9         Connection connection = null;
10 
11         try {
12             connection = MysqlUtils.getConnection();
13             String sql = "select * from t_user";
14 
15             List<User> userList = queryRunner.query(connection,sql, new BeanListHandler<User>(User.class));
16 
17             System.out.println(userList);
18         } catch (Exception e) {
19             e.printStackTrace();
20         } finally{
21             try {
22                 connection.close();
23             } catch (SQLException e) {
24                 e.printStackTrace();
25             }
26         }
27     }

MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。

 1    /**
 2      * MapHandler: 返回 SQL 对应的第一条记录对应的 Map 对象.
 3      * 键: SQL 查询的列名(不是列的别名), 值: 列的值.
 4      */
 5     @Test
 6     public void testMapHandler(){
 7         Connection connection = null;
 8 
 9         try {
10             connection = MysqlUtils.getConnection();
11             String sql = "select * from t_user";
12 
13             Map<String, Object> result = queryRunner.query(connection,
14                     sql, new MapHandler());
15 
16             System.out.println(result);
17         } catch (Exception e) {
18             e.printStackTrace();
19         } finally{
20             try {
21                 connection.close();
22             } catch (SQLException e) {
23                 e.printStackTrace();
24             }
25         }
26     }

MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List

 1  /**
 2      * MapListHandler: 将结果集转为一个 Map 的 List
 3      * Map 对应查询的一条记录: 键: SQL 查询的列名(不是列的别名), 值: 列的值.
 4      * 而 MapListHandler: 返回的多条记录对应的 Map 的集合.
 5      */
 6     @Test
 7     public void testMapListHandler(){
 8         Connection connection = null;
 9 
10         try {
11             connection = MysqlUtils.getConnection();
12             String sql = "select * from t_user";
13 
14             List<Map<String, Object>> result = queryRunner.query(connection,
15                     sql, new MapListHandler());
16 
17             System.out.println(result);
18         } catch (Exception e) {
19             e.printStackTrace();
20         } finally{
21             try {
22                 connection.close();
23             } catch (SQLException e) {
24                 e.printStackTrace();
25             }
26         }
27     }