MongoTemplate 分组分页复合条件查询

一、前言

最近项目使用MongoDB作为数据主要存取的地方

又是第一次接触MongoDB，也是踩了不少坑...

维护数据无非就是增删改查，而里面最复杂的就是查询了

所以来总结一下有关MongoDB的查询方法

当然如果你在此之前你对MongoDB一点都不了解的话

个人建议点击这里，花三十分钟初步了解一下MongoDB

ok，正文开始

二、正文

1.使用mongoTemplate对象常常会调用如下两种方法

① findAll(Class<T> entityClass, String collectionName)

分析：此方法入两个参数，前者entityClass是类类型 即某个实体类，后者collectionName是String类型

即MongoDB的某个集合名，那么这个方法很明显就是根据入参的集合名称到MongoDB中查询并

转换为指定的类类型。

注：entityClass参数的写法应为 xxx.class ，如Student学生类：Student.class

② find(Query query, Class<T> entityClass, String collectionName)

分析：此方法三个参数，与①不同的是，多了第一个query参数，这个query就是用来封装查询条件的

2.Query的使用（这里以我自己的一个业务逻辑角度写的，下面有这个逻辑的连贯代码）

① 首先在这个方法里面需要定义如下两个对象

//用来封装所有条件的对象
Query query = new Query();
//用来构建条件
Criteria criteria = new Criteria();
② 先来一个模糊查询的条件

/**
* 这里使用的正则表达式的方式
* 第二个参数Pattern.CASE_INSENSITIVE是对字符大小写不明感匹配
*/
Pattern pattern = Pattern.compile("^.*"+这里拼接你的查询条件字符串+".*$", Pattern.CASE_INSENSITIVE);
/**
* criteria.and().regex() 在这里是构建了一个模糊查询的条件，并且用 'and' 相连
* query.addCriteria 把条件封装起来
*/
query.addCriteria(criteria.and("这里填写你MongoDB集合中的key").regex(pattern));
③ 再来一个精准查询的条件

