文档章节

DAO设计

疯子阳
 疯子阳
发布于 2016/01/26 21:49
字数 4894
阅读 177
收藏 14
点赞 1
评论 0
引用

  提供不同数据源和方言实现智能分页,因Spring单例模式,可以利用Cglib实现动态数据源切换方案,基础东西不讲了,直接看代码。 

引用

  持久超接口,获取操作模板,可以是JdbcTemplate、SqlSessionTemplate等 

Java代码   收藏代码
  1. package com.sunshine.basic.dao;  
  2.   
  3. public interface SuperDao<T> {  
  4.       
  5.     /** 
  6.      * 获取操作模板 
  7.      * @return  
  8.      */  
  9.      T getTemplate();  
  10.       
  11. }  

引用

查询+分页操作接口 

Java代码   收藏代码
  1. package com.sunshine.basic.dao;  
  2.   
  3. import java.sql.SQLException;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6.   
  7. import org.springframework.jdbc.core.JdbcTemplate;  
  8.   
  9. import com.sunshine.basic.dao.page.PagingParameter;  
  10. import com.sunshine.basic.exception.DaoAccessException;  
  11.   
  12. /** 
  13.  * 查询+分页操作接口 
  14.  * @author OY 
  15.  * @since 2016/01/20 
  16.  * @see V2.0.0 
  17.  */  
  18. public interface JdbcQueryDao extends SuperDao<JdbcTemplate>{  
  19.       
  20.     /*** 
  21.      * 查询单个字段值 
  22.      * 采用?占位符,如 name=? 
  23.      * @param sql 
  24.      * @param paras 
  25.      * @return 
  26.      * @throws DaoAccessException 
  27.      */  
  28.     Object getField(String sql, Object...paras) throws DaoAccessException;  
  29.     /** 
  30.      * 查询单个字段值 
  31.      * 采用?占位符 
  32.      * @param sql 
  33.      * @param paras 
  34.      * @return 
  35.      * @throws DaoAccessException 
  36.      */  
  37.     Object getField(String sql, List<Object> paras) throws DaoAccessException;  
  38.     /** 
  39.      * 查询单个字段值 
  40.      * 采用名称占位符,如 name=:name 
  41.      * @param sql 
  42.      * @param paras key与占位符名称一致 
  43.      * @return 
  44.      * @throws DaoAccessException 
  45.      */  
  46.     Object getField(String sql, Map<String, Object> paras) throws DaoAccessException;  
  47.     //===================================================================================  
  48.     /** 
  49.      * 查询单个对象 
  50.      * 采用?占位符,如 name=? 
  51.      * @param sql 
  52.      * @param paras 
  53.      * @return 
  54.      */  
  55.     Map<String, Object> getObject(String sql, Object...paras) throws DaoAccessException;  
  56.     /** 
  57.      * 查询单个对象 
  58.      * 采用?占位符,如 name=? 
  59.      * @param sql 
  60.      * @param paras 
  61.      * @return 
  62.      * @throws DaoAccessException 
  63.      */  
  64.     Map<String, Object> getObject(String sql, List<Object> paras) throws DaoAccessException;  
  65.     /** 
  66.      * 查询单个对象 
  67.      * 采用名称占位符,如 name=:name 
  68.      * @param sql 
  69.      * @param paras key与占位符名称一致 
  70.      * @return 
  71.      * @throws DaoAccessException 
  72.      */  
  73.     Map<String, Object> getObject(String sql, Map<String, Object> paras) throws DaoAccessException;  
  74.       
  75.     /** 
  76.      * 查询单个对象(封装) 
  77.      * 采用?占位符,如 name=? 
  78.      * @param sql 
  79.      * @param classz 
  80.      * @param paras 
  81.      * @return 
  82.      */  
  83.     <T> T getObject(String sql, Class<T> classz, Object...paras) throws DaoAccessException;  
  84.     /** 
  85.      * 查询单个对象(封装) 
  86.      * 采用?占位符,如 name=? 
  87.      * @param sql 
  88.      * @param classz 
  89.      * @param paras 
  90.      * @return 
  91.      * @throws DaoAccessException 
  92.      */  
  93.     <T> T getObject(String sql, Class<T> classz, List<Object> paras) throws DaoAccessException;  
  94.     /** 
  95.      * 查询单个对象(封装) 
  96.      * 采用名称占位符,如 name=:name 
  97.      * @param sql 
  98.      * @param classz 
  99.      * @param paras key与占位符名称一致 
  100.      * @return 
  101.      * @throws DaoAccessException 
  102.      */  
  103.     <T> T getObject(String sql, Class<T> classz, Map<String, Object> paras) throws DaoAccessException;  
  104.       
  105.     //====================================================================================================  
  106.     /** 
  107.      * 查询列表 
  108.      * 采用?占位符,如 name=? 
  109.      * @param sql SQL语句 
  110.      * @param paras 参数 
  111.      * @return 
  112.      * @throws DaoAccessException 
  113.      */  
  114.     List<Map<String, Object>> getList(String sql, Object...paras) throws DaoAccessException;  
  115.     /** 
  116.      * 查询列表 
  117.      * 采用?占位符,如 name=? 
  118.      * @param sql 
  119.      * @param paras 
  120.      * @return 
  121.      * @throws DaoAccessException 
  122.      */  
  123.     List<Map<String, Object>> getList(String sql, List<Object> paras) throws DaoAccessException;  
  124.     /** 
  125.      * 查询列表 
  126.      * @param sql 
  127.      * @param paras 
  128.      * @return 
  129.      * @throws DaoAccessException 
  130.      */  
  131.     List<Map<String, Object>> getList(String sql, Map<String, Object> paras) throws DaoAccessException;  
  132.       
  133.       
  134.     /** 
  135.      * 查询列表(封装) 
  136.      * 采用?占位符,如 name=? 
  137.      * @param sql SQL语句 
  138.      * @param classz 结果封装类 
  139.      * @param paras 参数 
  140.      * @return 
  141.      * @throws DaoAccessException 
  142.      */  
  143.     <T> List<T> getList(String sql, Class<T> classz, Object...paras) throws DaoAccessException;  
  144.     /** 
  145.      * 查询列表(封装) 
  146.      * 采用?占位符,如 name=? 
  147.      * @param sql 
  148.      * @param classz 
  149.      * @param paras 
  150.      * @return 
  151.      * @throws DaoAccessException 
  152.      */  
  153.     <T> List<T> getList(String sql, Class<T> classz, List<Object> paras) throws DaoAccessException;  
  154.     /** 
  155.      * 查询列表(封装) 
  156.      * 采用名称占位符,如 name=:name 
  157.      * @param sql 
  158.      * @param classz 
  159.      * @param paras key与占位符名称一致 
  160.      * @return 
  161.      * @throws DaoAccessException 
  162.      */  
  163.     <T> List<T> getList(String sql, Class<T> classz, Map<String, Object> paras) throws DaoAccessException;  
  164.       
  165.       
  166.     //====================================================================================================  
  167.       
  168.       
  169.     /** 
  170.      * 查询总记录数 
  171.      * 采用?占位符,如 name=? 
  172.      * @param sql                 查询SQL 
  173.      * @param limit               查询限制,limit=0查询不受限制 
  174.      * @return 
  175.      * @throws SQLException 
  176.      * @throws DaoAccessException 
  177.      */  
  178.     public int getRecordCounts(String sql, int limit, Object...paras)throws DaoAccessException;  
  179.     /** 
  180.      * 查询记录总数 
  181.      * 采用?占位符,如 name=? 
  182.      * @param sql 
  183.      * @param limit 
  184.      * @param paras 
  185.      * @return 
  186.      * @throws DaoAccessException 
  187.      */  
  188.     public int getRecordCounts(String sql, int limit, List<Object> paras)throws DaoAccessException;  
  189.     /** 
  190.      * 查询记录总数 
  191.      * 采用名称占位符,如 name=:name 
  192.      * @param sql 
  193.      * @param limit 
  194.      * @param paras key与占位符名称一致 
  195.      * @return 
  196.      * @throws DaoAccessException 
  197.      */  
  198.     public int getRecordCounts(String sql, int limit, Map<String, Object> paras)throws DaoAccessException;  
  199.       
  200.     /** 
  201.      * 查询分页列表 
  202.      * 采用?占位符,如 name=? 
  203.      * @param sql                 查询SQL 
  204.      * @param pagingParameter     分页对象,pagingParameter=null或无参数构分页对象,不做分页 
  205.      * @return 
  206.      * @throws SQLException 
  207.      * @throws DaoAccessException 
  208.      */  
  209.     public List<Map<String, Object>> getRecordData(String sql, PagingParameter pagingParameter, Object...paras)throws DaoAccessException;  
  210.     /** 
  211.      * 查询分页列表 
  212.      * 采用?占位符,如 name=? 
  213.      * @param sql 
  214.      * @param pagingParameter 
  215.      * @param paras 
  216.      * @return 
  217.      * @throws DaoAccessException 
  218.      */  
  219.     public List<Map<String, Object>> getRecordData(String sql, PagingParameter pagingParameter, List<Object> paras)throws DaoAccessException;  
  220.     /** 
  221.      * 查询分页列表 
  222.      * 采用名称占位符,如 name=:name 
  223.      * @param sql 
  224.      * @param pagingParameter 
  225.      * @param paras key与占位符名称一致 
  226.      * @return 
  227.      * @throws DaoAccessException 
  228.      */  
  229.     public List<Map<String, Object>> getRecordData(String sql, PagingParameter pagingParameter, Map<String, Object> paras)throws DaoAccessException;  
  230.       
  231.     /** 
  232.      * 查询分页列表(封装) 
  233.      * 采用?占位符,如 name=? 
  234.      * @param <T>          
  235.      * @param sql                 查询SQL 
  236.      * @param pagingParameter     分页对象,pagingParameter=null或无参数构分页对象,不做分页 
  237.      * @param classz 
  238.      * @return 
  239.      * @throws SQLException 
  240.      * @throws DaoAccessException 
  241.      */  
  242.     public <T> List<T> getRecordData(String sql, Class<T> classz, PagingParameter pagingParameter, Object...paras)throws DaoAccessException;  
  243.     /** 
  244.      * 查询分页列表(封装) 
  245.      * 采用?占位符,如 name=? 
  246.      * @param sql 
  247.      * @param classz 
  248.      * @param pagingParameter 
  249.      * @param paras 
  250.      * @return 
  251.      * @throws DaoAccessException 
  252.      */  
  253.     public <T> List<T> getRecordData(String sql, Class<T> classz, PagingParameter pagingParameter, List<Object> paras)throws DaoAccessException;  
  254.     /** 
  255.      * 查询分页列表(封装) 
  256.      * 采用名称占位符,如 name=:name 
  257.      * @param sql 
  258.      * @param classz 
  259.      * @param pagingParameter 
  260.      * @param paras key与占位符名称一致 
  261.      * @return 
  262.      * @throws DaoAccessException 
  263.      */  
  264.     public <T> List<T> getRecordData(String sql, Class<T> classz, PagingParameter pagingParameter, Map<String, Object> paras)throws DaoAccessException;  
  265.   
  266.     //==================================================================================================================  
  267.     /** 
  268.      * 分页查询结果 
  269.      * 采用?占位符,如 name=? 
  270.      * @param sql 
  271.      * @param curPage 
  272.      * @param pageSize 
  273.      * @param paras 
  274.      * @return 
  275.      */  
  276.     public Map<String, Object> getPageForMap(String sql, int curPage, int pageSize, Object...paras)throws DaoAccessException;  
  277.     /** 
  278.      * 分页查询结果 
  279.      * 采用?占位符,如 name=? 
  280.      * @param sql 
  281.      * @param curPage 
  282.      * @param pageSize 
  283.      * @param paras 
  284.      * @return 
  285.      * @throws DaoAccessException 
  286.      */  
  287.     public Map<String, Object> getPageForMap(String sql, int curPage, int pageSize, List<Object> paras)throws DaoAccessException;  
  288.     /** 
  289.      * 分页查询结果 
  290.      * 采用名称占位符,如 name=:name 
  291.      * @param sql 
  292.      * @param curPage 
  293.      * @param pageSize 
  294.      * @param paras key与占位符名称一致 
  295.      * @return 
  296.      * @throws DaoAccessException 
  297.      */  
  298.     public Map<String, Object> getPageForMap(String sql, int curPage, int pageSize, Map<String, Object> paras)throws DaoAccessException;  
  299.       
  300.     /** 
  301.      * 分页查询结果(封装) 
  302.      * 采用?占位符,如 name=? 
  303.      * @param sql 
  304.      * @param curPage 
  305.      * @param pageSize 
  306.      * @param clazz 
  307.      * @param paras 
  308.      * @return 
  309.      */  
  310.     public Map<String, Object> getPageForMap(String sql, int curPage, int pageSize, Class<?> clazz, Object...paras)throws DaoAccessException;  
  311.     /** 
  312.      * 分页查询结果(封装) 
  313.      * 采用?占位符,如 name=? 
  314.      * @param sql 
  315.      * @param curPage 
  316.      * @param pageSize 
  317.      * @param clazz 
  318.      * @param paras 
  319.      * @return 
  320.      * @throws DaoAccessException 
  321.      */  
  322.     public Map<String, Object> getPageForMap(String sql, int curPage, int pageSize, Class<?> clazz, List<Object> paras)throws DaoAccessException;  
  323.     /** 
  324.      * 分页查询结果(封装) 
  325.      * 采用名称占位符,如 name=:name 
  326.      * @param sql 
  327.      * @param curPage 
  328.      * @param pageSize 
  329.      * @param clazz 
  330.      * @param paras key与占位符名称一致 
  331.      * @return 
  332.      * @throws DaoAccessException 
  333.      */  
  334.     public Map<String, Object> getPageForMap(String sql, int curPage, int pageSize, Class<?> clazz, Map<String, Object> paras)throws DaoAccessException;  
  335.   
  336. }  

