数据库操作工具类，支持多数据源配置

/**
 * 数据库操作工具类，支持多数据源配置
 *
 * @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 
     */
    public static <T> void save(T entity) {
        save(-1, entity);
    }

    /**
     * 单表保存，指定数据库
     *
     * @param dbIndex
     * @param entity
     * @param 
     */
    public static <T> void save(int dbIndex, T entity) {
        CommonHibernateDao hibernateDao = getHibernateDao(dbIndex);
        hibernateDao.save(entity);
    }

    /**
     * 单表保存，指定数据库
     *
     * @param dbKey
     * @param entity
     * @param 
     */
    public static <T> void save(String dbKey, T entity) {
        save(getDbIndex(dbKey), entity);
    }

    /**
     * 批量保存
     *
     * @param entitys
     * @param 
     */
    public static <T> void save(List<T> entitys) {
        save(-1, entitys);
    }

    /**
     * 批量保存，指定数据库
     *
     * @param dbIndex
     * @param entitys
     * @param 
     */
    public static <T> void save(int dbIndex, List<T> entitys) {
        for (T entity : entitys) {
            save(dbIndex, entity);
        }
    }

    /**
     * 批量保存，指定数据库
     *
     * @param dbKey
     * @param entitys
     * @param 
     */
    public static <T> void save(String dbKey, List<T> entitys) {
        save(getDbIndex(dbKey), entitys);
    }

    /**
     * 单表更新
     *
     * @param entity
     * @param 
     */
    public static <T> void update(T entity) {
        update(-1, entity);
    }

    /**
     * 单表更新，指定数据库
     *
     * @param dbIndex
     * @param entity
     * @param 
     */
    public static <T> void update(int dbIndex, T entity) {
        CommonHibernateDao hibernateDao = getHibernateDao(dbIndex);
        hibernateDao.update(entity);
    }

    /**
     * 单表更新，指定数据库
     *
     * @param dbKey
     * @param entity
     * @param 
     */
    public static <T> void update(String dbKey, T entity) {
        update(getDbIndex(dbKey), entity);
    }

    /**
     * 批量更新
     *
     * @param entitys
     * @param 
     */
    public static <T> void update(List<T> entitys) {
        update(-1, entitys);
    }

    /**
     * 批量更新，指定数据库
     *
     * @param dbIndex
     * @param entitys
     * @param 
     */
    public static <T> void update(int dbIndex, List<T> entitys) {
        for (T entity : entitys) {
            update(dbIndex, entity);
        }
    }

    /**
     * 批量更新，指定数据库
     *
     * @param dbKey
     * @param entitys
     * @param 
     */
    public static <T> void update(String dbKey, List<T> entitys) {
        update(getDbIndex(dbKey), entitys);
    }

    /**
     * 单实体删除
     *
     * @param clazz
     * @param id
     * @param 
     */
    public static <T> void delete(Class<T> clazz, Serializable id) {
        delete(-1, clazz, id);
    }

    /**
     * 单实体删除，指定数据库
     *
     * @param dbIndex
     * @param clazz
     * @param id
     * @param 
     */
    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 
     */
    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 
     */
    public static <T> void delete(int dbIndex, T entity) {
        CommonHibernateDao hibernateDao = getHibernateDao(dbIndex);
        hibernateDao.delete(entity);
    }

    /**
     * 单实体删除，指定数据库
     *
     * @param dbKey
     * @param entity
     * @param 
     */
    public static <T> void delete(String dbKey, T entity) {
        delete(getDbIndex(dbKey), entity);
    }

    /**
     * 批量删除
     *
     * @param entitys
     * @param 
     */
    public static <T> void delete(List<T> entitys) {
        delete(-1, entitys);
    }

    /**
     * 批量删除，指定数据库
     *
     * @param dbIndex
     * @param entitys
     * @param 
     */
    public static <T> void delete(int dbIndex, List<T> entitys) {

        for (T entity : entitys) {
            delete(dbIndex, entity);
        }
    }

    /**
     * 批量删除，指定数据库
     *
     * @param dbKey
     * @param entitys
     * @param 
     */
    public static <T> void delete(String dbKey, List<T> entitys) {
        delete(getDbIndex(dbKey), entitys);
    }

    /**
     * 单实体加载
     *
     * @param 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @return
     */
    public static <T> List<T> loadList(String hql, Object... params) {
        return loadList(-1, hql, params);
    }

    /**
     * 通过hql查询列表，指定数据库
     *
     * @param dbIndex
     * @param hql
     * @param params
     * @param 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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>，放入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>，放入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>，放入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>，放入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>，放入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>，放入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>，放入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>，放入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>，放入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>，放入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>，放入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>，放入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，放入Page中
     *
     * @param pageParam
     * @param sql
     * @param clazz
     * @param params
     * @param 
     * @return
     */
    public static <R> PageResult query(PageParam pageParam, String sql, Class<R> clazz, Object... params) {
        return query(-1, pageParam, sql, clazz, params);
    }

    /**
     * 分页查询，结果集为List，放入Page中
     *
     * @param pageParam
     * @param sql
     * @param clazz
     * @param params
     * @param 
     * @return
     */
    public static <R> PageResult query(PageParam pageParam, Sql sql, Class<R> clazz, Object... params) {
        return query(-1, pageParam, sql, clazz, params);
    }

    /**
     * 分页查询，结果集为List，放入Page中，指定数据库
     *
     * @param dbIndex
     * @param pageParam
     * @param sql
     * @param clazz
     * @param params
     * @param 
     * @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，放入Page中，指定数据库
     *
     * @param dbKey
     * @param pageParam
     * @param sql
     * @param clazz
     * @param params
     * @param 
     * @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，放入Page中，指定数据库
     *
     * @param dbIndex
     * @param pageParam
     * @param sql
     * @param clazz
     * @param params
     * @param 
     * @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，放入Page中，指定数据库
     *
     * @param dbKey
     * @param pageParam
     * @param sql
     * @param clazz
     * @param params
     * @param 
     * @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，放入Page中，带字典表
     *
     * @param pageParam
     * @param sql
     * @param clazz
     * @param dicMap
     * @param params
     * @param 
     * @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，放入Page中，带字典表
     *
     * @param pageParam
     * @param sql
     * @param clazz
     * @param dicMap
     * @param params
     * @param 
     * @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，放入Page中，带字典表，指定数据库
     *
     * @param dbIndex
     * @param pageParam
     * @param sql
     * @param clazz
     * @param dicMap
     * @param params
     * @param 
     * @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，放入Page中，带字典表，指定数据库
     *
     * @param dbKey
     * @param pageParam
     * @param sql
     * @param clazz
     * @param dicMap
     * @param params
     * @param 
     * @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，放入Page中，带字典表，指定数据库
     *
     * @param dbIndex
     * @param pageParam
     * @param sql
     * @param clazz
     * @param dicMap
     * @param params
     * @param 
     * @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，放入Page中，带字典表，指定数据库
     *
     * @param dbKey
     * @param pageParam
     * @param sql
     * @param clazz
     * @param dicMap
     * @param params
     * @param 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 
     * @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 请参考下篇文章