嘿，我看了你遇到的问题——在响应式Spring Boot + MongoDB的环境下，要给Product的productId做安全的自增，还要避免竞态条件，不能用阻塞的计数查询对吧？MongoDB确实不像关系型数据库有原生的GeneratedValue，但我们可以用计数器集合+原子操作的方案来解决，完全适配响应式，还能保证线程安全，不会出现重复id的情况。

下面结合你的现有代码，一步步给你说怎么改：

1. 新增计数器实体类（Sequence） #

首先我们需要一个专门的集合来存每个业务实体的自增序列值，这个集合的每个文档对应一个实体的当前最大id：

package com.bh25034.products.model;

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Data
@Document(collection = "sequences")
public class Sequence {
    @Id
    private String id; // 用业务标识当文档ID，比如"product_sequence"
    private long seq; // 当前的序列值
}

2. 实现原子序列生成服务 #

接下来写一个服务，用MongoDB的findAndModify原子操作来获取下一个自增id——这个操作是数据库层面的原子操作，多个并发请求过来时MongoDB会串行处理，绝对不会出现两个请求拿到同一个id的情况，而且是响应式的非阻塞操作：

package com.bh25034.products.service;

import com.bh25034.products.model.Sequence;
import org.springframework.data.mongodb.core.ReactiveMongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;

import static org.springframework.data.mongodb.core.FindAndModifyOptions.options;

@Service
public class SequenceGeneratorService {

    private final ReactiveMongoTemplate mongoTemplate;

    // 构造注入ReactiveMongoTemplate
    public SequenceGeneratorService(ReactiveMongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    // 根据序列名称获取下一个自增值
    public Mono<Long> generateNextSequence(String seqName) {
        // 1. 查询指定名称的序列文档
        Query query = new Query(Criteria.where("_id").is(seqName));
        // 2. 执行自增操作
        Update update = new Update().inc("seq", 1);
        // 3. 配置选项：如果文档不存在则自动插入（upsert=true），返回修改后的新值（returnNew=true）
        return mongoTemplate.findAndModify(query, update, options().returnNew(true).upsert(true), Sequence.class)
                .map(Sequence::getSeq);
    }
}

3. 修改ProductService的创建逻辑 #

现在回到你的ProductService，在创建Product的时候，先调用序列服务拿到自增的productId，再保存实体——整个流程都是响应式链式调用，没有阻塞：

首先在ProductService里注入SequenceGeneratorService：

private final SequenceGeneratorService sequenceGeneratorService;

// 构造注入时加上这个参数
public ProductService(ProductRepository productRepository, 
                      ProductMapper productMapper,
                      SequenceGeneratorService sequenceGeneratorService) {
    this.productRepository = productRepository;
    this.productMapper = productMapper;
    this.sequenceGeneratorService = sequenceGeneratorService;
}

然后修改createProduct方法：

public Mono<ProductDto> createProduct(final ProductDto productDto) {
    // 先获取下一个自增的productId，再映射实体、保存
    return sequenceGeneratorService.generateNextSequence("product_sequence")
            .map(nextProductId -> {
                Product product = productMapper.toProduct(productDto);
                product.setProductId(nextProductId); // 给product设置自增id
                return product;
            })
            .flatMap(productRepository::save) // 响应式保存
            .map(productMapper::toProductDto); // 转换回Dto返回
}

4. 保留唯一性保障 #

你在Product实体里给productId加的@Indexed(unique = true)一定要保留！这相当于双重保险：就算原子操作出现极端意外（几乎不可能），MongoDB的唯一索引也会直接抛出DuplicateKeyException，避免重复id存入数据库。到时候你可以在服务里捕获这个异常，重试一次获取序列即可。

为什么这个方案适合你？ #

• 非阻塞响应式：所有操作都是基于ReactiveMongo的Mono/Flux，完全符合你的非阻塞API要求，没有任何阻塞的数据库调用
• 线程安全无竞态：findAndModify是MongoDB原生的原子操作，数据库层面保证并发下不会重复分配id
• 轻量易集成：不需要额外依赖，只需要新增几个简单的类，对现有代码侵入极小
• 自动初始化：如果sequences集合里没有product_sequence这个文档，findAndModify的upsert=true会自动创建它，初始seq为0，第一个生成的productId就是1，完全不用手动初始化（当然你也可以提前插入初始值调整起始id）

内容来源于stack exchange