apachecommon连接mysql_对JDBC的封装，调用Apache Commons 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注入后即可调用

*

* private DbUtilsTemplate dbUtilsTemplate;

* public void setDbUtilsTemplate(DbUtilsTemplate dbUtilsTemplate) {

*     this.dbUtilsTemplate = dbUtilsTemplate;

* }

*

* @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语句,无法保证事务不推荐使用

*

* executeUpdate("update user set username = 'kitty' where username = ?", "hello kitty");

*

* @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> find(String sql) {

return find(sql, null);

}

/**

* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中

* @param sql sql语句

* @param param 参数

* @return 查询结果

*/

public List> find(String sql, Object param) {

return find(sql, new Object[] {param});

}

/**

* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中

* @param sql sql语句

* @param params 参数数组

* @return 查询结果

*/

@SuppressWarnings("unchecked")

public List> find(String sql, Object[] params) {

queryRunner = new QueryRunner(dataSource);

List> list = new ArrayList>();

try {

if (params == null) {

list = (List>) queryRunner.query(sql, new MapListHandler());

} else {

list = (List>) 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 List find(Class entityClass, String sql) {

return find(entityClass, sql, null);

}

/**

* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中

* @param entityClass 类名

* @param sql sql语句

* @param param 参数

* @return 查询结果

*/

public List find(Class 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 List find(Class entityClass, String sql, Object[] params) {

queryRunner = new QueryRunner(dataSource);

List list = new ArrayList();

try {

if (params == null) {

list = (List) queryRunner.query(sql, new BeanListHandler(entityClass));

} else {

list = (List) 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 List find(Class 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 List find(Class 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 List find(Class entityClass, String sql, Object[] params, int page, int pageSize) {

queryRunner = new QueryRunner(dataSource);

List list = new ArrayList();

int startFlag = (((page < 1 ? 1 : page) - 1) * pageSize);

String pageSql = " limit " + startFlag + " , " + startFlag + pageSize;

try {

if (params == null) {

list = (List) queryRunner.query(sql + pageSql, new BeanListHandler(entityClass));

} else {

list = (List) 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 PageResult findPageResult(Class 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 PageResult findPageResult(Class 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 PageResult findPageResult(Class entityClass, String sql, Object[] params, int page, int pageSize) {

queryRunner = new QueryRunner(dataSource);

List list = new ArrayList();

int startPage = page < 1 ? 1 : page;

int startFlag = ((startPage - 1) * pageSize);

String pageSql = " limit " + startFlag + " , " + startFlag + pageSize;

try {

if (params == null) {

list = (List) queryRunner.query(sql + pageSql, new BeanListHandler(entityClass));

} else {

list = (List) 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 findFirst(Class entityClass, String sql) {

return findFirst(entityClass, sql, null);

}

/**

* 查询出结果集中的第一条记录，并封装成对象

* @param entityClass 类名

* @param sql sql语句

* @param param 参数

* @return 对象

*/

public T findFirst(Class entityClass, String sql, Object param) {

return findFirst(entityClass, sql, new Object[] { param });

}

/**

* 查询出结果集中的第一条记录，并封装成对象

* @param entityClass 类名

* @param sql sql语句

* @param params 参数数组

* @return 对象

*/

@SuppressWarnings("unchecked")

public T findFirst(Class 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 findFirst(String sql) {

return findFirst(sql, null);

}

/**

* 查询出结果集中的第一条记录，并封装成Map对象

* @param sql sql语句

* @param param 参数

* @return 封装为Map的对象

*/

public Map findFirst(String sql, Object param) {

return findFirst(sql, new Object[] { param });

}

/**

* 查询出结果集中的第一条记录，并封装成Map对象

* @param sql sql语句

* @param params 参数数组

* @return 封装为Map的对象

*/

@SuppressWarnings("unchecked")

public Map findFirst(String sql, Object[] params) {

queryRunner = new QueryRunner(dataSource);

Map map = null;

try {

if (params == null) {

map = (Map) queryRunner.query(sql, new MapHandler());

} else {

map = (Map) 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;

}

}