DBUtils使用总结

Apache DBUtils使用总结

2010-01-26 14:33:07

标签： DBUtils Apache

原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处、作者信息和本声明。否则将追究法律责任。 http://lavasoft.blog.51cto.com/62575/270661

Apache DBUtils使用总结

DBUtils是个小巧的JDBC轻量级封装的工具包，其最核心的特性是结果集的封装，可以直接将查询出来的结果集封装成JavaBean，这就为我们做了最枯燥乏味、最容易出错的一大部分工作。

在使用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的引用”，但此处的主键不一定就是数据库的主键，可以随意指定，比如：

ResultSetHandler h = newKeyedHandler( "id");
Map found = (Map) queryRunner.query( "select id, name, age from person", h);
Map jane = (Map) found.get( newLong(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的灵活性。

6、对于JavaBean的成员类型定义，有一条原则那就是：尽可能使用包装类型，而不要使用基本类型。很多人不理解为什么，包括我见到一些傻B（，我提出让改为包装类型，他还信誓旦旦的说他的代码多牛多叼），都干好多年了，这个简单的道理还不知道:

//错误
int a1 = (Integer) null;
boolean x1 = (Boolean)null;
//正确
Integer a2 = (Integer) null;
Boolean x2 = (Boolean)null;

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

下面给出一个简单例子，作为以后写代码时候有点参考：

环境：

MySQL5.4

JDK1.5

建表SQL：

CREATE TABLEperson (
id bigint(20) NOT NULLAUTO_INCREMENT,
name varchar(24) DEFAULT NULL,
age int(11) DEFAULT NULL,
address varchar(120) DEFAULT NULL,
PRIMARY KEY(id)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULTCHARSET=gbk

Java代码：

public classPerson {
privateLong id;
privateString sdf;
privateString address2;
privateInteger age;

publicPerson() {
}

publicPerson(String sdf) {
this.sdf = sdf;
}

publicPerson(String sdf, Integer age, String address) {
this.sdf = sdf;
this.age = age;
this.address2 = address;
}

publicLong getId() {
returnid;
}

public voidsetId(Long id) {
this.id = id;
}

publicString getSdf() {
returnsdf;
}

public voidsetSdf(String sdf) {
this.sdf = sdf;
}

publicInteger getAge() {
returnage;
}

public voidsetAge(Integer age) {
this.age = age;
}

publicString getAddress() {
returnaddress2;
}

public voidsetAddress(String address2) {
this.address2 = address2;
}
}

测试

packagecom.lavasoft.dbstu;

importcom.lavasoft.common.DBToolkit;
importorg.apache.commons.dbutils.QueryRunner;
importorg.apache.commons.dbutils.handlers.BeanHandler;
importorg.apache.commons.dbutils.handlers.BeanListHandler;
importorg.apache.commons.dbutils.handlers.MapHandler;
importorg.apache.commons.dbutils.handlers.ScalarHandler;

importjava.sql.Connection;
importjava.sql.SQLException;
importjava.util.List;
importjava.util.Map;

/**
* Created by IntelliJ IDEA.
*
* @author leizhimin 2010-1-25 21:00:29
*/
public classPersonDAOImpl implementsPersonDAO {
private staticPersonDAOImpl instance = newPersonDAOImpl();

public staticPersonDAOImpl getInstance() {
returninstance;
}

public static voidmain(String[] args) {
//错误
inta1 = (Integer) null;
booleanx1 = (Boolean) null;
//正确
Integer a2 = (Integer) null;
Boolean x2 = (Boolean) null;

getInstance().save( null);
//getInstance().save(null);
//getInstance().save(null);
//getInstance().save(null);
//getInstance().save(null);
getInstance().update( null);
getInstance().load( null);
getInstance().load4Map( null);
}

@Override
publicLong save(String sql) {
Long id = null;
String ins_sql = "INSERT INTO person (NAME, age, address) VALUES ('aaa', 21, 'address001')";
Connection conn = DBToolkit.getConnection();
QueryRunner qr = newQueryRunner();
try{
qr.update(conn, ins_sql);
//获取新增记录的自增主键
id = (Long) qr.query(conn, "SELECT LAST_INSERT_ID()", newScalarHandler(1));
} catch(SQLException e) {
e.printStackTrace();
} finally{
DBToolkit.closeConnection(conn);
}
returnid;
}

@Override
public intdelete(Long id) {
intx = 0;
Connection conn = DBToolkit.getConnection();
QueryRunner qr = newQueryRunner();
try{
x = qr.update(conn, "DELETE FROM person WHERE id = ?", id);
} catch(SQLException e) {
e.printStackTrace();
} finally{
DBToolkit.closeConnection(conn);
}
returnx;
}

@Override
public intupdate(Person person) {
intx = 0;
Connection conn = DBToolkit.getConnection();
QueryRunner qr = newQueryRunner();
try{
x = qr.update(conn, "UPDATE person SET NAME = ?, age = ?, address = ? WHERE id = ?", "xxx", 23, "ttt", 5);
} catch(SQLException e) {
e.printStackTrace();
} finally{
DBToolkit.closeConnection(conn);
}
returnx;

}

@Override
publicPerson load(Long id) {
Connection conn = DBToolkit.getConnection();
QueryRunner qr = newQueryRunner();
try{
Person person = (Person) qr.query(conn, "SELECT * FROM person where id = ?", newBeanHandler(Person. class), 3L);
System.out.println(person.getId() + "/t"+ person.getSdf() + "/t"+ person.getAge() + "/t"+ person.getAddress());
} catch(SQLException e) {
e.printStackTrace();
}
return null;
}

@Override
publicList<Person> findPerson(String sql) {
Connection conn = DBToolkit.getConnection();
QueryRunner qr = newQueryRunner();
try{
List<Person> pset = (List) qr.query(conn, "SELECT * FROM person", newBeanListHandler(Person. class));
for(Person person : pset) {
System.out.println(person.getId() + "/t"+ person.getSdf() + "/t"+ person.getAge() + "/t"+ person.getAddress());
}
} catch(SQLException e) {
e.printStackTrace();
}
return null;
}

publicPerson load4Map(Long id) {
Connection conn = DBToolkit.getConnection();
QueryRunner qr = newQueryRunner();
try{
//先将两个字段置为null
qr.update(conn, "update person set age =null,address =nullwhere id =1");
Map<String, Object> map = qr.query(conn, "SELECT * FROM person where id = ?", newMapHandler(), 1L);
Person person = newPerson();
person.setId((Long) map.get( "id"));
person.setSdf((String) map.get( "name"));
person.setAge((Integer) map.get( "age"));
person.setAddress((String) map.get( "address"));
System.out.println(person.getId() + "/t"+ person.getSdf() + "/t"+ person.getAge() + "/t"+ person.getAddress());
} catch(SQLException e) {
e.printStackTrace();
}
return null;
}
}

注意：

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

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

如果你想看更多例子：

http://jzinfo.javaeye.com/blog/543929

本文出自 “熔 岩” 博客，请务必保留此出处http://lavasoft.blog.51cto.com/62575/270661

　附件下载：dbutilstest.rar

Dbutil 的使用示例

本文转载：http://2008ningli.blog.163.com/blog/static/3699023200983102416916/

Java代码

1. packagecn.lining.test;
3. importjava.sql.Connection;
4. importjava.sql.DriverManager;
5. importjava.sql.SQLException;
6. importjava.util.List;
7. importjava.util.Map;
9. importorg.apache.commons.dbutils.DbUtils;
10. importorg.apache.commons.dbutils.QueryRunner;
11. importorg.apache.commons.dbutils.handlers.ArrayHandler;
12. importorg.apache.commons.dbutils.handlers.ArrayListHandler;
13. importorg.apache.commons.dbutils.handlers.BeanHandler;
14. importorg.apache.commons.dbutils.handlers.BeanListHandler;
15. importorg.apache.commons.dbutils.handlers.ColumnListHandler;
16. importorg.apache.commons.dbutils.handlers.KeyedHandler;
17. importorg.apache.commons.dbutils.handlers.MapHandler;
18. importorg.apache.commons.dbutils.handlers.MapListHandler;
19. importorg.apache.commons.dbutils.handlers.ScalarHandler;
21. publicclasstest{
22. @SuppressWarnings("unchecked")
23. publicstaticvoidmain(String[]args)throwsClassNotFoundException{
25. UserFielduserField=newUserField();
27. Connectionconn=null;
28. StringjdbcURL="jdbc:mysql://localhost:3306/macaw4";
29. StringjdbcDriver="com.mysql.jdbc.Driver";
30. try{
31. DbUtils.loadDriver(jdbcDriver);
32. conn=DriverManager.getConnection(jdbcURL,"root","root");
33. conn.setAutoCommit(false);//关闭自动提交
34. QueryRunnerqRunner=newQueryRunner();
36. //以下部分代码采用MapHandler存储方式查询
37. System.out.println("***UsingMapHandler***");
38. Mapmap=(Map)qRunner.query(conn,
39. "select*frommc_user_fieldwhereid=?",
40. newMapHandler(),newObject[]{"5"});
42. System.out.println("id-------------name");
43. System.out.println(map.get("id")+"-------------"
44. +map.get("name"));
46. //以下部分代码采用MapListHandler存储方式查询
47. System.out.println("***UsingMapListHandler***");
48. ListlMap=(List)qRunner.query(conn,
49. "select*frommc_user_field",newMapListHandler());
51. System.out.println("id-------------name");
52. for(inti=0;i<lMap.size();i++){
53. Mapvals=(Map)lMap.get(i);
54. System.out.println(vals.get("id")+"-------------"
55. +vals.get("name"));
56. }
58. //以下部分代码采用BeanHandler存储方式查询
59. System.out.println("***UsingBeanHandler***");
60. userField=(UserField)qRunner.query(conn,
61. "select*frommc_user_fieldwhereid=?",
62. newBeanHandler(Class.forName("cn.lining.test.UserField")),
63. newObject[]{"5"});
64. System.out.println("id-------------name");
65. System.out.println(userField.getId()+"-------------"
66. +userField.getName());
68. //以下部分代码采用BeanListHandler存储方式查询
69. System.out.println("***UsingBeanListHandler***");
70. ListlBean=(List)qRunner.query(conn,
71. "select*frommc_user_field",newBeanListHandler(Class
72. .forName("cn.lining.test.UserField")));
73. System.out.println("id-------------name");
74. for(inti=0;i<lBean.size();i++){
75. userField=(UserField)lBean.get(i);
76. System.out.println(userField.getId()+"-------------"
77. +userField.getName());
78. }
80. //以下部分代码采用ArrayHandler存储方式查询
81. System.out.println("***UsingArrayHandler***");
82. Object[]array=(Object[])qRunner.query(conn,
83. "select*frommc_user_fieldwhereid=?",
84. newArrayHandler(),newObject[]{"5"});
86. System.out.println("id-------------name");
87. System.out.println(array[0].toString()+"-------------"
88. +array[1].toString());
90. //以下部分代码采用ArrayListHandler存储方式查询
91. System.out.println("***UsingArrayListHandler***");
92. ListlArray=(List)qRunner.query(conn,
93. "select*frommc_user_field",newArrayListHandler());
94. System.out.println("id-------------name");
95. for(inti=0;i<lArray.size();i++){
96. Object[]var=(Object[])lArray.get(i);
97. System.out.println(var[0].toString()+"-------------"
98. +var[1].toString());
99. }
101. //以下部分代码采用ColumnListHandler存储方式查询指定列
102. System.out.println("***UsingColumnListHandler***");
103. ListlName=(List)qRunner.query(conn,
104. "select*frommc_user_fieldwhereid=?",
105. newColumnListHandler("name"),newObject[]{"5"});
106. System.out.println("name");
107. for(inti=0;i<lName.size();i++){
108. Stringname=(String)lName.get(i);
109. System.out.println(name);
110. }
112. //以下部分代码采用ScalarHandler存储方式查询
113. System.out.println("***UsingScalarHandler***");
114. Stringname=(String)qRunner.query(conn,
115. "select*frommc_user_fieldwhereid=?",
116. newScalarHandler("name"),newObject[]{"5"});
118. System.out.println("name");
119. System.out.println(name);
121. //以下部分代码采用KeyedHandler存储方式查询
122. System.out.println("***UsingKeyedHandler***");
123. Map<String,Map>map2=(Map<String,Map>)qRunner.query(conn,
124. "select*frommc_user_field",newKeyedHandler("name"));
126. System.out.println("name:field_name2");
127. Mapvals=(Map)map2.get("field_name2");
128. System.out.println(vals.get("id")+""+vals.get("name")+""
129. +vals.get("type"));
131. //以下部分代码插入一条数据
132. System.out.println("***Insertbegin***");
133. userField=newUserField();
134. qRunner.update(conn,"insertintomc_user_field("
135. +"id,name,type,sort_order,required,visible)"
136. +"values(?,?,?,?,?,?)",newObject[]{userField.getId(),
137. userField.getName(),userField.getType(),
138. userField.getSort_order(),userField.getRequired(),
139. userField.getVisible()});
140. System.out.println("***updateend***");
142. //以下部分代码更新一条数据
143. System.out.println("***updatebegin***");
144. userField=newUserField();
145. qRunner.update(conn,"updatemc_user_fieldset"
146. +"name=?,type=?,sort_order=?,"
147. +"required=?,visible=?"+"whereid=?",
148. newObject[]{userField.getName(),userField.getType(),
149. userField.getSort_order(),userField.getRequired(),
150. userField.getVisible(),userField.getId()});
151. System.out.println("***updateend***");
153. //以下部分代码删除一条数据
154. System.out.println("***deletebegin***");
155. userField=newUserField();
156. qRunner.update(conn,"deletefrommc_user_fieldwhereid2=?",
157. newObject[]{userField.getId()});
158. System.out.println("***deleteend***");
160. }catch(SQLExceptionex){
161. ex.printStackTrace();
162. try{
163. System.out.println("***rollbackbegin***");
164. DbUtils.rollback(conn);
165. System.out.println("***rollbackend***");
166. }catch(SQLExceptione){
167. e.printStackTrace();
168. }
169. }finally{
170. DbUtils.closeQuietly(conn);
171. }
173. }
174. }

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

ScalarHandler：将结果集中某一条记录的其中某一列的数据存成Object。

---

---

common-utils的使用

默认分类2009-05-19 11:51:59阅读294评论0字号：大中小订阅

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。
*
*/