DBUtils框架详解

最新推荐文章于 2023-10-26 15:56:01 发布
最新推荐文章于 2023-10-26 15:56:01 发布
阅读量333 收藏
点赞数
分类专栏： 框架详解 文章标签： sql 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DengShuo_shuai/article/details/120584769
版权

DBUtils框架

DBUtils框架的作用

DBUtils框架能够将将JDBC的方法封装，大大简化了Dao层的操作，且提供出了处理结果集的接口，可以依据项目做拓展。让整个JDBCUitls也变得更加简单。

1.框架处理结果集的接口：

ResultSetHandler（结果集处理的接口）、ColumnRrocessor（列接受器接口）

public interface ResultSetHandler<T> {
    /**
     * 返回的结果集
     * @param resultSet
     * @return
     */
    T handler(ResultSet resultSet) throws SQLException, IllegalAccessException, InstantiationException, InvocationTargetException;
}

public interface ColumnProcessor<T> {
    /**
     * 处理列的数据
     * @param resultSet
     * @return
     */
    T[] handler (ResultSet resultSet) throws SQLException;
}
2.框架的异常处理：

DBUtilException

public class DBUtilException extends RuntimeException {
    private int code;

    private String errorMessage;

    public DBUtilException(int code,String errorMessage){
        super(errorMessage);   //错误信息传递给父异常
        this.code=code;
        this.errorMessage=errorMessage;
    }
}
3. 存放错误码的枚举类：

ResponseCode

public enum ResponseCode {
    SELECT_MANY_NUMBER(555,"查询出多个结果，与预期要求不符"),
    SELECT_RESULT_NONE(444,"结果集为空，与预期不相符合"),
    SELECT_RESULT_ERROR(333,"处理集使用错误"),
    SELECT_PARAMETER_DIFFERENT(222,"参数个数不同，无法参与查询"),
    SELECT_PARAMETER_EMPTY(111,"含有空参数，无法参与查询");
    private int code;
    private String msg;

    private ResponseCode(int code ,String msg){
        this.code = code;
        this.msg = msg;
    }

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}
4. 框架的核心执行类：

QueryRunner：通过处理集处理SQL语句，并返回相应的返回值

public class QueryRunner {

    //设置数据源
    private DataSource dataSource;

    //线程局部变量存储连接对象
    private static ThreadLocal<Connection> local =new ThreadLocal<>();

    //有参构造方法，初始化数据源
    public QueryRunner(DataSource dataSource){
        this.dataSource=dataSource;
    }

    /**
     * 获取连接对象
     * @return 连接对象
     */
    public Connection getConnection() throws SQLException {
        Connection connection=local.get();
        //查看当前local是否存有连接对象
        if(connection!=null){
            return connection;
        }else{
            //从数据源中获取一个新的connection
            connection = dataSource.getConnection();
            //装入local
            local.set(connection);
            return connection;
        }
    }

    /**
     * 对表的更新操作（插入、修改、删除）
     * @param sql sql语句
     * @param args 参数
     * @return 影响行数
     */
    public int update(String sql,Object... args) throws SQLException {
        //获取连接对象
        Connection connection = getConnection();
        //获取提交SQL语句的对象
        PreparedStatement statement = getPreparedStatement(sql, connection, args);
        //提交sql给数据库 获取返回值：受影响的行数
        int rows = statement.executeUpdate();
        close(statement,null);
        return rows;
    }

    /**
     * 增加处理事物的能力
     * @param connection 事务的连接对
     * @param sql sql语句
     * @param args 参数
     * @return 影响的行数
     * @throws SQLException
     */
    public int update(Connection connection,String sql,Object... args) throws SQLException {
        //获取提交SQL语句的对象
        PreparedStatement statement = getPreparedStatement(sql, connection, args);
        //提交sql给数据库 获取返回值：受影响的行数
        int rows = statement.executeUpdate();
        close(statement,null);
        return rows;
    }

