DbUtils

JunChow520

于 2022-10-06 15:16:38 发布

阅读量351

点赞数

文章标签： java 数据库开发语言

本文链接：https://blog.csdn.net/JunChow520/article/details/127704121

版权

分类	说明
名称	DbUtils
全称	Commons DbUtils
功能	数据库操作组件

Common DbUtils是由Apache组织提供的用于封装JDBC简化DAO层开发的工具类，用于简化JDBC应用程序的开发。

数据表读操作后可将结果集转换为List、Array、Set等Java集合
数据表写操作仅需书写SQL语句
使用JNDI、数据库连接池等技术优化性能
Bean Mapping：自动将结果集封装为JavaBean无需手动封装、类型转换
没有资源泄漏：确保不发生资源泄漏，无需清理或清除代码。

资源地址

类库 https://commons.apache.org/proper/commons-dbutils/download_dbutils.cgi

Maven项目添加DbUtils依赖

$ vim pom.xml

<dependency>
    <groupId>commons-dbutils</groupId>
    <artifactId>commons-dbutils</artifactId>
    <version>1.6</version>
</dependency>

DbUtils包含三个核心类

核心类	说明
DbUtils	数据库连接对象，控制连接、事务、驱动加载...，线程安全。
QueryRunner	SQL语句操作对象，可设置查询结果集的封装策略，线程安全。
ResultSetHandler	封装数据的策略对象，将查询结果集中的数据转换为对象。

DbUtils安装前准备工作

类库	说明
驱动程序	MySQL驱动
数据源	C3P0数据源
数据库操作类	DbUtils

操作流程

创建QueryRunner对象调用query()执行DSL语句或调用update()执行DML语句。

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.28</version>
</dependency>
<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.5.3</version>
</dependency>
<dependency>
    <groupId>commons-dbutils</groupId>
    <artifactId>commons-dbutils</artifactId>
    <version>1.6</version>
</dependency>

JavaBean

JavaBean组件是一个类，用于封装数据，具有以下特性：

需实现java.io.Serializable接口
需提供私有字段
需提供setter/getter方法
需提供无参构造

例如：使用Lombok创建JavaBean

$ vim pom.xml

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.24</version>
    <scope>provided</scope>
</dependency>

将数据表sys_user映射为JavaBean组件

$ vim entity/BaseEntity.java

package com.jc.entity;

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;

import java.io.Serializable;
import java.util.Date;

@Data
public class BaseEntity implements Serializable {
    private static final long serialVersionUID = 1L;

    private Long id;

    private String code;

    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date createdAt;

    private String createdBy;

    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date updatedAt;

    private String updatedBy;
}

$ vim entity/SysUser.java

package com.jc.entity;

import lombok.Data;

@Data
public class SysUser extends BaseEntity{
    private String username;
    private String password;
}

QueryRunner

QueryRunner类是DbUtils库的核心类，此类是线程安全的，它使用可插入策略执行SQL查询以处理ResultSet结果集。

public class QueryRunner extends AbstractQueryRunner

构造方法	示例	说明
无参构造	`QueryRunner qr = new QueryRunner();`	调用`query()`或`update()`方法时需携带`Connection`类型参数
有参构造	`QueryRunner qr = new QueryRunner(DataSource dataSource);`	参数为连接池对象(`DataSource dataSource`)

DSL

查询操作静态方法

qr.query(String sql, ResultSetHandler rsh, Param...)
qr.query(Connection con, String sql, ResultSetHandler rsh, Param...)

参数	说明
Connection con	数据库连接对象，使用有参构造QueryRunner时可不传。
String sql	DSL语句
ResultSetHandler rsh	结果集处理方式
Param	可变参数，对应SQL语句占位符的值。

例如：使用有参构造QueryRunner对象执行查询单条记录操作

try {
    QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());

    Long id = 4L;
    String sql = "SELECT * FROM sys_user WHERE 1=1 AND id = ?";
    ResultSetHandler<SysUser> rsh = new BeanHandler<>(SysUser.class);
    SysUser d = qr.query(sql, rsh, id);
    System.out.println(d.getId());
} catch (SQLException e) {
    e.printStackTrace();
}

例如：使用无参构造QueryRunner对象执行查询单条记录操作

Connection conn = null;
QueryRunner qr = null;

try {
    conn = C3P0Util.getConnection();
    qr = new QueryRunner();
    
    String sql = "SELECT * FROM sys_user WHERE 1=1 AND id = ?";
    ResultSetHandler<SysUser> rsh = new BeanHandler<>(SysUser.class);
    SysUser su = qr.query(conn, sql, rsh, 4);
    System.out.println(su.getId());
} catch (SQLException e) {
    e.printStackTrace();
}finally {
    C3P0Util.release(conn);
}

