spring数据mongodb如何实现聚合分页

Question

在spring数据mongodb中使用mongotemplate或mongorepository，如何实现聚合分页

Answer 1

您可以使用 MongoTemplate

org.spring.framework.data.mongodb.core.aggregation.Aggregation#skip
        and 
org.springframework.data.mongodb.core.aggregation.Aggregation#limit

Aggregation agg = newAggregation(
        project("tags"),
        skip(10),
        limit(10)
);

AggregationResults<TagCount> results = mongoTemplate.aggregate(agg, "tags", TagCount.class);
List<TagCount> tagCount = results.getMappedResults();

Answer 2

除了之外，您还可以使用 Pageable 类作为结果。

public Page<UserListItemView> list(final Pageable pageable) {

    final Aggregation agg = newAggregation(
        skip(pageable.getPageNumber() * pageable.getPageSize()),
        limit(pageable.getPageSize())
    );

    final List<UserListItemView> results = mongoTemplate
        .aggregate(agg, User.class, UserListItemView.class)
        .getMappedResults();

    return new PageImpl<>(results, pageable, results.size())
}

Answer 3

这是对旧 post 的回答，但我会提供一个答案，以防其他人在搜索类似内容时出现。

在之前的的基础上，将 results.size() 作为 PageImpl 构造函数中 "total" 字段的值将不会使分页工作正常进行，好吧，你期望分页工作。它将总大小设置为页面大小每次，因此，您需要找出您的查询的实际结果总数 return:

public Page<UserListItemView> list(final Pageable pageable) {
    long total = getCount(<your property name>, <your property value>);

    final Aggregation agg = newAggregation(
        skip(pageable.getPageNumber() * pageable.getPageSize()),
        limit(pageable.getPageSize())
    );

    final List<UserListItemView> results = mongoTemplate
        .aggregate(agg, User.class, UserListItemView.class)
        .getMappedResults();

    return new PageImpl<>(results, pageable, total);
}

现在，那么，获得结果总数的最佳方法是另一个问题，这也是我目前正在努力弄清楚的问题。我尝试（并且有效）的方法几乎运行相同的聚合两次，（一次获取总计数，再次获取分页的实际结果）但仅使用 MatchOperation 后跟 GroupOperation获取计数：

private long getCount(String propertyName, String propertyValue) {
    MatchOperation matchOperation = match(Criteria.where(propertyName).is(propertyValue));
    GroupOperation groupOperation = group(propertyName).count().as("count");
    Aggregation aggregation = newAggregation(matchOperation, groupOperation);
    return mongoTemplate.aggregate(aggregation, Foo.class, NumberOfResults.class).getMappedResults().get(0).getCount();
}

private class NumberOfResults {
    private int count;

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

运行两次几乎相同的查询似乎有点低效，但是如果你要对结果进行分页，可分页对象必须知道结果的总数如果您真的希望它表现得像分页，结果。如果有人可以改进我的方法来获得结果总数，那就太棒了！

Edit：这也会提供计数，而且更简单，因为你不需要包装对象来保存结果，所以你可以替换之前的整个代码块这个：

private long getCount(String propertyName, String propertyValue) {
    Query countQuery = new Query(Criteria.where(propertyName).is(propertyValue));
    return mongoTemplate.count(countQuery, Foo.class);
}

Answer 4

根据答案我为 Java 编写了代码。

使用聚合组获取数据的计数和数组以及其他分页信息。

    AggregationOperation group = Aggregation.group().count().as("total")
            .addToSet(pageable.getPageNumber()).as("pageNumber")
            .addToSet(pageable.getPageSize()).as("pageSize")
            .addToSet(pageable.getOffset()).as("offset")
            .push("$$ROOT").as("data");

使用Aggregation工程，根据分页信息进行切片。

    AggregationOperation project = Aggregation.project()
            .andInclude("pageSize", "pageNumber", "total", "offset")
            .and(ArrayOperators.Slice.sliceArrayOf("data").offset((int) pageable.getOffset()).itemCount(pageable.getPageSize()))
            .as("data");

使用mongo模板聚合。

    Aggregation aggr = newAggregation(group, project);
    CustomPage page = mongoTemplate.aggregate(aggregation, Foo.class, CustomPage.class).getUniqueMappedResult();

创建自定义页面。

