`

DbUtils的一个操作类

阅读更多
http://qiang2260-126-com.iteye.com/blog/436272

项目中用到了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 dbutils dbutils dbutils

    总之,DBUtils 是一个强大的 Python 数据库工具,通过连接池管理和异常处理等机制,极大地提升了数据库操作的稳定性和性能。在进行数据库相关的开发工作时,DBUtils 应该是你的首选辅助工具之一。

    DBUtils数据库工具类

    2. **QueryRunner**:QueryRunner是DBUtils的主要操作类,提供了执行SQL查询和更新的方法。例如,`query()`方法用于执行SELECT语句,返回结果集;`update()`方法用于执行INSERT、UPDATE、DELETE等操作。 3. **结果...

    DBUtils(通用的数据库工具类)

    DBUtils是Apache软件基金会开发的一个开源Java库,它提供了一套简单、易用且高度封装的数据库操作API,主要用于简化Java应用程序对数据库的访问。DBUtils的核心思想是为数据库操作提供一个安全、高效的抽象层,使得...

    dbutils工具类

    在Java开发中,`dbutils`是一个非常实用的数据库操作工具包,它简化了JDBC(Java Database Connectivity)的一些繁琐工作,比如连接管理、结果集处理等,使得开发者可以更专注于SQL语句的编写和数据的处理。...

    DBUtils 工具类

    DBUtils 是一个开源的 Java 工具包,主要用于简化 JDBC(Java Database Connectivity)操作,它由 Apache Software Foundation 提供,并广泛应用于各种 Java 开发项目中。DBUtils 的设计目标是提高开发效率,减少...

    Dbutils 的jar包

    1. **QueryRunner**:这是一个非常重要的类,它提供了执行SQL语句的方法,包括查询、更新(插入、删除、修改)以及批量操作。QueryRunner支持预编译的PreparedStatement,能有效防止SQL注入攻击。 2. **...

    DBUtils-QueryRunner类对数据表的操作

    DBUtils是Apache Commons库的一个子项目,它提供了一套简洁、高效、线程安全的数据库访问工具。本篇将详细讲解如何利用DBUtils中的QueryRunner类对数据表进行操作,包括连接数据库、执行SQL语句以及处理结果集。 ...

    python的DBUtils包

    Python的DBUtils是一个非常实用的库,主要用于增强Python标准库中的`DB-API 2.0`接口,提供了线程安全性和连接池管理等功能。DBUtils是基于PEP 249设计的,它使得数据库连接的管理和维护变得更加简单,尤其在多线程...

    C3P0和DButils

    例如,通过C3P0初始化一个数据库连接池,然后在DBUtils的QueryRunner中使用这些连接来执行数据库操作。这样,不仅可以利用C3P0的连接池管理,还能享受DBUtils带来的简洁和安全的数据库操作接口。 以下是一个简单的...

    DBUtils工具类

    DBUtils是Apache组织提供的一个开源Java库,它简化了JDBC(Java Database Connectivity)的使用。JDBC是Java中用于与各种类型数据库交互的标准API,但它的基础使用相对繁琐,涉及大量的异常处理和资源管理。DBUtils...

    JDBC连接数据库DBUtils操作数据库两个jar包

    `commons-dbutils-1.7.jar`是Apache Commons项目的一部分,提供了一个更安全、更便捷的方式来处理JDBC操作。 DBUtils的核心是QueryRunner类,它提供了执行SQL查询和更新的方法。使用DBUtils可以大大简化上述流程: ...

    DBUtils操作数据库以及事物的管理

    ### DBUtils操作数据库及事务管理详解 #### 一、DBUtils简介 DBUtils是一个轻量级的Java数据库访问工具类库,它简化了JDBC的使用步骤,使得开发者能够更方便地进行数据库操作。相比于传统的JDBC编程方式,DBUtils...

    模仿DBUtils(自己模仿DBUtils写的简易DBUtils)

    3. **QueryRunner**: QueryRunner是DBUtils提供的一个工具类,用于执行SQL查询和更新操作。通过QueryRunner,开发者可以方便地执行增删改查操作,而无需关心底层的Connection和Statement管理。简易DBUtils中也会有一...

    commons-dbutils-1.4.jar

    Apache Commons DBUtils是Apache软件基金会开发的一个开源项目,它提供了一套简洁、高效且实用的工具类,用于简化Java应用程序中的数据库操作。这个项目的最新版本为"commons-dbutils-1.4.jar",它的主要目标是减轻...

    commons-dbutils-1.6.jar包

    DbUtils是一个为简化JDBC操作的小类库. 接口摘要 ResultSetHandler 将ResultSet转换为别的对象的工具. RowProcessor 将ResultSet行转换为别的对象的工具. 类摘要 BasicRowProcessor RowProcessor接口的基本实现类. ...

    python-dbutils 简单封装

    Python的dbutils模块是Apache的一个开源项目,它提供了一套用于数据库操作的工具类,能够帮助简化数据库连接和管理,提高开发效率。本教程将详细讲解如何对dbutils进行简单的封装,以更好地适应实际的Python数据库...

    DbUtils.zip

    3. **QueryRunner与SimpleJdbcInsert**:QueryRunner是DbUtils提供的一个主要类,用于执行SQL查询和更新操作。它可以处理简单的SELECT、INSERT、UPDATE和DELETE语句,以及存储过程。而SimpleJdbcInsert则简化了插入...

    dbutils + oracle 增删改查批量插入示例

    在IT行业中,数据库操作是日常开发中的重要环节,而`dbutils`是一个非常实用的Java数据库操作工具包,它简化了对数据库进行增删改查(CRUD)操作的过程。本示例着重介绍如何结合`dbutils`与Oracle数据库进行高效的...

    commons-dbutils-1.3.zip

    DBUtils库是Apache Commons项目的一部分,旨在提供一个简单、安全的方式来处理数据库操作,减少与数据库交互时出现的常见错误。 DBUtils的核心理念是基于数据库连接池和对JDBC API的封装,以提高性能和易用性。在...

Global site tag (gtag.js) - Google Analytics