如何摆脱Quarkus响应式应用中的"续体地狱"？

在Quarkus响应式Web应用开发中，若需链式调用多个Panache数据库操作组装DTO，嵌套的chain/flatMap会导致代码缩进过深、可读性下降，即所谓的"续体地狱"。而直接用Uni.combine()并发执行多个Uni查询会触发IllegalStateException（错误信息：Illegal pop() with non-matching JdbcValuesSourceProcessingState），核心原因是响应式Hibernate会话不支持并发操作。

以下是几种可行的解决方案：

方案1：合并为单个JPQL查询（最优） #

如果多个实体的查询条件一致，直接编写一个JPQL查询一次性获取所有需要的数据，避免多次数据库交互，从根源上消除嵌套。

@GET
public Uni<MyDto> get(@QueryParam("criteria") String someCriteria) {
    return Panache.withTransaction(() -> 
        // 根据实际字段调整查询条件，确保每个实体返回唯一结果
        PanacheEntity.find("SELECT f.value, b.value, z.value FROM Foo f, Bar b, Baz z " +
                          "WHERE f.someField = ?1 AND b.someField = ?1 AND z.someField = ?1", someCriteria)
            .firstResult()
            .map(tuple -> new MyDto(
                tuple.get(0, String.class),
                tuple.get(1, String.class),
                tuple.get(2, String.class)
            ))
    );
}

若需获取完整实体实例，也可以直接查询三个实体：

@GET
public Uni<MyDto> get(@QueryParam("criteria") String someCriteria) {
    return Panache.withTransaction(() -> 
        PanacheEntity.find("SELECT f, b, z FROM Foo f, Bar b, Baz z " +
                          "WHERE f.someField = ?1 AND b.someField = ?1 AND z.someField = ?1", someCriteria)
            .firstResult()
            .map(result -> {
                Object[] entities = (Object[]) result;
                Foo foo = (Foo) entities[0];
                Bar bar = (Bar) entities[1];
                Baz baz = (Baz) entities[2];
                return new MyDto(foo.value, bar.value, baz.value);
            })
    );
}

方案2：提取嵌套逻辑到独立方法（优化可读性） #

把嵌套的chain逻辑拆分成多个小方法，让主流程更清晰，避免缩进地狱。

@GET
public Uni<MyDto> get(@QueryParam("criteria") String someCriteria) {
    return Foo.findBySomeCriteria(someCriteria)
            .flatMap(foo -> fetchBarWithFoo(someCriteria, foo));
}

private Uni<MyDto> fetchBarWithFoo(String criteria, Foo foo) {
    return Bar.findBySomeCriteria(criteria)
            .flatMap(bar -> fetchBazAndBuildDto(criteria, foo, bar));
}

private Uni<MyDto> fetchBazAndBuildDto(String criteria, Foo foo, Bar bar) {
    return Baz.findBySomeCriteria(criteria)
            .map(baz -> new MyDto(foo.value, bar.value, baz.value));
}

每个方法只负责单一职责，主方法流程一目了然，后续维护和错误处理也更方便。

方案3：并发执行查询（独立事务） #

如果多个查询之间没有依赖关系，且不需要原子性，可以给每个查询单独包裹事务，这样就能安全使用Uni.combine()并发执行，避免嵌套。

@GET
public Uni<MyDto> get(@QueryParam("criteria") String someCriteria) {
    Uni<Foo> fooUni = Panache.withTransaction(() -> Foo.findBySomeCriteria(someCriteria));
    Uni<Bar> barUni = Panache.withTransaction(() -> Bar.findBySomeCriteria(someCriteria));
    Uni<Baz> bazUni = Panache.withTransaction(() -> Baz.findBySomeCriteria(someCriteria));
    
    return Uni.combine().all().unis(fooUni, barUni, bazUni)
            .with((foo, bar, baz) -> new MyDto(foo.value, bar.value, baz.value));
}

注意：这种方式会创建三个独立的数据库事务，若需要数据一致性（比如三个查询必须同时成功），不建议使用此方案。

方案4：手动管理响应式会话 #

通过注入ReactiveSession手动控制会话上下文，确保所有操作在同一个会话中顺序执行，同时结合方法提取优化代码结构。

@Inject
ReactiveSession session;

@GET
public Uni<MyDto> get(@QueryParam("criteria") String someCriteria) {
    return session.withTransaction(this::fetchAllEntitiesAndBuildDto);
}

private Uni<MyDto> fetchAllEntitiesAndBuildDto(ReactiveSession session) {
    return session.find(Foo.class, someCriteria)
            .flatMap(foo -> session.find(Bar.class, someCriteria)
                    .flatMap(bar -> session.find(Baz.class, someCriteria)
                            .map(baz -> new MyDto(foo.value, bar.value, baz.value))
                    )
            );
}

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