02.04.02 Reactor 实战教程：响应式编程从入门到精通

02.04.02 Reactor 实战教程：响应式编程从入门到精通

导读

在微服务和高并发场景下，传统的阻塞式编程模型面临着严峻挑战：线程资源昂贵、扩展性受限、响应延迟高。响应式编程（Reactive Programming）应运而生，通过非阻塞、异步、事件驱动的方式，让我们能用少量线程处理海量并发请求。

本文将深入探讨 Project Reactor------Spring WebFlux 的核心响应式库，从 Reactive Streams 规范到实战应用，带你全面掌握响应式编程。

适用人群：熟悉 Java 基础和多线程，想要学习响应式编程和 Spring WebFlux 的开发者

学习目标：

• 理解 Reactive Streams 规范和背压机制
• 掌握 Reactor 核心 API（Mono 和 Flux）
• 在 Spring WebFlux 中应用响应式编程
• 解决响应式编程中的常见问题

---

一、响应式编程核心概念

1.1 什么是响应式编程？

响应式编程是一种面向数据流和变化传播的编程范式。在响应式系统中：

• 非阻塞：不会因为等待 IO 而阻塞线程
• 异步：操作立即返回，结果通过回调传递
• 事件驱动：数据流触发处理逻辑
• 背压：消费者可以控制生产者的速度

传统 vs 响应式对比：

// ❌ 传统阻塞方式
public User getUser(String id) {
    User user = userRepository.findById(id);        // 阻塞等待数据库
    Profile profile = profileService.getProfile(id); // 阻塞等待远程服务
    return mergeUserProfile(user, profile);
}

// ✅ 响应式方式
public Mono<User> getUser(String id) {
    Mono<User> userMono = userRepository.findById(id);
    Mono<Profile> profileMono = profileService.getProfile(id);
    
    return Mono.zip(userMono, profileMono)  // 并行执行，非阻塞
        .map(tuple -> mergeUserProfile(tuple.getT1(), tuple.getT2()));
}

性能对比：

场景	传统 MVC	WebFlux (Reactor)
10000 并发请求	需要 ~10000 线程	需要 ~16 线程
内存占用	~10GB	~100MB
吞吐量	~5000 QPS	~20000 QPS
CPU 使用率	高（线程切换）	低（事件驱动）

1.2 Reactive Streams 规范

Reactive Streams 是响应式编程的标准规范，定义了四个核心接口：

// 1. Publisher：数据发布者
public interface Publisher<T> {
    void subscribe(Subscriber<? super T> subscriber);
}

// 2. Subscriber：数据订阅者
public interface Subscriber<T> {
    void onSubscribe(Subscription subscription);
    void onNext(T item);
    void onError(Throwable throwable);
    void onComplete();
}

// 3. Subscription：订阅契约（背压的关键）
public interface Subscription {
    void request(long n);  // 请求 n 个元素
    void cancel();         // 取消订阅
}

// 4. Processor：既是 Publisher 又是 Subscriber
public interface Processor<T, R> extends Subscriber<T>, Publisher<R> {
}

数据流动过程：

┌─────────────┐    subscribe()    ┌─────────────┐
│  Publisher  │◄──────────────────│ Subscriber  │
│             │                   │             │
│             │── onSubscribe() ─→│             │
│             │                   │             │
│             │◄── request(n) ────│             │
│             │                   │             │
│             │──── onNext() ────→│             │
│             │──── onNext() ────→│             │
│             │                   │             │
│             │── onComplete() ──→│             │
└─────────────┘                   └─────────────┘

---

二、背压机制深度解析

2.1 为什么需要背压？

问题场景：生产者速度 > 消费者速度 → 数据堆积 → 内存溢出

// 没有背压：可能导致 OOM
Flux.range(1, 1_000_000_000)  // 快速生产
    .map(this::slowProcess)    // 慢速消费
    .subscribe();

2.2 背压实现原理

Reactor 通过 Subscription.request(n) 实现背压：

// Reactor 背压实现（简化）
public abstract class Flux<T> implements Publisher<T> {
    public final void subscribe(Subscriber<? super T> actual) {
        // 创建 Subscription
        Subscription subscription = createSubscription(actual);
        actual.onSubscribe(subscription);
    }
}

// Subscription 实现
static final class FluxArray.ArraySubscription<T> implements Subscription {
    final Subscriber<? super T> actual;
    final T[] array;
    int index;
    long requested;  // 请求数量
    volatile boolean cancelled;
    
