java—将查询的结果封装成List与用回调函数实现数据的动态封装（44）

 手工的开始QueryRunner类。实现数据封装：

　MapListHandler

  ＭapHandler

  BeanListHandler

  BeanHandler

第一步：基本的封装测试

       写一个类，QueryRunner，实现一个方法query(sql)- List<map>

package cn.itcast.dbutils;



import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.sql.DataSource;

public class QueryRunner {

    //接收一个ds

    private DataSource ds;

    public QueryRunner() {

    }

    public QueryRunner(DataSource ds) {

        this.ds = ds;

    }

    /**

     * 只封装成List<Map>

     */

    public List<Map<String,Object>> query(String sql){

        //封装数据用

        List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();//声明返回的对象

        Connection con = null;

        try{

            con = ds.getConnection();

            //执行查询

            Statement st = con.createStatement();

            ResultSet rs = st.executeQuery(sql);

            //分析结果集

            ResultSetMetaData rsmd = rs.getMetaData();

            //获取列数

            int cols = rsmd.getColumnCount(); 

            //遍历数据

            while(rs.next()){

                //一行数据

                Map<String,Object> mm = new HashMap<String, Object>();

                //遍历列

                for(int i=0;i<cols;i++){

                    //获取列名

                    String colName = rsmd.getColumnName(i+1);

                    //获取数据

                    Object val     = rs.getObject(i+1);

                    //封装到map

                    mm.put(colName, val);

                }

                //将这个map放到list

                list.add(mm);

            }

            

        }catch(Exception e){

            throw new RuntimeException(e);

        }finally{

            try {

                con.close();

            } catch (SQLException e) {

                e.printStackTrace();

            }

        }

        return list;

    }

}

用回调函数实现数据的动态封装

回调是指在执行时，具体的封装处理工用由第三方的类来实现。

       回调一般由两部分组成：

       １：调用类　－　QueryRunner。实例类

       ２：回调规范 – ResultSetHandler。一般是一个接口。

       ３：回调规范定义回调方法且这个方法由调用类调用。

package cn.itcast.demo;

import java.util.ArrayList;

import java.util.List;

import org.junit.Test;

public class ThreadDemo {

    /**

     * 测试泛型

     * @throws Exception

     */

    @Test

    public void aa() throws Exception{

       //泛型，在运行时是没有地。

       List<String> list = new ArrayList<String>();

       list.add("ddd");

       List list2 = list;

       list2.add(777);

       list.getClass().getMethod("add",Object.class).invoke(list,909);

       for(Object o:list){

           System.err.println(o+","+o.getClass());

       }

    }

    /**

     * 测试线程

     * @param args

     */

    public static void main(String[] args) {

       new Thread(

              new Runnable() {

                  public void run() {

                     System.err.println("Ｂ这是runnable.run。。。。");

                  }

              }

       ){

           public void run() {

              super.run();//调用父类的方法，以执行runnalble.run

              System.err.println("Ａ这是thread.run....");

           };

       }.start();

    }

}