Creare Osservabile senza utilizzare Observable.create

Sto utilizzando RxJava nella mia applicazione Android e desidero caricare i dati dal database.

In questo modo, sto generando un nuovo Observable utilizzando Observable.create() che restituisce un elenco di EventLog

  • Riconoscimento della moneta su Android
  • Problema di memory di Viewpager Webview
  • Data binding di Android (simile a WPF)?
  • Come impostare OnClickListener su un RadioButton in Android?
  • Ottenere i dati dettagliati successivi e precedenti da listview
  • L'esecuzione di comandi di adb nell'app consente di negare il permesso
  •  public Observable<List<EventLog>> loadEventLogs() { return Observable.create(new Observable.OnSubscribe<List<EventLog>>() { @Override public void call(Subscriber<? super List<EventLog>> subscriber) { List<DBEventLog> logs = new Select().from(DBEventLog.class).execute(); List<EventLog> eventLogs = new ArrayList<>(logs.size()); for (int i = 0; i < logs.size(); i++) { eventLogs.add(new EventLog(logs.get(i))); } subscriber.onNext(eventLogs); } }); } 

    Anche se funziona correttamente, ho letto che l'utilizzo di Observable.create() non è in realtà una pratica migliore per Rx Java (vedi qui ).

    Così ho cambiato questo metodo in questo modo.

     public Observable<List<EventLog>> loadEventLogs() { return Observable.fromCallable(new Func0<List<EventLog>>() { @Override public List<EventLog> call() { List<DBEventLog> logs = new Select().from(DBEventLog.class).execute(); List<EventLog> eventLogs = new ArrayList<>(logs.size()); for (int i = 0; i < logs.size(); i++) { eventLogs.add(new EventLog(logs.get(i))); } return eventLogs; } }); } 

    È questo un approccio migliore utilizzando Rx Java? Perché? Qual è la differenza tra i due methods?

    Inoltre, dal momento che il database carica un elenco di elementi, ha senso per emettere l'intera list in una sola volta? Oppure dovrei emettere un elemento alla volta?

  • Android TTS aggiunge le lingue
  • Applicazione Android: come leggere get i parametri da un programma url personalizzato?
  • Perché Gradle costruisce il mio module in modalità di rilascio quando l'applicazione è in Debug
  • Effetto curl della pagina Android su layout / s
  • Android Studio 2.0 - schermata di pausa / bianco sulla prima esecuzione dell'app
  • Utilizzo della libreria LGPL nell'applicazione Android a pagamento
  • 2 Solutions collect form web for “Creare Osservabile senza utilizzare Observable.create”

    I due methods possono sembrare simili e si comportno da simili, ma da fromCallable con le difficoltà di backpressure per te mentre la versione create non lo fa. Affrontare il backpressure all'interno di un'implementazione OnSubscribe va da una semplice a una mente OnSubscribe ; tuttavia, se omesso, puoi get MissingBackpressureException s lungo i confini asincroni (ad esempio observeOn ) o addirittura sui confini di continuazione (come concat ).

    RxJava tenta di offrire un supporto adeguato al backpressure per tutte le fabbriche e gli operatori possibili, tuttavia esistono molte fabbriche e operatori che non possono sostenerlo.

    Il secondo problema con l'implementazione manuale di OnSubscribe è la mancanza di supporto per la cancellazione, in particolare se si genera un sacco di chiamate onNext . Molti di questi possono essere sostituiti da methods di fabbrica standard (ad esempio from ) o classi di helper (come SyncOnSubscribe ) che si occupano di tutta la complessità per te.

    Potresti trovare un sacco di introduzioni e esempi che utilizzano (ancora) l'utilizzo per due ragioni.

    1. È molto più facile introdurre i datastream push-based mostrando come funziona la spinta degli events in modo imperativo. A mio parere, tali fonti trascorrono troppo tempo con la create proporzionale, anziché parlare dei methods di fabbrica standard e mostrare come determinate operazioni comuni (come le tue) possono essere raggiunte in modo sicuro.
    2. Molti di questi esempi sono stati creati il ​​tempo che RxJava non ha richiesto il supporto backpressure o addirittura un supporto sincrono sincrono o sono stati semplicemente portti dagli esempi Rx.NET (che fino ad oggi non support il backpressure e la cancellazione sincrona in qualche modo, a causa di C # I indovinare.) La generazione di valori chiamando Onextra era senza preoccupazioni di allora. Tuttavia, tale utilizzo port a un block di buffer e all'utilizzo eccessivo della memory, pertanto, la squadra di Netflix ha fornito un modo per limitare l'utilizzo della memory, richiedendo agli osservatori di indicare quanti elementi sono disposti a procedere. Questo è stato conosciuto come backpressure.

    Per la seconda domanda, vale a dire se si dovrebbe creare un elenco o una sequenza di valori, dipende dalla vostra origine. Se la tua fonte support una sorta di iterazione o di streaming di singoli elementi di dati (ad esempio JDBC), è sufficiente collegarlo e emettere uno per uno (vedere SyncOnSubscribe ). Se non lo support o ne hai bisogno in forma List, comunque, mantenilo com'è. È ansible convertire sempre tra le due forms attraverso la toList e il flatMapIterable se necessario.

    Come spiegato nella risposta che hai collegato, con Observable.create potresti aver bisogno di violare i requisiti avanzati di RxJava.

    Ad esempio, è necessario implementare la contropressione o come disdire la sottoscrizione.

    In questo caso, si desidera emettere un elemento, senza wherer affrontare il backpressure o l'abbonamento. Così Observable.fromCallable è una buona chiamata. RxJava si occuperà del resto.

    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.