    @Override
    public void request(long n) {
        if (n > 0) {
            long r = addRequested(n);  // 增加请求数量
            if (r == 0) {
                drain();  // 开始推送数据
            }
        }
    }
    
    void drain() {
        int i = index;
        long e = 0L;
        long r = requested;
        T[] a = array;
        int n = a.length;
        
        while (i != n && e != r) {  // 只推送被请求的数据
            if (cancelled) {
                return;
            }
            T t = a[i];
            if (t == null) {
                actual.onError(new NullPointerException());
                return;
            }
            actual.onNext(t);  // 推送数据
            i++;
            e++;
        }
        
        if (i == n) {
            actual.onComplete();
        } else {
            index = i;
            requested = r - e;  // 更新剩余请求数
        }
    }
}

2.3 背压策略

Reactor 提供多种背压策略：

// 1. BUFFER：缓冲（默认，可能导致 OOM）
Flux.range(1, 1_000_000)
    .onBackpressureBuffer(1000)  // 缓冲1000个元素
    .subscribe();

// 2. DROP：丢弃新元素
Flux.range(1, 1_000_000)
    .onBackpressureDrop(dropped -> log.warn("丢弃: {}", dropped))
    .subscribe();

// 3. LATEST：只保留最新元素
Flux.range(1, 1_000_000)
    .onBackpressureLatest()
    .subscribe();

// 4. ERROR：抛出异常
Flux.range(1, 1_000_000)
    .onBackpressureError()
    .subscribe();

策略选择指南：

策略	适用场景	风险
BUFFER	处理速度略慢于生产速度	可能 OOM
DROP	可以丢弃数据（如日志）	数据丢失
LATEST	只需最新数据（如股票价格）	数据丢失
ERROR	必须保证不丢失	需要重试机制

---

三、Reactor 核心 API

3.1 Mono vs Flux

Mono ：0 或 1 个元素的异步序列
Flux：0 到 N 个元素的异步序列

// Mono：单值
Mono<String> mono = Mono.just("Hello");
Mono<User> userMono = userRepository.findById("123");

// Flux：多值
Flux<Integer> flux = Flux.range(1, 10);
Flux<User> userFlux = userRepository.findAll();

3.2 创建响应式流

// 1. 从已有值创建
Mono<String> mono = Mono.just("Hello");
Flux<String> flux = Flux.just("A", "B", "C");

// 2. 从集合创建
List<String> list = Arrays.asList("A", "B", "C");
Flux<String> flux = Flux.fromIterable(list);

// 3. 从 Stream 创建
Stream<String> stream = Stream.of("A", "B", "C");
Flux<String> flux = Flux.fromStream(stream);

// 4. 从 Callable 创建（懒加载）
Mono<String> mono = Mono.fromCallable(() -> {
    // 只有订阅时才执行
    return expensiveOperation();
});

// 5. 空流
Mono<String> empty = Mono.empty();
Flux<String> emptyFlux = Flux.empty();

// 6. 错误流
Mono<String> error = Mono.error(new RuntimeException("Error"));

// 7. 延迟创建
Mono<Long> defer = Mono.defer(() -> Mono.just(System.currentTimeMillis()));

3.3 转换操作

// map：1:1 转换
Flux<String> names = Flux.just("alice", "bob")
    .map(String::toUpperCase);  // ["ALICE", "BOB"]

// flatMap：1:N 转换（异步）
Flux<Order> orders = Flux.just("user1", "user2")
    .flatMap(userId -> orderService.getOrders(userId));  // 并行执行

// flatMapSequential：保持顺序
Flux<Order> orderedOrders = Flux.just("user1", "user2")
    .flatMapSequential(userId -> orderService.getOrders(userId));

// concatMap：顺序执行
Flux<Order> sequentialOrders = Flux.just("user1", "user2")
    .concatMap(userId -> orderService.getOrders(userId));  // 串行执行

// filter：过滤
Flux<Integer> evens = Flux.range(1, 10)
    .filter(n -> n % 2 == 0);  // [2, 4, 6, 8, 10]

// take：取前 N 个
Flux<Integer> first3 = Flux.range(1, 10)
    .take(3);  // [1, 2, 3]

// skip：跳过前 N 个
Flux<Integer> skipFirst3 = Flux.range(1, 10)
    .skip(3);  // [4, 5, 6, 7, 8, 9, 10]

