DBUtils 封装

• 一、DBUtils

1.QueryRunner的API

       QueryRunner() //由于创建时没有指定数据源，其下的所有操作都要明确的传入Connection，由于是自己传入的Connection对象，可以在传入的Connection对象上进行事务管理
        update(Connection conn, String sql) 
        update(Connection conn, String sql, Object... params) 
        update(Connection conn, String sql, Object param) 
        query(Connection conn, String sql, ResultSetHandler<T> rsh) 
        query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) 

       QueryRunner(DataSource ds) //由于创建是指定了数据源，其下的所有操作都不需要传入Connection，由于是由DBUtils帮住我们管理连接，所以所有的语句都在各自的事务当中，不能手动控制事务
        update(String sql) 
        update(String sql, Object... params) 
        update(String sql, Object param) 
        query(String sql, ResultSetHandler<T> rsh) 
        query(String sql, ResultSetHandler<T> rsh, Object... params) 

2.ResultSetHandler的实现类

      //1.ArrayHandler 将查询结果的第一行转换为一个数组对象返回
        Object[] objs = runner.query("select * from account where name=?",new ArrayHandler() , "c");
        System.out.println(objs);

    //2.ArrayHandler 将查询结果的第一行转换为一个数组对象返回
        List<Object[]> list = runner.query("select * from account",new ArrayListHandler() );
        System.out.println(list);

        //3.BeanHandler,将查询结果的第一行转换为一个JavaBean对象返回
        Account acc = runner.query("select * from account where name=?",new BeanHandler<Account>(Account.class) , "c");
        System.out.println(acc);

        //4.BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
        List<Account> acclist = runner.query("select * from account",new BeanListHandler<Account>(Account.class) );
        System.out.println(acclist);

     //5.MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
        Map map = runner.query("select * from account",new MapHandler() );
        System.out.println(map);

        //6.MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List
        List<Map<String, Object>> maplist = runner.query("select * from account",new MapListHandler() );
        System.out.println(maplist);

        //7.ColumnListHandler：将结果集中某一列的数据存放到List中。
        List<Object> columnList = runner.query("select * from account",new ColumnListHandler(2) );
        System.out.println(columnList);

     //8.KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里(List<Map>)，再把这些map再存到一个map里，其key为指定的列。
        Map<Object, Map<String, Object>> keymap = runner.query("select * from account",new KeyedHandler("id") );
        System.out.println(keymap);

        //9.ScalarHandler: 单值查询
        //select count(*) from account;
        Long count = (Long)runner.query("select count(*) from account",new ScalarHandler(1) );
        System.out.println(count);

3.DBUtils工具类，提供如关闭连接、装载JDBC驱动程序等常规工作的工具类，里面的所有方法都是静态的。

---

• DBUtils工具类（会用）
  1.必须会用
  2.先感叹，再导入jar包。
  
  • commons-dbutils-1.4.jar

3.核心的类和方法
* QueryRunner类（完成增删改查的功能）
* QueryRunner() – 没有帮咱们管理连接
* QueryRunner(DataSource ds) – 传入连接池进来（自己已经帮咱们去管理连接了）

    * int update(String sql, Object... params) 
    * int update(Connection conn, String sql, Object... params)

    *  <T> T query(String sql, ResultSetHandler<T> rsh, Object... params) 
    *  <T> T query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) 

* 总结
    * 如果不使用事务
        * QueryRunner(DataSource ds) 
        * int update(String sql, Object... params) 
        * <T> T query(String sql, ResultSetHandler<T> rsh, Object... params) 

    * 如果使用事务
        *  QueryRunner() 
        *  int update(Connection conn, String sql, Object... params)
        *  <T> T query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) 

    * 为什么有用？
        * 事务加在业务层，在业务层中开启事务，把conn传递到DAO层。
        * 在DAO层编写JDBC的代码（可以使用DBUtils来完成的），

* ResultSetHandler接口，用户使用查询的功能，必须要提供该接口的实现类，提供了9个实现类。
    *  ArrayHandler, ArrayListHandler, BeanHandler, BeanListHandler, ColumnListHandler, KeyedHandler, MapHandler, MapListHandler, ScalarHandler

* DbUtils
    * 和释放资源和管理事务相关的类
    *  static void  commitAndClose(Connection conn)
    *  static void  rollbackAndClose(Connection conn) 
    *  static void  rollback(Connection conn) 
    *  static void  close(Statement stmt)

修改我的工具类（自己修改工具类）

1.代码
/**
* 获取C3P0的连接池
* @return
*/
public static DataSource getDataSource(){
return dataSource;
}

2.代码（测试QueryRunner类）

SetHandler接口的实现类（重点的要掌握）

1.不想使用实现类，没有任何问题，自己定义实现类。
2.使用实现类，编写代码更简单。

    * （掌握）BeanHandler           -- 将一条记录，封装到一个Java对象。Account
    * （掌握）BeanListHandler       -- 将一条记录，封装到一个Java对象中，把这些对象封装到一个List集合中。List<Account>

    * ArrayHandler          -- 将一条记录，封装到一个数组中。
    * ArrayListHandler      -- 将已经记录封装到数组中，把这些数组封装到List集合中。

    * MapHandler            -- 将一条记录，封装到一个Map集合中
    * MapListHandler        -- 将一条记录封装到一个Map集合中，在把map集合封装到List集合中

    * （掌握）ScalarHandler     -- 编写聚集函数。（分页）      
    * ColumnListHandler -- 有可能查询只有某一列数据。（select money from t_account）
    * （掌握）KeyedHandler      -- 把一条记录封装到一个Map集合中，再把Map集合封装到一个大的Map集合。