Java代码   收藏代码
  1. /*更新接口*/  
  2. package com.sunshine.basic.dao;  
  3.   
  4. import java.util.List;  
  5. import java.util.Map;  
  6.   
  7. import org.springframework.jdbc.core.JdbcTemplate;  
  8.   
  9. import com.sunshine.basic.exception.DaoAccessException;  
  10.   
  11.   
  12. public interface JdbcUpdateDao extends SuperDao<JdbcTemplate>{  
  13.       
  14.     void update(String sql, Object...paras) throws DaoAccessException;  
  15.       
  16.     void update(String sql, List<Object> paras) throws DaoAccessException;  
  17.       
  18.     void update(String sql, Map<String, Object> paras) throws DaoAccessException;  
  19.       
  20. }  

Java代码   收藏代码
  1. /*插入接口*/  
  2. package com.sunshine.basic.dao;  
  3.   
  4. import java.util.List;  
  5. import java.util.Map;  
  6.   
  7. import org.springframework.jdbc.core.JdbcTemplate;  
  8.   
  9. import com.sunshine.basic.exception.DaoAccessException;  
  10.   
  11.   
  12. public interface JdbcInsertDao extends SuperDao<JdbcTemplate>{  
  13.       
  14.     void insert(String sql, Object...paras) throws DaoAccessException;  
  15.       
  16.     void insert(String sql, List<Object> paras) throws DaoAccessException;  
  17.       
  18.     void insert(String sql, Map<String, Object> paras) throws DaoAccessException;  
  19.       
  20. }  

引用

操作实现,暂未实现更新、插入。定义模板获取方法、SQL解析器由子类实现(设计模式之模板模式) 

