Apache- DBUtils框架学习

 一、DBUtils DBUtils 的介绍

 　　commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，,DBUtils封装了对JDBC的操作，简化了JDBC操作。可以少写代码。

二、DBUtils的三个核心对象　　

• QueryRunner类
• ResultSetHandler接口
• DBUtils类

　　1、QueryRunner类 (QueryRunner中提供对sql语句操作的API，该类主要是“执行者”的角色，由它来执行“增删改查”等操作、它主要有三个方法)

　　　　query() 用于执行select

　　　　update() 用于执行insert update delete

　　　　batch() 批处理  

　　　　public Object query(Connection conn, String sql, Object[] params, ResultSetHandler rsh) throws SQLException：执行一个查询操作，在这个查询中，对象数组中的每个元素值被用来作为查询语句的置换参数。该方法会自行处理 PreparedStatement 和 ResultSet 的创建和关闭。
　　　　public Object query(String sql, Object[] params, ResultSetHandler rsh) throws SQLException:　几乎与第一种方法一样；唯一的不同在于它不将数据库连接提供给方法，并且它是从提供给构造方法的数据源(DataSource) 或使用的setDataSource 方法中重新获得 Connection。
　　　　public Object query(Connection conn, String sql, ResultSetHandler rsh) throws SQLException : 执行一个不需要置换参数的查询操作。
　　　　public int update(Connection conn, String sql, Object[] params) throws SQLException:用来执行一个更新（插入、更新或删除）操作。
　　　　public int update(Connection conn, String sql) throws SQLException：用来执行一个不需要置换参数的更新操作。
　　　　

package common;

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

import javax.swing.plaf.basic.BasicTableUI.KeyHandler;

import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.KeyedHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.omg.Dynamic.Parameter;

import Entity.UserModel;

/*
 * author   wwj
 * date        2017-01-07
 */
public class DBUtilsExecute {

    private QueryRunner runner; // DBUtils执行类

    private Connection conn; // Connection

    public DBUtilsExecute() {
        this.runner = new QueryRunner();
        this.conn = DBClass.GetConn();
    }

    // 显示数据
    // public Object query(Connection conn, String sql, ResultSetHandler rsh)
    public void ShowData() throws SQLException {
        BeanListHandler<UserModel> handler = new BeanListHandler<UserModel>(UserModel.class);
        List<UserModel> list = runner.query(conn,
                "SELECT s.`EmpId`,s.`EmpCode`,s.`EmpName`,s.`EmpSex`,s.`WorkDate` FROM `sys_employee` s", handler);
        if (list != null) {
            for (UserModel item : list) {
                System.out.print("姓名:" + item.getEmpName() + ",编号:" + item.getEmpCode());
                System.out.println();
            }
        }
        DbUtils.close(conn);
    }

    // 显示列表第一条数据
    // public Object query(Connection conn, String sql, ResultSetHandler rsh)
    public void ShowFirst() throws SQLException {
        BeanHandler<UserModel> handler = new BeanHandler<UserModel>(UserModel.class);
        UserModel user = runner.query(conn,
                "SELECT s.`EmpId`,s.`EmpCode`,s.`EmpName`,s.`EmpSex`,s.`WorkDate` FROM `sys_employee` s", handler);
        if (user != null) {
            System.out.print("姓名:" + user.getEmpName() + ",编号:" + user.getEmpCode());
        }
        DbUtils.close(conn);
    }

    // 显示数据
    // public Object query(Connection conn, String sql, Object[] params,
    // ResultSetHandler rsh)
    public void ShowWhereData() throws SQLException {
        BeanListHandler<UserModel> handler = new BeanListHandler<UserModel>(UserModel.class);
        List<UserModel> list = runner.query(conn,
                "SELECT s.`EmpId`,s.`EmpCode`,s.`EmpName`,s.`EmpSex`,s.`WorkDate` FROM `sys_employee` s where s.`EmpId`>? and s.`EmpId`<?",
                new Object[] { 100, 104 }, handler);
        if (list != null) {
            for (UserModel item : list) {
                System.out.print("姓名:" + item.getEmpName() + ",编号:" + item.getEmpCode());
                System.out.println();
            }
        }
        DbUtils.close(conn);
    }

