package com.cmbc.cmspf.common;
import java.math.BigDecimal;
import java.sql.CallableStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.CallableStatementCallback;
import org.springframework.jdbc.core.ColumnMapRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.rowset.SqlRowSet;
import org.springframework.stereotype.Repository;
import com.cmbc.cmspf.exception.DaoException;
import com.cmbc.cmspf.util.CollectionUtils;
import com.cmbc.cmspf.util.DatabaseUtils;
import com.cmbc.cmspf.util.ObjectUtils;
/**
*
* @Description: 通用dao,实现一些对数据库的操作,事物不进行控制
* @author hui
* @date 2013-10-29 上午09:29:06
* @version 1.0
*/
@Repository
public class BaseUtilDao {
public static String DATABASE_ORACLE = "oracle";
public static String DATABASE_MSSQL = "mssql";
public static String DATABASE_MYSQL = "mysql";
public static String DATABASE_DB2 = "db2";
public static String DATABASE_SYBASE = "sybase";
public static String DATABASE_POSTGRESQL = "postgre";
@Resource
private JdbcTemplate jdbcTemplate;
private static final Log log = LogFactory.getLog(BaseDao.class);
//记录是什么数据库
private String databaseName;
//内部类,重载getColumnKey(),使其返回小写
private ColumnMapRowMapper mapper = new ColumnMapRowMapper(){
protected String getColumnKey(String columnName){
return columnName.toLowerCase();
}
};
/**
* 获得使用的是什么数据库
* @return
*/
public String getDatabaseName()
{
if ((this.databaseName == null) || ("".equals(this.databaseName)))
{
this.databaseName = DatabaseUtils.getDatabaseProductName(jdbcTemplate);
}
if ((this.databaseName == null) || ("".equals(this.databaseName))) {
this.databaseName = DATABASE_ORACLE;
}
return this.databaseName;
}
/**
* 执行INSERT/UPDATE/DELETE的sql语句
* @param sql
* SQL语句 用例:delete from user where user_id=1000
* @return 影响记录数 0表示操作失败
*/
public int execute(String sql)
{
return this.jdbcTemplate.update(sql);
}
/**
* 执行带参数的INSERT/UPDATE/DELETE的sql语句
* @date 2013-9-24 下午05:51:36
* @param sql
* SQL语句 用例:delete from user where user_id=1000
* @param parameters 查询参数:
* 用例:new Object[]{new Long(1000)}
* @return 影响记录数 0 表示操作失败
*/
public int execute(String sql, Object[] parameters)
{
return this.jdbcTemplate.update(sql, parameters);
}
/**
* 调用存储过程
* @date 2013-9-24 下午06:00:02
* @param callString
* @param action
* @return
* @throws DataAccessException
*/
public ResultSet execute(String callString, CallableStatementCallback action)
throws DataAccessException
{
Object obj = this.jdbcTemplate.execute(callString, new CallableStatementCallback()
{
public Object doInCallableStatement(CallableStatement cs) throws SQLException, DataAccessException {
cs.execute();
ResultSet rs = cs.getResultSet();
return rs;
}
});
return ((ResultSet)obj);
}
/**
* 批量执行sql语句
* @date 2013-10-30 下午11:03:45
* @param sqlList
* @return
*/
public int[] batchExcuteSql(String[] sqlList){
return jdbcTemplate.batchUpdate(sqlList);
}
/**
* 批量执行
* @date 2013-10-30 下午11:37:59
* @param sql
* @param para 要求批量执行中的字符必须全部为小写
* @param objList
* @return
*/
public int[] batchExecute( String sql, String para[], List objList ){
return executeBatch(sql, new CommonBatchSetter(para, objList));
}
/**
* 批量执行
* @date 2013-10-31 上午09:17:21
* @param sql
* @param para 形式如column1,column2,column2形式,且列必须要小写
* @param objList
* @return
*/
public int[] batchExecute(String sql , String para,List objList){
String paras[] = para.toLowerCase().split(",");
return executeBatch(sql, new CommonBatchSetter(paras, objList));
}
/**
* 用于返回一个结果
* @param resultList
* @return
*/
private Object getOnlyOne(List resultList){
if(!CollectionUtils.isEmpty(resultList)){
return resultList.get(0);
}
return null;
}
/**
* 查询一条记录,返回Map集合
* @param sql
* @return HashMap类型的单笔记录
*/
public Map queryForOne(String sql)
{
List resultList = this.jdbcTemplate.query(sql, mapper);
Object obj=getOnlyOne(resultList);
if(obj==null)return null;
return (Map)obj;
}
/**
* 查询一条记录,返回一个对象
* @date 2013-10-30 上午11:00:13
* @param sql
* @param clazz 要返回对象的Class
* @return
*/
public <T> T queryForOne(String sql, Class<T> clazz)
{
List resultList = queryForList(sql,clazz);
Object obj=getOnlyOne(resultList);
if(obj==null) return null;
return (T)obj ;
}
/**
* 查询一条记录,带有条件
* @param sql
* @param parameters 查询参数
* 用例:new Object[new Long(1000)]
* @return
*/
public Object queryForOne(String sql, Object[] parameters)
{
List resultList = this.jdbcTemplate.query(sql, parameters, mapper);
return getOnlyOne(resultList);
}
/**
* 查询一条记录,带有条件,返回一个映射对象
* @param sql
* 带?参数的SQL语句 用例:select * from user where user_id=?
* @param parameters 查询参数
* 用例:new Object[new Long(1000)]
* @param clazz 要返回对象的Class
* @return rowMapper指定映射对象的单笔记录
*/
public <T> T queryForOne(String sql, Object[] parameters, Class<T> clazz)
{
List resultList = this.jdbcTemplate.query(sql, parameters, new ComplexMapper(clazz));
Object obj=getOnlyOne(resultList);
if(obj==null)return null;
return (T)obj ;
}
/**
* 查询出一个List
* @param sql
* @return
*/
public List queryForList(String sql)
{
return this.jdbcTemplate.query(sql, mapper);
}
/**
* 查询出一个List,返回映射对象的集合
* @param sql
* @param clazz 要返回对象的Class
* @return
*/
public <T>List<T> queryForList(String sql, Class<T> clazz)
{
int count = this.getCount(sql);
if (count == 0) {
return null;
}
return this.jdbcTemplate.query(sql, new ComplexMapper(clazz));
}
/**
* 查询出一个List,带有条件
* @param sql
* @param parameters
* @return
*/
public List queryForList(String sql, Object[] parameters)
{
List rs = null;
if (parameters == null)
rs = queryForList(sql);
else {
rs = this.jdbcTemplate.query(sql, parameters, mapper);
}
return rs;
}
/**
- 1
- 2
前往页