Query类详解

Query类详解
Query类，Query是一个查询参数类，封装了查询条件，分页，排序等功能。
参数介绍
Query里面封装了一系列查询参数，主要分为以下几类：
分页参数：设置分页

排序参数：设置排序字段

条件参数：设置查询条件
Query类

/**
 * @auther twh
 * @description 查询条件封装类
 * @date 2019/11/19
 */
@SuppressWarnings("serial")
public class Query implements Serializable {
	//查询条件 key:"字段名_查询方式" value:"查询值"
    private final Map<String, Object> conditionMap;
	//排序(有序) key:"字段名" value:"排序方式"
    private final Map<String, String> orderMap;
	//或
    private final List<Map<String, Object>> orConditionMaps;
	//忽略空值
    private boolean ignoreEmptyValue;
	//分页
    private PageData pageData;
	//统计
    private boolean count;

    public final static String SPLIT = "_";
    public final static String EQ = "eq";
    public final static String NE = "ne";
    public final static String LT = "lt";
    public final static String LT_OR_EQ = "ltOrEq";
    public final static String GT = "gt";
    public final static String GT_OR_EQ = "gtOrEq";
    public final static String IN = "in";
    public final static String NOT_IN = "notIn";
    public final static String BETWEEN = "between";
    public final static String NOT_BETWEEN = "notBetween";
    public final static String LIKE = "like";
    public final static String FULL_LIKE = "fullLike";
    public final static String HEAD_LIKE = "headLike";
    public final static String TAIL_LIKE = "tailLike";
    public final static String ASC = "asc";
    public final static String DESC = "desc";
    public final static String REC_STATUS = "recStatus";
    public final static String IS_NULL = "isNull";
    public final static String NOT_NULL = "notNull";

    public Query() {
        conditionMap = Maps.newHashMap();
        orderMap = Maps.newLinkedHashMap();
        orConditionMaps = Lists.newArrayList();
        ignoreEmptyValue = false;
    }

    /**
     * 功能描述:将对象所有属性值作为eq条件
     *
     * @param o:
     * @return
     * @author twh
     * @date 2019/11/21
     */
    public Query(Object o) throws Exception {
        this();
        if (o == null)
            throw new IllegalArgumentException("can not construct Query bean with an empty object!");
        Map<String, Object> map = BeanUtil.beanToMap(o);
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            if (entry.getValue() == null)
                continue;
            eq(entry.getKey(), entry.getValue());
        }
    }

    /**
     * 功能描述:设置分页参数，只生效一次 可根据需求设置是否需要统计
     *
     * @param pageData:
     * @param count:
     * @return Query
     * @author twh
     * @date 2019/11/19
     */
    public void startPage(PageData pageData, boolean count) {
        this.pageData = pageData;
        this.count = count;
    }

    /**
     * 功能描述:设置分页参数，只生效一次， 默认包含统计
     *
     * @param pageData:
     * @return Query
     * @author twh
     * @date 2019/11/19
     */
    public void startPage(PageData pageData) {
        startPage(pageData, true);
    }

    /**
     * 功能描述:设置分页参数，只生效一次, 不统计
     *
     * @param start:
     * @param length:
     * @return void
     * @author twh
     * @date 2019/11/25
     */
    public void startPage(int start, int length) {
        PageData pageData = new PageData();
        pageData.setStart(start + "");
        pageData.setLength(length + "");
        startPage(pageData, false);
    }

    /**
     * 功能描述:设置返回结果数字
     *
     * @param length:
     * @return void
     * @author twh
     * @date 2019/11/25
     */
    public void limit(int length) {
        PageData pageData = new PageData();
        pageData.setStart("0");
        pageData.setLength(length + "");
        startPage(pageData, false);
    }

    /**
     * 功能描述:等于
     *
     * @param field:属性名
     * @param value:比较值
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query eq(String field, Object value) {
        if (ignoreEmptyValue && isBlank(value))
            return this;
        notEmptyValue(field, value);
        putCondition(field, EQ, value);
        return this;
    }

    /**
     * 功能描述:不等于
     *
     * @param field:属性名
     * @param value:比较值
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query ne(String field, Object value) {
        if (ignoreEmptyValue && isBlank(value))
            return this;
        notEmptyValue(field, value);
        putCondition(field, NE, value);
        return this;
    }

    /**
     * 功能描述:小于
     *
     * @param field:
     * @param value:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query lt(String field, Object value) {
        if (ignoreEmptyValue && isBlank(value))
            return this;
        notEmptyValue(field, value);
        putCondition(field, LT, value);
        return this;
    }

    /**
     * 功能描述:小于等于
     *
     * @param field:
     * @param value:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query ltOrEq(String field, Object value) {
        if (ignoreEmptyValue && isBlank(value))
            return this;
        notEmptyValue(field, value);
        putCondition(field, LT_OR_EQ, value);
        return this;
    }

    /**
     * 功能描述:大于
     *
     * @param field:
     * @param value:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query gt(String field, Object value) {
        if (ignoreEmptyValue && isBlank(value))
            return this;
        notEmptyValue(field, value);
        putCondition(field, GT, value);
        return this;
    }

    /**
     * 功能描述:大于等于
     *
     * @param field:
     * @param value:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query gtOrEq(String field, Object value) {
        if (ignoreEmptyValue && isBlank(value))
            return this;
        notEmptyValue(field, value);
        putCondition(field, GT_OR_EQ, value);
        return this;
    }

    /**
     * 功能描述:in
     *
     * @param field:
     * @param values:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query in(String field, List<? extends Object> values) {
        if (ignoreEmptyValue && CollUtil.isEmpty(values))
            return this;
        notEmptyValue(field, values);
        putCondition(field, IN, values);
        return this;
    }

    public Query in(String field, Object value, Object... values) {
        if (ignoreEmptyValue && ((values == null || values.length == 0) && isBlank(value)))
            return this;
        List<Object> list = Lists.newArrayList(Arrays.asList(values));
        list.add(value);
        notEmptyValue(field, list);
        putCondition(field, IN, list);
        return this;
    }

    /**
     * 功能描述:not in
     *
     * @param field:
     * @param values:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query notIn(String field, List<Object> values) {
        if (ignoreEmptyValue && CollUtil.isEmpty(values))
            return this;
        notEmptyValue(field, values);
        putCondition(field, NOT_IN, values);
        return this;
    }

    public Query notIn(String field, Object value, Object... values) {
        if (ignoreEmptyValue && ((values == null || values.length == 0) && isBlank(value)))
            return this;
        List<Object> list = Lists.newArrayList(Arrays.asList(values));
        list.add(value);
        notEmptyValue(field, list);
        putCondition(field, NOT_IN, list);
        return this;
    }

    /**
     * 功能描述:between
     *
     * @param field:
     * @param arg1:
     * @param arg2:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query between(String field, Object arg1, Object arg2) {
        if (ignoreEmptyValue && (arg1 == null && arg2 == null))
            return this;
        notEmptyValue(field, arg1);
        notEmptyValue(field, arg2);
        putCondition(field, BETWEEN, new Object[] {arg1, arg2});
        return this;
    }

    /**
     * 功能描述:not between
     *
     * @param field:
     * @param arg1:
     * @param arg2:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query notBetween(String field, Object arg1, Object arg2) {
        if (ignoreEmptyValue && (arg1 == null && arg2 == null))
            return this;
        notEmptyValue(field, arg1);
        notEmptyValue(field, arg2);
        putCondition(field, NOT_BETWEEN, new Object[] {arg1, arg2});
        return this;
    }

    /**
     * 功能描述:模糊查询，自己设置模糊查询的格式
     *
     * @param field:
     * @param value:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/12/3
     */
    public Query like(String field, Object value) {
        if (ignoreEmptyValue && isBlank(value))
            return this;
        notEmptyValue(field, value);
        putCondition(field, LIKE, value);
        return this;
    }

    /**
     * 功能描述:包含value
     *
     * @param field:
     * @param value:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query fullLike(String field, Object value) {
        if (ignoreEmptyValue && isBlank(value))
            return this;
        notEmptyValue(field, value);
        putCondition(field, FULL_LIKE, value);
        return this;
    }

    /**
     * 功能描述:以value开始
     *
     * @param field:
     * @param value:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query headLike(String field, Object value) {
        if (ignoreEmptyValue && isBlank(value))
            return this;
        notEmptyValue(field, value);
        putCondition(field, HEAD_LIKE, value);
        return this;
    }

    /**
     * 功能描述:以value结尾
     *
     * @param field:
     * @param value:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public Query tailLike(String field, Object value) {
        if (ignoreEmptyValue && isBlank(value))
            return this;
        notEmptyValue(field, value);
        putCondition(field, TAIL_LIKE, value);
        return this;
    }

    /**
     * 功能描述:相当于.eq("resStatus", "N")
     *
     * @param :
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/12/4
     */
    public Query notRecRecords() {
        putCondition(REC_STATUS, EQ, "N");
        return this;
    }

    /**
     * 功能描述:字段为空
     *
     * @param field:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/12/3
     */
    public Query isNull(String field) {
        if (isBlank(field))
            return this;
        putCondition(field, IS_NULL, null);
        return this;
    }

    /**
     * 功能描述:字段为不为空
     *
     * @param field:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/12/3
     */
    public Query notNull(String field) {
        if (isBlank(field))
            return this;
        putCondition(field, NOT_NULL, null);
        return this;
    }

    private void putCondition(String field, String type, Object value) {
        if (value != null && value instanceof String) {
            value = ((String)value).trim();
        }
        conditionMap.put(field + SPLIT + type, value);
    }

    /**
     * 功能描述:设置升序排序
     *
     * @param field:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public void addAscOrderByClause(String field) {
        orderMap.put(field, ASC);
    }

    /**
     * 功能描述:设置降序排序
     *
     * @param field:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/21
     */
    public void addDescOrderByClause(String field) {
        orderMap.put(field, DESC);
    }

    /**
     * 功能描述:继承其他Query类的条件
     *
     * @param query:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/22
     */
    public void add(Query query) {
        this.conditionMap.putAll(query.getConditionMap());
    }

    /**
     * 功能描述:或
     *
     * @param query:
     * @return com.betterda.catpay.ultimate.business.Query
     * @author twh
     * @date 2019/11/22
     */
    public void or(Query query) {
        this.orConditionMaps.add(query.getConditionMap());
    }

    /**
     * 功能描述:自动忽略value为空的条件
     *
     * @param :
     * @return boolean
     * @author twh
     * @date 2019/11/25
     */
    public boolean autoIgnoreEmptyValue() {
        return ignoreEmptyValue = true;
    }

    public void notAllowEmptyValue() {
        this.ignoreEmptyValue = false;
    }

    public Map<String, Object> getConditionMap() {
        return conditionMap;
    }

    public Map<String, String> getOrderMap() {
        return orderMap;
    }

    public List<Map<String, Object>> getOrConditionMaps() {
        return orConditionMaps;
    }

    public PageData getPageData() {
        return pageData;
    }

    public boolean getCount() {
        return count;
    }

    private void notEmptyValue(String field, Object value) {
        if (value instanceof List) {
            if (CollUtil.isEmpty((List)value))
                throw new IllegalArgumentException("query condition " + field + " can not be empty!");
        }
        if (value instanceof Object[]) {
            if (value == null || ((Object[])value).length == 0)
                throw new IllegalArgumentException("query condition " + field + " can not be empty!");
        }
        if (value == null || StrUtil.isEmpty(String.valueOf(value)))
            throw new IllegalArgumentException("query condition " + field + " can not be empty!");

    }

    private boolean isBlank(Object value) {
        if (value instanceof String) {
            return StrUtil.isBlank(String.valueOf(value));
        } else {
            return value == null;
        }
    }

    public static void main(String[] args) {
        Object value = " ";
        System.out.println(StrUtil.isBlank(String.valueOf(value)));
    }
}