    // 显示数据
    // KeyedHandler<Object,Map<String, Object>>
    // 查询所有的数据集，选择数据集的某列作为key,然后value中存的数据为 列名:数据
    public void ShowKeyHandler() throws SQLException {
        QueryRunner runber = new QueryRunner();
        Map<Object, Map<String, Object>> dic = runber.query(conn,
                "SELECT s.`EmpId`,s.`EmpCode`,s.`EmpName`,s.`EmpSex`,s.`WorkDate` FROM `sys_employee` s",
                new KeyedHandler(1));
        for (Map.Entry<Object, Map<String, Object>> item : dic.entrySet()) {
            System.out.println("key:" + item.getKey());
            for (Map.Entry<String, Object> chItem : item.getValue().entrySet()) {
                System.out.println(chItem);
            }
        }
        DbUtils.close(conn);
    }

    // 显示数据
    // KeyedHandler<Object,Map<String, Object>>
    // 查询所有的数据集，选择数据集的某列作为key,然后value中存的数据为 列名:数据
    public void ShowMapHandler() throws SQLException {
        QueryRunner runber = new QueryRunner();
        Map<String, Object> dic = runber.query(conn,
                "SELECT s.`EmpId`,s.`EmpCode`,s.`EmpName`,s.`EmpSex`,s.`WorkDate` FROM `sys_employee` s",
                new MapHandler());
        for (Map.Entry<String, Object> Item : dic.entrySet()) {
            System.out.println(Item);
        }
        DbUtils.close(conn);
    }

    // 删除数据
    // public int update(Connection conn, String sql)
    public void DeleteDataItem() throws SQLException {
        int result = runner.update(conn, "delete from sys_employee where EmpName='RW9'");
        if (result > 0) {
            System.out.println("删除成功!");
        }
        DbUtils.close(conn);
    }

    // 删除数据
    // public int update(Connection conn, String sql, Object[] params)
    public void DeleteWhereItem() throws SQLException {
        int result = runner.update(conn, "delete from sys_employee where EmpId=?", new Object[] { 204 });
        if (result > 0) {
            System.out.println("删除成功!");
        }
        DbUtils.close(conn);
    }

    // 批处理
    public void BatchInsert() throws SQLException {
        Object[][] param = new Object[5][]; // 参数
        for (int i = 0; i < 5; i++) {
            param[i] = new Object[] { "wwj" + i, "wwj" + i, 1, 123456 };
        }
        String sql = "INSERT INTO sys_employee (`EmpCode`,`EmpName`,`EmpSex`,`EmpTel`) values(?,?,?,?)";
        int[] result = runner.batch(conn, sql, param);
        if (result.length > 0) {
            System.out.println("添加成功!");
        }
        DbUtils.close(conn);
    }

    // 事务提交
    public void tranTest() throws SQLException {
        int result = 0;
        Connection conn = this.conn; // 确保所有的操作是在一个数据源里
        try {
            conn.setAutoCommit(false); // 开启事务
            QueryRunner runble = new QueryRunner();// 执行类
            result = runble.update(conn, "DELETE FROM test.`sys_employee` WHERE empcode LIKE ?",
                    new Object[] { "cl%" });
            // 设置程序抛出异常
            int testex = 1 / 0;
            conn.commit(); // 事务提交
        } catch (Exception e) {
            result = 0;
            conn.rollback();// 事务回滚
        } finally {
            conn.close();
            if (result > 0) {
                System.out.println("删除成功！");
            }
        }
    }
}

package com.itheima.util;

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

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.KeyedHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.Test;

import com.itheima.entity.User;

