一、前言

最近项目使用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;
}

4. 到此全部代码已经写完了

 

使用mongoTemplate实现多条件加分组查询 

 

希望能够帮助到你

over