rxjavaandroid如何使用Zip操作符

对于我的android项目，我在理解RxJava中的zip操作符时遇到了很多困难。 问题 我需要能够发送一个网络请求上传视频 然后我需要发送一个网络请求来上传一张照片 最后，我需要添加一个描述，并使用前两个请求的响应将视频和图片的位置URL与描述一起上传到我的服务器

我认为zip操作符非常适合这个任务，因为据我所知，我们可以获取两个可观察对象（视频和图片请求）的响应，并将它们用于我的最终任务。 但我似乎无法按照我的设想实现这一点

我正在寻找一个人来回答如何做到这一点，可以在概念上与psuedo代码位。

---

谢谢

zip

运算符允许您从两个不同的可观察结果合成结果

// assuming each observable returns response in the form of String
Observable<String> movOb = Observable.create(...);
// if you use Retrofit
Observable<String> picOb = RetrofitApiManager.getService().uploadPic(...),
Observable.zip(movOb, picOb, new Func2<String, String, MyResult>() {
      @Override
      public MyResult call(String movieUploadResponse, String picUploadResponse) {
          // analyze both responses, upload them to another server
          // and return this method with a MyResult type
          return myResult;
      }
   }
)
// continue chaining this observable with subscriber
// or use it for something else

您必须给出am lambda，该lambda将根据每个可观察对象发出的数据创建一个结果

Observable<MovieResponse> movies = ...
Observable<PictureResponse> picture = ...

Observable<Response> response = movies.zipWith(picture, (movie, pic) -> {
        return new Response("description", movie.getName(), pic.getUrl());

});

可观察电影=。。。
可观察图片=。。。
可观察的反应=电影。zipWith（图片，（电影，图片）->{
返回新的响应（“description”，movie.getName（），pic.getUrl（））；
});

Zip操作符严格地对来自可观察对象的发射项进行配对。它等待两个（或多个）项目到达，然后合并它们。因此，是的，这将适合您的需要

我将使用

Func2

链接前两个观测值的结果。 注意，如果您使用改型，这种方法会更简单，因为它的api接口可能会返回一个可观察的结果。否则，您需要创建自己的可观察对象

// assuming each observable returns response in the form of String
Observable<String> movOb = Observable.create(...);
// if you use Retrofit
Observable<String> picOb = RetrofitApiManager.getService().uploadPic(...),
Observable.zip(movOb, picOb, new Func2<String, String, MyResult>() {
      @Override
      public MyResult call(String movieUploadResponse, String picUploadResponse) {
          // analyze both responses, upload them to another server
          // and return this method with a MyResult type
          return myResult;
      }
   }
)
// continue chaining this observable with subscriber
// or use it for something else

//假设每个可观察对象以字符串形式返回响应
可观察的movOb=可观察的。创建（…）；
//如果你使用改装
Observable picOb=ReformationApiManager.getService（）.uploadPic（…），
zip（movOb、picOb、newfunc2（）{
@凌驾
公共MyResult调用（String movieUploadResponse、String picUploadResponse）{
//分析两个响应，将它们上载到另一台服务器
//并使用MyResult类型返回此方法
返回我的结果；
}
}
)
//继续将此可观察对象链接到订阅服务器
//或者用它来做别的事情

这里我举了一个例子，我是以异步方式使用Zip的，以防万一

      /**
 * Since every observable into the zip is created to subscribeOn a diferent thread, it´s means all of them will run in parallel.
 * By default Rx is not async, only if you explicitly use subscribeOn.
  */
@Test
public void testAsyncZip() {
    scheduler = Schedulers.newThread();
    scheduler1 = Schedulers.newThread();
    scheduler2 = Schedulers.newThread();
    long start = System.currentTimeMillis();
    Observable.zip(obAsyncString(), obAsyncString1(), obAsyncString2(), (s, s2, s3) -> s.concat(s2)
                                                                                        .concat(s3))
              .subscribe(result -> showResult("Async in:", start, result));
}

/**
 * In this example the the three observables will be emitted sequentially and the three items will be passed to the pipeline
 */
@Test
public void testZip() {
    long start = System.currentTimeMillis();
    Observable.zip(obString(), obString1(), obString2(), (s, s2, s3) -> s.concat(s2)
                                                                         .concat(s3))
              .subscribe(result -> showResult("Sync in:", start, result));
}


public void showResult(String transactionType, long start, String result) {
    System.out.println(result + " " +
                               transactionType + String.valueOf(System.currentTimeMillis() - start));
}

public Observable<String> obString() {
    return Observable.just("")
                     .doOnNext(val -> {
                         System.out.println("Thread " + Thread.currentThread()
                                                              .getName());
                     })
                     .map(val -> "Hello");
}

public Observable<String> obString1() {
    return Observable.just("")
                     .doOnNext(val -> {
                         System.out.println("Thread " + Thread.currentThread()
                                                              .getName());
                     })
                     .map(val -> " World");
}

