SpringBoot整合MongoDB，使用mongoTemplate实现高级查询

亦凉 2022-05-15 10:20 890阅读 0赞

### **一、前言** ###

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

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

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

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

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

个人建议点击[这里][Link 1]，花三十分钟初步了解一下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实现多条件加分组查询][mongoTemplate] **

希望能够帮助到你

over

[Link 1]: http://www.runoob.com/mongodb
[mongoTemplate]: https://blog.csdn.net/qq_41402200/article/details/84651977