ResultSetHandler接口用于处理ResultSet结果集，它可以将结果集中的数据转换为不同的形式。根据结果集中不同的数据类型，ResultSetHandler提供了几种常见的实现类。

ResultSetHandler接口还提供了一个单独的方法handle (java.sql.ResultSet rs)，如果上述实现类没有提供想要的功能，可以自定义一个实现ResultSetHandler接口的类，然后通过重写handle()方法，实现结果集的处理。

BeanHandler和BeanListHandler

ColumnListHandler和ScalarHandler

ColumnListHandler和ScalarHandler类可以对指定的列数据进行封装，在封装时，查询指定列数据，然后将获得的列数据封装到容器中。ColumnListHandler和ScalarHandler的对比如下表所示。

：Object…  params于是百度查了查。

这是JDK1.5新增语法，新特性，动态参数或者是可变参数的意思。
（1）使用…将参数声明成可变长参数。
（2）可变长参数必须是最后一个参数。
（3）可变参数同时可以跟固定的参数混合使用，但是一个方法的参数中不能同时拥有2种类型的可变参数。

案例代码
user类：

package chapter11;
import java.util.Date;
public class user {

    private int id;
    private String name;
    private String password;
    private String email;
    private Date birthday;
    
    public user() {
    	
    }
    public user(int id,String name,String password,String email,Date birthday) {
    	this.id = id;
    	this.name = name;
    	this.password = password;
    	this.email = email;
    	this.birthday = birthday;
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String username) {
        this.name = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

BaseDao的类，在该类中编写一个通用的查询方法。

package chapter11;


import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.apache.commons.dbutils.ResultSetHandler;

import chapter10.JDBCUtils;

public class BaseDao {
    // 优化查询
    public static Object query(String sql, ResultSetHandler<?> rsh,
                               Object... params) throws SQLException {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            // 获得连接
            conn = JDBCUtils.getConnection();
            // 预编译sql
            pstmt = conn.prepareStatement(sql);
            // 将参数设置进去
            for (int i = 0; params != null && i < params.length; i++)
            {
                pstmt.setObject(i + 1, params[i]);
            }
            // 发送sql
            rs = pstmt.executeQuery();
            
         // 处理结果集 验证
            while (rs.next()) {

                System.out.println("id: " + rs.getInt("id") + " ,name: " + rs.getString("name"));
            }
            
            // 让调用者去实现对结果集的处理
            //Object obj = rsh.handle(rs);
            Object obj = rsh.handle(rs);
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            // 释放资源
            JDBCUtils.release(rs, pstmt, conn);
        }
        return rs;
    }
    
    
    /* 目前重新的有点问题 稍后修改
    public static Object query(Connection connection,String sql, ResultSetHandler<?> rsh,
            Object... params) throws SQLException 
    {
		Connection conn = connection;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		try {
			// 获得连接
			//conn = JDBCUtils.getConnection();
			// 预编译sql
			pstmt = conn.prepareStatement(sql);
			// 将参数设置进去
			for (int i = 0; params != null && i < params.length; i++)
			{
				pstmt.setObject(i + 1, params[i]);
			}
			// 发送sql
			rs = pstmt.executeQuery();
			
			// 处理结果集 验证
			while (rs.next()) {
			
				System.out.println("id: " + rs.getInt("id") + "name: " + rs.getString("name"));
		}
	
		// 让调用者去实现对结果集的处理
		Object obj = rsh.handle(rs);
		@Override
		public List<Blog> handle(ResultSet rs) throws SQLException {
			List<Blog> lists = new ArrayList<Blog>();
			while(rs.next()){
				Blog blog = new Blog();
				blog.setId(rs.getInt("id"));
				blog.setContent(rs.getString("content")+"huangbaokang");
				blog.setTitle(rs.getString("title")+"黄宝康");
				lists.add(blog);
			}
			return lists;
		}
		return obj;
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
		// 释放资源
			JDBCUtils.release(rs, pstmt, conn);
		}
			return rs;
	}
    */
    
}

验证代码类：

package chapter11;

import java.sql.Connection;

import java.sql.SQLException;
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.ScalarHandler;

import chapter10.JDBCUtils;

import java.util.ArrayList;

public class ResultSetTest {
	

	public static void main(String[] args) throws SQLException {
		testBeanHandler();
		//testBeanListHandler();
		//testColumnListHandler();
		
		//testScalarHandler();
	
	}
	
	/*
	//BeanHandler类处理结果集
    public static void myBeanHandler() throws SQLException {
    	Connection connection = null;
    	try {
    		connection = JDBCUtils.getConnection();
    		String sql = "select id,name,password,email,birthday from users where id = ?";
    		users customers=(users) BaseDao.query(connection, sql, new BeanHandler(users.class), 1);
    		System.out.println(customers);
    	} catch (Exception e) {
    		e.printStackTrace();
    	} finally {
    		JDBCUtils.release(null, connection);
    	}

	} */
	
	//BeanHandler类处理结果集
	public static void testBeanHandler() throws SQLException {
        BaseDao basedao = new BaseDao();
        String sql = "select * from users where id=?;";
        //String sql = "select id,name,password,email,birthday from users where id=?;";
        @SuppressWarnings({ "static-access", "rawtypes", "unchecked" })
		user myuser = (user) basedao.query(sql, new BeanHandler(user.class), 1);
        if (myuser == null)
        {
        	System.out.print("返回记录个数为：null" );
        }
        else {
        	System.out.print("id为1的users对象的name值为：" + myuser.getName());
		}
        
        
    }
	
