精华内容
下载资源
问答
  • CRITERIA-1D / GEO CRITERIA-1D是一种农业水文学模型,用于模拟一维水通量,作物生长和作物需水量。可以在不同的详细级别定义土壤和作物参数。它需要每日农业气象数据作为输入:最低和最高气温,总降水量以及皮下...
  • Criteria标准化对象查询小例子,内有配套的SQL表语句和使用说明
  • 本手册目的是根据《全球化学品统一分类和标签制度》(此标准已上传)推介需遵守运输规章的危险货物、危害性物质和混合物的联合国分类办法。它还描述各种试验方法和程序,这些方法和程序据认为最有助于分类实体获得...
  • Criteria hibernate

    2019-04-06 01:18:51
    NULL 博文链接:https://ssydxa219.iteye.com/blog/1543253
  • 主要介绍了Android使用criteria选择合适的地理位置服务实现方法,实例分析了Criteria的具体使用技巧,需要的朋友可以参考下
  • 绍Hibernate的Criteria 查询方法
  • Acceptance Criteria.pdf

    2020-09-20 21:33:15
    讲了AC的相关概念与表达形式,包括GWT、Checklist形式。还有一个实例贯穿始终。出自一个外网的博客?有在论文中引用应该是很可信的。
  • For digital holographic applications, we have studied the refocus criteria operating on the high-pass filtered and the nonfiltered reconstructed complex amplitudes (RCAs), respectively. A set of 10 ...
  • 主要介绍了Java的Hibernate框架中Criteria查询使用的实例讲解,Hibernate是Java的SSH三大web开发框架之一,需要的朋友可以参考下
  • Hibernate Criteria

    2019-03-15 01:14:13
    NULL 博文链接:https://chenlinbo.iteye.com/blog/335677
  • criteria介绍与使用

    2013-01-03 14:57:11
    criteria的相关知识及其介绍,便于java编程中使用criteria进行相关操作。
  • Hibernate中Criteria的完整用法 Criteria 是一个完全面向对象,可扩展的条件查询API,通过它完全不需要考虑数据库底层如何实现、SQL语句如何...
  • Hibernate的Criteria文档

    2016-07-28 16:35:25
    一个项目不一定只有一种类型的数据源,如何屏蔽掉不同数据库的差异呢?hibernate在这方面做得很好,同时Criteria虽然不比HQL用得广泛,但是效率比它高,而且对于特定项目,它表现得很灵活。
  • 主要介绍了java 过滤器模式(Filter/Criteria Pattern)详细介绍的相关资料,需要的朋友可以参考下
  • Java mongoDB查询(Query Criteria

    千次阅读 2020-09-01 16:35:53
    MongoDB 将数据存储为一个文档,数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。... CriteriaDefinition existing = (CriteriaDefinition)this.criteria.get(criteriaDefini

    MongoDB 将数据存储为一个文档,数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档,数组及文档数组。
    在这里插入图片描述

    Query

    //添加过滤条件
    public Query addCriteria(CriteriaDefinition criteriaDefinition) {
        CriteriaDefinition existing = (CriteriaDefinition)this.criteria.get(criteriaDefinition.getKey());
        String key = criteriaDefinition.getKey();
        if (existing == null) {
            this.criteria.put(key, criteriaDefinition);
            return this;
        } else {
            throw new InvalidMongoDbApiUsageException(String.format("Due to limitations of the com.mongodb.BasicDocument, you can't add a second '%s' criteria. Query already contains '%s'", key, SerializationUtils.serializeToJsonSafely(existing.getCriteriaObject())));
        }
    }
    
    //指定返回字段
    public Field fields() {
        if (this.fieldSpec == null) {
            this.fieldSpec = new Field();
        }
    
        return this.fieldSpec;
    }
    
    //跳过指定数量的数据
    public Query skip(long skip) {
        this.skip = skip;
        return this;
    }
    
    //接受一个数字参数
    public Query limit(int limit) {
        this.limit = limit;
        return this;
    }
    
    //
    public Query withHint(String name) {
        Assert.hasText(name, "Hint must not be empty or null!");
        this.hint = name;
        return this;
    }
    
    //分页查询
    public Query with(Pageable pageable) {
        if (pageable.isUnpaged()) {
            return this;
        } else {
            this.limit = pageable.getPageSize();
            this.skip = pageable.getOffset();
            return this.with(pageable.getSort());
        }
    }
    
    //排序
    public Query with(Sort sort) {
        Assert.notNull(sort, "Sort must not be null!");
        if (sort.isUnsorted()) {
            return this;
        } else {
            sort.stream().filter(Order::isIgnoreCase).findFirst().ifPresent((it) -> {
                throw new IllegalArgumentException(String.format("Given sort contained an Order for %s with ignore case! MongoDB does not support sorting ignoring case currently!", it.getProperty()));
            });
            this.sort = this.sort.and(sort);
            return this;
        }
    }
    
    public Set<Class<?>> getRestrictedTypes() {
        return this.restrictedTypes;
    }
    
    public Query restrict(Class<?> type, Class<?>... additionalTypes) {
        Assert.notNull(type, "Type must not be null!");
        Assert.notNull(additionalTypes, "AdditionalTypes must not be null");
        this.restrictedTypes.add(type);
        this.restrictedTypes.addAll(Arrays.asList(additionalTypes));
        return this;
    }
    
    //对文档的操作
    public Document getQueryObject() {
        Document document = new Document();
        Iterator var2 = this.criteria.values().iterator();
    
        while(var2.hasNext()) {
            CriteriaDefinition definition = (CriteriaDefinition)var2.next();
            document.putAll(definition.getCriteriaObject());
        }
    
        if (!this.restrictedTypes.isEmpty()) {
            document.put("_$RESTRICTED_TYPES", this.getRestrictedTypes());
        }
    
        return document;
    }
    
    //对文档的操作
    public Document getFieldsObject() {
        return this.fieldSpec == null ? new Document() : this.fieldSpec.getFieldsObject();
    }
    
    //对文档的操作
    public Document getSortObject() {
        if (this.sort.isUnsorted()) {
            return new Document();
        } else {
            Document document = new Document();
            this.sort.stream().forEach((order) -> {
                document.put(order.getProperty(), order.isAscending() ? 1 : -1);
            });
            return document;
        }
    }
    
    //指定在光标上进行处理操作的累积时间限制(以毫秒为单位)。
    public Query maxTimeMsec(long maxTimeMsec) {
        this.meta.setMaxTimeMsec(maxTimeMsec);
        return this;
    }
    

    Criteria

        /**
         *Query query = new Query();
         * query.addCriteria(Criteria.where("name").is(name));
         * @param key
         * @return
         */
        //把多个条件组合在一起
            public static Criteria where(String key) {
                return new Criteria(key);
            }
    
            //封装查询条件
            /**例如:
             *
             *创建匹配器,即如何使用查询条件
             * ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
             *        .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式:模糊查询
             *        .withIgnoreCase(true) //改变默认大小写忽略方式:忽略大小写
             *        .withMatcher("name", ExampleMatcher.GenericPropertyMatchers.contains()) //标题采用“包含匹配”的方式查询
             *        .withIgnorePaths("pageNum", "pageSize");  //忽略属性,不参与查询
             *创建实例
             *Example<Student> example = Example.of(student, matcher);
             *Query query = new Query(Criteria.byExample(example));
             **/
            public static Criteria byExample(Object example) {
                return byExample(Example.of(example));
            }
    
    
            //封装查询条件
            public static Criteria byExample(Example<?> example) {
                return (new Criteria()).alike(example);
            }
    
            //匹配文档
            public static Criteria matchingDocumentStructure(MongoJsonSchema schema) {
                return (new Criteria()).andDocumentStructureMatches(schema);
            }
    
            //并且
            public Criteria and(String key) {
                return new Criteria(this.criteriaChain, key);
            }
    
            //是
            public Criteria is(@Nullable Object o) {
                if (!this.isValue.equals(NOT_SET)) {
                    throw new InvalidMongoDbApiUsageException("Multiple 'is' values declared. You need to use 'and' with multiple criteria");
                } else if (this.lastOperatorWasNot()) {
                    throw new InvalidMongoDbApiUsageException("Invalid query: 'not' can't be used with 'is' - use 'ne' instead.");
                } else {
                    this.isValue = o;
                    return this;
                }
            }
    
            //用于匹配正则表达式
            private boolean lastOperatorWasNot() {
                return !this.criteria.isEmpty() && "$not".equals(this.criteria.keySet().toArray()[this.criteria.size() - 1]);
            }
    
            //不等于
            public Criteria ne(@Nullable Object o) {
                this.criteria.put("$ne", o);
                return this;
            }
    
            //小于
            public Criteria lt(Object o) {
                this.criteria.put("$lt", o);
                return this;
            }
    
            //小于等于
            public Criteria lte(Object o) {
                this.criteria.put("$lte", o);
                return this;
            }
    
            //大于
            public Criteria gt(Object o) {
                this.criteria.put("$gt", o);
                return this;
            }
    
            //大于等于
            public Criteria gte(Object o) {
                this.criteria.put("$gte", o);
                return this;
            }
    
            //包含
            public Criteria in(Object... o) {
                if (o.length > 1 && o[1] instanceof Collection) {
                    throw new InvalidMongoDbApiUsageException("You can only pass in one argument of type " + o[1].getClass().getName());
                } else {
                    this.criteria.put("$in", Arrays.asList(o));
                    return this;
                }
            }
    
            //包含
            public Criteria in(Collection<?> c) {
                this.criteria.put("$in", c);
                return this;
            }
    
            //与in相反
            public Criteria nin(Object... o) {
                return this.nin((Collection)Arrays.asList(o));
            }
    
            //与in相反
            public Criteria nin(Collection<?> o) {
                this.criteria.put("$nin", o);
                return this;
            }
    
            //取模(求余)运算 ,即:key对应的值%value==remainder(求余是否等于remainder)
            public Criteria mod(Number value, Number remainder) {
                List<Object> l = new ArrayList();
                l.add(value);
                l.add(remainder);
                this.criteria.put("$mod", l);
                return this;
            }
    
            //key键对应的集合包含col(all是包含关系,in是被包含关系)
            public Criteria all(Object... o) {
                return this.all((Collection)Arrays.asList(o));
            }
    
            public Criteria all(Collection<?> o) {
                this.criteria.put("$all", o);
                return this;
            }
    
            //匹配key所对应的集合的元素的指定数量(!!!不能进行像<5之类的范围匹配)
            public Criteria size(int s) {
                this.criteria.put("$size", s);
                return this;
            }
    
            //查询字段是否存在(true:存在,false:不存在)
            public Criteria exists(boolean b) {
                this.criteria.put("$exists", b);
                return this;
            }
    
            //基于 bson type来匹配一个元素的类型,像是按照类型ID来匹配
            public Criteria type(int t) {
                this.criteria.put("$type", t);
                return this;
            }
    
            public Criteria type(Type... types) {
                Assert.notNull(types, "Types must not be null!");
                Assert.noNullElements(types, "Types must not contain null.");
                this.criteria.put("$type", Arrays.asList(types).stream().map(Type::value).collect(Collectors.toList()));
                return this;
            }
    
            //取反
            public Criteria not() {
                return this.not((Object)null);
            }
    
            private Criteria not(@Nullable Object value) {
                this.criteria.put("$not", value);
                return this;
            }
    
            //模糊查询用
            public Criteria regex(String re) {
                return this.regex(re, (String)null);
            }
    
            public Criteria regex(String re, @Nullable String options) {
                return this.regex(this.toPattern(re, options));
            }
    
            public Criteria regex(Pattern pattern) {
                Assert.notNull(pattern, "Pattern must not be null!");
                if (this.lastOperatorWasNot()) {
                    return this.not(pattern);
                } else {
                    this.isValue = pattern;
                    return this;
                }
            }
    
            public Criteria regex(BsonRegularExpression regex) {
                if (this.lastOperatorWasNot()) {
                    return this.not(regex);
                } else {
                    this.isValue = regex;
                    return this;
                }
            }
    
            //
            private Pattern toPattern(String regex, @Nullable String options) {
                Assert.notNull(regex, "Regex string must not be null!");
                return Pattern.compile(regex, options == null ? 0 : BSON.regexFlags(options));
            }
    
            public Criteria withinSphere(Circle circle) {
                Assert.notNull(circle, "Circle must not be null!");
                this.criteria.put("$geoWithin", new GeoCommand(new Sphere(circle)));
                return this;
            }
    
            public Criteria within(Shape shape) {
                Assert.notNull(shape, "Shape must not be null!");
                this.criteria.put("$geoWithin", new GeoCommand(shape));
                return this;
            }
    
            //输出接近某一地理位置的有序文档
            public Criteria near(Point point) {
                Assert.notNull(point, "Point must not be null!");
                this.criteria.put("$near", point);
                return this;
            }
    
            //指定地理空间查询从最近到最远返回文档的点。 MongoDB 使用球面几何计算$nearSphere的距离
            public Criteria nearSphere(Point point) {
                Assert.notNull(point, "Point must not be null!");
                this.criteria.put("$nearSphere", point);
                return this;
            }
    
            //
            public Criteria intersects(GeoJson geoJson) {
                Assert.notNull(geoJson, "GeoJson must not be null!");
                this.criteria.put("$geoIntersects", geoJson);
                return this;
            }
    
            //创建一个地理空间标准,与nearSphere一起使用
            public Criteria maxDistance(double maxDistance) {
                if (!this.createNearCriteriaForCommand("$near", "$maxDistance", maxDistance) && !this.createNearCriteriaForCommand("$nearSphere", "$maxDistance", maxDistance)) {
                    this.criteria.put("$maxDistance", maxDistance);
                    return this;
                } else {
                    return this;
                }
            }
    
            //mongodb地理空间计算逻辑
            public Criteria minDistance(double minDistance) {
                if (!this.createNearCriteriaForCommand("$near", "$minDistance", minDistance) && !this.createNearCriteriaForCommand("$nearSphere", "$minDistance", minDistance)) {
                    this.criteria.put("$minDistance", minDistance);
                    return this;
                } else {
                    return this;
                }
            }
    
            //匹配查询
            public Criteria elemMatch(Criteria c) {
                this.criteria.put("$elemMatch", c.getCriteriaObject());
                return this;
            }
    
            //使用给定对象作为模式创建条件
            public Criteria alike(Example<?> sample) {
                this.criteria.put("$example", sample);
                this.criteriaChain.add(this);
                return this;
            }
    
            //创建一个criteria ($jsonSchema),根据MongoJsonSchema定义的给定结构匹配文档
            public Criteria andDocumentStructureMatches(MongoJsonSchema schema) {
                Assert.notNull(schema, "Schema must not be null!");
                Criteria schemaCriteria = new Criteria();
                schemaCriteria.criteria.putAll(schema.toDocument());
                return this.registerCriteriaChainElement(schemaCriteria);
            }
    
            public Criteria.BitwiseCriteriaOperators bits() {
                return new Criteria.BitwiseCriteriaOperatorsImpl(this);
            }
    
            //或者
    
            /**
             * Aggregation agg = Aggregation.newAggregation(
             *     Aggregation.match(new Criteria()
             *             .andOperator(Criteria.where("onlineTime").gt(new Date()))
             *             .orOperator( Criteria.where("offlineTime").gt(new Date())
             *     ,Criteria.where("offlineTime").exists(false) ))
             * @param criteria
             * @return
             */
            public Criteria orOperator(Criteria... criteria) {
                BasicDBList bsonList = this.createCriteriaList(criteria);
                return this.registerCriteriaChainElement((new Criteria("$or")).is(bsonList));
            }
    
            //非或者
            public Criteria norOperator(Criteria... criteria) {
                BasicDBList bsonList = this.createCriteriaList(criteria);
                return this.registerCriteriaChainElement((new Criteria("$nor")).is(bsonList));
            }
    
            //并且
            public Criteria andOperator(Criteria... criteria) {
                BasicDBList bsonList = this.createCriteriaList(criteria);
                return this.registerCriteriaChainElement((new Criteria("$and")).is(bsonList));
            }
    
            private Criteria registerCriteriaChainElement(Criteria criteria) {
                if (this.lastOperatorWasNot()) {
                    throw new IllegalArgumentException("operator $not is not allowed around criteria chain element: " + criteria.getCriteriaObject());
                } else {
                    this.criteriaChain.add(criteria);
                    return this;
                }
            }
    
            @Nullable
            public String getKey() {
                return this.key;
            }
    
            public Document getCriteriaObject() {
                if (this.criteriaChain.size() == 1) {
                    return ((Criteria)this.criteriaChain.get(0)).getSingleCriteriaObject();
                } else if (CollectionUtils.isEmpty(this.criteriaChain) && !CollectionUtils.isEmpty(this.criteria)) {
                    return this.getSingleCriteriaObject();
                } else {
                    Document criteriaObject = new Document();
                    Iterator var2 = this.criteriaChain.iterator();
    
                    while(var2.hasNext()) {
                        Criteria c = (Criteria)var2.next();
                        Document document = c.getSingleCriteriaObject();
                        Iterator var5 = document.keySet().iterator();
    
                        while(var5.hasNext()) {
                            String k = (String)var5.next();
                            this.setValue(criteriaObject, k, document.get(k));
                        }
                    }
    
                    return criteriaObject;
                }
            }
    
            protected Document getSingleCriteriaObject() {
                Document document = new Document();
                boolean not = false;
                Iterator var3 = this.criteria.entrySet().iterator();
    
                while(true) {
                    while(var3.hasNext()) {
                        Entry<String, Object> entry = (Entry)var3.next();
                        String key = (String)entry.getKey();
                        Object value = entry.getValue();
                        if (requiresGeoJsonFormat(value)) {
                            value = new Document("$geometry", value);
                        }
    
                        if (not) {
                            Document notDocument = new Document();
                            notDocument.put(key, value);
                            document.put("$not", notDocument);
                            not = false;
                        } else if ("$not".equals(key) && value == null) {
                            not = true;
                        } else {
                            document.put(key, value);
                        }
                    }
    
                    if (!StringUtils.hasText(this.key)) {
                        if (not) {
                            return new Document("$not", document);
                        }
    
                        return document;
                    }
    
                    Document queryCriteria = new Document();
                    if (!NOT_SET.equals(this.isValue)) {
                        queryCriteria.put(this.key, this.isValue);
                        queryCriteria.putAll(document);
                    } else {
                        queryCriteria.put(this.key, document);
                    }
    
                    return queryCriteria;
                }
            }
    
            private BasicDBList createCriteriaList(Criteria[] criteria) {
                BasicDBList bsonList = new BasicDBList();
                Criteria[] var3 = criteria;
                int var4 = criteria.length;
    
                for(int var5 = 0; var5 < var4; ++var5) {
                    Criteria c = var3[var5];
                    bsonList.add(c.getCriteriaObject());
                }
    
                return bsonList;
            }
    
            private void setValue(Document document, String key, Object value) {
                Object existing = document.get(key);
                if (existing == null) {
                    document.put(key, value);
                } else {
                    throw new InvalidMongoDbApiUsageException("Due to limitations of the com.mongodb.BasicDocument, you can't add a second '" + key + "' expression specified as '" + key + " : " + value + "'. Criteria already contains '" + key + " : " + existing + "'.");
                }
            }
    
            private boolean createNearCriteriaForCommand(String command, String operation, double maxDistance) {
                if (!this.criteria.containsKey(command)) {
                    return false;
                } else {
                    Object existingNearOperationValue = this.criteria.get(command);
                    if (existingNearOperationValue instanceof Document) {
                        ((Document)existingNearOperationValue).put(operation, maxDistance);
                        return true;
                    } else if (existingNearOperationValue instanceof GeoJson) {
                        Document dbo = (new Document("$geometry", existingNearOperationValue)).append(operation, maxDistance);
                        this.criteria.put(command, dbo);
                        return true;
                    } else {
                        return false;
                    }
                }
            }
    
            public boolean equals(Object obj) {
                if (this == obj) {
                    return true;
                } else if (obj != null && this.getClass().equals(obj.getClass())) {
                    Criteria that = (Criteria)obj;
                    if (this.criteriaChain.size() != that.criteriaChain.size()) {
                        return false;
                    } else {
                        for(int i = 0; i < this.criteriaChain.size(); ++i) {
                            Criteria left = (Criteria)this.criteriaChain.get(i);
                            Criteria right = (Criteria)that.criteriaChain.get(i);
                            if (!this.simpleCriteriaEquals(left, right)) {
                                return false;
                            }
                        }
    
                        return true;
                    }
                } else {
                    return false;
                }
            }
    
            private boolean simpleCriteriaEquals(Criteria left, Criteria right) {
                boolean keyEqual = left.key == null ? right.key == null : left.key.equals(right.key);
                boolean criteriaEqual = left.criteria.equals(right.criteria);
                boolean valueEqual = this.isEqual(left.isValue, right.isValue);
                return keyEqual && criteriaEqual && valueEqual;
            }
    
            //判断是否相等
            private boolean isEqual(Object left, Object right) {
                if (left == null) {
                    return right == null;
                } else if (Pattern.class.isInstance(left)) {
                    if (!Pattern.class.isInstance(right)) {
                        return false;
                    } else {
                        Pattern leftPattern = (Pattern)left;
                        Pattern rightPattern = (Pattern)right;
                        return leftPattern.pattern().equals(rightPattern.pattern()) && leftPattern.flags() == rightPattern.flags();
                    }
                } else {
                    return ObjectUtils.nullSafeEquals(left, right);
                }
            }
    
            public int hashCode() {
                int result = 17;
                int result = result + ObjectUtils.nullSafeHashCode(this.key);
                result += this.criteria.hashCode();
                result += ObjectUtils.nullSafeHashCode(this.isValue);
                return result;
            }
    
            private static boolean requiresGeoJsonFormat(Object value) {
                return value instanceof GeoJson || value instanceof GeoCommand && ((GeoCommand)value).getShape() instanceof GeoJson;
            }
    
            private static class BitwiseCriteriaOperatorsImpl implements Criteria.BitwiseCriteriaOperators {
                private final Criteria target;
    
                BitwiseCriteriaOperatorsImpl(Criteria target) {
                    this.target = target;
                }
    
                public Criteria allClear(int numericBitmask) {
                    return this.numericBitmask("$bitsAllClear", numericBitmask);
                }
    
                public Criteria allClear(String bitmask) {
                    return this.stringBitmask("$bitsAllClear", bitmask);
                }
    
                public Criteria allClear(List<Integer> positions) {
                    return this.positions("$bitsAllClear", positions);
                }
    
                public Criteria allSet(int numericBitmask) {
                    return this.numericBitmask("$bitsAllSet", numericBitmask);
                }
    
                public Criteria allSet(String bitmask) {
                    return this.stringBitmask("$bitsAllSet", bitmask);
                }
    
                public Criteria allSet(List<Integer> positions) {
                    return this.positions("$bitsAllSet", positions);
                }
    
                public Criteria anyClear(int numericBitmask) {
                    return this.numericBitmask("$bitsAnyClear", numericBitmask);
                }
    
                public Criteria anyClear(String bitmask) {
                    return this.stringBitmask("$bitsAnyClear", bitmask);
                }
    
                public Criteria anyClear(List<Integer> positions) {
                    return this.positions("$bitsAnyClear", positions);
                }
    
                public Criteria anySet(int numericBitmask) {
                    return this.numericBitmask("$bitsAnySet", numericBitmask);
                }
    
                public Criteria anySet(String bitmask) {
                    return this.stringBitmask("$bitsAnySet", bitmask);
                }
    
                public Criteria anySet(List<Integer> positions) {
                    return this.positions("$bitsAnySet", positions);
                }
    
                private Criteria positions(String operator, List<Integer> positions) {
                    Assert.notNull(positions, "Positions must not be null!");
                    Assert.noNullElements(positions.toArray(), "Positions must not contain null values.");
                    this.target.criteria.put(operator, positions);
                    return this.target;
                }
    
                private Criteria stringBitmask(String operator, String bitmask) {
                    Assert.hasText(bitmask, "Bitmask must not be null!");
                    this.target.criteria.put(operator, new Binary(Base64Utils.decodeFromString(bitmask)));
                    return this.target;
                }
    
                private Criteria numericBitmask(String operator, int bitmask) {
                    this.target.criteria.put(operator, bitmask);
                    return this.target;
                }
            }
    
            public interface BitwiseCriteriaOperators {
                Criteria allClear(int var1);
    
                Criteria allClear(String var1);
    
                Criteria allClear(List<Integer> var1);
    
                Criteria allSet(int var1);
    
                Criteria allSet(String var1);
    
                Criteria allSet(List<Integer> var1);
    
                Criteria anyClear(int var1);
    
                Criteria anyClear(String var1);
    
                Criteria anyClear(List<Integer> var1);
    
                Criteria anySet(int var1);
    
                Criteria anySet(String var1);
    
                Criteria anySet(List<Integer> var1);
            }
        }
    }
    
    展开全文
  • Criteria使用方法

    2012-03-26 23:19:09
    介绍了hibernate中 Criteria接口在实际开发过程中的常见使用方法及技巧
  • Criteria连表查询

    2012-07-29 11:31:52
    Hibernate中的Criteria连表查询,包括单表属性查询,多表内连,以及左外连接查询
  • MockDatabase-开发 一个模拟数据库,用于对Hibernate Criteria,Query和SQLQuery进行单元测试。
  • 条件必须可以自动生成,再网上找了相关资料,一种是领域驱动设计中的规约Criteria 一种是hibernate中的criteria。还有apache的也有。 我设想是用纯JDBC 来处理,兼部分mybatis。 我尝试着模仿hibernate的criteria...
  • Criteria用法

    千次阅读 2018-11-01 18:02:12
    原文:...   criteria 英[kraɪˈtɪərɪə] 美[kraɪˈtɪrɪə] ...1,Criteria Hibernate 设计了 CriteriaSpecification 作为 Criteria 的父接口,下面提供了 Criteria和DetachedCrit...

    原文:http://blog.csdn.net/saindy5828/article/details/16893257

     

    criteria

    英[kraɪˈtɪərɪə]

    美[kraɪˈtɪrɪə]

    标准

    1,Criteria
    Hibernate 设计了 CriteriaSpecification 作为 Criteria 的父接口,下面提供了 Criteria和DetachedCriteria 。

    2,DetachedCriteria
    Spring 的框架提供了getHibernateTemplate
    ().findByCriteria(detachedCriteria) 方法可以很方便地根据DetachedCriteria 来返回查询结
    果。DetachedCriteria 提供了 2 个静态方法 forClass(Class) 或 forEntityName(Name)
    进行DetachedCriteria 实例的创建。

    3,Criteria 和 DetachedCriteria
    Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样, Criteria 是在线的,是由
     Hibernate Session 进行创建的;而 DetachedCriteria 是离线的,创建时无需Session。

    使用DetchedCriteria

    Criteria与Session绑定,其生命周期跟随着Session结束而结束,使用Criteria时进行查询时,每次都要于执行时期动态建立物件,并加入各种查询条件,随着Session的回收,Criteria也跟着回收。

    Criteria 和 DetachedCriteria 均可使用 Criterion 和 Projection 设置查询条件。可以设
    置 FetchMode( 联合查询抓取的模式 ) ,设置排序方式。对于 Criteria 还可以设置 FlushModel
    (冲刷 Session 的方式)和 LockMode (数据库锁模式)。
    下面对 Criterion 和 Projection 进行详细说明。

    4,Criterion 和 Projection
         a,概念
    Criterion 是 Criteria 的查询条件。Criteria 提供了 add(Criterion criterion) 方法来
    添加查询条件。
    Criterion 接口的主要实现包括: Example 、 Junction 和 SimpleExpression 。
    Junction 的实际使用是它的两个子类 conjunction 和 disjunction ,分别是使用 AND 和 OR 操
    作符进行来联结查询条件集合。
         b,创建
    Criterion 的实例可以通过 Restrictions 工具类来创建,Restrictions 提供了大量的静态
    方法,如 eq (等于)、 ge (大于等于)、 between 等来方法的创建 Criterion 查询条件
    (SimpleExpression 实例)。除此之外, Restrictions 还提供了方法来创建 conjunction 和
    disjunction 实例,通过往该实例的 add(Criteria) 方法来增加查询条件形成一个查询条件集合

    至于 Example 的创建有所不同, Example 本身提供了一个静态方法 create(Object
    entity) ,即根据一个对象(实际使用中一般是映射到数据库的对象)来创建。然后可以设置一些
    过滤条件:
    Example exampleUser =Example.create(u)
    .ignoreCase() // 忽略大小写
    .enableLike(MatchMode.ANYWHERE);
    // 对 String 类型的属性,无论在那里值在那里都匹配。相当于 %value%
    Project 主要是让 Criteria 能够进行报表查询,并可以实现分组。 Project 主要有
    SimpleProjection 、 ProjectionList 和 Property 三个实现。其中 SimpleProjection 和
    ProjectionList 的实例化是由内建的 Projections 来完成,如提供的 avg 、 count 、 max 、
    min 、 sum 可以让开发者很容易对某个字段进行统计查询。
      Property 是对某个字段进行查询条件的设置,如通过Porperty.forName(“color”).in
    (new String[]{“black”,”red”,”write”}); 则可以创建一个 Project 实例。通过
    criteria 的 add(Project) 方法加入到查询条件中去。

    5,应用
    使用 Criteria 进行查询,主要要清晰的是 Hibernate 提供了那些类和方法来满足开发中查
    询条件的创建和组装,下面介绍几种用法:
    1. 创建一个Criteria 实例
    org.hibernate.Criteria接口表示特定持久类的一个查询。Session是 Criteria实例的工厂。
    Criteria crit = sess.createCriteria(Cat.class);
    crit.setMaxResults(50);
    List cats = crit.list();

    2. 限制结果集内容
    一个单独的查询条件是org.hibernate.criterion.Criterion 接口的一个实例。

    org.hibernate.criterion.Restrictions类 定义了获得某些内置Criterion类型的工厂方法。
    List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add( Restrictions.between("weight", minWeight, maxWeight) )
    .list();

    约束可以按逻辑分组。

    List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add( Restrictions.or(
      Restrictions.eq( "age", new Integer(0) ),
      Restrictions.isNull("age")
    ) )
    .list();

    List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.in( "name", new String[] { "Fritz", "Izi", "Pk" } ) )
    .add( Restrictions.disjunction()
      .add( Restrictions.isNull("age") )
      .add( Restrictions.eq("age", new Integer(0) ) )
      .add( Restrictions.eq("age", new Integer(1) ) )
      .add( Restrictions.eq("age", new Integer(2) ) )
    ) )

    .list();

    限定查询笔数  分页查询

    Criteria的setMaxResults()方法可以限定查询回来的笔数,如果配合setFirstResult()设定传回查询结果第一笔资料的位置,就可以实现简单的分页,例如传回第51笔之后的50笔资料(如果有的话):

    Criteria criteria = session.createCriteria(User.class);
    criteria.setFirstResult(51);
    criteria.setMaxResults(50);
    List users = criteria.list();


    Hibernate提供了相当多的内置criterion类型(Restrictions 子类), 但是尤其有用的是可以允许

    你直接使用SQL。

    List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.sql("lower({alias}.name) like lower(?)", "Fritz%",Hibernate.STRING) )
    .list();

    {alias}占位符应当被替换为被查询实体的列别名。

    Property实例是获得一个条件的另外一种途径。你可以通过调用Property.forName() 创建一个

     

    使用add()方法加入条件时,预设是使用and来组合条件,如果要用or的方式来组合条件,则可以使用Restrictions.or()方法

     

    Restrictions的几个常用限定查询方法如下表所示:
     

    QBC常用限定方法

    Restrictions.eq --> equal,等于.

    Restrictions.allEq --> 参数为Map对象,使用key/value进行多个等于的比对,相当于多个Restrictions.eq 的效果

    Restrictions.gt --> great-than > 大于

    Restrictions.ge --> great-equal >= 大于等于

    Restrictions.lt --> less-than, < 小于

    Restrictions.le --> less-equal <= 小于等于

    Restrictions.between --> 对应SQL的between子句

    Restrictions.like --> 对应SQL的LIKE子句

    Restrictions.in --> 对应SQL的in子句

    Restrictions.and --> and 关系

    Restrictions.or --> or 关系

    Restrictions.isNull --> 判断属性是否为空,为空则返回true  相当于SQL的 is null

    Restrictions.isNotNull --> 与isNull相反     相当于SQL的 is not null

    Restrictions.sqlRestriction --> SQL限定的查询

    Order.asc --> 根据传入的字段进行升序排序

    Order.desc --> 根据传入的字段进行降序排序

    MatchMode.EXACT --> 字符串精确匹配.相当于"like 'value'"

    MatchMode.ANYWHERE --> 字符串在中间匹配.相当于"like '%value%'"

    MatchMode.START --> 字符串在最前面的位置.相当于"like 'value%'"

    MatchMode.END --> 字符串在最后面的位置.相当于"like '%value'"

     


    Property。

    Property age = Property.forName("age");
    List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.disjunction()
      .add( age.isNull() )
      .add( age.eq( new Integer(0) ) )
      .add( age.eq( new Integer(1) ) )
      .add( age.eq( new Integer(2) ) )
    ) ) 
    .add( Property.forName("name").in( new String[] { "Fritz", "Izi", "Pk" } ) )

    .list();

     

    多个OR查询

    Restrictions.or(Restrictions.like(),Restrictions.or(Restrictions.like,........))
    里面的or可以无限加的
     

    Criteria criteria = session.createCriteria(Film.class);
            List<Film> list = criteria.add(
                Restrictions.or(Restrictions.like("description", key,MatchMode.ANYWHERE),
                Restrictions.or(Restrictions.like("name", key,MatchMode.ANYWHERE),
                Restrictions.or( Restrictions.like("direct", key,MatchMode.ANYWHERE),
                Restrictions.or(Restrictions.like("mainplay",key,MatchMode.ANYWHERE),
                            Restrictions.like("filearea", key,MatchMode.ANYWHERE)))))).list();


    3. 结果集排序
    你可以使用org.hibernate.criterion.Order来为查询结果排序。

    List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "F%")
    .addOrder( Order.asc("name") )
    .addOrder( Order.desc("age") )
    .setMaxResults(50)
    .list();

    List cats = sess.createCriteria(Cat.class)
    .add(Restrictions.liek("name", "F",MatchMode.ANYWHERE));
    .addOrder( Property.forName("name").asc() )
    .addOrder( Property.forName("age").desc() )
    .setMaxResults(50)
    .list();

    4. 关联 
    你可以使用createCriteria()非常容易的在互相关联的实体间建立 约束。

    List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "F%")
    .createCriteria("kittens")
      .add( Restrictions.like("name", "F%")
    .list();


    注意第二个 createCriteria()返回一个新的 Criteria实例,该实例引用kittens 集合中的元素。
    接下来,替换形态在某些情况下也是很有用的。

    List cats = sess.createCriteria(Cat.class)
    .createAlias("kittens", "kt")
    .createAlias("mate", "mt")
    .add( Restrictions.eqProperty("kt.name", "mt.name") )
    .list();


    (createAlias()并不创建一个新的 Criteria实例。)
    Cat实例所保存的之前两次查询所返回的kittens集合是 没有被条件预过滤的。如果你希望只获得

    符合条件的kittens, 你必须使用returnMaps()。

    List cats = sess.createCriteria(Cat.class)
    .createCriteria("kittens", "kt")
    .add( Restrictions.eq("name", "F%") )
    .returnMaps()
    .list();
    Iterator iter = cats.iterator();
    while ( iter.hasNext() ) {
    Map map = (Map) iter.next();
    Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);
    Cat kitten = (Cat) map.get("kt");


    5. 动态关联抓取
    你可以使用setFetchMode()在运行时定义动态关联抓取的语义。

    List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .setFetchMode("mate", FetchMode.EAGER)
    .setFetchMode("kittens", FetchMode.EAGER)
    .list();

    这个查询可以通过外连接抓取mate和kittens。

    6. 查询示例
    org.hibernate.criterion.Example类允许你通过一个给定实例 构建一个条件查询。

    Cat cat = new Cat();
    cat.setSex('F');
    cat.setColor(Color.BLACK);
    List results = session.createCriteria(Cat.class)
    .add( Example.create(cat) )
    .list();


    版本属性、标识符和关联被忽略。默认情况下值为null的属性将被排除。
    可以自行调整Example使之更实用。

    Example example = Example.create(cat)
    .excludeZeroes()     //exclude zero valued properties
    .excludeProperty("color") //exclude the property named "color"
    .ignoreCase()       //perform case insensitive string comparisons
    .enableLike();       //use like for string comparisons
    List results = session.createCriteria(Cat.class)
    .add(example)
    .list();


    甚至可以使用examples在关联对象上放置条件。

    List results = session.createCriteria(Cat.class)
    .add( Example.create(cat) )
    .createCriteria("mate")
      .add( Example.create( cat.getMate() ) )
    .list();


    7. 投影(Projections)、聚合(aggregation)和分组(grouping)
    org.hibernate.criterion.Projections是 Projection 的实例工厂。我们通过调用

    setProjection()应用投影到一个查询。

    List results = session.createCriteria(Cat.class)
    .setProjection( Projections.rowCount() )
    .add( Restrictions.eq("color", Color.BLACK) )
    .list();

    List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
      .add( Projections.rowCount() )
      .add( Projections.avg("weight") )
      .add( Projections.max("weight") )
      .add( Projections.groupProperty("color") )

    .list();


    在一个条件查询中没有必要显式的使用 "group by" 。某些投影类型就是被定义为 分组投影,他

    们也出现在SQL的group by子句中。

    可以选择把一个别名指派给一个投影,这样可以使投影值被约束或排序所引用。下面是两种不同的

    实现方式: 

    List results = session.createCriteria(Cat.class)
    .setProjection( Projections.alias( Projections.groupProperty("color"), "colr" ) )
    .addOrder( Order.asc("colr") )
    .list();



    List results = session.createCriteria(Cat.class)
    .setProjection( Projections.groupProperty("color").as("colr") )
    .addOrder( Order.asc("colr") )
    .list();

    alias()和as()方法简便的将一个投影实例包装到另外一个 别名的Projection实例中。简而言之,

    当你添加一个投影到一个投影列表中时 你可以为它指定一个别名:

    List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
      .add( Projections.rowCount(), "catCountByColor" )
      .add( Projections.avg("weight"), "avgWeight" )
      .add( Projections.max("weight"), "maxWeight" )
      .add( Projections.groupProperty("color"), "color" )

    .addOrder( Order.desc("catCountByColor") )
    .addOrder( Order.desc("avgWeight") )
    .list();


    List results = session.createCriteria(Domestic.class, "cat")
    .createAlias("kittens", "kit")
    .setProjection( Projections.projectionList()
      .add( Projections.property("cat.name"), "catName" )
      .add( Projections.property("kit.name"), "kitName" )

    .addOrder( Order.asc("catName") )
    .addOrder( Order.asc("kitName") )
    .list();


    也可以使用Property.forName()来表示投影:

    List results = session.createCriteria(Cat.class)
    .setProjection( Property.forName("name") )
    .add( Property.forName("color").eq(Color.BLACK) )
    .list();
    List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
      .add( Projections.rowCount().as("catCountByColor") )
      .add( Property.forName("weight").avg().as("avgWeight") )
      .add( Property.forName("weight").max().as("maxWeight") )
      .add( Property.forName("color").group().as("color" )

    .addOrder( Order.desc("catCountByColor") )
    .addOrder( Order.desc("avgWeight") )
    .list();


    8. 离线(detached)查询和子查询
    DetachedCriteria类使你在一个session范围之外创建一个查询,并且可以使用任意的 Session来

    执行它。 

    DetachedCriteria query = DetachedCriteria.forClass(Cat.class)
    .add( Property.forName("sex").eq('F') );
    //创建一个Session
    Session session = .;
    Transaction txn = session.beginTransaction();
    List results = query.getExecutableCriteria(session).setMaxResults(100).list();
    txn.commit();
    session.close();


    DetachedCriteria也可以用以表示子查询。条件实例包含子查询可以通过 Subqueries或者
    Property获得。

    DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)
    .setProjection( Property.forName("weight").avg() );
    session.createCriteria(Cat.class)
    .add( Property.forName("weight).gt(avgWeight) )
    .list();
    DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)
    .setProjection( Property.forName("weight") );
    session.createCriteria(Cat.class)
    .add( Subqueries.geAll("weight", weights) )
    .list();

    相互关联的子查询也是有可能的:

    DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, "cat2")
    .setProjection( Property.forName("weight").avg() )
    .add( Property.forName("cat2.sex").eqProperty("cat.sex") );
    session.createCriteria(Cat.class, "cat")
    .add( Property.forName("weight).gt(avgWeightForSex) )
    .list();


    补充:

    criteria.add(Expression.eq("status",new Integer(status)));

    展开全文
  • 执行标准模式 探索避免基于多个检查选择对象的一般模式
  • 易于使用......只需输入分子......分母并获得劳斯阵列......它甚至告诉没有。 右手极的礼物......
  • Fuzzy Multi-Criteria Decision Making Theory and Applications with Recent Developments 模糊多准则决策理论及其应用的最新进展
  • JPA 动态查询 Criteria JPQL 语法详解 Java Persistence Query Language
  • 这个案例是根据分组查询,并且得到每组的条数,不懂得可以q我:1710086675,欢迎认识更多新朋友
  • JPA-Criteria模块实现了JPA的Criteria API,但由Blaze-Persistence Core API支持,因此您可以从CriteriaQuery对象中获取查询构建器。 借助Spring Data或DeltaSpike Data集成,您可以轻松地在现有存储库中使用Blaze...
  • NULL 博文链接:https://beisicao.iteye.com/blog/955674
  • Hibernate-Criteria_模糊查询
  • 01_2006_multi-criteria group consensus under linear cost opinion elasticity原文
  • Multi-Criteria Chinese Word Segmentationwith Transformer 译文 谷歌翻译版,仅供参考

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 82,980
精华内容 33,192
关键字:

criteria