commons-dbutilsAPI介绍：
- org.apache.commons.dbutils.QueryRunner
- org.apache.commons.dbutils.ResultSetHandler
一，QueryRunner类
两个实例化的方法 queryRunner qr=new queryRunner();
queryRunner qr=new queryRunner(javax.sql.DataSource);javax.sql.DataSource是数据库链接池
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：用来执行一个不需要置换参数的更新操作。
package me.gacl.test;
import java.util.Date;
import java.util.List;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.sql.SQLException;
import javax.sql.rowset.serial.SerialClob;
import me.gacl.domain.User;
import me.gacl.util.JdbcUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.junit.Test;
/**
* @ClassName: DBUtilsCRUDTest
* @Description:使用dbutils框架的QueryRunner类完成CRUD,以及批处理
* @author: 孤傲苍狼
* @date: 2014-10-5 下午4:56:44
*
*/
public class QueryRunnerCRUDTest {
/*
*测试表
create table users(
id int primary key auto_increment,
name varchar(40),
password varchar(40),
email varchar(60),
birthday date
);
*/
@Test
public void add() throws SQLException {
//将数据源传递给QueryRunner，QueryRunner内部通过数据源获取数据库连接
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "insert into users(name,password,email,birthday) values(?,?,?,?)";
Object params[] = {"孤傲苍狼","123", "gacl@sina.com", new Date()};
//Object params[] = {"白虎神皇","123", "gacl@sina.com", "1988-05-07"};
qr.update(sql, params);
}
@Test
public void delete() throws SQLException {
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "delete from users where id=?";
qr.update(sql, 1);
}
@Test
public void update() throws SQLException {
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "update users set name=? where id=?";
Object params[] = { "ddd", 5};
qr.update(sql, params);
}
@Test
public void find() throws SQLException {
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select * from users where id=?";
Object params[] = {2};
User user = (User) qr.query(sql, params, new BeanHandler(User.class));
System.out.println(user.getBirthday());
}
@Test
public void getAll() throws SQLException {
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select * from users";
List list = (List) qr.query(sql, new BeanListHandler(User.class));
System.out.println(list.size());
}
/**
* @Method: testBatch
* @Description:批处理
* @Anthor:孤傲苍狼
*
* @throws SQLException
*/
@Test
public void testBatch() throws SQLException {
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "insert into users(name,password,email,birthday) values(?,?,?,?)";
Object params[][] = new Object[10][];
for (int i = 0; i < 10; i++) {
params[i] = new Object[] { "aa" + i, "123", "aa@sina.com",
new Date() };
}
qr.batch(sql, params);
}
//用dbutils完成大数据（不建议用）
/***************************************************************************
create table testclob
(
id int primary key auto_increment,
resume text
);
**************************************************************************/
@Test
public void testclob() throws SQLException, IOException{
QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
String sql = "insert into testclob(resume) values(?)"; //clob
//这种方式获取的路径，其中的空格会被使用“%20”代替
String path = QueryRunnerCRUDTest.class.getClassLoader().getResource("data.txt").getPath();
//将“%20”替换回空格
path = path.replaceAll("%20", " ");
FileReader in = new FileReader(path);
char[] buffer = new char[(int) new File(path).length()];
in.read(buffer);
SerialClob clob = new SerialClob(buffer);
Object params[] = {clob};
runner.update(sql, params);
}
}三、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各种类型的处理器
1 package me.gacl.test; 2 3 import java.sql.SQLException; 4 import java.util.Arrays; 5 import java.util.List; 6 import java.util.Map; 7 import me.gacl.util.JdbcUtils; 8 import org.apache.commons.dbutils.QueryRunner; 9 import org.apache.commons.dbutils.handlers.ArrayHandler; 10 import org.apache.commons.dbutils.handlers.ArrayListHandler; 11 import org.apache.commons.dbutils.handlers.ColumnListHandler; 12 import org.apache.commons.dbutils.handlers.KeyedHandler; 13 import org.apache.commons.dbutils.handlers.MapHandler; 14 import org.apache.commons.dbutils.handlers.MapListHandler; 15 import org.apache.commons.dbutils.handlers.ScalarHandler; 16 import org.junit.Test; 17 18 /** 19 * @ClassName: ResultSetHandlerTest 20 * @Description:测试dbutils各种类型的处理器 21 * @author: 孤傲苍狼 22 * @date: 2014-10-6 上午8:39:14 23 * 24 */ 25 public class ResultSetHandlerTest { 26 27 @Test 28 public void testArrayHandler() throws SQLException{ 29 QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource()); 30 String sql = "select * from users"; 31 Object result[] = (Object[]) qr.query(sql, new ArrayHandler()); 32 System.out.println(Arrays.asList(result)); //list toString() 33 } 34 35 @Test 36 public void testArrayListHandler() throws SQLException{ 37 38 QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource()); 39 String sql = "select * from users"; 40 List<Object[]> list = (List) qr.query(sql, new ArrayListHandler()); 41 for(Object[] o : list){ 42 System.out.println(Arrays.asList(o)); 43 } 44 } 45 46 @Test 47 public void testColumnListHandler() throws SQLException{ 48 QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource()); 49 String sql = "select * from users"; 50 List list = (List) qr.query(sql, new ColumnListHandler("id")); 51 System.out.println(list); 52 } 53 54 @Test 55 public void testKeyedHandler() throws Exception{ 56 QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource()); 57 String sql = "select * from users"; 58 59 Map<Integer,Map> map = (Map) qr.query(sql, new KeyedHandler("id")); 60 for(Map.Entry<Integer, Map> me : map.entrySet()){ 61 int id = me.getKey(); 62 Map<String,Object> innermap = me.getValue(); 63 for(Map.Entry<String, Object> innerme : innermap.entrySet()){ 64 String columnName = innerme.getKey(); 65 Object value = innerme.getValue(); 66 System.out.println(columnName + "=" + value); 67 } 68 System.out.println("----------------"); 69 } 70 } 71 72 @Test 73 public void testMapHandler() throws SQLException{ 74 75 QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource()); 76 String sql = "select * from users"; 77 78 Map<String,Object> map = (Map) qr.query(sql, new MapHandler()); 79 for(Map.Entry<String, Object> me : map.entrySet()) 80 { 81 System.out.println(me.getKey() + "=" + me.getValue()); 82 } 83 } 84 85 86 @Test 87 public void testMapListHandler() throws SQLException{ 88 QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource()); 89 String sql = "select * from users"; 90 List<Map> list = (List) qr.query(sql, new MapListHandler()); 91 for(Map<String,Object> map :list){ 92 for(Map.Entry<String, Object> me : map.entrySet()) 93 { 94 System.out.println(me.getKey() + "=" + me.getValue()); 95 } 96 } 97 } 98 99 @Test 100 public void testScalarHandler() throws SQLException{ 101 QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource()); 102 String sql = "select count(*) from users"; //[13] list[13] 103 int count = ((Long)qr.query(sql, new ScalarHandler(1))).intValue(); 104 System.out.println(count); 105 } 106 }
三、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。
四、JDBC开发中的事务处理
在开发中，对数据库的多个表或者对一个表中的多条数据执行更新操作时要保证对多个更新操作要么同时成功，要么都不成功，这就涉及到对多个更新操作的事务管理问题了。比如银行业务中的转账问题，A用户向B用户转账100元，假设A用户和B用户的钱都存储在Account表，那么A用户向B用户转账时就涉及到同时更新Account表中的A用户的钱和B用户的钱，用SQL来表示就是：
1 update account set money=money-100 where name='A' 2 update account set money=money+100 where name='B'
4.1、在数据访问层(Dao)中处理事务
对于这样的同时更新一个表中的多条数据的操作，那么必须保证要么同时成功，要么都不成功，所以需要保证这两个update操作在同一个事务中进行。在开发中，我们可能会在AccountDao写一个转账处理方法，如下：
1 /** 2 * @Method: transfer 3 * @Description:这个方法是用来处理两个用户之间的转账业务 4 * 在开发中，DAO层的职责应该只涉及到CRUD， 5 * 而这个transfer方法是处理两个用户之间的转账业务的，已经涉及到具体的业务操作，应该在业务层中做，不应该出现在DAO层的 6 * 所以在开发中DAO层出现这样的业务处理方法是完全错误的 7 * @Anthor:孤傲苍狼 8 * 9 * @param sourceName 10 * @param targetName 11 * @param money 12 * @throws SQLException 13 */ 14 public void transfer(String sourceName,String targetName,float money) throws SQLException{ 15 Connection conn = null; 16 try{ 17 conn = JdbcUtils.getConnection(); 18 //开启事务 19 conn.setAutoCommit(false); 20 /** 21 * 在创建QueryRunner对象时，不传递数据源给它，是为了保证这两条SQL在同一个事务中进行， 22 * 我们手动获取数据库连接，然后让这两条SQL使用同一个数据库连接执行 23 */ 24 QueryRunner runner = new QueryRunner(); 25 String sql1 = "update account set money=money-100 where name=?"; 26 String sql2 = "update account set money=money+100 where name=?"; 27 Object[] paramArr1 = {sourceName}; 28 Object[] paramArr2 = {targetName}; 29 runner.update(conn,sql1,paramArr1); 30 //模拟程序出现异常让事务回滚 31 int x = 1/0; 32 runner.update(conn,sql2,paramArr2); 33 //sql正常执行之后就提交事务 34 conn.commit(); 35 }catch (Exception e) { 36 e.printStackTrace(); 37 if(conn!=null){ 38 //出现异常之后就回滚事务 39 conn.rollback(); 40 } 41 }finally{ 42 //关闭数据库连接 43 conn.close(); 44 } 45 }
然后我们在AccountService中再写一个同名方法，在方法内部调用AccountDao的transfer方法处理转账业务，如下：
1 public void transfer(String sourceName,String targetName,float money) throws SQLException{ 2 AccountDao dao = new AccountDao(); 3 dao.transfer(sourceName, targetName, money); 4 }
务操作，所以在开发中DAO层出现这样的业务处理方法是一种不好的设计。
4.2、在业务层(BusinessService)处理事务
由于上述AccountDao存在具体的业务处理方法，导致AccountDao的职责不够单一，下面我们对AccountDao进行改造，让AccountDao的职责只是做CRUD操作，将事务的处理挪到业务层(BusinessService)，改造后的AccountDao如下：
1 package me.gacl.dao; 2 3 import java.sql.Connection; 4 import java.sql.SQLException; 5 import org.apache.commons.dbutils.QueryRunner; 6 import org.apache.commons.dbutils.handlers.BeanHandler; 7 import me.gacl.domain.Account; 8 import me.gacl.util.JdbcUtils; 9 10 /*account测试表 11 create table account( 12 id int primary key auto_increment, 13 name varchar(40), 14 money float 15 )character set utf8 collate utf8_general_ci; 16 17 insert into account(name,money) values('A',1000); 18 insert into account(name,money) values('B',1000); 19 insert into account(name,money) values('C',1000); 20 21 */ 22 23 /** 24 * @ClassName: AccountDao 25 * @Description: 针对Account对象的CRUD 26 * @author: 孤傲苍狼 27 * @date: 2014-10-6 下午4:00:42 28 * 29 */ 30 public class AccountDao { 31 32 //接收service层传递过来的Connection对象 33 private Connection conn = null; 34 35 public AccountDao(Connection conn){ 36 this.conn = conn; 37 } 38 39 public AccountDao(){ 40 41 } 42 43 /** 44 * @Method: update 45 * @Description:更新 46 * @Anthor:孤傲苍狼 47 * 48 * @param account 49 * @throws SQLException 50 */ 51 public void update(Account account) throws SQLException{ 52 53 QueryRunner qr = new QueryRunner(); 54 String sql = "update account set name=?,money=? where id=?"; 55 Object params[] = {account.getName(),account.getMoney(),account.getId()}; 56 //使用service层传递过来的Connection对象操作数据库 57 qr.update(conn,sql, params); 58 59 } 60 61 /** 62 * @Method: find 63 * @Description:查找 64 * @Anthor:孤傲苍狼 65 * 66 * @param id 67 * @return 68 * @throws SQLException 69 */ 70 public Account find(int id) throws SQLException{ 71 QueryRunner qr = new QueryRunner(); 72 String sql = "select * from account where id=?"; 73 //使用service层传递过来的Connection对象操作数据库 74 return (Account) qr.query(conn,sql, id, new BeanHandler(Account.class)); 75 } 76 }
接着对AccountService(业务层)中的transfer方法的改造，在业务层(BusinessService)中处理事务
1 package me.gacl.service; 2 3 import java.sql.Connection; 4 import java.sql.SQLException; 5 import me.gacl.dao.AccountDao; 6 import me.gacl.domain.Account; 7 import me.gacl.util.JdbcUtils; 8 9 /** 10 * @ClassName: AccountService 11 * @Description: 业务逻辑处理层 12 * @author: 孤傲苍狼 13 * @date: 2014-10-6 下午5:30:15 14 * 15 */ 16 public class AccountService { 17 18 /** 19 * @Method: transfer 20 * @Description:这个方法是用来处理两个用户之间的转账业务 21 * @Anthor:孤傲苍狼 22 * 23 * @param sourceid 24 * @param tartgetid 25 * @param money 26 * @throws SQLException 27 */ 28 public void transfer(int sourceid,int tartgetid,float money) throws SQLException{ 29 Connection conn = null; 30 try{ 31 //获取数据库连接 32 conn = JdbcUtils.getConnection(); 33 //开启事务 34 conn.setAutoCommit(false); 35 //将获取到的Connection传递给AccountDao，保证dao层使用的是同一个Connection对象操作数据库 36 AccountDao dao = new AccountDao(conn); 37 Account source = dao.find(sourceid); 38 Account target = dao.find(tartgetid); 39 40 source.setMoney(source.getMoney()-money); 41 target.setMoney(target.getMoney()+money); 42 43 dao.update(source); 44 //模拟程序出现异常让事务回滚 45 int x = 1/0; 46 dao.update(target); 47 //提交事务 48 conn.commit(); 49 }catch (Exception e) { 50 e.printStackTrace(); 51 //出现异常之后就回滚事务 52 conn.rollback(); 53 }finally{ 54 conn.close(); 55 } 56 } 57 }
程序经过这样改造之后就比刚才好多了，AccountDao只负责CRUD，里面没有具体的业务处理方法了，职责就单一了，而AccountService则负责具体的业务逻辑和事务的处理，需要操作数据库时，就调用AccountDao层提供的CRUD方法操作数据库。
1279
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
