DBUtils学习----QueryRunner类

最新推荐文章于 2022-02-11 17:09:45 发布
最新推荐文章于 2022-02-11 17:09:45 发布
阅读量400 收藏
点赞数
分类专栏： Java 数据库

作者：N3verL4nd 
来源：CSDN 
原文：https://blog.csdn.net/x_iya/article/details/77370161 

package org.apache.commons.dbutils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

/**
 * 使用可插拔的策略执行SQL查询，并处理 ResultSet
 * 这个类是线程安全的
 */
public class QueryRunner extends AbstractQueryRunner {

    /**
     * QueryRunner 类的构造函数
     */
    public QueryRunner() {
        super();
    }

    /**
     * 用于控制是否使用 ParameterMetaData 的 QueryRunner 的构造函数
     * pmdKnownBroken：有些数据库驱动不支持 java.sql.ParameterMetaData#getParameterType(int)
     * 如果 pmdKnownBroken设置为 true, 我们不去尝试; 如果设置为 false, 我们去尝试,如果测试不能使用，我们就不再去使用它
     */
    public QueryRunner(boolean pmdKnownBroken) {
        super(pmdKnownBroken);
    }

    /**
     * 使用数据源 DataSource 的 QueryRunner 的构造函数
     * 不带有 Connection 参数的方法将会从 DataSource 中获取
     */
    public QueryRunner(DataSource ds) {
        super(ds);
    }

    /**
     * QueryRunner 的构造函数
     */
    public QueryRunner(DataSource ds, boolean pmdKnownBroken) {
        super(ds, pmdKnownBroken);
    }

    /**
     * 批处理（一批INSERT、UPDATE、DELETE操作）
     * conn：用于执行 SQL 操作的 Connection 对象
     * Connection 由调用者负责关闭
     * sql：SQL语句
     * params：一组查询替换参数，该数组中的每一行都是一组批量替换值
     * 返回每个语句更新的行数组成的int数组
     * 数据库访问出错则抛出 SQLException 异常
     */
    public int[] batch(Connection conn, String sql, Object[][] params) throws SQLException {
        return this.batch(conn, false, sql, params);
    }

    /**
     * 批处理操作
     * Connection 从 构造函数中的 DataSource 参数中获取
     * 该 Connection 必须处于自动提交模式，否则更新将不会被保存
     */
    public int[] batch(String sql, Object[][] params) throws SQLException {
        Connection conn = this.prepareConnection();

        return this.batch(conn, true, sql, params);
    }

    /**
     * 同上
     */
    private int[] batch(Connection conn, boolean closeConn, String sql, 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 (params == null) {
            if (closeConn) {
                close(conn);
            }
            throw new SQLException("Null parameters. If parameters aren't need, pass an empty array.");
        }

        PreparedStatement stmt = null;
        int[] rows = null;
        try {
            stmt = this.prepareStatement(conn, sql);

            for (int i = 0; i < params.length; i++) {
                this.fillStatement(stmt, params[i]);
                stmt.addBatch();
            }
            rows = stmt.executeBatch();

        } catch (SQLException e) {
            this.rethrow(e, sql, (Object[])params);
        } finally {
            close(stmt);
            if (closeConn) {
                close(conn);
            }
        }

        return rows;
    }

