嘿，我之前处理过类似的超大规模MongoDB集合遍历场景，结合Hibernate OGM的特性，给你几个可行的优化方向，能避开你现在用setFirstResult/setMaxResult遇到的性能陷阱：

方案1：基于_id范围的Keyset分页（推荐） #

这是MongoDB处理大数据量分页的经典方案，核心思路是利用_id的有序性（默认ObjectId包含时间戳且自带索引），每次记录当前批次最后一条文档的_id，下一批次直接查询_id > lastId的文档，彻底避免skip()带来的性能损耗。

用Hibernate OGM的Criteria API实现示例：

Object lastId = null;
final int BATCH_SIZE = 50000;

try (Session session = sessionFactory.openSession()) {
    while (true) {
        CriteriaBuilder cb = session.getCriteriaBuilder();
        CriteriaQuery<YourEntity> cq = cb.createQuery(YourEntity.class);
        Root<YourEntity> root = cq.from(YourEntity.class);
        
        // 从上次记录的_id开始查询
        if (lastId != null) {
            cq.where(cb.greaterThan(root.get("_id"), lastId));
        }
        // 按_id升序保证遍历顺序
        cq.orderBy(cb.asc(root.get("_id")));
        
        List<YourEntity> batch = session.createQuery(cq)
                .setMaxResults(BATCH_SIZE)
                .getResultList();
        
        if (batch.isEmpty()) {
            break; // 遍历完成
        }
        
        // 处理当前批次数据
        processBatch(batch);
        
        // 更新lastId为当前批次最后一条的_id
        lastId = batch.get(batch.size() - 1).getId();
        
        // 清理Session缓存，避免内存膨胀
        session.flush();
        session.clear();
    }
}

这个方案的优势是每个批次的查询效率基本一致，不会随着遍历深入而变慢，内存占用也能通过批次大小控制。

方案2：直接操作MongoDB底层游标 #

如果想更贴近MongoDB原生操作，也可以通过Hibernate OGM获取底层的MongoCollection，用原生游标逐批遍历，内存占用极低，因为游标会按需从数据库拉取数据。

示例代码：

final int BATCH_SIZE = 50000;

try (Session session = sessionFactory.openSession()) {
    // 获取MongoDB原生集合
    MongoCollection<Document> mongoCollection = session.unwrap(MongoSession.class)
            .getCollection(YourEntity.class);
    
    FindIterable<Document> iterable = mongoCollection.find();
    MongoCursor<Document> cursor = iterable.iterator();
    
    List<YourEntity> batch = new ArrayList<>(BATCH_SIZE);
    int batchCount = 0;
    
    while (cursor.hasNext()) {
        Document doc = cursor.next();
        // 用Hibernate将Document转换为实体对象
        YourEntity entity = session.get(YourEntity.class, doc.getObjectId("_id"));
        batch.add(entity);
        
        if (batch.size() >= BATCH_SIZE) {
            processBatch(batch);
            batch.clear();
            batchCount++;
            // 清理Session缓存
            session.flush();
            session.clear();
            System.out.println("Processed batch " + batchCount);
        }
    }
    
    // 处理最后一批剩余数据
    if (!batch.isEmpty()) {
        processBatch(batch);
        session.flush();
        session.clear();
    }
}

这种方式完全绕开了Hibernate OGM的分页限制，直接利用MongoDB的游标特性，适合对性能要求极高的场景。

方案3：尝试Hibernate OGM的ScrollableResults（版本依赖） #

虽然你提到没找到Hibernate OGM的Scrolling API，但部分新版本（Hibernate OGM 5.x及以上）其实有限支持ScrollableResults，前提是配置MongoDB的游标批次大小：

在persistence.xml中添加配置：

<property name="org.hibernate.ogm.mongodb.cursor.batch_size" value="50000"/>

然后用ScrollableResults遍历：

final int BATCH_SIZE = 50000;

try (Session session = sessionFactory.openSession()) {
    CriteriaBuilder cb = session.getCriteriaBuilder();
    CriteriaQuery<YourEntity> cq = cb.createQuery(YourEntity.class);
    cq.from(YourEntity.class);
    
    // 使用FORWARD_ONLY模式，底层会用MongoDB游标
    ScrollableResults results = session.createQuery(cq)
            .scroll(ScrollMode.FORWARD_ONLY);
    
    List<YourEntity> batch = new ArrayList<>(BATCH_SIZE);
    int count = 0;
    
    while (results.next()) {
        YourEntity entity = (YourEntity) results.get(0);
        batch.add(entity);
        count++;
        
        if (count % BATCH_SIZE == 0) {
            processBatch(batch);
            batch.clear();
            session.flush();
            session.clear();
        }
    }
    
    if (!batch.isEmpty()) {
        processBatch(batch);
        session.flush();
        session.clear();
    }
    results.close();
}

注意：这个方案需要验证你使用的Hibernate OGM版本是否支持，部分旧版本可能对MongoDB的ScrollableResults支持不完善。

你当前方案的问题分析 #

你现在用的setFirstResult/setMaxResult之所以会越来越慢，是因为Hibernate OGM会把它转换成MongoDB的skip()和limit()。当skip的数值很大时（比如第1200批就要跳过近6000万条），MongoDB需要扫描前面所有文档才能定位到起始位置，这就导致批次越往后耗时越长，完全不符合高效遍历的需求。

综合来看，Keyset分页是最稳妥的选择，性能稳定且适配Hibernate OGM的API；如果需要极致性能，直接操作底层游标会更灵活；ScrollableResults则要看你使用的Hibernate OGM版本是否支持，建议先测试验证。

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