    public class CustomPage {
        private long pageSize;
        private long pageNumber;
        private long offset;
        private long total;
        private List<Foo> data;
    }

Answer 5

对于 return 具有正确的可分页对象值的分页对象，我发现这是最好和最简单的方法。

Aggregation aggregation = Aggregation.newAggregation(Aggregation.match(Criteria.where("type").is("project")),
                        Aggregation.group("id").last("id").as("id"), Aggregation.project("id"),
                        Aggregation.skip(pageable.getPageNumber() * pageable.getPageSize()),
                        Aggregation.limit(pageable.getPageSize()));


    PageableExecutionUtils.getPage(mongoTemplate.aggregate(aggregation, Draft.class, Draft.class).getMappedResults(), pageable,() -> mongoTemplate.count(Query.of(query).limit(-1).skip(-1), Draft.class));

Answer 6

这是我的通用解决方案：

public Page<ResultObject> list(Pageable pageable) {
    // build your main stages
    List<AggregationOperation> mainStages = Arrays.asList(match(....), group(....));
    return pageAggregation(pageable, mainStages, "target-collection", ResultObject.class);
}

public <T> Page<T> pageAggregation(
        final Pageable pageable,
        final List<AggregationOperation> mainStages,
        final String collection,
        final Class<T> clazz) {
    final List<AggregationOperation> stagesWithCount = new ArrayList<>(mainStages);
    stagesWithCount.add(count().as("count"));
    final Aggregation countAgg = newAggregation(stagesWithCount);
    final Long count = Optional
            .ofNullable(mongoTemplate.aggregate(countAgg, collection, Document.class).getUniqueMappedResult())
            .map(doc -> ((Integer) doc.get("count")).longValue())
            .orElse(0L);

    final List<AggregationOperation> stagesWithPaging = new ArrayList<>(mainStages);
    stagesWithPaging.add(sort(pageable.getSort()));
    stagesWithPaging.add(skip(pageable.getOffset()));
    stagesWithPaging.add(limit(pageable.getPageSize()));
    final Aggregation resultAgg = newAggregation(stagesWithPaging);
    final List<T> result = mongoTemplate.aggregate(resultAgg, collection, clazz).getMappedResults();

    return new PageImpl<>(result, pageable, count);
}

Answer 7

另一种方法是扩展 PagingAndSortingRepository<T, ID> 接口。然后，您可以创建一个 @Aggregation 查询方法，如下所示：

@Aggregation(pipeline = {
      "{ $match: { someField: ?0 } }",
      "{ $project: { _id: 0, someField: 1} }"
})
List<StuffAggregateModel> aggregateStuff(final String somePropertyName, final Pageable pageable);

只需从您的业务逻辑服务中调用它 class 并构造 Pageable（如果需要，它还包含排序选项）并调用 repo 方法。我喜欢这种方法，因为它非常简单，而且可以最大限度地减少您必须编写的代码量。如果您的查询（聚合管道）足够简单，这可能是最好的解决方案。这种方法的维护编码几乎毫不费力。

Answer 8

我的回答是 MongoDB $facet

// User(_id, first name, etc), Car (user_id, brand, etc..)
LookupOperation lookupStageCar = Aggregation.lookup(‘cars ’, ‘user_id’, ‘_id’, ‘car’);
 MatchOperation matchStage = Aggregation.match(Criteria.where(‘car.user_id ‘).exists(true));

 CountOperation countOperation = Aggregation.count().as("total");
 AddFieldsOperation addFieldsOperation = Aggregation.addFields().addFieldWithValue("page", pageable.getPageNumber()).build();
 SkipOperation skipOperation = Aggregation.skip(Long.valueOf(pageable.getPageNumber() * pageable.getPageSize()));
 LimitOperation limitOperation = Aggregation.limit(pageable.getPageSize());

// here the magic
 FacetOperation facetOperation = Aggregation.facet( countOperation, addFieldsOperation).as("metadata")
         .and(skipOperation, limitOperation).as("data");

// users with car
 List<AggrigationResults> map = mongoTemplate.aggregate(Aggregation.newAggregation( lookupStageCar, matchStage, facetOperation), "User",  AggrigationResults.class).getMappedResults();

———————————————————————————
public class AggrigationResults  {

    private List<Metadata> metadata;
    private List<User> data;

}

public class Metadata {

    private long total;
    private long page;

}

———————————————————————————
output: 
{
    "metadata" : [ 
        {
            "total" : 300,
            "page" : 3
        }
    ],
    "data" : [ 
        {
            ... original document ...
        }, 
        {
            ... another document ...
        }, 
        {
            ... etc up to 10 docs ...
        }
    ]
}

参见：

spring数据mongodb如何实现聚合分页

In spring data mongodb how to achieve pagination for aggregation

spring-boot

spring-data-mongodb