/**
* criteria.and().is() 在这里是构建了一个精准查询的条件，并且用 'and' 相连
* query.addCriteria 把条件封装起来
*/
query.addCriteria(criteria.and("你MongoDB中的key").is("你的条件");
④ 来一个在某个值之间的条件（类似于sql中的BETWEEN ... AND）

如果在这里，模仿精准查询，把 is() 方法换成 gt() 或 lt() ，然后运行，肯定会报错，具体的

错误信息我没有记录下来，大概意思就是同一个字段连续出现了两次

这里需要用到 andOperator 方法，如下

//大于方法
Criteria gt = Criteria.where("你MongoDB中的key").gt("你的条件");
//小于方法
Criteria lt = Criteria.where("你MongoDB中的key").lt("你的条件");
/**
* new Criteria().andOperator(gt,lt) 把上面的大于和小于放在一起，注意上面两个key一定是一样的
* andOperator() 这个方法就是关键的方法了，把同key的多个条件组在一起
* 但是 andOperator() 有个很坑的地方就是，在一个query中只能出现一次
* 如果你有很固定很明确的入参，那还好，直接调用一次 andOperator()
* 如果是多个key需要多个条件，而且条件数量还是动态的，怕不是魔鬼吧...
*/
query.addCriteria(new Criteria().andOperator(gt,lt));
⑤ 当得知一个query中只能存在一个 andOperator() 方法的时候，就应该把思考方向放在如何

把不确定个数的 Criteria 对象放入一个 andOperator() 方法中，这里是把多个 Criteria 对象用

逗号分隔的，其实 andOperator() 方法还可以入参 Criteria[] 数组

定义数组的话，那么问题又来了，如何确定数组的长度...即使定义了一个 [1024] 这样长度的数组

那如果逻辑中还有 if 判断隔开了，那数组的下标如何保证连续不错误，于是就又定义了一个List<Criteria>

泛型集合，先往集合里面存，完事了后就把集合遍历放入数组，最后把数组入参到 andOperator() 方法

//定义一个泛型集合，类型为 Criteria
List<Criteria> criteriaList = new ArrayList<>();
//定义一个无长度的数组，类型为 Criteria
Criteria[] criteriaArray = {};
//往集合里面添加条件对象
if(你的逻辑){
//大于方法
Criteria gt = Criteria.where("你MongoDB中的key").gt("你的条件");
//小于方法
Criteria lt = Criteria.where("你MongoDB中的key").lt("你的条件");
if(gt!=null && lt!=null){
criteriaList.add(gt);
criteriaList.add(lt);
}else if(gt!=null){
query.addCriteria(gt);
}else if(lt!=null){
query.addCriteria(lt);
}
}
//是否有条件
if(criteriaList.size()>0){
//把无长度的数组实例出来，长度就位集合的个数
criteriaArray = new Criteria[criteriaList.size()];
for(int i = 0 ; i < criteriaList.size() ; i++){
//把集合中的条件对象全部存入数组中
criteriaArray[i] = criteriaList.get(i);
}
}
//最后把数组入参到 andOperator() 方法中
query.addCriteria(new Criteria().andOperator(criteriaArray));
⑥ 最后一步，调用 mongoTemplate 对象的 find() 方法

/**
* xxxxx 即为实体类，也是此方法返回泛型类型
* 如 xxxxx 为 Student （Student.class），那么此方法就会返回 List<Student>
*/
mongoTemplate.find(query,xxxxx.class,collectionName);
 3. 连贯代码实例，因为没有写demo，代码中有很多敏感信息，我就替换成文字说明，但是我会尽量

写的通俗易懂

/**
* 定义了一个方法，返回类型就是等会最后入参的 xxxxx.class 类型的泛型集合
* 参数
* 条件 --- > 条件集合
* collectionName --- > MongoDB的集合名称
*/
public List<返回类型> getXxxxxByCollectionNameAndCondition(List<条件类型> 条件,String collectionName) throws Exception{

//用来封装所有条件的对象
Query query = new Query();
//用来构建条件
Criteria criteria = new Criteria();

/**
* 这里最多会出现两个多条件的key
* 所以我定义了两个集合和两个数组
*/

//定义一个泛型集合，类型为 Criteria
List<Criteria> criteriaList_first = new ArrayList<>();
//定义一个无长度的数组，类型为 Criteria
Criteria[] criteriaArray_first = {};

//定义一个泛型集合，类型为 Criteria
List<Criteria> criteriaList_second = new ArrayList<>();
//定义一个无长度的数组，类型为 Criteria
Criteria[] criteriaArray_second = {};

//遍历所有条件
for(条件类型 条件对象 : 条件){
if(条件对象){
//往集合里面添加条件对象
if(你的逻辑){
//大于方法
Criteria gt = Criteria.where("你MongoDB中的key").gt("你的条件");
//小于方法
Criteria lt = Criteria.where("你MongoDB中的key").lt("你的条件");
if(gt!=null && lt!=null){
criteriaList_first.add(gt);
criteriaList_first.add(lt);
}else if(gt!=null){
query.addCriteria(gt);
}else if(lt!=null){
query.addCriteria(lt);
}
}else if(你的逻辑){
//大于方法
Criteria gt = Criteria.where("你MongoDB中的key").gt("你的条件");
//小于方法
Criteria lt = Criteria.where("你MongoDB中的key").lt("你的条件");
if(gt!=null && lt!=null){
criteriaList_second.add(gt);
criteriaList_second.add(lt);
}else if(gt!=null){
query.addCriteria(gt);
}else if(lt!=null){
query.addCriteria(lt);
}
}else if(你的逻辑){
...
}
}else if(其他条件对象){
...
}

}

//是否有条件
if(criteriaList_first.size()>0){
//把无长度的数组实例出来，长度就位集合的个数
criteriaArray_first = new Criteria[criteriaList_first.size()];
for(int i = 0 ; i < criteriaList_first.size() ; i++){
//把集合中的条件对象全部存入数组中
criteriaArray_first[i] = criteriaList_first.get(i);
}
}

//是否有条件
if(criteriaList_second.size()>0){
//把无长度的数组实例出来，长度就位集合的个数
criteriaArray_second = new Criteria[criteriaList_second.size()];
for(int i = 0 ; i < criteriaList_second.size() ; i++){
//把集合中的条件对象全部存入数组中
criteriaArray_second[i] = criteriaList_second.get(i);
}
}

//如果两个参数数组中任意一个存在值
if(criteriaArray_first.length > 0 || criteriaArray_second.length > 0){
//调用合并数组方法，并入参到query中（合并数组的方法紧接着下面写了）
query.addCriteria(new Criteria().andOperator(this.concat(criteriaArray_first,criteriaArray_second)));
}

//调用 find() 方法并返回
return mongoTemplate.find(query,返回类型.class,collectionName);

}

/**
* 把两个数组合并为一个数组
*/
private Criteria[] concat(Criteria[] criteria1 , Criteria[] criteria2){
Criteria[] c= new Criteria[criteria1.length+criteria2.length];
System.arraycopy(criteria1, 0, c, 0, criteria1.length);
System.arraycopy(criteria2, 0, c, criteria1.length, criteria2.length);
return c;
}