Introducción a la programación reactiva con Vert.x. Esta presentación la utilicé en una charla para desarrolladores https://www.meetup.com/es-ES/Software-Crafters-Alicante/events/264365511/

1. Programación reactiva con Vert.xProgramación reactiva con Vert.x

2. ¿Quién soy?¿Quién soy?
{
"name":"Fran García",
"email":"fgarciarico@gmail.com",
"twitter":"@frangarcia",
"linkedin":"https://www.linkedin.com/in/frangarcia/",
"position":"Ingeniero de Software Senior en Wayin",
"description":"Desde 2014 con Vert.x"
}

3. Contexto actualContexto actual
Fuente: https://www.ericsson.com

4. SoluciónSolución
Aprovechemos mejor los recursos.

5. Programación reactivaProgramación reactiva

6. ¿Qué es la programación reactiva?¿Qué es la programación reactiva?
Se refiere a un paradigma de programación enfocado
al tratamiento de flujos de datos de forma asíncrona
tal y como se recoge en el Reactive Manifesto
http://www.reactivemanifesto.org

7. Principios del Reactive ManifestoPrincipios del Reactive Manifesto
Responsivos
Resilientes
Elásticos
Orientados a Mensajes

8. ResponsivosResponsivos
Responder de manera oportuna
Detectar problemas rápidamente
Tiempos de respuesta rápidos

9. ResilientesResilientes
Responder correctamente a fallos
Replicación
Aislamiento

10. ElásticosElásticos
Siempre responsivo ante diferentes niveles de
carga
Reaccionar a los cambios
Evitar cuellos de botella

11. Orientados a MensajesOrientados a Mensajes
Intercambio de mensajes asíncronos
Bajo acoplamiento
Aislamiento

12. Arquitectura del Manifiesto de SistemasArquitectura del Manifiesto de Sistemas
ReactivosReactivos
Responsive
Resilient
Message Driven
Elastic
Fuente: http://www.reactivemanifesto.org

13. Hollywood PrincipleHollywood Principle
Fuente: https://dzone.com/articles/the-hollywood-
principle

14. ¿Qué es Vert.x?¿Qué es Vert.x?
Eclipse Vert.x ( ) es un conjunto de
utilidades (no un framework) basado en 2 conceptos
Diseño dirigido por los eventos
Es NO bloqueante
http://vertx.io

15. Características de Vert.xCaracterísticas de Vert.x
Propósito general
Políglota
Java
Javascript
Groovy
Ruby
Ceylon
Scala
Kotlin
Escalabilidad
No dogmático

16. Características de Vert.xCaracterísticas de Vert.x
Muy ligero
Rápido
No es un servidor de aplicaciones
Modular
Sencillo pero no simplista
Ideal para microservicios
Buenísima documentación

17. ¿Quién utiliza Vert.x?¿Quién utiliza Vert.x?

18. Instalación de Vert.xInstalación de Vert.x
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install vertx

19. Vert.x coreVert.x core
Clientes y servidores TCP
Clientes y servidores HTTP
Websockets
Event bus
Datos compartidos
Acciones periódicas
Desplegar verticles
Clientes DNS
Acceso al sistema de ficheros
Alta disponibilidad
Clustering

20. IntegraciónIntegración
MySQL
PostgreSQL
Elasticsearch
Redis
Kafka

21. ¿Qué es el event loop?¿Qué es el event loop?
¿Tenemos algún evento que procesar?
Lo proceso y llamo a los handlers necesarios
Y así constantemente
Tantos hilos de event loop como número de
núcleos * 2

22. Event loopEvent loop
Fuente: http://escoffier.me/vertx-kubernetes/

23. Event loopEvent loop
Fuente: http://www.vertx.io

24. ¿Igual que Node.js?¿Igual que Node.js?
Node.js utiliza un único event loop mientras que Vert.x
utiliza un event loop por cada core multiplicado por
dos. Esto se conoce como Multi-Reactor Pattern.

25. La regla de oroLa regla de oro
!!No bloquees el event loop!!

26. Ejemplos de bloquear el event loopEjemplos de bloquear el event loop
Thread.sleep()
Costosas operaciones con bases de datos
Cálculos complejos que tarden mucho

