Prevenire OnErrorNotImplementedException

Question

voglio ottenere che se chiamo il metodo Obervable.subscribe(Action1), non buttare OnErrorNotImplementedException ovunque, ma se chiamo Obervable.subscribe(Action1, Action1), la seconda azione viene chiamato quando un'errore viene generato come normale. Ho provato due modi:

.onErrorResumeNext(Observable.empty()) 

questo modo OnErrorNotImplementedException non si butta, se mi passa anche la seconda azione, l'azione non viene mai chiamato neanche.

Secondo:

.lift(new Observable.Operator<T, T>() { 
    @Override 
    public Subscriber<? super T> call(Subscriber<? super T> subscriber) { 
     return new Subscriber<T>() { 
      @Override 
      public void onCompleted() { 
       if (!subscriber.isUnsubscribed()) { 
        subscriber.onCompleted(); 
       } 
      } 

      @Override 
      public void onError(Throwable e) { 
       if (!subscriber.isUnsubscribed()) { 
        try { 
         subscriber.onError(e); 
        } catch (Throwable t) { 
         if (!(t instanceof OnErrorNotImplementedException)) { 
          throw t; 
         } 
        } 
       } 
      } 

      @Override 
      public void onNext(T t) { 
       if (!isUnsubscribed()) { 
        subscriber.onNext(t); 
       } 
      } 
     }; 
    } 
}); 

Il problema con questo se observeOn() è chiamato più tardi allora questo sarà asincrona e ovviamente la mia gestione qui un'eccezione non funzionerà.

C'è un modo per raggiungere questo obiettivo. Vorrei che ci sarebbe un metodo subscribe() che non getta OnErrorNotImplementedException in onError.

Answer 1

ecco come lo facciamo al lavoro. Invece di fare azioni, abbiamo creato un NYTSubscriber astratto che ha implementato onError e onCompleted. In questo modo è possibile utilizzare questo abbonato e implementare solo la richiamata onNext o si può ignorare onError e onCompleted quando necessario

public abstract class NYTSubscriber<T> extends Subscriber<T> { 

@Override 
public void onCompleted() { 
} 

@Override 
public void onError(Throwable e) { 
} 
} 

Answer 2

Ecco un'altra soluzione possibile, è possibile definire l'onNext e un Throwable (inoltre, non si può perdere la lambda sintassi):

.subscribe(t -> doSomething(t), e -> showError(e)); 

Answer 3

quando si esegue come questo '.onErrorResumeNext (Observable.empty())' il vostro flusso sarà completata in caso di errore - è per questo che le vostre azioni non viene mai chiamato. È possibile l'utente '.retry()' e il flusso verrà riavviato automaticamente in caso di errore.