¿En qué se diferencia Single de Observable?
Por supuesto, no tiene todos los métodos que tiene Observable. El suscriptor único también se diferencia en que contiene solo dos métodos, no tres. Creo que puedes encontrar todas las diferencias en términos de implementación en la documentación.
Surge la pregunta:
¿Qué causó tales cambios?
La respuesta es obvia: Single (que incluso se puede entender por el nombre) contiene solo un elemento, a diferencia de Observable.
Alguien pensará y dirá
pfff, ¿y qué? Y siempre usaré Obsevable, que tenga un solo elemento.
En mi opinión, no hay nada de malo en eso, pero ¿hay alguna desventaja de tal uso?
- Si sabe que trabajará con un solo elemento, entonces no es necesario utilizar Observable o, como dicen, overkill;
- También debe comprender que Observable es más pesado que Single (y dicen que Single es incluso más rápido);
Dices Soltero, hmm ...
En soltero, son posibles dos situaciones:
- un significado
- excepción
Es importante comprender lo que está tratando de lograr o cuál es su política. Si cree que un resultado vacío está bien para usted, lo más probable es que Single no funcione para usted, pero si no lo es y sabe que el resultado debe ser, entonces Single es lo que necesita. Por cierto, vale la pena señalar que Single no tiene un método vacío (). Decidí informar esto, por si acaso.
Sí, ¡finalmente enséñame cómo usar este single!
Un ejemplo común de la vida. Supongamos que tenemos una arquitectura de microservicios (me encantan los microservicios).
Entrada: Tenemos tres mikroservisa A , Casas , el C .
A - servicio de orquestación.
Tarea: realice una solicitud al servicio B y C desde el microservicio A y agregue los datos.
Respuesta: por supuesto, puede realizar una solicitud al microservicio B y luego al microservicio Cy luego agregar los datos en el microservicio A, pero luego debe esperar los resultados de un microservicio y luego de otro. ¡Vaya, cuánto tiempo!
Pero recuerda que tenemos rx.Single, hurra!
Single<String> b = Single.fromCallable(() -> serviceA.getResponse()) .subscribeOn(Schedulers.io()); Single<String> c = Single.fromCallable(() -> serviceB.getResponse()) .subscribeOn(Schedulers.io()); Single.zip(b, c, (resultA, resultB) -> resultA + resultB);
¡Y aquí está!
Qué exactamente ?
La solicitud al microservicio B y la solicitud al microservicio C se producen de forma independiente, y el microservicio A simplemente espera los resultados.
Interesante
Aquí hay un enlace a la documentación. Muy buena documentacion. Puedes encontrar muchas cosas útiles. Bueno, también puedo recomendar un libro: "Programación reactiva con RxJava".