Java代码   收藏代码
  1.  package com.sunshine.basic.dao;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Arrays;  
  5. import java.util.Collections;  
  6. import java.util.HashMap;  
  7. import java.util.List;  
  8. import java.util.Map;  
  9.   
  10. import org.apache.log4j.Logger;  
  11. import org.springframework.dao.EmptyResultDataAccessException;  
  12. import org.springframework.jdbc.core.BeanPropertyRowMapper;  
  13. import org.springframework.jdbc.core.JdbcTemplate;  
  14. import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;  
  15.   
  16. import com.sunshine.basic.dao.page.DataStore;  
  17. import com.sunshine.basic.dao.page.PagingParameter;  
  18. import com.sunshine.basic.dao.parser.AbstractParser;  
  19. import com.sunshine.basic.dao.parser.Dialect;  
  20. import com.sunshine.basic.dao.parser.Parser;  
  21. import com.sunshine.basic.exception.DaoAccessException;  
  22. /** 
  23.  * 持久操作 
  24.  * @author OY 
  25.  * @since 2016/01/20 
  26.  * @see V2.0.0 
  27.  */  
  28. public abstract class AbstractJdbcCommDao implements JdbcQueryDao, JdbcInsertDao, JdbcUpdateDao{  
  29.   
  30.     private Logger log = Logger.getLogger(getClass());  
  31.       
  32.     private NamedParameterJdbcTemplate nameJdbTemplate;  
  33.       
  34.     private JdbcTemplate jdbcTemplate;  
  35.       
  36.     public NamedParameterJdbcTemplate getNamedJdbcTemplate(){  
  37.         nameJdbTemplate = new NamedParameterJdbcTemplate(  
  38.                 getTemplate());  
  39.         return nameJdbTemplate;  
  40.     }  
  41.     /** 
  42.      * 子类实现获取JdbcTemplate 
  43.      * @return 
  44.      * @throws DaoAccessException 
  45.      */  
  46.     public abstract JdbcTemplate getSubJdbcTemplate() throws DaoAccessException ;  
  47.     /** 
  48.      * 子类实现解析器(根据方言构造分页语句) 
  49.      * @return 
  50.      * @throws DaoAccessException 
  51.      */  
  52.     public abstract Parser getParser() throws DaoAccessException;  
  53.       
  54.     @Override  
  55.     public final JdbcTemplate getTemplate() {  
  56.         try {  
  57.             jdbcTemplate = getSubJdbcTemplate();  
  58.             if(jdbcTemplate == null) {  
  59.                 log.info("jdbcTemplate is not exits!");  
  60.                 throw new IllegalAccessException("jdbcTemplate is not exits!");  
  61.                 //return SpringApplicationContext.getBean(DEFAULT_JDBC_TEMPLATE, JdbcTemplate.class);  
  62.             }  
  63.         } catch (Exception e) {  
  64.             log.error("jdbcTemplate is not exits!");  
  65.             e.printStackTrace();  
  66.         }  
  67.         return jdbcTemplate;  
  68.     }  
  69.       
  70.     @Override  
  71.     public Object getField(String sql, Object... paras)  
  72.             throws DaoAccessException {  
  73.         log.info("jcbksql-" + sql);  
  74.         Object result = null;  
  75.         try{  
  76.             result = getTemplate().queryForObject(sql, paras, Object.class);  
  77.         }catch(EmptyResultDataAccessException e){  
  78.             //不做处理  
  79.         }  
  80.         return result;  
  81.     }  
  82.   
  83.     @Override  
  84.     public Object getField(String sql, List<Object> paras)  
  85.             throws DaoAccessException {  
  86.         log.info("jcbksql-" + sql);  
  87.         return getField(sql, paras.toArray());  
  88.     }  
  89.   
  90.     @Override  
  91.     public Object getField(String sql, Map<String, Object> paras)  
  92.             throws DaoAccessException {  
  93.         log.info("jcbksql-" + sql);  
  94.         Object result = null;  
  95.         try{  
  96.             result = getNamedJdbcTemplate().queryForObject(sql, paras, Object.class);  
  97.         }catch(EmptyResultDataAccessException e){  
  98.             //不做处理  
  99.         }  
  100.         return result;  
  101.     }  
  102.       
  103.     @Override  
  104.     public Map<String, Object> getObject(String sql, Object... paras)  
  105.             throws DaoAccessException {  
  106.         log.info("jcbksql-" + sql);  
  107.         Map<String, Object> result = null;  
  108.         try{  
  109.             result = getTemplate().queryForMap(sql, paras);  
  110.         }catch(EmptyResultDataAccessException e){  
  111.             //不做处理  
  112.         }  
  113.         return result;  
  114.     }  
  115.   
  116.     @Override  
  117.     public Map<String, Object> getObject(String sql, List<Object> paras)  
  118.             throws DaoAccessException {  
  119.         log.info("jcbksql-" + sql);  
  120.         return getObject(sql, paras.toArray());  
  121.     }  
  122.   
  123.     @Override  
  124.     public Map<String, Object> getObject(String sql, Map<String, Object> paras)  
  125.             throws DaoAccessException {  
  126.         log.info("jcbksql-" + sql);  
  127.         Map<String, Object> result = null ;  
  128.         try{  
  129.             result = getNamedJdbcTemplate().queryForMap(sql, paras);  
  130.         }catch(EmptyResultDataAccessException e){  
  131.             //不做处理  
  132.         }  
  133.         return result;  
  134.     }  
  135.   
  136.     @Override  
  137.     public <T> T getObject(String sql, Class<T> classz, Object... paras)  
  138.             throws DaoAccessException {  
  139.         log.info("jcbksql-" + sql);  
  140.         T result = null;  
  141.         try{  
  142.             result = getTemplate().queryForObject(sql, paras, new BeanPropertyRowMapper<T>(classz));  
  143.         }catch(EmptyResultDataAccessException e){  
  144.             //不做处理  
  145.         }  
  146.         return result;  
  147.     }   
  148.   
  149.     @Override  
  150.     public <T> T getObject(String sql, Class<T> classz, List<Object> paras)  
  151.             throws DaoAccessException {  
  152.         log.info("jcbksql-" + sql);  
  153.         return getObject(sql, classz, paras.toArray());  
  154.     }  
  155.   
  156.     @Override  
  157.     public <T> T getObject(String sql, Class<T> classz,  
  158.             Map<String, Object> paras) throws DaoAccessException {  
  159.         log.info("jcbksql-" + sql);  
  160.         T result = null;  
  161.         try{  
  162.             result = getNamedJdbcTemplate().queryForObject(sql, paras, new BeanPropertyRowMapper<T>(classz));  
  163.         }catch(EmptyResultDataAccessException e){  
  164.             //不做处理  
  165.         }  
  166.         return result;  
  167.     }  
  168.       
  169.     @Override  
  170.     public List<Map<String, Object>> getList(String sql, Object... paras)  
  171.             throws DaoAccessException {  
  172.         log.info("jcbksql-" + sql);  
  173.         return getTemplate().queryForList(sql, paras);  
  174.     }  
  175.   
  176.     @Override  
  177.     public List<Map<String, Object>> getList(String sql, List<Object> paras)  
  178.             throws DaoAccessException {  
  179.         log.info("jcbksql-" + sql);  
  180.         return getList(sql, paras.toArray());  
  181.     }  
  182.   
  183.     @Override  
  184.     public List<Map<String, Object>> getList(String sql,  
  185.             Map<String, Object> paras) throws DaoAccessException {  
  186.         log.info("jcbksql-" + sql);  
  187.         return getNamedJdbcTemplate().queryForList(sql, paras);  
  188.     }  
  189.   
  190.     @Override  
  191.     public <T> List<T> getList(String sql, Class<T> classz, Object... paras)  
  192.             throws DaoAccessException {  
  193.         log.info("jcbksql-" + sql);  
  194.         return getTemplate().query(sql, paras, new BeanPropertyRowMapper<T>(classz));  
  195.     }  
  196.   
  197.     @Override  
  198.     public <T> List<T> getList(String sql, Class<T> classz, List<Object> paras)  
  199.             throws DaoAccessException {  
  200.         log.info("jcbksql-" + sql);  
  201.         return getList(sql, classz, paras.toArray());  
  202.     }  
  203.   
  204.     @Override  
  205.     public <T> List<T> getList(String sql, Class<T> classz,  
  206.             Map<String, Object> paras) throws DaoAccessException {  
  207.         log.info("jcbksql-" + sql);  
  208.         return getNamedJdbcTemplate().query(sql, paras, new BeanPropertyRowMapper<T>(classz));  
  209.     }  
  210.   
  211.       
  212.     @Override  
  213.     public int getRecordCounts(String sql, int limit, Object... paras)  
  214.             throws DaoAccessException {  
  215.         log.info("jcbksql-" + sql);  
  216.         String cSql = getParser().getCountSql(sql);  
  217.         log.info("jcbksql-count-" + cSql);  
  218.         Object result = getField(cSql, paras);  
  219.         return Integer.valueOf((result == null)?"0":String.valueOf(result));  
  220.     }  
  221.   
  222.     @Override  
  223.     public int getRecordCounts(String sql, int limit, List<Object> paras)  
  224.             throws DaoAccessException {  
  225.           
  226.         return getRecordCounts(sql, limit, paras.toArray());  
  227.     }  
  228.   
  229.     @Override  
  230.     public int getRecordCounts(String sql, int limit, Map<String, Object> paras)  
  231.             throws DaoAccessException {  
  232.         log.info("jcbksql-" + sql);  
  233.         String cSql = getParser().getCountSql(sql);  
  234.         log.info("jcbksql-count-" + cSql);  
  235.         Object result = getField(cSql, paras);  
  236.         return Integer.valueOf((result==null)?"0":String.valueOf(result));  
  237.     }  
  238.   
  239.   
  240.     /** 
  241.      * 增加分页参数(分页启始行、页大小)  
  242.      */  
  243.     private List<Object> addPageParameters(List<Object> paras, PagingParameter pagingParameter, Parser parser){  
  244.         List<Object> plist = new ArrayList<Object>(2);  
  245.         /* 结束行或页大小 */  
  246.         plist.add(pagingParameter.getEndRow(parser.getDialect()));  
  247.         /* 开始 */  
  248.         plist.add(pagingParameter.getStartRow());  
  249.         Dialect dialect = parser.getDialect();  
  250.         switch (dialect) {  
  251.             case mysql:  
  252.                 Collections.reverse(plist); /*MYSQL*/  
  253.                 break;  
  254.             default:  
  255.                 break;  
  256.         }  
  257.         if(paras != null){  
  258.             List<Object> temp = Collections.synchronizedList(paras);  
  259.             plist.addAll(0, temp);  
  260.         }  
  261.         return plist;  
  262.     }  
  263.       
  264.     /** 
  265.      * 增加分页参数(分页启始行、页大小)  
  266.      */  
  267.     private Map<String, Object> addPageParameters(Map<String, Object> paras, PagingParameter pagingParameter, Parser parser){  
  268.         Map<String, Object> pMap = new HashMap<String, Object>(2);  
  269.         pMap.put(AbstractParser.START_INDEX_NAME, pagingParameter.getStartRow());  
  270.         pMap.put(AbstractParser.END_INDEX_NAME, pagingParameter.getEndRow(parser.getDialect()));  
  271.         if(paras != null){  
  272.             paras.putAll(pMap);  
  273.             return paras;  
  274.         }  
  275.         return pMap;  
  276.     }  
  277.       
  278.     @Override  
  279.     public List<Map<String, Object>> getRecordData(String sql,  
  280.             PagingParameter pagingParameter, Object... paras)  
  281.             throws DaoAccessException {  
  282.           
  283.         return getRecordData(sql, pagingParameter, Arrays.asList(paras));  
  284.     }  
  285.       
  286.     @Override  
  287.     public List<Map<String, Object>> getRecordData(String sql,  
  288.             PagingParameter pagingParameter, List<Object> paras)  
  289.             throws DaoAccessException {  
  290.         log.info("jcbksql-" + sql);  
  291.         Parser parser = getParser();  
  292.         String pSql = parser.getPageSql(sql);  
  293.         log.info("jcbksql-page-" + pSql + " dialect-" + parser.getDialect().toString());  
  294.         List<Object> _paras = addPageParameters(paras, pagingParameter, parser);  
  295.         return getList(pSql, _paras);  
  296.     }  
  297.   
  298.     @Override  
  299.     public List<Map<String, Object>> getRecordData(String sql,  
  300.             PagingParameter pagingParameter, Map<String, Object> paras)  
  301.             throws DaoAccessException {  
  302.         log.info("jcbksql-" + sql);  
  303.         Parser parser = getParser();  
  304.         String pSql = parser.getPageSqlForPlace(sql);  
  305.         log.info("jcbksql-page-" + pSql + " dialect-" + parser.getDialect().toString());  
  306.         Map<String, Object> _paras = addPageParameters(paras, pagingParameter, parser);  
  307.         return getList(pSql, _paras);  
  308.     }  
  309.   
  310.     @Override  
  311.     public <T> List<T> getRecordData(String sql, Class<T> classz,  
  312.             PagingParameter pagingParameter, Object... paras)  
  313.             throws DaoAccessException {  
  314.           
  315.         return getRecordData(sql, classz, pagingParameter, Arrays.asList(paras));  
  316.     }  
  317.   
  318.     @Override  
  319.     public <T> List<T> getRecordData(String sql, Class<T> classz,  
  320.             PagingParameter pagingParameter, List<Object> paras)  
  321.             throws DaoAccessException {  
  322.         log.info("jcbksql-" + sql);  
  323.         Parser parser = getParser();  
  324.         String pSql = parser.getPageSqlForPlace(sql);  
  325.         log.info("jcbksql-page-" + pSql + " dialect-" + parser.getDialect().toString());  
  326.         List<Object> _paras = addPageParameters(paras, pagingParameter, parser);  
  327.         return getList(pSql, classz, _paras);  
  328.     }  
  329.   
  330.     @Override  
  331.     public <T> List<T> getRecordData(String sql, Class<T> classz,  
  332.             PagingParameter pagingParameter, Map<String, Object> paras)  
  333.             throws DaoAccessException {  
  334.         log.info("jcbksql-" + sql);  
  335.         Parser parser = getParser();  
  336.         String pSql = parser.getPageSqlForPlace(sql);  
  337.         log.info("jcbksql-page-" + pSql + " dialect-" + parser.getDialect().toString());  
  338.         Map<String, Object> _paras = addPageParameters(paras, pagingParameter, parser);  
  339.         return getList(pSql, classz, _paras);  
  340.     }  
  341.   
  342.     @Override  
  343.     public Map<String, Object> getPageForMap(String sql, int curPage,  
  344.             int pageSize, Object... paras) throws DaoAccessException {  
  345.           
  346.         return getPageForMap(sql, curPage, pageSize, Arrays.asList(paras));  
  347.     }  
  348.   
  349.     @Override  
  350.     public Map<String, Object> getPageForMap(String sql, int curPage,  
  351.             int pageSize, List<Object> paras) throws DaoAccessException {  
  352.         int total = getRecordCounts(sql, 0, paras);  
  353.         PagingParameter pp = new PagingParameter(curPage, pageSize, total);  
  354.         List<Map<String, Object>> list = getRecordData(sql, pp, paras);  
  355.         return new DataStore(total,list).getEntity();  
  356.     }  
  357.   
  358.     @Override  
  359.     public Map<String, Object> getPageForMap(String sql, int curPage,  
  360.             int pageSize, Map<String, Object> paras) throws DaoAccessException {  
  361.         int total = getRecordCounts(sql, 0, paras);  
  362.         PagingParameter pp = new PagingParameter(curPage, pageSize, total);  
  363.         List<Map<String, Object>> list = getRecordData(sql, pp, paras);  
  364.         return new DataStore(total,list).getEntity();  
  365.     }  
  366.   
  367.     @Override  
  368.     public Map<String, Object> getPageForMap(String sql, int curPage,  
  369.             int pageSize, Class<?> clazz, Object... paras)  
  370.             throws DaoAccessException {  
  371.           
  372.         return getPageForMap(sql, curPage, pageSize, clazz, Arrays.asList(paras));  
  373.     }  
  374.   
  375.     @Override  
  376.     public Map<String, Object> getPageForMap(String sql, int curPage,  
  377.             int pageSize, Class<?> clazz, List<Object> paras)  
  378.             throws DaoAccessException {  
  379.         int total = getRecordCounts(sql, 0, paras);  
  380.         PagingParameter pp = new PagingParameter(curPage, pageSize, total);  
  381.         List<?> list = getRecordData(sql, clazz, pp, paras);  
  382.         return new DataStore(total,list).getEntity();  
  383.     }  
  384.   
  385.     @Override  
  386.     public Map<String, Object> getPageForMap(String sql, int curPage,  
  387.             int pageSize, Class<?> clazz, Map<String, Object> paras)  
  388.             throws DaoAccessException {  
  389.         int total = getRecordCounts(sql, 0, paras);  
  390.         PagingParameter pp = new PagingParameter(curPage, pageSize, total);  
  391.         List<?> list = getRecordData(sql, clazz, pp, paras);  
  392.         return new DataStore(total,list).getEntity();  
  393.     }  
  394.       
  395.     @Override  
  396.     public void update(String sql, Object... paras) throws DaoAccessException {  
  397.         // TODO Auto-generated method stub  
  398.         throw new DaoAccessException("暂不支持该操作!");  
  399.     }  
  400.       
  401.     @Override  
  402.     public void update(String sql, List<Object> paras)  
  403.             throws DaoAccessException {  
  404.         // TODO Auto-generated method stub  
  405.         throw new DaoAccessException("暂不支持该操作!");  
  406.     }  
  407.       
  408.     @Override  
  409.     public void update(String sql, Map<String, Object> paras)  
  410.             throws DaoAccessException {  
  411.         // TODO Auto-generated method stub  
  412.         throw new DaoAccessException("暂不支持该操作!");  
  413.     }  
  414.       
  415.     @Override  
  416.     public void insert(String sql, Object... paras) throws DaoAccessException {  
  417.         // TODO Auto-generated method stub  
  418.         throw new DaoAccessException("暂不支持该操作!");  
  419.     }  
  420.       
  421.     @Override  
  422.     public void insert(String sql, List<Object> paras)  
  423.             throws DaoAccessException {  
  424.         // TODO Auto-generated method stub  
  425.         throw new DaoAccessException("暂不支持该操作!");  
  426.     }  
  427.       
  428.     @Override  
  429.     public void insert(String sql, Map<String, Object> paras)  
  430.             throws DaoAccessException {  
  431.         // TODO Auto-generated method stub  
  432.         throw new DaoAccessException("暂不支持该操作!");  
  433.     }  
  434. }  

