[1]

Aprendizaje de la programación
reactiva con Java 8

Aprender a utilizar RxJava y sus observables reactivas para construir

rápido, concurrente y potentes aplicaciones a través de ejemplos detallados

nickolay Tsvetinov

BIRMINGHAM - Bombay
Aprendizaje de la programación reactiva con Java 8

Copyright © 2015 Packt Publishing

Todos los derechos reservados. Ninguna parte de esta publicación puede ser reproducida, almacenada en un sistema
de recuperación o transmitida en cualquier forma o por cualquier medio, sin la previa autorización por escrito del editor,
excepto en el caso de citas breves incorporados en artículos de revistas.

Cada esfuerzo se ha hecho en la preparación de este libro para asegurar la exactitud de la información
presentada. Sin embargo, la información contenida en este libro se vende sin garantía, ya sea expresa o
implícita. Ni el autor, ni Packt Publishing, y sus concesionarios y distribuidores serán responsables por cualquier
daño causado o presuntamente causado directa o indirectamente por este libro. Packt Publishing se ha esforzado
para proporcionar información sobre marcas registradas acerca de todas las compañías y productos
mencionados en este libro por el uso apropiado de capitales. Sin embargo, Packt Publishing no puede garantizar
la exactitud de esta información.

Publicado por primera vez: June el año 2015

Producción referencia: 1170615

Publicado por Packt Publishing Ltd. librea Place

35 librea calle Birmingham B3 2PB, Reino
Unido. ISBN 978-1-78528-872-2

www.packtpub.com
 créditos

Autor Coordinador del proyecto

nickolay Tsvetinov sanchita Mandal

Los revisores Corrector de pruebas

Samuel Gruetter safis Edición

Dávid Karnok Timo

indexador
Tuominen Shixiong
Mariammal Chettiyar
Zhu

Coordinador de produccion
Editor de puesta en marcha
Conidon Miranda
Veena Pagare

trabajo portada
Editor de adquisición
Conidon Miranda
Larrisa Pinto

Editor de Desarrollo de Contenidos

Adrian Raposo

Editor técnico
Abhishek R. Kotian

Los editores de copia

Brandt D'Mello

Neha Vyas
 Sobre el Autor

nickolay Tsvetinov es un versátil desarrollador web profesional en la primera plataforma abierta integral
de TransportAPI-Gran Bretaña por las soluciones de transporte. Durante su carrera como desarrollador de
software, que experimentó tanto buenas como malas y jugó con la mayoría de los lenguajes de programación
populares desde-C y Java a Ruby y JavaScript. Durante los últimos 3-4 años, ha sido la creación y
mantenimiento de aplicaciones de una sola página (SPA) y las arquitecturas de la API de backend que les
sirven. Él es un fan de software de código abierto, rieles, Vim, Sinatra, Ember.js, Nodo. js, y Nintendo. Era un
músico y poeta sin éxito, pero él es un esposo y padre éxito. Su área de interés y experiencia incluye la
programación declarativa / funcional y reactivo que dio lugar a la creación de ProAct.js ( http://proactjs.com), que
es una biblioteca que aumenta el lenguaje JavaScript y lo convierte en un lenguaje reactivo.

En primer lugar, quiero dar las gracias a mi esposa, Tania. Escribí este libro porque ella me
dijo que yo era capaz de hacer esto. Ella estaba conmigo todos estos meses; Trabajé a altas
horas de la noche y los fines de semana, pero ella no le importaba. Ella también me ayudó
con el contenido de este libro. Gracias, Tania; Te amo y Dedico este libro a usted. Quiero dar
las gracias a mi niña, Dalia. Ella es la única que me hace aprender y hacer cosas nuevas. Un
día, yo quiero que ella esté orgulloso de mí, ella es mi sol. Quiero agradecer a mis colegas de
TransportAPI, especialmente Dave, que me ayudó con mi Inglés, y Jonathan y Martin, que me
dio el valor para terminar el libro.

Quiero Soluciones de agradecimiento Astea, ya que me dio espacio para escribir, así como mis

padres, Georgi y Dimana, que hicieron lo mismo para mí los fines de semana. Por último, quiero

agradecer a todos mis amigos que me apoyaron-Simeon, Rosen, Deyan, Pavel, mi hermana,

Marina, y muchos más. ¡Gracias!

 Acerca de los revisores

Samuel Gruetter tiene un título de Licenciado en Informática por la Escuela Politécnica Federal de Lausana
(EPFL), Suiza. Como asistente del estudiante y miembro del equipo de la EPFL Scala, desarrolló RxScala, que es un
adaptador de Scala para la biblioteca RxJava reactiva extensiones. De esta manera, contribuyó a RxJava. También
fue un asistente de enseñanza para el Principios de programación reactiva masiva curso en línea abierta en Coursera,
que es el primer curso en línea sobre la programación reactiva.

dávid Karnok es un asistente de investigación y estudiante de doctorado en el Laboratorio de Investigación

en Ingeniería y Gestión de Inteligencia del Instituto de Ciencia y Control de la Academia de Ciencias de Hungría
ordenador.

Él ha estado trabajando con Java y tecnologías básicas relacionadas desde el año 2005 para llevar los beneficios de
Java a la fabricación y empresas de logística.

Él fue el primero en marco Rx.NET puerto de Microsoft para volver Java en 2010; sin embargo, el concepto era tan
adelantado a su tiempo que su biblioteca no captó mucha atención hasta Netflix salió con el puerto RxJava
independiente en 2013. Se unió al proyecto no mucho más tarde y es un colaborador núcleo y ha contribuido a un 30
por ciento del código de la biblioteca en los últimos años. Con varios años de experiencia en programación reactiva y
como un desarrollador principal de RxJava, con frecuencia responde a preguntas sobre la biblioteca de desbordamiento
de pila, en la que revisa las solicitudes de extracción en la página del proyecto RxJava GitHub y mensajes correcciones
de errores y mejoras sobre una base regular.
Timo Tuominen desarrolla proyectos de software a gran escala desde la concepción hasta la finalización de los clientes, incluyendo
grandes empresas de telecomunicaciones y fabricantes de dispositivos. A medida que la dirección técnica, que ha creado docenas de
productos y servicios tanto para el uso de consumidores y empresas.

Trabajar con Futurice, que comenzó a usar RxJava en 2013 y diseñó uno de los primeros arquitecturas RxJava puros
en Android. Su enfoque novedoso fue el resultado de los principios de programación reactiva funcionales inflexibles
que se aplican a una plataforma existente. Varias aplicaciones y miles de confirmaciones de código más adelante,
ahora está convencido de que RxJava y FRP representan una nueva y mejor manera de compilación del software.

Me gustaría dedicar este libro a todos los que han puesto al día con mis innovaciones
RxJava.

Zhu Shixiong es un confirmador RxJava y también mantiene el proyecto RxScala. Recibió su grado de maestría de la
ciencia en informática de la Universidad de Pekín, China. Después de eso, se unió a MicroStrategy y trabajó en varios
proyectos de grandes volúmenes de datos. También ha trabajado en el equipo de infraestructura en Xiaomi.
Actualmente, él está viviendo en Beijing y trabajar en el proyecto de chispa Apache, que es una plataforma rápida y
general para el procesamiento de datos a gran escala.
 www.PacktPub.com

los archivos de soporte, libros electrónicos, ofertas de descuento

y más
Para los archivos de soporte y descargas relacionadas con su libro, por favor visite www.PacktPub.com.

¿Sabías que Packt ofertas ebook versiones de cada libro publicado, con archivos PDF y ePub disponibles? Se puede actualizar a la versión
de libro electrónico en www.PacktPub.com y como un cliente de impresión de libros, usted tiene derecho a un descuento en la copia de libros
electrónicos. Póngase en contacto con nosotros en
service@packtpub.com para más detalles. A www.PacktPub.com, también se puede leer una colección de artículos técnicos

gratuitos, crea para una serie de boletines gratuitos y recibe descuentos y ofertas exclusivas en los libros y libros electrónicos

Packt.

TM

https://www2.packtpub.com/books/subscription/packtlib

¿Necesita soluciones inmediatas a las preguntas que su TI? PacktLib es la biblioteca de libros digitales en línea Packt. Aquí, usted
puede buscar, acceder y leer toda la biblioteca de los libros de Packt.

¿Por qué suscribirse?

• Que se puede buscar a través de cada libro publicado por Packt

• Copiar y pegar, imprimir, y el contenido marcador

• En la demanda y accesible a través de un navegador web

Acceso gratis para los titulares de cuentas Packt

Si usted tiene una cuenta con Packt en www.PacktPub.com, se puede usar esto para el acceso PacktLib hoy y ver 9 libros
enteramente libres. Sólo tiene que utilizar sus credenciales de acceso para el acceso inmediato.
 Tabla de contenido
Prefacio v
Capítulo 1: Introducción a la programación reactiva 1
¿Cuál es la programación reactiva? 2
¿Por qué debemos ser reactivos? 3
La introducción de RxJava 5
Descargar y configurar RxJava 5
Comparando el iterador y la RxJava observable 6
La implementación de la suma reactiva 10
Resumen dieciséis

Capítulo 2: Uso de las construcciones funcionales de Java 8 17

Lambdas en Java 8 18
Presentación de la nueva sintaxis y la semántica 18
interfaces funcionales en Java 8 y RxJava 22
Implementación del ejemplo suma reactivo con lambdas 24
funciones puras y funciones de orden superior 26
funciones puras 26
funciones de orden superior 28
RxJava y la programación funcional 30
Resumen 30
Capítulo 3: Creación y conexión de los observables, Observadores,
y los sujetos 31
El método Observable.from 32
El método Observable.just 33
Otros métodos de fábrica observables 35
El método Observable.create 37
Suscripción y desuscripción 39

[ yo ]
Tabla de contenido

Caliente y casos observables frías 43

La clase ConnectableObservable 44
Las instancias Asunto 46
Resumen 50
Capítulo 4: La transformación, filtrado y acumulación de los datos
51
transformaciones observables 51
Transformaciones con los distintos operadores flatMap 53
Agrupación de elementos 61
operadores de transformación útiles adicionales 64
Filtrado de datos sesenta y cinco

La acumulación de datos 71
Resumen 74
Capítulo 5: Los combinadores, condicionales, y tratamiento de errores 75
La combinación de los casos observables 76
El operador postal 76
El operador combineLatest 78
El operador de combinación 80
El operador concat 81
Los operadores condicionales 83
El operador amb 83
El takeUntil (), takeWhile (), skipUntil (), y skipWhile () operadores
condicionales 84
El DefaultIfEmpty () operador 86
Gestión de errores 86
Los operadores de retorno y CV 87
La técnica de volver a intentar 88
Un ejemplo de cliente HTTP 91
Resumen 95
Capítulo 6: Uso de concurrencia y paralelismo con Schedulers 97
programadores de RxJava 98
Depuración observables y sus programadores 98
El intervalo observable y su parrilla de programación por defecto 101
Tipos de programadores 102
El planificador Schedulers.immediate 105
El planificador Schedulers.trampoline 106
El planificador Schedulers.newThread 107
El planificador Schedulers.computation 108
El planificador Schedulers.io 110
El método Schedulers.from (ejecutor) 111

[Ii]
 Tabla de contenido

Combinando observables y programadores 111

La <T> subscribeOn método observables (Scheduler) 112
El observable <T> observeOn (Scheduler) operador 114
Paralelismo 117
Buffering, estrangulación, y eliminación de rebotes 120
estrangulación 121
supresión de rebotes 122
Los operadores de amortiguamiento y ventanas 123
Los operadores de contrapresión 125
Resumen 126
Capítulo 7: Analizar su aplicación RxJava 127
Las pruebas utilizando sencilla suscripción 128
La clase BlockingObservable 130
Los operadores de agregados y la clase BlockingObservable 132
Las pruebas con los operadores de agregados y la clase
BlockingObservable 134
Utilización de la clase TestSubscriber para las pruebas en

profundidad 135
Prueba de observables casos asíncronos con la ayuda de la clase
TestScheduler 136
Resumen 139
Capítulo 8: Gestión de Recursos y RxJava Extendiendo 141
Administracion de recursos 142
Introduciendo el método Observable.using 142
El almacenamiento en caché de datos con Observable.cache 146
La creación de los operadores personalizados con ascensor 148
Componiendo varios operadores con el operador Observable.compose
151
Resumen 153
Índice 155

[Iii]
 Prefacio
la programación reactiva ha existido durante décadas. Ha habido un par de implementaciones de la programación
reactiva desde el momento en Smalltalk era un lenguaje joven. Sin embargo, sólo recientemente se ha popularizado y
ahora se está convirtiendo en una tendencia. ¿Por qué ahora lo preguntas? Debido a que es bueno para escribir
rápido, aplicaciones en tiempo real y las tecnologías actuales y la Web lo exigen.

Me involucré en ella de nuevo en 2008, cuando el equipo era parte de un creador fue el desarrollo de libro multimedia
llamada Sophie 2. Tenía que ser rápido y sensible por lo que creamos un marco llamado Prolib, que proporcionó los
objetos con propiedades que podría depender de entre sí (en otras palabras, hemos implementado enlaces para swing y
mucho más, transformaciones, filtrado, y así sucesivamente). Se sentía natural para cablear los datos del modelo a la
interfaz gráfica de usuario de esta manera.

Por supuesto, esto estaba muy lejos del enfoque funcional al igual que viene con RX. En 2010, Microsoft lanzó
RX y, después de eso, Netflix portado a Java-RxJava. Sin embargo, Netflix lanzó RxJava a la comunidad de
código abierto y el proyecto se convirtió en un gran éxito. Muchos otros idiomas tienen su puerto de RX y
muchas alternativas a la misma. Ahora, se puede codificar utilizando la programación reactiva en su base de
Java y el alambre a frontend de su RxJava.

Este libro trata de explicar a usted lo que la programación reactiva se trata y cómo utilizarlo con RxJava. Tiene
muchos pequeños ejemplos y explica los conceptos y detalles de la API en pequeños pasos. Después de leer
este libro, usted tendrá una idea de RxJava, la programación funcional, y el paradigma reactivo.

[V]
Prefacio

Lo que este libro cubre

Capítulo 1, Una introducción a la programación reactiva, le dará a conocer el concepto de programación
reactiva y le dirá qué usted debe aprender acerca de él. Este capítulo contiene ejemplos que demuestran
cómo RxJava incorpora el concepto de programación reactiva.

Capitulo 2, El uso de las construcciones funcionales de Java 8, le enseñará cómo utilizar las nuevas
construcciones lambda de Java 8. Se explicará algunos conceptos de programación funcional y le mostrará cómo
usarlos con RxJava en sus programas de reactivos.

Capítulo 3, Creación y conexión de los observables, Observadores, y los sujetos, le mostrará los elementos
básicos de la biblioteca llamada RxJava los observables. Usted aprenderá la diferencia entre 'caliente' y
observables 'frío' y cómo suscribirse y darse de baja de ellos usando una instancia de suscripción.

Capítulo 4, La transformación, filtrado y acumulación de los datos, le guiará a través de los operadores de
reactivos básicos, que va a aprender a utilizar para lograr cálculos paso a paso. Este capítulo le dará una
idea de cómo transformar los eventos los observables emiten, cómo filtrar sólo los datos que necesitamos, y
cómo agrupar, se acumulan, y procesarla.

Capítulo 5, Combinadores, condicionales, y tratamiento de errores, le presentará operadores reactivas más

complejas, lo que permitirá a dominar el encadenamiento observable. Usted aprenderá acerca de la combinación y
operadores condicionales y cómo los observables interactúan entre sí. Este capítulo muestra los diferentes
enfoques para el tratamiento de errores.

Capítulo 6, El uso de concurrencia y paralelismo con programadores, le guiará a través del proceso de la
escritura de programas simultáneos y paralelos con RxJava. Esto se logrará mediante los programadores
RxJava. Los tipos de programadores se introducirán y se llega a saber cuándo y por qué utilizar cada uno de
ellos. En este capítulo se le presentará con un mecanismo que le mostrará cómo evitar y aplicar
contrapresión.

Capítulo 7, Prueba de su Aplicación RxJava, le mostrará cómo poner a prueba la unidad de sus aplicaciones RxJava.

Capítulo 8, La extensión de Gestión de Recursos y RxJava, le enseñará la forma de gestionar los recursos utilizados como
fuentes de datos de las aplicaciones RxJava. Vamos a escribir nuestros propios operadores observables aquí.

[Vi]
 Prefacio

Lo que necesita para este libro

Con el fin de ejecutar los ejemplos, se necesita:

• Java instalado 8, que se puede descargar desde el sitio de Oracle http: //

www.oracle.com/technetwork/java/javase/downloads/jdk8downloads-2133151.html

• Gradle para construir el proyecto-2.x, que se puede descargar desde https: // gradle.org/downloads

• Eclipse para abrir el proyecto. También necesitará el plugin para Eclipse Gradle, que puede ser
descargado desde el Eclipse Marketplace. Por supuesto, puede utilizar Gradle desde la línea de
comandos y pasar por el código con Vim o cualquier otro editor de texto arbitrario

para quien es este libro

Si usted es un desarrollador de Java que sabe cómo escribir el software y le gustaría aprender cómo aplicar sus

conocimientos actuales de la programación reactiva, este libro es para ti. Este libro puede ser útil a cualquier persona, sin

importar si son principiantes, los programadores avanzados, o incluso los expertos. Usted no necesita tener ninguna

experiencia con lambdas y arroyos de cualquiera de Java 8 o con RxJava.

convenciones
En este libro, encontrará una serie de estilos de texto que distinguen entre diferentes tipos de información.
Estos son algunos ejemplos de estos estilos y una explicación de su significado.

Las palabras de código en el texto, nombres de tabla de base de datos, nombres de carpeta, nombres de archivos, extensiones de archivos,

nombres de ruta, URLs ficticias, de entrada del usuario, y mangos de Twitter se muestran como sigue: "Podemos incluir otros contextos a

través del uso de la incluir . Directiva" Un bloque de código se establece de la siguiente manera:

Observable
. justo ( 'R', 'x', 'J', 'una', 'v' 'a')
. suscribirse (System.out ::
impresión, System.err :: println,
System.out :: println

);

[Vii]
Prefacio

Cuando deseamos llamar su atención sobre una parte específica de un bloque de código, las líneas o los artículos pertinentes
se exponen en negrita:

Observable <Objeto> obs = observable

. intervalo (40L, TimeUnit.MILLISECONDS)
. switchMap (v ->
observable
. temporizador (0L, 10L, TimeUnit.MILLISECONDS)
. mapa (u -> "observable <" + (v + 1) + ">:" + (v + u)))
);
subscribePrint (obs, "switchMap");

