多条件分页查询，省掉麻烦的空值判断

    在之前做的一个基于java的web项目中，有很多多条件查询，每个条件都需要判断下是不是空，然后再拼起来，做组合查询，觉得很烦，就想能不能自己封装一套高层的api，自动忽略空值的条件，自动实现统计总数，自动翻页，等功能；后来又加上了条件优先级，如果某个字段不是空，则其他某个字段不参与查询（就是条件优先级，比如如果条件2不是空，则条件1不生效），这样我就自己写了一个符合这个要求的实现。我觉得这个东西有价值，跟大家分享一下。

    访问数据库我用的hibernate，我的这套api跟hibernate的critical查询比较像，不过我是基于hql拼条件的思路做的，下面看例子：

原来多条件查询的例子：

 1     @Override
 2     @Transactional(readOnly = true, rollbackFor = Exception.class )
 3     public Page<Dictionary> findByPage(int pageNo, String table, String name,Dictionary pareDict) {
 4         Page<Dictionary> page = new Page<Dictionary>();
 5         page.setAutoCount(true);
 6         page.setPageNo(pageNo);
 7         page.setPageSize(5);
 8         
 9         if(name==null || name.equals("")){//判断输入条件的空值
10             if(pareDict!=null){
11                 Query query = getQueryForFind(pareDict.getId(), table);
12                 int count = query.list().size();
13                 List<Dictionary> list = query.setMaxResults(5).setFirstResult((pageNo - 1) * 5).list();
14                 page.setRows(list);
15                 page.setTotal(count);
16                 return page;
17             }else{
18                 return dictionaryDao.findByCriteria(page,Restrictions.eq("tableName", table));
19             }
20             
21         }else{
22             if(pareDict!=null){//判断输入条件空值
23return dictionaryDao.findByCriteria(page,Restrictions.eq("tableName", table),
24                         Restrictions.like("name", "%"+name+"%"),Restrictions.eq("parentTable", pareDict));

25             }else{
26                 return dictionaryDao.findByCriteria(page,Restrictions.eq("tableName", table),
27                         Restrictions.like("name", "%"+name+"%"));
28             }
29         }
30 
31     }

这个例子逻辑看不懂没有关系，只要能看出来原来是怎么根据多个条件进行判断的就好了，相信很多做过java的人都会有这方面的经验。

    以下是使用我写的api查询的例子：

    private List<Well> find(Integer jobid, String state, List<String> wellNames) throws Exception {
        
        Page<WellJob> page = new Page<WellJob>();//初始化一个分页查询结果对象，用于接收查询结果
        page.setPageSize(rows.size());//设置一页大小
        PageQuery<WellJob> query = new PageQuery<WellJob>(page);//用page对象构造查询对象
        query.setCount(false);//设定是否自动获取总数，如果获取的话，只会统计一次
        query.addTable(WellJob.class, null);//addtable可以多次调用，用于联合查询，第二个参数是表别名，null的话表示用默认值
        query.addConditon("jobType.id", OP.eq, jobid).and("state", OP.eq, state).and("well.wellNum", OP.in, wellNames);
        //addCondition 这个方法表示设置条件的开始，只能调用一次，如果第三个参数是null，则忽略这次方法调用
        //add  与条件，如果第三个参数是null，忽略这次方法调用
        //query 对象上基本每个api的返回值都是自身，api可以连续调用，编码更流畅

        this.pageQueryService.getNextPage(query);//获取下一页，如果page参数从页面上传回来，这个方法就是翻页了
        //this.pageQueryService 对象是全局对象，基本上就是个壳，不用关心，主要功能都是在query对象里边实现的

        //以下代码都是分析结果的，于查询api关系不大
        Set<Long> wellNumSet = new HashSet<Long>();
        for (WellJob wj : page.getRows()) {
            wellNumSet.add(wj.getWell().getId());
        }
        List<Well> result = new ArrayList<Well>(rows.size() - wellNumSet.size());
        for (Well w : rows) {
            if (!wellNumSet.contains(w.getId())) {
                result.add(w);
            }
        }
        
        return result;
    }

    查询对象的主要api：

package com.secneo.common;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import org.apache.commons.lang.xwork.StringUtils;
import org.hibernate.Query;
import org.hibernate.classic.Session;
import org.secneo.framework.orm.hibernate.Page;

