RxJava Объединить Последовательность Запросов

на flatMap оператор предназначен для обслуживания этих типов рабочих процессов.

я обрисую широкие штрихи с простым примером из пяти шагов. надеюсь, вы можете легко восстановить те же принципы в своем коде:

@Test fun flatMapExample() {
    // (1) constructing a fake stream that emits a list of values
    Observable.just(listOf(1, 2, 3, 4, 5))
            // (2) convert our List emission into a stream of its constituent values 
            .flatMap { numbers -> Observable.fromIterable(numbers) }
            // (3) subsequently convert each individual value emission into an Observable of some 
            //     newly calculated type
            .flatMap { number ->
                when(number) {
                       1 -> Observable.just("A1")
                       2 -> Observable.just("B2")
                       3 -> Observable.just("C3")
                       4 -> Observable.just("D4")
                       5 -> Observable.just("E5")
                    else -> throw RuntimeException("Unexpected value for number [$number]")
                }
            }
            // (4) collect all the final emissions into a list
            .toList()
            .subscribeBy(
                    onSuccess = {
                        // (5) handle all the combined results (in list form) here
                        println("## onNext($it)")
                    },
                    onError = { error ->
                        println("## onError(${error.message})")
                    }
            )
}

(кстати, если порядок выбросов имеет значение, посмотрите на использование concatMap вместо).

надеюсь, это поможет.

Проверьте ниже, что он работает.

скажем, у вас есть несколько сетевых вызовов, которые вам нужно сделать, чтобы получить информацию о пользователе Github и события пользователя Github, например.

и вы хотите ждать каждого, чтобы вернуться перед обновлением пользовательского интерфейса. RxJava может помочь вам здесь. Давайте сначала определим наш модифицированный объект для доступа к API Github, а затем настроим два наблюдаемых для вызова двух сетевых запросов.

Retrofit repo = new Retrofit.Builder()
        .baseUrl("https://api.github.com")
        .addConverterFactory(GsonConverterFactory.create())
        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
        .build();

Observable<JsonObject> userObservable = repo
        .create(GitHubUser.class)
        .getUser(loginName)
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread());

Observable<JsonArray> eventsObservable = repo
        .create(GitHubEvents.class)
        .listEvents(loginName)
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread());

используется интерфейс для него, как ниже:

public interface GitHubUser {
  @GET("users/{user}")
  Observable<JsonObject> getUser(@Path("user") String user);
}

public interface GitHubEvents {
  @GET("users/{user}/events")
  Observable<JsonArray> listEvents(@Path("user") String user);
}

после того, как мы используем RxJava zip метод объединения наших двух наблюдаемых и ждать их завершения, прежде чем создавать новый наблюдаемый.

Observable<UserAndEvents> combined = Observable.zip(userObservable, eventsObservable, new Func2<JsonObject, JsonArray, UserAndEvents>() {
  @Override
  public UserAndEvents call(JsonObject jsonObject, JsonArray jsonElements) {
    return new UserAndEvents(jsonObject, jsonElements);
  }
});

наконец, давайте вызовем метод subscribe на нашем новом комбинированном наблюдаемом:

combined.subscribe(new Subscriber<UserAndEvents>() {
          ...
          @Override
          public void onNext(UserAndEvents o) {
            // You can access the results of the 
            // two observabes via the POJO now
          }
        });

нет больше ожидания в потоках и т. д. Для завершения сетевых вызовов. RxJava сделал все это для вас в zip(). надеюсь, мой ответ поможет вам.

я решил аналогичную проблему с RxJava2. Выполнение запросов на Api 2 параллельно несколько ускоряет работу.

private InformationRepository informationRepository;

//init....

public Single<List<FullInformation>> getFullInformation() {
    return informationRepository.getInformationList()
            .subscribeOn(Schedulers.io())//I usually write subscribeOn() in the repository, here - for clarity
            .flatMapObservable(Observable::fromIterable)
            .flatMapSingle(this::getFullInformation)
            .collect(ArrayList::new, List::add);

}

private Single<FullInformation> getFullInformation(Information information) {
    return informationRepository.getExtendedInformation(information)
            .map(extendedInformation -> new FullInformation(information, extendedInformation))
            .subscribeOn(Schedulers.io());//execute requests in parallel
}

InformationRepository - просто интерфейс. Его реализация нам не интересна.

public interface InformationRepository {

    Single<List<Information>> getInformationList();

    Single<ExtendedInformation> getExtendedInformation(Information information);
}

FullInformation-контейнер для результата.

public class FullInformation {

    private Information information;
    private ExtendedInformation extendedInformation;

    public FullInformation(Information information, ExtendedInformation extendedInformation) {
        this.information = information;
        this.extendedInformation = extendedInformation;
    }
}

попробуйте использовать Observable.zip() оператора. Он будет ждать, пока оба вызова Api не будут завершены, прежде чем продолжить поток. Затем вы можете вставить некоторую логику, вызвав flatMap() далее.

http://reactivex.io/documentation/operators/zip.html