PageData类
public class PageData implements java.io.Serializable {
    private String start;
    private String length;
    private String draw;

    public String getStart() {
        return start;
    }

    public void setStart(String start) {
        this.start = start;
    }

    public String getDraw() {
        return draw;
    }

    public void setDraw(String draw) {
        this.draw = draw;
    }

    public String getLength() {
        return length;
    }

    public void setLength(String length) {
        this.length = length;
    }

    public Integer getPageNum() {
        return (Integer.parseInt(start) / Integer.parseInt(length)) + 1;
    }

    public Integer getPageSize() {
        return Integer.parseInt(length);
    }
}


public class PageData4App extends PageData implements Serializable {

    @ApiModelProperty(value = "开始下标", required = true)
    private String pageNum;
    @ApiModelProperty(value = "分页长度", required = true)
    private String pageSize;

    @Override
    public Integer getPageNum() {
        return Integer.valueOf(pageNum);
    }

    @Override
    public Integer getPageSize() {
        return Integer.valueOf(pageSize);
    }

    public void setPageNum(String pageNum) {
        this.pageNum = pageNum;
    }

    public void setPageSize(String pageSize) {
        this.pageSize = pageSize;
    }
}


解析Query

	private Class<T> modelClass;

    public BaseServiceImpl() {
        ParameterizedType pt = (ParameterizedType)this.getClass().getGenericSuperclass();
        modelClass = (Class<T>)pt.getActualTypeArguments()[0];
    }
    
	protected Example getExample(Query query) {
        Example example = new Example(modelClass);
        Example.Criteria criteria = example.createCriteria();
        // 简单条件拼装
        assemblyCriteria(criteria, query.getConditionMap());
        // 或条件拼装
        if (CollUtil.isNotEmpty(query.getOrConditionMaps())) {
            for (Map<String, Object> orConditionMap : query.getOrConditionMaps()) {
                Example.Criteria orCriteria = example.createCriteria();
                assemblyCriteria(orCriteria, orConditionMap);
                example.or(orCriteria);
            }
        }
        // 排序拼装
        assemblyOrderByClause(example, query.getOrderMap());
        return example;
    }

    private void assemblyCriteria(Example.Criteria criteria, Map<String, Object> conditionMap) {
        for (Map.Entry<String, Object> entry : conditionMap.entrySet()) {
            String[] arr = entry.getKey().split(Query.SPLIT);
            String property = arr[0];
            switch (arr[1]) {
                case Query.EQ:
                    criteria.andEqualTo(property, entry.getValue());
                    break;
                case Query.NE:
                    criteria.andNotEqualTo(property, entry.getValue());
                    break;
                case Query.LT:
                    criteria.andLessThan(property, entry.getValue());
                    break;
                case Query.LT_OR_EQ:
                    criteria.andLessThanOrEqualTo(property, entry.getValue());
                    break;
                case Query.GT:
                    criteria.andGreaterThan(property, entry.getValue());
                    break;
                case Query.GT_OR_EQ:
                    criteria.andGreaterThanOrEqualTo(property, entry.getValue());
                    break;
                case Query.IN:
                    criteria.andIn(property, (List)entry.getValue());
                    break;
                case Query.NOT_IN:
                    criteria.andNotIn(property, (List)entry.getValue());
                    break;
                case Query.BETWEEN:
                    criteria.andBetween(property, ((Object[])entry.getValue())[0], ((Object[])entry.getValue())[1]);
                    break;
                case Query.NOT_BETWEEN:
                    criteria.andNotBetween(property, ((Object[])entry.getValue())[0], ((Object[])entry.getValue())[1]);
                    break;
                case Query.LIKE:
                    criteria.andLike(property, entry.getValue() + "");
                    break;
                case Query.FULL_LIKE:
                    criteria.andLike(property, "%" + entry.getValue() + "%");
                    break;
                case Query.HEAD_LIKE:
                    criteria.andLike(property, entry.getValue() + "%");
                    break;
                case Query.TAIL_LIKE:
                    criteria.andLike(property, "%" + entry.getValue());
                    break;
                case Query.NOT_NULL:
                    criteria.andIsNotNull(property);
                    break;
                case Query.IS_NULL:
                    criteria.andIsNull(property);
                    break;
                default:
                    throw new IllegalArgumentException(
                        "no parse method for '" + arr[1] + "' in" + this.getClass().getName());
            }
        }
    }

    private void assemblyOrderByClause(Example example, Map<String, String> orderMap) {
        for (Map.Entry<String, String> entry : orderMap.entrySet()) {
            if (Query.ASC.equals(entry.getValue())) {
                example.orderBy(entry.getKey()).asc();
            }
            if (Query.DESC.equals(entry.getValue())) {
                example.orderBy(entry.getKey()).desc();
            }
        }
    }