27. Ejecutar código bloqueanteEjecutar código bloqueante
vertx.executeBlocking({ future ->
// Llama a métodos bloqueantes
def result = someAPI.blockingMethod("hello")
future.complete(result)
}, { res ->
println("The result is: ${res.result()}")
})

28. Talk is cheap, show me the codeTalk is cheap, show me the code
Fuente: Recruiting daily

29. Ejemplo: Hello world!Ejemplo: Hello world!
vertx run s01e01.groovy
import io.vertx.core.http.HttpServer
HttpServer httpServer = vertx.createHttpServer()
//Responder a cada petición con un Hello World!
httpServer.requestHandler({ request ->
// Este handler será llamado con una petición al servidor
request.response().end("hello world!")
})
httpServer.listen(8080)

30. Ejemplo: Devolviendo JsonEjemplo: Devolviendo Json
vertx run s01e02.groovy
import io.vertx.core.http.HttpServer
HttpServer httpServer = vertx.createHttpServer()
//Responder a cada petición con un Hello World!
httpServer.requestHandler({ request ->
String json = """{"foo":"bar"}"""
request.response()
.putHeader("Content-Type", "application/json")
.putHeader("Content-Length",json.size().toString())
.write(json)
.end()
})
httpServer.listen(8080)

31. Ejemplo: Ejecuciones periódicasEjemplo: Ejecuciones periódicas
vertx run s01e03.groovy
vertx.setPeriodic(1000, {id ->
println("Temporizador ejecutado! ${id}")
})

32. Ejemplo: TemporizadoresEjemplo: Temporizadores
vertx run s01e04.groovy
Closure handler
handler = { id ->
println("Temporizador ejecutado! ${id}")
vertx.setTimer(1000*(id+1), handler)
}
vertx.setTimer(1000, handler)

33. VerticlesVerticles
Suponen el corazón de Vert.x
Aunque no estás obligado a utilizarlos
Una aplicación consiste habitualmente en
muchos verticles ejecutándose simultáneamente
en una instancia de Vert.x

34. Escribiendo verticlesEscribiendo verticles
En un Groovy script
En una clase Groovy que implementa la interfaz
o extiende la claseVerticle AbstractVerticle

35. Desplegando verticlesDesplegando verticles
vertx run s01e05.groovy
vertx.deployVerticle("HelloWorldHttpVerticle.groovy")
vertx.deployVerticle("s01e06.groovy")

36. Desplegando verticles:Desplegando verticles:
HelloWorldHttpVerticle.groovyHelloWorldHttpVerticle.groovy
import io.vertx.core.AbstractVerticle
public class HelloWorldHttpVerticle extends AbstractVerticle {
public void start() {
println("Starting HelloWorldHttpVerticle")
}
public void stop() {
println("Stopping HelloWorldHttpVerticle")
}
}

37. Desplegando verticles: s01e06.groovyDesplegando verticles: s01e06.groovy
void vertxStart() {
println "starting s01e06"
}
void vertxStop() {
println "stopping s01e06"
}