// distinct：去重
Flux<Integer> unique = Flux.just(1, 2, 2, 3, 3, 3)
    .distinct();  // [1, 2, 3]

3.4 组合操作

// zip：组合（等待所有源完成）
Mono<User> userMono = userRepository.findById("123");
Mono<Profile> profileMono = profileService.getProfile("123");

Mono<UserView> userView = Mono.zip(userMono, profileMono)
    .map(tuple -> new UserView(tuple.getT1(), tuple.getT2()));

// merge：合并（先到先处理）
Flux<String> flux1 = Flux.just("A", "B");
Flux<String> flux2 = Flux.just("C", "D");
Flux<String> merged = Flux.merge(flux1, flux2);  // 顺序不确定

// concat：拼接（顺序执行）
Flux<String> concatenated = Flux.concat(flux1, flux2);  // ["A", "B", "C", "D"]

// combineLatest：组合最新值
Flux<String> combined = Flux.combineLatest(
    Flux.interval(Duration.ofMillis(100)),
    Flux.interval(Duration.ofMillis(200)),
    (a, b) -> "a=" + a + ", b=" + b
);

3.5 错误处理

// onErrorReturn：返回默认值
Mono<String> result = getData()
    .onErrorReturn("默认值");

// onErrorResume：切换到备用流
Mono<String> result = getData()
    .onErrorResume(ex -> getFromCache());

// onErrorMap：转换异常
Mono<String> result = getData()
    .onErrorMap(IOException.class, ex -> new BusinessException("IO错误", ex));

// retry：重试
Mono<String> result = getData()
    .retry(3);  // 重试3次

// retryWhen：条件重试（指数退避）
Mono<String> result = getData()
    .retryWhen(Retry.backoff(3, Duration.ofMillis(100)));

// doOnError：错误时执行操作
Mono<String> result = getData()
    .doOnError(ex -> log.error("错误", ex));

---

四、Spring WebFlux 实战

4.1 响应式 Controller

@RestController
@RequestMapping("/api/products")
public class ProductController {
    
    private final InventoryService inventory;
    private final PricingService pricing;
    
    // 获取单个产品
    @GetMapping("/{id}")
    public Mono<ProductView> getProduct(@PathVariable String id) {
        Mono<Inventory> inventoryMono = inventory.findById(id);
        Mono<Price> priceMono = pricing.findPrice(id);
        
        return Mono.zip(inventoryMono, priceMono)
            .map(tuple -> ProductView.of(tuple.getT1(), tuple.getT2()))
            .timeout(Duration.ofSeconds(2))  // 超时控制
            .onErrorResume(TimeoutException.class,
                ex -> Mono.just(ProductView.fallback(id)));  // 降级
    }
    
    // 获取产品列表
    @GetMapping
    public Flux<Product> getProducts(
        @RequestParam(defaultValue = "0") int page,
        @RequestParam(defaultValue = "10") int size
    ) {
        return productRepository.findAll()
            .skip(page * size)
            .take(size);
    }
    
    // 创建产品
    @PostMapping
    public Mono<Product> createProduct(@RequestBody Mono<Product> productMono) {
        return productMono
            .flatMap(productRepository::save)
            .doOnSuccess(p -> log.info("创建产品: {}", p.getId()));
    }
}

4.2 响应式 Repository

// 使用 Spring Data Reactive
public interface UserRepository extends ReactiveCrudRepository<User, String> {
    
    Flux<User> findByAgeBetween(int minAge, int maxAge);
    
    Mono<User> findByEmail(String email);
    
    @Query("SELECT * FROM users WHERE name LIKE :name")
    Flux<User> searchByName(String name);
}

// 使用 R2DBC
@Service
public class UserService {
    
    private final DatabaseClient databaseClient;
    
    public Mono<User> findById(String id) {
        return databaseClient.sql("SELECT * FROM users WHERE id = :id")
            .bind("id", id)
            .map(row -> new User(
                row.get("id", String.class),
                row.get("name", String.class),
                row.get("email", String.class)
            ))
            .one();
    }
}

4.3 响应式 WebClient

@Service
public class ExternalApiService {
    
    private final WebClient webClient;
    
    public ExternalApiService(WebClient.Builder builder) {
        this.webClient = builder
            .baseUrl("https://api.example.com")
            .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
            .build();
    }
    
