Wie kann ich Ausnahmen in der Karte Griff() in einer beobachtbaren in RxJava

Question

Ich möchte, dies zu tun:

Observable.just(bitmap) 
      .map(new Func1<Bitmap, File>() { 
       @Override 
       public File call(Bitmap photoBitmap) { 

        //File creation throws IOException, 
        //I just want it to hit the onError() inside subscribe() 

        File photoFile = new File(App.getAppContext().getCacheDir(), "userprofilepic_temp.jpg"); 
        if(photoFile.isFile()) {//delete the file first if it exists otherwise the new file won't be created 
         photoFile.delete(); 
        } 
        photoFile.createNewFile(); //saves the file in the cache dir 

        FileOutputStream fos = new FileOutputStream(photoFile); 
        photoBitmap.compress(Bitmap.CompressFormat.JPEG, 90, fos);//jpeg format 
        fos.close(); 

        return photoFile; 

       } 
      }) 
      .subscribe(//continue implementation...); 

Grundsätzlich im call() Methode, es Ausnahmen auslösen kann. Wie kann ich den Observer dazu bringen, es in onError() zu behandeln. Oder ist das nicht der richtige Weg, darüber nachzudenken?

Answer 1

Rx wird immer Fehler abfangen, auch wenn dies RuntimeException ist. Sie können also eine Art Runtime-Ausnahme in catch-Block werfen. So sollte es eigentlich funktionieren.

Observable.just(bitmap) 
       .map(b -> { 
        try { 
         // do some work which throws IOException 
         throw new IOException("something went wrong"); 
        } catch (IOException e) { 
         throw new RXIOException(e); 
         // Or you can use 
         throw Exceptions.propagate(e); 
         // This helper method will wrap your exception with runtime one 
        } 
       }).subscribe(o -> { 
        // do something here 
       }, exception -> exception.printStackTrace()); 

public static class RXIOException extends RuntimeException { 
     public RXIOException(IOException throwable) { 
      super(throwable); 
     } 
} 

Answer 2

Mit 1.0.15 gibt es die fromCallable Factory-Methode, die wir an, Sie eine Callable Instanz für jeden Teilnehmer laufen, wo Sie Ausnahmen auch geprüft werfen kann:

Observable.fromCallable(() -> {  
    File photoFile = new File(App.getAppContext().getCacheDir(), 
     "userprofilepic_temp.jpg"); 
    if (photoFile.isFile()) { 
     //delete the file if it exists otherwise the new file won't be created 
     photoFile.delete(); 
    } 
    photoFile.createNewFile(); //saves the file in the cache dir 

    FileOutputStream fos = new FileOutputStream(photoFile); 
    photoBitmap.compress(Bitmap.CompressFormat.JPEG, 90, fos);//jpeg format 
    fos.close(); 

    return photoFile; 
}) 
.subscribe(...) 

Edit:

source.flatMap(v -> { 
    try { 
     //... 
     return Observable.just(result); 
    } catch (Exception e) { 
     return Observable.error(e); 
    } 
}) 
.subscribe(...); 

Answer 3

gerade erstellt Hilfsklasse diese vorformulierten an einen anderen Ort zu extrahieren:

public class RxRethrow { 
    public static <T, R> Func1<T, R> rethrow(Func1R<T, R> catchedFunc) { 
     return t -> { 
      try { 
       return catchedFunc.call(t); 
      } catch (Exception e) { 
       throw Exceptions.propagate(e); 
      } 
     }; 
    } 

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

Sie können es so nennen:

.map(RxRethrow.rethrow(products -> mapper.writer(schema).writeValueAsString(products))) 

Answer 4

Ich weiß nicht, wie die Situation war, als Diese Frage wurde zuerst gestellt und beantwortet, aber RxJava enthält momentan eine Hilfsmethode für genau diesen Zweck: Exceptions.propagate(Throwable t)

RxJava Javadoc

Convenience-Methode eine Runtime und Fehler direkt oder wickeln andere Ausnahme-Typ in eine Runtime zu werfen.