/**
 * 分页查询 工具, 原理类似hibernate 的critical工具，但用法上不同， 可以与pageQueryService 配合，在 action中直接使用，
 * 本质上该工具是对hql的封装， 封装后
 * 目的是提供简易的分页查询接口，可以设定为自动计算总条目数。
 * 可以设定条件的替换规则，如 第二个条件不为空时 ，第一个条件则不生效，
 * 
 * @author ZDCIN
 *
 */
public class PageQuery<T> {
    
    private Page<T> page;
//    private List<String> tables = new ArrayList<String>();
    private String where = "";
    private Map<Integer, CondTuple> conditionMap = new HashMap<Integer, CondTuple>();
    private String orderBy = "";
    
    private int conditionIndex = 0;
    private boolean isCount = true;
    
    /**
     * 查看是否计算总数， 默认true， 计算总数的条件是 isCount = true
     * @return
     */
    public boolean isCount() {
        return isCount;
    }
    /**
     * 设置是否计算总数， 默认true
     * @return
     */
    public void setCount(boolean isCount) {
        this.isCount = isCount;
    }
    /**
     * 设定page对象，和返回类型T
     * @param page
     */
    public PageQuery(Page<T> page) {
        this.page = page;
    }

    private String selectSql = "";

    /**
     * 当获取字段不是一个标准bean或者不是一个bean的全部字段的时候使用， 默认不用调用该方法
     * @param selectSql
     * @return
     */
    public PageQuery<T> setSelectSql(String selectSql) {
        this.selectSql = selectSql;
        return this;
    }
    private String countSql;
    
    /**
     * 当count语句不能从select简易变化过来的时候使用。 比如有distinct限制的时候
     * @param countSql
     * @return
     */
    public PageQuery<T> setCountSql(String countSql) {
        this.countSql = countSql;
        return this;
    }

    private String fromSql;
    
    /**
     * 添加要查询的表，并设定别名， 该方法可以多次调用，作为多表联合查询。
     * @param tableClass
     * @param alias  可以为空，表示没有别名
     * @return
     */
    @SuppressWarnings("rawtypes")
    public PageQuery<T> addTable(Class tableClass, String alias) {
       。。。。。
    }

    /**
     * 添加条件， 该方法只能调用一次，且必须在and 或者or之前调用
     * @param filedName 字段名， 别名和字段的组合形式，
     * @param op 字段上的条件操作， 如等于， 大于， in like等，
     * @param value  如果value为空，则该条件不生效，  但当op是 innotnull或者isnull的时候例外，该条件会生效
     * @return
     */
    public PageQuery<T> addConditon(String filedName, OP op, Object value) {
       。。。。
    }


    /**
     *  addConditon(String filedName, OP op, Object value) 的简写形式， op 是eq
     * @param filedName
     * @param value
     * @return
     */
    public PageQuery<T> addConditon(String filedName, Object value) {
        return this.addConditon(filedName, OP.eq, value);
    }

    private static enum LogicOp {
        and, or;
    }

    private PageQuery<T> and_AND_or(LogicOp logicOP, String filedName, OP op, Object value,
            String replaceWhich) {
        。。。。
    }

    /**
     * 添加and条件， where中的条件都是平级的，如果有括号，则用逻辑运算规则拉平
     * 
     * @param filedName  与addConditon中意义相同
     * @param op  与addConditon中意义相同
     * @param value  与addConditon中意义相同
     * @param replaceWhich  替换列表， 如果该方法中value不为空，则替换列表中的字段，如“1,2” 
     * 
     * @return
     */
    public PageQuery<T> and(String filedName, OP op, Object value, String replaceWhich) {
        return this.and_AND_or(LogicOp.and,  filedName, op, value, replaceWhich);
    }

    /**
     * and(String filedName, OP op, Object value, String replaceWhich) 的简写形式
     * @param filedName
     * @param op
     * @param value
     * @return
     */
    public PageQuery<T> and(String filedName, OP op, Object value) {
        return this.and_AND_or(LogicOp.and,  filedName, op, value, null);
    }

