Question

我已经通过实施org.reactivestreams.Publisher实现了一个Reactor运算符，如下所示。但是，我想知道这是否是使用Reactor的 right way™。手动实现订户看起来有点麻烦。 Operators课程似乎在这方面没有帮助。

class MyOperator implements Publisher<Integer> {

    private final Publisher<Integer> source;

    public MyOperator(Publisher<Integer> source) {
        this.source = source;
    }

    @Override
    public void subscribe(Subscriber<? super Integer> target) {
        final Subscriber<Integer> wrappedSubscriber = createSubscriber(target);
        source.subscribe(wrappedSubscriber);
    }

    private Subscriber<Integer> createSubscriber(Subscriber<? super Integer> target) {
        return new Subscriber<Integer>() {
            private Subscription subscription;

            @Override
            public void onSubscribe(Subscription subscription) {
                this.subscription = subscription;
                subscription.request(Long.MAX_VALUE);
            }

            @Override
            public void onNext(Integer integer) {
                target.onNext(integer + 1); // actual behaviour
                subscription.request(Long.MAX_VALUE);
            }

            @Override
            public void onError(Throwable t) {
                target.onError(t);
            }

            @Override
            public void onComplete() {
                target.onComplete();
            }
        };
    }
}

以下示例是 right way™？

class MyCompactOperator implements Publisher<Integer> {

    final Flux<Integer> flux;

    public MyCompactOperator(Publisher<Integer> source) {
        flux = Flux.from(source).map(number -> number + 1);
    }

    @Override
    public void subscribe(Subscriber<? super Integer> subscriber) {
        flux.subscribe(subscriber);
    }
}

至少这需要更少的代码。

以Flux作为来源的变体3，正如SimonBaslé所建议的那样：

class MyFluxOperator extends Flux<Integer> {

    private final Flux<Integer> source;

    public MyFluxOperator(Flux<Integer> source) {
        this.source = source;
    }

    @Override
    public void subscribe(Subscriber<? super Integer> subscriber) {
        source.map(number -> number + 1).subscribe(subscriber);
    }
}

所有实施都按预期工作：

Flux<Integer> source = Flux.just(1, 2, 3, 4, 5);
Flux.from(new MyOperator(source)).subscribe(System.out::println);

// for variant 3
new MyFluxOperator(source).subscribe(System.out::println);

我在第二行使用了Flux来避免实现另一个订阅者。

输出：

问题：

我的实施中是否缺少某些内容？
在Reactor 3中实现运算符是否有更好的方法（代码更少，错误处理更好等）？
两种方法之间是否存在相关的功能或非功能差异？

Answer 1

看到你的第二个选项，你似乎认为你必须实现一个发布者。绝对不是这种情况（相反）。从反应器Flux源（或Publisher + Reactor的Flux.from）开始，然后简单地链接到map。

编辑：澄清您不想创建任何类，只需在主代码路径中执行此操作：

如果您的source已经是Flux或Mono：

Flux<Integer> incrementedSource = source.map(i -> i + 1);
incrementedSource.subscribe(subscriber);

如果您的source是另一种Publisher：

Flux<Integer> incrementedSource = Flux.from(source).map(i -> i + 1);
incrementedSource.subscribe(subscriber);

像Reactor这样的库的整个想法是为您提供直接撰写的操作员，而无需编写Publisher

如果您想要一种共享代码的方法，因为您经常将一组运算符应用于各种Flux，请查看transform和compose（以及reference documentation ）。

如何在Reactor 3中编写运算符？

1 个答案: