Java轻量级ORM工具--DbUtils使用

一、概述

DbUtil是一个非常经量级的ORM工具，不属于一个ORM框架，只提供数据库操作的简单实现，包含增、删、改、查、批量以及事务等操作。

二、功能介绍

采用配置文件properties配置数据库信息；

采用java.util.Properties来加载配置文件；

使用dbcp连接池技术；

三、相关数据表

DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  `inserttime` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

四、配置文件

#mysql database setting
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

#dbcp settings
dbcp.maxIdle=2
dbcp.maxActive=5
dhcp.maxActive=10
dbcp.defaultAutoCommit=true

五、整体结构



六、具体代码

1、用户对象

package com.dto;

import java.sql.Timestamp;

public class UserDto implements java.io.Serializable {
private static final long serialVersionUID = 1L;
private Integer id;
private String username;
private String password;
private Timestamp inserttime;

public UserDto() {
}

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public String getUsername() {
return username;
}

public void setUsername(String username) {
this.username = username;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public Timestamp getInserttime() {
return inserttime;
}

public void setInserttime(Timestamp inserttime) {
this.inserttime = inserttime;
}

}

2、配置文件解析类

package com.config;

import java.io.InputStream;
import java.util.HashMap;
import java.util.Properties;

/**
 * 读取*.properties配置文件
 */
public class PropertiesConfig {

// 配置文件的map key:propertiesName value:PropertiesUtil对象
private static HashMap propertiesMap = new HashMap();

// 属性文件
private Properties properties;

private PropertiesConfig() {

}

public synchronized static PropertiesConfig getInstance(String propertiesName) {

PropertiesConfig configUtil = propertiesMap.get(propertiesName);

if (configUtil == null) {
configUtil = new PropertiesConfig();
configUtil.analysisXml(propertiesName);
propertiesMap.put(propertiesName, configUtil);
}

return configUtil;
}

private void analysisXml(String propertiesName) {
InputStream ins = getClass().getResourceAsStream(propertiesName);
properties = new Properties();
try {
properties.load(ins);
} catch (Exception e) {
e.printStackTrace();
}
}

public String getProperty(String key) {
return properties.getProperty(key);
}

}

3、配置文件服务类

package com.config;

/**
 * properties服务类
 */
public class PropertiesService {

/**
 * application配置文件
 * 
 * @return
 */
public static PropertiesConfig getApplicationConfig() {
return PropertiesConfig.getInstance("/application.properties");
}
}

4、工具类

package com.utils;

public class CommonUtil {
public static int objectToInteger(Object obj) {
try {
if (obj != null && !obj.toString().trim().equals(""))
return Integer.parseInt(obj.toString());
} catch (Exception ex) {
ex.printStackTrace();
return 0;
}
return 0;
}
}

5、封装DbUtils的工具类DbBuilder

package com.utils;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.KeyedHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.apache.log4j.Logger;

import com.config.PropertiesConfig;
import com.config.PropertiesService;
import com.dto.UserDto;

public class DbBuilder {
private static DataSource dataSource;
private static Logger logger = Logger.getLogger(DbBuilder.class);

private DbBuilder() {
}

public static DataSource getDataSource() {
if (DbBuilder.dataSource == null) {
try {
PropertiesConfig config = PropertiesService.getApplicationConfig();
BasicDataSource dbcpDataSource = new BasicDataSource();
dbcpDataSource.setUrl(config.getProperty("jdbc.url"));
dbcpDataSource.setDriverClassName(config.getProperty("jdbc.driver"));
dbcpDataSource.setUsername(config.getProperty("jdbc.username"));
dbcpDataSource.setPassword(config.getProperty("jdbc.password"));
dbcpDataSource.setDefaultAutoCommit(Boolean.parseBoolean(config.getProperty("dbcp.defaultAutoCommit")));
dbcpDataSource.setMaxActive(Integer.parseInt(config.getProperty("dbcp.maxActive")));
dbcpDataSource.setMaxIdle(Integer.parseInt(config.getProperty("dbcp.maxIdle")));
dbcpDataSource.setMaxWait(Integer.parseInt(config.getProperty("dbcp.maxActive")));
DbBuilder.dataSource = (DataSource) dbcpDataSource;
logger.info("dbcp数据源初始化成功!");
} catch (Exception ex) {
logger.info("dbcp数据源初始化失败:" + ex.getMessage());
}
}
return DbBuilder.dataSource;
}

public static Connection getConnection() {
try {
DataSource dataSource = DbBuilder.getDataSource();
return dataSource.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}

public static void close(Connection connection) {
try {
if (connection != null)
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}

public static QueryRunner getQueryRunner() {
return new QueryRunner(DbBuilder.getDataSource());
}

/**
 * 得到查询记录的条数
 * 
 * @param sql
 *            必须为select count(*) from t_user的格式
 * @return
 */
public static int getCount(String sql) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
Object value = runner.query(sql, new ScalarHandler());
return CommonUtil.objectToInteger(value);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}

/**
 * 得到查询记录的条数
 * 
 * @param sql
 *            必须为select count(*) from t_user的格式
 * @return
 */
public static int getCount(Connection connection, String sql) {
try {
QueryRunner runner = new QueryRunner();
Object value = runner.query(connection, sql, new ScalarHandler());
return CommonUtil.objectToInteger(value);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}

/**
 * 得到查询记录的条数
 * 
 * @param sql
 *            必须为select count(*) from t_user的格式
 * @param params
 * @return
 */
public static int getCount(String sql, Object... params) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
Object value = runner.query(sql, new ScalarHandler(), params);
return CommonUtil.objectToInteger(value);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}

/**
 * 得到查询记录的条数
 * 
 * @param sql
 *            必须为select count(*) from t_user的格式
 * @param params
 * @return
 */
public static int getCount(Connection connection, String sql, Object... params) {
try {
QueryRunner runner = new QueryRunner();
Object value = runner.query(connection, sql, new ScalarHandler(), params);
return CommonUtil.objectToInteger(value);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}

/**
 * 根据传入的sql，查询记录，以数组形式返回第一行记录。 注意：如果有多行记录，只会返回第一行，所以适用场景需要注意，可以使用根据主键来查询的场景
 * 
 * @param sql
 * @return
 */
public static Object[] getFirstRowArray(String sql) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.query(sql, new ArrayHandler());
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据传入的sql，查询记录，以数组形式返回第一行记录。 注意：如果有多行记录，只会返回第一行，所以适用场景需要注意，可以使用根据主键来查询的场景
 * 
 * @param sql
 * @return
 */
public static Object[] getFirstRowArray(Connection connection, String sql) {
try {
QueryRunner runner = new QueryRunner();
return runner.query(connection, sql, new ArrayHandler());
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据传入的sql，查询记录，以数组形式返回第一行记录。 注意：如果有多行记录，只会返回第一行，所以适用场景需要注意，可以使用根据主键来查询的场景
 * 
 * @param sql
 * @param params
 * @return
 */
public static Object[] getFirstRowArray(String sql, Object... params) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.query(sql, new ArrayHandler(), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据传入的sql，查询记录，以数组形式返回第一行记录。 注意：如果有多行记录，只会返回第一行，所以适用场景需要注意，可以使用根据主键来查询的场景
 * 
 * @param sql
 * @param params
 * @return
 */
public static Object[] getFirstRowArray(Connection connection, String sql, Object... params) {
try {
QueryRunner runner = new QueryRunner();
return runner.query(connection, sql, new ArrayHandler(), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据sql查询返回所有记录，以List数组形式返回
 * 
 * @param sql
 * @return
 */
public static List getListArray(String sql) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.query(sql, new ArrayListHandler());
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据sql查询返回所有记录，以List数组形式返回
 * 
 * @param sql
 * @return
 */
public static List getListArray(Connection connection, String sql) {
try {
QueryRunner runner = new QueryRunner();
return runner.query(connection, sql, new ArrayListHandler());
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据sql查询返回所有记录，以List数组形式返回
 * 
 * @param sql
 * @param params
 * @return
 */
public static List getListArray(String sql, Object... params) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.query(sql, new ArrayListHandler(), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据sql查询返回所有记录，以List数组形式返回
 * 
 * @param sql
 * @param params
 * @return
 */
public static List getListArray(Connection connection, String sql, Object... params) {
try {
QueryRunner runner = new QueryRunner();
return runner.query(connection, sql, new ArrayListHandler(), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据传入的sql，查询记录，以Map形式返回第一行记录。 注意：如果有多行记录，只会返回第一行，所以适用场景需要注意，可以使用根据主键来查询的场景
 * 
 * @param sql
 * @return
 */
public static Map getFirstRowMap(String sql) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.query(sql, new MapHandler());
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据传入的sql，查询记录，以Map形式返回第一行记录。 注意：如果有多行记录，只会返回第一行，所以适用场景需要注意，可以使用根据主键来查询的场景
 * 
 * @param sql
 * @return
 */
public static Map getFirstRowMap(Connection connection, String sql) {
try {
QueryRunner runner = new QueryRunner();
return runner.query(connection, sql, new MapHandler());
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据传入的sql，查询记录，以Map形式返回第一行记录。 注意：如果有多行记录，只会返回第一行，所以适用场景需要注意，可以使用根据主键来查询的场景
 * 
 * @param sql
 * @param params
 * @return
 */
public static Map getFirstRowMap(String sql, Object... params) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.query(sql, new MapHandler(), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据传入的sql，查询记录，以Map形式返回第一行记录。 注意：如果有多行记录，只会返回第一行，所以适用场景需要注意，可以使用根据主键来查询的场景
 * 
 * @param sql
 * @param params
 * @return
 */
public static Map getFirstRowMap(Connection connection, String sql, Object... params) {
try {
QueryRunner runner = new QueryRunner();
return runner.query(connection, sql, new MapHandler(), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据传入的sql查询所有记录，以List Map形式返回
 * 
 * @param sql
 * @return
 */
public static List getListMap(String sql) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.query(sql, new MapListHandler());
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据传入的sql查询所有记录，以List Map形式返回
 * 
 * @param sql
 * @return
 */
public static List getListMap(Connection connection, String sql) {
try {
QueryRunner runner = new QueryRunner();
return runner.query(connection, sql, new MapListHandler());
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据传入的sql查询所有记录，以List Map形式返回
 * 
 * @param sql
 * @param params
 * @return
 */
public static List getListMap(String sql, Object... params) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.query(sql, new MapListHandler(), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据传入的sql查询所有记录，以List Map形式返回
 * 
 * @param sql
 * @param params
 * @return
 */
public static List getListMap(Connection connection, String sql, Object... params) {
try {
QueryRunner runner = new QueryRunner();
return runner.query(connection, sql, new MapListHandler(), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据sql和对象，查询结果并以对象形式返回
 * 
 * @param sql
 * @param type
 * @return
 */
public static  T getBean(String sql, Class type) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.query(sql, new BeanHandler(type));
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据sql和对象，查询结果并以对象形式返回
 * 
 * @param sql
 * @param type
 * @return
 */
public static  T getBean(Connection connection, String sql, Class type) {
try {
QueryRunner runner = new QueryRunner();
return runner.query(connection, sql, new BeanHandler(type));
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据sql和对象，查询结果并以对象形式返回
 * 
 * @param sql
 * @param type
 * @param params
 * @return
 */
public static  T getBean(String sql, Class type, Object... params) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.query(sql, new BeanHandler(type), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据sql和对象，查询结果并以对象形式返回
 * 
 * @param sql
 * @param type
 * @param params
 * @return
 */
public static  T getBean(Connection connection, String sql, Class type, Object... params) {
try {
QueryRunner runner = new QueryRunner();
return runner.query(connection, sql, new BeanHandler(type), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据sql查询list对象
 * 
 * @param sql
 * @param type
 * @return
 */
public static  List getListBean(String sql, Class type) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.query(sql, new BeanListHandler(type));
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据sql查询list对象
 * 
 * @param sql
 * @param type
 * @return
 */
public static  List getListBean(Connection connection, String sql, Class type) {
try {
QueryRunner runner = new QueryRunner();
return runner.query(connection, sql, new BeanListHandler(type));
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据sql查询list对象
 * 
 * @param sql
 * @param type
 * @param params
 * @return
 */
public static  List getListBean(String sql, Class type, Object... params) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.query(sql, new BeanListHandler(type), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 根据sql查询list对象
 * 
 * @param sql
 * @param type
 * @param params
 * @return
 */
public static  List getListBean(Connection connection, String sql, Class type, Object... params) {
try {
QueryRunner runner = new QueryRunner();
return runner.query(connection, sql, new BeanListHandler(type), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 保存操作
 * 
 * @param sql
 * @param params
 * @return
 */
public static int save(String sql, Object... params) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.update(sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}

/**
 * 保存操作
 * 
 * @param sql
 * @param params
 * @return
 */
public static int save(Connection connection, String sql, Object... params) {
try {
QueryRunner runner = new QueryRunner();
return runner.update(connection, sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}

/**
 * 更新操作
 * 
 * @param sql
 * @param params
 * @return
 */
public static int update(String sql, Object... params) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.update(sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}

/**
 * 更新操作
 * 
 * @param sql
 * @param params
 * @return
 */
public static int update(Connection connection, String sql, Object... params) {
try {
QueryRunner runner = new QueryRunner();
return runner.update(connection, sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}

/**
 * 删除操作
 * 
 * @param sql
 * @param params
 * @return
 */
public static int delete(String sql, Object... params) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.update(sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}

/**
 * 删除操作
 * 
 * @param sql
 * @param params
 * @return
 */
public static int delete(Connection connection, String sql, Object... params) {
try {
QueryRunner runner = new QueryRunner();
return runner.update(connection, sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}

/**
 * 批量操作，包括批量保存、修改、删除
 * 
 * @param sql
 * @param params
 * @return
 */
public static int[] batch(String sql, Object[][] params) {
try {
QueryRunner runner = DbBuilder.getQueryRunner();
return runner.batch(sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 批量操作，包括批量保存、修改、删除
 * 
 * @param sql
 * @param params
 * @return
 */
public static int[] batch(Connection connection, String sql, Object[][] params) {
try {
QueryRunner runner = new QueryRunner();
return runner.batch(connection, sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}

/**
 * 开启事务
 */
public static void beginTransaction(Connection conn) {
try {
// 开启事务
conn.setAutoCommit(false);
} catch (Exception e) {
throw new RuntimeException(e);
}
}

/**
 * 回滚事务
 */
public static void rollback(Connection conn) {
try {
conn.rollback();
} catch (Exception e) {
throw new RuntimeException(e);
}
}

/**
 * 提交事务
 */
public static void commit(Connection conn) {
try {
conn.commit();
} catch (Exception e) {
throw new RuntimeException(e);
}
}

public static void main(String[] args) {
try {
System.out.println(DbBuilder.getCount("select count(*) from T_USER"));

// 返回ArrayHandler结果,第一行结果：Object[]
System.out.println("返回ArrayHandler结果......");
Object[] arrayResult = DbBuilder.getFirstRowArray("select * from T_USER where id=2");
QueryRunner runner = DbBuilder.getQueryRunner();
for (int i = 0; i < arrayResult.length; i++) {
System.out.print(arrayResult[i] + "    ");
}
System.out.println();

// 返回ArrayListHandler结果
System.out.println("返回ArrayListHandler结果.........");
List arrayListResult = DbBuilder.getListArray("select * from T_USER");
for (int i = 0; i < arrayListResult.size(); i++) {
for (int j = 0; j < arrayListResult.get(i).length; j++) {
System.out.print(arrayListResult.get(i)[j] + "    ");
}
System.out.println();
}
System.out.println();

// 返回bean
UserDto user = DbBuilder.getBean("select * from T_USER where Id=?", UserDto.class, 1);
System.out.println(user.getUsername());

// 返回beanlist
System.out.println("返回BeanList结果......");
List beanListResult = DbBuilder.getListBean("select * from T_USER", UserDto.class);
Iterator iter_beanList = beanListResult.iterator();
while (iter_beanList.hasNext()) {
System.out.println(iter_beanList.next().getUsername());
}

// 返回指定列
System.out.println("返回ColumnList结果......");
List columnResult = runner.query("select * from T_USER", new ColumnListHandler("username"));
Iterator iter = columnResult.iterator();
while (iter.hasNext()) {
System.out.println(iter.next());
}

// 返回KeyedHandler结果：Map：map的key为KeyedHandler指定
System.out.println("返回KeyedHandler结果.........");
Map keyedResult = runner.query("select * from T_USER", new KeyedHandler(
"username"));
System.out.println(keyedResult.get("username"));

// MapHandler
System.out.println("返回MapHandler结果.........");
Map mapResult = DbBuilder.getFirstRowMap("select * from T_USER");
Iterator iter_mapResult = mapResult.keySet().iterator();
while (iter_mapResult.hasNext()) {
System.out.print(mapResult.get(iter_mapResult.next()) + "   ");
}
System.out.println();

// 返回MapListHandler结果
System.out.println("返回MapListHandler结果.........");
List mapListResult = DbBuilder.getListMap("select * from T_USER");
for (int i = 0; i < mapListResult.size(); i++) {
Iterator values = mapListResult.get(i).keySet().iterator();
while (values.hasNext()) {
System.out.print(mapListResult.get(i).get(values.next()) + "   ");
}
System.out.println();
}
Connection conn = DbBuilder.getConnection();
DbBuilder.beginTransaction(conn);
System.out.println(DbBuilder.save(conn,"insert into t_user(username,password) values(?,?)", "demo", "demo"));
DbBuilder.commit(conn);
DbBuilder.close(conn);
Object increaseId = runner.query("select last_insert_id()", new ScalarHandler());
System.out.println(increaseId);
} catch (SQLException e) {
e.printStackTrace();
}
}
}

七、代码说明

此代码采用dbcp连接池技术，但是如果直接使用连接池来初始化QueryRunner对象，则没有事务控制，如果需要事物操作，则要调用getConnection()方法得到连接，再调用开启事务、提交事务，异常的时候回滚事务来控制事务。

完整的代码已经提交到GitHub上，大家可以fork进行修改，并提交。https://github.com/16boke/DbUtil.git

欢迎转载，请注明来源一路博客，地址：http://www.16boke.com/article/detail/143