查询方式
说明




eq
等于=


gt
大于>


lt
小于<


ge
大于等于>=


le
小于等于<=


notEq
不等于<>


like
模糊查询


in
in()查询


notIn
not in()查询


isNull
NULL值查询


notNull
IS NOT NULL


notEmpty
字段不为空，非NULL且有内容


isEmpty
字段为NULL或者为""

本篇介绍Query类，Query是一个查询参数类，封装了查询条件，分页，排序等功能。

参数介绍

Query里面封装了一系列查询参数，主要分为以下几类：

分页参数：设置分页
排序参数：设置排序字段
条件参数：设置查询条件
字段参数：可返回指定字段
下面逐个讲解每个参数的用法。



分页参数

一般来说分页的使用比较简单，通常是两个参数， 

pageIndex：当前页索引，pageSize：每页几条数据。 

Query类使用page(pageIdnex, pageSize)方法来设置。 

假如我们要查询第二页，每页10条数据，代码可以这样写：



Query query = new Query().page(2, 10);
List<User> list = dao.find(query);

如果要实现不规则分页，可以这样写：



Query query = new Query().limit(3,5);
// 对应mysql：limit 3,5

如果要查询所有数据,则可以这样写:
Query query = new Query();
List<User> list = dao.findAll(query);



排序参数

