项目中用到了SSH构架，但个别地方，需要调用原生的SQL语句。用Hibernate来调用原生SQL太麻烦了。
需要Connection conn = this.getHibernateTemplate().getSessionFactory().openSession();
然后加Try，Catch，最后要在finally块中关闭掉Session，这样无疑多了很多代码。
Apache Commons DbUtils是一个轻量级的封装。我将它用在了项目中，在需要使用原生SQL语句的地方(批量操作或者很复杂的SQL语句)，调用DbUtils来进行操作。
首先是Spring的配置文件：
<!-- 定义数据源Bean-->
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName"
value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- 下面定义了DbUtils的一个模板操作Bean -->
<bean id="dbUtilsTemplate" class="com.company.project.dao.template.DbUtilsTemplate">
<property name="dataSource" ref="dataSource" />
</bean>
然后，是这个模板操作类，在需要用到原生SQL的地方，注入这个类即可：
package com.company.project.dao.template;
import java.sql.SQLException;
import java.util.ArrayList;
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.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* 调用Apache Commons DBUtil组件的数据库操作类
* 采用DBCP作为数据源，数据源在Spring中已经配置好
* 本类已经在Spring中配置好，在需要的地方，set注入后即可调用
* <code>
* private DbUtilsTemplate dbUtilsTemplate;
* public void setDbUtilsTemplate(DbUtilsTemplate dbUtilsTemplate) {
* this.dbUtilsTemplate = dbUtilsTemplate;
* }
* </code>
* @author Sunshine
* @version 1.0 2009-07-29
*/
public class DbUtilsTemplate {
private DataSource dataSource;
private QueryRunner queryRunner;
private static final Log LOG = LogFactory.getLog(DbUtilsTemplate.class);
public void setDataSource(BasicDataSource dataSource) {
this.dataSource = dataSource;
}
/**
* 执行sql语句
* @param sql sql语句
* @return 受影响的行数
*/
public int update(String sql) {
return update(sql, null);
}
/**
* 执行sql语句
* <code>
* executeUpdate("update user set username = 'kitty' where username = ?", "hello kitty");
* </code>
* @param sql sql语句
* @param param 参数
* @return 受影响的行数
*/
public int update(String sql, Object param) {
return update(sql, new Object[] { param });
}
/**
* 执行sql语句
* @param sql sql语句
* @param params 参数数组
* @return 受影响的行数
*/
public int update(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
int affectedRows = 0;
try {
if (params == null) {
affectedRows = queryRunner.update(sql);
} else {
affectedRows = queryRunner.update(sql, params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to update data", e);
}
return affectedRows;
}
/**
* 执行批量sql语句
* @param sql sql语句
* @param params 二维参数数组
* @return 受影响的行数的数组
*/
public int[] batchUpdate(String sql, Object[][] params) {
queryRunner = new QueryRunner(dataSource);
int[] affectedRows = new int[0];
try {
affectedRows = queryRunner.batch(sql, params);
} catch (SQLException e) {
LOG.error("Error occured while attempting to batch update data", e);
}
return affectedRows;
}
/**
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
* @param sql sql语句
* @return 查询结果
*/
public List<Map<String, Object>> find(String sql) {
return find(sql, null);
}
/**
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
* @param sql sql语句
* @param param 参数
* @return 查询结果
*/
public List<Map<String, Object>> find(String sql, Object param) {
return find(sql, new Object[] {param});
}
/**
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
* @param sql sql语句
* @param params 参数数组
* @return 查询结果
*/
@SuppressWarnings("unchecked")
public List<Map<String, Object>> find(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
try {
if (params == null) {
list = (List<Map<String, Object>>) queryRunner.query(sql, new MapListHandler());
} else {
list = (List<Map<String, Object>>) queryRunner.query(sql, new MapListHandler(), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return list;
}
/**
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
* @param entityClass 类名
* @param sql sql语句
* @return 查询结果
*/
public <T> List<T> find(Class<T> entityClass, String sql) {
return find(entityClass, sql, null);
}
/**
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
* @param entityClass 类名
* @param sql sql语句
* @param param 参数
* @return 查询结果
*/
public <T> List<T> find(Class<T> entityClass, String sql, Object param) {
return find(entityClass, sql, new Object[] { param });
}
/**
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
* @param entityClass 类名
* @param sql sql语句
* @param params 参数数组
* @return 查询结果
*/
@SuppressWarnings("unchecked")
public <T> List<T> find(Class<T> entityClass, String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
List<T> list = new ArrayList<T>();
try {
if (params == null) {
list = (List<T>) queryRunner.query(sql, new BeanListHandler(entityClass));
} else {
list = (List<T>) queryRunner.query(sql, new BeanListHandler(entityClass), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return list;
}
/**
* 查询出结果集中的第一条记录，并封装成对象
* @param entityClass 类名
* @param sql sql语句
* @return 对象
*/
public <T> T findFirst(Class<T> entityClass, String sql) {
return findFirst(entityClass, sql, null);
}
/**
* 查询出结果集中的第一条记录，并封装成对象
* @param entityClass 类名
* @param sql sql语句
* @param param 参数
* @return 对象
*/
public <T> T findFirst(Class<T> entityClass, String sql, Object param) {
return findFirst(entityClass, sql, new Object[] { param });
}
/**
* 查询出结果集中的第一条记录，并封装成对象
* @param entityClass 类名
* @param sql sql语句
* @param params 参数数组
* @return 对象
*/
@SuppressWarnings("unchecked")
public <T> T findFirst(Class<T> entityClass, String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
Object object = null;
try {
if (params == null) {
object = queryRunner.query(sql, new BeanHandler(entityClass));
} else {
object = queryRunner.query(sql, new BeanHandler(entityClass), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return (T) object;
}
/**
* 查询出结果集中的第一条记录，并封装成Map对象
* @param sql sql语句
* @return 封装为Map的对象
*/
public Map<String, Object> findFirst(String sql) {
return findFirst(sql, null);
}
/**
* 查询出结果集中的第一条记录，并封装成Map对象
* @param sql sql语句
* @param param 参数
* @return 封装为Map的对象
*/
public Map<String, Object> findFirst(String sql, Object param) {
return findFirst(sql, new Object[] { param });
}
/**
* 查询出结果集中的第一条记录，并封装成Map对象
* @param sql sql语句
* @param params 参数数组
* @return 封装为Map的对象
*/
@SuppressWarnings("unchecked")
public Map<String, Object> findFirst(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource);
Map<String, Object> map = null;
try {
if (params == null) {
map = (Map<String, Object>) queryRunner.query(sql, new MapHandler());
} else {
map = (Map<String, Object>) queryRunner.query(sql, new MapHandler(), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return map;
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql sql语句
* @param columnName 列名
* @return 结果对象
*/
public Object findBy(String sql, String columnName) {
return findBy(sql, columnName, null);
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql sql语句
* @param columnName 列名
* @param param 参数
* @return 结果对象
*/
public Object findBy(String sql, String columnName, Object param) {
return findBy(sql, columnName, new Object[] { param });
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql sql语句
* @param columnName 列名
* @param params 参数数组
* @return 结果对象
*/
public Object findBy(String sql, String columnName, Object[] params) {
queryRunner = new QueryRunner(dataSource);
Object object = null;
try {
if (params == null) {
object = queryRunner.query(sql, new ScalarHandler(columnName));
} else {
object = queryRunner.query(sql, new ScalarHandler(columnName), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return object;
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql sql语句
* @param columnIndex 列索引
* @return 结果对象
*/
public Object findBy(String sql, int columnIndex) {
return findBy(sql, columnIndex, null);
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql sql语句
* @param columnIndex 列索引
* @param param 参数
* @return 结果对象
*/
public Object findBy(String sql, int columnIndex, Object param) {
return findBy(sql, columnIndex, new Object[] { param });
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql sql语句
* @param columnIndex 列索引
* @param params 参数数组
* @return 结果对象
*/
public Object findBy(String sql, int columnIndex, Object[] params) {
queryRunner = new QueryRunner(dataSource);
Object object = null;
try {
if (params == null) {
object = queryRunner.query(sql, new ScalarHandler(columnIndex));
} else {
object = queryRunner.query(sql, new ScalarHandler(columnIndex), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return object;
}
}
分享到：
相关推荐
总之，DBUtils 是一个强大的 Python 数据库工具，通过连接池管理和异常处理等机制，极大地提升了数据库操作的稳定性和性能。在进行数据库相关的开发工作时，DBUtils 应该是你的首选辅助工具之一。
2. **QueryRunner**：QueryRunner是DBUtils的主要操作类，提供了执行SQL查询和更新的方法。例如，`query()`方法用于执行SELECT语句，返回结果集；`update()`方法用于执行INSERT、UPDATE、DELETE等操作。 3. **结果...
DBUtils是Apache软件基金会开发的一个开源Java库，它提供了一套简单、易用且高度封装的数据库操作API，主要用于简化Java应用程序对数据库的访问。DBUtils的核心思想是为数据库操作提供一个安全、高效的抽象层，使得...
在Java开发中，`dbutils`是一个非常实用的数据库操作工具包，它简化了JDBC（Java Database Connectivity）的一些繁琐工作，比如连接管理、结果集处理等，使得开发者可以更专注于SQL语句的编写和数据的处理。...
DBUtils 是一个开源的 Java 工具包，主要用于简化 JDBC（Java Database Connectivity）操作，它由 Apache Software Foundation 提供，并广泛应用于各种 Java 开发项目中。DBUtils 的设计目标是提高开发效率，减少...
1. **QueryRunner**：这是一个非常重要的类，它提供了执行SQL语句的方法，包括查询、更新（插入、删除、修改）以及批量操作。QueryRunner支持预编译的PreparedStatement，能有效防止SQL注入攻击。 2. **...
DBUtils是Apache Commons库的一个子项目，它提供了一套简洁、高效、线程安全的数据库访问工具。本篇将详细讲解如何利用DBUtils中的QueryRunner类对数据表进行操作，包括连接数据库、执行SQL语句以及处理结果集。 ...
Python的DBUtils是一个非常实用的库，主要用于增强Python标准库中的`DB-API 2.0`接口，提供了线程安全性和连接池管理等功能。DBUtils是基于PEP 249设计的，它使得数据库连接的管理和维护变得更加简单，尤其在多线程...
例如，通过C3P0初始化一个数据库连接池，然后在DBUtils的QueryRunner中使用这些连接来执行数据库操作。这样，不仅可以利用C3P0的连接池管理，还能享受DBUtils带来的简洁和安全的数据库操作接口。 以下是一个简单的...
DBUtils是Apache组织提供的一个开源Java库，它简化了JDBC（Java Database Connectivity）的使用。JDBC是Java中用于与各种类型数据库交互的标准API，但它的基础使用相对繁琐，涉及大量的异常处理和资源管理。DBUtils...
`commons-dbutils-1.7.jar`是Apache Commons项目的一部分，提供了一个更安全、更便捷的方式来处理JDBC操作。 DBUtils的核心是QueryRunner类，它提供了执行SQL查询和更新的方法。使用DBUtils可以大大简化上述流程： ...
### DBUtils操作数据库及事务管理详解 #### 一、DBUtils简介 DBUtils是一个轻量级的Java数据库访问工具类库，它简化了JDBC的使用步骤，使得开发者能够更方便地进行数据库操作。相比于传统的JDBC编程方式，DBUtils...
3. **QueryRunner**: QueryRunner是DBUtils提供的一个工具类，用于执行SQL查询和更新操作。通过QueryRunner，开发者可以方便地执行增删改查操作，而无需关心底层的Connection和Statement管理。简易DBUtils中也会有一...
Apache Commons DBUtils是Apache软件基金会开发的一个开源项目，它提供了一套简洁、高效且实用的工具类，用于简化Java应用程序中的数据库操作。这个项目的最新版本为"commons-dbutils-1.4.jar"，它的主要目标是减轻...
DbUtils是一个为简化JDBC操作的小类库. 接口摘要 ResultSetHandler 将ResultSet转换为别的对象的工具. RowProcessor 将ResultSet行转换为别的对象的工具. 类摘要 BasicRowProcessor RowProcessor接口的基本实现类. ...
Python的dbutils模块是Apache的一个开源项目，它提供了一套用于数据库操作的工具类，能够帮助简化数据库连接和管理，提高开发效率。本教程将详细讲解如何对dbutils进行简单的封装，以更好地适应实际的Python数据库...
3. **QueryRunner与SimpleJdbcInsert**：QueryRunner是DbUtils提供的一个主要类，用于执行SQL查询和更新操作。它可以处理简单的SELECT、INSERT、UPDATE和DELETE语句，以及存储过程。而SimpleJdbcInsert则简化了插入...
DbUtils 1.8.1版本是其稳定的一个版本，它包含了对数据库操作的基本功能，如执行SQL语句、处理结果集、管理数据库连接等。 DbUtils的核心设计理念是基于JDBC但又高于JDBC，它将JDBC的一些繁琐工作进行了封装，比如...
在IT行业中，数据库操作是日常开发中的重要环节，而`dbutils`是一个非常实用的Java数据库操作工具包，它简化了对数据库进行增删改查（CRUD）操作的过程。本示例着重介绍如何结合`dbutils`与Oracle数据库进行高效的...