rxjava2 - RxJava 2.x: ¿Debo usar Flowable o Single/Completable?
rx single (5)
Hmm ...
Creo que la pregunta no es trivial, mientras que te enfrentas a una situación más compleja.
P.ej. Guardar usuario (REST)> Guardar usuario (SQLlite)
Es posible que desee encadenar flujos de Rx en uno.
Así que o bien usted declara
1.
Flowable<Response<Void>> saveUser(String username, String hashedPassword, boolean logged, User user);
y luego use algunos de: flatMap, contactMap, switchMap
2.
... o creo que puede ser más preferible no confundir la responsabilidad de clase (puede usar el mismo código en muchos lugares)
Single<Response<Void>> saveUser(String username, String hashedPassword, boolean logged, User user);
RestService.saveUser(...)
.toFlowable() // Transform into Flowable
.switchMap{ saveToDB() }
.subscribeBy{ ... }
.addTo( yourDisposable )
3.
Por cierto, sugiero que no utilices Completable en caso de que quieras tener un buen manejo de errores. Puede ajustar fácilmente Retrofit.Response<Body> en Single o Flowable para aprovechar la respuesta del código del servidor
Estoy desarrollando una aplicación para Android usando Clean Architecture y la estoy migrando a RxJava 2.x. Tengo que hacer algunas solicitudes de red a un servicio de jabón, así que definí la interfaz api en el módulo de dominio:
public interface SiginterApi {
Observable<User> login(String user, String password);
...
Observable<List<Campaign>> getCampaigns(List<Long> campaignIds);
}
He leído que una solicitud de red debe hacerse con " Flowable ", debido a la gestión de la contrapresión, ya que es un "frío observable". Por otro lado, sé que el resultado de la solicitud será un éxito (con la respuesta) o un error, por lo que no sé si debo usar Flowable o Single o incluso Observable .
Además, tengo una base de datos de accesos como esta:
public interface UserRepository extends Repository {
Observable<Void> saveUser(String username, String hashedPassword, boolean logged, User user);
...
Observable<User> findUser(String username, String hashedPassword);
}
No sé si debo usar Completable / Flowable / Observable en el método saveUser y Single / Flowable / Observable en el método findUser .
La cardinalidad es una forma de entender las diferencias entre Completable , Maybe y Single :
- Un
Maybe<T>es solo un Observable con cardinalidad 0 o 1, es decir, representa un resultado que puede estar presente o no. - Un
Single<T>es un observable que siempre devuelve un resultado, es decir, una cardinalidad de 1. - Un
Completablepuede interpretarse como unObservable<Void>es decir, una cardinalidad de 0.
Entonces, en su caso, puede cambiar la firma del repositorio de esta manera:
Completable saveUser(...);
Single<User> findUser(...);
(No mencioné los Flowable s que son como los Observable s con Backpressure ).
La contrapresión es lo que se obtiene cuando un Observable origen emite elementos más rápido de lo que un Subscriber puede consumirlos. Es más a menudo una preocupación con los observables calientes , no con los fríos , como lo solicita su red.
Creo que debería usar Completable lugar de Observable<Void> en su método saveUser , y usar Single para todos los lugares donde siga un patrón de solicitud / respuesta o entrada / salida. Observable debe usarse cuando realmente desee un flujo continuo de eventos.
Según tengo entendido, debe usar Single: cuando esté bastante seguro de que va a obtener un artículo, de lo contrario, obtendrá un error. Por ejemplo: GET - card /: id
Tal vez: es la solución correcta si no está tan seguro de obtener un artículo. Por ejemplo: GET - card? License-plate = xvar3
Completable: cuando solo quieres saber si se realizó la acción. Ej .: PUT o DETELE
Observable: cuando la cantidad de artículos no es tan grande.
Flujo: cuando no sepas la cantidad de artículos que recibirás.
Backpressure produce cuando un Observable emite elementos más rápidamente de lo que un operador o suscriptor puede consumirlos .
Sabiendo eso, la contrapresión no es un problema en su caso ya que su Observable emitirá solo un elemento, por lo que Flowable no es un buen candidato.
Por lo tanto, la pregunta real es si usar Completable u Observable para saveUser y Single u Observable para findUser y aquí, ya que solo se espera un resultado (éxito o fracaso) en aras de la simplicidad y claridad de su API, definitivamente debe usar Completable / Single de lo contrario, será difícil comprender que solo se emitirá un valor que podría ser engañoso para los usuarios de la API.