Los nuevos términos y Palabras importantes se muestran en negrita. Palabras que se ven en la pantalla, por ejemplo, en los
menús y cuadros de diálogo, aparecerá en el texto como este: "Interfaces de este tipo se denominan interfaces funcionales ".

Advertencias o notas importantes aparecen en un cuadro como este.

Consejos y trucos aparecen así.

comentarios de los lectores

Los comentarios de nuestros lectores es siempre bienvenido. Háganos saber lo que piensa de este libro, lo que gustó o no.

comentarios de los lectores es importante para nosotros, ya que nos ayuda a desarrollar títulos que usted realmente va a obtener el

máximo provecho de. Para enviar comentarios generales, sólo tiene que enviar un correo electrónico feedback@packtpub.com , y

mencione el título del libro en el asunto del mensaje.

Si hay un tema que tiene experiencia y está interesado en cualquiera de escritura o contribuir a un libro, ver
nuestra guía de Autor www.packtpub.com/authors.

Atención al cliente
Ahora que usted es el orgulloso propietario de un libro Packt, tenemos una serie de cosas para ayudarle a obtener el
máximo provecho de su compra.

[Viii]
 Prefacio

La descarga del código de ejemplo

Puede descargar los archivos de código de ejemplo de su cuenta al http: // www. packtpub.com para todos los
libros Packt Publishing que ha adquirido. Si ha adquirido este libro otra parte, se puede visitar http://www.packtpub.com/support

y registrarse para tener los archivos enviados por correo electrónico directamente a usted.

Errata
Aunque hemos tomado todas las precauciones para asegurar la exactitud de nuestro contenido, los errores ocurren. Si
encuentra un error en uno de nuestros libros, tal vez un error en el texto o el código-estaríamos agradecidos si pudiera
informar de esto a nosotros. Al hacerlo, puede ahorrar otros lectores de la frustración y ayudar a mejorar las versiones
posteriores de este libro. Si encuentra alguna errata, por favor informe al visitar http: //www.packtpub. com /
presentar-erratas, la selección de su libro, hacer clic en el Formulario de Presentación de erratas

