JDBC学习笔记(9)——DBUtils的使用

使用DBUtils提供的功能需要使用commons-dbutils-1.6.jar这个JAR包，在Apache官网可以下载到

使用DBUtils进行更新操

测试QueryRunner类的update方法 ,该方法可用于insert,update,delete操作
具体代码实现

    @Test
    public void testQuertRunnerUpdate() {
        // 1.创建QueryRunner的实现类
        String sql = "delete from customers" + " where id in (?,?)";
        Connection connection = null;
        try {
            connection = JDBCTools.getConnection();
            queryRunner.update(connection, sql, 3, 4);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(null, null, connection);
        }
    }

我们可以查看一下update方法的源码，可以看到是调用的是重载形式的update：

conn:数据库连接

sql：SQL语句

params:填充占位符的参数

 public int update(Connection conn, String sql, Object... params) throws SQLException {
        return update(conn, false, sql, params);
    }

看具体实现代码：

 1     private int update(Connection conn, boolean closeConn, String sql, Object... params) throws SQLException {
 2         if (conn == null) {
 3             throw new SQLException("Null connection");
 4         }
 5 
 6         if (sql == null) {
 7             if (closeConn) {
 8                 close(conn);
 9             }
10             throw new SQLException("Null SQL statement");
11         }
12         //封装使用的是PreparedStatement
13         PreparedStatement stmt = null;
14         int rows = 0;
15 
16         try {
17             stmt = this.prepareStatement(conn, sql);
           //填充占位符的操作
18             this.fillStatement(stmt, params);
           //执行更新操作
19             rows = stmt.executeUpdate();
20 
21         } catch (SQLException e) {
22             this.rethrow(e, sql, params);
23 
24         } finally {
25             close(stmt);
26             if (closeConn) {
27                 close(conn);
28             }
29         }
30 
31         return rows;
32     }

可以看到QueryRunner中封装的都是我们所熟悉的基本操作，测试我们的testQuertRunnerUpdate方法，可以发现对应id为3,4的记录已经被删除

测试QueryRunner的查询方法query

// 因为是线程安全的,所以queryRunner可以放到这个位置
    QueryRunner queryRunner = new QueryRunner();

    class MyResultSetHandler implements ResultSetHandler {

        @Override
        public Object handle(ResultSet resultSet) throws SQLException {
            List<Customer> customers = new ArrayList<Customer>();
            while (resultSet.next()) {
                int id = resultSet.getInt(1);
                String name = resultSet.getString(2);
                String email = resultSet.getString(3);
                Date birth = resultSet.getDate(4);
                Customer customer = new Customer(id, name, email, birth);
                customers.add(customer);
            }
            return customers;
        }

    }

    @Test
    public void testQuery() {
        QueryRunner queryRunner = new QueryRunner();
        Connection connection = null;
        try {
            connection = JDBCTools.getConnection();
            String sql = "select id,name,email,birth" + " from customers";
            Object obj = queryRunner.query(connection, sql,
                    new MyResultSetHandler());
            System.out.println(obj);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(null, null, connection);
        }
    }

运行方法可以看到我们要查询的结果：

[Customer [id=1, name=ATGUIGU, email=simale@163.com, birth=2016-05-08], Customer [id=2, name=ABCDE, email=abcd@guigu.com, birth=2016-05-08], Customer [id=5, name=dsv, email=474405914@qq.com, birth=2016-05-10]]

我们查看一下query方法的源码

private <T> T query(Connection conn, boolean closeConn, String sql, ResultSetHandler<T> rsh, Object... params)
            throws SQLException {
        if (conn == null) {
            throw new SQLException("Null connection");
        }

        if (sql == null) {
            if (closeConn) {
                close(conn);
            }
            throw new SQLException("Null SQL statement");
        }

        if (rsh == null) {
            if (closeConn) {
                close(conn);
            }
            throw new SQLException("Null ResultSetHandler");
        }

        PreparedStatement stmt = null;
        ResultSet rs = null;
        T result = null;

        try {
            stmt = this.prepareStatement(conn, sql);
            this.fillStatement(stmt, params);
            rs = this.wrap(stmt.executeQuery());
            result = rsh.handle(rs);

        } catch (SQLException e) {
            this.rethrow(e, sql, params);

        } finally {
            try {
                close(rs);
            } finally {
                close(stmt);
                if (closeConn) {
                    close(conn);
                }
            }
        }

        return result;
    }

其中最关键的是这四个语句：

            stmt = this.prepareStatement(conn, sql);
            this.fillStatement(stmt, params);
            rs = this.wrap(stmt.executeQuery());
            result = rsh.handle(rs);

