DButils工具类和连接池的使用

1. DButils工具类的介绍个三个核心类

   A: DButils工具类的介绍个三个核心类
   a: 概述
      DBUtils是java编程中的数据库操作实用工具，小巧简单实用。
      DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码。
      DBUtils就是JDBC的简化开发工具包。需要项目导入commons-dbutils-1.6.jar才能够正常使用DBUtils工具。
   b: Dbutils三个核心功能介绍
     QueryRunner中提供对sql语句操作的API.
     update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作
     query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) ，用来完成表数据的查询操作
     ResultSetHandler接口，用于定义select操作后，怎样封装结果集.
     DbUtils类，它就是一个工具类,定义了关闭资源与事务处理的方法

2. QueryRunner类的update方法介绍

     a: 方法介绍

     update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作
     使用QueryRunner类,实现对数据表的insert delete update
     调用QueryRunner类的方法 update (Connection con,String sql,Object...param)
     Object...param 可变参数,Object类型,SQL语句会出现?占位符
     数据库连接对象,自定义的工具类传递

   b. 代码实现  

/**
 * QueryRunner类
 * update(Connection conn, String sql, Object... params)
 * 实现表中数据的增、删、改
 * @author vanguard
 *
 */
public class QueryRunnerDemo {
    //获取数据库连接
    private static Connection conn = JDBCUtils.getConnection();
    
    public static void main(String[] args) throws SQLException {
        //insert();
        //delete();
        //update();
    }
    /**
     * 使用QueryRunner类中的update方法，实现更新数据
     * @throws SQLException
     */
    private static void update() throws SQLException {
        //创建QueryRunner类对象
        QueryRunner qr = new QueryRunner();
        //定义更新的sql语句
        String sql = "UPDATE sort SET sname=?,sprice=?,sdesc=? WHERE sid=?";
        ////将四个?占位符的实际参数写在数组中
        Object[] params = {"家居产品", 9000, "涨价了", 2};
        ////调用QueryRunner类的方法update执行SQL语句
        int row = qr.update(conn, sql, params);
        System.out.println(row);
        DbUtils.closeQuietly(conn);
    }
    /**
     *  使用QueryRunner类中的update方法，实现添加数据
     * @throws SQLException
     */
    private static void delete() throws SQLException {
        //创建QueryRunner类对象
        QueryRunner qr = new QueryRunner();
        String sql = "DELETE FROM sort WHERE sid=?";
        //调用QueryRunner类的方法update执行SQL语句
        int row = qr.update(conn, sql, 7);
        System.out.println(row);
        DbUtils.closeQuietly(conn);
    }
    
    /**
     * 使用Q    ueryRunner类中的update方法，实现添加数据
     * @throws SQLException
     */
    private static void insert() throws SQLException {
        //创建QueryRunner类对象
        QueryRunner qr = new QueryRunner();
        String sql = "INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
        //将三个?占位符的实际参数写在数组中
        Object[] params = {"体育用品", 200.98, "购买体育用品"};
        //调用QueryRunner类的方法update执行SQL语句
        int row = qr.update(conn, sql, params);
        System.out.println(row);
        DbUtils.closeQuietly(conn);
    }
}

3. DBUtils工具类结果集处理的方式

   a: QueryRunner实现查询操作
     query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) ，用来完成表数据的查询操作
   b: ResultSetHandler结果集处理类
    ArrayHandler 将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
    ArrayListHandler 将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
    BeanHandler 将结果集中第一条记录封装到一个指定的javaBean中。
    BeanListHandler 将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
    ColumnListHandler 将结果集中指定的列的字段值，封装到一个List集合中
    ScalarHandler 它是用于单数据。例如select count(*) from 表操作。
    MapHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据
    MapListHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据,Map集合存储到List集合

4. QueryRunner类的方法query
  a: QueryRunner类的方法query数据查询操作
    调用QueryRunner类方法query(Connection con,String sql,ResultSetHandler r, Object..params)
    ResultSetHandler r 结果集的处理方式,传递ResultSetHandler接口实现类
    Object..params SQL语句中的?占位符
    注意: query方法返回值,返回的是T 泛型, 具体返回值类型,跟随结果集处理方式变化

  b:代码实现：   