public Observable<String> obString2() {
    return Observable.just("")
                     .doOnNext(val -> {
                         System.out.println("Thread " + Thread.currentThread()
                                                              .getName());
                     })
                     .map(val -> "!");
}

public Observable<String> obAsyncString() {
    return Observable.just("")
                     .observeOn(scheduler)
                     .doOnNext(val -> {
                         System.out.println("Thread " + Thread.currentThread()
                                                              .getName());
                     })
                     .map(val -> "Hello");
}

public Observable<String> obAsyncString1() {
    return Observable.just("")
                     .observeOn(scheduler1)
                     .doOnNext(val -> {
                         System.out.println("Thread " + Thread.currentThread()
                                                              .getName());
                     })
                     .map(val -> " World");
}

public Observable<String> obAsyncString2() {
    return Observable.just("")
                     .observeOn(scheduler2)
                     .doOnNext(val -> {
                         System.out.println("Thread " + Thread.currentThread()
                                                              .getName());
                     })
                     .map(val -> "!");
}

/**
*由于zip中的每个可观察对象都是在不同的线程上创建的，这意味着它们都将并行运行。
*默认情况下，只有在显式使用subscribeOn时，Rx才是异步的。
*/
@试验
public-void-testAsyncZip（）{
scheduler=Schedulers.newThread（）；
scheduler1=Schedulers.newThread（）；
scheduler2=Schedulers.newThread（）；
长启动=System.currentTimeMillis（）；
obaservable.zip（obAsyncString（），obAsyncString1（），obAsyncString2（），（s，s2，s3）->s.concat（s2）
康卡特先生（s3））
.subscribe（结果->显示结果（“异步输入：”，开始，结果））；
}
/**
*在本例中，三个观测值将依次发射，三个项目将传递到管道
*/
@试验
公共void testZip（）{
长启动=System.currentTimeMillis（）；
Observable.zip（obString（），obString1（），obString2（），（s，s2，s3）->s.concat（s2）
康卡特先生（s3））
.subscribe（结果->显示结果（“同步到：”，开始，结果））；
}
公共void showResult（字符串事务类型、长起始、字符串结果）{
System.out.println（结果+“”+
transactionType+String.valueOf（System.currentTimeMillis（）-start））；
}
公共可观测obString（）{
返回可观察。仅（“”）
.doOnNext（val->{
System.out.println（“Thread”+Thread.currentThread（）
.getName（））；
})
.map（val->“你好”）；
}
公共可观测obString1（）{
返回可观察。仅（“”）
.doOnNext（val->{
System.out.println（“Thread”+Thread.currentThread（）
.getName（））；
})
.地图（val->“世界”）；
}
公共可观测obString2（）{
返回可观察。仅（“”）
.doOnNext（val->{
System.out.println（“Thread”+Thread.currentThread（）
.getName（））；
})
.地图（val->“！”）；
}
公共可观测的obAsyncString（）{
返回可观察。仅（“”）
.observeOn（调度程序）
.doOnNext（val->{
System.out.println（“Thread”+Thread.currentThread（）
.getName（））；
})
.map（val->“你好”）；
}
公共可观测的obAsyncString1（）{
返回可观察。仅（“”）
.observeOn（附表1）
.doOnNext（val->{
System.out.println（“Thread”+Thread.currentThread（）
.getName（））；
})
.地图（val->“世界”）；
}
公共可观测的obAsyncString2（）{
返回可观察。仅（“”）
.observeOn（附表2）
.doOnNext（val->{
System.out.println（“Thread”+Thread.currentThread（）
.getName（））；
})
.地图（val->“！”）；
}

您可以在此处看到更多示例

一个小示例：

val observableOne = Observable.just("Hello", "World")
val observableTwo = Observable.just("Bye", "Friends")
val zipper = BiFunction<String, String, String> { first, second -> "$first - $second" }
Observable.zip(observableOne, observableTwo, zipper)
  .subscribe { println(it) }

---

在

BiFunction

中，第一个

String

类型

@Test
public void zipOperator() throws Exception {

    List<Integer> indexes = Arrays.asList(0, 1, 2, 3, 4);
    List<String> letters = Arrays.asList("a", "b", "c", "d", "e");

    Observable<Integer> indexesObservable = Observable.fromIterable(indexes);

    Observable<String> lettersObservable = Observable.fromIterable(letters);

    Observable.zip(indexesObservable, lettersObservable, mergeEmittedItems())
            .subscribe(printMergedItems());
}

@NonNull
private BiFunction<Integer, String, String> mergeEmittedItems() {
    return new BiFunction<Integer, String, String>() {
        @Override
        public String apply(Integer index, String letter) throws Exception {
            return "[" + index + "] " + letter;
        }
    };
}