Java代码   收藏代码
  1.  /*为了实现动态修改数据源名称,增加了适配类*/  
  2. package com.sunshine.basic.dao;  
  3.   
  4. import org.springframework.beans.BeansException;  
  5. import org.springframework.jdbc.core.JdbcTemplate;  
  6.   
  7. import com.sunshine.basic.dao.AbstractJdbcCommDao;  
  8. import com.sunshine.basic.dao.parser.AbstractParser;  
  9. import com.sunshine.basic.dao.parser.Dialect;  
  10. import com.sunshine.basic.dao.parser.Parser;  
  11. import com.sunshine.basic.exception.DaoAccessException;  
  12. import com.sunshine.basic.tools.ApplicationContextTools;  
  13.   
  14. /** 
  15.  * 利用JdbcAdapterDaoProxy生成子类代理,然后修改数据源名称 
  16.  * @see com.sunshine.monitor.comm.dao.adapter.JdbcAdapterDaoProxy 
  17.  * @author OY 
  18.  * 
  19.  */  
  20. public abstract class AbstractJdbcAdapterDao extends AbstractJdbcCommDao {  
  21.       
  22.     /* 静态数据源 */  
  23.     private String jdbcTemplateName;  
  24.       
  25.     private Dialect dialect;  
  26.       
  27.     /** 
  28.      * 子类实现静态JdbcTemplate操作模板及方言 
  29.      * @param jdbcTemplateName 
  30.      * @param dialect 
  31.      */  
  32.     public AbstractJdbcAdapterDao(String jdbcTemplateName, Dialect dialect){  
  33.           
  34.         this.jdbcTemplateName = jdbcTemplateName;  
  35.           
  36.         this.dialect = dialect;  
  37.     }  
  38.     /*动态修改数据源名称*/  
  39.     public final void setJdbcTemplateName(String jdbcTemplateName){  
  40.           
  41.         this.jdbcTemplateName = jdbcTemplateName;  
  42.     }  
  43.       
  44.     @Override  
  45.     public final JdbcTemplate getSubJdbcTemplate() throws DaoAccessException {  
  46.         JdbcTemplate jdbcTemplate = null;  
  47.         try {  
  48.             jdbcTemplate = ApplicationContextTools.getBean(  
  49.                         this.jdbcTemplateName, JdbcTemplate.class);  
  50.             if(jdbcTemplate == null)  
  51.                 throw new DaoAccessException("JdbcTemplate实例访问失败!");  
  52.         } catch (BeansException e) {  
  53.             e.printStackTrace();  
  54.             throw new DaoAccessException("JdbcTemplate实例访问失败!");  
  55.         }  
  56.         return jdbcTemplate;  
  57.     }  
  58.       
  59.     @Override  
  60.     public Parser getParser() throws DaoAccessException {  
  61.           
  62.         return AbstractParser.newParser(this.dialect);  
  63.     }  
  64. }  