    /**
     * 查询数据，根据结果集的处理方式返回
     * @param sql
     * @param resultSetHandler  处理结果集对象
     * @param args
     * @param <T>
     * @return
     * @throws SQLException
     */
    public <T> T query(String sql, ResultSetHandler<T> resultSetHandler, Object... args) throws SQLException, IllegalAccessException, InvocationTargetException, InstantiationException {

        //参数判断
        if (StringUtils.isEmpty(sql)||resultSetHandler==null){
            throw new DBUtilException(ResponseCode.SELECT_PARAMETER_EMPTY.getCode(),ResponseCode.SELECT_PARAMETER_EMPTY.getMsg());
        }
        PreparedStatement preparedStatement = getPreparedStatement(sql, getConnection(), args);
        //获取返回结果集
        ResultSet resultSet = preparedStatement.executeQuery();
        T t = resultSetHandler.handler(resultSet);
        close(preparedStatement,resultSet);
        return t;
    }


    /**
     * 处理SQL语句的方法
     * @param sql
     * @param connection
     * @param args
     * @return
     * @throws SQLException
     */
    private PreparedStatement getPreparedStatement(String sql, Connection connection, Object[] args) throws SQLException {
        PreparedStatement statement = connection.prepareStatement(sql);
        //获取sql参数的元数据
        ParameterMetaData parameterMetaData = statement.getParameterMetaData();
        //获取参数个数（SQL语句中占位符的个数）
        int parameterCount = parameterMetaData.getParameterCount();

        //判断占位符和去args参数个数是否相等
        if (parameterCount!= args.length){
            throw new DBUtilException(ResponseCode.SELECT_PARAMETER_DIFFERENT.getCode(), ResponseCode.SELECT_PARAMETER_DIFFERENT.getMsg());
        }
        //循环设置SQL中的占位符
        for (int i = 0; i < parameterCount; i++) {
            statement.setObject(i+1, args[i]);
        }
        return statement;
    }

    public void close(PreparedStatement statement,ResultSet resultSet) throws SQLException {
        Connection connection = local.get();
        if (resultSet!=null){
            resultSet.close();
        }
        if (statement!=null){
            statement.close();
        }
        if(null!=connection){
            connection.close();
            local.remove();
        } 
    }
}
5. 基础的结果集处理器和列处理器

BeanHandler：处理查询到的单行数据

/**
 * 返回单行值，自动封装为对象
 * @param <T>
 */
public class BeanHandler<T> implements ResultSetHandler<T> {
    //设置封装对象
    private Class laCass;

    public BeanHandler(Class laCass){
        this.laCass=laCass;
    }
    @Override
    public T handler(ResultSet resultSet) throws SQLException, IllegalAccessException, InstantiationException, InvocationTargetException {
        //获取结果集的元数据
        ResultSetMetaData metaData = resultSet.getMetaData();
        //通过元数据获取列的数量
        int columnCount = metaData.getColumnCount();

        //开始封装对象
        //利用反射实例化对象
        T t = (T) laCass.newInstance();
        //判断结果集指针下是否有数据
        if (!resultSet.next()){
            return null;
        }
        //获取查询行的数据
        for (int i = 0; i < columnCount; i++) {
            //获取列名
            String columnName = metaData.getColumnName(i + 1);
            //获取值
            Object object = resultSet.getObject(i + 1);
            //使用BeanUtils工具类封装
            BeanUtils.copyProperty(t,columnName,object);
        }
        //再次判断是否有多行数据
        if (resultSet.next()){
            throw new DBUtilException(ResponseCode.SELECT_MANY_NUMBER.getCode(),ResponseCode.SELECT_MANY_NUMBER.getMsg());
        }
        return t;
    }
}

BeanListHandler：处理查询到的多行数据

public class BeanListHandler<T> implements ResultSetHandler<List<T>> {
    //设置封装对象
    private Class laCass;

