commons dbutils 常用方法

要运行要使用了dbcp连接池

package com.crm.db.base;

import java.sql.SQLException;
import java.util.List;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;
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.ScalarHandler;

import com.crm.domain.User;
import com.crm.util.Constants;
// [e-mail]
public class DBBase {
	
	
	private static DBBase dbBase;
	
	private static QueryRunner run ;
	
	private DataSource dataSource;
	public DataSource getDataSource() {	return dataSource;}
	public void setDataSource(DataSource dataSource) {	this.dataSource = dataSource;}
	
	
	private DBBase(){}
	
	
	private void init(){
		dbBase = this;
		run=new QueryRunner(dataSource);
	}
	
	public static DBBase getInstance(){
		return dbBase;
	}
	
	
	/**
	 * eg:
	 * select count(1) from user
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
	public int count(String sql, Object[] params){
		
		Object o = getAnAttr(sql,params);
		if(o instanceof Integer){
			return (Integer) o;
		}
		if(o instanceof Long){
			Long l = (Long)o;
			return l.intValue();
		}
		
		String s = (String)o;
		try{
			return Integer.parseInt(s);
		}catch (NumberFormatException e) {
			return 0;
		}
	}
	 
	 /**
	  * 获得第一个查询第一行第一列
	  * @param sql
	  * @param params
	  * @return
	  */
	public Object getAnAttr(String sql, Object[] params){

		showSql(sql);

		Object s=null;
		try {
			s = run.query(sql, new ScalarHandler(1),params);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return s;
	}
	/**
	 * 查询返回单个对象
	 * @param sql
	 * @param clazz
	 * @return
	 */	
	public <T> T queryForObject(String sql,Object param[],Class<T> clazz){		
		T obj = null;
		try {			
			showSql(sql);			
			obj = (T)run.query(sql,new BeanHandler(clazz), param);			
		} catch (SQLException e) {			
			e.printStackTrace();
		} 
		return obj;
	}
	
	/**
	 * 查询返回list对象
	 * @param sql
	 * @param clazz
	 * @return
	 */
	public <T> List<T> queryForOList(String sql,Object[] param,Class<T> clazz){
		List<T> obj = null;
		try {
			showSql(sql);
			obj = (List<T>)run.query(sql,new BeanListHandler(clazz),param);			
		} catch (SQLException e) {			
			e.printStackTrace();
		} 
		return obj;
	}
	
	
	/**
	 * 保存返回主键
	 * @param sql
	 * @param param
	 * @return
	 */
	public int storeInfoAndGetGeneratedKey(String sql,Object[] param){
		int pk=0;
		try	{
			showSql(sql);
			run.update(sql,param);
			pk = ((Long)run.query("SELECT LAST_INSERT_ID()", new ScalarHandler(1))).intValue();	
		}catch(SQLException e) {
			e.printStackTrace();
		}
		return pk;
	}
	/**
	 * 更新
	 * @param sql
	 * @return
	 */
	
	public int update(String sql,Object[] param){
		int i=0;
		try	{
			showSql(sql);
			i = run.update(sql,param);
		}catch(SQLException e) {
			e.printStackTrace();
		}
		return i;

	}
	
	private void showSql(String sql){
		if(Constants.SHOW_SQL){
			System.out.println(sql);
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String uri = "jdbc:mysql://localhost:3306/miccrm";   
		DataSource ds = setupDataSource(uri);
		DBBase db = new DBBase();
		db.setDataSource(ds);
		db.init();
		
		String sql = "select count(1) from user";	
		int i = db.count(sql,null);
		
		sql="select name from user";
		List<User> us = DBBase.getInstance().queryForOList(sql, null, User.class);		
		for(User u:us){
			System.out.println(u.getName());
		}
		
		sql = "insert into user(name) values(?)";
		int pk = DBBase.getInstance().storeInfoAndGetGeneratedKey(sql, new Object[]{"a"});
		System.out.println(pk);
		
		sql ="select name from user where id =?";
		String a =(String) DBBase.getInstance().getAnAttr(sql, new Object[]{1});
		
		System.out.println(a);
	
	}


    private static DataSource setupDataSource(String connectURI) {
        BasicDataSource ds = new BasicDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUsername("root");
        ds.setPassword("123456");
        ds.setUrl(connectURI);
        return ds;
    }

}

评论

15 楼 guji528 2012-06-19  

简单试了一下，觉得很方便：
UserRef extends RefObject
  List<RefObject> buildOracleQuery(Connection conn) {
        QueryRunner qr = new QueryRunner();
//        RefObject user = null;
        ResultSetHandler<?> arrayResult = new ArrayListHandler();
        ResultSetHandler<RefObject> rs = null;
        ResultSetHandler<List<RefObject>> rList = null;
        rs = new BeanHandler<RefObject>(RefObject.class);
        rList = new BeanListHandler(UserRef.class);
       
        ResultSetHandler<List<Map<String, Object>>> map = new MapListHandler();
        String sql =  "select id, name, alias" +
        " from (select id, name,  alias, op_seq, op_status from user" +
        " where op_status = 0" +
        " order by op_seq) where rownum <= ?";
       
//        Connection conn = null;
       
        QueryLoader q = QueryLoader.instance();
        Object params = 10;
        List<RefObject> list = null;
        List<Map<String, Object>> iMap = null;
        List<Object[]> arrResult = null;
        try
        {
            //查询返回数组列表
            arrResult = (List<Object[]>)qr.query(conn,sql, arrayResult, params);
           
            //查询返回JavaBean列表
            list = qr.query(conn,sql, rList, params);
           
            //查询返回Map列表
            iMap = qr.query(conn,sql, map, params);
//            qr.fillStatementWithBean(arg0, arg1, arg2);
//            DbUtils.
           
           
            conn.setAutoCommit(false);

/**            此段代码是通过查询得到的数组直接批量插入到数据，简洁高效
           
            Object[][] inParam = new Object[arrResult.size()][];
            for (int i = 0; i < inParam.length; i++)
            {
                inParam[i] = arrResult.get(i);
               
            }
            qr.batch(conn,TransConst.USER_INSERT_SQL, inParam);
           
  */         
            PreparedStatement stmt = conn.prepareStatement(TransConst.USER_INSERT_SQL);
   
            String[] props = new String[] {"id", "name", "alias"};
           
           
            for (RefObject user : list)
            {
                //通过JavaBean方式填充Statement参数
                qr.fillStatementWithBean(stmt, user, props);
                stmt.addBatch();
            }
            stmt.executeBatch();

14 楼 summerfeel 2010-06-29  

这只是数据源的配置，没有把事务处理放进去，具体事务策略当然是留到service再处理，我只是想知道你使用DBUtils以后，数据源是怎么配的。

13 楼 chenkan2000 2010-06-29  

我不这么配置的。事务是在service层实现的，不是在DAO中实现。对service中的方法进行事务性声明，DataSource和DAO是普通的Spring Bean。

12 楼 summerfeel 2010-06-27  

chenkan2000 写道

你说的很对。但我认为hack DBUtils没有必要，DBUtils和Spring可以一起使用。用DBUtils实现DAO，让Spring管理Datasource和transaction，把DBBase声明为Spring可管理的bean，把datasource注入到DBBase中。可能要用构造函数注入，因为需要在构造函数中创建QueryRunner。DBBase中所有包含数据库操作的函数都让它抛出Runtime Exception，或者直接借用Spring的DataAccessException。

有道理，修改DBUtils确实不是好办法。
不过DataSource应该使用Spring的一个DataSource代理TransactionAwareDataSourceProxy

<bean id="dataSourceTarget" class="org.apache.commons.dbcp.BasicDataSource" scope="singleton">       
    <property name="driverClassName">
    	<value>oracle.jdbc.driver.OracleDriver</value>
    </property>      
    <property name="url">
    	<value>jdbc:oracle:thin:@localhost:1521:dbname</value>
    </property>      
    <property name="username">
    	<value>user_bask_app</value>
    </property>      
    <property name="password">
    	<value>user_bask_app</value>
    </property>      
</bean>

<bean id="dataSource" class="org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy" scope="singleton">
    <constructor-arg>
	<ref bean="dataSourceTarget"/>
    </constructor-arg>
</bean>

<bean id="runner" class="org.apache.commons.dbutils.QueryRunner">
    <constructor-arg>
	<ref bean="dataSource"/>
    </constructor-arg>
</bean>

QueryRunner从代理中取得Connection，在同一个请求线程中由Spring保证其事务性。

11 楼 chenkan2000 2010-06-26  

你说的很对。但我认为hack DBUtils没有必要，DBUtils和Spring可以一起使用。用DBUtils实现DAO，让Spring管理Datasource和transaction，把DBBase声明为Spring可管理的bean，把datasource注入到DBBase中。可能要用构造函数注入，因为需要在构造函数中创建QueryRunner。DBBase中所有包含数据库操作的函数都让它抛出Runtime Exception，或者直接借用Spring的DataAccessException。

10 楼 summerfeel 2010-06-24  

wnick 写道

chenkan2000 写道

BeanPropertyRowMapper和ParameterizedBeanPropertyRowMapper可以实现BeanListHandler一样的功能，也是一行代码。我并不是要说明spring JDBC比DBUtils功能强大，但事务、数据库连接池真的需要好好考虑的。

我没有别的意思
只是我网上查了一下感觉都比较麻烦
所以希望找一个简短点的
呵呵

我稍微看了一下源代码，Spring和DbUtils在基本查询和处理结果集方面的设计思想是一致的。DBUtils只提供了一个QueryRunner，确实够轻量级，数据源也可以使用开源的连接池，但事务确实不好控制。
在单个数据源的情况下要准确的控制事务的提交回滚，必须保证在一个事务中的操作都使用同一个Connection。在Spring中通过对DataSource进行代理，返回与当前执行线程绑定的Connection，以此来保证上面所说的这一点。使用DBUtils实现事务，不知是否需要hack源码...

9 楼 wnick 2010-06-24  

chenkan2000 写道

BeanPropertyRowMapper和ParameterizedBeanPropertyRowMapper可以实现BeanListHandler一样的功能，也是一行代码。我并不是要说明spring JDBC比DBUtils功能强大，但事务、数据库连接池真的需要好好考虑的。

我没有别的意思
只是我网上查了一下感觉都比较麻烦
所以希望找一个简短点的
呵呵

8 楼 chenkan2000 2010-06-23  

BeanPropertyRowMapper和ParameterizedBeanPropertyRowMapper可以实现BeanListHandler一样的功能，也是一行代码。我并不是要说明spring JDBC比DBUtils功能强大，但事务、数据库连接池真的需要好好考虑的。

7 楼 wnick 2010-06-22  

chenkan2000 写道

处理返回结果不麻烦。可以看一下spring javadoc中这几个类：
RowMapper，BeanPropertyRowMapper，ParameterizedBeanPropertyRowMapper, RowCallbackHandler等。

DBBase类有个问题，所有方法都把SQLException捕获后又不抛出异常，调用它的service类实现事务处理就很困难了。

这里只是用来记录一下
没有做其他处理
我印象中 springjdbc要返回对象要使用回调一类操作
不知能否麻烦你用springJDBC 做一个 简单的查询返回 一个对象和 返回一个list

6 楼 chenkan2000 2010-06-22  

处理返回结果不麻烦。可以看一下spring javadoc中这几个类：
RowMapper，BeanPropertyRowMapper，ParameterizedBeanPropertyRowMapper, RowCallbackHandler等。

DBBase类有个问题，所有方法都把SQLException捕获后又不抛出异常，调用它的service类实现事务处理就很困难了。

5 楼 wnick 2010-06-21  

summerfeel 写道

想知道你事务是怎么处理的

这个工具强大的是查询功能
返回自定义对象、map 等
事务那些还是要自己来完成的

chenkan2000 写道

直接用Spring的JdbcTemplate得了。

spring 的查询要返回对象自己需要做很多编码
感觉麻烦
也许是我不了解它吧
只是看了一下spring文档的demo

4 楼 chenkan2000 2010-06-21  

直接用Spring的JdbcTemplate得了。

3 楼 summerfeel 2010-06-21  

想知道你事务是怎么处理的

2 楼 cyberblue 2010-06-19  

DbUtils比较不错，如果数据库的结构不是很复杂，可以用DbUtils代替iBatis。

1 楼 ma3310 2010-06-19  

#         DBBase db = new DBBase(); 
#         db.setDataSource(ds); 
#         db.init(); 

直接在DbBase里做掉好