package demo;

/*

 * QueryRunner数据查询操作；

 *     调用QueryRunner类方法query(Connection con,String sql,ResultSetHandler r,Oberct...params))

 *    ResultSetHandler r 结果集的处理方式，传递ResultSetHandler接口实现类

 *    Object...params SQL语句中的？占位符

 *

 *    注意：query方法返回值，返回的是T 泛型，具体返回值类型，跟随结果集处理方式变化

 */

import java.util.List;

import java.util.Map;

import java.sql.Connection;

import java.sql.SQLException;

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 domain.Sort;

import jdbcutil.JDBCUtilsConfig;

public class QueryRunnerDemo1{

    private static Connection con=JDBCUtilsConfig.getConnection();

    public static void main(String[] args) throws SQLException {

        //arrayHandler();

        //arrayListHandler();

        //beanHandler();

        //beanListHandler()

        //columnListHandler();

        //scalarHandler();

        //mapHandler();

        mapListHandler();

    }

    /**

     * 结果集第八种处理方法，MapListHandler

     * 将结果集每一行存储到Map集合，键：列明，值：数据

     * Map集合过多，存储到List集合

     * @throws SQLException

     */

    public static void mapListHandler() throws SQLException{

        QueryRunner qr=new QueryRunner();

        String sql="select * from sort";

        //调用方法query，传递结果集实现类MapListHandler

        List<Map<String, Object>> list=qr.query(con, sql,new MapListHandler());

        //遍历集合List

        for(Map<String,Object> map:list){

            for(String key:map.keySet()){

                System.out.print(key+"....."+map.get(key)+"\t");

            }

            System.out.println();

        }

    }

    /**

     * 结果集的第七种处理方法，MapHandler

     * 将结果集第一行数据，封装到Map集合中

     * Map<键,值> 键：列名 值：这列的数据

     * @throws SQLException

     */

    public static void mapHandler() throws SQLException{

        QueryRunner qr=new QueryRunner();

        String sql="select * from sort";

        //调用方法query，传递结果集实现类MapHandler

        //返回值：Map集合，Map接口实现类，泛型

        Map<String,Object > map=qr.query(con, sql,new MapHandler());

        for(String key:map.keySet()){

            System.out.println(key+"....."+map.get(key));

        }

    }

    /**

     *  结果集第六种处理方法，ScalarHandler

     *  对于查询后，只有1个结果

     * @throws SQLException

     */

    public static void scalarHandler() throws SQLException{

        QueryRunner qr=new QueryRunner();

        String sql="select count(*) from sort";

        //调用方法query，传递结果集处理实现类scalarHandler

        Long count=qr.query(con, sql,new ScalarHandler<Long>());

        System.out.println(count);

    }

    /**

     * 结果集第五种处理方法，ColumnListHandler

     * 结果集，指定列的数据，存储到List集合

     * List<Object> 每个列数据类型不同

     * @throws SQLException

     */

    public  static void columnListHandler() throws SQLException{

        QueryRunner qr=new QueryRunner();

        String sql="select * from sort";

        //调用方法query，传递结果集实现类

        //实现类构造方法中，使用字符串的列名

        List<Object> list=qr.query(con, sql,new ColumnListHandler<Object>("sname"));

        for(Object obj:list){

            System.out.println(obj);

        }

    }

    /**

     * 结果集第四种处理方法，BeanListHandler

     * 将数据结果集的每一行数据，封装成javaBean对象

     * 多个JavaBean对象封装到List集合中

     * @throws SQLException

     *

     */

    public static void beanListHandler() throws SQLException{

        QueryRunner qr=new QueryRunner();

        String sql="select * from sort";

        //调用方法传递结果集的实现类 BeanListHandler

        List<Sort> result=qr.query(con, sql,new BeanListHandler<Sort>(Sort.class));

        for(Sort r:result){

            System.out.println(r);

        }

    }

    /**

     * 结果集的第三种处理方法，BeanHandler

     * 将结果集的第一行的数据，封装成JavaBean对象     *

     * 注意：被封装成数据到JavaBean对象，Sort类必须有空参数构造

     */

    public static void beanHandler() throws SQLException{

        QueryRunner qr=new QueryRunner();

        String sql="select * from sort where sid=20";

        //调用方法，传递结果集实现类BeanHandler

        //BeanHandler(Class<T> type)

        Sort s=qr.query(con,sql, new BeanHandler<Sort>(Sort.class));

        System.out.println(s);

    }

    /**

     * 结果集第二种处理方法，ArrayListHandler

     * 将结果集的每一行，封装到对象数组中，出现很多对象数据

     * 对象数组存储到List集合

     * @throws SQLException

     *

     */

    public static void arrayListHandler() throws SQLException{

        QueryRunner qr=new QueryRunner();

        String sql="select * from sort where sid>10";

        //调用query方法，结果集处理的参数上，传递实现类ArrayListHandler

        //方法返回值 每行是一个对象数据，存储到List

         List<Object[]> result   =qr.query(con, sql,new ArrayListHandler());

         //集合的遍历

         for(Object[] objs:result){

             for(Object obj:objs){

                 System.out.print(obj+"\t");

             }

             System.out.println();

         }

    }

    /**

      * 结果集第一种处理方法，ArrayHandler

      * 将结果集的第一行存储到对象数组中 Object[]

      * @throws SQLException

      */

    public static void arrayHandler() throws SQLException{

        QueryRunner qr=new QueryRunner();

        String sql="select * from sort where sid=10";

        //调用方法query执行查询，传递连接对象，SQL语句，结果集处理方式实现类

        //返回对象数组

        Object[] result=qr.query(con,sql,new ArrayHandler());

        System.out.println(result.length);

        for(Object obj:result){

            System.out.print(obj+"\t");

        }

    }

}