    public BeanListHandler(Class laCass){
        this.laCass=laCass;
    }

    @Override
    public List<T> handler(ResultSet resultSet) throws SQLException, IllegalAccessException, InstantiationException, InvocationTargetException {
        //获取结果集的元数据
        ResultSetMetaData metaData = resultSet.getMetaData();
        //获取列的数量
        int columnCount = metaData.getColumnCount();

        //创建集合
        List<T> ts = new ArrayList<T>();
        while (resultSet.next()){
            //创建封装对象
            T t = (T) laCass.newInstance();
            for (int i = 0; i < columnCount; i++) {
                //获取列名
                String columnName = metaData.getColumnName(i + 1);
                //获取值
                Object object = resultSet.getObject(i + 1);
                //使用BeanUtils工具类封装
                BeanUtils.copyProperty(t,columnName,object);
            }
            ts.add(t);
        }
        return ts;
    }
}

BeanArrayHandler：处理查询到的单列数据

注：这里使用到了处理单列的列处理器

public class BeanArrayHandler<T> implements ResultSetHandler<T[]> {
    private ColumnProcessor columnProcessor;

    public BeanArrayHandler(ColumnProcessor columnProcessor){
        this.columnProcessor = columnProcessor;
    }
    @Override
    public T[] handler(ResultSet resultSet) throws SQLException {

        if (!resultSet.next()){
            throw new DBUtilException(ResponseCode.SELECT_RESULT_NONE.getCode(), ResponseCode.SELECT_RESULT_NONE.getMsg());
        }
        return (T[]) columnProcessor.handler(resultSet);
    }
}

ColumnProcessor：单列处理器

public class BasicColumnProcessor<T> implements ColumnProcessor<T> {
    private Class aClass;
    public BasicColumnProcessor(Class aClass){
        this.aClass = aClass;
    }

    @Override
    public T[] handler(ResultSet resultSet) throws SQLException {
        //游标还原
        resultSet.beforeFirst();
        //获取结果集中的元数据
        ResultSetMetaData metaData = resultSet.getMetaData();
        //获取返回的列数
        int columnCount = metaData.getColumnCount();
        //判断当前列是否是1
        if (columnCount!=1){
            throw new DBUtilException(ResponseCode.SELECT_RESULT_ERROR.getCode(), ResponseCode.SELECT_RESULT_ERROR.getMsg());
        }
        //创建集合存放数据
        ArrayList<T> ts = new ArrayList<>();
        while (resultSet.next()){
            //获取行的单个数据
            T t = (T) resultSet.getObject(1);
            ts.add(t);
        }
        return getArray(ts);
    }
    public T[] getArray(List<T> tList){
        T[] t = (T[]) Array.newInstance(aClass,tList.size());
        for (int i = 0; i <tList.size() ; i++) {
            t[i]=tList.get(i);
        }
        return t;
    }
}

在JDBCUtils中使用DBUtils工具类

public class JDBCUtils {
    //定义线程池
    private static DruidDataSource dataSource;

    //静态代码块初始化
    static {
        dataSource = new DruidDataSource();
        dataSource.setUrl("jdbc:mysql:///studentsystem?useUnicode=true&characterEncoding=UTF-8");
        dataSource.setUsername("root");
        dataSource.setPassword("1234");
    }

    /**
     * 返回的QueryRunner对象
     * @return
     */
    public static QueryRunner queryRunner(){
        return new QueryRunner(dataSource);
    }
}

Dao层实现类使用示例：

public class UserDAOImpl implements IUserDAO {

    /**
     * 插入数据
     * @param user
     * @throws SQLException
     */
    @Override
    public void insert(User user) throws SQLException {
        JDBCUtils.queryRunner().update("insert into user(userName,password) values(?,?)",user.getUserName(),user.getPassword());
    }