38. Desplegando verticles de formaDesplegando verticles de forma
asíncronaasíncrona
vertx run s01e07.groovy
import io.vertx.core.Future
void vertxStart(Future future) {
vertx.deployVerticle("s01e06.groovy", { res ->
if (res.succeeded()) {
println "s01e06 started successfully asynchronously"
future.complete()
} else {
println "error starting s01e06 asynchronously"
future.fail("Error starting s01e06")
}
})
}
void vertxStop(Future future) {

39. Desplegando verticles de formaDesplegando verticles de forma
asíncronaasíncrona
vertx run HelloWorldHttpVerticleAsync.groovy
import io.vertx.core.AbstractVerticle
import io.vertx.core.Future
public class HelloWorldHttpVerticleAsync extends AbstractVerti
public void start(Future future) {
println "starting"
vertx.deployVerticle("s01e06.groovy", { res ->
if (res.succeeded()) {
println "s01e06 started successfully asynchronously"
future.complete()
} else {
println "s01e06 not started asynchronously due to an e
future.fail()
}

40. Desplegando verticles con variasDesplegando verticles con varias
instanciasinstancias
vertx run s01e08.groovy
vertx.deployVerticle("HelloWorldHttpVerticle.groovy", [instanc

41. Tipos de verticlesTipos de verticles
Standard
Worker
Multi-Threaded

42. Standard verticlesStandard verticles
Se asigna un event loop cuando se crean
Vert.x garantiza que cualquier código de estos
verticles siempre se ejecutará en el mismo event
loop
De esta forma, escribe tu aplicación como si fuera
monohilo que Vert.x ya se encargará de hacerlo
multihilo y de la escalabilidad

43. Worker verticlesWorker verticles
No utilizan el event loop
Utilizan un thread del pool de threads de Vert.x
Están diseñados para ejecutar código bloqueante
def options = [
worker:true
]
vertx.deployVerticle("MyFirstVerticle", options)

44. Multi-thread worker verticlesMulti-thread worker verticles
Como un worker verticle pero que puede ser
ejecutado en multiples threads

45. Event busEvent bus
Es el sistema nervioso de Vert.x
Un unico event bus para cualquier verticle
Es la mejor forma de comunicar verticles en Vert.x

46. ¿Cómo funciona el Event bus?¿Cómo funciona el Event bus?
Mandamos mensaje a una dirección, e.g.
europe.news.feed
Los mensajes son simples cadenas de texto
Los handlers reciben los mensajes, pero antes
habrá que registrarlos
Varios handlers pueden estar suscritos en una
misma dirección
Un mismo handler puede estar suscritos en varias
direcciones

47. Tipos de subscripciónTipos de subscripción
Publish/Subscribe
Punto a punto

48. Tipos de subscripción:Tipos de subscripción:
Publish/SubscribePublish/Subscribe
Todos los handlers suscritos a una dirección recibirán
el mensaje.

49. Tipos de suscripción: Punto a puntoTipos de suscripción: Punto a punto
Vert.x se encargará de que sólo un handler reciba el
mensaje. Se puede especificar incluso un reply
handler.

50. Tipos de mensajes en el event busTipos de mensajes en el event bus
Normalmente se utiliza Json, aunque no estamos
forzados a ello.

51. Registrando handlersRegistrando handlers
def eb = vertx.eventBus()
eb.consumer("news.uk.sport", { message ->
println("I have received a message: ${message.body()}")
})

52. Ejemplo: Publish/SubscribeEjemplo: Publish/Subscribe
vertx run PublishingMessage.groovy
import io.vertx.core.http.HttpServer
def eventBus = vertx.eventBus()
eventBus.consumer("news.uk.sport", { message ->
println("EH1: I have received a message: ${message.body()}")
})
eventBus.consumer("news.uk.sport", { message ->
println("EH2: I have received a message: ${message.body()}")
})
HttpServer httpServer = vertx.createHttpServer()
httpServer.requestHandler({ request ->

53. Ejemplo: Punto a puntoEjemplo: Punto a punto
vertx run PointToPointExample.groovy
import io.vertx.core.http.HttpServer
def eventBus = vertx.eventBus()
eventBus.consumer("news.uk.sport", { message ->
println("EH1: I have received a message: ${message.body()}")
})
eventBus.consumer("news.uk.sport", { message ->
println("EH2: I have received a message: ${message.body()}")
})
HttpServer httpServer = vertx.createHttpServer()
httpServer.requestHandler({ request ->

54. Ejemplo: Respondiendo al eventoEjemplo: Respondiendo al evento
vertx run EventReplyExample.groovy
import io.vertx.core.http.HttpServer
def eventBus = vertx.eventBus()
eventBus.consumer("news.uk.sport", { message ->
println("I have received a message: ${message.body()}")
message.reply("Event received, thanks!")
})
HttpServer httpServer = vertx.createHttpServer()
httpServer.requestHandler({ request ->
eventBus.send("news.uk.sport", "Yay! Someone kicked a ball",
if (ar.succeeded()) {
request.response().end("This is what we received: "${ar
} else {
request.response().end("There was an error")

55. EjercicioEjercicio
Si sólo conocieramos Eclipse Vert.x, ¿como
diseñaríamos la arquitectura de un servicio para
registrar usuarios que necesita mandar un mail de
confirmación a través de un servicio externo y al
mismo tiempo el nuevo usuario debe ser añadido a
otro servicio externo?

56. Demo: JuegoDemo: Juego
https://bit.ly/2PKs75P

57. Más informaciónMás información
https://vertx.io/
https://groups.google.com/forum/#!forum/vertx

58. Fuente: https://velvetyblog.com

59. ¿Preguntas?¿Preguntas?