JdbcDao 兼容 mysql 和oracle的 分页 方法，

2019独角兽企业重金招聘Python工程师标准>>>

@Repository("jdbcDao")
public class JdbcDao extends SimpleJdbcTemplate {

 /**
  * 数据库类型
  */
 public static final String DATABSE_TYPE_MYSQL = "mysql";
 public static final String DATABSE_TYPE_POSTGRE = "postgresql";
 public static final String DATABSE_TYPE_ORACLE = "oracle";
 public static final String DATABSE_TYPE_SQLSERVER = "sqlserver";
 /**
  * 分页SQL
  */
 public static final String MYSQL_SQL = "select * from ( {0}) sel_tab00 limit {1},{2}"; // mysql
 public static final String POSTGRE_SQL = "select * from ( {0}) sel_tab00 limit {2} offset {1}";// postgresql
 
 
 
 public static final String ORACLE_SQL =
 "select * from (select row_.*,rownum rownum_ from ({0}) row_ where rownum <= {1}) where rownum_>{2}"; // oracle

 
 
 public static final String SQLSERVER_SQL = 
 "select * from ( select row_number() over(order by tempColumn) tempRowNumber, * from (select top {1} tempColumn = 0, {0}) t ) tt where tempRowNumber > {2}"; // sqlserver

 @Autowired
 public JdbcDao(DataSource dataSource) {
 super(dataSource);
 }

 /**
  * 根据sql语句，返回对象集合
  * 
  * @param  sql语句
  *            (参数用冒号加参数名，例如select * from tb where id=:id)
  * @param  clazz类型
  * @param  parameters参数集合
  *            (key为参数名，value为参数值)
  * @return bean对象集合
  */
 public List find(String sql, Class clazz, Map parameters) {
 return super.find(sql, clazz, parameters);
 }

 /**
  * 根据sql语句，返回对象
  * 
  * @param sql语句
  *            (参数用冒号加参数名，例如select * from tb where id=:id)
  * @param clazz类型
  * @param parameters参数集合
  *            (key为参数名，value为参数值)
  * @return bean对象
  */
 public Object findForObject(String sql, Class clazz, Map parameters) {
 return super.findForObject(sql, clazz, parameters);
 }

 /**
  * 根据sql语句，返回数值型返回结果
  * 
  * @param sql语句
  *            (参数用冒号加参数名，例如select count(*) from tb where id=:id)
  * @param parameters参数集合
  *            (key为参数名，value为参数值)
  * @return bean对象
  */
 public long findForLong(String sql, Map parameters) {
 return super.findForLong(sql, parameters);
 }

 /**
  * 根据sql语句，返回Map对象,对于某些项目来说，没有准备Bean对象，则可以使用Map代替Key为字段名,value为值
  * 
  * @param sql语句
  *            (参数用冒号加参数名，例如select count(*) from tb where id=:id)
  * @param parameters参数集合
  *            (key为参数名，value为参数值)
  * @return bean对象
  */
 public Map findForMap(String sql, Map parameters) {
 return super.findForMap(sql, parameters);
 }

 /**
  * 根据sql语句，返回Map对象集合
  * 
  * @see findForMap
  * @param sql语句
  *            (参数用冒号加参数名，例如select count(*) from tb where id=:id)
  * @param parameters参数集合
  *            (key为参数名，value为参数值)
  * @return bean对象
  */
 public List<Map<String, Object>> findForListMap(String sql, Map parameters) {
 return super.findForListMap(sql, parameters);
 }

 /**
  * 执行insert，update，delete等操作<br>
  * 例如insert into users (name,login_name,password)
  * values(:name,:loginName,:password)<br>
  * 参数用冒号,参数为bean的属性名
  * 
  * @param sql
  * @param bean
  */
 public int executeForObject(String sql, Object bean) {
 return super.executeForObject(sql, bean);
 }

 /**
  * 执行insert，update，delete等操作<br>
  * 例如insert into users (name,login_name,password)
  * values(:name,:login_name,:password)<br>
  * 参数用冒号,参数为Map的key名
  * 
  * @param sql
  * @param parameters
  */
 public int executeForMap(String sql, Map parameters) {
 return super.executeForMap(sql, parameters);
 }

 /*
  * 批量处理操作 例如：update t_actor set first_name = :firstName, last_name =
  * :lastName where id = :id 参数用冒号
  */
 public int[] batchUpdate(final String sql, List<Object[]> batch) {
 return super.batchUpdate(sql, batch);
 }