public class TestResultSetHandler {
    @Test//ArrayHandler:适合取1条记录。把该条记录的每列值封装到一个数组中Object[]
    public void tese1() throws SQLException{
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        Object[] arr  = qr.query("select * from users", new ArrayHandler());
        
        for (Object o : arr) {
            System.out.println(o);
        }
    }
    
    @Test//ArrayListHandler:适合取多条记录。把每条记录的每列值封装到一个数组中Object[]，把数组封装到一个List中
    public void tese2() throws SQLException{
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        List<Object[]> query = qr.query("select * from users", new ArrayListHandler());
        
        for (Object[] os : query) {
            for (Object o : os) {
                System.out.println(o);
            }
            System.out.println("--------------");
        }
    }
    
    @Test //ColumnListHandler:取某一列的数据。封装到List中。
    public void tese3() throws SQLException{
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        List<Object> list = qr.query("select username,password from users", new ColumnListHandler(1));
        
        for (Object o : list) {
            System.out.println(o);
        }
    }
    
    @Test //KeyedHandler:取多条记录，每一条记录封装到一个Map中，再把这个Map封装到另外一个Map中，key为指定的字段值。
    public void tese4() throws SQLException{
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        //大Map的key是表中的某列数据，小Map中的key是表的列名，所以大Map的key是Object类型，小Map的key是String类型
        Map<Object,Map<String,Object>> map = qr.query("select * from users", new KeyedHandler(1));
        
        for (Map.Entry<Object, Map<String,Object>> m : map.entrySet()) {
            System.out.println(m.getKey());//大Map中key值就是id列的值
            for (Map.Entry<String, Object> mm : m.getValue().entrySet()) {
                System.out.println(mm.getKey()+"\t"+mm.getValue());//取出小Map中的列名和列值
            }
            System.out.println("---------------------");
        }
        
    }
    
    
    @Test//MapHandler:适合取1条记录。把当前记录的列名和列值放到一个Map中
    public void tese5() throws SQLException{
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        Map<String,Object> map = qr.query("select * from users where id=?", new MapHandler(),20);
        
        for (Map.Entry<String, Object> m : map.entrySet()) {
            System.out.println(m.getKey()+"\t"+m.getValue());
        }
        
    }
    
    
    @Test//MapListHandler:适合取多条记录。把每条记录封装到一个Map中，再把Map封装到List中
    public void tese6() throws SQLException{
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        List<Map<String,Object>> list = qr.query("select * from users", new MapListHandler());
        
        for (Map<String, Object> map : list) {
            for (Map.Entry<String, Object> m : map.entrySet()) {
                System.out.println(m.getKey()+"\t"+m.getValue());
            }
            System.out.println("---------------");
        }
    }
    
    @Test //ScalarHandler:适合取单行单列数据
    public void tese7() throws SQLException{
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        Object o = qr.query("select count(*) from users", new ScalarHandler(1));
        System.out.println(o.getClass().getName());
    }
    
    @Test //BeanHandler:适合取单行单列数据
    public void tese8() throws SQLException{
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        User user = qr.query("select * from users where id=?", new BeanHandler<User>(User.class),1);
        System.out.println(user);
    }
    
    
    @Test //BeanListHandler 
    public void tese9() throws SQLException{
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        List<User> list = qr.query("select * from users where id=?", new BeanListHandler<User>(User.class),1);
        
        System.out.println(list.size());
    }
}

 

     2、ResultSetHandler结果处理器 

　　因为 ResultSetHandler 是一个接口，于是Apatche为我们提供了许多实现类。：

• ArrayHandler：把结果集中的第一行数据转成对象数组。
• ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
• BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
• BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
• ColumnListHandler：将结果集中某一列的数据存放到List中。
• KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里，再把这些map再存到一个map里，其key为指定的key。
• MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
• MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List
• ScalarHandler:适合取单行单列数据

 

下面是写的一个小例子:

　　点击下载