que - rxjava library android

RxJava: ¿Cómo manejar el error con el operador zip?

Question

Estoy usando RxJava y RxAndroid con Retrofit2.

Observable<ResponseOne> responseOneObservable = getRetrofitClient().getDataOne()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread());

Observable<ResponseTwo> responseTwoObservable = getRetrofitClient().getDataTwo()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread());

Usando el operador zip como se muestra abajo en los dos observadores anteriores.

 Observable<ArrayList<TestData>> testDataObservable = Observable.zip(responseOneObservable, responseTwoObservable, new Func2<ResponseOne, ResponseTwo, ArrayList<TestData>>() {
            @Override
                public ArrayList<TestData> call(ResponseOne responseOne, ResponseTwo responseTwo) {
                  ArrayList<TestData> testDataList = new ArrayList();
                      // Add test data from response responseOne & responseTwo
                  return testDataList;
            } 
    })
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Subscriber<ArrayList<TestData>>() {

        @Override
        public void onNext(ArrayList<TestData> testDataList) {

        }

        @Override
        public void onCompleted() {
            Log.d(TAG, "onCompleted" );
        }

        @Override
        public void onError(Throwable t) {
            Log.d(TAG, "onError Throwable: " + t.toString() );
        }
    });

Si se produce algún error durante la llamada http de retrofit en responseOneObservable y responseTwoObservable , se llamará directamente onError método onError del suscriptor de testDataObservable .

Quiero continuar con el método de call del operador zip, incluso si cualquiera de los dos observables obtuvo una respuesta exitosa.

¿Cómo manejar la respuesta de error usando zip operador zip ?

Answer 1

Debe usar onErrorResumeNext sobre los observables con un solo zip para indicarles que emitan un elemento predeterminado en caso de error.

Consulte a los operadores de manejo de errores

Answer 2

Puede devolver la respuesta predeterminada de cualquiera de los dos observables con el operador onErrorResumeNext .

Observable<ResponseOne> responseOneObservable = getRetrofitClient().getDataOne()
    .onErrorResumeNext(throwable -> {/*some default value*/})
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread());

Observable<ResponseTwo> responseTwoObservable = getRetrofitClient().getDataTwo()
    .onErrorResumeNext(throwable -> {/*some default value*/})
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread());

También vea Manejo de errores en RxJava - Dan Lew

Answer 3

Puede usar onErrorResumeNext para devolver algunos Observable u onErrorReturn para devolver algún valor predeterminado a zip , como:

Observable.zip(
   responseOneObservable
       .onErrorReturn(new Func1<Throwable, ResponseOne>() {
        @Override
        public ResponseOne call(final Throwable throwable) {
            return new ResponseOne();
        }
    }),
   responseTwoObservable
       .onErrorReturn(new Func1<Throwable, ResponseTwo>() {
        @Override
        public ResponseTwo call(final Throwable throwable) {
            return new ResponseTwo();
        }
    }),
   ...

Ver manejo de errores para más información.