    // GET 请求
    public Mono<User> getUser(String id) {
        return webClient.get()
            .uri("/users/{id}", id)
            .retrieve()
            .bodyToMono(User.class)
            .timeout(Duration.ofSeconds(3))
            .retryWhen(Retry.backoff(3, Duration.ofMillis(100)));
    }
    
    // POST 请求
    public Mono<User> createUser(User user) {
        return webClient.post()
            .uri("/users")
            .bodyValue(user)
            .retrieve()
            .bodyToMono(User.class);
    }
    
    // 并行调用多个 API
    public Mono<Dashboard> getDashboard(String userId) {
        Mono<User> userMono = getUser(userId);
        Mono<List<Order>> ordersMono = getOrders(userId);
        Mono<Stats> statsMono = getStats(userId);
        
        return Mono.zip(userMono, ordersMono, statsMono)
            .map(tuple -> new Dashboard(
                tuple.getT1(),
                tuple.getT2(),
                tuple.getT3()
            ));
    }
}

4.4 线程模型与调度器

// Schedulers：线程调度器
public class SchedulerExample {
    
    // parallel：CPU 密集型任务（固定线程池，默认 = CPU 核数）
    public Mono<String> cpuIntensiveTask() {
        return Mono.fromCallable(() -> {
            // 复杂计算
            return compute();
        }).subscribeOn(Schedulers.parallel());
    }
    
    // boundedElastic：IO 密集型/阻塞任务（弹性线程池）
    public Mono<String> blockingTask() {
        return Mono.fromCallable(() -> {
            // 阻塞 IO 操作
            return legacyService.blockingCall();
        }).subscribeOn(Schedulers.boundedElastic());
    }
    
    // single：单线程执行
    public Flux<String> sequentialTask() {
        return Flux.range(1, 10)
            .map(String::valueOf)
            .publishOn(Schedulers.single());
    }
    
    // immediate：当前线程执行
    public Mono<String> immediateTask() {
        return Mono.just("Hello")
            .subscribeOn(Schedulers.immediate());
    }
}

调度器选择指南：

调度器	适用场景	线程池特性
parallel	CPU 密集型计算	固定大小（CPU 核数）
boundedElastic	IO 密集型、阻塞调用	弹性扩展（最多 10 * CPU 核数）
single	顺序执行	单线程
immediate	无需线程切换	当前线程

---

五、常见问题与解决方案

5.1 调试困难

问题：响应式调用栈复杂，难以追踪错误

解决方案：

// 1. 启用调试模式（开发环境）
Hooks.onOperatorDebug();

// 2. 使用 Reactor Debug Agent（生产环境）
// JVM 参数：-javaagent:reactor-tools.jar

// 3. 添加日志
Flux.range(1, 10)
    .doOnNext(i -> log.debug("处理: {}", i))
    .doOnError(ex -> log.error("错误", ex))
    .doOnComplete(() -> log.info("完成"))
    .subscribe();

// 4. 使用 BlockHound 检测阻塞（开发环境）
BlockHound.install();

5.2 阻塞调用处理

问题：第三方库是阻塞的，如何在响应式中使用？

解决方案：

// ❌ 错误：直接阻塞
Mono.just("test")
    .map(s -> {
        return database.query(s);  // 阻塞调用
    });

// ✅ 正确：切换到 boundedElastic
Mono.just("test")
    .publishOn(Schedulers.boundedElastic())
    .map(s -> database.query(s));  // 在弹性线程池执行

// 或使用 fromCallable
Mono.fromCallable(() -> database.query("test"))
    .subscribeOn(Schedulers.boundedElastic());

5.3 内存泄漏

问题：订阅后忘记取消，导致内存泄漏

解决方案：

// ❌ 错误：无限流未取消
Flux.interval(Duration.ofSeconds(1))
    .subscribe(i -> log.info("Tick: {}", i));

// ✅ 正确：使用 Disposable 取消订阅
Disposable disposable = Flux.interval(Duration.ofSeconds(1))
    .subscribe(i -> log.info("Tick: {}", i));

// 在适当时机取消
disposable.dispose();

// 或使用 take 限制数量
Flux.interval(Duration.ofSeconds(1))
    .take(10)
    .subscribe();

5.4 测试响应式代码