vincular, y entrar en los detalles de su fe de erratas. Una vez que sus erratas se verifican, su presentación será
aceptado y la fe de erratas se cargará en nuestra página web o añadir a cualquier fe de erratas existentes en la
sección de erratas de ese título. Para ver la fe de erratas presentada anteriormente, vaya a https://www.packtpub.com/books/
contenido / soporte y escriba el nombre del libro en el campo de búsqueda. La información requerida aparecerá bajo

el Errata sección.

Piratería
La piratería de material con copyright en Internet es un problema constante en todos los medios. En Packt, tomamos la protección

de nuestros derechos de autor y licencias muy en serio. Si se encuentra con todas las copias ilegales de nuestros trabajos en

cualquier forma en Internet, por favor nos proporcione la dirección de ubicación o el nombre del sitio web inmediatamente para

que podamos presentar un recurso. Por favor, póngase en contacto con nosotros en copyright@packtpub.com con un enlace al

material pirateado sospecha.

Apreciamos su ayuda en la protección de nuestros autores y nuestra capacidad para lograr que el contenido valioso.

preguntas
Si usted tiene un problema con cualquier aspecto de este libro, puede ponerse en contacto con nosotros en

questions@packtpub.com , y haremos nuestro mejor esfuerzo para resolver el problema.

[Ix]
 Una introducción a Reactiva
Programación
Hoy en día, el término la programación reactiva es una tendencia. Las bibliotecas y los marcos en varios lenguajes
de programación están surgiendo. Se están creando blogs, artículos y presentaciones sobre la programación
reactiva. Las grandes empresas, como Facebook, Soundcloud, Microsoft y Netflix, están apoyando y el uso de este
concepto. Así que, como programadores, están comenzando a preguntarse sobre ella. ¿Por qué la gente se anime
así acerca de la programación reactiva? ¿Qué significa ser reactiva? ¿Sería útil en nuestros proyectos? ¿Hay que
aprender a usarlo?

Mientras tanto, Java es popular con su multi-threading, velocidad, fiabilidad y buena portabilidad. Se utiliza para la construcción de
una amplia variedad de aplicaciones, desde los motores de búsqueda, a través de bases de datos a las aplicaciones web complejas
que se ejecutan en los clústeres de servidores. Pero Java tiene mala fama demasiado, es muy difícil escribir dos aplicaciones
simultáneas y simples usando sólo la incorporada en las herramientas, y la programación en Java requiere escribir mucho código
repetitivo. Además, si tiene que ser asíncrona (utilizando futuros, por ejemplo), se puede conseguir fácilmente en el "infierno de
devolución de llamada", que en realidad es válido para todos los lenguajes de programación.

