Java 如何从aysnc回调创建多个流量

从反应堆的参考指南中，我了解到可以使用

Flux.create（）

将aysnc回调转换为

Flux

然而，有时回调有多种方法来接收多种类型的数据，假设我有如下代码：

asrService.recognize(new Callback() {
    @Override
    public void stateChange(State state) {
        // consume state
    }

    @Override
    public void onResultData(Result result) {
        // consume result
    }
});

---

如何将其转换为两个反应流：

Flux

和

Flux

？

一种方法是使用一些处理器，如DirectProcessor，您可以创建两个不同的处理器，并在事件中向处理器发送项并订阅处理器，但如果您仍然想使用Flux.create，您可以这样做

    Flux<Object> objectFlux;

@Override
public void run(String... args) throws Exception {

    objectFlux = Flux.create(objectFluxSink ->
            asrService.recognize(new Callback() {
                @Override
                public void stateChange(State state) {
                    objectFluxSink.next(state);
                }

                @Override
                public void onResultData(Result result) {
                    objectFluxSink.next(state);
                }
            }));





}

public Flux<Result> getResult(){
 return    objectFlux.filter(o -> o instanceof Result)
            .map(o -> ((Result)o));
}

public Flux<State> geState(){
    return    objectFlux.filter(o -> o instanceof State)
            .map(o -> ((State)o));
}

Flux-objectFlux；
@凌驾
公共无效运行（字符串…参数）引发异常{
objectFlux=Flux.create（objectFluxSink->
assrservice.recognize（新回调（）{
@凌驾
公共无效状态更改（状态）{
objectFluxSink.next（状态）；
}
@凌驾
结果数据上的公共无效（结果）{
objectFluxSink.next（状态）；
}
}));
}
公共流量getResult（）{
返回objectFlux.filter（o->o结果实例）
.map（o->（（结果）o））；
}
公共流量孕育（）{
返回objectFlux.filter（o->o instanceof State）
.map（o->（（State）o））；
}

我仍然认为，使用处理器应该更干净，你不需要做过滤和铸造，但你需要有2个处理器 像这样：

        DirectProcessor <Result> resultDirectProcessor = DirectProcessor.create();
    DirectProcessor<State> stateDirectProcessor = DirectProcessor.create();
    asrService.recognize(new Callback() {
        @Override
        public void stateChange(State state) {
            stateDirectProcessor.onNext(state);
        }

        @Override
        public void onResultData(Result result) {
            resultDirectProcessor.onNext(result);
        }
    });

DirectProcessor resultDirectProcessor=DirectProcessor.create（）；
DirectProcessor stateDirectProcessor=DirectProcessor.create（）；
assrservice.recognize（新回调（）{
@凌驾
公共无效状态更改（状态）{
stateDirectProcessor.onNext（状态）；
}
@凌驾
结果数据上的公共无效（结果）{
resultDirectProcessor.onNext（结果）；
}
});

你能举一个使用处理器的例子吗？@LiangChen是的，我知道答案不会在两次

流量中注册两次回调。创建

工作吗？这样每个

Flux

都将直接属于正确的类型。@SimonBaslé这是不可能的，因为这两个回调方法都在

callback

的接口中，因此没有方法调用

Flux。创建
两次。