测试DBUtils工具类 QueryRunner:
 * query(Connection conn,String sql,ResultSetHandler rsh){ 
 * 这三个步骤就是为了得到结果集 
 * stmt = this.prepareStatement(conn, sql);
 * this.fillStatement(stmt, params);
 * rs = this.wrap(stmt.executeQuery());
 * 调用传入的ResultSetHandler对象的handle方法，并且把前面得到的ResultSet对象作为参数传入
 * result =rsh.handle(rs); 
 * 把result作为结果返回 
 * return result
 * }

测试BeanHandler的用法
BeanHandler：把结果集的第一条记录转为创建BeanHandler 对象时传入的Class参数对应的对象。

具体测试代码：

public void testBeanHandler() {
        Connection connection = null;
        try {
            connection = JDBCTools.getConnection();
            String sql = "select id,name,email,birth"
                    + " from customers where id=?";
            Customer customer = queryRunner.query(connection, sql,
                    new BeanHandler(Customer.class), 5);
            System.out.println(customer);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(null, null, connection);
        }
    }

查看源码可以看到query函数中用到的handler函数实现的功能是这样的

  @Override
    public T handle(ResultSet rs) throws SQLException {
        return rs.next() ? this.convert.toBean(rs, this.type) : null;
    }

实现的功能是把结果集的第一条记录转为创建BeanHandler 对象时传入的Class参数对应的对象。

其中的toBean方法的实现方式：(多看源码吧，有点乱了)

    public <T> T toBean(ResultSet rs, Class<T> type) throws SQLException {

        PropertyDescriptor[] props = this.propertyDescriptors(type);

        ResultSetMetaData rsmd = rs.getMetaData();
        int[] columnToProperty = this.mapColumnsToProperties(rsmd, props);

        return this.createBean(rs, type, props, columnToProperty);
    }

测试BeanListHandler的用法
和前面那个差不多，只不过将查询的结果放到了一个List容器中了

    @Test
    public void testBeanListHandler() {
        Connection connection = null;
        try {
            connection = JDBCTools.getConnection();
            String sql = "select id,name,email,birth" + " from customers";
            List<Customer> customers = queryRunner.query(connection, sql,
                    new BeanListHandler(Customer.class));
            System.out.println(customers);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(null, null, connection);
        }
    }

运行结果：

[Customer [id=1, name=ATGUIGU, email=simale@163.com, birth=2016-05-08], Customer [id=2, name=ABCDE, email=abcd@guigu.com, birth=2016-05-08], Customer [id=5, name=dsv, email=474405914@qq.com, birth=2016-05-10]]

测试MapHandler的用法

MapHandler：返回SQL对应的第一条记录对应的Map对象 键：SQL查询的列名(不是列别名) 值：列的值

@Test
    public void testMapHandler() {
        Connection connection = null;
        try {
            connection = JDBCTools.getConnection();
            String sql = "select id,name,email,birth" + " from customers";
            Map<String, Object> result = queryRunner.query(connection, sql,
                    new MapHandler());
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(null, null, connection);
        }
    }

运行结果：

{id=1, name=ATGUIGU, email=simale@163.com, birth=2016-05-08}

测试MapListHandler的用法

MapListHandler:将结果集转为一个Map的List, Map对应查询的一条记录的Map对象

键：SQL查询的列名(不是列别名)
值：列的值 而MapListHandler：返回的多条记录对应的Map集合

@Test
    public void testMapListHandler() {
        Connection connection = null;
        try {
            connection = JDBCTools.getConnection();
            String sql = "select id,name,email,birth" + " from customers";
            List<Map<String, Object>> result = queryRunner.query(connection,
                    sql, new MapListHandler());
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(null, null, connection);
        }
    }

运行结果：

[{id=1, name=ATGUIGU, email=simale@163.com, birth=2016-05-08}, {id=2, name=ABCDE, email=abcd@guigu.com, birth=2016-05-08}, {id=5, name=dsv, email=474405914@qq.com, birth=2016-05-10}]

测试ScalarHandler的用法

ScalarHandle：把结果集转为一个数值(可以是任意基本数据类型和字符串，Date等)返回

@Test
    public void testScalarHandler() {
        Connection connection = null;
        try {
            connection = JDBCTools.getConnection();
            String sql = "select count(id) from customers";
            Object result = queryRunner.query(connection, sql,
                    new ScalarHandler());
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(null, null, connection);
        }
    }

运行结果：3

至此为止我们学习了JDBC中常用的一些知识点，下面我们就使用DBUtils编写通用的DAO(DAO其实就是封装了操作数据库数据的一些方法的接口)

使用DButils编写通用的DAO

第一步：先写一个访问数据的DAO接口

package com.atguigu.jdbc;

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

/**
 * 访问数据的DAO接口
 * 里面定义好访问数据表的各种方法
 * @author Administrator
 * @param T:DAO处理的实体类的类型
 */
public interface DAO {
    /**
     * 批量处理的方法
     * @param connection
     * @param sql
     * @param args:填充占位符的Object[]类型的可变参数
     */
    void batch(Connection connection,
    String sql,Object[] ...args);
    /**
     * 返回一个具体的一个值，例如总人数，平均工资
     * 某一个认得email
     * @param connection
     * @param sql
     * @param args
     * @return
     */
    <E> E getForValue(Connection connection,
    String sql,    Object ...args);
    
    /**
     * 返回T的一个集合
     * @param <T>
     * @param connection
     * @param sql
     * @param args
     * @return
     */
    <T> List<T> getForList(Connection connection,
    String sql,Object ...args);
    /**
     * 返回一个T的对象
     * @param <T>
     * @param connection
     * @param sql
     * @param args 
     * @return
     * @throws Exception 
     */
    <T> T get(Connection connection,String sql,Object ...args) throws Exception;
    /**
     * 
     * @param connection:数据库连接
     * @param sql：SQL语句
     * @param args：填充占位符的可变参数
     */
    void update(Connection connection,String sql,Object ...args);
}

第二步：定义实现该接口的实例类JdbcDAOImpl

package com.atguigu.jdbc;

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

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;

/**
 * 使用QueryRunner提供其具体的实现
 * @author Administrator
 *
 * @param <T>:子类需传入的泛型类型
 */
public class JdbcDAOImpl<T> implements DAO {
    private QueryRunner queryRunner=null;
    private Class<T> type; 
    public  JdbcDAOImpl() {
        queryRunner=new QueryRunner();
        type= (Class<T>) ReflectionUtils.getGenericSuperClass(getClass(),0);
    }
    @Override
    public void batch(Connection connection, String sql, Object[]... args) {
    }

    @Override
    public <E> E getForValue(Connection connection, String sql, Object... args) {
        
        return null;
    }

    @Override
    public  List<T> getForList(Connection connection, String sql,
            Object... args) {
        
        return null;
    }

    @Override
    public  T get(Connection connection, String sql, Object... args) throws Exception {
        
        return  queryRunner.query(connection, sql,
        new BeanHandler<>(type),args);
    }

    @Override
    public void update(Connection connection, String sql, Object... args) {
    }

    
}

第三步：定义一个具体操作的类继承自JdbcDAOImpl

package com.atguigu.jdbc;

public class CustomerDAO extends JdbcDAOImpl<Customer>{
    
}

第四步：我们测试一下我们已经实现的get方法，其他的方法实现过程类似

package com.atguigu.jdbc;

import static org.junit.Assert.*;

import java.sql.Connection;

import org.junit.Test;

public class CustomerDaoTest {
    CustomerDAO customerDAO=new CustomerDAO();

    @Test
    public void testBatch() {
        fail("Not yet implemented");
    }

    @Test
    public void testGetForValue() {
        fail("Not yet implemented");
    }

    @Test
    public void testGetForList() {
        fail("Not yet implemented");
    }

    @Test
    public void testGet() {
        Connection connection=null;
        try {
            connection=JDBCTools.getConnection();
            String sql = "select id,name,email,birth"
                    + " from customers where id=?";
            Customer customer=customerDAO.get(connection, sql, 5);
            System.out.println(customer);
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            JDBCTools.release(null, null, connection);
        }
    }

    @Test
    public void testUpdate() {
        fail("Not yet implemented");
    }

}

运行一下：

Customer [id=5, name=dsv, email=474405914@qq.com, birth=2016-05-10]

可以通过我们的get方法得到我们想要的数据信息

---

个人感悟：把简单的事情做到极致,打扎实的基础,写优秀的代码

本文为博主原创文章，转载请注明出处：http://www.cnblogs.com/ysw-go/
1、本博客的原创原创文章，都是本人平时学习所做的笔记，如有错误，欢迎指正。
2、如有侵犯您的知识产权和版权问题，请通知本人，本人会即时做出处理文章。
3、本博客的目的是知识交流所用，转载自其它博客或网站，作为自己的参考资料的，感谢这些文章的原创人员