    /**
     * and(String filedName, OP op, Object value, String replaceWhich) 的简写形式
     * @param filedName
     * @param value
     * @return
     */
    public PageQuery<T> and(String filedName, Object value) {
        return this.and_AND_or(LogicOp.and,  filedName, OP.eq, value, null);
    }

    /**
     * 添加or条件， where中的条件都是平级的，如果有括号，则用逻辑运算规则拉平
     * 
     * @param filedName  与addConditon中意义相同
     * @param op  与addConditon中意义相同
     * @param value  与addConditon中意义相同
     * @param replaceWhich  替换列表， 如果该方法中value不为空，则替换列表中的字段，如“1,2” 
     * 
     * @return
     */
    public PageQuery<T> or(String filedName, OP op, Object value, String replaceWhich) {
        return this.and_AND_or(LogicOp.or,  filedName, op, value, replaceWhich);
    }


    /**
     * 同  or(String filedName, OP op, Object value, String replaceWhich)
     * @param filedName
     * @param op
     * @param value
     * @return
     */
    public PageQuery<T> or(String filedName, OP op, Object value) {
        return this.and_AND_or(LogicOp.or, filedName, op, value, null);
    }

    /**
     * 同  or(String filedName, OP op, Object value, String replaceWhich)
     * @param filedName
     * @param value
     * @return
     */
    public PageQuery<T> or(String filedName, Object value) {
        return this.and_AND_or(LogicOp.or, filedName, OP.eq, value, null);
    }
    
    /**
     * 添加排序， 可调用多次
     * @param filedName  与addConditon中意义相同
     * @param orderType OrderType.ASC, OrderType.DESC
     * @return
     */
    public PageQuery<T> addOrderBy(String filedName, OrderType orderType) {
        。。。。
    }
    
    
    /**
     * 执行查询， 在pageQueryService中调用， service可以提供hibernate session对象
     * @param currentSession
     * @return
     */
    public Page<T> excuteQuery(Session currentSession) {
        。。。。
    }
}

   page对象api：

public class Page<T> {public Page() {
    }
    public Page(Integer pageSize, boolean autoCount) {
    }
    /**
     * 每页的记录数量，默认值 15.
     */
    public Integer getPageSize() {
    }
    public boolean isPageSizeSetted() {
    }
    public void setPageSize(Integer pageSize) {
    }
    /**
     * 当前页的页号,序号从1开始.
     */
    public Integer getPageNo() {
    }
    public void setPageNo(Integer pageNo) {
    }
    /**
     * 第一条记录在结果集中的位置,序号从0开始.
     */
    public Integer getFirst() {
    }
    public boolean isFirstSetted() {
    }
    public boolean isOrderBySetted() {
    }
    /**
     * 是否自动获取总页数,默认为false,query by HQL时本属性无效.
     */
    public boolean isAutoCount() {
    }
    public void setAutoCount(boolean autoCount) {
    }
    /**
     * 页内的数据列表.
     */
    public List<T> getRows() {
    }
    public void setRows(List<T> result) {
    }
    /**
     * 总记录数.
     */
    public Integer getTotal() {
    }
    public void setTotal(Integer totalCount) {
    }
    /**
     * 计算总页数.
     */
    public Integer getTotalPages() {
    }
    /**
     * 是否还有下一页.
     */
    public boolean isHasNext() {
    }

    /**
     * 返回下页的页号,序号从1开始.
     */
    public Integer getNextPage() {
    }
    /**
     * 是否还有上一页.
     */
    public boolean isHasPre() {
    }
    /**
     * 返回上页的页号,序号从1开始.
     */
    public Integer getPrePage() {
    }
    /**
     * 得到分页条件仅支持like查询
     */
    public Map<String, Object> getCondition() {
    }
    public void setCondition(Map<String, Object> condition) {
    }
    /**
     * 多排序条件
     * 
     * @return
     */
    public String[][] getOrderByArr() {
    }
    public void setOrderByArr(String[][] orderByArr) {
    }
    public String getMemo() {
    }
    public void setMemo(String memo) {
    }
}

