如何基于DynamoDB Scan实现过滤结果的分页功能？

一、核心问题的针对性解决 #

1. 解决"Scan加过滤找不到符合项"的问题 #

当前代码首次请求（nextToken为null）无结果时直接抛异常，可调整为更灵活的逻辑：

• 区分首次请求无结果与后续分页无结果：首次请求无结果可返回空列表+null nextToken（除非业务强制要求必须存在数据）；
• 扫描过程中，若某次Scan返回空且无lastEvaluatedKey，说明全表扫描完毕，直接终止循环。

2. 正确判断是否还有剩余符合条件的项 #

当前用过滤后的最后一项生成nextToken的逻辑存在漏洞，正确做法是：

• 保留DynamoDB返回的lastEvaluatedKey作为分页标记，这是官方提供的准确扫描位置记录，而非用过滤后的项主键；
• 仅当lastEvaluatedKey为null时，才代表全表扫描完成，此时返回null作为nextToken；否则无论过滤结果是否满足resultSize，都返回当前lastEvaluatedKey。

3. 优化多次Scan的性能问题 #

表规模2000条时Scan性能足够，但可通过以下方式减少不必要的扫描次数：

• 将Scan的Limit设为resultSize * 2，单次返回更多原始数据，降低循环次数；
• 提前构建带过滤条件的请求模板，仅在循环中更新exclusiveStartKey；
• 添加ProjectionExpression只返回业务需要的字段，减少数据传输量。

二、改进后的代码实现 #

public PaginatedResult<List<ItemRecord>> getFilteredItems(String nextToken, int resultSize) {
    Map<String, AttributeValue> exclusiveStartKey = decodeNextToken(nextToken);

    // 构建过滤表达式，添加ProjectionExpression只返回需要的字段
    Expression filterExpression = Expression.builder()
            .expression("status = :status AND type IN (:type1, :type2)")
            .expressionValues(Map.of(
                    ":status", AttributeValue.fromBool(true),
                    ":type1", AttributeValue.fromString("typeValue1"),
                    ":type2", AttributeValue.fromString("typeValue2")
            ))
            .build();

    // 提前设置Limit为resultSize的2倍，减少扫描次数
    int scanLimit = resultSize * 2;
    ScanEnhancedRequest.Builder scanRequestBuilder = ScanEnhancedRequest.builder()
            .filterExpression(filterExpression)
            .limit(scanLimit)
            .projectionExpression("id, status, type, [其他业务需要的字段]"); // 替换为实际字段

    List<ItemRecord> filteredItems = new ArrayList<>();
    Map<String, AttributeValue> currentStartKey = exclusiveStartKey;
    Boolean hasMorePages = true;

    while (hasMorePages && filteredItems.size() < resultSize) {
        try {
            ScanEnhancedRequest scanRequest = scanRequestBuilder
                    .exclusiveStartKey(currentStartKey)
                    .build();

            Page<ItemRecord> page = table.scan(scanRequest).stream().findFirst().orElse(null);
            if (page == null) {
                break;
            }

            // 收集符合条件的项（DynamoDB已过滤，此处仅控制不超过resultSize）
            for (ItemRecord item : page.items()) {
                if (filteredItems.size() < resultSize) {
                    filteredItems.add(item);
                } else {
                    break;
                }
            }

            // 更新分页标记：使用DynamoDB官方返回的lastEvaluatedKey
            currentStartKey = page.lastEvaluatedKey();
            hasMorePages = currentStartKey != null;

        } catch (Exception e) {
            // 实际业务中添加具体异常处理，如日志记录、降级逻辑
            e.printStackTrace();
            hasMorePages = false;
        }
    }

    // 处理空结果场景
    if (filteredItems.isEmpty()) {
        if (nextToken == null) {
            // 首次请求无结果，可根据业务选择抛异常或返回空列表
            // throw new NotFoundException("Qualified items not found");
            return new PaginatedResult<>(Collections.emptyList(), Optional.empty(), resultSize);
        }
        return new PaginatedResult<>(Collections.emptyList(), Optional.empty(), resultSize);
    }

    // 生成nextToken：仅当还有未扫描页面时返回，否则返回null
    String newNextToken = hasMorePages ? ConversionHelper.encodeNextToken(currentStartKey) : null;
    return new PaginatedResult<>(filteredItems, Optional.ofNullable(newNextToken), resultSize);
}

三、额外建议：用GSI替代Scan提升长期性能 #

若后续表规模增长（如超过1万条），Scan性能会下降，建议创建全局二级索引（GSI）：

• 以status为分区键、type为排序键（可根据查询频率调整顺序）；
• 用Query操作替代Scan，直接定位到status = true的分区再过滤type，性能远高于Scan；
• Query分页逻辑更简单，直接使用返回的lastEvaluatedKey即可，无需多次循环。

GSI定义示例（AWS控制台/Terraform风格） #

GlobalSecondaryIndexes:
  - IndexName: status-type-index
    KeySchema:
      - AttributeName: status
        KeyType: HASH
      - AttributeName: type
        KeyType: RANGE
    Projection:
      ProjectionType: INCLUDE
      NonKeyAttributes: [id, 其他业务字段] # 只投影需要的字段

使用GSI的Query分页代码示例 #

public PaginatedResult<List<ItemRecord>> getFilteredItemsWithGSI(String nextToken, int resultSize) {
    Map<String, AttributeValue> exclusiveStartKey = decodeNextToken(nextToken);

    Expression keyConditionExpression = Expression.builder()
            .expression("status = :status AND type IN (:type1, :type2)")
            .expressionValues(Map.of(
                    ":status", AttributeValue.fromBool(true),
                    ":type1", AttributeValue.fromString("typeValue1"),
                    ":type2", AttributeValue.fromString("typeValue2")
            ))
            .build();

    QueryEnhancedRequest queryRequest = QueryEnhancedRequest.builder()
            .indexName("status-type-index")
            .keyConditionExpression(keyConditionExpression)
            .limit(resultSize)
            .exclusiveStartKey(exclusiveStartKey)
            .build();

    Page<ItemRecord> page = table.query(queryRequest).stream().findFirst().orElse(null);
    if (page == null) {
        return new PaginatedResult<>(Collections.emptyList(), Optional.empty(), resultSize);
    }

    List<ItemRecord> items = page.items();
    String newNextToken = page.lastEvaluatedKey() != null ? ConversionHelper.encodeNextToken(page.lastEvaluatedKey()) : null;
    return new PaginatedResult<>(items, Optional.ofNullable(newNextToken), resultSize);
}

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