精华内容
下载资源
问答
  • Query类

    2020-04-01 17:06:10
  • 自定义Query类

    2021-01-22 15:57:19
    Query类详解 Query类,Query是一个查询参数类,封装了查询条件,分页,排序等功能。 参数介绍 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类详解

    万次阅读 多人点赞 2018-02-22 14:21:48
    本篇介绍Query类,Query是一个查询参数类,封装了查询条件,分页,排序等功能。参数介绍Query里面封装了一系列查询参数,主要分为以下几类: 分页参数:设置分页 排序参数:设置排序字段 条件参数:设置查询条件 ...

    本篇介绍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类详解

    千次阅读 2018-11-06 10:22:39
    本篇介绍Query类,Query是一个查询参数类,封装了查询条件,分页,排序等功能。 参数介绍 Query里面封装了一系列查询参数,主要分为以下几类: 分页参数:设置分页 排序参数:设置排序字段 条件参数:设置查询条件...

    本篇介绍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”都为数据库字段。
     

    展开全文
  • AXQuery类

    2011-01-31 08:47:00
    Query类一. 过滤时的值的形式在query中,过滤的关键就是query.value(_value)中参数_value的格式,该参数的值可以是基本数据类型、表达式、值列表。下面会依次示例它们的使用方法。//最普通的query如下代码static ...
  • wordpress 获取指定分类中的日志列表常常用于显示指定分类下的日志,适合于CMS,或者网站地图之类的,我们常用的函数是query_posts()函数,使用WP_Query类也有更多的优点。1、利用query_posts()函数query_posts()是...
  • Spring JDBC SqlQuery类

    2018-03-10 10:13:53
    org.springframework.jdbc.object.SqlQuery类提供了表示SQL查询的可重用操作对象。使用到的 Student 表的结构如下 -CREATE TABLE Student( ID INT NOT NULL AUTO_INCREMENT, NAME VARCHAR(20) NOT NULL, AGE ...
  • 组合查询 WordPress插件-组合查询 描述 这个实验性插件可让您使用combined_query属性将多个WP_Query查询合并为一个查询。 这是作为Stackoverflow的... 该WP_Combine_Query类,取而代之只需使用的被删除combined_que
  • 【Qt】Qt的数据库(Driver类、Query类、Model类、View类)   Qt提供了与数据库联动以开发应用程序的模块。与其他API相比,Qt提供的API更直观,也更容易理解。使用Qt提供的API之前,需要添加如下的头文件。 #...
  • Query是一个查询参数类,封装了查询条件,分页,排序等功能 参数介绍 Query里面封装了一系列查询参数,...Query类使用page(pageIdnex, pageSize)方法来设置。 假如我们要查询第二页,每页10条数据,代码可以这样写:
  • luncene 各种Query类详解实例

    千次阅读 2014-12-11 11:57:38
    luncene 各种Query类详解实例,包括词条搜索类TermQuery “与或”搜索类——BooleanQuery 在某一范围内搜索类——RangeQuery 使用前缀搜索类——PrefixQuery 多关键字搜索——PhraseQuery 短语词缀搜索——...
  • Query类中的uniqueQuery( )

    2018-09-26 21:38:26
    当特别明确知道查询出来的数据只有一条的时候,就用Query类中的uniqueQuery()而不再用list()使用此方法的原因: 因为使用query.list()方法的时候,要将整张表都遍历一遍,但是如果使用uniqueQuery()的话, 当查询...
  • geotools学习:gt-api-RC1.jar中Query类学习Query位于org.geotools.data包下,今天学习它的用法,在geotools的官网上不能下载到Query类源代码,只能到GitHub上下载(Query.Java)。
  • 1.编译没有重复定义,但是链接重复定义。头文件中定义导致。 2.-o后面忘记加可执行文件名,结果出现下面错误,同时第一个cpp文件还会自动消失 /usr/lib/gcc/x86_64-linux-...就没有在头文件中声明,光在Query.cpp文件
  • hibernate的Query类

    千次阅读 2018-02-02 15:47:15
    Query query = em.createNativeQuery(sql, .class);  return query.setParameter("name", name).getResultList(); __________________  Query query = em.createNativeQuery(sql);  query.unwrap...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,275
精华内容 4,110
关键字:

query类