@NonNull
private Consumer<String> printMergedItems() {
    return new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            System.out.println(s);
        }
    };
}

[0] a
[1] b
[2] c
[3] d
[4] e

//
// API Client Interface
//
@GET(ServicesConstants.API_PREFIX + "questions/{id}/")
Single<Response<ResponseGeneric<List<ResponseQuestion>>>> getBaseQuestions(@Path("id") int personId);

@GET(ServicesConstants.API_PREFIX + "physician/{id}/")
Single<Response<ResponseGeneric<List<ResponsePhysician>>>> getPhysicianInfo(@Path("id") int personId);

//
// API middle layer - NOTE: I had feedback that the Single.create is not needed (but I haven't yet spent the time to improve it)
//
public Single<List<ResponsePhysician>> getPhysicianInfo(int personId) {
    return Single.create(subscriber -> {
        apiClient.getPhysicianInfo(appId)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .subscribe(response -> {
                    ResponseGeneric<List<ResponsePhysician>> responseBody = response.body();
                    if(responseBody != null && responseBody.statusCode == 1) {
                        if (!subscriber.isDisposed()) subscriber.onSuccess(responseBody.data);
                    } else if(response.body() != null && response.body().status != null ){
                        if (!subscriber.isDisposed()) subscriber.onError(new Throwable(response.body().status));
                    } else {
                        if (!subscriber.isDisposed()) subscriber.onError(new Throwable(response.message()));
                    }
                }, throwable -> {
                    throwable.printStackTrace();
                    if(!subscriber.isDisposed()) subscriber.onError(throwable);
                });
    });
}

public Single<List<ResponseQuestion>> getHealthQuestions(int personId){
    return Single.create(subscriber -> {
        apiClient.getBaseQuestions(personId)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .subscribe(response -> {
                    ResponseGeneric<List<ResponseQuestion>> responseBody = response.body();
                    if(responseBody != null && responseBody.data != null) {
                        if (!subscriber.isDisposed()) subscriber.onSuccess(response.body().data);
                    } else if(response.body() != null && response.body().status != null ){
                        if (!subscriber.isDisposed()) subscriber.onError(new Throwable(response.body().status));
                    } else {
                        if (!subscriber.isDisposed()) subscriber.onError(new Throwable(response.message()));
                    }
                }, throwable -> {
                    throwable.printStackTrace();
                    if(!subscriber.isDisposed()) subscriber.onError(throwable);
                });
    });
}

//please note that ResponseGeneric is just an outer wrapper of the returned data - common to all API's in this project

public class ResponseGeneric<T> {

    @SerializedName("Status")
    public String status;

    @SerializedName("StatusCode")
    public float statusCode;

    @SerializedName("Data")
    public T data;
}

//
// API end-use layer - this gets close to the UI so notice the oberver is set for main thread
//
private static class MergedResponse{// this is just a POJO to store all the responses in one object
    public List<ResponseQuestion> listQuestions;
    public List<ResponsePhysician> listPhysicians;
    public MergedResponse(List<ResponseQuestion> listQuestions, List<ResponsePhysician> listPhysicians){
        this.listQuestions = listQuestions;
        this.listPhysicians = listPhysicians;
    }
}

// example of Single.zip() - calls getHealthQuestions() and getPhysicianInfo() from API Middle Layer
private void downloadHealthQuestions(int personId) {
    addRxSubscription(Single
            .zip(getHealthQuestions(personId), getPhysicianInfo(personId), MergedResponse::new)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(response -> {
                if(response != null) {
                    Timber.i(" - total health questions downloaded %d", response.listQuestions.size());
                    Timber.i(" - physicians downloaded %d", response.listPhysicians.size());

                    if (response.listPhysicians != null && response.listPhysicians.size()>0) {
                        // do your stuff to process response data
                    }

                    if (response.listQuestions != null && response.listQuestions.size()>0) {

                        // do your stuff to process response data
                    }


                } else {
                    // process error - show message
                }
            }, error -> {
                // process error - show network error message
            }));
}

Observable<MovieResponse> movies = ...
Observable<PictureResponse> picture = ...

Observable<ZipResponse> response = Observable.zip(movies, picture, ZipResponse::new);

class ZipResponse {
        private MovieResponse movieResponse;
        private PictureResponse pictureResponse;

        ZipResponse(MovieResponse movieResponse, PictureResponse pictureResponse) {
             this.movieResponse = movieResponse;
             this.pictureResponse = pictureResponse;
        }

        public MovieResponse getMovieResponse() {
             return movieResponse;
        }

        public void setMovieResponse(MovieResponse movieResponse) {
            this.movieResponse= movieResponse;
        }

        public PictureResponse getPictureResponse() {
             return pictureResponse;
        }

        public void setPictureResponse(PictureResponse pictureResponse) {
            this.pictureResponse= pictureResponse;
        }
}