Spring Data MongoDB反应式场景下如何指定创建固定集合

你提到的问题确实很常见——Spring Data MongoDB的@Document注解目前并没有直接配置固定集合的属性，不过我们可以通过Spring的启动初始化机制，结合MongoTemplate（或反应式的ReactiveMongoTemplate）来自动创建或转换为固定集合，完美适配嵌入式MongoDB和外部MongoDB的场景。

下面是两种实用的解决方案，分别对应普通和反应式的Spring Data MongoDB场景：

1. 非反应式场景：用CommandLineRunner初始化固定集合 #

我们可以通过CommandLineRunner在应用启动时自动检查并创建固定集合，代码如下：

@Configuration
public class CappedCollectionSetup {

    private final MongoTemplate mongoTemplate;

    // 构造注入MongoTemplate（推荐替代@Autowired）
    public CappedCollectionSetup(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    @Bean
    public CommandLineRunner createCappedPriceDataCollection() {
        return args -> {
            String collectionName = mongoTemplate.getCollectionName(PriceData.class);
            
            // 先判断集合是否存在
            if (!mongoTemplate.collectionExists(collectionName)) {
                // 创建固定集合：设置大小（单位字节，这里是10MB）和可选的最大文档数
                CollectionOptions cappedOptions = CollectionOptions.empty()
                        .capped()
                        .size(10 * 1024 * 1024)
                        .maxDocuments(10000);
                
                mongoTemplate.createCollection(PriceData.class, cappedOptions);
                System.out.println("已创建固定集合：" + collectionName);
            } else {
                // 可选：检查现有集合是否为固定集合，若不是则转换（注意转换会锁集合，谨慎使用）
                Document stats = mongoTemplate.executeCommand(new Document("collStats", collectionName));
                if (!stats.getBoolean("capped")) {
                    mongoTemplate.executeCommand(
                            new Document("convertToCapped", collectionName)
                                    .append("size", 10 * 1024 * 1024)
                    );
                    System.out.println("已将集合转换为固定集合：" + collectionName);
                }
            }
        };
    }
}

2. 反应式场景：用ReactiveCommandLineRunner初始化 #

如果你用的是反应式的Spring Data MongoDB，只需替换为ReactiveMongoTemplate和ReactiveCommandLineRunner：

@Configuration
public class ReactiveCappedCollectionSetup {

    private final ReactiveMongoTemplate reactiveMongoTemplate;

    public ReactiveCappedCollectionSetup(ReactiveMongoTemplate reactiveMongoTemplate) {
        this.reactiveMongoTemplate = reactiveMongoTemplate;
    }

    @Bean
    public ReactiveCommandLineRunner createReactiveCappedCollection() {
        return args -> {
            String collectionName = reactiveMongoTemplate.getCollectionName(PriceData.class);
            
            reactiveMongoTemplate.collectionExists(collectionName)
                    .flatMap(exists -> {
                        if (!exists) {
                            CollectionOptions options = CollectionOptions.empty()
                                    .capped()
                                    .size(10 * 1024 * 1024)
                                    .maxDocuments(10000);
                            return reactiveMongoTemplate.createCollection(PriceData.class, options)
                                    .doOnSuccess(v -> System.out.println("已创建反应式固定集合：" + collectionName));
                        } else {
                            // 可选：检查并转换为固定集合
                            return reactiveMongoTemplate.executeCommand(new Document("collStats", collectionName))
                                    .flatMap(stats -> {
                                        if (!stats.getBoolean("capped")) {
                                            return reactiveMongoTemplate.executeCommand(
                                                    new Document("convertToCapped", collectionName)
                                                            .append("size", 10 * 1024 * 1024)
                                            ).doOnSuccess(v -> System.out.println("已转换为反应式固定集合：" + collectionName));
                                        }
                                        return Mono.empty();
                                    });
                        }
                    })
                    .subscribe();
        };
    }
}

方案优势 #

• 适配多环境：嵌入式MongoDB每次启动都会自动创建集合；外部MongoDB仅首次启动时创建（或转换），后续不会重复执行。
• 与Spring Data无缝集成：直接利用MongoTemplate的API，无需手动执行原生MongoDB命令。
• 灵活可控：可以根据需求调整固定集合的大小、最大文档数，也可以选择是否转换现有集合。

遗憾的是，目前Spring Data MongoDB的@Document注解确实没有提供配置固定集合的属性，所以这种启动时初始化的方式是当前最靠谱的解决方案。

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