如何使用DynamoDbEnhancedClient实现DynamoDB类GROUP BY查询？

DynamoDB本身没有原生GROUP BY语法，针对你的需求，有两种实用的实现方式，基于DynamoDbEnhancedClient分别说明：

方式一：客户端侧聚合（适合小数据量场景） #

先通过扫描或查询获取目标数据，再在客户端用Map实现分组计数。

1. 定义实体类 #

对应Simulation表的Java实体：

@DynamoDbBean
public class Simulation {
    private String simulationId;
    private String type;
    // 表中其他字段

    @DynamoDbPartitionKey
    public String getSimulationId() {
        return simulationId;
    }

    public void setSimulationId(String simulationId) {
        this.simulationId = simulationId;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    // 其他字段的getter/setter方法
}

2. 扫描数据并聚合计数 #

// 初始化EnhancedClient和表对象
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.create();
DynamoDbTable<Simulation> simulationTable = enhancedClient.table("Simulation", TableSchema.fromBean(Simulation.class));

// 扫描全表（如果只需要特定simulation_id，改用query方法）
Iterator<Simulation> simIterator = simulationTable.scan().items().iterator();

// 用HashMap存储分组计数，key为simulationId+type的组合
Map<String, Integer> groupCountMap = new HashMap<>();

while (simIterator.hasNext()) {
    Simulation sim = simIterator.next();
    String groupKey = sim.getSimulationId() + "_" + sim.getType();
    groupCountMap.put(groupKey, groupCountMap.getOrDefault(groupKey, 0) + 1);
}

// 输出统计结果
groupCountMap.forEach((key, count) -> {
    String[] keyParts = key.split("_");
    System.out.printf("%s - %s - %d%n", keyParts[0], keyParts[1], count);
});

方式二：预维护统计表（适合大数据量/高频统计场景） #

在写入Simulation数据时，同步更新一张专门的统计表，直接存储分组后的计数，查询时只需读取统计表即可，效率更高。

1. 定义统计表实体类 #

@DynamoDbBean
public class SimulationStats {
    private String statId; // 格式：simulationId_type
    private Integer count;

    @DynamoDbPartitionKey
    public String getStatId() {
        return statId;
    }

    public void setStatId(String statId) {
        this.statId = statId;
    }

    public Integer getCount() {
        return count;
    }

    public void setCount(Integer count) {
        this.count = count;
    }
}

2. 写入数据时同步更新统计 #

// 初始化统计表对象
DynamoDbTable<SimulationStats> statsTable = enhancedClient.table("SimulationStats", TableSchema.fromBean(SimulationStats.class));

// 写入Simulation主表数据
Simulation newSim = new Simulation();
newSim.setSimulationId("simulation_id_1");
newSim.setType("type_1");
// 设置其他字段
simulationTable.putItem(newSim);

// 同步更新统计表，计数加1
String statKey = newSim.getSimulationId() + "_" + newSim.getType();
SimulationStats stats = new SimulationStats();
stats.setStatId(statKey);

statsTable.updateItem(r -> r.item(stats)
        .addAction(UpdateAction.builder()
                .path("count")
                .value(1)
                .build()));

3. 查询统计结果 #

Iterator<SimulationStats> statsIterator = statsTable.scan().items().iterator();
while (statsIterator.hasNext()) {
    SimulationStats stats = statsIterator.next();
    String[] keyParts = stats.getStatId().split("_");
    System.out.printf("%s - %s - %d%n", keyParts[0], keyParts[1], stats.getCount());
}

两种方式对比 #

• 客户端聚合：实现简单，无需额外表结构，但数据量大时扫描开销高，适合数据量小、统计频率低的场景。
• 预维护统计表：写入时增加少量开销，但查询速度极快，适合数据量大、需要频繁统计的场景。

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