Apache DBUtils使用总结

1、DBUtils是JDBC的简单封装，可以和JDBC混合使用。

 

2、DBUtils对结果集自动封装为JavaBean是有着苛刻要求的：必须满足JavaBean的规范，其次Bean的getter与setter方法的名字与结果集的列名一一对应，而不要求JavaBean的私有成员与表结果集列名一一对应。

比如：

person表中有个字段叫：address，那么对应的JavaBean的Person类中必须有getAddress和setAddress两个方法，而Person类中可以将address属性命名为add，这是没问题的。

 

3、DBUtils可以将结果集封装为各种类型，主要有：Bean/List<Bean>，Map/List<Map>/Map<Map>，数组/List<数组>，列/List<列>，这些类型。

对于Map<Map>的类型使用KeyedHandler作为结果集处理器，内层的Map是“列名-值"对，外层的Map是“主键-内层Map的引用”，但此处的主键不一定就是数据库的主键，可以随意指定，比如：

new KeyedHandler( "id"); 
Map found = (Map) queryRunner.query( "select id, name, age from person", h); 
Map jane = (Map) found.get( new Long(1));  // jane's id is 1 
String janesName = (String) jane.get( "name"); 
Integer janesAge = (Integer) jane.get( "age");

 

4、DBUtils执行插入操作的时候，无法返回自增主键，这是一个很严重的问题，当然不能怪DBUtils，可以通过变通的方法来实现，比如在MySQL中，执行完了一个插入SQL后，接着执行SELECT LAST_INSERT_ID()语句，就可以获取到自增主键。

 

5、DBUtils的性能和JDBC性能是一样，测试过程中没发现性能损失，拥有了很高性能的同时，而不失JDBC的灵活性。

 

实际上就是为了保证在查询结果为null的时候，也不会因为给基本类型赋null值而发生错误。

 

实例：

package  cn.lining.test;

import  java.sql.Connection;
import  java.sql.DriverManager;
import  java.sql.SQLException;
import  java.util.List;
import  java.util.Map;

import  org.apache.commons.dbutils.DbUtils;
import  org.apache.commons.dbutils.QueryRunner;
import  org.apache.commons.dbutils.handlers.ArrayHandler;
import  org.apache.commons.dbutils.handlers.ArrayListHandler;
import  org.apache.commons.dbutils.handlers.BeanHandler;
import  org.apache.commons.dbutils.handlers.BeanListHandler;
import  org.apache.commons.dbutils.handlers.ColumnListHandler;
import  org.apache.commons.dbutils.handlers.KeyedHandler;
import  org.apache.commons.dbutils.handlers.MapHandler;
import  org.apache.commons.dbutils.handlers.MapListHandler;
import  org.apache.commons.dbutils.handlers.ScalarHandler;

