项目中用到了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;
}
}
分享到:
相关推荐
JavaWeb之DBUtils-QueryRunner类对数据表的操作
DbUtils是一个为简化JDBC操作的小类库. 接口摘要 ResultSetHandler 将ResultSet转换为别的对象的工具. RowProcessor 将ResultSet行转换为别的对象的工具. 类摘要 BasicRowProcessor RowProcessor接口的基本实现类. ...
这是一个用于数据库操作的通用类库,用它可以完成各种有关数据库的操作,而且有其帮助文档可以用它大大缩短开发时间!
query方法后面参数中加一个Connection连接,是在获取不到数据源的情况下,也就是说,QueryRunner的实例化构造函数使用无参的那个,下面我的实现代码就是用的这种方法。 当然还有一种实例化:new QueryRunner(new ...
DBUtils包括3个包: org apache commons dbutils org apache commons dbutils handlers org apache commons dbutils wrappers DBUtils封装了对JDBC的操作 简化了JDBC操作 可以少写代码 org apache commons dbutils ...
采用Apache dbutils操作数据库的DAO类:
JDBC的工具类,就是java操作的数据库的小工具,配合c3p0连接池.让你操作数据库简单明了.复制进项目就能使用.欢迎下载
Dbutils是操作数据库的组件,对传统操作数据库的类进行二次封装,可以把结果集转化成List。
类DBUtils1操作SQLite数据库
Apache Common DbUtils是操作数据库的组件,对传统操作数据库的类(JDBC)进行二次封装,可以把结果集转化成List。 DbUtils封装了对JDBC的操作,简化了JDBC操作,可以少写代码。 应用实践小结: 一、...
dbutils可以在Java开发中用来简化对数据库的操作。
压缩包中存在DbUtils使用说明文档、jar包以及一个使用样例。commons-dbutils 是 Apache 组织提供的一个开源 JDBC 工具类库,对传统操作数据库的类进行二次封装,可以把结果集转化成List。
Common Dbutils是操作数据库的组件,对传统操作数据库的类进行二次封装,可以把结果集转化成List。 补充一下,传统操作数据库的类指的是JDBC(java database connection:java数据库连接,java的数据库操作的基础API...
JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由...DBUtils是Apache组织开发的一个简单,小巧,又具有大部分功能的操作数据库的java组件
commons-dbutils.jar是在java架构开发时十分重要的一款.jar包,正确的使用commons dbutils可以...commons-dbutils 是 Apache 组织提供的一个开源 JDBC 工具类库,对传统操作数据库的类进行二次封装,可以把结果集转化成L
Common Dbutils是操作数据库的组件,对传统操作数据库的类进行二次封装,可以把结果集转化成List。 补充一下,传统操作数据库的类指的是JDBC(java database connection:java数据库连接,java的数据库操作的基础API...
commons-dbutils 是 Apache 组织提供的一个开源 JDBC 工具类库,对传统操作数据库的类进行二次封装,可以把结果集转化成List。 Commons dbutils主要相关类及接口的简介: 主要讲解两个类(org.apache.commons....
apache下面有很多值得学习的开源项目,尤其是commons系列,在此,特封装了其组织下的dbutils根据,方便了喜欢使用sql开发的java朋友,里面有各种实用的封装类和对数据库操作的接口,欢迎下载!
JDBC学习(九)dbUtils原理代码实例,包含三个demo:正常C3P0数据库池对数据库的增删改查操作;自己实现dbutils对数据库实现增删改查操作;使用apache的工具类dbutils对数据库增删改查操作。
使用JSP + Servlet + JDBC实现MVC 使用JSP + Servlet + DBUtils实现MVC ...5.使用DBUtils1.6操作数据库,使用原生方法操作数据库 TUserDao使用JDBC TUserDaoEx使用Dbutils 6.扩展方法JsonResult自定义方法