Spring Data MongoDB：实现多阶段聚合查询与Java对象映射

db.collection.aggregate([
    {
        $group: {
            _id: {
                year: { 
                        $year: "$createdAt" 
                },
                status: "$status"
            },
            count: { 
                     $sum: 1
            }
        }
    },
    { $replaceWith: { $mergeObjects: [ "$_id", "$$ROOT" ] } },
    { $unset: "_id" }
])

import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.aggregation.DateOperators;
import org.springframework.data.mongodb.core.aggregation.Fields;
import org.springframework.data.mongodb.core.aggregation.ObjectOperators;
import org.springframework.data.mongodb.core.aggregation.ReplaceWithOperation;
import org.springframework.data.mongodb.core.aggregation.UnsetOperation;
// ... 其他Spring Data MongoDB相关的类

import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.aggregation.*;
import org.springframework.stereotype.Service;

@Service
public class AggregationService {

    private final MongoOperations mongoOperations;

    public AggregationService(MongoOperations mongoOperations) {
        this.mongoOperations = mongoOperations;
    }

    public AggregationResults<Object> getYearlyStatusCounts() {
        // 阶段1: 投影和日期提取
        // 对应 MongoDB 的 $project 阶段，用于提前提取年份和保留status字段
        // 这一步并非原始MongoDB查询的显式阶段，但在Java中为了方便后续$group，
        // 尤其是当$group的_id需要从日期字段提取信息时，通常会先进行$project。
        // 原始MongoDB查询是在$group的_id定义中直接使用$year，
        // 但在Java中，为了清晰和方便构建复合_id，先投影出year字段是更常见的做法。
        ProjectionOperation projectOperation = Aggregation.project("status")
                                                    .and(DateOperators.Year.yearOf("createdAt")).as("year");

        // 阶段2: 分组和计数
        // 对应 MongoDB 的 $group 阶段
        GroupOperation groupOperation = Aggregation.group(
                                                Fields.from(
                                                    Fields.field("year", "year"), // 按投影出的year字段分组
                                                    Fields.field("status", "status") // 按status字段分组
                                                )
                                            ).count().as("count"); // 统计每个分组的数量，命名为count

        // 阶段3: 重构文档
        // 对应 MongoDB 的 $replaceWith 阶段
        ReplaceWithOperation replaceWithOperation = ReplaceWithOperation.replaceWithValueOf(
                                                        ObjectOperators.MergeObjects.mergeValuesOf("$_id").mergeWith("$$ROOT")
                                                    );

        // 阶段4: 清理字段
        // 对应 MongoDB 的 $unset 阶段
        UnsetOperation unsetOperation = UnsetOperation.unset("_id");

        // 构建完整的聚合管道
        Aggregation aggregation = Aggregation.newAggregation(
                projectOperation,
                groupOperation,
                replaceWithOperation,
                unsetOperation
        );

        // 执行聚合查询并返回结果
        // "collectionName" 应替换为你的实际集合名称
        return mongoOperations.aggregate(aggregation, "yourCollectionName", Object.class);
    }
}

AggregationResults<Object> results = getYearlyStatusCounts();
for (Object result : results) {
    System.out.println(result); // 示例输出: {year=2023, status=active, count=10}
    // 如果需要进一步处理，可以强制转换为 Map
    // Map<String, Object> resultMap = (Map<String, Object>) result;
    // System.out.println("Year: " + resultMap.get("year") + ", Status: " + resultMap.get("status") + ", Count: " + resultMap.get("count"));
}

public class YearlyStatusCount {
    private int year;
    private String status;
    private long count; // 或者 int count，取决于你的预期计数范围

    // 构造函数、Getter和Setter
    public YearlyStatusCount() {}

    public YearlyStatusCount(int year, String status, long count) {
        this.year = year;
        this.status = status;
        this.count = count;
    }

    public int getYear() { return year; }
    public void setYear(int year) { this.year = year; }
    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }
    public long getCount() { return count; }
    public void setCount(long count) { this.count = count; }

    @Override
    public String toString() {
        return "YearlyStatusCount{" +
               "year=" + year +
               ", status='" + status + '\'' +
               ", count=" + count +
               '}';
    }
}

public AggregationResults<YearlyStatusCount> getYearlyStatusCountsTyped() {
    // ... (同上，构建 projectOperation, groupOperation, replaceWithOperation, unsetOperation)

    Aggregation aggregation = Aggregation.newAggregation(
            projectOperation,
            groupOperation,
            replaceWithOperation,
            unsetOperation
    );

    return mongoOperations.aggregate(aggregation, "yourCollectionName", YearlyStatusCount.class);
}