 /**
  * 使用指定的检索标准检索数据并分页返回数据
  */
 public List<Map<String, Object>> findForJdbc(String sql, int page, int rows) {
 // 封装分页SQL
 sql = jeecgCreatePageSql(sql, page, rows);
 return this.jdbcTemplate.queryForList(sql);
 }

 public List<Map<String, Object>> findForJdbc(String sql, Object... objs) {
 return this.jdbcTemplate.queryForList(sql, objs);
 }

 /**
  * 使用指定的检索标准检索数据并分页返回数据
  * 
  * @throws IllegalAccessException
  * @throws InstantiationException
  */
 public List<T> findObjForJdbc(String sql, int page, int rows, Class<T> clazz) {
 List<T> rsList = new ArrayList<T>();
 // 封装分页SQL
 sql = jeecgCreatePageSql(sql, page, rows);
 List<Map<String, Object>> mapList = jdbcTemplate.queryForList(sql);

 T po = null;
 for (Map<String, Object> m : mapList) {
 try {
 po = clazz.newInstance();
 MyBeanUtils.copyMap2Bean_Nobig(po, m);
 rsList.add(po);
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 return rsList;
 }

 /**
  * 使用指定的检索标准检索数据并分页返回数据-采用预处理方式
  * 
  * @param criteria
  * @param firstResult
  * @param maxResults
  * @return
  * @throws DataAccessException
  */
 public List<Map<String, Object>> findForJdbcParam(String sql, int page,
 int rows, Object... objs) {
 // 封装分页SQL
 sql = jeecgCreatePageSql(sql, page, rows);
 return jdbcTemplate.queryForList(sql, objs);
 }

 public Map<String, Object> findOneForJdbc(String sql, Object... objs) {
 try {
 return this.jdbcTemplate.queryForMap(sql, objs);
 } catch (EmptyResultDataAccessException e) {
 return null;
 }
 }

 /**
  * 使用指定的检索标准检索数据并分页返回数据For JDBC
  */
 public Long getCountForJdbc(String sql) {
 return jdbcTemplate.queryForLong(sql);
 }

 /**
  * 使用指定的检索标准检索数据并分页返回数据For JDBC-采用预处理方式
  * 
  */
 public Long getCountForJdbcParam(String sql, Object... objs) {
 return jdbcTemplate.queryForLong(sql, objs);
 }

 public Integer executeSql2(String sql, List<Object> param) {
 return this.jdbcTemplate.update(sql, param);
 }

 public Integer executeSql(String sql, Object... param) {
 return this.jdbcTemplate.update(sql, param);
 }

 public Integer countByJdbc(String sql, Object... param) {
 return this.jdbcTemplate.queryForInt(sql, param);
 }

 /**
  * 按照数据库类型，封装SQL
  */
 public static String jeecgCreatePageSql(String sql, int page, int rows) {
 int beginNum = (page - 1) * rows;
 String[] sqlParam = new String[3];
 sqlParam[0] = sql;
 sqlParam[1] = beginNum + "";
 sqlParam[2] = rows + "";
 if (ResourceUtil.getJdbcUrl().indexOf(DATABSE_TYPE_MYSQL) != -1) {
 sql = MessageFormat.format(MYSQL_SQL, sqlParam);
 } else if (ResourceUtil.getJdbcUrl().indexOf(DATABSE_TYPE_POSTGRE) != -1) {
 sql = MessageFormat.format(POSTGRE_SQL, sqlParam);
 } else {
 int beginIndex = (page - 1) * rows;
 int endIndex = beginIndex + rows;
 sqlParam[2] = Integer.toString(beginIndex);
 sqlParam[1] = Integer.toString(endIndex);
 if (ResourceUtil.getJdbcUrl().indexOf(DATABSE_TYPE_ORACLE) != -1) {
 sql = MessageFormat.format(ORACLE_SQL, sqlParam);
 } else if (ResourceUtil.getJdbcUrl()
 .indexOf(DATABSE_TYPE_SQLSERVER) != -1) {
 sqlParam[0] = sql.substring(getAfterSelectInsertPoint(sql));
 sql = MessageFormat.format(SQLSERVER_SQL, sqlParam);
 }
 }
 return sql;
 }

 private static int getAfterSelectInsertPoint(String sql) {
 int selectIndex = sql.toLowerCase().indexOf("select");
 int selectDistinctIndex = sql.toLowerCase().indexOf("select distinct");
 return selectIndex + (selectDistinctIndex == selectIndex ? 15 : 6);
 }
}

转载于:https://my.oschina.net/thomas2/blog/301622