Java Observable pour lancer une erreur si elle se produit

Question

Y at-il un moyen d'avoir un Observable juste jeter une exception qui se produit dans une fonction comme flatMap()?

En Java, une fonction normale, vous pouvez spécifier qu'il peut lancer une exception:

public void dangerousFunction() throws IOException {} 

Au sein d'une fonction Observable comme flatMap(), je ne peux pas sembler trouver une syntaxe similaire. Je peux utiliser une try/catch comme ceci:

myObservable.flatMap(() -> { 
    try { 
     return dangerousFunction(); 
    } catch (IOException e) { 
     return Observable.error(e); 
    } 
}); 

Y at-il une méthode plus propre pour écrire cela? Si j'ai beaucoup de cartes et/ou Observables, cela finit par être beaucoup de try/catch blocs encombrant mon code.

Answer 1

L'approche standard pour gérer les exceptions dans une méthode RxJava map() consiste à propager l'exception par catch-and-throw. Par exemple:

.map(b -> { 
    try { 
     ... 
    } catch (IOException ex) { 
     // manual catch and throw 
     throw new RuntimeException(ex); 

     // or catch-and-throw using a built-in helper 
     throw Exceptions.propagate(e); 
    } 
}) 

Cela peut être obtenir assez bavard quand il est répété sur plusieurs map() appels que vous pouvez donc définir une aide pour envelopper ce comportement par exemple

observable.map(RxMapWrapper.wrapAndThrow(new RxMapWrapper.Func1Wrapper<A, B>() { 
     @Override 
     public B call(A document) throws Exception { 
      // your map logic here ... 
     } 
    })) 

public class RxMapWrapper { 
    public static <T, R> Func1<T, R> wrapAndThrow(Func1Wrapper<T, R> caughtFunction) { 
     return t -> { 
      try { 
       return caughtFunction.call(t); 
      } catch (Exception e) { 
       throw Exceptions.propagate(e); 
      } 
     }; 
    } 

    public interface Func1Wrapper<T, R> extends Function { 
     R call(T t) throws Exception; 
    } 
} 

Answer 2

Si vous voulez seulement revenir Observable.error(e) blocs catch à l'intérieur, vous n'avez pas besoin try/catch du tout. L'exception irait en aval et .subscribe(,throwable) l'attraperait de toute façon.

Si vous souhaitez renvoyer un autre objet/défaut en cas d'erreur, essayez ces opérateurs: onErrorReturnItem, onErrorResumeNext, onErrorReturn. Ce serait plus propre.

Une autre option implémenterait ce mécanisme onErrorReturnItem dans vos méthodes elle-même au lieu de lancer Exception.