/**
* 数据库操作工具类，支持多数据源配置
*
* @author: yxz
* @version: 1.0
* @date:
*/
@Component
public class DBUtils implements DBSupport {
private static DBConfig dbConfig;
private static Logger logger = LoggerFactory.getLogger(DBUtils.class);
@Autowired(required = false)
public void setDbConfig(DBConfig dbConfig) {
DBUtils.dbConfig = dbConfig;
}
@Override
public boolean isReady() {
return dbConfig != null;
}
@Autowired
private SpringContextUtils springContextUtils;
@PostConstruct
public void init() {
try {
if (dbConfig == null) {
logger.debug("dbConfig not found,try inject default bean");
if (ClassUtils.isPresent("org.hibernate.SessionFactory")) {
SessionFactory sessionFactory = (SessionFactory) SpringContextUtils.getBean("sessionFactory");
if (sessionFactory != null) {
logger.debug("hibernate found");
dbConfig = new DBConfig();
dbConfig.setSessionFactory(sessionFactory);
}
}
if (dbConfig == null) {
DataSource dataSource = (DataSource) SpringContextUtils.getBean("dataSource");
if (dataSource != null) {
logger.debug("dataSource found");
dbConfig = new DBConfig();
dbConfig.setDataSource(dataSource);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static boolean hasDB() {
return dbConfig != null;
}
public static int getDbIndex(String dbKey) {
if (dbKey == null || dbKey.length() < 1) {
return -1;
}
if (dbConfig == null) {
throw new DatabaseException("数据源未配置");
}
return dbConfig.getDbIndex(dbKey);
}
/**
* 判断数据库类型
*
* @param dataSource
* @return
*/
public static DataBaseType checkDataBaseType(DataSource dataSource) {
return dbConfig.checkDataBaseType(dataSource);
}
private static CommonJdbcDao getJdbcDao(int dbIndex) {
if (dbConfig == null) {
throw new DatabaseException("数据源未配置");
}
return dbConfig.getJdbcDao(dbIndex);
}
private static CommonHibernateDao getHibernateDao(int dbIndex) {
if (dbConfig == null) {
throw new DatabaseException("数据源未配置");
}
return dbConfig.getHibernateDao(dbIndex);
}
/**
* 切换数据库
*
* @param dbIndex
*/
public static int switchTo(int dbIndex) {
if (dbConfig == null) {
throw new DatabaseException("数据源未配置");
}
return dbConfig.switchTo(dbIndex);
}
/**
* 切换数据库
*
* @param dbKey
*/
public static int switchTo(String dbKey) {
return switchTo(getDbIndex(dbKey));
}
/**
* 切换到主库
*/
@Deprecated
public static void switchToMain() {
reset();
}
/**
* 切换到主库
*/
public static void reset() {
if (dbConfig == null) {
throw new DatabaseException("数据源未配置");
}
dbConfig.reset();
}
/**
* 单表保存
*
* @param entity
* @param <T>
*/
public static <T> void save(T entity) {
save(-1, entity);
}
/**
* 单表保存，指定数据库
*
* @param dbIndex
* @param entity
* @param <T>
*/
public static <T> void save(int dbIndex, T entity) {
CommonHibernateDao hibernateDao = getHibernateDao(dbIndex);
hibernateDao.save(entity);
}
/**
* 单表保存，指定数据库
*
* @param dbKey
* @param entity
* @param <T>
*/
public static <T> void save(String dbKey, T entity) {
save(getDbIndex(dbKey), entity);
}
/**
* 批量保存
*
* @param entitys
* @param <T>
*/
public static <T> void save(List<T> entitys) {
save(-1, entitys);
}
/**
* 批量保存，指定数据库
*
* @param dbIndex
* @param entitys
* @param <T>
*/
public static <T> void save(int dbIndex, List<T> entitys) {
for (T entity : entitys) {
save(dbIndex, entity);
}
}
/**
* 批量保存，指定数据库
*
* @param dbKey
* @param entitys
* @param <T>
*/
public static <T> void save(String dbKey, List<T> entitys) {
save(getDbIndex(dbKey), entitys);
}
/**
* 单表更新
*
* @param entity
* @param <T>
*/
public static <T> void update(T entity) {
update(-1, entity);
}
/**
* 单表更新，指定数据库
*
* @param dbIndex
* @param entity
* @param <T>
*/
public static <T> void update(int dbIndex, T entity) {
CommonHibernateDao hibernateDao = getHibernateDao(dbIndex);
hibernateDao.update(entity);
}
/**
* 单表更新，指定数据库
*
* @param dbKey
* @param entity
* @param <T>
*/
public static <T> void update(String dbKey, T entity) {
update(getDbIndex(dbKey), entity);
}
/**
* 批量更新
*
* @param entitys
* @param <T>
*/
public static <T> void update(List<T> entitys) {
update(-1, entitys);
}
/**
* 批量更新，指定数据库
*
* @param dbIndex
* @param entitys
* @param <T>
*/
public static <T> void update(int dbIndex, List<T> entitys) {
for (T entity : entitys) {
update(dbIndex, entity);
}
}
/**
* 批量更新，指定数据库
*
* @param dbKey
* @param entitys
* @param <T>
*/
public static <T> void update(String dbKey, List<T> entitys) {
update(getDbIndex(dbKey), entitys);
}
/**
* 单实体删除
*
* @param clazz
* @param id
* @param <T>
*/
public static <T> void delete(Class<T> clazz, Serializable id) {
delete(-1, clazz, id);
}
/**
* 单实体删除，指定数据库
*
* @param dbIndex
* @param clazz
* @param id
* @param <T>
*/
public static <T> void delete(int dbIndex, Class<T> clazz, Serializable id) {
T entity = load(dbIndex, clazz, id);
if (entity == null) {
throw new DatabaseException(String.format("没有找到id为%s的实体%s", id, clazz));
}
CommonHibernateDao hibernateDao = getHibernateDao(dbIndex);
hibernateDao.delete(entity);
}
/**
* 单实体删除，指定数据库
*
* @param dbKey
* @param clazz
* @param id
* @param <T>
*/
public static <T> void delete(String dbKey, Class<T> clazz, Serializable id) {
delete(getDbIndex(dbKey), clazz, id);
}
/**
* 单实体删除
*
* @param entity
*/
public static <T> void delete(T entity) {
delete(-1, entity);
}
/**
* 单实体删除，指定数据库
*
* @param dbIndex
* @param entity
* @param <T>
*/
public static <T> void delete(int dbIndex, T entity) {
CommonHibernateDao hibernateDao = getHibernateDao(dbIndex);
hibernateDao.delete(entity);
}
/**
* 单实体删除，指定数据库
*
* @param dbKey
* @param entity
* @param <T>
*/
public static <T> void delete(String dbKey, T entity) {
delete(getDbIndex(dbKey), entity);
}
/**
* 批量删除
*
* @param entitys
* @param <T>
*/
public static <T> void delete(List<T> entitys) {
delete(-1, entitys);
}
/**
* 批量删除，指定数据库
*
* @param dbIndex
* @param entitys
* @param <T>
*/
public static <T> void delete(int dbIndex, List<T> entitys) {
for (T entity : entitys) {
delete(dbIndex, entity);
}
}
/**
* 批量删除，指定数据库
*
* @param dbKey
* @param entitys
* @param <T>
*/
public static <T> void delete(String dbKey, List<T> entitys) {
delete(getDbIndex(dbKey), entitys);
}
/**
* 单实体加载
*
* @param <T>
* @param clazz
* @param id
* @return
*/
public static <T> T load(Class<T> clazz, Serializable id) {
return load(-1, clazz, id);
}
/**
* 单实体加载，指定数据库
*
* @param dbIndex
* @param clazz
* @param id
* @param <T>
* @return
*/
public static <T> T load(int dbIndex, Class<T> clazz, Serializable id) {
CommonHibernateDao hibernateDao = getHibernateDao(dbIndex);
return hibernateDao.load(clazz, id);
}
/**
* 单实体加载，指定数据库
*
* @param dbKey
* @param clazz
* @param id
* @param <T>
* @return
*/
public static <T> T load(String dbKey, Class<T> clazz, Serializable id) {
return load(getDbIndex(dbKey), clazz, id);
}
/**
* 通过hql加载实体
*
* @param hql
* @param params
* @param <T>
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T load(String hql, Object... params) {
return (T) load(-1, hql, params);
}
/**
* 通过hql加载实体，指定数据库
*
* @param dbIndex
* @param hql
* @param params
* @param <T>
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T load(int dbIndex, String hql, Object... params) {
CommonHibernateDao hibernateDao = getHibernateDao(dbIndex);
return (T) hibernateDao.load(hql, params);
}
/**
* 通过hql加载实体，指定数据库
*
* @param dbKey
* @param hql
* @param params
* @param <T>
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T loadFrom(String dbKey, String hql, Object... params) {
return load(getDbIndex(dbKey), hql, params);
}
/**
* 通过hql查询列表
*
* @param hql
* @param params
* @param <T>
* @return
*/
public static <T> List<T> loadList(String hql, Object... params) {
return loadList(-1, hql, params);
}
/**
* 通过hql查询列表，指定数据库
*
* @param dbIndex
* @param hql
* @param params
* @param <T>
* @return
*/
public static <T> List<T> loadList(int dbIndex, String hql, Object... params) {
CommonHibernateDao hibernateDao = getHibernateDao(dbIndex);
return hibernateDao.loadList(hql, params);
}
/**
* 通过hql查询列表，指定数据库
*
* @param dbKey
* @param hql
* @param params
* @param <T>
* @return
*/
public static <T> List<T> loadListFrom(String dbKey, String hql, Object... params) {
return loadList(getDbIndex(dbKey), hql, params);
}
/**
* 提交hibernate缓存实体
*/
public static void flush() {
flush(-1);
}
/**
* 提交hibernate缓存实体，指定数据库
*
* @param dbIndex
*/
public static void flush(int dbIndex) {
CommonHibernateDao hibernateDao = getHibernateDao(dbIndex);
hibernateDao.flush();
}
/**
* 提交hibernate缓存实体，指定数据库
*
* @param dbKey
*/
public static void flush(String dbKey) {
flush(getDbIndex(dbKey));
}
/**
* 清空hibernate缓存实体
*/
public static void clear() {
clear(-1);
}
/**
* 清空hibernate缓存实体，指定数据库
*
* @param dbIndex
*/
public static void clear(int dbIndex) {
CommonHibernateDao hibernateDao = getHibernateDao(dbIndex);
hibernateDao.clear();
}
/**
* 清空hibernate缓存实体，指定数据库
*
* @param dbKey
*/
public static void clear(String dbKey) {
clear(getDbIndex(dbKey));
}
/******************************************JDBC部分******************************************************/
/**
* 通过sql查询单个实体
*
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> R get(String sql, Class<R> clazz, Object... params) {
return get(-1, sql, clazz, params);
}
/**
* 通过sql查询单个实体
*
* @param column
* @param table
* @param where
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> R get(String column, String table, String where, Class<R> clazz, Object... params) {
return get(-1, column, table, where, clazz, params);
}
/**
* 通过sql查询单个实体，指定数据库
*
* @param dbIndex
* @param sql
* @param clazz
* @param params
* @return
*/
public static <R> R get(int dbIndex, String sql, Class<R> clazz, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.get(getTrueSql(sql), clazz, params);
}
/**
* 通过sql查询单个实体，指定数据库
*
* @param dbKey
* @param sql
* @param clazz
* @param params
* @return
*/
public static <R> R get(String dbKey, String sql, Class<R> clazz, Object... params) {
return get(getDbIndex(dbKey), sql, clazz, params);
}
private static String concatSql(String column, String table, String where) {
return "select " + column + " from " + table + " where " + where;
}
/**
* 通过sql查询单个实体，指定数据库
*
* @param dbIndex
* @param column
* @param table
* @param where
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> R get(int dbIndex, String column, String table, String where, Class<R> clazz, Object... params) {
String sql = concatSql(column, table, where);
return get(-1, sql, clazz, params);
}
/**
* 通过sql查询单个实体，指定数据库
*
* @param dbKey
* @param column
* @param table
* @param where
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> R get(String dbKey, String column, String table, String where, Class<R> clazz, Object... params) {
return get(getDbIndex(dbKey), column, table, where, clazz, params);
}
/**
* 通过sql查询单个实体，带字典表
*
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> R get(String sql, Class<R> clazz, DicMap dicMap, Object... params) {
return get(-1, sql, clazz, dicMap, params);
}
/**
* 通过sql查询单个实体，带字典表，指定数据库
*
* @param dbIndex
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> R get(int dbIndex, String sql, Class<R> clazz, DicMap dicMap, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.get(getTrueSql(sql), clazz, dicMap, params);
}
/**
* 通过sql查询单个实体，带字典表，指定数据库
*
* @param dbKey
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> R get(String dbKey, String sql, Class<R> clazz, DicMap dicMap, Object... params) {
return get(getDbIndex(dbKey), sql, clazz, dicMap, params);
}
/**
* 通过sql查询单个实体
*
* @param sql
* @param params
* @return
*/
public static Map<String, Object> get(String sql, Object... params) {
return get(-1, sql, params);
}
/**
* 通过sql查询单个实体，指定数据库
*
* @param dbIndex
* @param sql
* @param params
* @return
*/
public static Map<String, Object> get(int dbIndex, String sql, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.get(getTrueSql(sql), params);
}
/**
* 通过sql查询单个实体，指定数据库
*
* @param dbKey
* @param sql
* @param params
* @return
*/
public static Map<String, Object> getFrom(String dbKey, String sql, Object... params) {
return get(getDbIndex(dbKey), sql, params);
}
/**
* 通过sql查询单个实体，带字典表
*
* @param sql
* @param dicMap
* @param params
* @return
*/
public static Map<String, Object> get(String sql, DicMap dicMap, Object... params) {
return get(-1, sql, dicMap, params);
}
/**
* 通过sql查询单个实体，带字典表，指定数据库
*
* @param dbIndex
* @param sql
* @param dicMap
* @param params
* @return
*/
public static Map<String, Object> get(int dbIndex, String sql, DicMap dicMap, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.get(getTrueSql(sql), dicMap, params);
}
/**
* 通过sql查询单个实体，带字典表，指定数据库
*
* @param dbKey
* @param sql
* @param dicMap
* @param params
* @return
*/
public static Map<String, Object> getFrom(String dbKey, String sql, DicMap dicMap, Object... params) {
return get(getDbIndex(dbKey), sql, dicMap, params);
}
/**
* 获取首个查询结果
*
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> R getFirst(String sql, Class<R> clazz, Object... params) {
return getFirst(-1, sql, clazz, params);
}
/**
* 获取首个查询结果，指定数据库
*
* @param dbIndex
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> R getFirst(int dbIndex, String sql, Class<R> clazz, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.getFirst(getTrueSql(sql), clazz, params);
}
/**
* 获取首个查询结果，指定数据库
*
* @param dbKey
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> R getFirst(String dbKey, String sql, Class<R> clazz, Object... params) {
return getFirst(getDbIndex(dbKey), sql, clazz, params);
}
/**
* 获取首个查询结果，带字典表
*
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> R getFirst(String sql, Class<R> clazz, DicMap dicMap, Object... params) {
return getFirst(-1, sql, clazz, dicMap, params);
}
/**
* 获取首个查询结果，带字典表，指定数据库
*
* @param dbIndex
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> R getFirst(int dbIndex, String sql, Class<R> clazz, DicMap dicMap, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.getFirst(getTrueSql(sql), clazz, dicMap, params);
}
/**
* 获取首个查询结果，带字典表，指定数据库
*
* @param dbKey
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> R getFirst(String dbKey, String sql, Class<R> clazz, DicMap dicMap, Object... params) {
return getFirst(getDbIndex(dbKey), sql, clazz, dicMap, params);
}
/**
* 以Map方式返回首个结果
*
* @param sql
* @param params
* @return
*/
public static Map<String, Object> getFirst(String sql, Object... params) {
return getFirst(-1, sql, params);
}
/**
* 以Map方式返回首个结果，指定数据库
*
* @param dbIndex
* @param sql
* @param params
* @return
*/
public static Map<String, Object> getFirst(int dbIndex, String sql, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.getFirst(getTrueSql(sql), params);
}
/**
* 以Map方式返回首个结果，指定数据库
*
* @param dbKey
* @param sql
* @param params
* @return
*/
public static Map<String, Object> getFirstFrom(String dbKey, String sql, Object... params) {
return getFirst(getDbIndex(dbKey), sql, params);
}
/**
* 以Map方式返回结果，带字典表
*
* @param sql
* @param dicMap
* @param params
* @return
*/
public static Map<String, Object> getFirst(String sql, DicMap dicMap, Object... params) {
return getFirst(-1, sql, dicMap, params);
}
/**
* 以Map方式返回结果，带字典表，指定数据库
*
* @param dbIndex
* @param sql
* @param dicMap
* @param params
* @return
*/
public static Map<String, Object> getFirst(int dbIndex, String sql, DicMap dicMap, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.getFirst(getTrueSql(sql), dicMap, params);
}
/**
* 获取count数据
*
* @param sql
* @param params
* @return
*/
public static Long getCount(String sql, Object... params) {
return getCount(-1, sql, params);
}
/**
* 获取count数据
*
* @param dbIndex
* @param sql
* @param params
* @return
*/
public static Long getCount(int dbIndex, String sql, Object... params) {
try {
if (sql == null) {
return 0L;
}
if (sql.charAt(0) == '/') {
sql = SqlBuilder.getSql(sql);
}
sql = sql.trim();
if (StringUtils.startsWithIgnoreCase(sql, "from")) {
sql = StringUtils.join("select count(*) ", sql);
}
} catch (Exception ignore) {
}
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
Long result = jdbcDao.getValue(sql, Long.class, params);
if (result == null) {
result = 0L;
}
return result;
}
/**
* 获取count数据
*
* @param dbKey
* @param sql
* @param params
* @return
*/
public static Long getCountFrom(String dbKey, String sql, Object... params) {
return getCount(getDbIndex(dbKey), sql, params);
}
/**
* 查询单值结果，如Integer，Long
*
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> R getValue(String sql, Class<R> clazz, Object... params) {
return getValue(-1, sql, clazz, params);
}
/**
* 查询单值结果，如Integer，Long，指定数据库
*
* @param dbIndex
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> R getValue(int dbIndex, String sql, Class<R> clazz, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.getValue(getTrueSql(sql), clazz, params);
}
/**
* 查询单值结果，如Integer，Long，指定数据库
*
* @param dbKey
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> R getValueFrom(String dbKey, String sql, Class<R> clazz, Object... params) {
return getValue(getDbIndex(dbKey), sql, clazz, params);
}
/**
* 获得整型对象
*
* @param sql
* @param params
* @return
*/
public static int getInt(String sql, Object... params) {
return getInt(-1, sql, params);
}
/**
* 获得整型对象，指定数据库
*
* @param dbIndex
* @param sql
* @param params
* @return
*/
public static int getInt(int dbIndex, String sql, Object... params) {
Integer result = getValue(dbIndex, sql, Integer.class, params);
if (result == null) {
result = 0;
}
return result;
}
/**
* 获得整型对象，指定数据库
*
* @param dbKey
* @param sql
* @param params
* @return
*/
public static int getIntFrom(String dbKey, String sql, Object... params) {
return getInt(getDbIndex(dbKey), sql, params);
}
/**
* 获得长整型对象
*
* @param sql
* @param params
* @return
*/
public static long getLong(String sql, Object... params) {
return getLong(-1, sql, params);
}
/**
* 获得长整型对象，指定数据库
*
* @param dbIndex
* @param sql
* @param params
* @return
*/
public static long getLong(int dbIndex, String sql, Object... params) {
Long result = getValue(dbIndex, sql, Long.class, params);
if (result == null) {
result = 0L;
}
return result;
}
/**
* 获得长整型对象，指定数据库
*
* @param dbKey
* @param sql
* @param params
* @return
*/
public static long getLongFrom(String dbKey, String sql, Object... params) {
return getLong(getDbIndex(dbKey), sql, params);
}
/**
* 获得双精度对象
*
* @param sql
* @param params
* @return
*/
public static double getDouble(String sql, Object... params) {
return getDouble(-1, sql, params);
}
/**
* 获得双精度对象，指定数据库
*
* @param dbIndex
* @param sql
* @param params
* @return
*/
public static double getDouble(int dbIndex, String sql, Object... params) {
Double result = getValue(dbIndex, sql, Double.class, params);
if (result == null) {
result = 0D;
}
return result;
}
/**
* 获得双精度对象，指定数据库
*
* @param dbKey
* @param sql
* @param params
* @return
*/
public static double getDoubleFrom(String dbKey, String sql, Object... params) {
return getDouble(getDbIndex(dbKey), sql, params);
}
/**
* 获得浮点对象
*
* @param sql
* @param params
* @return
*/
public static float getFloat(String sql, Object... params) {
return getFloat(-1, sql, params);
}
/**
* 获得浮点对象，指定数据库
*
* @param dbIndex
* @param sql
* @param params
* @return
*/
public static float getFloat(int dbIndex, String sql, Object... params) {
Float result = getValue(dbIndex, sql, Float.class, params);
if (result == null) {
result = 0F;
}
return result;
}
/**
* 获得浮点对象，指定数据库
*
* @param dbKey
* @param sql
* @param params
* @return
*/
public static float getFloatFrom(String dbKey, String sql, Object... params) {
return getFloat(getDbIndex(dbKey), sql, params);
}
/**
* 获得字符型对象
*
* @param sql
* @param params
* @return
*/
public static String getString(String sql, Object... params) {
return getString(-1, sql, params);
}
/**
* 获得字符型对象，指定数据库
*
* @param dbIndex
* @param sql
* @param params
* @return
*/
public static String getString(int dbIndex, String sql, Object... params) {
String result = getValue(dbIndex, sql, String.class, params);
if (result == null) {
result = "";
}
return result;
}
/**
* 获得字符型对象，指定数据库
*
* @param dbKey
* @param sql
* @param params
* @return
*/
public static String getStringFrom(String dbKey, String sql, Object... params) {
return getString(getDbIndex(dbKey), sql, params);
}
/**
* 执行sql，并返回记录数
*
* @param sql
* @param params
* @return
*/
public static int execSql(String sql, Object... params) {
if (!TransactionSynchronizationManager.isActualTransactionActive() || TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
throw new DatabaseException("该方法不支持只读事务");
}
return execSql(-1, sql, params);
}
/**
* 执行sql，并返回记录数，指定数据库
*
* @param dbIndex
* @param sql
* @param params
* @return
*/
public static int execSql(int dbIndex, String sql, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.execSql(getTrueSql(sql), params);
}
/**
* 执行sql，并返回记录数，指定数据库
*
* @param dbKey
* @param sql
* @param params
* @return
*/
public static int execSqlFrom(String dbKey, String sql, Object... params) {
return execSql(getDbIndex(dbKey), sql, params);
}
/**
* 分页查询，结果集为List<Map<String,Object>>，放入PageResult中
*
* @param pageParam
* @param sql
* @param params
* @return
*/
public static PageResult query(PageParam pageParam, String sql, Object... params) {
return query(-1, pageParam, sql, params);
}
/**
* 分页查询，结果集为List<Map<String,Object>>，放入PageResult中
*
* @param pageParam
* @param sql
* @param params
* @return
*/
public static PageResult query(PageParam pageParam, Sql sql, Object... params) {
return query(-1, pageParam, sql, params);
}
/**
* 分页查询，结果集为List<Map<String,Object>>，放入PageResult中，指定数据库
*
* @param dbIndex
* @param pageParam
* @param sql
* @param params
* @return
*/
public static PageResult query(int dbIndex, PageParam pageParam, String sql, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.query(pageParam, getTrueSql(sql), params);
}
/**
* 分页查询，结果集为List<Map<String,Object>>，放入PageResult中，指定数据库
*
* @param dbKey
* @param pageParam
* @param sql
* @param params
* @return
*/
public static PageResult query(String dbKey, PageParam pageParam, String sql, Object... params) {
return query(getDbIndex(dbKey), pageParam, sql, params);
}
private static Sql fixSql(Sql sql) {
Sql sqlFix = new Sql();
sqlFix.setQuerySql(getTrueSql(sql.getQuerySql()));
sqlFix.setCountSql(getTrueSql(sql.getCountSql()));
return sqlFix;
}
/**
* 分页查询，结果集为List<Map<String,Object>>，放入PageResult中，指定数据库
*
* @param dbIndex
* @param pageParam
* @param sql
* @param params
* @return
*/
public static PageResult query(int dbIndex, PageParam pageParam, Sql sql, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.query(pageParam, fixSql(sql), params);
}
/**
* 分页查询，结果集为List<Map<String,Object>>，放入PageResult中，指定数据库
*
* @param dbKey
* @param pageParam
* @param sql
* @param params
* @return
*/
public static PageResult query(String dbKey, PageParam pageParam, Sql sql, Object... params) {
return query(getDbIndex(dbKey), pageParam, sql, params);
}
/**
* 分页查询，结果集为List<Map<String,Object>>，放入Page中，带字典表
*
* @param pageParam
* @param sql
* @param dicMap
* @param params
* @return
*/
public static PageResult query(PageParam pageParam, String sql, DicMap dicMap, Object... params) {
return query(-1, pageParam, sql, dicMap, params);
}
/**
* 分页查询，结果集为List<Map<String,Object>>，放入Page中，带字典表
*
* @param pageParam
* @param sql
* @param dicMap
* @param params
* @return
*/
public static PageResult query(PageParam pageParam, Sql sql, DicMap dicMap, Object... params) {
return query(-1, pageParam, sql, dicMap, params);
}
/**
* 分页查询，结果集为List<Map<String,Object>>，放入Page中，带字典表，指定数据库
*
* @param dbIndex
* @param pageParam
* @param sql
* @param dicMap
* @param params
* @return
*/
public static PageResult query(int dbIndex, PageParam pageParam, String sql, DicMap dicMap, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.query(pageParam, getTrueSql(sql), dicMap, params);
}
/**
* 分页查询，结果集为List<Map<String,Object>>，放入Page中，带字典表，指定数据库
*
* @param dbKey
* @param pageParam
* @param sql
* @param dicMap
* @param params
* @return
*/
public static PageResult query(String dbKey, PageParam pageParam, String sql, DicMap dicMap, Object... params) {
return query(getDbIndex(dbKey), pageParam, sql, dicMap, params);
}
/**
* 分页查询，结果集为List<Map<String,Object>>，放入Page中，带字典表，指定数据库
*
* @param dbIndex
* @param pageParam
* @param sql
* @param dicMap
* @param params
* @return
*/
public static PageResult query(int dbIndex, PageParam pageParam, Sql sql, DicMap dicMap, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.query(pageParam, fixSql(sql), dicMap, params);
}
/**
* 分页查询，结果集为List<Map<String,Object>>，放入Page中，带字典表，指定数据库
*
* @param dbKey
* @param pageParam
* @param sql
* @param dicMap
* @param params
* @return
*/
public static PageResult query(String dbKey, PageParam pageParam, Sql sql, DicMap dicMap, Object... params) {
return query(getDbIndex(dbKey), pageParam, sql, dicMap, params);
}
/**
* 分页查询，结果集为List<R>，放入Page中
*
* @param pageParam
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> PageResult query(PageParam pageParam, String sql, Class<R> clazz, Object... params) {
return query(-1, pageParam, sql, clazz, params);
}
/**
* 分页查询，结果集为List<R>，放入Page中
*
* @param pageParam
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> PageResult query(PageParam pageParam, Sql sql, Class<R> clazz, Object... params) {
return query(-1, pageParam, sql, clazz, params);
}
/**
* 分页查询，结果集为List<R>，放入Page中，指定数据库
*
* @param dbIndex
* @param pageParam
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> PageResult query(int dbIndex, PageParam pageParam, String sql, Class<R> clazz, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.query(pageParam, getTrueSql(sql), clazz, params);
}
/**
* 分页查询，结果集为List<R>，放入Page中，指定数据库
*
* @param dbKey
* @param pageParam
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> PageResult query(String dbKey, PageParam pageParam, String sql, Class<R> clazz, Object... params) {
return query(getDbIndex(dbKey), pageParam, sql, clazz, params);
}
/**
* 分页查询，结果集为List<R>，放入Page中，指定数据库
*
* @param dbIndex
* @param pageParam
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> PageResult query(int dbIndex, PageParam pageParam, Sql sql, Class<R> clazz, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.query(pageParam, fixSql(sql), clazz, params);
}
/**
* 分页查询，结果集为List<R>，放入Page中，指定数据库
*
* @param dbKey
* @param pageParam
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> PageResult query(String dbKey, PageParam pageParam, Sql sql, Class<R> clazz, Object... params) {
return query(getDbIndex(dbKey), pageParam, sql, clazz, params);
}
/**
* 分页查询，结果集为List<R>，放入Page中，带字典表
*
* @param pageParam
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> PageResult query(PageParam pageParam, String sql, Class<R> clazz, DicMap dicMap, Object... params) {
return query(-1, pageParam, sql, clazz, dicMap, params);
}
/**
* 分页查询，结果集为List<R>，放入Page中，带字典表
*
* @param pageParam
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> PageResult query(PageParam pageParam, Sql sql, Class<R> clazz, DicMap dicMap, Object... params) {
return query(-1, pageParam, sql, clazz, dicMap, params);
}
/**
* 分页查询，结果集为List<R>，放入Page中，带字典表，指定数据库
*
* @param dbIndex
* @param pageParam
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> PageResult query(int dbIndex, PageParam pageParam, String sql, Class<R> clazz, DicMap dicMap, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.query(pageParam, getTrueSql(sql), clazz, dicMap, params);
}
/**
* 分页查询，结果集为List<R>，放入Page中，带字典表，指定数据库
*
* @param dbKey
* @param pageParam
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> PageResult query(String dbKey, PageParam pageParam, String sql, Class<R> clazz, DicMap dicMap, Object... params) {
return query(getDbIndex(dbKey), pageParam, sql, clazz, dicMap, params);
}
/**
* 分页查询，结果集为List<R>，放入Page中，带字典表，指定数据库
*
* @param dbIndex
* @param pageParam
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> PageResult query(int dbIndex, PageParam pageParam, Sql sql, Class<R> clazz, DicMap dicMap, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.query(pageParam, fixSql(sql), clazz, dicMap, params);
}
/**
* 分页查询，结果集为List<R>，放入Page中，带字典表，指定数据库
*
* @param dbKey
* @param pageParam
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> PageResult query(String dbKey, PageParam pageParam, Sql sql, Class<R> clazz, DicMap dicMap, Object... params) {
return query(getDbIndex(dbKey), pageParam, sql, clazz, dicMap, params);
}
/**
* 通过sql查询实体列表
*
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> List<R> query(String sql, Class<R> clazz, Object... params) {
return query(-1, sql, clazz, params);
}
public static <R> List<R> query(String column, String table, String where, Class<R> clazz, Object... params) {
return query(-1, column, table, where, clazz, params);
}
/**
* 通过sql查询实体列表，指定数据库
*
* @param dbIndex
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> List<R> query(int dbIndex, String sql, Class<R> clazz, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.query(getTrueSql(sql), clazz, params);
}
/**
* 通过sql查询实体列表，指定数据库
*
* @param dbKey
* @param sql
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> List<R> query(String dbKey, String sql, Class<R> clazz, Object... params) {
return query(getDbIndex(dbKey), sql, clazz, params);
}
/**
* 通过sql查询实体列表，指定数据库
*
* @param dbIndex
* @param column
* @param table
* @param where
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> List<R> query(int dbIndex, String column, String table, String where, Class<R> clazz, Object... params) {
String sql = concatSql(column, table, where);
return query(-1, sql, clazz, params);
}
/**
* 通过sql查询实体列表，指定数据库
*
* @param dbKey
* @param column
* @param table
* @param where
* @param clazz
* @param params
* @param <R>
* @return
*/
public static <R> List<R> query(String dbKey, String column, String table, String where, Class<R> clazz, Object... params) {
return query(getDbIndex(dbKey), column, table, where, clazz, params);
}
/**
* 通过sql查询实体列表，带字典表
*
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> List<R> query(String sql, Class<R> clazz, DicMap dicMap, Object... params) {
return query(-1, sql, clazz, dicMap, params);
}
/**
* 通过sql查询实体列表，带字典表，指定数据库
*
* @param dbIndex
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> List<R> query(int dbIndex, String sql, Class<R> clazz, DicMap dicMap, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.query(getTrueSql(sql), clazz, dicMap, params);
}
/**
* 通过sql查询实体列表，带字典表，指定数据库
*
* @param dbIndex
* @param sql
* @param clazz
* @param dicMap
* @param params
* @param <R>
* @return
*/
public static <R> List<R> query(String dbKey, String sql, Class<R> clazz, DicMap dicMap, Object... params) {
return query(getDbIndex(dbKey), sql, clazz, dicMap, params);
}
/**
* 以Map方式返回结果集列表
*
* @param sql
* @param params
* @return
*/
public static List<Map<String, Object>> query(String sql, Object... params) {
return query(-1, sql, params);
}
/**
* 以Map方式返回结果集列表，指定数据库
*
* @param dbIndex
* @param sql
* @param params
* @return
*/
public static List<Map<String, Object>> query(int dbIndex, String sql, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.query(getTrueSql(sql), params);
}
/**
* 以Map方式返回结果集列表，指定数据库
*
* @param dbKey
* @param sql
* @param params
* @return
*/
public static List<Map<String, Object>> queryFrom(String dbKey, String sql, Object... params) {
return query(getDbIndex(dbKey), sql, params);
}
/**
* 以Map方式返回结果集列表，带字典表
*
* @param sql
* @param dicMap
* @param params
* @return
*/
public static List<Map<String, Object>> query(String sql, DicMap dicMap, Object... params) {
return query(-1, sql, dicMap, params);
}
/**
* 以Map方式返回结果集列表，带字典表，指定数据库
*
* @param dbIndex
* @param sql
* @param dicMap
* @param params
* @return
*/
public static List<Map<String, Object>> query(int dbIndex, String sql, DicMap dicMap, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.query(getTrueSql(sql), dicMap, params);
}
/**
* 以Map方式返回结果集列表，带字典表，指定数据库
*
* @param dbKey
* @param sql
* @param dicMap
* @param params
* @return
*/
public static List<Map<String, Object>> queryFrom(String dbKey, String sql, DicMap dicMap, Object... params) {
return query(getDbIndex(dbKey), sql, dicMap, params);
}
/**
* 获取格式化的序列号，限Oracle
*
* @param sequenceName
* @param format
* @return
*/
public static String getSequenceValue(String sequenceName, String format) {
return getSequenceValue(-1, sequenceName, format);
}
/**
* 获取Oracle序列号
*
* @param sequenceName
* @return
*/
public static String getSequenceValue(String sequenceName) {
return getSequenceValue(-1, sequenceName, null);
}
/**
* 获取Oracle序列号，指定数据库
*
* @param dbIndex
* @param sequenceName
* @return
*/
public static String getSequenceValue(int dbIndex, String sequenceName) {
return getSequenceValue(dbIndex, sequenceName, null);
}
/**
* 获取Oracle序列号，指定数据库
*
* @param dbKey
* @param sequenceName
* @return
*/
public static String getSequenceValueFrom(String dbKey, String sequenceName) {
return getSequenceValue(getDbIndex(dbKey), sequenceName, null);
}
/**
* 获取格式化的序列号，限Oracle，指定数据库
*
* @param dbIndex
* @param sequenceName
* @param format
* @return
*/
public static String getSequenceValue(int dbIndex, String sequenceName, String format) {
StringBuilder sql = new StringBuilder(100);
if (format == null) {
sql.append("select ").append(sequenceName).append(".nextval from dual");
} else {
sql.append("select to_char(").append(sequenceName).append(".nextval,'");
sql.append(format).append("') from dual");
}
return getString(dbIndex, sql.toString()).trim();
}
/**
* 获取格式化的序列号，限Oracle，指定数据库
*
* @param dbKey
* @param sequenceName
* @param format
* @return
*/
public static String getSequenceValueFrom(String dbKey, String sequenceName, String format) {
return getSequenceValue(getDbIndex(dbKey), sequenceName, format);
}
/**
* 获取格式化的序列号，限Oracle，指定数据库
*
* @param dbIndex
* @param sequenceName
* @return
*/
public static long getSequenceLongValue(int dbIndex, String sequenceName) {
return getLong(dbIndex, "select " + sequenceName + ".nextval from dual");
}
/**
* 获取格式化的序列号，限Oracle，指定数据库
*
* @param dbKey
* @param sequenceName
* @return
*/
public static long getSequenceLongValue(String dbKey, String sequenceName) {
return getSequenceLongValue(getDbIndex(dbKey), sequenceName);
}
/**
* 获取Oracle序列号
*
* @param sequenceName
* @return
*/
public static long getSequenceLongValue(String sequenceName) {
return getSequenceLongValue(-1, sequenceName);
}
/**
* 判断表是否存在
*
* @param tablename
* @return
*/
public static boolean isTableExist(String tablename) {
return isTableExist(-1, tablename);
}
/**
* 判断表是否存在，指定数据库
*
* @param dbIndex
* @param tablename
* @return
*/
public static boolean isTableExist(int dbIndex, String tablename) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.isTableExist(tablename) || jdbcDao.isTableExist(tablename.toUpperCase());
}
/**
* 判断表是否存在，指定数据库
*
* @param dbKey
* @param tablename
* @return
*/
public static boolean isTableExist(String dbKey, String tablename) {
return isTableExist(getDbIndex(dbKey), tablename);
}
private final static String SELECT = "select * ";
/**
* 判断是否是SQL语句或者sqlid
*
* @param sql
* @return
*/
private static String getTrueSql(String sql) {
if (sql == null) {
return null;
}
if (sql.charAt(0) == '/') {
return SqlBuilder.getSql(sql);
} else {
sql = sql.trim();
if (StringUtils.startsWithIgnoreCase(sql, "from")) {
return StringUtils.join(SELECT, sql);
} else {
return sql;
}
}
}
/**
* 调用数据库存储过程
*
* @param spSupportBean
* @return
*/
public static void excuteProcedure(SpSupportBean spSupportBean) {
excuteProcedure(-1, spSupportBean);
}
/**
* 调用数据库存储过程
*
* @param dbIndex
* @param spSupportBean
* @return
*/
public static void excuteProcedure(int dbIndex, SpSupportBean spSupportBean) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
jdbcDao.excuteProcedure(spSupportBean);
}
/**
* 调用数据库存储过程
*
* @param dbKey
* @param spSupportBean
* @return
*/
public static void excuteProcedure(String dbKey, SpSupportBean spSupportBean) {
excuteProcedure(getDbIndex(dbKey), spSupportBean);
}
/**
* 调用数据库函数，返回指定类型
*
* @param sfName
* @param returnClass
* @param params
* @param <R>
* @return
*/
public static <R> R excuteFunction(String sfName, Class<R> returnClass, Object... params) {
return excuteFunction(-1, sfName, returnClass, params);
}
/**
* 调用数据库函数，返回指定类型
*
* @param dbIndex
* @param sfName
* @param returnClass
* @param params
* @param <R>
* @return
*/
public static <R> R excuteFunction(int dbIndex, String sfName, Class<R> returnClass, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.excuteFunction(sfName, returnClass, params);
}
/**
* 调用数据库函数，返回指定类型
*
* @param dbKey
* @param sfName
* @param returnClass
* @param params
* @param <R>
* @return
*/
public static <R> R excuteFunction(String dbKey, String sfName, Class<R> returnClass, Object... params) {
return excuteFunction(getDbIndex(dbKey), sfName, returnClass, params);
}
/**
* 调用数据库函数，返回字符串
*
* @param dbIndex
* @param sfName
* @param params
* @return
*/
public static String excuteFunction(int dbIndex, String sfName, Object... params) {
CommonJdbcDao jdbcDao = getJdbcDao(dbIndex);
return jdbcDao.excuteFunction(sfName, String.class, params);
}
/**
* 调用数据库函数，返回字符串
*
* @param dbKey
* @param sfName
* @param params
* @return
*/
public static String excuteFunctionFrom(String dbKey, String sfName, Object... params) {
return excuteFunction(getDbIndex(dbKey), sfName, params);
}
/**
* 调用数据库函数，返回字符串
*
* @param sfName
* @param params
* @return
*/
public static String excuteFunction(String sfName, Object... params) {
return excuteFunction(-1, sfName, params);
}
}
注:DBConfig 与SpringContextUtils 请参考下篇文章
838
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