Java代码   收藏代码
  1.  /*Oracle实现类*/  
  2. package com.sunshine.basic.dao.jdbc;  
  3.   
  4. import org.springframework.stereotype.Repository;  
  5.   
  6. import com.sunshine.basic.dao.AbstractJdbcAdapterDao;  
  7. import com.sunshine.basic.dao.parser.Dialect;  
  8.   
  9. @Repository("oracleJdbcDao")  
  10. public class OracleJdbcDao extends AbstractJdbcAdapterDao {  
  11.   
  12.     public OracleJdbcDao(){  
  13.         super("jdbcTemplate", Dialect.of("oracle"));  
  14.     }  
  15. }  

Java代码   收藏代码
  1. /*GreenPum实现类*/  
  2. package com.sunshine.basic.dao.jdbc;  
  3.   
  4. import org.springframework.stereotype.Repository;  
  5.   
  6. import com.sunshine.basic.dao.AbstractJdbcAdapterDao;  
  7. import com.sunshine.basic.dao.parser.Dialect;  
  8.   
  9. /** 
  10.  * @author oy 
  11.  * 
  12.  */  
  13. @Repository("greenPlumJdbcDao")  
  14. public class GreenPlumJdbcDao extends AbstractJdbcAdapterDao {  
  15.   
  16.     public GreenPlumJdbcDao(){  
  17.         super("gpJdbcTemplate",Dialect.of("postgresql"));  
  18.     }  
  19.   
  20. }  

Java代码   收藏代码
  1.  package com.sunshine.basic.dao.proxy;  
  2.   
  3. import java.lang.reflect.Method;  
  4. import net.sf.cglib.proxy.Enhancer;  
  5. import net.sf.cglib.proxy.MethodInterceptor;  
  6. import net.sf.cglib.proxy.MethodProxy;  
  7. /** 
  8.  * 生成代理对象 
  9.  * @author oy 
  10.  * 
  11.  */  
  12. public class JdbcAdapterDaoProxy implements MethodInterceptor{  
  13.       
  14.     private Object target;    
  15.        
  16.     public JdbcAdapterDaoProxy(){  
  17.           
  18.     }  
  19.   
  20.     public Object createInstance(Object target){  
  21.         this.target = target;  
  22.         Enhancer enhancer = new Enhancer();    
  23.         enhancer.setSuperclass(this.target.getClass());    
  24.         // 回调方法    
  25.         enhancer.setCallback(this);    
  26.         // 创建代理对象    
  27.         return enhancer.create();         
  28.     }  
  29.       
  30.     @Override  
  31.     public Object intercept(Object obj, Method method, Object[] args,  
  32.             MethodProxy proxy) throws Throwable {  
  33.           
  34.         return proxy.invokeSuper(obj, args);  
  35.     }  
  36.       
  37. }  

引用

  数据库方言及SQL智能分页 

Java代码   收藏代码
  1.  package com.sunshine.basic.dao.parser;  
  2.   
  3. public interface Parser {  
  4.   
  5.     /** 
  6.      * 获取总数sql - 如果要支持其他数据库,修改这里就可以 
  7.      * 
  8.      * @param sql 原查询sql 
  9.      * @return 返回count查询sql 
  10.      */  
  11.     String getCountSql(String sql);  
  12.   
  13.     /** 
  14.      * 获取分页sql - 如果要支持其他数据库,修改这里就可以 
  15.      * 
  16.      * @param sql 原查询sql 
  17.      * @return 返回分页sql 
  18.      */  
  19.     String getPageSql(String sql);  
  20.       
  21.     /** 
  22.      *  
  23.      * @param sql 
  24.      * @return 
  25.      */  
  26.     String getPageSqlForPlace(String sql);  
  27.       
  28.     /** 
  29.      * 获取方言 
  30.      * @return 
  31.      */  
  32.     Dialect getDialect();  
  33.       
  34.     /** 
  35.      * 设置方言 
  36.      * @param dialect 
  37.      */  
  38.     void setDialect(Dialect dialect);  
  39.   
  40. }  

Java代码   收藏代码
  1. package com.sunshine.basic.dao.parser;  
  2.   
  3. import com.sunshine.basic.dao.parser.impl.MysqlParser;  
  4. import com.sunshine.basic.dao.parser.impl.OracleParser;  
  5. import com.sunshine.basic.dao.parser.impl.PostgreSQLParser;  
  6.   
  7. public abstract class AbstractParser implements Parser{  
  8.       
  9.     //处理SQL  
  10.     public static final SqlParser sqlParser = new SqlParser();  
  11.       
  12.     private Dialect dialect;  
  13.       
  14.     public static final String END_INDEX_NAME="endIndex";  
  15.       
  16.     public static final String START_INDEX_NAME = "startIndex";  
  17.       
  18.     public Dialect getDialect(){  
  19.           
  20.         return dialect;  
  21.     }  
  22.       
  23.     public void setDialect(Dialect dialect){  
  24.           
  25.         this.dialect = dialect;  
  26.     }  
  27.       
  28.     public static Parser newParser(Dialect dialect) {  
  29.         Parser parser = null;  
  30.         switch (dialect) {  
  31.             case postgresql:  
  32.                  parser = new PostgreSQLParser();  
  33.                  break;  
  34.             case mysql:  
  35.                 parser = new MysqlParser();  
  36.                 break;  
  37.             case oracle:  
  38.                 parser = new OracleParser();  
  39.                 break;  
  40.             default:  
  41.                 break;  
  42.         }  
  43.         if(parser != null)  
  44.             parser.setDialect(dialect);  
  45.         return parser;  
  46.     }  
  47.   
  48.     public String getCountSql(final String sql) {  
  49.           
  50.         return sqlParser.getSmartCountSql(sql);  
  51.     }  
  52.       
  53.     public abstract String getPageSql(String sql);  
  54.   
  55. }  

