基于Elasticsearch Java API获取百万级符合条件索引文档的解决方案（不修改index.max_result_window）

这个问题我之前处理过多次，Elasticsearch的from/size分页确实不适合拉取百万级别的数据——不仅会触发max_result_window限制，而且性能极差，因为ES需要在内存中排序并跳过前面所有结果。既然不能修改索引参数，那官方推荐的Scroll API或者Search After就是最优解，下面给你具体的Java实现方案：

方案一：使用Scroll API（适合一次性导出全量数据） #

Scroll API是专门为批量获取大量数据设计的，它会创建一个快照上下文，后续请求通过scroll_id来拉取后续批次的数据，完全避开from/size的内存开销和窗口限制。

Java实现代码 #

public IndexSearchResult findAllMatchingDocuments(final String studId, final String collageId) {
    List<Map<String, Object>> allSearchResults = new ArrayList<>();
    IndexSearchResult indexSearchResult = new IndexSearchResult();
    // 设置scroll上下文过期时间（按需调整，确保拉取完所有数据前不失效）
    Scroll scroll = new Scroll(TimeValue.timeValueMinutes(1L));
    SearchRequest searchRequest = new SearchRequest("clgindex");
    searchRequest.scroll(scroll);

    // 复用你原有的查询条件
    QueryBuilder queryBuilder = new BoolQueryBuilder().minimumShouldMatch(2)
            .should(QueryBuilders.matchQuery("STUD_ID", studId).operator(Operator.AND))
            .should(QueryBuilders.matchQuery("CLG_ID", collageId).operator(Operator.AND));

    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    sourceBuilder.query(queryBuilder);
    sourceBuilder.size(500); // 每次拉取的批次大小，建议500-1000，按需调整
    // 排序字段加上_id，避免因排序值重复导致漏取数据
    sourceBuilder.sort(new FieldSortBuilder("ROLL_NO.keyword").order(SortOrder.DESC));
    sourceBuilder.sort(new FieldSortBuilder("_id").order(SortOrder.DESC));

    searchRequest.source(sourceBuilder);

    try {
        // 第一次查询，获取初始结果和scroll_id
        SearchResponse searchResponse = rClient.search(searchRequest, RequestOptions.DEFAULT);
        String scrollId = searchResponse.getScrollId();
        SearchHit[] searchHits = searchResponse.getHits().getHits();

        // 循环拉取所有数据，直到没有结果返回
        while (searchHits != null && searchHits.length > 0) {
            // 处理当前批次数据
            for (SearchHit hit : searchHits) {
                allSearchResults.add(hit.getSourceAsMap());
            }

            // 构建下一次scroll请求
            SearchScrollRequest scrollRequest = new SearchScrollRequest(scrollId);
            scrollRequest.scroll(scroll);
            searchResponse = rClient.scroll(scrollRequest, RequestOptions.DEFAULT);
            scrollId = searchResponse.getScrollId();
            searchHits = searchResponse.getHits().getHits();
        }

        // 必须清理scroll上下文，释放ES资源
        ClearScrollRequest clearScrollRequest = new ClearScrollRequest();
        clearScrollRequest.addScrollId(scrollId);
        rClient.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);

        indexSearchResult.setListOfIndexes(allSearchResults);
        log.info("Total matching documents fetched: {}", allSearchResults.size());
    } catch (Exception e) {
        log.error("Error fetching all matching documents: {}", e.getMessage(), e);
    }

    return indexSearchResult;
}

核心注意点： #

• Scroll过期时间要根据数据量调整，确保在拉取完成前上下文不会被ES回收；
• 最后一定要调用ClearScrollRequest清理资源，否则ES会一直占用内存；
• 排序字段必须唯一（加上_id），防止多个文档排序值相同导致漏数据。

方案二：使用Search After（适合实时分页场景） #

如果你的需求是用户分页浏览（而非一次性导出全量），Search After是更优选择——它不需要维护scroll上下文，而是基于上一页最后一个文档的排序值来查询下一页，完全避开max_result_window限制。

Java实现代码 #

public IndexSearchResult findDocumentsByPage(final String studId, final String collageId, int pageSize, List<Object> lastSortValues) {
    List<Map<String, Object>> searchResults = new ArrayList<>();
    IndexSearchResult indexSearchResult = new IndexSearchResult();

    // 复用原有查询条件
    QueryBuilder queryBuilder = new BoolQueryBuilder().minimumShouldMatch(2)
            .should(QueryBuilders.matchQuery("STUD_ID", studId).operator(Operator.AND))
            .should(QueryBuilders.matchQuery("CLG_ID", collageId).operator(Operator.AND));

    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    sourceBuilder.query(queryBuilder);
    sourceBuilder.size(pageSize);
    // 定义排序字段，必须和search_after使用的字段完全一致
    List<SortBuilder<?>> sorts = new ArrayList<>();
    sorts.add(new FieldSortBuilder("ROLL_NO.keyword").order(SortOrder.DESC));
    sorts.add(new FieldSortBuilder("_id").order(SortOrder.DESC));
    sourceBuilder.sort(sorts);

    // 如果不是第一页，传入上一页最后一个文档的排序值
    if (lastSortValues != null && !lastSortValues.isEmpty()) {
        sourceBuilder.searchAfter(lastSortValues.toArray());
    }

    SearchRequest searchRequest = new SearchRequest("clgindex");
    searchRequest.source(sourceBuilder);

    try {
        SearchResponse response = rClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHit[] hits = response.getHits().getHits();
        for (SearchHit hit : hits) {
            searchResults.add(hit.getSourceAsMap());
        }

        // 获取当前页最后一个文档的排序值，用于下一页请求
        List<Object> nextLastSortValues = new ArrayList<>();
        if (hits.length > 0) {
            for (SortField sortField : hits[hits.length - 1].getSortValues()) {
                nextLastSortValues.add(sortField.getValue());
            }
        }
        indexSearchResult.setListOfIndexes(searchResults);
        // 将排序值返回给调用方，用于下一页查询
        indexSearchResult.setLastSortValues(nextLastSortValues);
        log.info("Fetched {} documents for current page", searchResults.size());
    } catch (Exception e) {
        log.error("Error fetching documents by page: {}", e.getMessage(), e);
    }

    return indexSearchResult;
}

核心注意点： #

• 需要调用方保存上一页的lastSortValues，作为下一页请求的参数；
• 排序字段必须唯一（加上_id），避免出现重复或漏数据的情况；
• 这种方式没有资源泄漏问题，不需要清理上下文，适合实时分页场景。

最后提醒 #

• 绝对不要用from/size拉取超过100000条数据，不仅性能差，还会触发限制；
• 一次性导出全量数据选Scroll API，用户分页浏览选Search After；
• 测试时先从小批量数据验证，再放大到百万级，确保稳定性。

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