page对象功能比较直观，但因为大部分代码都不是我写的，page的源码我就不提供了。

    这个api就是为了解决多个条件任意组合的联合查询的问题，省去if判断空值，省去写额外的统计总数代码，还提供条件优先级的功能。

    我的这个代码不会那么容易跑起来，我觉得比代码更重要的是，提供一种简化问题、解决问题的思路。如果读者您对这个问题跟我一样感兴趣，欢迎讨论。

  以下是query对象和queryService对象的的全部源码：

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import org.apache.commons.lang.xwork.StringUtils;
import org.hibernate.Query;
import org.hibernate.classic.Session;
import org.secneo.framework.orm.hibernate.Page;

/**
 * 分页查询 工具, 原理类似hibernate 的critical工具，但用法上不同， 可以与pageQueryService 配合，在 action中直接使用，
 * 本质上该工具是对hql的封装， 封装后
 * 目的是提供简易的分页查询接口，可以设定为自动计算总条目数。
 * 可以设定条件的替换规则，如 第二个条件不为空时 ，第一个条件则不生效，
 * 
 * @author ZDCIN
 *
 */
public class PageQuery<T> {
    
    private Page<T> page;
//    private List<String> tables = new ArrayList<String>();
    private String where = "";
    private Map<Integer, CondTuple> conditionMap = new HashMap<Integer, CondTuple>();
    private String orderBy = "";
    
    private int conditionIndex = 0;
    private boolean isCount = true;
    
    /**
     * 查看是否计算总数， 默认true， 计算总数的条件是 isCount = true
     * @return
     */
    public boolean isCount() {
        return isCount;
    }
    /**
     * 设置是否计算总数， 默认true
     * @return
     */
    public void setCount(boolean isCount) {
        this.isCount = isCount;
    }
    /**
     * 设定page对象，和返回类型T
     * @param page
     */
    public PageQuery(Page<T> page) {
        this.page = page;
    }

    private String selectSql = "";

    /**
     * 当获取字段不是一个标准bean或者不是一个bean的全部字段的时候使用， 默认不用调用该方法
     * @param selectSql
     * @return
     */
    public PageQuery<T> setSelectSql(String selectSql) {
        this.selectSql = selectSql;
        return this;
    }
    private String countSql;
    
    /**
     * 当count语句不能从select简易变化过来的时候使用。 比如有distinct限制的时候
     * @param countSql
     * @return
     */
    public PageQuery<T> setCountSql(String countSql) {
        this.countSql = countSql;
        return this;
    }

    private String fromSql;
    
    /**
     * 添加要查询的表，并设定别名， 该方法可以多次调用，作为多表联合查询。
     * @param tableClass
     * @param alias  可以为空，表示没有别名
     * @return
     */
    @SuppressWarnings("rawtypes")
    public PageQuery<T> addTable(Class tableClass, String alias) {
        if (StringUtils.isBlank(this.fromSql)) {
            this.fromSql = " FROM ";
        } else {
            this.fromSql += ", ";
        }
        if (StringUtils.isNotBlank(alias)) {
            this.fromSql += tableClass.getSimpleName() + " AS " + alias;
        } else {
            this.fromSql += tableClass.getSimpleName() + " ";
        }
        return this;
    }

    /**
     * 添加条件， 该方法只能调用一次，且必须在and 或者or之前调用
     * @param filedName 字段名， 别名和字段的组合形式，
     * @param op 字段上的条件操作， 如等于， 大于， in like等，
     * @param value  如果value为空，则该条件不生效，  但当op是 innotnull或者isnull的时候例外，该条件会生效
     * @return
     */
    public PageQuery<T> addConditon(String filedName, OP op, Object value) {
        CondTuple tuple = new CondTuple(null, filedName, op, value, null);
        this.conditionMap.put(this.conditionIndex ++, tuple);
        return this;
//        if (value == null) {
//            return this;
//        }
//        //String filedFullName = this.filedName(tableIndex, filedName);
//        this.condition = " WHERE " + filedName + op.v() + ":" + filedName;
//        this.conditionMap.put(filedName, value);
//        return this;
    }


    /**
     *  addConditon(String filedName, OP op, Object value) 的简写形式， op 是eq
     * @param filedName
     * @param value
     * @return
     */
    public PageQuery<T> addConditon(String filedName, Object value) {
        return this.addConditon(filedName, OP.eq, value);
    }

    private static enum LogicOp {
        and, or;
    }

