Java DButils框架

一、DButils介绍

​ DButils是Apache软件基金会提供的一个开源数据库工具类库，目的就是为了开发项目简单化。

优点：

​ 简化JDBC应用程序开发，小巧又实用，可以视为一个开发DAO层的简单框架

​ 在使用DButils之前，Dao层使用的技术是JDBC，

JDBC的缺点：

​ 1.数据库链接对象，sql语句操作对象，封装结果集对象，这三大对象会重复定义

​ 2.封装数据的代码重复，而且操作复杂，代码量大

​ 3.释放资源的代码重复

​ 总结：程序员在开发的时候，有大量的重复工作，而且开发周期长，效率低

​ DButils框架就是用来解决以上弊端。除此之外DButils可以将结果映射到JavaBean中，也可以将结果转换为Java集合。

二、DButils核心类的功能

1.QueryRunner

​ SQL语句的操作对象，可以设置查询结果集的封装策略，线程安全

​ 构造方法：

​ （1).QueryRunner() 无参数

​ 创建一个与数据库无关的QueryRunner对象，后期再操作数据库，需要手动给一 个Connection对象，它可以手动控制事务。

​ Connection.setAutoCommit(false); 设置手动管理事务

​ Connection.commit(); 提交事务

​ (2).QueryRunner(DataSource ds) 参数：DataSource：数据库连接池对象。

​ 创建一个与数据库关联的queryRunner对象，后期再操作数据库的时候，不需要 Connection对象，自动管理事务。

​

​ 构造函数与增删改查方法的组合：

 QueryRunner  qr =  QueryRunner() //无参构造方法，后面需要指定Connection对象

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

 QueryRunner  qr =  QueryRunner(ds) //有参构造方法，后面不需要指定Connection对象  
 
 qr.update(String sql, Object... params)   

qr.query(String sql, ResultSetHandler<T> rsh, Object... params)

2.静态方法：int update(Connection conn,String sql,Param);

int update(Connection conn,String sql,Param);
//参数一：连接对象（这个在无参构造函数的时候使用，有参构造时不用填写）
//参数二：SQL语句 用来完成对表的查询操作
//参数三：可变参数也就是sql中?对应的值
//返回值：返回受影响的函数

3.静态方法 query(Connction con, String sql,ResultSetHandler rsh, Param);

query(Connction  con, String  sql,ResultSetHandler<T> rsh, Param);
//参数一：连接对象（这个在无参构造函数的时候使用，有参构造时不用填写）
//参数二：SQL语句 用来完成对表的查询操作
//参数三：对应不同的结果集封装策略
//参数四：可变参数也就是sql中?对应的值
//返回值：返回受影响的函数

ResultSetHandle：封装数据的策略对象

将封装结果集中的数据，转换到另一个对象

策略：封装数据到对象的方式（示例：将数据库保存在User、保存到数组、保存到集合）

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集合
KeyedHandler	查询的每一行数据存储到map集合中,将多个map集合再存储到map中

三、javaBean

​ javaBean是一个遵循特定写法的Java类，它通常具有如下特点

​ 1.所有的成员变量都需要用private关键字修饰

​ 2.为类编写一个无参构造方法

​ 3.为类编写一个有参构造方法（全部参数）

​ 4. 为每一个成员编写一对Get/set方法

public class Student {

  private long id;
  private String name;
  
  public Student(){
    
  }
  public Student(long id, String name) {
    this.id = id;
    this.name = name;
  }

  public long getId() {
    return id;
  }

  public void setId(long id) {
    this.id = id;
  }


  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }
}

四、DButils框架的使用

1. 建立分层

​ 主类文件夹 DButilsTest

​ Dao层文件夹 dao

​ Bean层文件夹 Bean

2. 配置文件

​ 设置c3p0-config.xml配置文件。此文件放置在src目录下

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <default-config> <!--默认配置-->
        <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/company?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false&amp;serverTimezone=UTC</property>
        <property name="user">root</property>
        <property name="password"></property>
        <property name="checkoutTimeout">30000</property>
        <property name="idleConnectionTestPeriod">30</property>
        <property name="initialPoolSize">10</property>
        <property name="maxIdleTime">30</property>
        <property name="maxPoolSize">100</property>
        <property name="minPoolSize">10</property>
        <property name="maxStatements">200</property>
    </default-config>

    <named-config name="mysql"> <!--指定名称的配置-->
        <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/company?characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone=UTC</property>
        <property name="user">root</property>
        <property name="password"></property>

        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property> <!-- intergalactoApp adopts a different approach to configuring statement caching -->
        <property name="maxStatements">50</property>
        <property name="maxStatementsPerConnection">5</property> <!-- he's important, but there's only one of him -->
    </named-config>
</c3p0-config>

3. 生成JavaBean文件

​ 可以选择自动生成也可以选择手动操作

​ 自动生成操作：使用Idea企业版或者社区版下载Database Navigator插件

​ 这里推荐Idea企业版，