Java代码   收藏代码
  1. package com.sunshine.basic.dao.parser.impl;  
  2.   
  3. import com.sunshine.basic.dao.parser.AbstractParser;  
  4.   
  5. public class OracleParser extends AbstractParser {  
  6.       
  7.     @Override  
  8.     public String getPageSql(String sql) {  
  9.         StringBuilder sqlBuilder = new StringBuilder(sql.length() + 120);  
  10.         sqlBuilder.append("select * from ( select tmp_page.*, rownum row_id from ( ");  
  11.         sqlBuilder.append(sql);  
  12.         sqlBuilder.append(" ) tmp_page where rownum <= ? ) where row_id > ?");  
  13.         return sqlBuilder.toString();  
  14.     }  
  15.       
  16.     @Override  
  17.     public String getPageSqlForPlace(String sql) {  
  18.         StringBuilder sqlBuilder = new StringBuilder(sql.length() + 120);  
  19.         sqlBuilder.append("select * from ( select tmp_page.*, rownum row_id from ( ");  
  20.         sqlBuilder.append(sql);  
  21.         sqlBuilder.append(" ) tmp_page where rownum <= :");  
  22.         sqlBuilder.append(END_INDEX_NAME);  
  23.         sqlBuilder.append(") where row_id > :");  
  24.         sqlBuilder.append(START_INDEX_NAME);  
  25.         return sqlBuilder.toString();  
  26.     }  
  27. }  

Java代码   收藏代码
  1. /*方言*/  
  2. package com.sunshine.basic.dao.parser;  
  3.   
  4. public enum Dialect {  
  5.       
  6.     mysql, oracle, postgresql;  
  7.   
  8.     public static Dialect of(String dialect) {  
  9.         try {  
  10.             Dialect d = Dialect.valueOf(dialect);  
  11.             return d;  
  12.         } catch (IllegalArgumentException e) {  
  13.             String dialects = null;  
  14.             for (Dialect d : Dialect.values()) {  
  15.                 if (dialects == null) {  
  16.                     dialects = d.toString();  
  17.                 } else {  
  18.                     dialects += "," + d;  
  19.                 }  
  20.             }  
  21.             throw new IllegalArgumentException("分页dialect参数值错误,可选值为[" + dialects + "]");  
  22.         }  
  23.     }  
  24.   
  25.     public static String[] dialects() {  
  26.         Dialect[] dialects = Dialect.values();  
  27.         String[] ds = new String[dialects.length];  
  28.         for (int i = 0; i < dialects.length; i++) {  
  29.             ds[i] = dialects[i].toString();  
  30.         }  
  31.         return ds;  
  32.     }  
  33.       
  34.     public static String fromJdbcUrl(String jdbcUrl) {  
  35.         String[] dialects = dialects();  
  36.         for (String dialect : dialects) {  
  37.             if (jdbcUrl.indexOf(":" + dialect + ":") != -1) {  
  38.                 return dialect;  
  39.             }  
  40.         }  
  41.         return null;  
  42.     }  
  43. }  

Java代码   收藏代码
  1. /*SQL智分析,依赖jsqlparse.jar*/  
  2. package com.sunshine.basic.dao.parser;  
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6. import java.util.concurrent.ConcurrentHashMap;  
  7.   
  8. import net.sf.jsqlparser.expression.Alias;  
  9. import net.sf.jsqlparser.expression.Function;  
  10. import net.sf.jsqlparser.parser.CCJSqlParserUtil;  
  11. import net.sf.jsqlparser.schema.Column;  
  12. import net.sf.jsqlparser.statement.Statement;  
  13. import net.sf.jsqlparser.statement.select.FromItem;  
  14. import net.sf.jsqlparser.statement.select.Join;  
  15. import net.sf.jsqlparser.statement.select.LateralSubSelect;  
  16. import net.sf.jsqlparser.statement.select.OrderByElement;  
  17. import net.sf.jsqlparser.statement.select.PlainSelect;  
  18. import net.sf.jsqlparser.statement.select.Select;  
  19. import net.sf.jsqlparser.statement.select.SelectBody;  
  20. import net.sf.jsqlparser.statement.select.SelectExpressionItem;  
  21. import net.sf.jsqlparser.statement.select.SelectItem;  
  22. import net.sf.jsqlparser.statement.select.SetOperationList;  
  23. import net.sf.jsqlparser.statement.select.SubJoin;  
  24. import net.sf.jsqlparser.statement.select.SubSelect;  
  25. import net.sf.jsqlparser.statement.select.ValuesList;  
  26. import net.sf.jsqlparser.statement.select.WithItem;  
  27.   
  28. import org.apache.log4j.Logger;  
  29.   
  30. /** 
  31.  * sql解析类,提供更智能的count查询sql 
  32.  */  
  33. public class SqlParser {  
  34.       
  35.     private static final List<SelectItem> COUNT_ITEM;  
  36.       
  37.     private static final Alias TABLE_ALIAS;  
  38.       
  39.     private Logger log = Logger.getLogger(SqlParser.class);  
  40.   
  41.     static {  
  42.         COUNT_ITEM = new ArrayList<SelectItem>();  
  43.         COUNT_ITEM.add(new SelectExpressionItem(new Column("count(1)")));  
  44.   
  45.         TABLE_ALIAS = new Alias("table_count");  
  46.         TABLE_ALIAS.setUseAs(false);  
  47.     }  
  48.   
  49.     // 缓存已经修改过的sql  
  50.     private Map<String, String> CACHE = new ConcurrentHashMap<String, String>();  
  51.   
  52.     public void isSupportedSql(String sql) {  
  53.         if (sql.trim().toUpperCase().endsWith("FOR UPDATE")) {  
  54.             throw new RuntimeException("分页不支持包含for update的sql");  
  55.         }  
  56.     }  
  57.   
  58.     /** 
  59.      * 获取智能的countSql 
  60.      * 
  61.      * @param sql 
  62.      * @return 
  63.      */  
  64.     public String getSmartCountSql(String sql) {  
  65.         log.info("Sql parse before:" + sql);  
  66.         //校验是否支持该sql  
  67.         isSupportedSql(sql);  
  68.         if (CACHE.get(sql) != null) {  
  69.             log.info("Count sql parse(Cache):" + CACHE.get(sql));  
  70.             return CACHE.get(sql);  
  71.         }  
  72.         //解析SQL  
  73.         Statement stmt = null;  
  74.         try {  
  75.             stmt = CCJSqlParserUtil.parse(sql);  
  76.         } catch (Throwable e) {  
  77.             //无法解析的用一般方法返回count语句  
  78.             String countSql = getSimpleCountSql(sql);  
  79.             CACHE.put(sql, countSql);  
  80.             return countSql;  
  81.         }  
  82.         Select select = (Select) stmt;  
  83.         SelectBody selectBody = select.getSelectBody();  
  84.         //处理body-去order by  
  85.         processSelectBody(selectBody);  
  86.         //处理with-去order by  
  87.         processWithItemsList(select.getWithItemsList());  
  88.         //处理为count查询  
  89.         sqlToCount(select);  
  90.         String result = select.toString();  
  91.         CACHE.put(sql, result);  
  92.         log.info("Sql parse after:" + sql);  
  93.         return result;  
  94.     }  
  95.   
  96.     /** 
  97.      * 获取普通的Count-sql 
  98.      * @param sql 原查询sql 
  99.      * @return 返回count查询sql 
  100.      */  
  101.     public String getSimpleCountSql(final String sql) {  
  102.         isSupportedSql(sql);  
  103.         StringBuilder stringBuilder = new StringBuilder(sql.length() + 40);  
  104.         stringBuilder.append("select count(*) from (");  
  105.         stringBuilder.append(sql);  
  106.         stringBuilder.append(") tmp_count");  
  107.         return stringBuilder.toString();  
  108.     }  
  109.   
  110.     /** 
  111.      * 将sql转换为count查询 
  112.      * @param select 
  113.      */  
  114.     public void sqlToCount(Select select) {  
  115.         SelectBody selectBody = select.getSelectBody();  
  116.         // 是否能简化count查询  
  117.         if (selectBody instanceof PlainSelect && isSimpleCount((PlainSelect) selectBody)) {  
  118.             ((PlainSelect) selectBody).setSelectItems(COUNT_ITEM);  
  119.         } else {  
  120.             PlainSelect plainSelect = new PlainSelect();  
  121.             SubSelect subSelect = new SubSelect();  
  122.             subSelect.setSelectBody(selectBody);  
  123.             subSelect.setAlias(TABLE_ALIAS);  
  124.             plainSelect.setFromItem(subSelect);  
  125.             plainSelect.setSelectItems(COUNT_ITEM);  
  126.             select.setSelectBody(plainSelect);  
  127.         }  
  128.     }  
  129.   
  130.     /** 
  131.      * 是否可以用简单的count查询方式 
  132.      * @param select 
  133.      * @return 
  134.      */  
  135.     public boolean isSimpleCount(PlainSelect select) {  
  136.         //包含group by的时候不可以  
  137.         if (select.getGroupByColumnReferences() != null) {  
  138.             return false;  
  139.         }  
  140.         //包含distinct的时候不可以  
  141.         if (select.getDistinct() != null) {  
  142.             return false;  
  143.         }  
  144.         for (SelectItem item : select.getSelectItems()) {  
  145.             //select列中包含参数的时候不可以,否则会引起参数个数错误  
  146.             if (item.toString().contains("?")) {  
  147.                 return false;  
  148.             }  
  149.             //如果查询列中包含函数,也不可以,函数可能会聚合列  
  150.             if (item instanceof SelectExpressionItem) {  
  151.                 if (((SelectExpressionItem) item).getExpression() instanceof Function) {  
  152.                     return false;  
  153.                 }  
  154.             }  
  155.         }  
  156.         return true;  
  157.     }  
  158.   
  159.     /** 
  160.      * 处理selectBody去除Order by 
  161.      * 
  162.      * @param selectBody 
  163.      */  
  164.     public void processSelectBody(SelectBody selectBody) {  
  165.         if (selectBody instanceof PlainSelect) {  
  166.             processPlainSelect((PlainSelect) selectBody);  
  167.         } else if (selectBody instanceof WithItem) {  
  168.             WithItem withItem = (WithItem) selectBody;  
  169.             if (withItem.getSelectBody() != null) {  
  170.                 processSelectBody(withItem.getSelectBody());  
  171.             }  
  172.         } else {  
  173.             SetOperationList operationList = (SetOperationList) selectBody;  
  174.             if (operationList.getPlainSelects() != null && operationList.getPlainSelects().size() > 0) {  
  175.                 List<PlainSelect> plainSelects = operationList.getPlainSelects();  
  176.                 for (PlainSelect plainSelect : plainSelects) {  
  177.                     processPlainSelect(plainSelect);  
  178.                 }  
  179.             }  
  180.             if (!orderByHashParameters(operationList.getOrderByElements())) {  
  181.                 operationList.setOrderByElements(null);  
  182.             }  
  183.         }  
  184.     }  
  185.   
  186.     /** 
  187.      * 处理PlainSelect类型的selectBody 
  188.      * 
  189.      * @param plainSelect 
  190.      */  
  191.     public void processPlainSelect(PlainSelect plainSelect) {  
  192.         if (!orderByHashParameters(plainSelect.getOrderByElements())) {  
  193.             plainSelect.setOrderByElements(null);  
  194.         }  
  195.         if (plainSelect.getFromItem() != null) {  
  196.             processFromItem(plainSelect.getFromItem());  
  197.         }  
  198.         if (plainSelect.getJoins() != null && plainSelect.getJoins().size() > 0) {  
  199.             List<Join> joins = plainSelect.getJoins();  
  200.             for (Join join : joins) {  
  201.                 if (join.getRightItem() != null) {  
  202.                     processFromItem(join.getRightItem());  
  203.                 }  
  204.             }  
  205.         }  
  206.     }  
  207.   
  208.     /** 
  209.      * 处理WithItem 
  210.      * 
  211.      * @param withItemsList 
  212.      */  
  213.     public void processWithItemsList(List<WithItem> withItemsList) {  
  214.         if (withItemsList != null && withItemsList.size() > 0) {  
  215.             for (WithItem item : withItemsList) {  
  216.                 processSelectBody(item.getSelectBody());  
  217.             }  
  218.         }  
  219.     }  
  220.   
  221.     /** 
  222.      * 处理子查询 
  223.      * 
  224.      * @param fromItem 
  225.      */  
  226.     public void processFromItem(FromItem fromItem) {  
  227.         if (fromItem instanceof SubJoin) {  
  228.             SubJoin subJoin = (SubJoin) fromItem;  
  229.             if (subJoin.getJoin() != null) {  
  230.                 if (subJoin.getJoin().getRightItem() != null) {  
  231.                     processFromItem(subJoin.getJoin().getRightItem());  
  232.                 }  
  233.             }  
  234.             if (subJoin.getLeft() != null) {  
  235.                 processFromItem(subJoin.getLeft());  
  236.             }  
  237.         } else if (fromItem instanceof SubSelect) {  
  238.             SubSelect subSelect = (SubSelect) fromItem;  
  239.             if (subSelect.getSelectBody() != null) {  
  240.                 processSelectBody(subSelect.getSelectBody());  
  241.             }  
  242.         } else if (fromItem instanceof ValuesList) {  
  243.   
  244.         } else if (fromItem instanceof LateralSubSelect) {  
  245.             LateralSubSelect lateralSubSelect = (LateralSubSelect) fromItem;  
  246.             if (lateralSubSelect.getSubSelect() != null) {  
  247.                 SubSelect subSelect = lateralSubSelect.getSubSelect();  
  248.                 if (subSelect.getSelectBody() != null) {  
  249.                     processSelectBody(subSelect.getSelectBody());  
  250.                 }  
  251.             }  
  252.         }  
  253.         //Table时不用处理  
  254.     }  
  255.   
  256.     /** 
  257.      * 判断Orderby是否包含参数,有参数的不能去 
  258.      * 
  259.      * @param orderByElements 
  260.      * @return 
  261.      */  
  262.     public boolean orderByHashParameters(List<OrderByElement> orderByElements) {  
  263.         if (orderByElements == null) {  
  264.             return false;  
  265.         }  
  266.         for (OrderByElement orderByElement : orderByElements) {  
  267.             if (orderByElement.toString().contains("?")) {  
  268.                 return true;  
  269.             }  
  270.         }  
  271.         return false;  
  272.     }  
  273.       
  274.     public static void main(String[] args) {  
  275.         String countSql = new SqlParser()  
  276.         .getSmartCountSql("select count(t.hphm) as GCCS, t.hphm as HPHM, t.hpys as HPYS, t.hpzl as HPZL   from veh_passrec t  where t.hphm like '粤A_____' and t.gcsj > '2010-02-18 00:00:00' and t.gcsj <= '2010-02-21 23:59:59'  group by t.hphm, t.hpys, t.hpzl");  
  277.         System.out.println(countSql);  
  278.     }  
  279. }  

