1 条件查询的构造与优化
1.1 基础条件构造：Filters 的使用
在 Java 驱动中，Filters 提供了丰富的构造方法，可以直接将字段、操作符封装为 Bson。通过组合 and、or、not 等，能实现高效的前置筛选，降低集合扫描范围，进一步提升查询性能。
示例中，我们常用的组合是 Filters.and 将多个条件并行筛选，避免逐条查询的低效写法。合理的结构还能让索引发挥作用，降低响应时间。
import com.mongodb.client.MongoCollection;
import com.mongodb.client.model.Filters;
import org.bson.Document;
import org.bson.conversions.Bson;// 假设已获取 collection
Bson filter = Filters.and(Filters.eq("status", "ACTIVE"),Filters.gt("amount", 100)
);for (Document d : collection.find(filter)) {// 处理文档
}
使用 Filters.in 与 Filters.exists 可以进一步提升查询的可读性和灵活性，尤其是在可选字段场景，避免硬编码条件。
1.2 组合逻辑与操作符
复杂条件往往需要 组合逻辑，如在一个条件组里同时存在多种匹配。通过 Filters.or 与 Filters.and 的嵌套，可以把业务规则转化为高效的 Bson，从而提升查询表达力。
此外，区间查询、集合查询、以及对字段存在性的判断，都可以通过对应的 Filters 方法实现，保持查询语义清晰，便于后续维护。
Bson complex = Filters.or(Filters.and(Filters.eq("type", "standard"), Filters.gt("createdAt", startDate)),Filters.and(Filters.eq("type", "premium"), Filters.in("status", Arrays.asList("ACTIVE", "PENDING")))
);collection.find(complex).into(new ArrayList<>());
1.3 时间与范围查询
时间字段的范围查询是复杂查询的常见场景。使用 Filters.gte、Filters.lt 等方法，可以准确限定时间窗口，确保进入聚合阶段的数据稳定。
结合 日期字段索引，可以显著提升查询吞吐量，避免全表扫描，尤其是在按时间维度分析的业务中。
Bson dateRange = Filters.and(Filters.gte("orderDate", startDate),Filters.lt("orderDate", endDate)
);collection.find(dateRange).projection(Projections.include("orderId","orderDate","amount")).into(new ArrayList<>());
2 聚合管道的设计与实战
2.1 匹配阶段 $match 的构造
聚合管道的第一步通常是 $match，它决定了进入后续阶段的数据量。使用 Aggregates.match 搭配前面的 Filters，可以把前置限制放到管道内，提高后续阶段的处理效率。
在设计阶段，优先把高基数字段放在前端筛选，以减少进入下一阶段的文档数。高效的 $match 能显著降低内存消耗，提升整体吞吐量。
import static com.mongodb.client.model.Aggregates.match;
import static com.mongodb.client.model.Filters.and;
import static com.mongodb.client.model.Filters.eq;
import com.mongodb.client.model.Aggregates;
import com.mongodb.client.model.Filters;
import java.util.Arrays;
import java.util.List;List pipeline = Arrays.asList(Aggregates.match(and(eq("status","ACTIVE"), gt("amount", 100))),// 继续后续阶段Aggregates.group("$customerId", Accumulators.sum("total", "$amount"))
);
2.2 投影与字段重命名 $project
通过 $project，可以控制输出字段并重命名，以匹配前端需求。避免传输不必要字段，有助于降低网络带宽与序列化成本。
在 Java 中，Projections 提供了简洁语法，结合 字段别名，实现前后端契合的数据结构，提升可维护性。
import static com.mongodb.client.model.Projections.*;
import com.mongodb.client.model.Aggregates;
import org.bson.Document;Bson project = project("customerId", "totalAmount",include("orderDate"), excludeId());List pipeline = Arrays.asList(Aggregates.match(Filters.eq("status","ACTIVE")),Aggregates.project(fields(computed("customerId", "$_id"),include("totalAmount", "orderDate")))
);
2.3 分组与聚合运算 $group
$group 是聚合分析的核心，能将文档按键聚合并计算聚合表达式，如求和、计数、平均值等。Accumulators 提供了多种聚合操作，便于表达复杂统计。
设计分组键时，要考虑下游需要的粒度与性能之间的平衡，避免产生过多的中间文档，降低内存与磁盘 I/O 负载。
List groupStage = Arrays.asList(Aggregates.group("$customerId",Accumulators.sum("totalSpending","$amount"),Accumulators.avg("avgOrder","$amount"))
);
2.4 使用 $lookup 实现跨集合关联
如果需要关联其他集合的数据，可以使用 $lookup，实现等价于 left join 的效果。正确的索引与投影配合，可以降低联表成本，提升查询灵活性。
在多集合场景下，lookup 的性能取决于入口数据量与索引选择，合理规划阶段顺序尤为重要。
List pipeline = Arrays.asList(Aggregates.match(Filters.eq("status","ACTIVE")),Aggregates.lookup("customers", "customerId", "_id", "customerInfo"),Aggregates.unwind("$customerInfo"),Aggregates.project(fields(include("customerInfo.name"), include("total")))
);
2.5 排序与分页 $sort 与 $skip/$limit
在聚合的末端，经常需要对结果排序与分页。$sort 结合 $skip 与 $limit，可以实现高效的分页查询。
尽量在聚合管道的早期阶段加入排序条件，以避免对已筛选的数据进行重复排序，影响整体性能。
List pipeline = Arrays.asList(Aggregates.match(Filters.eq("status", "ACTIVE")),Aggregates.sort(Sorts.descending("createdAt")),Aggregates.skip(10),Aggregates.limit(20)
);
3 Java 驱动的实践要点
3.1 Bson 构造与 Filters API
在实际项目中，Bson 的构造应该尽量简洁，Filters 提供了类型安全的构造工具，减少错误拼接与运行时异常的风险。
通过静态导入，如 Filters.eq、Filters.gt，可以使代码更具可读性与可维护性，且易于单元测试替换为 mock 数据。
import static com.mongodb.client.model.Filters.*;
import com.mongodb.client.model.Filters;
import org.bson.conversions.Bson;Bson f = and(eq("status","ACTIVE"), gte("amount", 50));
collection.find(f).into(new ArrayList<>());
3.2 Aggregates API 的组合
Aggregates 提供了 match、group、lookup 等阶段，组合时应注意阶段的顺序对性能的影响。
通过 Accumulators，可以实现统计字段，如 sum、avg、max 等，简化表达式。
import static com.mongodb.client.model.Aggregates.*;
import static com.mongodb.client.model.Accumulators.*;
import java.util.Arrays;
import java.util.List;List pipeline = Arrays.asList(match(eq("status","ACTIVE")),group("$customerId", sum("total","$amount")),sort(Sorts.descending("total"))
);
3.3 性能调优与索引策略
对复杂查询，索引策略是关键。确保常用的 查询字段 存在合适的单字段或复合索引，并尽量将筛选字段放在管道前段以减少数据量。
监控执行计划、查看 explain 输出，可以帮助定位瓶颈，从而决定是否需要重构管道或调整索引。
// 打开 explain 以分析执行计划（伪代码示意，MongoDB Java 驱动不直接返回 explain）
Document explainPlan = collection.find(filter).explain(ExplainVerbosity.ALL_PLANS).first();
System.out.println(explainPlan.toJson());
4 实战案例：从条件查询到完整聚合管道
4.1 案例背景与数据模型
案例背景涉及一个电子商务平台的订单数据，核心集合包含 orders、customers 与 orderItems。数据模型设计影响查询的复杂度与聚合结果。
典型字段包括 orderDate、status、amount、customerId，以及关联的商品信息。良好的数据建模帮助减少聚合阶段的重复扫描，提升查询性能。
// 简化的文档结构示意
{_id: ObjectId,orderDate: ISODate,status: "ACTIVE",amount: Number,customerId: ObjectId,items: [{ productId, quantity, price }]
}
4.2 构建条件和阶段管道
从前端筛选条件到管道阶段，通常需要逐步构造 pipeline。先构造 $match，再拼接 $lookup 与 $group，最后做排序和分页，最终输出聚合结果。
关键在于把高基数字段放在前端筛选，降低后续阶段的工作量。下列代码演示一个简化场景的完整管道，覆盖从条件构造到聚合输出的核心流程。
List<Bson> pipeline = Arrays.asList(Aggregates.match(and(eq("status","ACTIVE"), gte("orderDate", startDate))),Aggregates.lookup("orderItems","_id","orderId","items"),Aggregates.unwind("$items"),Aggregates.group("$customerId", sum("grandTotal","$amount"), sum("itemCount","$items.quantity")),Aggregates.sort(Sorts.descending("grandTotal")),Aggregates.skip(0),Aggregates.limit(50)
);
4.3 完整查询代码演示
下面给出一个将前述阶段组合在一起的完整示例，展示如何在 Java 应用中执行聚合管道并解析结果。该示例强调从条件构造到完整聚合管道的实战流程。
注意，实际代码应包含异常处理、资源管理与连接池配置等，以下片段仅展示核心逻辑结构，帮助你快速把复杂查询落地。
MongoCollection<Document> orders = database.getCollection("orders");// 假设 startDate 已定义
List<Bson> pipeline = Arrays.asList(Aggregates.match(and(eq("status","ACTIVE"), gte("orderDate", startDate))),Aggregates.lookup("orderItems","_id","orderId","items"),Aggregates.unwind("$items"),Aggregates.group("$customerId", Accumulators.sum("totalSpent","$amount"),Accumulators.sum("itemsCount","$items.quantity")),Aggregates.sort(Sorts.descending("totalSpent")),Aggregates.skip(0),Aggregates.limit(20)
);AggregateIterable<Document> results = orders.aggregate(pipeline);
for (Document doc : results) {// 处理聚合结果
}