​ 步骤：单击database，会有一个加号，单击data source的MySQL，输入自己的账户密码，连接地址，Test Connectional测试创建成没成功，创建成功会出现如下图：

选择表右键单击Scriped Excensions 的Generate POJOS groovy，然后选择生成到Bean层文件夹底下

public class Student {

  private long id;
  private String name;
  private String address;
  private double chinese;
  private double english;
  private double math;

  public Student(){

  }

  public Student(long id, String name, String address, double chinese, double english, double math) {
    this.id = id;
    this.name = name;
    this.address = address;
    this.chinese = chinese;
    this.english = english;
    this.math = math;
  }

  public long getId() {
    return id;
  }

  public void setId(long id) {
    this.id = id;
  }


  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }


  public String getAddress() {
    return address;
  }

  public void setAddress(String address) {
    this.address = address;
  }


  public double getChinese() {
    return chinese;
  }

  public void setChinese(double chinese) {
    this.chinese = chinese;
  }


  public double getEnglish() {
    return english;
  }

  public void setEnglish(double english) {
    this.english = english;
  }


  public double getMath() {
    return math;
  }

  public void setMath(double math) {
    this.math = math;
  }

  @Override
  public String toString() {
    final StringBuilder sb = new StringBuilder("Student").append('[')
            .append("id=")
            .append(id)
            .append(",name=")
            .append(name)
            .append(",address=")
            .append(address)
            .append(",chinese=")
            .append(chinese)
            .append(",english=")
            .append(english)
            .append(",math=")
            .append(math)
            .append(']');
    return sb.toString();
  }
}

4.最后一步就可以进行增删改查的操作

import com.cheng.Bean.Emp;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.*;

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

public class EmpDao {
    /**创建c3p0连接池的变量
     * c3p0通过xml文件来配置连接池
     * 1.先配置xml文件
     * 2.将文件放入搭配src文件夹底下
     * 3.定义连接池变量
     * 4.定义连接变量
     * 5.指定数据库驱动程序
     * 6.创建数据库连接池对象给连接池变量
     * 7.创建连接变量对象给上面定义连接变量
     * */
    //创建一个全局的COnnection对象
    public   Connection conn = null;

