Spring Data MongoDB带分页的动态搜索实现问题求助

一、解决多词非连续匹配问题 #

你当前的搜索仅支持连续子串，是因为直接使用了完整字符串的正则匹配。要支持类似HYDRATION LOTION这种多词任意顺序的匹配，有两种可靠方案：

方案1：基于正则的多关键词匹配 #

将用户输入的搜索词拆分为独立关键词，对每个属性字段做所有关键词都匹配的正则查询，同时为不同字段赋予对应优先级的权重：

// 聚合管道示例
[
  {
    $addFields: {
      matchScore: {
        $sum: [
          // productName匹配所有关键词，权重最高（10）
          { $cond: [{ $and: [
            { $regexMatch: { input: "$productName", regex: "HYDRATION", options: "i" } },
            { $regexMatch: { input: "$productName", regex: "LOTION", options: "i" } }
          ]}, 10, 0] },
          // subCategoryName匹配，权重次之（5）
          { $cond: [{ $and: [
            { $regexMatch: { input: "$subCategoryName", regex: "HYDRATION", options: "i" } },
            { $regexMatch: { input: "$subCategoryName", regex: "LOTION", options: "i" } }
          ]}, 5, 0] },
          // categoryName匹配，权重3
          { $cond: [{ $and: [
            { $regexMatch: { input: "$categoryName", regex: "HYDRATION", options: "i" } },
            { $regexMatch: { input: "$categoryName", regex: "LOTION", options: "i" } }
          ]}, 3, 0] },
          // brandName匹配，权重1
          { $cond: [{ $and: [
            { $regexMatch: { input: "$brandName", regex: "HYDRATION", options: "i" } },
            { $regexMatch: { input: "$brandName", regex: "LOTION", options: "i" } }
          ]}, 1, 0] }
        ]
      }
    }
  },
  // 过滤出至少匹配一个字段的文档
  { $match: { matchScore: { $gt: 0 } } },
  // 按优先级排序（分数高的在前，同分数可按productName排序）
  { $sort: { matchScore: -1, productName: 1 } }
]

需要在代码中将用户输入按空格拆分，动态生成每个字段的$and匹配条件。

方案2：使用MongoDB文本索引（更高效） #

如果数据集较大，正则匹配性能会下降，推荐用MongoDB文本索引：

1. 先创建带权重的文本索引：

db.products.createIndex(
  {
    productName: "text",
    subCategoryName: "text",
    categoryName: "text",
    brandName: "text"
  },
  {
    weights: {
      productName: 10,
      subCategoryName: 5,
      categoryName: 3,
      brandName: 1
    },
    default_language: "english"
  }
)

2. 用$text查询自动处理多词匹配：

// 聚合管道示例
[
  {
    $match: {
      $text: {
        $search: "HYDRATION LOTION",
        $caseSensitive: false,
        $diacriticSensitive: false
      }
    }
  },
  // 加入MongoDB自动计算的文本得分（对应索引权重）
  { $addFields: { matchScore: { $meta: "textScore" } } },
  // 按得分排序
  { $sort: { matchScore: -1 } }
]

文本索引的性能远高于正则，适合大型数据集。

二、解决Spring Data MongoDB分页问题 #

你之前用unionWith导致分页困难，是因为Spring Data的分页机制对unionWith支持有限。改用单聚合管道+权重排序方案后，可直接用Spring Data的Aggregation结合分页参数实现分页：

Spring Data MongoDB代码示例 #

@Autowired
private MongoTemplate mongoTemplate;

public Page<Product> searchProducts(String keyword, Pageable pageable) {
    // 拆分关键词（仅方案1正则匹配需要，方案2文本索引可跳过）
    String[] keywords = keyword.split("\\s+");
    
    // 构建聚合管道
    Aggregation aggregation = Aggregation.newAggregation(
        // 方案1：添加权重分数（方案2替换为文本查询的$match+$addFields）
        Aggregation.addFields()
            .addField("matchScore")
            .withValue(
                AggregationExpression.from(
                    new Document("$sum", Arrays.asList(
                        // productName匹配权重逻辑
                        new Document("$cond", Arrays.asList(
                            new Document("$and", Arrays.stream(keywords)
                                .map(k -> new Document("$regexMatch", 
                                    new Document("input", "$productName")
                                        .append("regex", k)
                                        .append("options", "i")))
                                .collect(Collectors.toList())),
                            10, 0
                        )),
                        // subCategoryName匹配权重逻辑
                        new Document("$cond", Arrays.asList(
                            new Document("$and", Arrays.stream(keywords)
                                .map(k -> new Document("$regexMatch", 
                                    new Document("input", "$subCategoryName")
                                        .append("regex", k)
                                        .append("options", "i")))
                                .collect(Collectors.toList())),
                            5, 0
                        )),
                        // categoryName匹配权重逻辑
                        new Document("$cond", Arrays.asList(
                            new Document("$and", Arrays.stream(keywords)
                                .map(k -> new Document("$regexMatch", 
                                    new Document("input", "$categoryName")
                                        .append("regex", k)
                                        .append("options", "i")))
                                .collect(Collectors.toList())),
                            3, 0
                        )),
                        // brandName匹配权重逻辑
                        new Document("$cond", Arrays.asList(
                            new Document("$and", Arrays.stream(keywords)
                                .map(k -> new Document("$regexMatch", 
                                    new Document("input", "$brandName")
                                        .append("regex", k)
                                        .append("options", "i")))
                                .collect(Collectors.toList())),
                            1, 0
                        ))
                    ))
                )
            )
            .build(),
        // 过滤有匹配的文档
        Aggregation.match(Criteria.where("matchScore").gt(0)),
        // 按权重排序
        Aggregation.sort(Sort.by(Sort.Direction.DESC, "matchScore").and(Sort.by(Sort.Direction.ASC, "productName"))),
        // 分页：跳过偏移量，取页大小条数
        Aggregation.skip(pageable.getOffset()),
        Aggregation.limit(pageable.getPageSize())
    );
    
    // 执行聚合查询
    AggregationResults<Product> results = mongoTemplate.aggregate(aggregation, "products", Product.class);
    List<Product> content = results.getMappedResults();
    
    // 单独统计总条数
    long total = mongoTemplate.count(
        Aggregation.newAggregation(
            // 重复前面的matchScore计算和match逻辑
            Aggregation.addFields(...),
            Aggregation.match(Criteria.where("matchScore").gt(0)),
            Aggregation.count().as("total")
        ), "products", Long.class
    ).getMappedResults().get(0);
    
    return new PageImpl<>(content, pageable, total);
}

如果用文本索引方案，聚合管道会更简洁，只需保留文本查询、得分添加、排序和分页步骤即可。

三、关键注意事项 #

• 性能优先：数据集超过10万条时，优先用文本索引而非正则匹配。
• 权重调整：根据业务需求调整各字段的权重值，确保匹配优先级符合预期。
• 分页统计：Spring Data聚合分页需要手动统计总条数，需单独执行一次聚合统计总数。

内容的提问来源于stack exchange，提问作者Keshavram Kuduwa