Java代码   收藏代码
  1. /*分页参数对象*/  
  2. package com.sunshine.basic.dao.page;  
  3.   
  4. import java.io.Serializable;  
  5. import java.util.HashMap;  
  6. import java.util.Map;  
  7.   
  8. import com.sunshine.basic.dao.parser.Dialect;  
  9.   
  10. /** 
  11.  * 封装分页参数 
  12.  */  
  13. public class PagingParameter implements Serializable{  
  14.       
  15.     private static final long serialVersionUID = -5871263750693828476L;  
  16.   
  17.     /** 分页起始行,默认为-1,表示不分页,查询全部记录 */  
  18.     private int curPage = -1;  
  19.     /** 每页显示行数,默认为0,表示不分页,查询全部记录 */  
  20.     private int pageSize = 0;  
  21.     /** 总记录*/  
  22.     private int totalRows = 0;  
  23.       
  24.     /** 
  25.      * 构造方法,不指定分页起始行和每页显示行数,默认不分页,查询全部记录 
  26.      */  
  27.     public PagingParameter(){  
  28.     }  
  29.       
  30.     /** 
  31.      * 构造方法 
  32.      * @param start 
  33.      * @param pageSize 
  34.      */  
  35.     public PagingParameter(int curPage,int pageSize, int totalRows){  
  36.         this.curPage = curPage;  
  37.         this.pageSize = pageSize;  
  38.         this.totalRows = totalRows;  
  39.     }  
  40.       
  41.     public int getTotalRows() {  
  42.         return totalRows;  
  43.     }  
  44.   
  45.     public int getCurPage() {  
  46.         return curPage;  
  47.     }  
  48.       
  49.     public void setCurPage(int curPage) {  
  50.         this.curPage = curPage;  
  51.     }  
  52.       
  53.     public int getPageSize() {  
  54.         return pageSize;  
  55.     }  
  56.       
  57.     public void setPageSize(int pageSize) {  
  58.         this.pageSize = pageSize;  
  59.     }  
  60.   
  61.     public void setTotalRows(int totalRows) {  
  62.         this.totalRows = totalRows;  
  63.     }  
  64.   
  65.     /** 
  66.      * 判断分页参数是否无效,如果返回true(表示分页参数无效)则不分页,查询全部的记录 
  67.      * 
  68.      * @return 
  69.      */  
  70.     public boolean isInvalid() {  
  71.         return curPage < 0 || pageSize <= 0;  
  72.     }  
  73.   
  74.     /** 
  75.      * 构造开始行与结束行 
  76.      * @return 
  77.      */  
  78.     public Map<String,Integer> getStartAndEndRow(){  
  79.         // 总页数  
  80.         int totalPages = totalPage();  
  81.         Map<String,Integer> map = null;  
  82.         // 起始行数  
  83.         int start = (curPage - 1) * pageSize;  
  84.         // 结束行数  
  85.         int end = 0;  
  86.         if (totalRows < pageSize) {  
  87.             end = totalRows;  
  88.         } else if ((totalRows % pageSize == 0)  
  89.                 || (totalRows % pageSize != 0 && curPage < totalPages)) {  
  90.             end = curPage * pageSize;  
  91.         } else if (totalRows % pageSize != 0 && curPage == totalPages) {// 最后一页  
  92.             end = totalRows;  
  93.         }  
  94.         map = new HashMap<String,Integer>();  
  95.         map.put("start", start);  
  96.         map.put("end", end);  
  97.         return map ;  
  98.     }  
  99.       
  100.     /** 
  101.      * 结束行 
  102.      * @return 
  103.      */  
  104.     public int getEndRow(Dialect dialect){  
  105.         int end = 0;  
  106.         switch (dialect) {  
  107.             case mysql:  
  108.                 end = pageSize;  
  109.                 break;  
  110.             case postgresql:  
  111.                 end = pageSize;  
  112.                 break;  
  113.             case oracle:  
  114.                 end = getOracleEndRow();  
  115.                 break;  
  116.             default:  
  117.                 break;  
  118.         }  
  119.         return end;  
  120.     }  
  121.       
  122.     public int getOracleEndRow(){  
  123.         int end = 0;  
  124.         int totalPages = totalPage();  
  125.         if (totalRows < pageSize) {  
  126.             end = totalRows;  
  127.         } else if ((totalRows % pageSize == 0)  
  128.                 || (totalRows % pageSize != 0 && curPage < totalPages)) {  
  129.             end = curPage * pageSize;  
  130.         } else if (totalRows % pageSize != 0 && curPage == totalPages) {// 最后一页  
  131.             end = totalRows;  
  132.         }  
  133.         return end;  
  134.     }  
  135.       
  136.       
  137.     /** 
  138.      * 开始行 
  139.      * @return 
  140.      */  
  141.     public int getStartRow(){  
  142.           
  143.         return (curPage - 1) * pageSize;  
  144.     }  
  145.       
  146.     /** 
  147.      * 总页数 
  148.      * @return 
  149.      */  
  150.     public int totalPage(){  
  151.         int totalPages = 0;  
  152.         if (pageSize != -1) {  
  153.             int pc = (int)Math.ceil(totalRows/pageSize);  
  154.             totalPages = (pc == 0) ? 1 : pc;  
  155.         } else {  
  156.             totalPages = 1;  
  157.         }  
  158.         return totalPages;  
  159.     }  
  160. }  