public class  test {
@SuppressWarnings( " unchecked " )
public static void  main(String[] args)  throws  ClassNotFoundException {

UserField userField  = new  UserField();

Connection conn  = null ;
String jdbcURL  = " jdbc:mysql://localhost:3306/macaw4 " ;
String jdbcDriver  = " com.mysql.jdbc.Driver " ;
try  {
DbUtils.loadDriver(jdbcDriver);
conn  =  DriverManager.getConnection(jdbcURL,  " root " ,  " root " );
conn.setAutoCommit( false ); // 关闭自动提交
QueryRunner qRunner  = new  QueryRunner();

//  以下部分代码采用MapHandler存储方式查询
System.out.println( " ***Using MapHandler*** " );
Map map  =  (Map) qRunner.query(conn,
" select * from mc_user_field where id = ? " ,
new  MapHandler(),  new  Object[] {  " 5 "  });

System.out.println( " id ------------- name  " );
System.out.println(map.get( " id " )  + "  -------------  "
+  map.get( " name " ));

//  以下部分代码采用MapListHandler存储方式查询
System.out.println( " ***Using MapListHandler*** " );
List lMap  =  (List) qRunner.query(conn,
" select * from mc_user_field " ,  new  MapListHandler());

System.out.println( " id ------------- name  " );
for  ( int  i  = 0 ; i  <  lMap.size(); i ++ ) {
Map vals  =  (Map) lMap.get(i);
System.out.println(vals.get( " id " )  + "  -------------  "
+  vals.get( " name " ));
}

//  以下部分代码采用BeanHandler存储方式查询
System.out.println( " ***Using BeanHandler*** " );
userField  =  (UserField) qRunner.query(conn,
" select * from mc_user_field where id = ? " ,
new  BeanHandler(Class.forName( " cn.lining.test.UserField " )),
new  Object[] {  " 5 "  });
System.out.println( " id ------------- name  " );
System.out.println(userField.getId()  + "  -------------  "
+  userField.getName());

//  以下部分代码采用BeanListHandler存储方式查询
System.out.println( " ***Using BeanListHandler*** " );
List lBean  =  (List) qRunner.query(conn,
" select * from mc_user_field " ,  new  BeanListHandler(Class
.forName( " cn.lining.test.UserField " )));
System.out.println( " id ------------- name  " );
for  ( int  i  = 0 ; i  <  lBean.size(); i ++ ) {
userField  =  (UserField) lBean.get(i);
System.out.println(userField.getId()  + "  -------------  "
+  userField.getName());
}

//  以下部分代码采用ArrayHandler存储方式查询
System.out.println( " ***Using ArrayHandler*** " );
Object[] array  =  (Object[]) qRunner.query(conn,
" select * from mc_user_field where id = ? " ,
new  ArrayHandler(),  new  Object[] {  " 5 "  });

System.out.println( " id ------------- name  " );
System.out.println(array[ 0 ].toString()  + "  -------------  "
+  array[ 1 ].toString());

//  以下部分代码采用ArrayListHandler存储方式查询
System.out.println( " ***Using ArrayListHandler*** " );
List lArray  =  (List) qRunner.query(conn,
" select * from mc_user_field " ,  new  ArrayListHandler());
System.out.println( " id ------------- name  " );
for  ( int  i  = 0 ; i  <  lArray.size(); i ++ ) {
Object[] var  =  (Object[]) lArray.get(i);
System.out.println(var[ 0 ].toString()  + "  -------------  "
+  var[ 1 ].toString());
}

//  以下部分代码采用ColumnListHandler存储方式查询指定列
System.out.println( " ***Using ColumnListHandler*** " );
List lName  =  (List) qRunner.query(conn,
" select * from mc_user_field where id = ? " ,
new  ColumnListHandler( " name " ),  new  Object[] {  " 5 "  });
System.out.println( " name  " );
for  ( int  i  = 0 ; i  <  lName.size(); i ++ ) {
String name  =  (String) lName.get(i);
System.out.println(name);
}

//  以下部分代码采用ScalarHandler存储方式查询
System.out.println( " ***Using ScalarHandler*** " );
String name  =  (String) qRunner.query(conn,
" select * from mc_user_field where id = ? " ,
new  ScalarHandler( " name " ),  new  Object[] {  " 5 "  });

System.out.println( " name  " );
System.out.println(name);

//  以下部分代码采用KeyedHandler存储方式查询
System.out.println( " ***Using KeyedHandler*** " );
Map < String, Map >  map2  =  (Map < String, Map > ) qRunner.query(conn,
" select * from mc_user_field " ,  new  KeyedHandler( " name " ));

System.out.println( " name: field_name2 " );
Map vals  =  (Map) map2.get( " field_name2 " );
System.out.println(vals.get( " id " )  + " " +  vals.get( " name " )  + " "
+  vals.get( " type " ));

//  以下部分代码插入一条数据
System.out.println( " ***Insert begin*** " );
userField  = new  UserField();
qRunner.update(conn,  " insert into mc_user_field ( "
+ " id,name,type,sort_order,required,visible) "
+ " values (?,?,?,?,?,?) " ,  new  Object[] { userField.getId(),
userField.getName(), userField.getType(),
userField.getSort_order(), userField.getRequired(),
userField.getVisible() });
System.out.println( " ***update end*** " );

//  以下部分代码更新一条数据
System.out.println( " ***update begin*** " );
userField  = new  UserField();
qRunner.update(conn,  " update mc_user_field set  "
+ " name = ?,type = ?,sort_order = ?, "
+ " required = ?,visible = ? " + " where id = ? " ,
new  Object[] { userField.getName(), userField.getType(),
userField.getSort_order(), userField.getRequired(),
userField.getVisible(), userField.getId() });
System.out.println( " ***update end*** " );

//  以下部分代码删除一条数据
System.out.println( " ***delete begin*** " );
userField  = new  UserField();
qRunner.update(conn,  " delete from mc_user_field where id2 = ? " ,
new  Object[] { userField.getId() });
System.out.println( " ***delete end*** " );

}  catch  (SQLException ex) {
ex.printStackTrace();
try  {
System.out.println( " ***rollback begin*** " );
DbUtils.rollback(conn);
System.out.println( " ***rollback end*** " );
}  catch  (SQLException e) {
e.printStackTrace();
}
}  finally  {
DbUtils.closeQuietly(conn);
}

}
}

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

从上面的过程看，每个SQL的执行都需要用到QueryRunner，这其实是一个普通的类，非线程安全。在创建这个QueryRunner对象的时候，每次都要new。

 

QueryRunner对象的创建方式很多，可以通过DateSource，也可以通过Connection来创建。从QueryRunner对象上，可以直接获取到DataSource或者Connection对象。