设置排序：



orderby(String sortname, Sort sort)

其中sortname为数据库字段，非javaBean属性 

- orderby(String sortname, Sort sort)则可以指定排序方式，Sort为排序方式枚举 

  假如要按照添加时间倒序，可以这样写：



Query query = new Query().orderby("create_time",Sort.DESC);
dao.find(query);

添加多个排序字段可以在后面追加：



query.orderby("create_time",Sort.DESC).orderby("id",Sort.ASC);

条件参数

条件参数是用的最多一个，因为在查询中往往需要加入各种条件。 

easymybatis在条件查询上面做了一些封装，这里不做太多讲解，只讲下基本的用法，以后会单独开一篇文章来介绍。感兴趣的同学可以自行查看源码，也不难理解。

条件参数使用非常简单，Query对象封装一系列常用条件查询。

等值查询eq(String columnName, Object value)，columnName为数据库字段名，value为查询的值 

假设我们要查询姓名为张三的用户，可以这样写：
Query query = new Query();
query.eq("username","张三");
List<User> list = dao.find(query);

通过方法名即可知道eq表示等于’=’，同理lt表示小于<,gt表示大于>

查询方式
  
说明
eq
  
等于=
gt
  
大于>
lt
  
小于<
ge
  
大于等于>=
le
  