© 著作权归作者所有

共有 人打赏支持
疯子阳
粉丝 1
博文 25
码字总数 22731
作品 0
杭州
高级程序员
DAO层,Service层,Controller层、View层详解

本文转载自http://www.jianshu.com/p/403acf6df656 1、Dao层 Dao层主要是做数据持久层的工作,负责与数据库进行联络的一些任务都封装在此,Dao层的设计首先是设计Dao的接口,然后在Spring的配...

武小猪 ⋅ 2017/04/06 ⋅ 0

JAVA DAO(Data Access Object)的个人总结

最近上课,老师提到DAO,也是因为后面做作业的需要,就花了一点时间,来看一下DAO,也只是泛泛而谈,自己学习的一些总结,也希望给想学习的新手一些帮助吧。 1。什么是DAO 说来说去,DAO到底...

开源中国段子手 ⋅ 2015/07/22 ⋅ 0

Dao 集成开发环境--DaoStudio

DaoStudio 是道(Dao)语言的一个集成开发环境。Dao 语言是一个轻量级、支持类型标注和众多高级特性的程序语言。这次发布的 DaoStudio包括了Dao语言的最新版本2.0Beta2。最新版本的Dao语言对语...

叶秀兰 ⋅ 2014/08/25 ⋅ 0

python 与设计模式 ——工厂与单例

python 与设计模式 源码地址:[http://git.oschina.net/duoduo3_69/python_design_pattern][1] git checkout v001(这个版本与此篇博客相符) zarkpy里面运用了很多设计模式,以前一直很费解p...

duoduo3_69 ⋅ 2013/11/27 ⋅ 0

DaoStudio 0.5 Beta2 发布了!

DaoStudio是道(Dao)语言的一个集成开发环境。Dao语言是一个轻量级、支持类型标注和众多高级特性的程序语言。这次发布的DaoStudio包括了Dao语言的最新版本2.0Beta2。最新版本的Dao语言对语言的...

NeoHermit ⋅ 2014/08/25 ⋅ 9

python 与设计模式 ——工厂与装饰者

python 与设计模式第二篇 添加了test.py,里面的单元测试有使用的方法。 源码地址:[http://git.oschina.net/duoduo3_69/python_design_pattern][1] git checkout v002(这个版本与此篇博客相符...

duoduo3_69 ⋅ 2013/11/27 ⋅ 1

业务层架构模式

一:业务层架构模式概述 在三层架构中,业务层负责所有业务相关的工作,包括根据输入数据或已有数据进行计算,对从表示层输入的数据进行验证,以及根据从表示层接收的命令来确定应该调用哪些...

陈嘻嘻哈哈 ⋅ 2015/07/22 ⋅ 0

简单的MVC就够了吗?浅谈service Layer的引入

MVC是web开发中常见的程序结构。 简单的mvc结构如下: view层:显示层。 control层:业务层,集合了各种action。 model层:模型层,一般和数据打交道。简单的sample:一个表对应一个model类。...

蜗牛奔跑 ⋅ 2015/11/23 ⋅ 0

框架底层综合+快速开发+代码重用框架-设计(Service)层)

框架底层综合+快速开发+代码重用框架-设计(Model层) 框架底层综合+快速开发+代码重用框架-设计(Dao层) 框架底层综合+快速开发+代码重用框架-设计(Service层) 框架底层综合+快速开发+代...

bestupon ⋅ 2010/09/21 ⋅ 0

有关Hibernate中的多对多自关联查询的一个问题。

具体的需求如下。 User用户有多对多自关联(即用户与用户之间的好友关系,多对多关系通过friend中间表联系) Sport是用户的一个运动记录项目,User到Sport之间是一对多关系。 现在有一个需要...

as123123 ⋅ 2013/05/10 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

开启远程SSH

SSH默认没有开启账号密码登陆,需要再配置表中修改: vim /etc/ssh/sshd_configPermitRootLogin yes #是否可以使用root账户登陆PasswordAuthentication yes #是都开启密码登陆ser...

Kefy ⋅ 12分钟前 ⋅ 0

Zookeeper3.4.11+Hadoop2.7.6+Hbase2.0.0搭建分布式集群

有段时间没更新博客了,趁着最近有点时间,来完成之前关于集群部署方面的知识。今天主要讲一讲Zookeeper+Hadoop+Hbase分布式集群的搭建,在我前几篇的集群搭建的博客中已经分别讲过了Zookeep...

海岸线的曙光 ⋅ 19分钟前 ⋅ 0

js保留两位小数方法总结

本文是小编针对js保留两位小数这个大家经常遇到的经典问题整理了在各种情况下的函数写法以及遇到问题的分析,以下是全部内容: 一、我们首先从经典的“四舍五入”算法讲起 1、四舍五入的情况...

孟飞阳 ⋅ 38分钟前 ⋅ 0

python log

python log 处理方式 log_demo.py: 日志代码。 #! /usr/bin/env python# -*- coding: utf-8 -*-# __author__ = "Q1mi""""logging配置"""import osimport logging.config# 定义三种......

inidcard ⋅ 52分钟前 ⋅ 0

mysql 中的信息数据库以及 shell 查询 sql

Information_schema 是 MySQL 自带的信息数据库,里面的“表”保存着服务器当前的实时信息。它提供了访问数据库元数据的方式。 什么是元数据呢?元数据是关于数据的数据,如数据库名或表名,...

blackfoxya ⋅ 54分钟前 ⋅ 0

maven配置阿里云镜像享受飞的感觉

1.在maven目录下的conf/setting.xml中找到mirrors添加如下内容,对所有使用改maven打包的项目生效。 <mirror> <id>alimaven</id> <name>aliyun maven</name> <url>http://maven.al......

kalnkaya ⋅ 54分钟前 ⋅ 0

centos7下创建新用户并授权

1、创建新用户 创建一个用户名为:test adduser test 创建初始密码: passwd test 2、授予root权限 个人用户的权限只可以在/home/test下有完整权限,其他目录要看别人授权。而经常需要roo...

xixingzhe ⋅ 58分钟前 ⋅ 0

求助:TiledMap如何旋转对象呢?

比如我要旋转一个梯子的角度,单纯在TiledMap旋转角度好像没有效果。那是要用代码来控制角度,还是说只能通过导入相对应的斜的图片才可以呢?

花谢自相惜 ⋅ 今天 ⋅ 0

Micronaut 之HelloWorld!

小试一下Micronaut,按照官方文档跑了一下helloworld 第一步克隆,按照官方文档是: git clone git@github.com:micronaut-projects/micronaut-core.git 结果怎么是这样?? 换个方法吧 git ...

桂哥 ⋅ 今天 ⋅ 0

pom文件

Aeroever ⋅ 今天 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部