    private PageQuery<T> and_AND_or(LogicOp logicOP, String filedName, OP op, Object value,
            String replaceWhich) {
        CondTuple tuple = new CondTuple(logicOP, filedName, op, value, replaceWhich);
        this.conditionMap.put(this.conditionIndex ++, tuple);
        return this;
//        if (value == null) {
//            return this;
//        }
//        if (StringUtils.isBlank(this.condition)) {
//            this.condition = " WHERE ";
//        } else {
//            this.condition += " " + logicOP.name() + " ";
//        }
//        //String filedFullName = this.filedName(tableIndex, filedName);
//        this.condition += filedName + op.v() + ":" + filedName;
//        this.conditionMap.put(filedName, value);
//        return this;
    }

    /**
     * 添加and条件， where中的条件都是平级的，如果有括号，则用逻辑运算规则拉平
     * 
     * @param filedName  与addConditon中意义相同
     * @param op  与addConditon中意义相同
     * @param value  与addConditon中意义相同
     * @param replaceWhich  替换列表， 如果该方法中value不为空，则替换列表中的字段，如“1,2” 
     * 
     * @return
     */
    public PageQuery<T> and(String filedName, OP op, Object value, String replaceWhich) {
        return this.and_AND_or(LogicOp.and,  filedName, op, value, replaceWhich);
    }

    /**
     * and(String filedName, OP op, Object value, String replaceWhich) 的简写形式
     * @param filedName
     * @param op
     * @param value
     * @return
     */
    public PageQuery<T> and(String filedName, OP op, Object value) {
        return this.and_AND_or(LogicOp.and,  filedName, op, value, null);
    }

    /**
     * and(String filedName, OP op, Object value, String replaceWhich) 的简写形式
     * @param filedName
     * @param value
     * @return
     */
    public PageQuery<T> and(String filedName, Object value) {
        return this.and_AND_or(LogicOp.and,  filedName, OP.eq, value, null);
    }

    /**
     * 添加or条件， where中的条件都是平级的，如果有括号，则用逻辑运算规则拉平
     * 
     * @param filedName  与addConditon中意义相同
     * @param op  与addConditon中意义相同
     * @param value  与addConditon中意义相同
     * @param replaceWhich  替换列表， 如果该方法中value不为空，则替换列表中的字段，如“1,2” 
     * 
     * @return
     */
    public PageQuery<T> or(String filedName, OP op, Object value, String replaceWhich) {
        return this.and_AND_or(LogicOp.or,  filedName, op, value, replaceWhich);
    }


    /**
     * 同  or(String filedName, OP op, Object value, String replaceWhich)
     * @param filedName
     * @param op
     * @param value
     * @return
     */
    public PageQuery<T> or(String filedName, OP op, Object value) {
        return this.and_AND_or(LogicOp.or, filedName, op, value, null);
    }

    /**
     * 同  or(String filedName, OP op, Object value, String replaceWhich)
     * @param filedName
     * @param value
     * @return
     */
    public PageQuery<T> or(String filedName, Object value) {
        return this.and_AND_or(LogicOp.or, filedName, OP.eq, value, null);
    }
    
    /**
     * 添加排序， 可调用多次
     * @param filedName  与addConditon中意义相同
     * @param orderType OrderType.ASC, OrderType.DESC
     * @return
     */
    public PageQuery<T> addOrderBy(String filedName, OrderType orderType) {
        if (StringUtils.isBlank(filedName)) {
            return this;
        }
        if (StringUtils.isBlank(this.orderBy)) {
            this.orderBy = " ORDER BY ";
        } else {
            this.orderBy += ",";
        }
        this.orderBy += filedName + " " + orderType.name();
        return this;
    }
    
    
    /**
     * 执行查询， 在pageQueryService中调用， service可以提供hibernate session对象
     * @param currentSession
     * @return
     */
    public Page<T> excuteQuery(Session currentSession) {
        List<Integer> replaceList = this.getReplaceList();
        this.buildWhereStatementInSql(replaceList);
       
        if (page.getTotal() == -1) {
            String countHql = "SELECT " + (StringUtils.isBlank(this.countSql) ? " COUNT(*) " : this.countSql)
                    + this.fromSql + this.where;

            Query hquery = currentSession.createQuery(countHql);
            this.buildHibernateQuery(replaceList, hquery);
            Long totalCol = (Long) hquery.uniqueResult();

            page.setTotal(totalCol.intValue());
            // page.setPageNo(1);//肯定是从第一页开始
        }
        String hql = this.selectSql + this.fromSql + this.where + this.orderBy;
        System.out.println("query sql is:" + hql);
        Query hquery = currentSession.createQuery(hql);
        this.buildHibernateQuery(replaceList, hquery);
        @SuppressWarnings("unchecked")
        List<T> resultSet= hquery.setFirstResult(this.page.getFirst()).setMaxResults(this.page.getPageSize()).list();
        this.page.setRows(resultSet);
        return this.page;
    }
    