    /**
     * 修改数据
     * @param user
     * @throws SQLException
     */
    @Override
    public void update(User user) throws SQLException {
        JDBCUtils.queryRunner().update("update user set userName=?,password=? where id=?",user.getUserName(),user.getPassword(),user.getId());
    }

    /**
     * 通过id查询
     * @param id
     * @return
     * @throws InvocationTargetException
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    @Override
    public User selectUserById(int id) throws InvocationTargetException, SQLException, InstantiationException, IllegalAccessException {
        return JDBCUtils.queryRunner().query("select * from user where id=?",new BeanHandler<User>(User.class),id);
    }

    /**
     * 查询所有
     * @return
     * @throws InvocationTargetException
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    @Override
    public List<User> select() throws InvocationTargetException, SQLException, InstantiationException, IllegalAccessException {
        return JDBCUtils.queryRunner().query("select * from user",new BeanListHandler<User>(User.class));
    }

    /**
     * 删除数据
     * @param id
     * @throws SQLException
     */
    @Override
    public void delete(int id) throws SQLException {
        JDBCUtils.queryRunner().update("delete from user where id=?",id);
    }
}
最好的硕硕
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
非常好用的数据库框架-LitePal
weixin_43215895的博客
05-31 572
前言： 在使用SQLite的时候，发现修改数据库表很麻烦，需要更改版本号，最重要的是，更新后以前保存的数据就没了！！！这多恐怖啊，其升级具体操作就是先删除原来的表，再新建同名表，也可以使用一些方法将数据不进行保留，但是很麻烦，对于小白来说，很痛苦。那么，万能的开源库就来拯救我们了，别说了，你一定会喜欢上它。LitePal是一款开源的数据库框架，使用对象关系映射模式，（大家在使用Hibernate、...
DbUtils框架概述
weixin_45601120的博客
02-28 129
DbUtils操作简单，功能强大；
DBUtils框架ResultSetHandler接口使用
12-10
DBUtils框架ResultSetHandler接口使用
DBUtils框架jar包
10-18
DBUtils是java编程中的数据库操作实用工具，小巧简单实用。 DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码。
apache dbutils 框架
02-09
包括文件： DdlUtils-1.0.jar DdlUtils-1.0-bin.zip DdlUtils-1.0-doc.zip DdlUtils-1.0-src.zip
dbutils框架
07-29
这是apache组织的开源数据库框架，这里面除了有jar包，还有API文档和源代码
推荐一款绝对不能错过的 ORM 框架 dbVisitor，目前版本 4.3.0
哈库纳
12-18 1428
dbVisitor(原HasorDB) 是一个全功能数据库访问工具，提供对象映射、丰富的类型处理、动态SQL、存储过程、 内置分页方言20+、 支持嵌套事务、多数据源、条件构造器、INSERT 策略、多语句/多结果。并兼容 Spring 及 MyBatis 用法。 它不依赖任何其它框架，因此可以很方便的和任意一个框架整合在一起使用。...
Java DButils框架
凌北辰的博客
11-06 481
Java DButils框架 一、DButils介绍 ​ DButils是Apache软件基金会提供的一个开源数据库工具类库，目的就是为了开发项目简单化。 优点： ​ 简化JDBC应用程序开发，小巧又实用，可以视为一个开发DAO层的简单框架 ​ 在使用DButils之前，Dao层使用的技术是JDBC， JDBC的缺点： ​ 1.数据库链接对象，sql语句操作对象，封装结果集对象，这三大对象会重复定义 ​ 2.封装数据的代码重复，而且操作复杂，代码量大 ​
DBuitils之增删改查
weixin_43654083的博客
11-03 263
JDBC工具类 package com.itheima.jdbc.utils; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; i
DBUtils
一名小白的进阶之路
02-11 6137
一、概念 DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。简要来说就是配合数据库连接池简化对数据库的操作代码，数据库连接池简化了连接操作，而DBUtils简化了增删改查操作，底层由DbUtils工具实现，我们只需要关注用法和了解实现逻辑即可。 二、常用实现类 ArrayHandler：查询到的单个...
Dbutils_详解.docx
05-12
Dbutils_详解，适合初学者学习Dbutils。
Java开发基础(四)——dbutils的使用
热门推荐
simon曦的博客
05-23 3万+
文章目录前言DBUtilsJavaBean组件QueryRunner核心类：ResultSetHandler结果集处理类总结 前言 Java开发基础(二)——JDBC的使用中写到，Java与数据库的连接包括：导包、注册驱动、获取与数据库的连接对象、获取SQL语句的执行者对象、获取结果集对象、关闭连接等。其中连接池包含了注册驱动和获取与数据库连接两个步骤，而dbutils简化了其他步骤。 DBUti...
DBUitil
华材 的专栏
05-03 790
 Common Dbutils是操作数据库的组件，对传统操作数据库的类进行二次封装，可以把结果集转化成List。 补充一下，传统操作数据库的类指的是JDBC（java database connectivity：java数据库连接，java的数据库操作的基础API。）。 DBUtils是java编程中的数据库操作实用工具，小巧简单实用， 特色： 1.对于数据表的读操作，他可以把结果转
