Android RxJava2如何与其他两个观察者共享一个观察者，并将其合并回订户

我有以下方法

Document createDocument(String url);
List<MediaContent> getVideo(Document doc);
List<MediaContent> getImages(Document doc);

（此外，视频输出应在图像之前排序）

我该怎么做呢？我尝试了flatMap，但它似乎只允许使用一种方法

Single<List<MediaContent>> single = 
    Single.fromCallable(() -> createDocument(url))

      // . ?? .. 
      // this is the part i am lost with
      // how do i feed document to -> getVideo() and getImage()
      // and then merge them back into the subscriber 
      // 
          .subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread());

single.subscribe(parseImageSubscription);

Single=
Single.fromCallable（（）->createDocument（url））
// . ?? .. 
//这是我失去的部分
//如何将文档馈送到->getVideo（）和getImage（）中
//然后将它们合并回订阅服务器
// 
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））；
单次认购（parseImageSubscription）；

可处置的单一观察者

parseImageSubscription = new DisposableSingleObserver<List<MediaContent>>() {
    @Override
    public void onSuccess(List<MediaContent> media) { 
        if(media!=null) {
            appendToRv(media);
        }
    }

    @Override
    public void onError(Throwable error) { 
        doSnackBar("error loading: '" + q + "'");
    }
};

parseImageSubscription=new DisposableSingleObserver（）{
@凌驾
成功时公共无效（列表媒体）{
如果（媒体！=null）{
附录V（媒体）；
}
}
@凌驾
公共无效onError（可丢弃错误）{
doSnackBar（“加载错误：“+q+””）；
}
};

getVideos和getImages的单个可观察对象

Single<List<MediaContent>> SingleGetImage(Document document ) {
    return Single.create(e -> {
        List<MediaContent> result = getImage(document);
        if (result != null) {
            e.onSuccess(result);
        }else {
            e.onError(new Exception("No images found"));
        }
    });
}

Single<List<MediaContent>> singleGetVideo(Document document ) {
    return Single.create(e -> {
        List<MediaContent> result = getVideo( document);
        if (result != null) {
            e.onSuccess(result);
        }else {
            e.onError(new Exception("No videos found"));
        }
    });
}

单个SingleGetImage（文档）{
返回单个。创建（e->{
列表结果=getImage（文档）；
如果（结果！=null）{
e、 成功（结果）；
}否则{
e、 OneError（新异常（“未找到图像”）；
}
});
}
singleGetVideo（文档）{
返回单个。创建（e->{
列表结果=getVideo（文档）；
如果（结果！=null）{
e、 成功（结果）；
}否则{
e、 OneError（新的例外（“未找到视频”）；
}
});
}

假设您希望并行执行

getVideos

和

getImages

请求，您可以将

flatMap（）

与

zip（）

一起使用，zip将收集两个

单曲的两个排放量，您可以将这两个结果合并为一个新值，这意味着您可以对视频
MediaContent
列表进行排序，并将其与图像
MediaContent
列表相结合，然后返回统一列表（或任何您想要的其他对象）：

单曲=
Single.fromCallable（（）->createDocument（url））
.flatMap（document->Single.zip（singleGetVideo（document）、SingleGetImage（document），
（videoMediaContents，imageMediaContents）->//这里有两个结果
//您可以对组合等进行排序并返回统一对象
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））；
单一订阅（parseImageSubscription）
假设您希望并行执行
getVideos
和
getImages
请求，您可以将
flatMap（）
与
zip（）一起使用
，zip将收集两个
单曲的2个发射，您可以将这2个结果组合成一个新值，这意味着您可以对视频
MediaContent
列表进行排序，并将其与图像
MediaContent
列表组合，然后返回统一列表（或任何其他您想要的对象）：

单曲=
Single.fromCallable（（）->createDocument（url））
.flatMap（document->Single.zip（singleGetVideo（document）、SingleGetImage（document），
（videoMediaContents，imageMediaContents）->//这里有两个结果
//您可以对组合等进行排序并返回统一对象
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））；
单一订阅（parseImageSubscription）
Observable.zip（）可以完美地实现它。观察者将通过此方法接收合并结果

public void zip() {
    Observable<Integer> observable1 = Observable.just(1);
    Observable<Integer> observable2 = Observable.just(2);
    Observable.zip(observable1, observable2, new Func2<Integer, Integer, Integer>() {
        @Override
        public Integer call(Integer integer, Integer integer2) {
            return integer + integer2;
        }
    }).subscribe(new Observer<Integer>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Integer o) {
            Logger.i(o.toString());
            //Here will print 3.
        }
    });
}

public void zip（）{
可观察的可观察的1=可观察的。仅（1）；
可观察到的可观察到的2=可观察到的；
zip（Observable 1，Observable 2，new Func2（）{
@凌驾
公共整数调用（整数、整数2）{
返回整数+整数2；
}
}).订阅（新观察员）{
@凌驾
未完成的公共无效（）{
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
public void onNext（整数o）{
Logger.i（o.toString（））；
//这里将打印3。
}
});
}
Observable.zip（）可以完美地实现它。观察者将通过此方法接收合并结果

public void zip() {
    Observable<Integer> observable1 = Observable.just(1);
    Observable<Integer> observable2 = Observable.just(2);
    Observable.zip(observable1, observable2, new Func2<Integer, Integer, Integer>() {
        @Override
        public Integer call(Integer integer, Integer integer2) {
            return integer + integer2;
        }
    }).subscribe(new Observer<Integer>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Integer o) {
            Logger.i(o.toString());
            //Here will print 3.
        }
    });
}

public void zip（）{
可观察的可观察的1=可观察的。仅（1）；
可观察到的可观察到的2=可观察到的；
zip（Observable 1，Observable 2，new Func2（）{
@凌驾
公共整数调用（整数、整数2）{
返回整数+整数2；
}
}).订阅（新观察员）{
@凌驾
未完成的公共无效（）{
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
public void onNext（整数o）{
Logger.i（o.toString（））；
//这里将打印3。
}
});
}

Single<List<MediaContent>> single =
            Single.fromCallable(() -> createDocument(url))
                    .flatMap(document -> Single.zip(singleGetVideo(document), SingleGetImage(document),
                            (videoMediaContents, imageMediaContents) -> //here you'll have the 2 results
                    //you can sort combine etc. and return unified object
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread());

    single.subscribe(parseImageSubscription)

public void zip() {
    Observable<Integer> observable1 = Observable.just(1);
    Observable<Integer> observable2 = Observable.just(2);
    Observable.zip(observable1, observable2, new Func2<Integer, Integer, Integer>() {
        @Override
        public Integer call(Integer integer, Integer integer2) {
            return integer + integer2;
        }
    }).subscribe(new Observer<Integer>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Integer o) {
            Logger.i(o.toString());
            //Here will print 3.
        }
    });
}