mongodb去重分页查询支持排序

桃扇骨 2022-11-14 11:52 283阅读 0赞

需求：  
查询一张表，根据某字段去重后返回指定信息，支持分页，排序。

逻辑：  
1，match查询符合条件的数据  
2，利用分组进行去重  
3，返回全部字段信息  
4，排序  
5，分页

mongodb原生语句实现  
方法1 返回指定字段

db.getCollection('表名').aggregate([
    {
        "$match" : {"failure":{$in:["具体失效文件"]}}    //查询数组类型字段，根据需求可更改
    },
    {  
         "$group" : {
             "_id": { "lawId": "$lawId" },     //需要去重的字段
             "id":{"$first" :"$_id"},              
             "lawId": {"$first" :"$lawId"},
             "date":{"$first" :"$date"}
             }
    },
    {
        "$project": {               //设置返回字段，建立在group基础上
           "_id": 1,
             "id":1,
             "lawId": 1,
             "date":1
        }
    },
    {"$sort": {"date":-1}},            //排序
    { "$skip":0 }, { "$limit":10 }     //分页
    ])

方法2 返回全部字段

db.getCollection('表名').aggregate([
    {
        "$match" : {"failure":{$in:["具体失效文件"]}}      //查询数组类型字段，根据需求可更改
    },
    {  
         "$group" : {
             "_id": { "lawId": "$lawId" },     //需要去重的字段
             "data":{"$first" :"$$ROOT"}      //返回全部字段
             }
    },
    {
        "$project": {
          "data":1,                         //返回全部字段
        }
    },
    {"$sort": {"data.dae":-1}},             //根据date.dae字段排序
    { "$skip":0 }, { "$limit":10 }          //分页
    ])

java代码MongoTemplate实现方法2

/**
         * 处理group时使用流式操作，务必注意顺序
         * params 查询条件
         * page  分页信息
         * sortKey 排序值
         * direction 升序还是降序
         * filedsNameList 自定义返回的字段
         * groupKey 需要去重的字段
         */
        protected Aggregation getGeneralAggregation(Map<String, Object> params,
                                                    Page<T> page,
                                                    String sortKey,
                                                    Direction direction,
                                                    List<String> filedsNameList,
                                                    String groupKey) {
            List<AggregationOperation> aggOptions = new ArrayList<>();
            { // 添加查询条件
                List<Criteria> criteriaList = new ArrayList<>();
                if (params != null) {
                    logger.debug("查询参数：" + params);
                    for (Map.Entry<String, Object> entry : params.entrySet()) {
                        if (entry.getKey() != null && entry.getValue() != null) {
                            switch (entry.getValue().getClass().getName()) {
                            case "java.util.ArrayList":
                            case "java.util.LinkedList":
                                criteriaList.add(Criteria.where(entry.getKey()).in(entry.getValue()));
                                break;
                            default:
                                criteriaList.add(Criteria.where(entry.getKey()).is(entry.getValue()));
                                break;
                            }
                        }
                    }
                }
                aggOptions.add(Aggregation.match(new Criteria().andOperator(criteriaList.toArray(new Criteria[criteriaList.size()]))));
            }
            { // 分组
                if (StringUtils.isNotEmpty(groupKey)) {
                    aggOptions.add(new GroupOperation(Aggregation.fields(groupKey)).first("$$ROOT")
                                                                                   .as("data"));
                }
            }
            { // 排序
                sortKey = "data." + (sortKey == null ? "id" : sortKey);
                List<Order> orders = new ArrayList<Order>();
                orders.add(new Order(direction, sortKey));
                Sort sort = Sort.by(orders);
                aggOptions.add(Aggregation.sort(sort));
            }
            { // 分页
                if (page != null) {
                    aggOptions.add(Aggregation.skip((long) (page.getPageNumber() > 0
                            ? (page.getPageNumber() - 1) * page.getPageSize()
                            : 0)));
                    aggOptions.add(Aggregation.limit(page.getPageSize()));
                }
            }
            { // 添加返回field
                if (CollectionUtils.isNotEmpty(filedsNameList)) {
                    filedsNameList = filedsNameList.stream()
                                                   .map(str -> "data." + str)
                                                   .collect(Collectors.toList());
                    aggOptions.add(Aggregation.project(filedsNameList.toArray(new String[filedsNameList.size()])));
                }
            }
            Aggregation aggregation = Aggregation.newAggregation(aggOptions);
            return aggregation;
        }

然后调用

//agg是上面代码返回的Aggregation
     AggregationResults<T> list getMongoTemplate().aggregate(agg, getClassT(),getClassT());
    list.getMappedResults();  //获取结果