DBUtils使用详细示例
2013-09-30 10:14
423 查看
package com.exam.test;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import junit.framework.TestCase;
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.ColumnListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import com.exam.db.DbManager;
import com.exam.util.BasicRowProcessorEx;
public class TestSomething extends TestCase {
public void testDBUtilSelect() {
Connection conn = DbManager.getInstance().getConnection();
QueryRunner queryRunner = new QueryRunner();
try {
// 返回单行记录，使用Map
System.out.println("使用Map处理单行记录！");
Map<String, Object> map = queryRunner.query(conn,
"select * from tab where rownum=1", new MapHandler(),
(Object[]) null);
for (Iterator<Entry<String, Object>> i = map.entrySet().iterator(); i
.hasNext();) {
Entry<String, Object> e = i.next();
System.out.println(e.getKey() + "=" + e.getValue());
}
System.out.println("处理多行记录！");
List<Map<String, Object>> list = queryRunner.query(conn,
"select * from tab where rownum<=3", new MapListHandler(),
(Object[]) null);
for (Iterator<Map<String, Object>> li = list.iterator(); li
.hasNext();) {
System.out.println("--------------");
Map<String, Object> m = li.next();
for (Iterator<Entry<String, Object>> mi = m.entrySet()
.iterator(); mi.hasNext();) {
Entry<String, Object> e = mi.next();
System.out.println(e.getKey() + "=" + e.getValue());
}
}
System.out.println("使用Bean处理单行记录！");
// com.exam.test.TestSomething.Tab
Tab tab = queryRunner.query(conn,
"select tname from tab where rownum=1",
new BeanHandler<Tab>(Tab.class));
System.out.println("tname=" + tab.getTname());
System.out.println("tabtype=" + tab.getTabtype());
System.out.println("使用Array处理单行记录！");
Object[] array = queryRunner.query(conn,
"select * from tab where rownum=1", new ArrayHandler());
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("使用Array处理多行记录！");
List<Object[]> arraylist = queryRunner
.query(conn, "select * from tab where rownum<=3",
new ArrayListHandler());
for (Iterator<Object[]> itr = arraylist.iterator(); itr.hasNext();) {
Object[] a = itr.next();
System.out.println("--------------");
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
System.out.println("使用ColumnListHandler处理单行记录，返回其中指定的一列！");
List<Object> colList = queryRunner.query(conn,
"select * from tab where rownum=1", new ColumnListHandler(
"tname"));
for (Iterator<Object> itr = colList.iterator(); itr.hasNext();) {
System.out.println(itr.next());
}
System.out
.println("使用ScalarHandler处理单行记录，只返回结果集第一行中的指定字段，如未指定字段，则返回第一个字段！");
Object scalar1 = queryRunner.query(conn, "select * from tab",
new ScalarHandler("tname"));
System.out.println(scalar1);
Object scalar2 = queryRunner.query(conn,
"select tname,tabtype from tab", new ScalarHandler());
System.out.println(scalar2);
// 使用自定义的行处理器
// Map中的KEY可按输入顺序输出
System.out.println("使用Map处理单行记录(使用自定义行处理器)！");
Map<String, Object> linkedmap = queryRunner
.query(
conn,
"select tabtype,tname,'wallimn' as programmer from tab where rownum=1",
new MapHandler(new BasicRowProcessorEx()),
(Object[]) null);
for (Iterator<Entry<String, Object>> i = linkedmap.entrySet()
.iterator(); i.hasNext();) {
Entry<String, Object> e = i.next();
System.out.println(e.getKey() + "=" + e.getValue());
}
// 使用自定义的行处理器
// Map中的KEY可按输入顺序输出
System.out.println("处理多行记录(使用自定义行处理器)！");
List<Map<String, Object>> listLinedMap = queryRunner
.query(
conn,
"select tabtype,tname,'wallimn' as programmer from tab where rownum<=3",
new MapListHandler(new BasicRowProcessorEx()),
(Object[]) null);
for (Iterator<Map<String, Object>> li = listLinedMap.iterator(); li
.hasNext();) {
System.out.println("--------------");
Map<String, Object> m = li.next();
for (Iterator<Entry<String, Object>> mi = m.entrySet()
.iterator(); mi.hasNext();) {
Entry<String, Object> e = mi.next();
System.out.println(e.getKey() + "=" + e.getValue());
}
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
DbUtils.closeQuietly(conn);
}
public void testDBUtilInsertDeleteUpdateSelect() {
// 建一个简单的测试表，建表脚本如下
// create table T_DBUTILTEST(
// id integer,
// name varchar2(255)
// );
Connection conn = DbManager.getInstance().getConnection();
QueryRunner queryRunner = new QueryRunner(true);
try {
queryRunner.update(conn, "delete from T_DBUTILTEST");
// queryRunner.update(conn, "truncate table T_DBUTILTEST");
// 插一条
for (int i = 0; i < 10; i++) {
queryRunner.update(conn,
"insert into T_DBUTILTEST (id,name) values (?,?)", i,
"http://wallimn.iteye.com");
}
// 再插多条
queryRunner.batch(conn,
"insert into T_DBUTILTEST (id,name) values (?,?)",
new Object[][] { { 11, "batch:wallimn@sohu.com" },
{ 12, "batch:wallimn@sohu.com" } });
// 删除示例
queryRunner.update(conn, "delete from T_DBUTILTEST where id=1");
queryRunner.update(conn, "delete from T_DBUTILTEST where id=?", 2);
queryRunner.batch(conn, "delete from T_DBUTILTEST where id=?",
new Object[][] { { 3 }, { 4 } });
// 修改示例
queryRunner.update(conn,
"update T_DBUTILTEST set name = ? where id=?", "修改后的新值", 5);
System.out.println("最终结果显示结果");
List<Map<String, Object>> list = queryRunner.query(conn,
"select name,id from T_DBUTILTEST", new MapListHandler(),
(Object[]) null);
for (Iterator<Map<String, Object>> li = list.iterator(); li
.hasNext();) {
System.out.println("--------------");
Map<String, Object> m = li.next();
for (Iterator<Entry<String, Object>> mi = m.entrySet()
.iterator(); mi.hasNext();) {
Entry<String, Object> e = mi.next();
System.out.print(e.getValue());
System.out.print(",");
}
System.out.println();
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
DbUtils.closeQuietly(conn);
}
}
二、自定义扩展
如果用户想要依照存入Map的顺序显示内容，好像不能直接支持。看了看源码，自定义了一个扩展类。用法在前的代码中有示例。
package com.exam.util;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.commons.dbutils.BasicRowProcessor;
/**
* 用于apache的dbutil类的功能改进，当需要Map中的Key能按输入的顺序输出时，使用这个类来进行处理。简单改了一下基类。<br/>
* 编码：wallimn 时间：2012-7-25 上午11:07:06<br/>
* 版本：V1.0<br/>
*/
public class BasicRowProcessorEx extends BasicRowProcessor {
private static class CaseInsensitiveLinkedHashMap extends HashMap<String, Object> {
private final Map<String, String> lowerCaseMap = new LinkedHashMap<String, String>();
private static final long serialVersionUID = -2848100435296897392L;
/** {@inheritDoc} */
@Override
public boolean containsKey(Object key) {
Object realKey = lowerCaseMap.get(key.toString().toLowerCase());
return super.containsKey(realKey);
}
/** {@inheritDoc} */
@Override
public Object get(Object key) {
Object realKey = lowerCaseMap.get(key.toString().toLowerCase());
return super.get(realKey);
}
/** {@inheritDoc} */
@Override
public Object put(String key, Object value) {
Object oldKey = lowerCaseMap.put(key.toLowerCase(), key);
Object oldValue = super.remove(oldKey);
super.put(key, value);
return oldValue;
}
/** {@inheritDoc} */
@Override
public void putAll(Map<? extends String, ?> m) {
for (Map.Entry<? extends String, ?> entry : m.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
this.put(key, value);
}
}
/** {@inheritDoc} */
@Override
public Object remove(Object key) {
Object realKey = lowerCaseMap.remove(key.toString().toLowerCase());
return super.remove(realKey);
}
}
@Override
public Map<String, Object> toMap(ResultSet rs) throws SQLException {
Map<String, Object> result = new CaseInsensitiveLinkedHashMap();
ResultSetMetaData rsmd = rs.getMetaData();
int cols = rsmd.getColumnCount();
for (int i = 1; i <= cols; i++) {
result.put(rsmd.getColumnName(i), rs.getObject(i));
}
return result;
}
}
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Apache DBUtils使用总结
[align=center]Apache DBUtils使用总结[/align]
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 = 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的灵活性。
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 TABLE person (
id bigint(20)
NOT NULL AUTO_INCREMENT,
name varchar(24)
DEFAULT NULL,
age int(11) DEFAULT
NULL,
address varchar(120)
DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=gbk
Java代码：
public class Person {
private Long id;
private String sdf;
private String address2;
private Integer age;
public Person() {
}
public Person(String sdf) {
this.sdf = sdf;
}
public Person(String sdf, Integer age, String address) {
this.sdf = sdf;
this.age = age;
this.address2 = address;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getSdf() {
return sdf;
}
public void setSdf(String sdf) {
this.sdf = sdf;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getAddress() {
return address2;
}
public void setAddress(String address2) {
this.address2 = address2;
}
}
测试
package com.lavasoft.dbstu;
import com.lavasoft.common.DBToolkit;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
/**
* Created by IntelliJ IDEA.
*
* @author leizhimin 2010-1-25 21:00:29
*/
public class PersonDAOImpl
implements PersonDAO {
private static PersonDAOImpl instance =
new PersonDAOImpl();
public static PersonDAOImpl getInstance() {
return instance;
}
public static
void main(String[] args) {
//错误
int a1 = (Integer)
null;
boolean x1 = (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
public Long 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 = new QueryRunner();
try {
qr.update(conn, ins_sql);
//获取新增记录的自增主键
id = (Long) qr.query(conn, "SELECT LAST_INSERT_ID()",
new ScalarHandler(1));
} catch (SQLException e) {
e.printStackTrace();
} finally {
DBToolkit.closeConnection(conn);
}
return id;
}
@Override
public int delete(Long id) {
int x = 0;
Connection conn = DBToolkit.getConnection();
QueryRunner qr = new QueryRunner();
try {
x = qr.update(conn, "DELETE FROM person WHERE id = ?", id);
} catch (SQLException e) {
e.printStackTrace();
} finally {
DBToolkit.closeConnection(conn);
}
return x;
}
@Override
public int update(Person person) {
int x = 0;
Connection conn = DBToolkit.getConnection();
QueryRunner qr = new QueryRunner();
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);
}
return x;
}
@Override
public Person load(Long id) {
Connection conn = DBToolkit.getConnection();
QueryRunner qr = new QueryRunner();
try {
Person person = (Person) qr.query(conn,
"SELECT * FROM person where id = ?", new BeanHandler(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
public List<Person> findPerson(String sql) {
Connection conn = DBToolkit.getConnection();
QueryRunner qr = new QueryRunner();
try {
List<Person> pset = (List) qr.query(conn,
"SELECT * FROM person", new BeanListHandler(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;
}
public Person load4Map(Long id) {
Connection conn = DBToolkit.getConnection();
QueryRunner qr = new QueryRunner();
try {
//先将两个字段置为null
qr.update(conn, "update person set age =
null,address =null where id =1");
Map<String, Object> map = qr.query(conn,
"SELECT * FROM person where id = ?", new MapHandler(), 1L);
Person person = new Person();
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
本文出自 “熔 岩” 博客，请务必保留此出处/article/4231734.html
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import junit.framework.TestCase;
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.ColumnListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import com.exam.db.DbManager;
import com.exam.util.BasicRowProcessorEx;
public class TestSomething extends TestCase {
public void testDBUtilSelect() {
Connection conn = DbManager.getInstance().getConnection();
QueryRunner queryRunner = new QueryRunner();
try {
// 返回单行记录，使用Map
System.out.println("使用Map处理单行记录！");
Map<String, Object> map = queryRunner.query(conn,
"select * from tab where rownum=1", new MapHandler(),
(Object[]) null);
for (Iterator<Entry<String, Object>> i = map.entrySet().iterator(); i
.hasNext();) {
Entry<String, Object> e = i.next();
System.out.println(e.getKey() + "=" + e.getValue());
}
System.out.println("处理多行记录！");
List<Map<String, Object>> list = queryRunner.query(conn,
"select * from tab where rownum<=3", new MapListHandler(),
(Object[]) null);
for (Iterator<Map<String, Object>> li = list.iterator(); li
.hasNext();) {
System.out.println("--------------");
Map<String, Object> m = li.next();
for (Iterator<Entry<String, Object>> mi = m.entrySet()
.iterator(); mi.hasNext();) {
Entry<String, Object> e = mi.next();
System.out.println(e.getKey() + "=" + e.getValue());
}
}
System.out.println("使用Bean处理单行记录！");
// com.exam.test.TestSomething.Tab
Tab tab = queryRunner.query(conn,
"select tname from tab where rownum=1",
new BeanHandler<Tab>(Tab.class));
System.out.println("tname=" + tab.getTname());
System.out.println("tabtype=" + tab.getTabtype());
System.out.println("使用Array处理单行记录！");
Object[] array = queryRunner.query(conn,
"select * from tab where rownum=1", new ArrayHandler());
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("使用Array处理多行记录！");
List<Object[]> arraylist = queryRunner
.query(conn, "select * from tab where rownum<=3",
new ArrayListHandler());
for (Iterator<Object[]> itr = arraylist.iterator(); itr.hasNext();) {
Object[] a = itr.next();
System.out.println("--------------");
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
System.out.println("使用ColumnListHandler处理单行记录，返回其中指定的一列！");
List<Object> colList = queryRunner.query(conn,
"select * from tab where rownum=1", new ColumnListHandler(
"tname"));
for (Iterator<Object> itr = colList.iterator(); itr.hasNext();) {
System.out.println(itr.next());
}
System.out
.println("使用ScalarHandler处理单行记录，只返回结果集第一行中的指定字段，如未指定字段，则返回第一个字段！");
Object scalar1 = queryRunner.query(conn, "select * from tab",
new ScalarHandler("tname"));
System.out.println(scalar1);
Object scalar2 = queryRunner.query(conn,
"select tname,tabtype from tab", new ScalarHandler());
System.out.println(scalar2);
// 使用自定义的行处理器
// Map中的KEY可按输入顺序输出
System.out.println("使用Map处理单行记录(使用自定义行处理器)！");
Map<String, Object> linkedmap = queryRunner
.query(
conn,
"select tabtype,tname,'wallimn' as programmer from tab where rownum=1",
new MapHandler(new BasicRowProcessorEx()),
(Object[]) null);
for (Iterator<Entry<String, Object>> i = linkedmap.entrySet()
.iterator(); i.hasNext();) {
Entry<String, Object> e = i.next();
System.out.println(e.getKey() + "=" + e.getValue());
}
// 使用自定义的行处理器
// Map中的KEY可按输入顺序输出
System.out.println("处理多行记录(使用自定义行处理器)！");
List<Map<String, Object>> listLinedMap = queryRunner
.query(
conn,
"select tabtype,tname,'wallimn' as programmer from tab where rownum<=3",
new MapListHandler(new BasicRowProcessorEx()),
(Object[]) null);
for (Iterator<Map<String, Object>> li = listLinedMap.iterator(); li
.hasNext();) {
System.out.println("--------------");
Map<String, Object> m = li.next();
for (Iterator<Entry<String, Object>> mi = m.entrySet()
.iterator(); mi.hasNext();) {
Entry<String, Object> e = mi.next();
System.out.println(e.getKey() + "=" + e.getValue());
}
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
DbUtils.closeQuietly(conn);
}
public void testDBUtilInsertDeleteUpdateSelect() {
// 建一个简单的测试表，建表脚本如下
// create table T_DBUTILTEST(
// id integer,
// name varchar2(255)
// );
Connection conn = DbManager.getInstance().getConnection();
QueryRunner queryRunner = new QueryRunner(true);
try {
queryRunner.update(conn, "delete from T_DBUTILTEST");
// queryRunner.update(conn, "truncate table T_DBUTILTEST");
// 插一条
for (int i = 0; i < 10; i++) {
queryRunner.update(conn,
"insert into T_DBUTILTEST (id,name) values (?,?)", i,
"http://wallimn.iteye.com");
}
// 再插多条
queryRunner.batch(conn,
"insert into T_DBUTILTEST (id,name) values (?,?)",
new Object[][] { { 11, "batch:wallimn@sohu.com" },
{ 12, "batch:wallimn@sohu.com" } });
// 删除示例
queryRunner.update(conn, "delete from T_DBUTILTEST where id=1");
queryRunner.update(conn, "delete from T_DBUTILTEST where id=?", 2);
queryRunner.batch(conn, "delete from T_DBUTILTEST where id=?",
new Object[][] { { 3 }, { 4 } });
// 修改示例
queryRunner.update(conn,
"update T_DBUTILTEST set name = ? where id=?", "修改后的新值", 5);
System.out.println("最终结果显示结果");
List<Map<String, Object>> list = queryRunner.query(conn,
"select name,id from T_DBUTILTEST", new MapListHandler(),
(Object[]) null);
for (Iterator<Map<String, Object>> li = list.iterator(); li
.hasNext();) {
System.out.println("--------------");
Map<String, Object> m = li.next();
for (Iterator<Entry<String, Object>> mi = m.entrySet()
.iterator(); mi.hasNext();) {
Entry<String, Object> e = mi.next();
System.out.print(e.getValue());
System.out.print(",");
}
System.out.println();
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
DbUtils.closeQuietly(conn);
}
}
二、自定义扩展
如果用户想要依照存入Map的顺序显示内容，好像不能直接支持。看了看源码，自定义了一个扩展类。用法在前的代码中有示例。
package com.exam.util;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.commons.dbutils.BasicRowProcessor;
/**
* 用于apache的dbutil类的功能改进，当需要Map中的Key能按输入的顺序输出时，使用这个类来进行处理。简单改了一下基类。<br/>
* 编码：wallimn 时间：2012-7-25 上午11:07:06<br/>
* 版本：V1.0<br/>
*/
public class BasicRowProcessorEx extends BasicRowProcessor {
private static class CaseInsensitiveLinkedHashMap extends HashMap<String, Object> {
private final Map<String, String> lowerCaseMap = new LinkedHashMap<String, String>();
private static final long serialVersionUID = -2848100435296897392L;
/** {@inheritDoc} */
@Override
public boolean containsKey(Object key) {
Object realKey = lowerCaseMap.get(key.toString().toLowerCase());
return super.containsKey(realKey);
}
/** {@inheritDoc} */
@Override
public Object get(Object key) {
Object realKey = lowerCaseMap.get(key.toString().toLowerCase());
return super.get(realKey);
}
/** {@inheritDoc} */
@Override
public Object put(String key, Object value) {
Object oldKey = lowerCaseMap.put(key.toLowerCase(), key);
Object oldValue = super.remove(oldKey);
super.put(key, value);
return oldValue;
}
/** {@inheritDoc} */
@Override
public void putAll(Map<? extends String, ?> m) {
for (Map.Entry<? extends String, ?> entry : m.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
this.put(key, value);
}
}
/** {@inheritDoc} */
@Override
public Object remove(Object key) {
Object realKey = lowerCaseMap.remove(key.toString().toLowerCase());
return super.remove(realKey);
}
}
@Override
public Map<String, Object> toMap(ResultSet rs) throws SQLException {
Map<String, Object> result = new CaseInsensitiveLinkedHashMap();
ResultSetMetaData rsmd = rs.getMetaData();
int cols = rsmd.getColumnCount();
for (int i = 1; i <= cols; i++) {
result.put(rsmd.getColumnName(i), rs.getObject(i));
}
return result;
}
}
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Apache DBUtils使用总结
[align=center]Apache DBUtils使用总结[/align]
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 = 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的灵活性。
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 TABLE person (
id bigint(20)
NOT NULL AUTO_INCREMENT,
name varchar(24)
DEFAULT NULL,
age int(11) DEFAULT
NULL,
address varchar(120)
DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=gbk
Java代码：
public class Person {
private Long id;
private String sdf;
private String address2;
private Integer age;
public Person() {
}
public Person(String sdf) {
this.sdf = sdf;
}
public Person(String sdf, Integer age, String address) {
this.sdf = sdf;
this.age = age;
this.address2 = address;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getSdf() {
return sdf;
}
public void setSdf(String sdf) {
this.sdf = sdf;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getAddress() {
return address2;
}
public void setAddress(String address2) {
this.address2 = address2;
}
}
测试
package com.lavasoft.dbstu;
import com.lavasoft.common.DBToolkit;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
/**
* Created by IntelliJ IDEA.
*
* @author leizhimin 2010-1-25 21:00:29
*/
public class PersonDAOImpl
implements PersonDAO {
private static PersonDAOImpl instance =
new PersonDAOImpl();
public static PersonDAOImpl getInstance() {
return instance;
}
public static
void main(String[] args) {
//错误
int a1 = (Integer)
null;
boolean x1 = (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
public Long 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 = new QueryRunner();
try {
qr.update(conn, ins_sql);
//获取新增记录的自增主键
id = (Long) qr.query(conn, "SELECT LAST_INSERT_ID()",
new ScalarHandler(1));
} catch (SQLException e) {
e.printStackTrace();
} finally {
DBToolkit.closeConnection(conn);
}
return id;
}
@Override
public int delete(Long id) {
int x = 0;
Connection conn = DBToolkit.getConnection();
QueryRunner qr = new QueryRunner();
try {
x = qr.update(conn, "DELETE FROM person WHERE id = ?", id);
} catch (SQLException e) {
e.printStackTrace();
} finally {
DBToolkit.closeConnection(conn);
}
return x;
}
@Override
public int update(Person person) {
int x = 0;
Connection conn = DBToolkit.getConnection();
QueryRunner qr = new QueryRunner();
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);
}
return x;
}
@Override
public Person load(Long id) {
Connection conn = DBToolkit.getConnection();
QueryRunner qr = new QueryRunner();
try {
Person person = (Person) qr.query(conn,
"SELECT * FROM person where id = ?", new BeanHandler(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
public List<Person> findPerson(String sql) {
Connection conn = DBToolkit.getConnection();
QueryRunner qr = new QueryRunner();
try {
List<Person> pset = (List) qr.query(conn,
"SELECT * FROM person", new BeanListHandler(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;
}
public Person load4Map(Long id) {
Connection conn = DBToolkit.getConnection();
QueryRunner qr = new QueryRunner();
try {
//先将两个字段置为null
qr.update(conn, "update person set age =
null,address =null where id =1");
Map<String, Object> map = qr.query(conn,
"SELECT * FROM person where id = ?", new MapHandler(), 1L);
Person person = new Person();
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
本文出自 “熔 岩” 博客，请务必保留此出处/article/4231734.html
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- DBUtils使用详细示例
- DBUtils使用详细示例
- DBUtils使用详细示例
- DBUtils使用详细示例
- Java 集合系列13之 WeakHashMap详细介绍(源码解析)和使用示例
- 使用css美化html表单控件详细示例(表单美化)
- Java四种线程池的介绍及详细使用代码示例
- Java【集合系列】-12- TreeMap详细介绍(源码解析)和使用示例
- EventBus使用详细讲解，结合示例
- ListView中pointToPosition()方法使用详细示例
- Asp.net 2.0 自定义控件开发专题[详细探讨页面状态(视图状态和控件状态)机制及其使用场景](示例代码下载)
- Java 集合系列06之 Vector详细介绍(源码解析)和使用示例
- Java 集合系列06之 Vector详细介绍(源码解析)和使用示例
- Java 集合系列06之 Vector详细介绍(源码解析)和使用示例
- Hashtable详细介绍(源码解析)和使用示例
- TreeMap详细介绍(源码解析)和使用示例
- Java 集合系列05之 LinkedList详细介绍(源码解析)和使用示例
- Android使用GridView实现日历功能示例（详细代码）
- Java 集合系列03之 ArrayList详细介绍(源码解析)和使用示例
- 自定义ContentProvider以及ContentObserver的使用完整详细示例