數據庫操做類DBUtil

 工做的須要，不能所有使用Hibernate和數據庫交互，在此記錄Apache Commons DBUtil組件的數據庫操做類，供你們參考。

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; 
import com.tgula.util.common.PageResult;

/**
* 調用Apache Commons DBUtil組件的數據庫操做類
* 採用DBCP做爲數據源，數據源在Spring中已經配置好
* 本類已經在Spring中配置好，在須要的地方，set注入後便可調用
* <code>
* private DbUtilsTemplate dbUtilsTemplate;
* public void setDbUtilsTemplate(DbUtilsTemplate dbUtilsTemplate) {
*     this.dbUtilsTemplate = dbUtilsTemplate;
* }
* </code>
* @author LoveChina
* @version 1.0 2012-02-09
*/
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 受影響的行數
     * @deprecated
     */
    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 受影響的行數
     * @deprecated
     */
    public int update(String sql, Object param) {
        return update(sql, new Object[] { param });
    }
     
    /**
     * 執行sql語句,沒法保證事務不推薦使用
     * @param sql sql語句
     * @param params 參數數組
     * @return 受影響的行數
     * @deprecated
     */
    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 受影響的行數的數組
     * @deprecated
     */
    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;
    }
    
    /**
     * 執行分頁查詢，將每行的結果保存到Bean中，而後將全部Bean保存到List中
     * @param entityClass 類名
     * @param sql sql語句
     * @param page 頁號
     * @param pageSize 每頁記錄條數
     * @return 查詢結果
     */
    public <T> List<T> find(Class<T> entityClass, String sql, int page, int pageSize) {
        return find(entityClass, sql, null, page, pageSize);
    }
     
    /**
     * 執行分頁查詢，將每行的結果保存到Bean中，而後將全部Bean保存到List中
     * @param entityClass 類名
     * @param sql sql語句
     * @param param 參數
     * @param page 頁號
     * @param pageSize 每頁記錄條數
     * @return 查詢結果
     */
    public <T> List<T> find(Class<T> entityClass, String sql, Object param, int page, int pageSize) {
        return find(entityClass, sql, new Object[] { param }, page, pageSize);
    }
    
    /**
     * 執行分頁查詢，將每行的結果保存到Bean中，而後將全部Bean保存到List中
     * @param entityClass 類名
     * @param sql sql語句
     * @param params 參數數組
     * @param page 頁號
     * @param pageSize 每頁記錄條數
     * @return 查詢結果
     */
    @SuppressWarnings("unchecked")
    public <T> List<T> find(Class<T> entityClass, String sql, Object[] params, int page, int pageSize) {
        queryRunner = new QueryRunner(dataSource);
        List<T> list = new ArrayList<T>();
        int startFlag = (((page < 1 ? 1 : page) - 1) * pageSize);
        String pageSql = " limit " + startFlag + " , " + startFlag + pageSize;
        try {
            if (params == null) {
                list = (List<T>) queryRunner.query(sql + pageSql, new BeanListHandler(entityClass));
            } else {
                list = (List<T>) queryRunner.query(sql + pageSql, new BeanListHandler(entityClass), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return list;
    }
    
    /**
     * 執行分頁查詢，將每行的結果保存到Bean中，而後將全部Bean保存到List中,而後裝List封裝成PageResult對象
     * @param entityClass 類名
     * @param sql sql語句
     * @param page 頁號
     * @param pageSize 每頁記錄條數
     * @return PageResult對象
     */
    public <T> PageResult findPageResult(Class<T> entityClass, String sql, int page, int pageSize) {
        return findPageResult(entityClass, sql, null, page, pageSize);
    }
    
    /**
     * 執行分頁查詢，將每行的結果保存到Bean中，而後將全部Bean保存到List中,而後裝List封裝成PageResult對象
     * @param entityClass 類名
     * @param sql sql語句
     * @param param 參數
     * @param page 頁號
     * @param pageSize 每頁記錄條數
     * @return PageResult對象
     */
    public <T> PageResult findPageResult(Class<T> entityClass, String sql, Object param, int page, int pageSize) {
        return findPageResult(entityClass, sql, new Object[] { param }, page, pageSize);
    }
    
    /**
     * 執行分頁查詢，將每行的結果保存到Bean中，而後將全部Bean保存到List中,而後裝List封裝成PageResult對象
     * @param entityClass 類名
     * @param sql sql語句
     * @param params 參數數組
     * @param page 頁號
     * @param pageSize 每頁記錄條數
     * @return PageResult對象
     */
    @SuppressWarnings("unchecked")
    public <T> PageResult findPageResult(Class<T> entityClass, String sql, Object[] params, int page, int pageSize) {
        queryRunner = new QueryRunner(dataSource);
        List<T> list = new ArrayList<T>();
        int startPage = page < 1 ? 1 : page;
        int startFlag = ((startPage - 1) * pageSize);
        String pageSql = " limit " + startFlag + " , " + startFlag + pageSize;
        try {
            if (params == null) {
                list = (List<T>) queryRunner.query(sql + pageSql, new BeanListHandler(entityClass));
            } else {
                list = (List<T>) queryRunner.query(sql + pageSql, new BeanListHandler(entityClass), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        // 計算總行數
         int count = getCount(sql, params);
         int newCurrentPage = getBeginPage(startPage, pageSize, count);
        return new PageResult(newCurrentPage, pageSize, list, count);
    }
     
    /**
     * 查詢出結果集中的第一條記錄，並封裝成對象
     * @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;
    }
    
    /**
     * 查詢記錄總條數
     * @param sql sql語句
     * @return 記錄總數
     */
    public int getCount(String sql) {
        return getCount(sql, null);
    }
    
    /**
     * 查詢記錄總條數
     * @param sql sql語句
     * @param param 參數
     * @return 記錄總數
     */
    public int getCount(String sql, Object param) {
        return getCount(sql, new Object[] { param });
    }
    
    /**
     * 查詢記錄總條數
     * @param sql sql語句
     * @param params 參數數組
     * @return 記錄總數
     */
    public int getCount(String sql, Object[] params) {
        String newSql = "select count(1) from (" + sql + ") _c";
        if (params == null) {
            return ((Long)findBy(newSql, 1)).intValue();
        } else {
            return ((Long)findBy(newSql, 1, params)).intValue();
        }
    }
    
    private int getBeginPage(int begenPage, int pageSize, int count) {
        if (count == 0) {
            return 1;
        }
        int newCurrentPage = begenPage;
        if (begenPage > 1) {
            if ((begenPage - 1) * pageSize >= count) {
                newCurrentPage = (int) (Math.ceil((count * 1.0) / pageSize));
            }
        }
        return newCurrentPage;
    }
}