MongoDB聚合查询中获取包含重复项的完整数据-java教程-PHP中文网

MongoDB聚合查询中获取包含重复项的完整数据

碧海醫心

发布： 2025-11-27 16:00:09

原创

114人浏览过

MongoDB聚合查询中获取包含重复项的完整数据

本文旨在解决mongodb聚合查询中因group阶段导致数据去重的问题，详细阐述了如何在聚合管道中保留所有包含重复项的数据。核心解决方案是移除不必要的group阶段，并提供了java spring data mongodb的示例代码。文章还探讨了使用$project优化字段选择以及在不同场景下聚合与普通查询的选择策略，确保数据检索的准确性和效率。

理解MongoDB聚合中的去重行为

MongoDB的聚合框架是一个强大的工具，用于处理和分析集合中的数据。然而，在使用聚合管道时，如果不明确其各个阶段的作用，可能会意外地改变数据的结构或丢失信息。其中一个常见的误解与$group阶段有关。

$group阶段的主要功能是根据一个或多个指定字段对文档进行分组，然后对每个组执行累加操作。当您使用$group并指定一个字段作为_id时，聚合管道会为每个唯一的_id值生成一个文档。这意味着，如果您的目标是获取包含重复值的所有文档或字段，而聚合管道中包含了$group阶段，那么结果中的重复项将会被自动消除。

例如，原始代码片段中使用了TypedAggregation.group("numBerId")。这个操作会将所有具有相同numBerId值的文档归为一组，并为每个唯一的numBerId生成一个结果文档。因此，任何重复的numBerId在最终输出中都会被去重。

获取包含重复数据的聚合查询

要从MongoDB聚合查询中获取包含重复项的完整数据，关键在于避免使用会执行去重操作的聚合阶段，特别是$group阶段，除非您的明确意图就是去重并执行累加。

核心解决方案：移除 group 阶段

如果您希望获取所有匹配条件的文档，包括其中所有字段的重复值，最直接的方法就是从聚合管道中移除$group阶段。

以下是修正后的Java Spring Data MongoDB聚合代码示例：

import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.Criteria;
import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.domain.Sort;
import org.bson.Document;

import java.util.List;
import java.util.stream.Collectors;

public class MongoDBDuplicateDataRetrieval {

    private MongoTemplate mongoTemplate; // 假设已注入或初始化

    public List<String> getAllNumberIdsWithDuplicates(String numBerIdPrefix, String collectionName) {
        // 构建匹配条件：numBerId以numBerIdPrefix开头且不为空
        Criteria matchCriteria = Criteria.where("numBerId").regex("^" + numBerIdPrefix, "i")
                                     .andOperator(Criteria.where("numBerId").ne(""));

        // 构建聚合管道
        // 1. $match: 过滤符合条件的文档
        // 2. $limit: 限制返回的文档数量（可选，根据需求调整）
        // 3. $sort: 对结果进行排序（可选，根据需求调整）
        TypedAggregation<Document> agg = TypedAggregation.newAggregation(Document.class,
                TypedAggregation.match(matchCriteria),
                TypedAggregation.limit(20000), // 限制返回文档数量，防止内存溢出
                TypedAggregation.sort(Sort.Direction.ASC, "numBerId") // 对numBerId字段进行排序
        );

        // 执行聚合操作
        AggregationResults<Document> results = mongoTemplate.aggregate(agg, collectionName, Document.class);

        // 从结果中提取numBerId字段
        // 注意：这里返回的是包含完整文档的列表，如果只需要numBerId，需要进一步处理
        return results.getMappedResults().stream()
                .map(d -> (String) d.get("numBerId"))
                .collect(Collectors.toList());
    }

    // 假设的collectionName()方法
    private String collectionName() {
        return "yourCollectionName"; // 替换为您的实际集合名
    }
}

登录后复制

代码解释：

Spacely AI

为您的房间提供AI室内设计解决方案，寻找无限的创意

查看详情