    private void buildHibernateQuery(List<Integer> replaceList, Query hquery) {
        for (int i = 0; i < this.conditionIndex; i++) {
            CondTuple tuple = this.conditionMap.get(i);
            if (replaceList.contains(i)) {
                continue;
            }
            if (tuple.value != null && !tuple.op.equals(OP.in)) {
                this.putObjectToHql(hquery, tuple.valueNameInHql + i, tuple.value);
            }
        }
    }

    private void putObjectToHql(Query hquery, String valueNameInHql, Object value) {
//        valueNameInHql = valueNameInHql.replace('.', '_');
      //valueName 是hql中的冒号后边的单词，用于hql执行时用变量替换，里边不能含有下列字符
//        String valueNameInHql =  valueNameInHql;
        valueNameInHql = valueNameInHql.replace('.', '_');
        valueNameInHql = valueNameInHql.replaceAll(" ", "");
        valueNameInHql = valueNameInHql.replaceAll("-", "");
        valueNameInHql = valueNameInHql.replaceAll("\(", "");
        valueNameInHql = valueNameInHql.replaceAll("\)", "");
        if (value instanceof Long) {
            hquery.setLong(valueNameInHql, (Long) value);
        } else if (value instanceof String) {
            hquery.setString(valueNameInHql, (String) value);
        } else if (value instanceof Date) {
            hquery.setTimestamp(valueNameInHql, (Date) value);
        } else if (value instanceof BigDecimal) {
            hquery.setBigDecimal(valueNameInHql, (BigDecimal) value);
        } else if (value instanceof Integer) {
            hquery.setInteger(valueNameInHql, (Integer) value);
        } else if (value instanceof Double) {
            hquery.setDouble(valueNameInHql, (Double) value);
        } else if (value instanceof Float) {
            hquery.setFloat(valueNameInHql, (Float) value);
        } else if (value instanceof Boolean) {
            hquery.setBoolean(valueNameInHql, (Boolean) value);
        } else if (value instanceof byte[]) {
            hquery.setBinary(valueNameInHql, (byte[]) value);
        } else if (value instanceof Locale) {
            hquery.setLocale(valueNameInHql, (Locale) value);
        } else if (value instanceof BigInteger) {
            hquery.setBigInteger(valueNameInHql, (BigInteger) value);
        } else {
            throw new RuntimeException("不支持的value类型:" + value.getClass());
        }
        // 下面这些不常用，且麻烦，不支持
        // setText(String, String)
        // setSerializable(String, Serializable)
        // setDate(String, Date)
        // setTime(String, Date)
        // setCalendar(String, Calendar)
        // setCalendarDate(String, Calendar)
        // setCharacter(String, char)
        // setByte(String, byte)
        // setShort(String, short)
    }

    private void buildWhereStatementInSql(List<Integer> replaceList) {
        for (int i = 0; i < this.conditionIndex; i++) {
            CondTuple tuple = this.conditionMap.get(i);
            if (replaceList.contains(i)) {
                continue;
            }
            if (tuple.value != null) {
                //in 查询特殊处理
                if (tuple.op.equals(OP.in)) {
                    List value = (List)tuple.value;
                    String temp = "";
                    if (value == null || value.size() == 0) {
                        break;
                    }
                    if (value.get(0) instanceof String) {
                        temp = "('";
                        for (String subv : (List<String>)value) {
                            temp += subv + "','";
                        }
                        temp += "')";
                        temp = temp.replace(",')", "')");
                    } else if (value.get(0) instanceof Long){
                        temp = "(";
                        for (Long subv : (List<Long>)value) {
                            temp += subv.longValue() + ",";
                        }
                        temp += ")";
                        temp = temp.replace(",)", ")");
                    }else {
                        temp = "(";
                        for (Integer subv : (List<Integer>)value) {
                            temp += subv.intValue() + ",";
                        }
                        temp += ")";
                        temp = temp.replace(",)", ")");
                    }
                    this.where += (tuple.logicOp == null ? "" : tuple.logicOp.name()) + " " +  tuple.valueNameInHql + tuple.op.v()
                            + temp + " ";
                } else {
                    //valueName 是hql中的冒号后边的单词，用于hql执行时用变量替换，里边不能含有下列字符
                    String valueName =  tuple.valueNameInHql + i;
                    valueName = valueName.replace('.', '_');
                    valueName = valueName.replaceAll(" ", "");
                    valueName = valueName.replaceAll("-", "");
                    valueName = valueName.replaceAll("\(", "");
                    valueName = valueName.replaceAll("\)", "");
                    this.where += (tuple.logicOp == null ? "" : tuple.logicOp.name()) + " " + tuple.valueNameInHql
                            + tuple.op.v() + ":" + valueName + " ";
                }
            } else {
                if (tuple.op.equals(OP.isNull) || tuple.op.equals(OP.isNotNull)) {
                    this.where += (tuple.logicOp == null ? "" : tuple.logicOp.name()) + " " + tuple.valueNameInHql
                            + tuple.op.v()  + " ";
                }
            }
        }
        if (StringUtils.isNotBlank(this.where)) {
            this.where = " WHERE " + this.where;
            if (this.where.contains("WHERE and")) {
                this.where.replace("WHERE and", "WHERE ");
            } else if (this.where.contains("WHERE or")) {
                this.where.replace("WHERE or", "WHERE ");
            }
        }
    }
    private List<Integer> getReplaceList() {
        List<Integer> result = new ArrayList<Integer>();
        String replaceString = "";
        for (int i = 0; i < this.conditionIndex; i++) {
            CondTuple tuple = this.conditionMap.get(i);
            if (tuple.value != null && StringUtils.isNotBlank(tuple.replaceString)) {
                replaceString += tuple.replaceString;
            }
        }
        String[] temp = replaceString.split(",");
        if (temp == null || temp.length == 0) {
            return result;
        }
        for (String t : temp) {
            if (StringUtils.isBlank(t)) {
                continue;
            }
            if (!result.contains(t)) {
                result.add(Integer.parseInt(t));
            }
        }
        return result;
    }
    
    

    /**条件组合对象*/
    private static class CondTuple {
        CondTuple(LogicOp logicOp, String valueNameInHql, OP op, Object value, String replaceString) {
            this.logicOp = logicOp;
            this.valueNameInHql = valueNameInHql;
            this.op = op;
            this.value = value;
            this.replaceString = replaceString;
        }

        LogicOp logicOp;
        String valueNameInHql;
        OP op;
        Object value;
        String replaceString;
    }
    public static enum OrderType {
        ASC,DESC;
    }
    public static enum OP {
        eq {
            {
                value = "=";
            }
        },
        neq {
            {
                value = "<>";
            }
        },
        gt {
            {
                value = ">";
            }
        },
        lt {
            {
                value = "<";
            }
        },
        ge {
            {
                value = ">=";
            }
        },
        le {
            {
                value = "<=";
            }
        },
        like {
            {
                value = " like ";
            }
        },
        in {
            {
                value = " in ";
            }
        }, 
        isNotNull {
            {
                value = " is not null ";
            }
        },
        isNull {
            {
                value = " is null ";
            }
        };
        protected String value = null;

        public String v() {
            return value;
        }
    }

    
}

@Service("pageQueryService")
public class PageQueryService {
    
    private SessionFactory sessionFactory;

    @Resource(name = "sessionFactory")
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public <T> Page<T> getNextPage(PageQuery<T> pageQuery) {
        Page<T> result = pageQuery.excuteQuery(this.sessionFactory.getCurrentSession());
        return result;
    }
}

原文地址：http://www.cnblogs.com/zdcin/p/3152668.html