/**
 * 使用QueryRunner类中的
 * query(Connection conn, String sql, ResultSetHandler<T> rsh, 
 *                         Object... params)
 * 完成对数据的查询操作
 * ResultSetHandler结果集处理类 8中处理结果集的方式
 *  ArrayHandler    将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
 *  ArrayListHandler    将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
 *  BeanHandler    将结果集中第一条记录封装到一个指定的javaBean中。
 *  BeanListHandler    将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
 *  ColumnListHandler    将结果集中指定的列的字段值，封装到一个List集合中
 *  ScalarHandler    它是用于单数据。例如select count(*) from 表操作。
 *  MapHandler    将结果集第一行封装到Map集合中,Key 列名, Value 该列数据
 *  MapListHandler    将结果集第一行封装到Map集合中,Key 列名, Value 该列数据,Map集合存储到List集合
 * @author vanguard
 *
 */
public class QueryRunnerDmoe01 {
    private static Connection conn = JDBCUtils.getConnection();
    
    public static void main(String[] args) throws SQLException {
        //arrayHandler();
        //arrayListHandler();
        //beanHandler();
        //beanListHandler();
        //columnListHandler();
        //scalarHandler();
        //mapHandler();
        mapListHandler();
    }
    
    /**
     * 结果集处理的第八种方式MapListHandler
     * 将结果集的每一行结果封装到Map集合中，Key 列名，Value 该列的数据
     * 将Map集合放到List集合中
     * @throws SQLException
     */
    private static void mapListHandler() throws SQLException {
        //创建QueryRunner类对象
        QueryRunner qr = new QueryRunner();
        //定义查询的sql语句
        String sql = "SELECT * FROM sort";
        //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
        List<Map<String, Object>> list = qr.query(conn, sql, new MapListHandler());
        //遍历List集合
        for(Map<String, Object> map : list) {
            for(String row : map.keySet()) {
                System.out.print(row + ":" + map.get(row) + "	");
            }
            System.out.println();
        }
    }

    /**
     * 结果集处理的第七种方式MapHandler
     * 将结果集的第一行数据封装到Map集合中 Key 列名 Value 该列数据
     * @throws SQLException
     */
    private static void mapHandler() throws SQLException {
        //创建QueryRunner类对象
        QueryRunner qr = new QueryRunner();
        //定义查询的sql语句
        String sql = "SELECT * FROM sort";
        //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
        Map<String, Object> map = qr.query(conn, sql, new MapHandler());
        for(String row : map.keySet()) {
            System.out.print(row + ":" + map.get(row) + "  ");
        }
    }

    /**
     * 结果集处理的第六种方式ScalarHandler
     * 它用于单数据，对于查询后只有一个结果
     * @throws SQLException
     */
    private static void scalarHandler() throws SQLException {
        //创建QueryRunner类对象
        QueryRunner qr = new QueryRunner();
        //定义查询的sql语句
        String sql = "SELECT COUNT(*) FROM sort";
        //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
        long count = qr.query(conn, sql, new ScalarHandler<Long>());
        System.out.println(count);
    }
    
    /**
     * 结果集处理的第五种方式ColumnListHandler
     * 将结果集中指定列的字段值封装到list集合中
     * @throws SQLException
     */
    private static void columnListHandler() throws SQLException {
        //创建QueryRunner类对象
        QueryRunner qr = new QueryRunner();
        //定义查询的sql语句
        String sql = "SELECT * FROM sort";
        //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
        List<String> list = qr.query(conn, sql, new ColumnListHandler<String>("sname"));
        for(String name : list) {
            System.out.println(name);
        } 
    }

    /**
     * 结果集处理的第四种方式BeanListHandler
     * 将结果集中每一条数据封装到JavaBean对象中
     * 将这些JavaBean对象放到list集合中
     * @throws SQLException
     */
    private static void beanListHandler() throws SQLException {
        //创建QueryRunner类对象
        QueryRunner qr = new QueryRunner();
        //定义查询的sql语句
        String sql = "SELECT * FROM sort";
        //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
        List<Sort> list = qr.query(conn, sql, new BeanListHandler<Sort>(Sort.class));
        //遍历list集合
        for(Sort s : list) {
            System.out.println(s);
        }
    }