@Test
public void testReactiveCode() {
    // 使用 StepVerifier 测试
    Flux<Integer> flux = Flux.range(1, 5)
        .map(i -> i * 2);
    
    StepVerifier.create(flux)
        .expectNext(2, 4, 6, 8, 10)
        .expectComplete()
        .verify();
    
    // 测试错误
    Mono<String> errorMono = Mono.error(new RuntimeException("Error"));
    
    StepVerifier.create(errorMono)
        .expectError(RuntimeException.class)
        .verify();
    
    // 测试超时
    Mono<String> timeoutMono = Mono.delay(Duration.ofSeconds(2))
        .map(i -> "Done");
    
    StepVerifier.create(timeoutMono)
        .expectTimeout(Duration.ofSeconds(1))
        .verify();
}

---

六、从 MVC 迁移到 WebFlux

6.1 迁移步骤

// 步骤 1：改造 Controller
// 旧代码（MVC）
@GetMapping("/user/{id}")
public User getUser(@PathVariable String id) {
    return userService.getUser(id);
}

// 新代码（WebFlux）
@GetMapping("/user/{id}")
public Mono<User> getUser(@PathVariable String id) {
    return userService.getUser(id);  // 返回 Mono<User>
}

// 步骤 2：改造 Service
// 旧代码
public User getUser(String id) {
    return userRepository.findById(id);
}

// 新代码
public Mono<User> getUser(String id) {
    return userRepository.findById(id);  // 使用 Reactive Repository
}

// 步骤 3：处理阻塞调用
public Mono<User> getUser(String id) {
    return Mono.fromCallable(() -> 
        legacyService.getUser(id)  // 阻塞调用
    ).subscribeOn(Schedulers.boundedElastic());
}

6.2 混合使用 MVC 和 WebFlux

// 可以在同一个项目中混合使用
@Configuration
public class WebConfig {
    // MVC 配置
    @Bean
    public WebMvcConfigurer mvcConfigurer() {
        return new WebMvcConfigurer() { /* ... */ };
    }
    
    // WebFlux 配置
    @Bean
    public RouterFunction<ServerResponse> routerFunction(Handler handler) {
        return RouterFunctions.route()
            .GET("/api/reactive/users", handler::getUsers)
            .GET("/api/reactive/users/{id}", handler::getUser)
            .POST("/api/reactive/users", handler::createUser)
            .build();
    }
}

---

七、实战 Checklist

• 评估场景：IO 密集型、高并发场景才适合响应式
• 避免阻塞 ：在 boundedElastic 中执行阻塞调用
• 背压控制：合理选择背压策略，防止内存溢出
• 错误处理 ：添加 timeout、retry、onErrorResume
• 调试支持 ：开启 Hooks.onOperatorDebug() 或使用 Debug Agent
• 监控指标：监控信号速率、延迟、丢弃次数
• 测试覆盖 ：使用 StepVerifier 测试响应式代码
• 资源管理：及时取消订阅，避免内存泄漏

---

八、常见面试题精讲

Q1: 响应式编程与传统 MVC 的区别？

答案：

特性	传统 MVC	WebFlux (Reactor)
线程模型	每请求一个线程	少量事件循环线程
阻塞	阻塞 IO	非阻塞 IO
背压	无	有
扩展性	受线程数限制	高并发支持

Q2: 背压机制如何工作？

答案 ：通过 Subscription.request(n) 让消费者告诉发布者可以处理多少数据，发布者只推送被请求的数据量，避免堆积。

Q3: 何时应该使用响应式编程？

答案：

• ✅ IO 密集型应用（大量网络/数据库调用）
• ✅ 高并发场景（>10000 QPS）
• ❌ CPU 密集型计算
• ❌ 简单 CRUD 应用

---

九、延伸阅读

• 官方文档 ：Project Reactor Reference
• 经典书籍：《Hands-On Reactive Programming in Spring 5》
• 调试工具：BlockHound、Reactor Debug Agent
• 后续学习 ：
  • Netty：响应式底层网络框架
  • RSocket：响应式通信协议
  • Kotlin Coroutines：协程式响应式编程

---

总结 ：响应式编程是现代高并发应用的利器，但也有学习曲线。掌握 Reactor 的核心 API 和最佳实践，能让你在微服务和云原生时代游刃有余。记住：不是所有场景都需要响应式，选择合适的工具才是关键。

---

上一篇回顾 ： 《Java Stream API 进阶指南：从底层实现到性能优化》

我们深入探讨 Stream 的内部机制、并行流的性能优化，以及实际开发中的最佳实践。
下一篇预告 ：《Netty 原理深度解析：事件驱动的高性能网络框架》

我们将探讨 Netty 的事件循环模型、零拷贝优化，以及在真实项目中的应用案例。