    /**
     * 执行一个带有替换参数的SQL SELECT查询
     * 调用者负责关闭连接
     * T：处理器返回对象的类型
     * conn：执行查询的 Connection 对象
     * sql：执行的查询语句
     * rsh：将ResultSet 转换为其他对象的处理器
     * params：可变参数列表，用于替换sql语句中的占位符
     * 由 ResultSetHandler 负责返回相应对象
     * 数据库访问出错则抛出 SQLException 异常
     */
    public <T> T query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) throws SQLException {
        return this.<T>query(conn, false, sql, rsh, params);
    }

    /**
     * 同上，只是不带有可变参数列表
     */
    public <T> T query(Connection conn, String sql, ResultSetHandler<T> rsh) throws SQLException {
        return this.<T>query(conn, false, sql, rsh, (Object[]) null);
    }

    /**
     * 同上，只是不带有 Connection 参数，它会从构造函数的 DataSource 参数中获取
     */
    public <T> T query(String sql, ResultSetHandler<T> rsh, Object... params) throws SQLException {
        Connection conn = this.prepareConnection();

        return this.<T>query(conn, true, sql, rsh, params);
    }

    /**
     * 同上
     */
    public <T> T query(String sql, ResultSetHandler<T> rsh) throws SQLException {
        Connection conn = this.prepareConnection();

        return this.<T>query(conn, true, sql, rsh, (Object[]) null);
    }

    /**
     * 在检查参数后调用查询，以确保没有任何参数值为空。
     * closeConn：True：该方法替我们关闭；false：调用者负责处理
     */
    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 {
            //获得 PreparedStatement 对象
            stmt = this.prepareStatement(conn, sql);
            //填充参数
            this.fillStatement(stmt, params);
            //获得ResultSet
            rs = this.wrap(stmt.executeQuery());
            //将 ResultSet 转换为指定对象
            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;
    }

    /**
     * 执行 SQL INSERT, UPDATE, 或者 DELETE 操作
     * 返回更新的行数
     */
    public int update(Connection conn, String sql) throws SQLException {
        return this.update(conn, false, sql, (Object[]) null);
    }

    /**
     * 同上，带有一个参数
     */
    public int update(Connection conn, String sql, Object param) throws SQLException {
        return this.update(conn, false, sql, new Object[]{param});
    }

    /**
     * 同上，带有可变参数
     */
    public int update(Connection conn, String sql, Object... params) throws SQLException {
        return update(conn, false, sql, params);
    }

    /**
     * 同上
     */
    public int update(String sql) throws SQLException {
        Connection conn = this.prepareConnection();

        return this.update(conn, true, sql, (Object[]) null);
    }

    /**
     * 同上
     */
    public int update(String sql, Object param) throws SQLException {
        Connection conn = this.prepareConnection();

        return this.update(conn, true, sql, new Object[]{param});
    }

    /**
     * 同上
     */
    public int update(String sql, Object... params) throws SQLException {
        Connection conn = this.prepareConnection();

        return this.update(conn, true, sql, params);
    }

    /**
     * 同上
     */
    private int update(Connection conn, boolean closeConn, String sql, 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");
        }

        PreparedStatement stmt = null;
        int rows = 0;

        try {
            stmt = this.prepareStatement(conn, sql);
            this.fillStatement(stmt, params);
            rows = stmt.executeUpdate();

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

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

        return rows;
    }

    /**
     * 执行给定的SQL插入语句
     */
    public <T> T insert(String sql, ResultSetHandler<T> rsh) throws SQLException {
        return insert(this.prepareConnection(), true, sql, rsh, (Object[]) null);
    }

    /**
     * 执行给定的SQL插入语句
     */
    public <T> T insert(String sql, ResultSetHandler<T> rsh, Object... params) throws SQLException {
        return insert(this.prepareConnection(), true, sql, rsh, params);
    }

    /**
     * 执行给定的SQL插入语句
     */
    public <T> T insert(Connection conn, String sql, ResultSetHandler<T> rsh) throws SQLException {
        return insert(conn, false, sql, rsh, (Object[]) null);
    }

    /**
     * 执行给定的SQL插入语句
     */
    public <T> T insert(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) throws SQLException {
        return insert(conn, false, sql, rsh, params);
    }

    /**
     * 执行给定的SQL插入语句
     */
    private <T> T insert(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;
        T generatedKeys = null;

        try {
            stmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            this.fillStatement(stmt, params);
            stmt.executeUpdate();
            //获取自增主键值
            ResultSet resultSet = stmt.getGeneratedKeys();
            generatedKeys = rsh.handle(resultSet);
        } catch (SQLException e) {
            this.rethrow(e, sql, params);
        } finally {
            close(stmt);
            if (closeConn) {
                close(conn);
            }
        }

        return generatedKeys;
    }

    /**
     * 执行给定的多个插入SQL语句
     */
    public <T> T insertBatch(String sql, ResultSetHandler<T> rsh, Object[][] params) throws SQLException {
        return insertBatch(this.prepareConnection(), true, sql, rsh, params);
    }

    /**
     * 执行给定的多个插入SQL语句
     */
    public <T> T insertBatch(Connection conn, String sql, ResultSetHandler<T> rsh, Object[][] params) throws SQLException {
        return insertBatch(conn, false, sql, rsh, params);
    }

    /**
     * 执行给定的多个插入SQL语句
     */
    private <T> T insertBatch(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 (params == null) {
            if (closeConn) {
                close(conn);
            }
            throw new SQLException("Null parameters. If parameters aren't need, pass an empty array.");
        }

        PreparedStatement stmt = null;
        T generatedKeys = null;
        try {
            stmt = this.prepareStatement(conn, sql, Statement.RETURN_GENERATED_KEYS);

            for (int i = 0; i < params.length; i++) {
                this.fillStatement(stmt, params[i]);
                stmt.addBatch();
            }
            stmt.executeBatch();
            ResultSet rs = stmt.getGeneratedKeys();
            generatedKeys = rsh.handle(rs);

        } catch (SQLException e) {
            this.rethrow(e, sql, (Object[])params);
        } finally {
            close(stmt);
            if (closeConn) {
                close(conn);
            }
        }

        return generatedKeys;
    }
}

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


    /**
     * 测试 QueryRunner 类的 update 方法
     */
    @Test
    public void testQueryRunnerUpdate() {
        Connection connection = null;

        String sql = "DELETE FROM persons WHERE id in (?, ?)";

        try {
            connection = JDBCTools.getConnection();
            //返回受影响的行数
            int rows = queryRunner.update(connection, sql, 41, 39);
            System.out.println(rows);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 测试 QueryRunner 类的 insert 方法
     */
    @Test
    public void testQueryRunnerInsert() {
        Connection connection = null;
        String sql = "INSERT INTO persons(name, age, birth, email) VALUES(?, ?, ?, ?)";

        try {
            connection = JDBCTools.getConnection();
            Object[] args= {"测试", 99, new java.sql.Date(new Date().getTime()), "tmd@qq.com"};
            //返回插入数据的主键
            Long id = queryRunner.insert(connection, sql, new ScalarHandler<Long>(), args);
            System.out.println(id);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtils.closeQuietly(connection);
        }
    }

    //自定义 ResultSetHandler
    @Test
    public void testQueryRunnerQuery() {
        Connection connection = null;
        try {
            connection = JDBCTools.getConnection();
            String sql = "SELECT * FROM persons";
            List<Person> list = queryRunner.query(connection, sql, rs -> {
                List<Person> list1 = new ArrayList<>();
                while (rs.next()) {
                    Person person = new Person(rs.getInt(1), rs.getString(2),
                            rs.getInt(3), rs.getDate(4), rs.getString(5));
                    list1.add(person);
                }
                return list1;
            });
            list.forEach(System.out::println);

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtils.closeQuietly(connection);
        }
    }

查询实例

@Override
    public User queryByName(String name) {
        //1.获取数据库操作对象
        QueryRunner run = JDBCUtils.getQueryRunner();
        //2.执行
        String sql = "SELECT * FROM t_user WHERE USERNAME = ?";
        User user = null;
        try {
            user = run.query(sql, new BeanHandler<>(User.class), name);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return user;
    }

--------------------- 
作者：N3verL4nd 
来源：CSDN 
原文：https://blog.csdn.net/x_iya/article/details/77370161 

wangfutai91
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA中DBUtils的QueryRunner类实现增删改查详解
2401_83816970的博客
04-17 779
1、看视频进行系统学习这几年的Crud经历，让我明白自己真的算是菜鸡中的战斗机，也正因为Crud，导致自己技术比较零散，也不够深入不够系统，所以重新进行学习是很有必要的。我差的是系统知识，差的结构框架和思路，所以通过视频来学习，效果更好，也更全面。关于视频学习，个人可以推荐去B站进行学习，B站上有很多学习视频，唯一的缺点就是免费的容易过时。2、读源码，看实战笔记，学习大神思路“编程语言是程序员的表达的方式，而架构是程序员对世界的认知”。所以，程序员要想快速认知并学习架构，读源码是必不可少的。
DBUtils-QueryRunner类对数据表的操作
08-30
JavaWeb之DBUtils-QueryRunner类对数据表的操作
[JavaWeb]关于DBUtils中QueryRunner的一些解读.
weixin_34344403的博客
05-24 164
前言:[本文属于原创分享文章, 转载请注明出处, 谢谢.]前面已经有文章说了DBUtils的一些特性, 这里再来详细说下QueryRunner的一些内部实现, 写的有错误的地方还恳请大家指出.  QueryRunner类 QueryRunner中提供对sql语句操作的API它主要有三个方法　　query() 用于执行select　　update() 用于执行insert/update/dele...
DBUtils中的QueryRunner
zpcqdkf的博客
05-22 456
1：DBUtils中的QueryRunner的使用：　　1.1：QueryRunner中提供了对SQL语句操作的api；　　1.2：主要有三个方法：　　　　1.2.1：query()：用于执行select（查询）；　　　　1.2.2：update()：用于执行insert（插入）/update（更新）/delete（删除）；　　　　1.2.3：batch()：批处理；...
JNDI技术简介和Apache—DBUtils框架(QueryRunner类)
~~~~~~~~~~~~
11-22 4074
这里拷一下PPT中的内容。 JNDI技术简介 JNDI(JavaNaming and Directory Interface)，Java命名和目录接口，它对应于J2SE中的javax.naming包， 这套API的主要作用在于：它可以把Java对象放在一个容器中（JNDI容器），并为容器中的java对象取一个名称，以后程序想获得Java对象，只需通过名称检索即可。 其核心API为Conte
Java基础-DButils工具类（QueryRunner）详解
weixin_33674437的博客
05-13 525
　　　　　　　　　　　Java基础-DButils工具类（QueryRunner）详解 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰 版权声明：原创作品，谢绝转载！否则将追究法律责任。     　　如果只使用JDBC进行开发，我们会发现冗余代码过多，为了简化JDBC开发，本案例我们讲采用apache commons组件一个成员：DBUtils。DBUtils...
Commons-dbutils1.7 jar包.rar
07-26
增删改查使用的类：QueryRunner类+ResultSetHandler类，使用这俩类就可以解决掉。 QueryRunner类的query()方法：new QueryRunner().query(Connection conn, String sql, ResultSetHandler<T> rsh) query方法后面参数...
commons-dbutils-1.6.jar包
10-16
包org.apache.commons.dbutils DbUtils是一个为简化JDBC操作的小类库. 接口摘要 ResultSetHandler 将ResultSet...QueryRunner 使用可插拔的策略执行SQL查询并处理结果集. ResultSetIterator 包装结果集为一个迭代器.
commons-dbutils-1.2.jar
10-16
最开始一样，对数据库进行连接，然后创建QueryRunner类型的对象，由于对数据的管理不返回一个结果集，所以只返回一个int类型的变量。 一样使用数组对sql语句中的占位符进行填充。 最后根据返回的值的大小（和0比），...
commons-dbutils
06-20
commons-dbutils
dbutils java_Java基础-DButils工具类（QueryRunner）详解
weixin_39675728的博客
02-12 143
1 /*2 @author :yinzhengjie3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/4 EMAIL:y1053419035@qq.com5 */67 package cn.org.yinzhengjie.note2;89 import java.sql.Connection;10 import...
JAVA中DBUtils的QueryRunner类实现增删改查详解，我的Java春季历程
m0_63102527的博客
11-09 381
try { pt.load(in); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } public static Connection getCon() { if (ds == null) { try { ds = (DruidDataSource) DruidDataSourceFactory.createDataSource(pt); } catch (Exception e) {
DBUtils的使用QueryRunner查询数据及增删改查
m0_59077137的博客
09-27 1158
使用DBUtils目的是为了简化jdbc的连接，短短两三行代码就可以总结jdbc里面的加载数据、连接数据、编译、编写sql、遍历等问题。 当然在使用之前我们必须要将DBUtils依赖包给导入，下载连接如下 链接：https://pan.baidu.com/s/1R2c9rY5rFMaFtxPbEkR8DQ 提取码：test 第一、使用QueryRunner数据的增删改操作（QueryRunner是由DBUtils包提供的一个工具类，需要引入 commons-dbutils 依赖。它与JdbcTemplat.
DbUtils和QueryRunner
Rocky balboa
02-09 203
DbUtils简介 根据官网的介绍，DbUtils是一种 JDBC Utility Component （翻译过来大概就是：JDBC实用部件），故名思意，和数据库操作有关 官网上的简介也称之为 JDBC helper library ，由此可知，DbUtils是一个工具类库，用来进行数据库通信的 用法 官方原文：The core classes/interfaces in DbUtils are QueryRunner and ResultSetHandler（在 DbUtils 中的核心类/接口为 Que
DBUtils框架QueryRunner的 使用
东方
03-20 876
DBUtils 使用： 开发步骤 （1）copy jar包： （2）核心类： QueryRunner类： （3）使用核心类完成读写，以及批量操作： 写： 删除， 更新： 添加： 调用同一个方法： update() package com.yidongxueyuan.test; import java.io.File; import java.io.FileInputStream; import ...
JDBC--DButils类QueryRunner的使用
sdau_20171819的博客
02-11 2520
1、简介 官网包链接：https://commons.apache.org/proper/commonsdbutils/download_dbutils.cgi 根据官网的介绍，DbUtils是一种 JDBC Utility Component （翻译过来大概就是：JDBC实用部件），故名思意，和数据库操作有关。 官网上的简介也称之为 JDBC helper library ，由此可知，DbUtils是一个工具类库，用来进行数据库通信的。 QueryRunner 中一共有6种方法： execute（执行
【转载】关于DBUtils中QueryRunner的一些解读
weixin_30342827的博客
01-03 122
前面已经有文章说了DBUtils的一些特性, 这里再来详细说下QueryRunner的一些内部实现, 写的有错误的地方还恳请大家指出. QueryRunner类 QueryRunner中提供对sql语句操作的API它主要有三个方法　　query()用于执行select　　update()用于执行insert/update/delete　　batch()批处理1,Query语句...
关于DBUtils中QueryRunner的一些解读
大Z小z的博客
10-08 958
ueryRunner类 QueryRunner中提供对sql语句操作的API 它主要有三个方法 　　query() 用于执行select 　　update() 用于执行insert/update/delete 　　batch() 批处理 1,Query语句 先来看下query的两种形式, 我们这里主要讲第一个方法, 因为我们用C3P0来统一管理connection.(Quer
Java基础学习笔记二十七 DBUtils和连接池
weixin_30933531的博客
07-21 155
DBUtils 如果只使用JDBC进行开发，我们会发现冗余代码过多，为了简化JDBC开发，本案例我们讲采用apache commons组件一个成员：DBUtils。DBUtils就是JDBC的简化开发工具包。需要项目导入commons-dbutils-1.6.jar才能够正常使用DBUtils工具。 DBUtils是java编程中的数据库操作实用工具，小巧简单实用。 DBUtils封装了对J...
commons-dbutils-1.7 jar
最新发布
11-11
1. QueryRunner：用于执行SQL语句，提供了一系列的查询方法，可以方便地执行查询操作并返回结果。 2. ResultSetHandler：用于处理SQL查询结果集，提供了多种实现类如BeanHandler、BeanListHandler、ScalarHandler等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值