使用Spring WebFlux构建全响应式服务，是否需全层使用Mono/Flux？

要真正发挥Spring WebFlux响应式编程的核心优势（少量线程处理大量请求、异步非阻塞等），必须从数据访问层（Repository）到业务逻辑层（Service）再到路由/处理器层，全程使用并返回Mono/Flux类型。只在路由层做表面包装的话，根本得不到响应式的真正价值，原因如下：

1. 保持异步非阻塞的调用链连续性 #

响应式的核心是避免线程阻塞，如果中间某一层使用同步阻塞的代码（比如返回普通Java对象），整个调用链会立刻退化为传统的"一个请求占一个线程"模型。比如：

• 如果Repository用了同步的JdbcTemplate，就算Service把结果包成Mono.just()，执行Repository代码的线程还是会被阻塞，直到数据库查询完成，线程没法去处理其他请求。
• 只有全程用Mono/Flux搭配响应式依赖（比如R2DBC数据库驱动、响应式Redis客户端等），才能让线程在等待IO操作时被释放，去处理其他请求，实现高并发下的高效线程利用。

2. 充分利用响应式编程的核心能力 #

Mono/Flux提供了丰富的操作符（flatMap、filter、retry、onErrorResume等），可以在业务层实现异步流程编排、错误处理、数据转换等逻辑。如果中间层不用响应式类型，这些能力完全无法发挥：

• 比如你需要在查询用户后异步调用另一个服务获取用户的权限信息，用flatMap可以轻松实现异步串联，而同步代码只能用线程池手动处理，复杂度高且容易出错。

3. 实现端到端的背压支持 #

背压是响应式编程的关键特性，能让下游组件向上游反馈自己的处理能力，避免上游发送过多数据导致过载。只有全程使用Mono/Flux，背压才能从客户端一直传递到数据库层：

• 比如用R2DBC的Repository时，数据库的查询速度会根据前端的处理能力动态调整，避免大量数据瞬间涌入内存；如果中间有同步层，背压链就会断裂，无法实现这种动态平衡。

反面例子：仅在路由层包装的问题 #

如果Service返回普通对象，Controller用Mono.just(serviceResult)包装，本质上还是同步阻塞的逻辑：

// 错误示范：Service返回同步对象
@Service
public class BadUserService {
    public User getUserByUsername(String username) {
        // 这里是同步阻塞的数据库查询
        return jdbcTemplate.queryForObject("SELECT * FROM users WHERE username = ?", User.class, username);
    }
}

@RestController
public class UserController {
    @GetMapping("/{username}")
    public Mono<User> getUser(@PathVariable String username) {
        // 表面用了Mono，但内部是同步阻塞
        return Mono.just(badUserService.getUserByUsername(username));
    }
}

这种写法下，处理请求的线程会被数据库查询完全阻塞，和传统Spring Web没有任何区别，完全浪费了WebFlux的响应式能力。

正确的三层响应式示例 #

Repository层（响应式数据库访问） #

import org.springframework.data.repository.reactive.ReactiveCrudRepository;

public interface UserRepository extends ReactiveCrudRepository<User, Long> {
    Mono<User> findByUsername(String username);
}

Service层（响应式业务逻辑） #

import reactor.core.publisher.Mono;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public Mono<User> getSafeUserByUsername(String username) {
        return userRepository.findByUsername(username)
                // 异步处理数据
                .map(user -> {
                    user.setPassword("***"); // 隐藏敏感字段
                    return user;
                })
                // 异步错误处理
                .onErrorResume(e -> Mono.error(new RuntimeException("查询用户失败", e)));
    }
}

Controller层（响应式路由处理器） #

import reactor.core.publisher.Mono;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{username}")
    public Mono<User> getUser(@PathVariable String username) {
        return userService.getSafeUserByUsername(username);
    }
}

特殊情况：处理同步阻塞代码 #

如果必须调用同步阻塞的第三方API，不要直接在响应式线程里执行，要把它放到专门的阻塞线程池，用Mono.fromCallable()包裹：

import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;

public Mono<String> callSyncThirdPartyApi(String param) {
    return Mono.fromCallable(() -> {
        // 同步阻塞的API调用
        return syncThirdPartyClient.call(param);
    }).subscribeOn(Schedulers.boundedElastic());
}

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