	//BeanListHandler类处理结果
	public static void testBeanListHandler() throws SQLException {
        BaseDao basedao = new BaseDao();
        String sql = "select * from users;";
        @SuppressWarnings({ "static-access", "unchecked", "rawtypes" })
		ArrayList<user> list = (ArrayList<user>) basedao.query(sql,
                new BeanListHandler(user.class));
        for (int i = 0; i < list.size(); i++) {
            System.out.println("第" + (i + 1) + "条数据的username值为:"
                    + list.get(i).getName());
        }
	}
	
	//ColumnListHandler
	public static void testColumnListHandler() throws SQLException {
        BaseDao basedao = new BaseDao();
        String sql = "select * from users;";
        Object arr = (Object) basedao.query(sql,
                new ColumnListHandler("name"));
        System.out.println(arr);
    }
	
	//ScalarHandler类的使用
	public static void testScalarHandler() throws SQLException {
		BaseDao basedao = new BaseDao();
		String sql = "select * from users where id=?";
		Object arr = (Object) basedao.query(sql, 
                               new ScalarHandler("name"), 1);
		System.out.println(arr);
	}


}

通过验证代码发现，测试过程中，发现调用(user) basedao.query(sql, new BeanHandler(user.class), 1);语句时，能查询到结果。但是：

 // 让调用者去实现对结果集的处理
Object obj = rsh.handle(rs);

会报错，无法正确转换。重新query类还未完成，稍后再做。

针对以上问题采用c3p0.ComboPooledDataSource 解决问题，对应教程上的11.2.6案例：

package chapter11;

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

import javax.sql.DataSource;

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.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import com.mchange.v2.c3p0.ComboPooledDataSource;


public class myResultSetHandler {
	public static void main(String[] args) throws SQLException {
		//获取数据源
		DataSource ds = new ComboPooledDataSource();
		QueryRunner queryRunner = new QueryRunner(ds);
				
		//testBeanHandler();
		
		//------------------------------查询语句------------------------------------
	
		
         /*
        //ArrayListHandler：将查询的结果的每一行放到一个数组中，然后再将数组放到集合中；
        String sql = "SELECT * FROM users;";
        List<Object[]> query = queryRunner.query(sql, new ArrayListHandler());
        for (Object[] obj : query) {
            for (Object o : obj) {
                System.out.print(o + " ");
            }
            System.out.println();
        } */

		/*
        //BeanHandler：将查询的结果的第一行封装到一份javabean对象中；
        String sql = "SELECT * FROM users;";
        user query = queryRunner.query(sql, new BeanHandler<user>(user.class));
        System.out.println(query);

        //BeanListHandler：将查询的结果的每一行封装到一个javabean对象中，然后再将这些对象存入list中；
        System.out.println("///");
        sql = "SELECT * FROM users";
        List<user> list = queryRunner.query(sql, new BeanListHandler<user>(user.class));
        for(user users:list) {
            System.out.println(users.getName());
        } */

        
        //ColumnListHandler：查询指定的列，将查询结果放到一个List中
		System.out.println("//ColumnListHandler：查询指定的列，将查询结果放到一个List中//");
        String sql = "SELECT * FROM users;";
        List<Object> list = queryRunner.query(sql, new ColumnListHandler<Object>("name"));
        for(Object o:list) {
            System.out.println(o);
        }

        //ScalarHandler：将查询的结果的第一行的某一列放到一个对象中；精确定位到某个值；
        System.out.println("//ScalarHandler：将查询的结果的第一行的某一列放到一个对象中；精确定位到某个值//");
        sql = "SELECT COUNT(*) FROM users;";
        Long query = queryRunner.query(sql, new ScalarHandler<Long>());
        System.out.println(query);

        //MapHandler：将查询的结果的第一行存入到一个map中，键为列名，值为各列值；
        System.out.println("//MapHandler 将查询的结果的第一行存入到一个map中，键为列名，值为各列值//");
        sql = "SELECT * FROM users;";
        Map<String, Object> queryMapHandler = queryRunner.query(sql, new MapHandler());
        for (String key : queryMapHandler.keySet()) {
            System.out.println(key + ":" + queryMapHandler.get(key));
        }

        //MapListHandler：将查询的结果的每一行存入到一个map中，键为列名，值为各列值；然后再将map存入list中；
        System.out.println("//MapListHandler：将查询的结果的每一行存入到一个map中，键为列名，值为各列值；然后再将map存入list中//");
        sql = "SELECT * FROM users;";
        List<Map<String, Object>> queryMapListHandler = queryRunner.query(sql, new MapListHandler());
        for (Map<String, Object> map : queryMapListHandler) {
            for(String key:map.keySet()) {
                System.out.print(key+":"+map.get(key)+" ");
            }
            System.out.println();
        }
    
		//ArrayHandler：将查询的结果的第一行放到一个数组中
	    System.out.println("//ArrayHandler：将查询的结果的第一行放到一个数组中//");
		sql = "SELECT * FROM users;";
		Object[] queryArrayHandler = queryRunner.query(sql, new ArrayHandler());
		 for (Object o : queryArrayHandler) {
			 System.out.println(o);
		 }
		 
		 
		//------------------------------更新语句------------------------------------
	       /* sql = "SELECT * FROM users WHERE id = ?";
	        Map<String, Object> query = queryRunner.query(sql, new MapHandler(),1);
	        for(String key:query.keySet()) {
	            System.out.println(key+":"+query.get(key));
	        }

	        String sql = "DELETE FROM type WHERE id in(?,?)";
	        int update = queryRunner.update(sql,6,7);
	        System.out.println(update);

	        String sql = "UPDATE type SET name = '生日系列' WHERE id = ?";
	        int update = queryRunner.update(sql,8);
	        System.out.println(update);

	        String sql = "INSERT INTO type (name) values(?)";
	        int update = queryRunner.update(sql,"111");
	        System.out.println(update);
	        
	        */
		
	}  
      
  }