ResultSetHandler

ResultSetHandler接口负责对结果集转换成对象

public interface ResultSetHandler<T>

结果集处理方式，ResultSetHandler接口实现类。

ResultSetHandler	说明
ArrayHandler	将结果集首行存入数组
ArrayListHandler	将结果集每行数据存入数组，多个数组存入集合List<Object[]>
BeanHandler	将结果集首行数据存入Java Bean对象
BeanListHandler	将结果集每行数据存入Java Bean对象，多个对象存入集合。
ColumnListHandler	将某列数据存入集合
MapHandler	将结果集首行数据存入Map集合
MapListHandler	将结果集每行数据存入Map集合，多个Map存入List集合。
ScalarHandler	获取一个值，比如COUNT(1)、SUM(price)...

DML

qr.update(String sql, Object ...params)

插入/修改/删除

Connection conn = null;
QueryRunner qr = null;

try {
    conn = C3P0Util.getConnection();
    qr = new QueryRunner();

    String username = "root";
    String password = "root";

    String sql = "INSERT INTO sys_user(username, password) VALUES(TRIM(?), MD5(?))";
    int er = qr.update(conn, sql, username, password);
    System.out.println("effected records = " + er);
} catch (SQLException e) {
    e.printStackTrace();
}finally {
    C3P0Util.release(conn);
}

二次封装

获取数据库连接或数据源

$ util/ConnectionFactory.java

package com.jc.util;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

public class ConnectionFactory {
    private static final ConnectionFactory cf = new ConnectionFactory();
    public static ComboPooledDataSource ds;
    private Connection conn = null;

    static {
        Properties p = new Properties();
        try{
            InputStream is = ConnectionFactory.class.getClassLoader().getResourceAsStream("c3p0.properties");
            p.load(is);
            ds = new ComboPooledDataSource();
        }catch (IOException e) {
            e.printStackTrace();
        }
    }

    private ConnectionFactory(){}
    public static ConnectionFactory getInstance(){
        return cf;
    }

    public static ComboPooledDataSource getDataSource(){
        return ds;
    }

    public Connection getConnection(){
        if(ds != null){
            try{
                conn = ds.getConnection();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
        return conn;
    }
}

数据库操作

$ vim util/DBUtil.java

package com.jc.util;

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 DBUtil {
    public static QueryRunner getQueryRunner(){
        return new QueryRunner(ConnectionFactory.getDataSource());
    }

    public static int count(String sql){
        try {
            Object v = getQueryRunner().query(sql, new ScalarHandler<>());
            return v==null?0:(int)v;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }
    public static Object[] getArray(String sql, Object... param){
        try {
            return getQueryRunner().query(sql, new ArrayHandler(), param);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static Map<String, Object> getMap(String sql, Object... param){
        try {
            return getQueryRunner().query(sql, new MapHandler(), param);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static <T> T getBean(Class<T> type, String sql, Object... param){
        try {
            return getQueryRunner().query(sql, new BeanHandler<>(type), param);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static List<Object[]> getArrayList(String sql, Object... param){
        try {
            return getQueryRunner().query(sql, new ArrayListHandler(), param);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static List<Map<String, Object>> getMapList(String sql, Object... param){
        try {
            return getQueryRunner().query(sql, new MapListHandler(), param);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static <T> List<T> getBeanList(Class<T> type, String sql, Object... param){
        try {
            return getQueryRunner().query(sql, new BeanListHandler<>(type), param);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static int insert(String sql, Object... param){
        try {
            return getQueryRunner().update(sql, param);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }
    public static int update(String sql, Object... param){
        try {
            return getQueryRunner().update(sql, param);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }
    public static int delete(String sql, Object... param){
        try {
            return getQueryRunner().update(sql, param);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }
    public static int[] batch(String sql, Object[][] param){
        try {
            return getQueryRunner().batch(sql, param);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void beginTransaction(Connection conn){
        try {
            conn.setAutoCommit(false);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    public static void commit(Connection conn){
        try {
            conn.commit();
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    public static void rollback(Connection conn){
        try {
            conn.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}

测试

try {
    Long id = 4L;
    String sql = "SELECT * FROM sys_user WHERE 1=1 AND id = ?";
    SysUser d = DBUtil.getBean(SysUser.class, sql, id);
    System.out.println(d.getId());
} catch (Exception e) {
    e.printStackTrace();
}