重大改版
 鱼翔空 2013-04-18 spring,jdbc,常用工具|   0 1486 
文章评分 90 次,平均分 5.0

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

 

package com.ligitalsoft.approve.utils;

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 ducc 
*/  
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;  
	 }  
}

 

 

除特别注明外,本站所有文章均为我要编程原创,转载请注明出处来自http://5ycode.com/article/175.html

关于
该用户很懒!
切换注册

登录

忘记密码 ?

切换登录

注册

扫一扫二维码分享