在使用 SmallRye Mutiny 进行异步事件处理时，有时会遇到订阅者（Subscriber）无法接收到事件的情况，导致 onNext 方法未被调用的问题。这通常是由于 Reactive Streams 的背压机制导致的。理解并正确处理背压是解决此类问题的关键。
背压机制
Reactive Streams 规范引入了背压机制，用于控制数据流的速度，避免生产者（Publisher）产生数据的速度超过消费者（Subscriber）的处理能力，从而导致资源耗尽或程序崩溃。在这种机制下，消费者需要显式地向生产者请求数据，生产者才会发送相应的数据。
解决方案一：手动请求数据
当使用标准的 Subscriber 接口时，需要在 onSubscribe 方法中保存 Subscription 对象，并在 onNext 方法中调用 subscription.request(long) 方法，显式地请求下一个数据。request(long) 方法的参数表示请求的数据量。通常情况下，每次处理完一个数据后，请求下一个数据即可。
以下是修改后的代码示例：
import io.smallrye.mutiny.Multi;
import org.reactivestreams.Subscription;
import org.reactivestreams.Subscriber;
import java.util.concurrent.Executor;
public class MutinyExample {
private final Executor managedExecutor;
public MutinyExample(Executor managedExecutor) {
this.managedExecutor = managedExecutor;
}
public void writeTo(Multi events) {
events
.runSubscriptionOn(managedExecutor)
.subscribe()
.withSubscriber(
new Subscriber() {
private Subscription subscription;
@Override
public void onSubscribe(Subscription s) {
System.out.println("OnSubscription Method");
System.out.println("ON SUBS END");
subscription = s;
subscription.request(1); // 请求第一个数据
}
@Override
public void onNext(String event) {
System.out.println("On Next Method: " + event);
subscription.request(1); // 处理完一个数据后，请求下一个数据
}
@Override
public void onError(Throwable t) {
System.out.println("OnError Method: " + t.getMessage());
}
@Override
public void onComplete() {
System.out.println("On Complete Method");
}
});
}
public static void main(String[] args) throws InterruptedException {
// 模拟一个 Multi
Multi events = Multi.createFrom().items("Event 1", "Event 2", "Event 3");
// 创建一个 Executor (这里使用一个简单的 Executor)
Executor executor = Runnable::run;
// 创建 MutinyExample 实例
MutinyExample example = new MutinyExample(executor);
// 调用 writeTo 方法
example.writeTo(events);
// 等待一段时间，确保异步操作完成
Thread.sleep(1000);
}
} 注意事项：
- 务必在 onSubscribe 方法中保存 Subscription 对象。
- 在 onNext 方法中处理完数据后，必须调用 subscription.request(long) 方法请求下一个数据。
- 如果生产者发送的数据量很大，可以根据消费者的处理能力调整 request(long) 方法的参数。
解决方案二：使用 SmallRye 提供的简化 API
SmallRye Mutiny 提供了更简洁的 API 来处理事件流，避免了手动管理 Subscription 对象的麻烦。可以使用 onSubscription、onItem、onFailure 和 onCompletion 方法来注册相应的回调函数。
以下是使用简化 API 的代码示例：
import io.smallrye.mutiny.Multi;
import java.util.concurrent.Executor;
public class MutinyExampleSimplified {
private final Executor managedExecutor;
public MutinyExampleSimplified(Executor managedExecutor) {
this.managedExecutor = managedExecutor;
}
public void writeTo(Multi events) {
events
.runSubscriptionOn(managedExecutor)
.onSubscription()
.invoke(() -> {
System.out.println("OnSubscription Method");
System.out.println("ON SUBS END");
})
.onItem()
.invoke(event -> System.out.println("On Next Method: " + event))
.onFailure()
.invoke(t -> System.out.println("OnError Method: " + t.getMessage()))
.onCompletion()
.invoke(() -> System.out.println("On Complete Method"))
.subscribe()
.with(value -> {});
}
public static void main(String[] args) throws InterruptedException {
// 模拟一个 Multi
Multi events = Multi.createFrom().items("Event 1", "Event 2", "Event 3");
// 创建一个 Executor (这里使用一个简单的 Executor)
Executor executor = Runnable::run;
// 创建 MutinyExampleSimplified 实例
MutinyExampleSimplified example = new MutinyExampleSimplified(executor);
// 调用 writeTo 方法
example.writeTo(events);
// 等待一段时间，确保异步操作完成
Thread.sleep(1000);
}
} 总结
在使用 SmallRye Mutiny 进行异步事件处理时，理解 Reactive Streams 的背压机制至关重要。可以通过手动请求数据或使用 SmallRye 提供的简化 API 来解决订阅者无法接收到事件的问题。选择哪种方案取决于具体的需求和个人偏好。使用简化 API 可以减少代码量，提高可读性，但手动管理 Subscription 对象可以更精细地控制数据流。