    //定义连接方法
    public  Connection getConnection(){
        ComboPooledDataSource cpds = null;
        Connection conn = null;
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            //通过连接池获取数据库连接
            cpds = new ComboPooledDataSource();//创建出连接池
            conn = cpds.getConnection();//获取连接对象
            System.out.println("数据库连接创建成功");

        }catch (Exception e){
            System.out.println("数据库创建连接失败");
            e.printStackTrace();
            System.exit(0);
        }
        return conn;
    }

    //定义释放连接的方法
    public void closeAll(Connection conn) throws SQLException {
        if ((conn!=null)||(!conn.isClosed())){
            conn.close();
        }
    }

    //定义增加记录的方法
    //字段对应的是emp里的字段
    //添加与emp相对应的值
    public int insertValues(String sql,Object[] param) throws SQLException {
        //创建QueryRunner对象
        QueryRunner qr = new QueryRunner();
        //调用qr对象的update方法执行sql语句
        int rowcount = qr.update(conn,sql,param);
        //将连接交还连接池
        DbUtils.closeQuietly(conn);
        //返回插入的行数
        return rowcount;
    }


    //定义修改记录的方法
    public int updateValues(String sql,Object[] param) throws SQLException {
        //创建QueryRunner对象
        QueryRunner qr = new QueryRunner();
        //调用qr对象的update方法执行sql语句
        int rowcount = qr.update(conn,sql,param);
        //将连接交还连接池
        DbUtils.closeQuietly(conn);
        //返回更新的行数
        return rowcount;
    }

    //定义删除记录的方法
    public int dropValues(String sql,Object[] param) throws SQLException {
        //创建QueryRunner对象
        QueryRunner qr = new QueryRunner();
        //调用qr对象的update方法执行sql语句
        int rowcount = qr.update(conn,sql,param);
        //将连接交还连接池
        DbUtils.closeQuietly(conn);
        //返回删除的行数
        return rowcount;
    }

    //查询记录
    //不同的resultSetHandler实现类来处理结果集
    //(1)结果集的第一种实现类，ArrayHandle，返回结果集中的一行数据
    public void arrayHandle(String sql,Object[] params) throws SQLException {
        //创建一个QueryRunner对象
        QueryRunner qr  = new QueryRunner();
        //调用qr对象方法并执行sql，创建一个array数组，用来存放返回值
        Object[] ojbjs = qr.query(conn, sql, new ArrayHandler(), params);
        //打印数据
        for (Object obj: ojbjs) {
            System.out.print(obj+"\t");
        }
    }
    //(2)结果集的第二种实现类，ArrayListHandler
    public  void arrayListHandler(String sql,Object[] params) throws SQLException {
        //创建QueryRunner对象
        QueryRunner qr  = new QueryRunner();
        //调用QueryRunner的query方法并执行SQL，创建List对象，用来存放Array数组
        List<Object[]> lsit = qr.query(conn,sql,new ArrayListHandler(),params);
        //遍历打印数据
        for (Object[] objs: lsit) {
            for (Object obj: objs) {
                System.out.print(obj+"\t");
            }
            System.out.println();
        }
    }
    //(3)结果集的第二种实现类，BanHandler 讲结果集的第一行数据存储到java Bean 对象中
    public void  beanHandler(String sql,Object[] params) throws SQLException {
        //创建QueryRunner对象
        QueryRunner qr  = new QueryRunner();
        //调用方法 执行SQL语句，创建JAVABean对象用来存放结果集
        Emp emp = qr.query(conn,sql,new BeanHandler<Emp>(Emp.class),params);
        //打印数据
        System.out.println(emp);
    }
    //（4）结果集的第四种实现类，BenaListHandler，讲结果集存放到JAVABEan对象中
    public void  beanListHandler(String sql,Object[] params) throws SQLException {
        //创建QueryRunner对象
        QueryRunner qr  = new QueryRunner();
        //调用query方法执行sql，创建一个List集合，集合中的元素为JAVABEAN
       List<Emp> list = qr.query(conn,sql,new BeanListHandler<Emp>(Emp.class),params);
          //打印数据
        for (Emp emp:list) {
            System.out.println(emp);
        }
    }
    //5.结果集的第五种实现类，ScalarHandler，适合单个查询，Select语句结果集只有一个值
    public void  scalerHandler(String sql,Object[] params) throws SQLException {
        //创建QueryRunner对象
        QueryRunner qr  = new QueryRunner();
        Object obj = qr.query(conn,sql,new ScalarHandler<Object>("平均工资"),params);
        //打印数据
        System.out.println(obj);
    }


    //6.结果集的第五种实现类 ColumListHandler 存储一个列到集合
    public void columnListHandler(String sql,Object[] params) throws SQLException {
        //创建QueryRunner对象
        QueryRunner qr  = new QueryRunner();
        //调用query方法执行sql，将一列数据存入到集合
        List<Object> list = qr.query(conn,sql,new ColumnListHandler<Object>("姓名"),params);
        //打印数据
        for (Object obj: list) {
            System.out.println(obj);
        }
    }


    //7.结果集的第七种实现类 MApHandler 将结果集的第一行，存入map集合中
    public  void  mapHandler(String sql,Object[] params) throws SQLException {
        //创建QueryRunner对象
        QueryRunner qr  = new QueryRunner();
        //调用query方法执行sql 将返回结果集第一行装入map = 集合中
        Map<String ,Object> map = qr.query(conn,sql,new MapHandler(),params);
        //打印数据
        System.out.println(map);

    }
    //8.结果集的第八种实现类 MapListHandler 将结果集放入到List集合中
    public void  mapListHnadler(String sql,Object[] params) throws SQLException {
        //创建QueryRunner对象
        QueryRunner qr  = new QueryRunner();
        //调用query方法执行sql 把返回的结果集中每一行都装入map中，再装入List集合中
        List<Map<String ,Object>> list = qr.query(conn,sql,new MapListHandler(),params);
        //打印数据
        for (Map map: list) {
            System.out.println(map);
        }
    }
    //9.结果集的第九种实现类，KeyedHandler结果集的每一行数据都纯存到map集合中，将多个map集合在储存到map中
    public void keyedHandler(String sql,Object[] params) throws SQLException {
        //创建QueryRunner对象
        QueryRunner qr  = new QueryRunner();
        //调用query方法执行sql，结果集的每一行数据都储存到map集合中,将多个map集合在储存到map中
        Map<Object,Map<String,Object>> map = qr.query(conn,sql,new KeyedHandler<>(),params);
        for (Object obj:map.keySet()) {
            for (String key:map.get(obj).keySet()) {
                System.out.println(key+"\t"+map.get(obj).get(key)+"\t");
            }
            System.out.println();
        }
    }

调用Dao层底下的EmpDao的操作

import com.cheng.DAO.EmpDao;

import java.sql.SQLException;

public class EmpDaoTest {
    public static void main(String[] args) throws SQLException {
        EmpDao empDao = new EmpDao();
        empDao.conn = empDao.getConnection();
        //调用显示方法
//        empDao.arrayHandle("select *from emp",null);
     
        // empDao.arrayListHandler("select *from emp",null);

        //empDao.beanHandler("select *from emp",null);
        // empDao.beanListHandler("select *from emp",null);
        // empDao.scalerHandler("select avg(sal) as 平均工资 from emp ",null);
        //empDao.columnListHandler("select name as 姓名 from emp ",null);
        //empDao.mapHandler("select *from emp",null);
        empDao.mapListHnadler("select *from emp",null);
//empDao.keyedHandler("select *from emp",null);
        empDao.closeAll(empDao.conn);//关闭连接
    }
    }