TypedAggregation.match(matchCriteria): 这个阶段负责根据指定的条件过滤文档。只有numBerId字段以numBerIdPrefix开头（不区分大小写）且不为空的文档才能进入后续阶段。
TypedAggregation.limit(20000): 这是一个可选的阶段，用于限制聚合操作返回的文档数量。在处理大量数据时，这是一个非常重要的优化，可以防止内存溢出和提高性能。
TypedAggregation.sort(Sort.Direction.ASC, "numBerId"): 这是一个可选的阶段，用于对匹配到的文档按照numBerId字段进行升序排序。
移除TypedAggregation.group("numBerId"): 这是核心改动。通过移除这个阶段，聚合管道不再对numBerId进行分组去重，而是将所有匹配的文档（或其指定字段）原封不动地传递到结果中，从而保留了所有重复项。

优化数据输出：使用 $project 阶段

如果您只是需要特定字段（例如numBerId），而不是整个文档，那么在$match之后添加一个$project阶段可以进一步优化性能和网络传输。$project允许您选择、重命名字段或计算新字段。

以下是使用$project来仅选择numBerId字段的示例：

import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.Criteria;
import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.aggregation.ProjectionOperation;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.domain.Sort;
import org.bson.Document;

import java.util.List;
import java.util.stream.Collectors;

public class MongoDBProjectedDuplicateDataRetrieval {

    private MongoTemplate mongoTemplate; // 假设已注入或初始化

    public List<String> getProjectedNumberIdsWithDuplicates(String numBerIdPrefix, String collectionName) {
        Criteria matchCriteria = Criteria.where("numBerId").regex("^" + numBerIdPrefix, "i")
                                     .andOperator(Criteria.where("numBerId").ne(""));

        // 定义投影操作，只包含numBerId字段
        ProjectionOperation projectNumBerId = Aggregation.project("numBerId");

        TypedAggregation<Document> agg = TypedAggregation.newAggregation(Document.class,
                TypedAggregation.match(matchCriteria),
                projectNumBerId, // 添加$project阶段
                TypedAggregation.limit(20000),
                TypedAggregation.sort(Sort.Direction.ASC, "numBerId")
        );

        AggregationResults<Document> results = mongoTemplate.aggregate(agg, collectionName, Document.class);

        // 由于使用了$project，每个结果文档只包含_id和numBerId
        // 我们可以直接从这些文档中提取numBerId
        return results.getMappedResults().stream()
                .map(d -> (String) d.get("numBerId"))
                .collect(Collectors.toList());
    }

    private String collectionName() {
        return "yourCollectionName"; // 替换为您的实际集合名
    }
}

登录后复制

注意事项与最佳实践

何时选择聚合 vs. 普通查询：
- 如果您只是需要根据简单条件查找文档，并获取其全部或部分字段，使用MongoTemplate的find或findDistinct方法通常更简洁、性能更好。
- 聚合框架适用于更复杂的场景，例如数据转换、计算、分组统计、多阶段处理等。当需要执行$lookup、$unwind、$facet等高级操作时，聚合是首选。
- 在本文的场景中，如果仅需获取所有numBerId字段（含重复），且没有其他复杂的聚合逻辑，一个简单的find查询配合fields投影可能更直接。
处理大量数据时的性能考量：
- 当返回的文档数量非常大时，$limit阶段至关重要。如果没有$limit，聚合操作可能会消耗大量内存和CPU资源，甚至导致服务崩溃。
- 确保$match阶段的查询条件能够利用索引。在numBerId字段上建立索引将大大加快匹配速度。
- $project阶段可以减少网络传输的数据量，尤其是在文档体积较大而您只需要其中少数几个字段时。
group 阶段的正确使用场景：
- $group阶段并非毫无用处，它在需要进行数据汇总、统计分析时非常强大。例如，计算每个numBerId出现的次数、求和、平均值等。
- 示例：计算每个numBerId出现的次数
```
TypedAggregation<Document> aggCount = TypedAggregation.newAggregation(Document.class,
    TypedAggregation.match(matchCriteria),
    TypedAggregation.group("numBerId").count().as("count"), // 按numBerId分组并计数
    TypedAggregation.sort(Sort.Direction.DESC, "count") // 按计数降序排序
);
```
  登录后复制
- 理解$group的作用，并根据实际需求决定是否使用它，是编写高效和正确聚合查询的关键。