    /**
     * 结果集处理的第三种方式BeanHandler
     * 将结果集中的第一条数据封装到JavaBean对象中
     * 注意：被封装成数据到JavaBean对象，Sort类中必须有空参构造
     * @throws SQLException
     */
    private static void beanHandler() throws SQLException {
        //创建QueryRunner类对象
        QueryRunner qr = new QueryRunner();
        //定义查询的sql语句
        String sql = "SELECT * FROM sort";
        //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
        Sort s = qr.query(conn, sql, new BeanHandler<Sort>(Sort.class));
        System.out.println(s);
    }

    /**
     * 结果集处理的第二种方式ArrayListHandler
     * 将结果集的每一行封装到Object[]数组中
     * 将这些数组放到list集合中
     * @throws SQLException
     */
    private static void arrayListHandler() throws SQLException {
        //创建QueryRunner类对象
        QueryRunner qr = new QueryRunner();
        //定义查询的sql语句
        String sql = "SELECT * FROM sort";
        //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
        List<Object[]> list = qr.query(conn, sql, new ArrayListHandler());
        for(Object[] objs : list) {
            for(Object obj : objs) {
                System.out.print(obj + "		");
            }
            System.out.println();
        }
    }

    /**
     * 结果集处理的第一种方式ArrayHandler
     * 将结果集的第一行封装到Object[]数组中
     * @throws SQLException 
     */
    private static void arrayHandler() throws SQLException {
        //创建QueryRunner类对象
        QueryRunner qr = new QueryRunner();
        //定义查询的sql语句
        String sql = "SELECT * FROM sort";
        //调用query()执行查询操作，传递连接对象，SQL语句，结果处理类方式的实现类
        Object[] objects = qr.query(conn, sql, new ArrayHandler());
        //遍历数组
        for(Object obj : objects) {
            System.out.print(obj + "  ");
        }
    }
}

public class Sort {
    private int sid;
    private String sname;
    private int sprice;
    private String sdesc;
    
    public Sort() {}
    
    public Sort(int sid, String sname, int sprice, String sdesc) {
        super();
        this.sid = sid;
        this.sname = sname;
        this.sprice = sprice;
        this.sdesc = sdesc;
    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public int getSprice() {
        return sprice;
    }

    public void setSprice(int sprice) {
        this.sprice = sprice;
    }

    public String getSdesc() {
        return sdesc;
    }

    public void setSdesc(String sdesc) {
        this.sdesc = sdesc;
    }

    @Override
    public String toString() {
        return "Sort [sid=" + sid + ", sname=" + sname + ", sprice=" + sprice
                + ", sdesc=" + sdesc + "]";
    }
    
    
}

5. 连接池介绍
  1）: 连接池介绍
    a: 连接池介绍
      实际上就是存放连接的池子(容器)
     在开发中“获得连接”或“释放资源”是非常消耗系统资源的两个过程
     为了解决此类性能问题，通常情况我们采用连接池技术，来共享连接Connection。
     这样我们就不需要每次都创建连接、释放连接了，这些操作都交给了连接池

 2）: 连接池概念规范和DataSource接口
   a: 连接池概念规范
     用池来管理Connection，这样可以重复使用Connection。
     不用自己来创建Connection，而是通过池来获取Connection对象
     使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池
     连接池技术可以完成Connection对象的再次利用
   b: DataSource接口
     Java为数据库连接池提供了公共的接口：javax.sql.DataSource
     各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池
     常见的连接池：DBCP、C3P0

 3）: DBCP连接池介绍
   a: DBCP连接池介绍
     DBCP也是一个开源的连接池，是Apache Common成员之一，在企业开发中也比较常见，tomcat内置的连接池