---

• 代码细节

public class DBUtil {

    private static final Logger logger = Logger.getLogger(DBUtil.class);

    // 打开数据库连接（type: MySQL，Oracle，SQLServer）
    public static Connection openConnection(String type, String host, String port, String name, String username, String password) {
        Connection conn = null;
        try {
            String driver;
            String url;
            if (type.equalsIgnoreCase("MySQL")) {
                driver = "com.mysql.jdbc.Driver";
                url = "jdbc:mysql://" + host + ":" + port + "/" + name;
            } else if (type.equalsIgnoreCase("Oracle")) {
                driver = "oracle.jdbc.driver.OracleDriver";
                url = "jdbc:oracle:thin:@" + host + ":" + port + ":" + name;
            } else if (type.equalsIgnoreCase("SQLServer")) {
                driver = "com.microsoft.jdbc.sqlserver.SQLServerDriver";
                url = "jdbc:sqlserver://" + host + ":" + port + ";databaseName=" + name;
            } else {
                throw new RuntimeException();
            }
            Class.forName(driver);
            conn = DriverManager.getConnection(url, username, password);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
        return conn;
    }

    // 关闭数据库连接
    public static void closeConnection(Connection conn) {
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    // 查询（返回 Array）
    public static Object[] queryArray(QueryRunner runner, String sql, Object... params) {
        Object[] result = null;
        try {
            result = runner.query(sql, new ArrayHandler(), params);
        } catch (SQLException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
        printSQL(sql);
        return result;
    }

    // 查询（返回 ArrayList）
    public static List<Object[]> queryArrayList(QueryRunner runner, String sql, Object... params) {
        List<Object[]> result = null;
        try {
            result = runner.query(sql, new ArrayListHandler(), params);
        } catch (SQLException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
        printSQL(sql);
        return result;
    }

    // 查询（返回 Map）
    public static Map<String, Object> queryMap(QueryRunner runner, String sql, Object... params) {
        Map<String, Object> result = null;
        try {
            result = runner.query(sql, new MapHandler(), params);
        } catch (SQLException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
        printSQL(sql);
        return result;
    }

    // 查询（返回 MapList）
    public static List<Map<String, Object>> queryMapList(QueryRunner runner, String sql, Object... params) {
        List<Map<String, Object>> result = null;
        try {
            result = runner.query(sql, new MapListHandler(), params);
        } catch (SQLException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
        printSQL(sql);
        return result;
    }

    // 查询（返回 Bean）
    public static <T> T queryBean(QueryRunner runner, Class<T> cls, Map<String, String> map, String sql, Object... params) {
        T result = null;
        try {
            if (MapUtil.isNotEmpty(map)) {
                result = runner.query(sql, new BeanHandler<T>(cls, new BasicRowProcessor(new BeanProcessor(map))), params);
            } else {
                result = runner.query(sql, new BeanHandler<T>(cls), params);
            }
            printSQL(sql);
        } catch (SQLException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
        return result;
    }

    // 查询（返回 BeanList）
    public static <T> List<T> queryBeanList(QueryRunner runner, Class<T> cls, Map<String, String> map, String sql, Object... params) {
        List<T> result = null;
        try {
            if (MapUtil.isNotEmpty(map)) {
                result = runner.query(sql, new BeanListHandler<T>(cls, new BasicRowProcessor(new BeanProcessor(map))), params);
            } else {
                result = runner.query(sql, new BeanListHandler<T>(cls), params);
            }
            printSQL(sql);
        } catch (SQLException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
        return result;
    }

    // 查询指定列名的值（单条数据）
    public static Object queryColumn(QueryRunner runner, String column, String sql, Object... params) {
        Object result = null;
        try {
            result = runner.query(sql, new ScalarHandler<Object>(column), params);
        } catch (SQLException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
        printSQL(sql);
        return result;
    }

    // 查询指定列名的值（多条数据）
    public static <T> List<T> queryColumnList(QueryRunner runner, String column, String sql, Object... params) {
        List<T> result = null;
        try {
            result = runner.query(sql, new ColumnListHandler<T>(column), params);
        } catch (SQLException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
        printSQL(sql);
        return result;
    }

    // 查询指定列名对应的记录映射
    public static <T> Map<T, Map<String, Object>> queryKeyMap(QueryRunner runner, String column, String sql, Object... params) {
        Map<T, Map<String, Object>> result = null;
        try {
            result = runner.query(sql, new KeyedHandler<T>(column), params);
        } catch (SQLException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
        printSQL(sql);
        return result;
    }

    // 更新（包括 UPDATE、INSERT、DELETE，返回受影响的行数）
    public static int update(QueryRunner runner, Connection conn, String sql, Object... params) {
        int result = 0;
        try {
            if (conn != null) {
                result = runner.update(conn, sql, params);
            } else {
                result = runner.update(sql, params);
            }
            printSQL(sql);
        } catch (SQLException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e.getMessage(), e);
        }
        return result;
    }

    private static void printSQL(String sql) {
        if (logger.isDebugEnabled()) {
            logger.debug("SQL: " + sql);
        }
    }
}