实现Unitils对多数据源的支持
teamojiao的专栏
08-24 216
目前淘宝共享中心测试的数据准备主要使用Unitils + DBunit来完成，具体实现请参阅：   http://teamojiao.iteye.com/blog/456782    文中已经提及和如何实现Uitils对Execl文件的 支持，并指出Unitils暂时无法支持多数据源的不足。在TC读写分离项目的测试中，需要同时往不同的数据   库插入测试数据，为此该问题的存在已经大...
DBUtils工具的使用和详解
码上人生的博客
05-15 2万+
DbUtils 是一个jdbc的工具，使用的范围内非常广，主要是为了简化jdbc的代码。核心类：QueryRunner; ResultSetHandler(是一个接口，主要是完成ORM映射，把结果街转化成我们需要的java对象)核心方法： * update();用来执行DDL（DDL：create alert,drop;）; * query();用来执行DML（DML:insert update ...
java record db 框架_JFinal框架学习-----Db+Record
weixin_42388898的博客
02-16 323
在JFinal中，除了Model可以对数据库进行操作之外，JFinal还提供了Db+Record模式来对数据库进行操作。Record相当于一个通用的Model，不同的是Record只能够承载数据，需要借助DB类来进行数据库的操作。而Model类既可承载数据也可以对数据库进行操作。(Record类里只使用Map来存储数据库里每一列的字段，DB类封装了数据库的常用操作：save,update,dele...
DButil框架
微信公众号
10-30 449
对于数据库的增删改查等操作已经有框架实现了 DBUtils是java编程中的数据库操作实用工具，小巧简单实用。DBUtils封装了对JDBC的操作，简化了JDBC操作。可以少写代码。 对于数据表的读操作，他可以把结果转换成List，Array，Set等java集合，便于程序员操作 对于数据表的写操作，也变得很简单（只需写sql语句） 可以使用数据源，使用JNDI，数据库连接池等技术来优化性能–重用
DbUtils框架
最新发布
weixin_53903929的博客
10-26 100
【代码】DbUtils框架。
DBUtils使用详解一
luxiaoyu_sdc的专栏
03-16 2万+
一, 先熟悉DBUtils的API：  简介： DbUtils是一个为简化JDBC操作的小类库。 以下使用的是最新版的commons-dbutils-1.4，先给个简介，以便迅速掌握API的使用。       整个dbutils总共才3个包： 1、包org.apache.commons.dbutils          接口摘要 ResultSetHandler
conda DBUtils
08-03
要在Anaconda中安装DBUtils包，可以按照以下步骤进行操作。首先，打开Anaconda Prompt，然后输入以下安装指令：conda install DBUtils。这样就可以安装DBUtils包了。[1] 需要注意的是，在安装过程中最好打开...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值