小于等于<=
notEq
  
不等于<>
like
  
模糊查询
in
  
in()查询
notIn
  
not in()查询
isNull
  
NULL值查询
notNull
  
IS NOT NULL
notEmpty
  
字段不为空，非NULL且有内容
isEmpty
  
字段为NULL或者为”
如果上述方法还不能满足查询需求的话，我们可以使用自定sql的方式来编写查询条件，方法为：



Query query = new Query();
query.sql(" username='Jim' OR username='Tom'");

注意：sql()方法不会处理sql注入问题，因此尽量少用。



字段参数

在某些场景下，我们只想获取表里面几个字段的信息，不想查询所有字段。此时使用方式如下：



Query query = new Query();
// 只返回id,username
query.setColumns(Arrays.asList("id","username"));
List<TUser> list = dao.find(query);

这里的”id”，”username”都为数据库字段。

本篇介绍Query类，Query是一个查询参数类，封装了查询条件，分页，排序等功能。

参数介绍

Query里面封装了一系列查询参数，主要分为以下几类：

分页参数：设置分页

排序参数：设置排序字段

条件参数：设置查询条件

字段参数：可返回指定字段

下面逐个讲解每个参数的用法。

分页参数

一般来说分页的使用比较简单，通常是两个参数， 

pageIndex：当前页索引，pageSize：每页几条数据。 

Query类使用page(pageIdnex, pageSize)方法来设置。 

假如我们要查询第二页，每页10条数据，代码可以这样写：

Query query = new Query().page(2, 10);
List<User> list = dao.find(query);



如果要实现不规则分页，可以这样写：

Query query = new Query().limit(3,5);

// 对应mysql：limit 3,5


如果要查询所有数据,则可以这样写:

Query query = new Query();
List<User> list = dao.findAll(query);

排序参数

设置排序：

orderby(String sortname, Sort sort)

其中sortname为数据库字段，非javaBean属性 

- orderby(String sortname, Sort sort)则可以指定排序方式，Sort为排序方式枚举 

假如要按照添加时间倒序，可以这样写：

Query query = new Query().orderby("create_time",Sort.DESC);
dao.find(query);

添加多个排序字段可以在后面追加：

query.orderby("create_time",Sort.DESC).orderby("id",Sort.ASC);

条件参数

条件参数是用的最多一个，因为在查询中往往需要加入各种条件。 

easymybatis在条件查询上面做了一些封装，这里不做太多讲解，只讲下基本的用法，以后会单独开一篇文章来介绍。感兴趣的同学可以自行查看源码，也不难理解。

条件参数使用非常简单，Query对象封装一系列常用条件查询。

等值查询eq(String columnName, Object value)，columnName为数据库字段名，value为查询的值 

假设我们要查询姓名为张三的用户，可以这样写：

Query query = new Query();
query.eq("username","张三");
List<User> list = dao.find(query);



通过方法名即可知道eq表示等于’=’，同理lt表示小于<,gt表示大于>

查询方式    说明

eq    等于=

gt    大于>

lt    小于<

ge    大于等于>=

le    小于等于<=

notEq    不等于<>

like    模糊查询

in    in()查询

notIn    not in()查询

isNull    NULL值查询

notNull    IS NOT NULL

notEmpty    字段不为空，非NULL且有内容

isEmpty    字段为NULL或者为”

如果上述方法还不能满足查询需求的话，我们可以使用自定sql的方式来编写查询条件，方法为：

Query query = new Query();
query.sql(" username='Jim' OR username='Tom'");

注意：sql()方法不会处理sql注入问题，因此尽量少用。

字段参数

在某些场景下，我们只想获取表里面几个字段的信息，不想查询所有字段。此时使用方式如下：

Query query = new Query();
// 只返回id,username
query.setColumns(Arrays.asList("id","username"));
List<TUser> list = dao.find(query);



这里的”id”，”username”都为数据库字段。