Spring Data Mongo Reactive多文档查询组合与Report对象响应式实现

嘿，作为响应式流的新手，碰到这种跨多个MongoDB集合组装数据的需求太正常了！我来一步步帮你梳理怎么用Spring Data Mongo Reactive搞定这个事儿，顺便聊聊多文档查询的组合技巧~

第一步：先准备好Reactive Repository接口 #

首先得给每个MongoDB集合定义对应的Reactive Repository，这是Spring Data Mongo Reactive的基础，它会帮你自动实现异步的CRUD方法：

// 对应Person集合的Reactive Repository
interface PersonReactiveRepo : ReactiveMongoRepository<Person, String>

// 对应Address集合的Reactive Repository
interface AddressReactiveRepo : ReactiveMongoRepository<Address, String> {
    // 自定义根据personId查询地址的方法（Spring Data支持方法名推导）
    fun findByPersonId(personId: String): Flux<Address>
}

// 对应Job集合的Reactive Repository
interface JobReactiveRepo : ReactiveMongoRepository<Job, String> {
    fun findByPersonId(personId: String): Flux<Job>
}

// 对应Credit集合的Reactive Repository
interface CreditReactiveRepo : ReactiveMongoRepository<Credit, String> {
    fun findByPersonId(personId: String): Flux<Credit>
}

第二步：组合多个响应式流构建Report对象 #

核心思路是用响应式操作符，把多个异步查询的结果聚合到一起。假设我们要根据personId获取完整的Report，这里可以用zipWith操作符来组合多个Mono，或者用flatMap处理依赖查询的场景：

场景1：所有查询都基于同一个personId（并行查询） #

这种情况最常见，所有关联数据都通过personId查询，我们可以并行发起所有查询，等所有结果就绪后再组装Report：

@Service
class ReportService(
    private val personRepo: PersonReactiveRepo,
    private val addressRepo: AddressReactiveRepo,
    private val jobRepo: JobReactiveRepo,
    private val creditRepo: CreditReactiveRepo
) {

    fun getReport(personId: String): Mono<Report> {
        // 1. 查询Person对象（返回Mono，因为最多一个结果）
        val personMono = personRepo.findById(personId)
            // 处理Person不存在的情况，比如抛出异常或返回默认值
            .switchIfEmpty(Mono.error(IllegalArgumentException("Person not found with id: $personId")))

        // 2. 查询关联的地址、工作、信用数据（返回Flux，因为可能多个结果）
        val addressesFlux = addressRepo.findByPersonId(personId)
        val jobsFlux = jobRepo.findByPersonId(personId)
        val creditsFlux = creditRepo.findByPersonId(personId)

        // 3. 把Flux转为Mono<List>，方便后续组合
        val addressesMono = addressesFlux.collectList()
        val jobsMono = jobsFlux.collectList()
        val creditsMono = creditsFlux.collectList()

        // 4. 组合所有Mono，当所有结果就绪时组装成Report
        return personMono.zipWith(addressesMono, jobsMono, creditsMono) { person, addresses, jobs, credits ->
            Report(person, addresses, jobs, credits)
        }
    }
}

场景2：查询依赖前一个结果（串行+并行结合） #

如果某些关联数据的查询依赖Person对象里的其他字段（比如用Person的城市查地址），可以用flatMap先获取Person，再发起后续查询：

fun getReportWithDependency(personId: String): Mono<Report> {
    return personRepo.findById(personId)
        .switchIfEmpty(Mono.error(IllegalArgumentException("Person not found with id: $personId")))
        .flatMap { person ->
            // 用Person的city字段查地址，同时并行查工作和信用数据
            val addressesMono = addressRepo.findByCity(person.city).collectList()
            val jobsMono = jobRepo.findByPersonId(person.id).collectList()
            val creditsMono = creditRepo.findByPersonId(person.id).collectList()

            // 组合后续的三个Mono，再和Person组装成Report
            Mono.zip(addressesMono, jobsMono, creditsMono) { addresses, jobs, credits ->
                Report(person, addresses, jobs, credits)
            }
        }
}

多文档查询组合的关键技巧 #

• 并行查询优势：上面的例子里，除了依赖Person的查询外，其他关联数据的查询都是并行执行的，不会互相阻塞，充分利用响应式的异步特性。
• 操作符选择：
  • 用zipWith/Mono.zip组合多个独立的异步结果，必须等所有结果都就绪才会继续。
  • 用flatMap处理有依赖的查询，先获取前一个结果，再发起后续请求。
  • 用collectList()把Flux（多个元素）转为Mono，方便和其他Mono组合。
• 空值处理：用switchIfEmpty处理查询不到数据的情况，避免返回空的Mono导致后续流程中断。

刚开始接触响应式流可能会有点绕，多写几个例子、熟悉这些操作符的用法后，就能轻松驾驭这种多集合聚合的场景啦！

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