| 分类 | 说明 |
|---|---|
| 名称 | DbUtils |
| 全称 | Commons DbUtils |
| 功能 | 数据库操作组件 |
Common DbUtils是由Apache组织提供的用于封装JDBC简化DAO层开发的工具类，用于简化JDBC应用程序的开发。
- 数据表读操作后可将结果集转换为List、Array、Set等Java集合
- 数据表写操作仅需书写SQL语句
- 使用JNDI、数据库连接池等技术优化性能
- Bean Mapping：自动将结果集封装为JavaBean无需手动封装、类型转换
- 没有资源泄漏：确保不发生资源泄漏，无需清理或清除代码。
资源地址
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();
}