 4）: 导入jar包
   a: jar包介绍
    mysql-connector-java-5.1.37-bin.jar：数据库驱动
    commons-dbutils-1.6.jar：提供QueryRunner类方便进行增删改查操作
    commons-dbcp-1.4.jar：
    commons-pool-1.5.6.jar：提供高效的数据库连接池技术
  b: 导入jar包
    在项目根路径下建立文件夹lib
    拷贝以上jar包，选定拷贝的jar包/右键/Build Path/Add to Build Path

 5）: BasicDataSource类的使用
   a: 案例代码

      

/**
 * 连接池
 * 连接池jar包中定义好了一个类DataSource
 * 实现该类数据源的规范接口 javax.sql.DataSource
 * @author vanguard
 *
 */
public class DataSourceDemo {
    public static void main(String[] args) {
        //创建DataSource类接口的实现类对象
        BasicDataSource datasource = new BasicDataSource();
        //连接数据库的四个基本信息可以通过setXXX方法设置
        datasource.setDriverClassName("com.mysql.jdbc.Driver");
        datasource.setUrl("jdbc:mysql://localhost:3306/mybase");
        datasource.setUsername("root");
        datasource.setPassword("root");
        
        //调用对象的方法获取数据库连接
        try {
            Connection conn = datasource.getConnection();
            System.out.println(conn);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("数据库连接失败");
        }
    }
}

 6）: BasicDataSource类的常见配置
   a: 常见配置
     分类 属性 描述
     必须项
      driverClassName 数据库驱动名称
      url 数据库的地址
      username 用户名
      password 密码
   基本项（扩展）
      maxActive 最大连接数量
      minIdle 最小空闲连接
      maxIdle 最大空闲连接
      initialSize 初始化连接

 7）: 实现数据库连接池工具类
    a: 案例代码
      

/**
 *  使用DBCP实现数据库的连接池
 *  连接池配置,自定义类,
 *  最基本四项完整
 *  对于数据库连接池其他配置,自定义
 * @author vanguard
 *
 */
public class JDBCPoolUtils {
    //创建出BasicDataSource类对象
    private static BasicDataSource datasource = new BasicDataSource();
    
    //静态代码块，对BasicDataSource类进行配置
    static {
        //数据库连接信息，必须的
        datasource.setDriverClassName("com.mysql.jdbc.Driver");
        datasource.setUrl("jdbc:mysql://localhost:3306/stdb");
        datasource.setUsername("root");
        datasource.setPassword("root");
        //对象连接池中的连接数量配置，可选
        datasource.setInitialSize(10);//初始化的连接数
        datasource.setMaxActive(8);//最大的连接数
        datasource.setMaxIdle(5);//最大空闲数
        datasource.setMinIdle(2);//最小空闲数
    }
    /**
     * 返回BasicDataSource类对象
     * @return
     */
    public static DataSource getDataSource() {
        return datasource;
    }
}

 8）: 工具类的测试
   a: 案例代码

/**
 * 测试写好的工具类
 * 提供的是一个DataSource接口的数据源
 *  QueryRunner类构造方法,接收DataSource接口的实现类
 *  后面,调用方法update,query,无需传递他们Connection连接对象
 * @author vanguard
 *
 */
public class QueryRunnerDemo {
    private static QueryRunner qr = new QueryRunner(JDBCPoolUtils.getDataSource());
    
    public static void main(String[] args) {
        //insert();
        select();
    }
    /**
     * 定义查询数据的方法
     */
    private static void select() {
        String sql = "SELECT * FROM sort";
        try {
            List<Object[]> list = qr.query(sql, new ArrayListHandler());
            for(Object[] objs : list) {
                for(Object obj : objs) {
                    System.out.print(obj + "	");
                }
                System.out.println();
            }
        } catch (SQLException e) {
            
            e.printStackTrace();
            throw new RuntimeException("数据库查询失败");
        }
    }

    /**
     * 定义添加数据的方法
     */
    private static void insert() {
        String sql = "INSERT INTO sort(sname,sprice,sdesc) VALUES(?,?,?)";
        Object[] params = {"水果", 20.5, "桃子便宜了"};
        try {
            int row = qr.update(sql, params);
            System.out.println(row);
        } catch (SQLException e) {
            
            e.printStackTrace();
            throw new RuntimeException("数据添加失败");
        }
    }
}