En otras palabras, Java es potente y se puede crear grandes aplicaciones con él, pero no va a ser fácil. La
buena noticia es que hay una manera de cambiar eso, utilizando el estilo de la programación reactiva. Este libro
presentará RxJava ( https://github.com/ReactiveX/RxJava), un código abierto de Java aplicación del paradigma de
programación reactiva. Escribir código usando RxJava requiere un tipo diferente de pensar, sino que le dará el
poder de crear una lógica compleja usando simples trozos de código bien estructurado.

[1]
Una introducción a la programación reactiva

En este capítulo, vamos a cubrir:

• ¿Qué programación reactiva es

• Razones para aprender y utilizar este estilo de programación

• La creación de RxJava y comparándolo con los modelos y las estructuras familiares

• Un ejemplo sencillo con RxJava

¿Cuál es la programación reactiva?

la programación reactiva es un paradigma que gira en torno a la propagación de cambio. En otras palabras, si un
programa se propaga a todos los cambios que modifican sus datos a todas las partes interesadas (usuarios, otros
programas, componentes y subpartes), entonces este programa puede ser llamado reactivo.

Un ejemplo sencillo de esto es Microsoft Excel. Si establece un número en la celda A1 y otro número en la celda 'B1', y el

conjunto de células 'C1' a SUM (A1, B1); siempre 'A1' o los cambios 'B1', 'C1' se actualizarán para ser su suma. la llamada

de dejar que esto la suma reactiva.

¿Cuál es la diferencia entre la asignación de una variable simple C que es igual a la suma de las un y si variables
y el método de suma reactiva?

En un programa Java normal, cuando cambiamos 'a' o 'b', tendremos que actualizar 'c' nosotros mismos. En
otras palabras, el cambio en el flujo de los datos representados por 'a' y 'b', no se propaga a 'c'. Aquí se ilustra
este a través de código fuente:

int a = 4; int b = 5; int c

= a + b;

System.out.println (c); // 9

a = 6;
System.out.println (c);
// 9 de nuevo, pero si 'c' fue el seguimiento de los cambios en 'a' y 'b', // hubiera sido 6 + 5 = 11

La descarga del código de ejemplo

Puede descargar los archivos de código de ejemplo para todos los libros Packt haya adquirido de su
cuenta en http://www.packtpub.com. Si ha adquirido este libro otra parte, se puede visitar http:
//www.packtpub. es / support y registrarse para tener los archivos enviados por correo electrónico
directamente a usted.

[2]
 Capítulo 1

Esta es una explicación muy sencilla de lo que "ser reactivos" significa. Por supuesto, hay varias
implementaciones de esta idea y hay varios problemas que deben resolver estas implementaciones.

¿Por qué debemos ser reactivos?

La forma más fácil para nosotros para responder a esta pregunta es pensar en las necesidades que tenemos mientras la creación
de aplicaciones en estos días.

Mientras que hace 10-15 años era normal que los sitios web que pasar por el mantenimiento o para tener un tiempo de
respuesta lento, hoy todo debe estar en línea 24/7 y debe responder con la velocidad del rayo; si es lento o hacia abajo, los
usuarios prefieren un servicio alternativo. Hoy en día los medios lentos inutilizables o rotas. Estamos trabajando con un
mayor volumen de datos que necesitamos para servir y procesar rápidamente.

HTTP fallos no eran algo raro en el pasado reciente, pero ahora, tenemos que ser tolerante a fallos y dar a nuestros
usuarios actualizaciones de mensajes legibles y razonables. En el pasado, escribimos aplicaciones de escritorio
simples, pero hoy escribimos aplicaciones web, que debe ser rápido y sensible. En la mayoría de los casos, estas
aplicaciones se comunican con un gran número de servicios a distancia.

Estos son los nuevos requisitos que tienen que cumplir si queremos que nuestro software sea competitivo. Así, en
otras palabras, tenemos que ser:

• Modular / dinámica: De esta manera, podremos tener 24/7 sistemas, ya que los módulos pueden ir fuera de
línea y en línea llegado sin romper o detener todo el sistema. Además, esto nos ayuda a estructurar mejor
nuestras aplicaciones a medida que se hacen más grandes y gestionar su base de código.

• Escalable: De esta manera, vamos a ser capaces de manejar una gran cantidad de datos o un gran número de
solicitudes de los usuarios.

• Tolerante a fallos: De esta manera, el sistema aparecerá estable a sus usuarios.

• Sensible: Esto significa rápido y disponible. Vamos a

pensar en cómo lograr esto:

• Podemos llegar a ser modular, si nuestro sistema es evento conducido. Podemos dividir el sistema en
múltiples micro-servicios / componentes / módulos que se va a comunicar entre sí utilizando las
notificaciones. De esta manera, vamos a reaccionar ante el flujo de datos del sistema, representado por
las notificaciones.

• Para ser medios escalables para reaccionar a los datos cada vez mayores, que reaccionan a la carga sin
desmoronarse.

[3]
Una introducción a la programación reactiva

• Como reacción a los fallos / errores hará que el sistema sea más tolerante a fallos.

• Para ser medios sensibles que reaccionan a la actividad del usuario en el momento oportuno. Si la solicitud es
dirigida por eventos, puede ser desacoplada en múltiples componentes autónomos. Esto nos ayuda a ser más escalable,
porque siempre podemos añadir nuevos componentes o eliminar los viejos sin parar o romper el sistema. Si los errores y
los fracasos se pasan al componente de la derecha, que puede manejar como las notificaciones, la aplicación puede
llegar a ser más tolerante a fallos o flexible. Así que si construimos nuestro sistema a ser controlado por eventos,
podemos lograr más fácilmente escalabilidad y tolerancia a fallos, y una solución escalable, desacoplado, y la aplicación
a prueba de errores es rápido y sensible para los usuarios.

Sensible

Elástico escalable

Evento conducido

los Manifiesto reactiva ( http://www.reactivemanifesto.org/) es un documento que define los cuatro principios reactivos
que hemos mencionado anteriormente. Cada sistema reactivo debe ser controlado por mensajes (dirigido por
eventos). De esa manera, puede convertirse imprecisa y por lo tanto escalable y elástico (tolerante a fallos), que
significa que es fiable y sensible (véase el diagrama anterior).

Tenga en cuenta que el reactivo Manifiesto describe un sistema reactivo y no es lo mismo que nuestra definición de la

programación reactiva. Se puede construir un mensaje impulsada, resistente, escalable, y la aplicación responde sin necesidad

de utilizar una biblioteca o lenguaje reactiva. Los cambios en los datos de aplicación pueden ser modelados con las

notificaciones, las cuales se pueden propagar a los manipuladores de la derecha. Por lo tanto, la escritura de aplicaciones

utilizando la programación reactiva es la forma más fácil de cumplir con el Manifiesto.

[4]
 Capítulo 1

La introducción de RxJava
Para escribir programas reactivos, necesitamos una biblioteca o un lenguaje de programación específico, debido a la
construcción de algo así a nosotros mismos es una tarea bastante difícil. Java no es realmente un lenguaje de
programación reactiva (que proporciona algunas herramientas como el java.util. Observable clase, pero son bastante
limitadas). Es un lenguaje orientado a objetos de tipos estáticos, y escribir una gran cantidad de código repetitivo para
lograr cosas simples (POJO, por ejemplo). Pero hay bibliotecas reactivos en Java que podemos utilizar. En este libro,
vamos a utilizar RxJava (desarrollado por la gente en la comunidad de código abierto de Java, guiado por Netflix).

Descargar y configurar RxJava

Puede descargar y generar RxJava de Github ( https://github.com/ ReactiveX / RxJava). Requiere cero
dependencias y es compatible con Java 8 lambdas. La documentación proporcionada por el Javadoc y las
páginas wiki GitHub está bien estructurado y algunos de los mejores que hay. Aquí es cómo comprobar a
cabo el proyecto y ejecutar la construcción:

$ Git clone git@github.com : ReactiveX / RxJava.git $ cd RxJava / $

acumulación ./gradlew

Por supuesto, también puede descargar el archivo JAR creado previamente. Para este libro, vamos a estar utilizando la versión 1.0.8.

Si utiliza Maven, puede agregar RxJava como una dependencia a su pom.xml archivo:

<Dependency>
<GroupId> io.reactivex </ groupId> <artifactId>
rxjava </ artifactId> <versión> 1.0.8 </ version> </
dependency>

Alternativamente, para Apache Ivy, poner este fragmento en dependencias de su archivo Hiedra:

<Dependencia org = "io.reactivex" name = "rxjava" rev = "1.0.8" />

Si utiliza Gradle lugar, actualizar su build.gradle dependencias de archivo de la siguiente:

{dependencias
. . .
compilación 'io.reactivex: rxjava: 1.0.8'
. . .
}

[5]
Una introducción a la programación reactiva

Los ejemplos y programas que acompañan a este libro de código pueden ser
construidos y probados con Gradle. Se puede descargar desde este repositorio
Github: https://github.com/meddle0x53/ aprendizaje-rxjava.

Ahora, vamos a echar un vistazo a lo RxJava se trata. Vamos a empezar con algo bien conocido, y
obtener gradualmente en los secretos de la biblioteca.

Comparando el iterador y la RxJava observable

Como programador de Java, es muy posible que usted ha oído o utilizó el iterador
modelo. La idea es simple: una iterador ejemplo se utiliza para atravesar a través de un recipiente (colección / fuente de
datos / generador), tirando de los elementos del recipiente de uno en uno cuando se requiere, hasta que alcanza el
extremo del recipiente. Aquí hay un pequeño ejemplo de cómo se utiliza en Java:

List <String> list = Arrays.asList ( "uno", "dos", "tres", "cuatro", "cinco"); // (1)

Iterator <String> iterador = list.iterator (); // (2)

while (iterator.hasNext ()) {// 3

// elementos Prints (4)
System.out.println (iterator.next ()); }

Cada java.util.Collection objeto es una iterable instancia que significa que tiene el método iterador (). Este método
crea una iterador ejemplo, que tiene como su fuente de la colección. Echemos un vistazo a lo que hace el
código anterior:

1. Creamos un nuevo Lista instancia que contiene cinco cuerdas.

2. Creamos una iterador ejemplo de esta Lista ejemplo, utilizando el

iterador () método.

3. La iterador interfaz tiene dos métodos importantes: hasNext () y siguiente().

los hasNext () método se utiliza para comprobar si el iterador instancia tiene más elementos para
atravesar. En este caso, no hemos empezado a ir a través de los elementos, por lo que volveremos Cierto.
Cuando pasamos por las cinco cuerdas, devolverá Falso y el programa procederá después de la mientras
lazo.

[6]
 Capítulo 1

4. Los primeros cinco veces, cuando llamamos a la siguiente() método en el iterador

ejemplo, devolverá los elementos en el orden en que se insertan en la colección. Así se imprimirán

las cuerdas. En este ejemplo, nuestro programa consume los elementos de la Lista instancia utilizando el

iterador ejemplo. Se tira de los datos (en este caso, representados por cuerdas) y las secuencias de roscado actuales
hasta los datos solicitados está listo y recibidos. Así, por ejemplo, si el
iterador instancia estaba disparando una petición a un servidor web en cada siguiente() método de llamada, el hilo principal
de nuestro programa sería bloqueada a la espera de cada una de las respuestas a llegar.

bloques de construcción de RxJava son los observables. los Observable clase (nota que este no es el java.util.Observable
clase que viene con el JDK) es el doble de la matemática iterador clase, lo que básicamente significa que son
como las dos caras de la misma moneda. Tiene una colección subyacente o cálculo que produce valores que
pueden ser consumidos por un consumidor. Pero la diferencia es que el consumidor no "pull" estos valores
desde el productor al igual que en el iterador modelo. Es exactamente lo contrario; los productores '' empuja los
valores como notificaciones al consumidor. Este es un ejemplo del mismo programa pero escrito utilizando una Observable
ejemplo:

List <String> list = Arrays.asList ( "uno", "dos", "tres", "cuatro", "cinco"); // (1)

Observable <String> observable = Observable.from (lista); // (2)

observable.subscribe (nuevo Action1 <String> () {// (3)

@Anular
llamada public void (elemento String) {
System.out.println (elemento); // imprime el elemento (4)}});

Esto es lo que está sucediendo en el código:

1. Creamos la lista de cuerdas de la misma manera que en el ejemplo anterior.

2. A continuación, creamos una Observable instancia de la lista, utilizando el

a partir de (Iterable <? extiende T> iterable) método. Este método se utiliza para crear instancias de Observable
que enviar todos los valores de una forma sincrónica iterable instancia (la lista en nuestro caso) uno por
uno a sus abonados (consumidores). Vamos a ver cómo los valores se envían a los suscriptores una
por una en Capítulo 3, Creación y conexión de los observables, observadores, y los sujetos.

[7]
Una introducción a la programación reactiva

3. A continuación, se puede suscribirse a la Observable ejemplo. Al suscribirse, nos

RxJava decir que estamos interesados ​en este Observable instancia y desea recibir notificaciones de ella.
Nosotros suscribimos el uso de una clase anónima aplicación de la action1 interfaz, mediante la definición de
un solo equivalencia- llame al (T).
Este método será llamado por el Observable ejemplo, cada vez que tiene un valor, listo para ser empujado.
Siempre creando nuevos action1 casos pueden parecer demasiado prolijo, pero Java 8 resuelve este nivel de
detalle. Vamos a aprender más sobre esto en Capitulo 2, El uso de las construcciones funcionales de Java 8.

4. Por lo tanto, cada cuerda de la lista fuente será empujado a través de la llamada()
método, y que será impreso. Las instancias de la RxJava Observable se comportan de clase algo
así como iteradores asíncronos, que notifiquen que hay un valor próximo a sus abonados / consumidores
por sí mismos. De hecho, la Observable clase se suma a la clásica Observador patrón (implementado en
Java-see java.util.Observable, ver Patrones de diseño: Elementos de software orientado a objetos reutilizables por la
Banda de los Cuatro) dos cosas disponibles en el iterable tipo.

• La capacidad para señalar al consumidor que no hay más datos disponibles. En lugar de llamar al hasNext
() método, se puede conectar a un abonado para escuchar un " OnCompleted' notificación.

• La capacidad de la señal al abonado de que ha ocurrido un error. En lugar de prueba- la captura de

un error, podemos asocia un detector de error a la Observable ejemplo. Estos oyentes se pueden unir usando
el suscribirse (Acción1 <? Super T>, Acción1 <Throwable>, Action0) método. Vamos a ampliar la Observable instancia
ejemplo mediante la adición de error y los oyentes completado:

List <String> list = Arrays.asList ( "uno", "dos", "tres", "cuatro", "cinco");

Observable <String> observable = Observable.from (lista); observable.subscribe (nueva

Acción1 <String> () {
@Anular
llamada public void (elemento String) {
System.out.println (elemento); }},

nueva Acción1 <Throwable> () {

@Anular
llamada public void (t Throwable) {
System.err.println (t); // (1)}},

[8]
 Capítulo 1

nueva Action0 () {
@Anular
llamada public void () {
System.out.println ( "Hemos finnished!"); // (2)}

});

Las nuevas cosas aquí son:

1. Si hay un error al procesar los elementos, las Observable instancia enviará este error a través de la llamar
(Throwable) método de esta oyente. Esto es análogo al bloque try-catch en el iterador ejemplo
instancia.

2. Cuando todo termina, este llamada() método será invocado por el

Observable ejemplo. Esto es análogo al uso de la hasNext () método con el fin de ver si el recorrido
sobre el iterable instancia tiene acabados e impresión "Hemos terminado!".

Este ejemplo está disponible en GitHub y se puede ver / descargar en https://github.com/meddle0x53/learning-rxjava/

blob / master / src / main / java / com / packtpub / reactiva / Chapter01 /
ObservableVSIterator.java.

Vimos cómo podemos utilizar la Observable instancias y que no son tan diferentes de algo familiar para
nosotros, la iterador ejemplo. Estas Observable casos se pueden utilizar para la construcción de flujos asíncronos
y empujando actualizaciones de datos a sus suscriptores (que puede tener múltiples abonados) .Esta es una
implementación del paradigma de programación reactiva. Los datos se propaga a todas las partes interesadas:
los suscriptores.

Codificación usando tales corrientes es una implementación más funcional como de la programación reactiva. Por
supuesto, hay definiciones formales y términos complejos para ella, pero esta es la explicación más simple.

La suscripción a eventos debe estar familiarizado; por ejemplo, al hacer clic en un botón en una aplicación GUI dispara un evento que se

propaga a los suscriptores manipuladores. Sin embargo, el uso de RxJava, podemos crear flujos de datos de entrada de cualquier cosa,

archivo, tomas de corriente, las respuestas, las variables, cachés, las entradas del usuario, y así sucesivamente. Además de eso, los

consumidores pueden recibir una notificación de que la corriente está cerrado, o que se ha producido un error. Así, mediante el uso de estas

corrientes, nuestras aplicaciones pueden reaccionar al fracaso.

[9]
Una introducción a la programación reactiva

En resumen, una corriente es una secuencia de curso mensajes / eventos, ordenados a medida que se procesan en
tiempo real. Puede ser considerado como un valor que está cambiando a través del tiempo, y estos cambios pueden ser
observados por los suscriptores (consumidores), que dependen de ella. Así, volviendo al ejemplo de Excel, hemos
reemplazado con eficacia las variables tradicionales con "variables" o reactivos de RxJava Observable instancias.

La implementación de la suma reactiva

Ahora que estamos familiarizados con el Observable clase y la idea de cómo utilizarlo para código de una manera
reactiva, que están dispuestos a poner en práctica la suma reactiva, mencionado al principio de este capítulo.

Echemos un vistazo a los requisitos de nuestro programa debe cumplir:

• Será una aplicación que se ejecuta en el terminal.

• Una vez iniciado, se ejecutará hasta que el usuario introduce salida.

• Si el usuario introduce A: <número>, el un colector se actualizará a la

<Número>.

• Si el usuario introduce b: <número>, el si colector se actualizará a la

<Número>.

• Si el usuario introduce cualquier otra cosa, será omitida.

• Cuando tanto el un y si colectores tienen valores iniciales, su suma será automáticamente calculada y
se imprime en la salida estándar en el formato
a + b = <sum>. En cada cambio de un o si, la suma se actualizará y se imprime.

El código fuente contiene características que vamos a discutir en detalle en los siguientes cuatro capítulos.

La primera pieza de código representa el cuerpo principal del programa:

ConnectableObservable <String> entrada = a partir de (System.in); // (1)

Observable <Double> A = varStream ( "a", de entrada); (2) observable <Double> b

= varStream ( "b", de entrada);

ReactiveSum suma = nuevo ReactiveSum (a, b); (3)

input.connect (); (4)

[10]
 Capítulo 1

Hay un montón de cosas nuevas que suceden aquí:

1. Lo primero que tenemos que hacer es crear una Observable ejemplo, que representa
el flujo de entrada estándar ( System.in). Por lo tanto, se utiliza el a partir de (InputStream)
método (aplicación será presentado en el próximo fragmento de código) para crear una ConnectableObservable
variable de la System.in. los
ConnectableObservable variable es una Observable instancia y comienza a emitir eventos procedentes de
su fuente sólo después de su conectar() método se llama. Leer más sobre ella en Capítulo 3, Creación y
conexión de los observables, observadores, y los sujetos.

2. Creamos dos Observable casos que representan el un y si valores, utilizando

el varStream (String, observable) método, que vamos a examinar más adelante. La corriente de
fuente de estos valores es el flujo de entrada.

3. Creamos una ReactiveSum ejemplo, depende de la un y si valores.

4. Y ahora, podemos empezar a escuchar el flujo de entrada.

Este código es responsable de la construcción de dependencias en el programa e iniciar apagado. los un y si Los
valores dependen de la entrada del usuario y su suma es dependiente de ellos.

Ahora vamos a ver la aplicación de la a partir de (InputStream) método, que crea una Observable instancia con
el java.io.InputStream fuente:

estática ConnectableObservable <String> de (corriente InputStream final) {

volver a partir de (nuevo BufferedReader (nuevo InputStreamReader (stream))); // (1)}

estática ConnectableObservable <String> a partir de (lector BufferedReader final) {

Observable.create retorno (nueva OnSubscribe <String> () {// (2)

@Anular
llamada public void (Subscriber <? súper String> abonado) {
si (subscriber.isUnsubscribed ()) {// (3)
regreso; }
tratar {

línea de cuerda;
while (! subscriber.isUnsubscribed () &&
(Línea = reader.readLine ())! = Null) {// (4)
si (== || line.equals línea nula ( "salida")) {// (5)
descanso; }

[11]
Una introducción a la programación reactiva

subscriber.onNext (línea); // (6)}}

catch (IOException e) {// (7)

subscriber.onError (e); }

si (subscriber.isUnsubscribed ()!) // (8) subscriber.onCompleted (); }}

}).publicar(); // (9)}

Esta es una pieza compleja de código, así que vamos a ver de paso a paso:

1. Este método convierte su aplicación Flujo de entrada parámetro a la

BufferedReader objeto y las llamadas a partir de (BufferedReader) método. Lo estamos haciendo porque
vamos a utilizar cadenas como datos, y trabajar con el Lector instancia es más fácil.

2. Así que la aplicación efectiva se encuentra en el segundo método. Se devuelve una

Observable ejemplo, creado usando el Observable.create (OnSubscribe)
método. Este método es el que vamos a utilizar la mayor parte de este libro. Se utiliza para crear Observable
casos con comportamiento personalizado. los rx.Observable.OnSubscribe interfaz pasado a que
tiene un método,
llamada (Subscriber). Este método se utiliza para implementar el comportamiento de la
Observable ejemplo porque el Abonado ejemplo pasado a él se puede utilizar para mensajes emitirá en Observable
abonado de ejemplo. Un suscriptor es el cliente de una Observable ejemplo, que consume sus
notificaciones. Lee más sobre esto en Capítulo 3, Creación y conexión de los observables,
observadores, y los sujetos.

3. Si el abonado ya ha cancelado la suscripción a este Observable ejemplo, no debe hacerse nada.

4. La lógica principal es escuchar la entrada del usuario, mientras que el abonado está suscrito. Cada línea que el
usuario entra en el terminal es tratado como un mensaje. Este es el bucle principal del programa.

5. Si el usuario introduce la palabra salida y accesos Entrar, el bucle principal se detiene.

6. De lo contrario, el mensaje que el usuario introducido es pasado como una notificación al abonado de
la Observable ejemplo, utilizando el onNext (T) método. De esta manera, se pasa todo a las partes
interesadas. Es su trabajo para filtrar y transformar los mensajes primas.

7. Si hay un error IO, los suscriptores son notificados con una OnError
la notificación a través de la onError (Throwable) método.

[12]
 Capítulo 1

8. Si el programa llega aquí (a través de romper el bucle principal) y el abonado todavía está suscrito a
la Observable ejemplo, una OnCompleted
se envía una notificación a los abonados que utilizan la OnCompleted () método.

9. Con la publicar() método, que a su vez la nueva Observable en caso

ConnectableObservable ejemplo. Tenemos que hacer esto porque, de otro modo, por cada suscripción a
este Observable ejemplo, nuestra lógica se ejecutará desde el principio. En nuestro caso, queremos
ejecutar sólo una vez y todos los suscriptores para recibir notificaciones de los mismos; esto se puede
lograr con el uso de una ConnectableObservable ejemplo. Lee más sobre esto en Capítulo 3, Creación y
conexión de los observables, observadores, y los sujetos.

Esto ilustra una forma simplificada para convertir flujos de IO en Java Observable instancias. Por supuesto, con este
bucle principal, el hilo principal del programa bloqueará esperando la entrada del usuario. Esto se puede prevenir
mediante la derecha Programador casos para mover la lógica a otro hilo. Volveremos a este tema en Capítulo 6, Usar la
concurrencia y paralelismo con programadores.

Ahora, cada línea el usuario escribe en el terminal se propaga como una notificación de la ConnectableObservable
instancia creada por este método. Ha llegado el momento de ver cómo nos conectamos nuestro valor Observable
casos, representa los colectores de la suma, a esta entrada Observable ejemplo. Aquí está la aplicación de la

varStream (String, observable) método, que toma un nombre de un valor y la fuente

Observable instancia y devuelve una Observable ejemplo que representa este valor:

public static observable <Double> varStream (última cadena varName, observable <String> entrada) {

patrón final Patrón = Pattern.compile ( "\\ ^ s *" + + varName "\\ s * [: | =]?.? s \\ * (- d + \\ \\ \\ d *) $") ; //
(1) de entrada de retorno

. mapa( nueva Func1 <String, Matcher> () {llamada

Matcher pública (String str) {
pattern.matcher (str) return; // (2)}})

. filtrar( nueva Func1 <Matcher, booleano> () {booleana llamada

pública (Matcher matcher) {
matcher.matches de retorno () && matcher.group (1)! = null; // (3)}})

. mapa( nueva Func1 <Matcher, doble> () {llamada doble pública

(Matcher matcher) {
retorno Double.parseDouble (matcher.group (1)); // (4)

[13]
Una introducción a la programación reactiva

}});
}

los mapa() y filtrar() métodos llamados en el Observable ejemplo aquí son parte de la API fluida proporcionada por
RxJava. Se les puede llamar en una Observable ejemplo, la creación de un nuevo Observable instancia que depende de
estos métodos y que transforma o filtra los datos entrantes. El uso de estos métodos de la manera correcta, puede
expresar una lógica compleja en una serie de pasos que conducen a su objetivo. Lea más sobre esto en Capítulo 4, La
transformación, filtrado, y la acumulación de sus datos. Vamos a analizar el código:

1. Nuestros variables están interesados ​sólo en los mensajes en el formato < var_name>:
<Valor> o < var_name> = <valor>, por lo que vamos a utilizar esta expresión regular para filtrar y procesar
sólo este tipo de mensajes. Recuerde que nuestra entrada Observable ejemplo envía cada línea escribe el
usuario; es nuestro trabajo para manejar de la manera correcta.

2. El uso de los mensajes que recibimos de la entrada, se crea una matcher ejemplo
usando la expresión regular anterior como un patrón.

3. Pasamos a través de sólo datos que coincidan con la expresión regular. Todo lo demás se descarta.

4. Aquí, el valor de conjunto se extrae como una Doble valor numérico. Así es como los valores un y si están
representados por las corrientes de valores dobles, cambiando en el tiempo. Ahora podemos poner en práctica su
suma. Hemos implementado como una clase que implementa la Observador interfaz, porque quería mostrar otra forma
de suscribirse a Observable instancias-utilizando la Observador interfaz. Aquí está el código:

estáticas pública implementos ReactiveSum clase final Observador <Double> {// (1)

suma doble privada;

ReactiveSum pública (observable <Double> a, observable <Double> b) {
this.sum = 0;
Observable.combineLatest (a, b, nuevo Func2 <Doble, doble, doble> () {// (5)

convocatoria pública (Doble un doble b) {

volver a + b; }

.}) Suscribirse (this); // (6)}

OnCompleted public void () {

System.out.println ( "Salida última suma era:" + this.sum); // (4)

[14]
 Capítulo 1

}
onError public void (Throwable e) {
System.err.println ( "Tienes un error!"); // (3)
e.printStackTrace ();
}
onNext pública vacío (suma Doble) {
this.sum = suma;
System.out.println ( "actualización: a + b =" + suma); // (2)}}

Se trata de la aplicación de la suma real, depende de los dos Observable

instancias que representan sus colectores:

1. Es un Observador interfaz. los Observador ejemplo se puede pasar a la

Observable instancias suscribirse (Observador) método y define tres métodos que llevan el nombre de
los tres tipos de notificación: onNext (T), onError (Throwable), y OnCompleted. Lea más sobre esta
interfaz en
Capítulo 3, Creación y conexión de los observables, observadores, y los sujetos.

2. En nuestro onNext (Doble) implementación del método, se establece la suma al valor de entrada e
imprimir una actualización a la salida estándar.

3. Si obtenemos un error, simplemente imprimirlo.

4. Cuando todo está hecho, nos saludan al usuario la suma final.

5. Ponemos en práctica la suma con el combineLatest (observable,

Observable, Func2) método. Este método crea un nuevo Observable
ejemplo. El nuevo Observable instancia se actualiza cuando cualquiera de los dos
Observable casos, pasaron a combineLatest recibe una actualización. El valor emitido a través de
la nueva Observable ejemplo se calcula el parámetro-tercera función que tiene acceso a los
últimos valores de las dos secuencias de código. En nuestro caso, sumamos los valores. No
habrá ninguna notificación hasta tanto del Observable casos pasados ​al método Emit al menos un
valor. Por lo tanto, vamos a tener la suma sólo cuando tanto un y si

tener notificaciones. Leer más acerca de este método y otros combinadores en

Capítulo 5, Combinadores, condicionales, y tratamiento de errores.

6. Nosotros suscribimos nuestra Observador instancia al combinado Observable ejemplo. A continuación se

muestra de lo que la salida de este ejemplo se vería así:

Reacitve Sum. Tipo 'a: <número>' y 'b: <número>' para probarlo. a: 4 b: 5

actualización: a + b = 9,0

[ 15 ]
Una introducción a la programación reactiva

a: 6

actualización: a + b = 11,0

¡Así que esto es todo! Hemos puesto en marcha nuestra suma reactiva utilizando flujos de datos.

El código fuente de este ejemplo puede ser descargado y probado desde aquí: https://github.com/meddle0x53/learning-rxjava/
blob / master / src / main / java / com / packtpub / reactiva / Chapter01 / ReactiveSumV1.java.

Resumen
En este capítulo, nos fuimos a través de los principios reactivos y las razones por las que deben aprender y utilizar. No es
tan duro para construir una aplicación de reactivos; que sólo requiere la estructuración del programa en pequeños pasos
declarativas. Con RxJava, esto se puede lograr mediante la creación de múltiples flujos asíncronos conectados de la manera
correcta, la transformación de los datos de todo el camino a través de su consumo.

Los dos ejemplos que se presentan en este capítulo pueden parecer un poco complejo y confuso a primera vista,
pero en realidad, son bastante simples. Hay un montón de cosas nuevas en ellos, pero todo se explicarán en detalle
en los siguientes capítulos. Si desea obtener más información sobre la programación reactiva, echar un vistazo a Programación
reactiva en la API de Netflix con RxJava, un buen artículo sobre el tema, disponible en

http://techblog.netflix.com/2013/02/rxjava-netflix-api.html. Otro post bien introduciendo el concepto se puede

encontrar aquí: https://gist.github.com/ staltz / 868e7e9bc2a7b8c1f754.

Y estas son las diapositivas acerca de la programación reactiva y RX por Ben Christensen, uno de los
creadores de RxJava: https://speakerdeck.com/benjchristensen/ reactiva de programación-con-rx-en-qconsf-2014.

En el siguiente capítulo, vamos a hablar sobre algunos de los conceptos de la programación funcional y su
aplicación en Java 8. Esto nos dará las ideas básicas necesarias en el resto de los capítulos y nos ayudará a
deshacernos de la verbosidad de Java cuando se escriben programas reactivos.

[ dieciséis ]
 El uso de las construcciones
funcionales de Java 8
La programación funcional no es una idea nueva; En realidad, es bastante antigua. Por ejemplo,
Ceceo, que es un lenguaje funcional, es la segunda más antigua de lenguajes de programación comúnmente usados ​en la
actualidad.

Los programas funcionales se construyen con pequeños trozos de funciones puras reutilizables (lambdas). La lógica del
programa se compone de pequeños pasos declarativas y algoritmos no complejos. Esto se debe a los programas
funcionales minimizar el uso de estado, lo que hace que los programas imperativos complejo y difícil de refactor / apoyo.
Con Java 8, el mundo Java tiene las expresiones lambda y la capacidad de pasar funciones a las funciones. Con ellos,
podemos codificar en un estilo más funcional y deshacerse de una gran parte del código repetitivo. La otra cosa nueva
que conseguimos con Java 8 es la corrientes, algo muy similar a los observables de RxJava pero no asíncrona. La
combinación de estas corrientes y las lambdas, somos capaces de crear programas más funcional-como.

Vamos a familiarizarnos con estas nuevas construcciones y vistazo a la forma en que se pueden utilizar con las
abstracciones de RxJava. Nuestros programas será más simple y más fácil de seguir utilizando el lambdas, y los
conceptos presentados en este capítulo serán de ayuda, mientras que el diseño de aplicaciones. Este capítulo
comprende:

• Lambdas en Java 8

• ejemplos primera RxJava utilizando la sintaxis lambda

• ¿Qué funciones puras y funciones de orden superior son

[17]
El uso de las construcciones funcionales de Java 8

Lambdas en Java 8
El cambio más importante en Java 8 es la introducción de expresiones lambda. Permiten rápida, clara de codificación y
hacen posible el uso de la programación funcional. Java fue creado en los años 90 como un lenguaje de programación
orientado a objetos, con la idea de que todo debe ser un objeto. En ese momento, la programación orientada a objetos
fue el paradigma principal para el desarrollo de software. Sin embargo, recientemente, la programación funcional se ha
convertido cada vez más popular debido a que es muy adecuado para la programación concurrente y por eventos. Esto
no significa que debemos dejar de escribir código con lenguajes orientados a objetos. En lugar de ello, la mejor estrategia
es mezclar elementos de la programación orientada a objetos y funcional. La adición de lambdas a Java 8 lazos con esta
idea en Java es un lenguaje orientado a objetos, pero ahora tiene lambdas, somos capaces de código utilizando el estilo
funcional también. Echemos un vistazo a esta nueva función en detalle.

Presentación de la nueva sintaxis y la semántica

Con el fin de introducir las expresiones lambda, necesitamos ver su valor real. Es por esto que este capítulo se
iniciará con un ejemplo implementado sin necesidad de utilizar las expresiones lambda, seguido por
re-implementar el mismo ejemplo usando expresiones lambda. Recuerda el mapa (Func1) método de la Observable ¿clase?
Vamos a tratar de implementar algo similar para el java.util.List colecciones. Por supuesto, Java no permite añadir
métodos a las clases existentes, por lo que la implementación será un método estático que toma una lista y la
transformación y devuelve una nueva lista que contiene los elementos transformados. Para aprobar una
transformación con el método, vamos a necesitar una interfaz con un método que lo representa. Echemos un
vistazo al código:

interfaz Mapper <V, M> {// (1)

mapa M (valor V); // (2)}

// (3)
public static <V, M> Lista <M> mapa (List <V> lista, Mapper <V, M> mapeador) {

Lista <M> mapeado = new ArrayList <M> (list.size ()); // (4) para (V v: lista) {

mapped.add (mapper.map (v)); // (5)}

[18]
 Capitulo 2

retorno asignada; // (6)}

¿Que está sucediendo aquí?

1. Se define una interfaz genérica, llamada Mapper.

2. Tiene sólo un método, mapa M (V), que recibe un valor de tipo V y lo transforma en un valor
de tipo METRO.

3. El método estático Lista <M> mapa (List <V>, Mapper <V, M>) tiene una lista
con elementos de tipo V y una Mapper implementación. Usando esto Mapper
de implementación mapa() método en cada elemento de la lista de fuentes, convierte la lista para una nueva lista
de tipo METRO que contiene los elementos transformados.

4. La aplicación crea una nueva lista vacía de tipo METRO con el mismo tamaño que
la lista de fuentes.

5. Cada elemento de la lista fuente se transformó utilizando el pasado Mapper

aplicación y se añade a la nueva lista.

6. Se devuelve la nueva lista.

En esta implementación, cada vez que desea crear una nueva lista mediante la transformación de otra, tendremos que

poner en práctica el Mapper interactuar con la transformación derecha. Hasta Java 8, la forma correcta de pasar lógica

personalizada a los métodos era exactamente así, con instancias de clases anónimas, la aplicación de los métodos que se

indican. Pero Echemos un vistazo a cómo utilizamos esta Lista <M> mapa (List <V>, Mapper <V, M>) método:

Lista <entero> = asignadas mapa (números, nueva Mapper <Integer, Integer> () {

@Anular
pública Entero mapa (valor entero) {
Valor de retorno Valor *; // mapeo real
}});

Con el fin de solicitar una asignación a una lista, tenemos que escribir cuatro líneas de código repetitivo. El mapeo real es
muy simple y es sólo una de estas líneas. El verdadero problema aquí es que en lugar de pasar una acción, estamos
pasando un objeto. Esto oscurece la verdadera intención de este programa para pasar una acción que produce la
transformación de todos los elementos de la lista de fuentes y para obtener una lista con los cambios aplicados al final.
Esto es lo que esta llamada se parece a usar la nueva sintaxis lambda de Java 8:

Lista <entero> = asignada mapa (números, valor -> valor * valor);

[19]
El uso de las construcciones funcionales de Java 8

Bastante sencillo, ¿verdad? Y simplemente funciona. En lugar de pasar un objeto y la implementación de una
interfaz, se pasa un bloque de código, una función sin nombre. Que esta pasando? Definimos una interfaz
arbitraria con un método arbitrario, pero podríamos pasar este lambda en lugar de una instancia de la
interfaz. En Java 8, si se define interfaz con sólo un método abstracto y se crea un método que recibe un
parámetro de este tipo de interfaz, puede pasar una vez lambda. Si el método de interfaz única toma dos
argumentos de tipo cadena y devuelve un valor entero, el lambda tendrá que estar compuesto de dos
argumentos ante el -> y volver entero, los argumentos se infiere como cadenas. Interfaces de este tipo se
denominan interfaces funcionales. Es importante que el único método que sea abstracto y no por defecto.
Otra cosa nueva en Java 8 es el método por defecto de las interfaces:

Programa de interfaz de {
defecto Cadena fromChapter () {
volver "Dos"; }}

Los métodos por defecto son útiles cuando se cambia las interfaces ya existentes. Cuando añadimos métodos
predeterminados a ellos, las clases que implementan ellos no se romperán. Una interfaz con sólo un método por
defecto no es funcional; un solo método no debería ser por defecto.

Lambdas actúan como implementaciones de las interfaces funcionales. Por lo tanto, es posible asignarlos a variables de
tipo de interfaz de la siguiente manera:

Mapper <Integer, Integer> = cuadrados (valor) -> valor * valor;

Y podemos reutilizar el objeto cuadrado, ya que es una implementación de la Mapper interfaz. Tal vez usted ha notado,

pero en los ejemplos hasta ahora, los parámetros de las expresiones lambda no tienen ningún tipo. Esto es debido a

que los tipos se infieren. Por lo que esta expresión es absolutamente la misma que la expresión anterior:

Mapper <Integer, Integer> = cuadrados (valor entero) -> valor * valor;

El hecho de que el ejemplo con un parámetro sin un tipo de obras no es magia. Java es un lenguaje de tipos
estáticos, por lo que el parámetro del método único de la interfaz funcional se utiliza para la comprobación de tipos.

[20]
 Capitulo 2

¿Y el cuerpo de la expresión lambda? No hay regreso cualquier declaración. Resulta que estos dos
ejemplos son exactamente los mismos:

Mapper <Integer, Integer> = cuadrados (valor) -> valor * valor;

// y
Mapper <Integer, Integer> = cuadrados (valor) -> {

Valor de retorno Valor *; };

La primera expresión es sólo una forma corta de la segunda. Se prefiere que el lambda ser sólo una línea de
código. Pero si la expresión lambda contiene más de una línea, la única manera de definir que está utilizando el
segundo enfoque, así:

Mapper <Integer, Integer> = cuadrados (valor) -> {

System.out.println ( "Cálculo de la plaza de" + valor); Valor de retorno Valor *; };

Bajo el capó, las expresiones lambda no son sólo la sintaxis de azúcar para las clases internas anónimas. Se llevan a
cabo para realizar rápidamente dentro de la máquina virtual de Java
( JVM), así que si su código está diseñado para ser compatible con Java solamente 8+, que sin duda debe usarlos. Su
idea principal es la de pasar alrededor de la conducta de la misma manera que se pasa de datos. Esto hace que su
programa legible más humano. Una última cosa relacionada con la nueva sintaxis es la capacidad de pasar a métodos y
asignar a las variables funciones y los métodos ya definidos. Vamos a definir una nueva interfaz funcional:

Acción interfaz <V> {

acto void (valor V); }

Podemos utilizarlo para ejecutar acciones arbitrarias para cada valor en una lista; por ejemplo, el registro de la lista. Aquí es un
método que utiliza esta interfaz:

public static <V> acto nulo (List <V> lista, Acción <V> acción) {
para (V v: lista) {
action.act (v); }}

[21]
El uso de las construcciones funcionales de Java 8

Este método es similar a la mapa() función. En él se recorre la lista y llama a la acción del pasado Actuar() Método de
cada elemento. Digamos que es el uso de un lambda que simplemente registra los elementos de la lista:

actuar (lista, valor -> System.out.println (valor));

Esto es bastante simple, pero no es necesario debido a que el println () método se puede pasar en sí a la Actuar() método.
Esto se hace de la siguiente manera:

acto (lista, System.out :: println);

El código de estos ejemplos se puede ver / descargar en

https://github.com/meddle0x53/learning-rxjava/ blob / master / src / main / java / com /
packtpub / reactiva / capítulo02 / Java8LambdasSyntaxIntroduction.java.

Esta es una sintaxis válida en Java 8-todo método puede convertirse en un lambda y se pueden asignar a una
variable o pasado a un método. Todos estos son válidas:

• método del libro :: makeBook // estático de una clase

• libro de lectura :: // método de una instancia

• :: libro nuevo // constructor de una clase

• Libro :: leer // método de instancia, pero hace referencia sin necesidad de utilizar una instancia real.

Ahora que nos hemos revelado la sintaxis lambda, que lo va a utilizar en nuestros ejemplos RxJava en lugar
de clases internas anónimas.

interfaces funcionales en Java 8 y RxJava

Java 8 viene con un paquete especial que contiene las interfaces funcionales para los casos comunes.
Este paquete es java.util.function, y no vamos a mirar en detalle en este libro, pero presentaremos algunos de
los que vale la pena mencionar:

• Consumidor <T>: Esto representa una función que acepta un argumento y devuelve nada. Su
método abstracto es Void aceptar (T). A modo de ejemplo, podemos utilizarlo para asignar el System.out
:: println método a una variable, como sigue:

Consumidor <String> imprimir = System.out :: println;

[22]
 Capitulo 2

• Función <T, R>: Esto representa una función que acepta un argumento de un tipo dado y devuelve
un resultado de un tipo arbitrario. Su método abstracto es
R accept (T), y que puede ser utilizado para el mapeo. No necesitamos la Mapper
interconectar a todos! Vamos a echar un vistazo en el siguiente fragmento de código:

Función <Integer, String> ToStr = (valor) -> (valor + "!"); Lista <String cadena => mapa (enteros,
ToStr);

• Predicado <T>: Esto significa una función con sólo un argumento que devuelve un resultado booleano.
Su método abstracto es prueba booleana (T) y se puede utilizar para filtrar. Vamos a echar un vistazo al
siguiente código:

! Predicado <Integer> = impar (valor) -> valor% 2 = 0;

Hay una gran cantidad de interfaces funcionales similares a éstos; por ejemplo, una función con dos argumentos, o un
operador binario. Esto es de nuevo una función con dos argumentos, pero ambos del mismo tipo y devolver un resultado
con el mismo tipo. Ellos están ahí para ayudar a la reutilización lambdas en nuestro código.

Lo bueno es que es RxJava lambda compatibles. Esto significa que las acciones estábamos de paso a la suscribir método

son, de hecho, las interfaces funcionales! interfaces funcionales de RxJava están en el rx.functions paquete. Todos ellos

se extienden una base interfaz de marcador ( interfaz con no hay métodos, utilizados para la comprobación de tipos),

llamados
Función. Además, hay otra interfaz de marcador, que se extiende la Función
uno, llamado Acción. Se utiliza para los consumidores de la marca (funciones, nada de vuelta). RxJava tiene

once Acción interfaces:

Action0 // Acción sin parámetros Action1 <T1> // Acción con un parámetro

Acción2 <T1, T2> // Acción con dos parámetros

Acción9 <T1, T2, T3, T4, T5, T6, T7, T8, T9> // Acción con nueve parámetros ActionN // Acción con número
arbitrario de parámetros

Pueden ser utilizados principalmente para las suscripciones ( action1 y Action0). los
Observable.OnSubscribe <T> parámetro, que vimos en Capítulo 1, Introducción a la programación reactiva, ( utilizado para
la creación de los observables personalizados) se extiende la Acción
interconectarse también.

Análogamente, hay once Función extensores que representan resultado de volver función. Son Func0 <R>, Func1
<T1, R> ... Func9 <T1, T2, T3, T4, T5, T6, T7, T8, T9
, R>, y FuncN <R>. Se utilizan para el mapeo, el filtrado, la combinación, y muchos otros propósitos.

[23]
El uso de las construcciones funcionales de Java 8

Cada método de operador y suscribir en RxJava es aplicable a una o más de estas interfaces. Esto significa que
podemos usar expresiones lambda en lugar de clases internas anónimas en RxJava en casi todas partes. A partir
de ahora, todos los ejemplos se utilizan lambdas con el fin de ser más fácil de leer y algo funcional. Ahora,
Echemos un vistazo a un ejemplo grande RxJava implementado con lambdas. Este es nuestro ejemplo
familiarizado reactiva Sum!

Implementación del ejemplo suma reactivo con

lambdas
Así que esta vez, nuestro principal pieza de código será muy similar a la anterior:

ConnectableObservable <String> entrada =

CreateObservable.from (System.in);

Observable <Double> A = varStream ( "a", de entrada); Observable

<Double> b = varStream ( "b", de entrada);

reactiveSum (a, b); // La diferencia

input.connect ();

La única diferencia es que vamos a adoptar un enfoque más funcional en el cálculo de nuestra suma y no a
mantener el mismo estado. No estaremos implementando el
Observador interfaz; En su lugar, vamos a pasar a lambdas de suscripción. Esta solución es mucho más limpio.

los CreateObservable.from (InputStream) método es muy parecido se utilizó anteriormente. Vamos a saltar y mirar el Observable
<Double> varStream (String, observable <String>) método, que crea la Observable

instancias que representan los coleccionistas:

public static observable <Double> varStream (

String name final, observable <String> entrada) {
Modelo MODELO final = Pattern.compile (
"\\ s *" + nombre + "\\ s * [: | =] \\ s * (-?.? D + \\ \\ \\ d *) $"
);
entrada de retorno
. mapear (patrón :: matcher) // (1)
. filtro (m -> m.matches () && m.group (1) = null) // (2)
. mapa (matcher -> matcher.group (1)) // (3)
. mapa (Doble :: parseDouble); // ( 4)
}
)

[24]
 Capitulo 2

Este método es mucho más corto que anteriormente utilizado y se ve más simple. Pero semánticamente, es la
misma. Se crea una Observable ejemplo conectada a una fuente observable producir cadenas arbitrarias, y si una
cadena está en el formato que espera, extrae un número doble de ella y emite este número. La lógica
responsable de comprobar el formato de la entrada y extraer el número es de sólo cuatro líneas y está
representado por lambdas simples. Examinemos que:

1. Trazamos un lambda que crea una matcher instancia utilizando el patrón esperado
y la cadena de entrada.

2. Uso de la filtrar() método, sólo la entrada que está en el formato correcto es

filtrado.

3. Usando una mapa() operador, creamos una cadena de la matcher ejemplo, que
contiene sólo los datos de número que necesitamos.

4. Y de nuevo con el mapa() operador, la cadena se convierte en una doble

número. Y en cuanto a la nueva reactiveSum vacío (observable <doble>, observable

<Double>) aplicación del método, utilice el código siguiente:

public static reactiveSum vacío (

Observable <Double> a, observable
<Double> b) {
Observable
. combineLatest (a, b, (x, y) -> x + y) // (1)
. suscribirse (// (2)
suma -> System.out.println ( "update: a + b =" + suma), el error -> {

System.out.println ( "Tienes un error!"); error.printStackTrace ();

},

() -> System.out.println ( "Saliendo ...")

); }

Vamos a echar un vistazo al siguiente código:

1. Una vez más, se utiliza el combineLatest () método, pero esta vez la tercera
argumento es una lambda simple que implementa una suma.

2. El suscribir() método tiene tres expresiones lambda que se activan

cuando se producen los siguientes eventos:

° Los cambios de suma

° Hay un error

° El programa está a punto de acabado

[25]
El uso de las construcciones funcionales de Java 8

La fuente de este ejemplo se puede ver / descargar en https: //

github.com/meddle0x53/learning-rxjava/blob/master/ src / main / java / com / packtpub /
reactiva / capítulo02 / ReactiveSumV2.java.

Todo se hace más simple el uso de lambdas. Mirando el programa anterior, podemos ver que la mayor parte de la lógica se
compone de funciones pequeñas e independientes, encadenados utilizando otras funciones. Esto es lo que entendemos por
ser funcionales, para expresar nuestros programas usando tan pequeñas funciones reutilizables que tienen otras funciones y
las funciones de retorno y las abstracciones de datos, que transforman los datos de entrada usando cadenas de funciones
con el fin de producir el resultado deseado. Pero vamos a ver estas funciones en profundidad.

funciones puras y funciones de orden

superior
Usted no tiene que recordar la mayor parte de los términos introducidos en este capítulo; Lo importante es
entender cómo nos ayudan a escribir programas simples pero de gran alcance.

El enfoque de RxJava tiene muchas ideas funcionales incorporados, lo que es importante para nosotros aprender
cómo pensar en formas más funcionales con el fin de escribir aplicaciones más reactivos.

funciones puras
UN función pura es una función cuyo valor de retorno solamente está determinado por su entrada, sin observable efectos
secundarios. Si lo llamamos con los mismos parámetros norte tiempos, que van a obtener el mismo resultado cada
vez. Por ejemplo:

Predicado <Integer> incluso = (número) -> número% 2 == 0; int i = 50; while ((yo--)> 0) {

System.out.println ( "es de cinco, incluso -?" + Even.test (5)); }

Cada vez, la función devuelve incluso Falso porque depende sólo de su entrada, que es el mismo cada vez y no
es ni siquiera.

[26]
 Capitulo 2

Esta propiedad de las funciones puras se llama idempotencia. Idempotent funciones no dependen del tiempo, para que
puedan tratar los datos continuos como los flujos de datos infinitas. Y es así como los datos en constante cambio está
representado en RxJava ( Observable instancias).

Tenga en cuenta que, aquí, el término "idempotencia" se utiliza en su significado la informática. En

informática, una operación idempotente es uno que no tiene ningún efecto adicional si se llama más
de una vez con los mismos parámetros de entrada; en matemáticas, una operación idempotente es
aquel que satisface esta expresión: f (f (x)) = f (x).

funciones puras no causan efectos secundarios. Por ejemplo:

Predicado <Integer> impureEven = (número) -> {

System.out.println ( "Impresión aquí es efecto secundario!"); número de devolución% 2
== 0; };

Esta función no es puro, ya que se imprime en la salida de un mensaje cada vez que se llama. Por lo tanto, hace dos
cosas: se comprueba si el número es par, y se muestra un mensaje como un efecto secundario. Un efecto secundario es
cualquier posible salida observable la función se puede producir, por ejemplo, eventos de activación y lanzar excepciones
y de E / S, diferente de su valor de retorno. Un efecto secundario también cambia estados compartidos o argumentos
mutables.

Piénsalo. Si la mayor parte de su programa se compone de funciones puras, será fácil de escala y ejecutar partes
de ella en paralelo porque las funciones puras pueden no entran en conflicto entre sí y no cambiar el estado
compartido. Otra cosa que vale la pena mencionar en este apartado es inmutabilidad. Los objetos inmutables son
objetos que no pueden cambiar su estado. Un ejemplo bueno es el Cuerda clase en Java. los Cuerda casos no pueden
cambiarse; métodos incluso como subcadena

crear una nueva instancia de Cuerda sin modificar la llamada. Si pasamos de datos inmutables a una pura función,
podemos estar seguros de que cada vez que se llama a estos datos se devolverá el mismo. Con mudable objetos,
no es exactamente lo mismo cuando escribimos programas paralelos, porque un hilo puede cambiar el estado del
objeto. En este caso, la pura función devolverá un resultado diferente si se llama, y ​por lo tanto dejará de ser
idempotente.

Si almacenamos nuestros datos en los objetos inmutables y operar sobre ella usando funciones puras, la creación de
nuevos objetos inmutables en el proceso, vamos a estar a salvo de los problemas inesperados de concurrencia. No
habrá estado global y ningún estado mutable; todo va a ser simple y predecible.

[27]
El uso de las construcciones funcionales de Java 8

El uso de objetos inmutables es complicado; cada acción con ellos crea nuevas instancias, y esto podría comer hasta la
memoria. Sin embargo, existen métodos para evitar que; por ejemplo, reutilizar tanto como podamos de lo inmutable fuente, o
haciendo ciclos de vida de los objetos inmutables lo más corto posible (ya que los objetos del ciclo de vida cortos son amigables
con GC o el almacenamiento en caché). Los programas funcionales deben estar diseñados para trabajar con datos sin estado
inmutables.

programas complejos no pueden ser compuestos únicamente de funciones puras, pero siempre que sea posible, es
bueno para usarlos. En la aplicación de este capítulo de El Reactivo Suma,
pasamos a mapa(), filtrar(), y combineLatest () sólo funciones puras. Hablando de la mapa() y filtrar() funciones, los

llamamos funciones de orden superior.

funciones de orden superior

Una función con al menos un parámetro de la función de tipo o una función que devuelve funciones se denomina mayor
función de orden. Por supuesto, funciones de orden superior pueden ser puros.

Aquí está un ejemplo de una función superior que lleva parámetros de la función:

public static <T, R> int highSum (

Función <T, Integer> f1, función <R,
Integer> f2, T datos1, datos2 R) {

volver f1.apply (datos1) + f2.apply (data2); }

Se necesitan dos funciones de tipo T -> int / R -> int y algunos datos con el fin de llamar y resumir sus resultados.
Por ejemplo, podemos hacerlo de esta manera:

highSum (v -> v * v, v -> v * v * v, 3, 2);

Aquí resumimos la plaza de tres y el cubo de dos.

Pero la idea de funciones de orden superior es ser flexible. Por ejemplo, podemos utilizar el
highSum () función para un propósito completamente diferente, por ejemplo, la suma de las cadenas, como se muestra aquí:

Función <String, Integer> strToInt = s -> Integer.parseInt (s);

highSum (strToInt, strToInt, "4", "5");

[28]
 Capitulo 2

Por lo tanto, una función de orden superior se puede utilizar para aplicar el mismo comportamiento para diferentes tipos de entrada.

Si los dos primeros argumentos que pasamos a la highSum () función son funciones puras, será una función pura
también. los strToInt parámetro es una función pura, y si llamamos a la highSum (strToInt, strToInt, "4", "5") método norte
veces, se le devolverá el mismo resultado y no tienen efectos secundarios. Aquí es otro ejemplo de una función
de orden superior:

Función public static <String, String> saludar (String saludo) {

retorno (String name) -> + saludo "" + nombre + "!"; }

Esta es una función que devuelve otra función. Se puede utilizar la siguiente manera:

System.out.println (saludar ( "Hola") se aplican ( "mundo").); 'mundo Hellow!' //

Imprime

System.out.println (. Greet ( "adiós") se aplica ( "mundo cruel")); // imprime 'Adiós mundo cruel!'

Función <String, String> Howdy = greet ( "Howdy");

System.out.println (howdy.apply ( "Tanya")); System.out.println (howdy.apply (

"Dali")); // Estos dos print 'Hola Tania!' y '¡Hola Dali'

El código de este ejemplo se puede encontrar en https: // github. com /

meddle0x53 / aprendizaje-rxjava / burbuja / maestro / src / main / java / com /
packtpub / reactiva / capítulo02 / PureAndHigherOrderFunctions.java.

Funciones como éstas pueden ser utilizadas para implementar diferentes comportamientos que tienen algo en común. En la

programación orientada a objetos definimos las clases y luego extender ellos, la sobrecarga de sus métodos. En la

programación funcional, se definen las funciones de orden superior como interfaces y los llamamos con diferentes parámetros,

dando lugar a diferentes comportamientos. Estas funciones son ciudadanos de primera clase; podemos codificar nuestra lógica

usando sólo las funciones, el encadenamiento de ellos, y el manejo de nuestros datos, la transformación, la filtración, o

acumularlo en un resultado.

[29]
El uso de las construcciones funcionales de Java 8

RxJava y la programación funcional

conceptos funcionales, tales como funciones puras y funciones de orden superior son muy importantes para
RxJava. RxJava de Observable clase es una implementación de un interfaz fluida. Esto significa que la mayoría de sus
métodos de instancia devolver una Observable
ejemplo. Por ejemplo:

Observable asignada = observable.map (someFunction);

los mapa() Devuelve un nuevo operador Observable ejemplo, emitiendo los datos transformados por ella. Los operadores como mapa()
son claramente las funciones de orden superior, y que pueden pasar a otras funciones a ellos. Por lo tanto, un programa
RxJava típico está representado por una cadena de operadores encadenado a una Observable instancia a la que múltiples suscriptores

pueden suscribirse. Estas funciones encadenadas pueden beneficiarse de los temas tratados en este capítulo.
Podemos pasar lambdas a ellos en lugar de implementaciones de interfaces anónimos (como vimos con la
segunda aplicación de la Suma reactiva),
y debemos tratar de trabajar con datos inmutables y funciones puras siempre que sea posible. De esta manera, nuestro
código será sencilla y segura.

Resumen
En este capítulo, hemos visto algunos de los principios y términos de programación funcional. Hemos aprendido
cómo escribir programas formados por pequeñas acciones función pura, encadenados juntos utilizando funciones de
orden superior.

Como la programación funcional es cada vez más popular, los desarrolladores competentes en que será de gran
demanda en un futuro muy próximo. Esto se debe a que nos ayuda a lograr escalabilidad y paralelismo con
facilidad. Y lo que es más, si añadimos la idea reactiva a la misma, se hace aún más atractivo.

Es por eso que vamos a bucear en el marco RxJava en los próximos capítulos, aprender a utilizar para
nuestro beneficio. Comenzaremos con la Observable técnicas de creación de instancias. Esto nos
proporcionará la habilidad para crear una Observable
instancia de todo, convirtiendo así a casi todo en un programa funcional reactivo.

[30]
 Creación y
Conexión observables,
Observadores, y los sujetos
RxJava de Observable casos son los bloques de construcción de aplicaciones de reactivos, y esta ventaja de RxJava es
beneficioso. Si tenemos una fuente Observable ejemplo, podríamos lógica cadena a la misma y suscribir para el resultado.
Todo lo que necesitamos es este inicial
Observable ejemplo.

En el navegador o en una aplicación de escritorio, la entrada del usuario ya está representada por los eventos que
podemos manejar y hacia adelante a través Observable instancias. Pero sería muy bueno para convertir todos nuestros
cambios o acciones de datos en Observable casos, no sólo la entrada del usuario. Por ejemplo, cuando leemos datos de un
archivo, sería ordenada a mirar cada línea leída o cada secuencia de bytes como un mensaje de que se puede emitir a
través de una Observable ejemplo.

Pronto nos ocuparemos en detalle la forma en que las fuentes de datos diferentes pueden ser transformados en

Observable instancias; no importa si son externos (archivos o entradas de usuario) o internos (colecciones o
escalares). Lo que es más, vamos a aprender acerca de los distintos tipos de
Observable casos, dependiendo de su comportamiento. Otra cosa importante que vamos a aprender es cómo y
cuándo debe darse de baja Observable instancias y cómo utilizar las suscripciones y Observador instancias.
Además, vamos a presentar Tipo de materia y su uso.

En este capítulo, vamos a aprender acerca de:

• Observable métodos- fábrica simplemente, de, crear, y otros

• Observadores y suscriptores

• Caliente y frío observables; observables que se pueden conectar

[31]