6. @aalmiray
SINCRONO VS ASINCRONO
Las operaciones síncronas bloquean el flujo hasta obtener
un resultado (éxito o error).
Las operaciones asíncronas no bloquean el flujo, permiten
que el programa continúe. Resultados y/o errores son
manipulados en un momento posterior, típicamente haciendo
uso de funciones (callbacks).
7. @aalmiray
FUTUROS Y PROMESAS
Describen un objecto que actúa como mediador sobre un
valor que se desconoce inicialmente.
El término Futuro y Promesa se usan indistintamente, pero
existe una diferencia:
• El Futuro es una referencia de sólo lectura al valor
esperado.
• La promesa es un contenedor de escritura única que
encargado de definir el valor del Futuro.
https://en.wikipedia.org/wiki/Futures_and_promises
8. @aalmiray
FUTUROS Y PROMESAS
Los Futuros en Java son inherentemente síncronos,
demonstrable por los siguientes métodos definidos en
java.util.concurrent.Future
V get()
V get(long timeout, TimeUnit unit)
9. @aalmiray
FUTUROS Y PROMESAS
Java8 incluye un nuevo tipo llamado CompletableFuture, el
cual implementa CompletableStage, que a su vez define el
comportamiento de una Promesa, como por ejemplo
thenAccept(Consumer<? Super T> action)
whenComplete(BiConsumer<? super T,? super Throwable>
action)
exceptionally(Function<Throwable,? extends T> fn)
… y muchos otros
10. @aalmiray
FUTUROS Y PROMESAS
JDeferred ofrece un API distinta que permite mejor
composición de funciones
Promise<D, F, P> then(DoneCallback<D> doneCallback)
Promise<D, F, P> done(DoneCallback<D> callback)
Promise<D, F, P> fail(FailCallback<F> callback)
Promise<D, F, P> always(AlwaysCallback<D, F> callback)
29. @aalmiray
HTTP://REACTIVEX.IO/
API para Programación Reactiva que provee flujos de datos
observables.
Existen múltiples implementaciones en más de 20 lenguages.
Java y Javascript implementan el estándar definido por
http://www.reactive-streams.org/
32. @aalmiray
FLUJO DE DATOS
Secuencia de valores calculados en el tiempo.
Los valores se emiten cuando éstos se encuentran
disponibles, es decir, han sido computados sin bloquear a
los consumidores.
Los consumidores de un flujo de datos escuchan los
cambios en el flujo y reaccionan a dichos cambios.
Modelo push vs pull.
33. @aalmiray
OBSERVABLE/OBSERVER
Los flujos de datos son de tipo Observable mientras que los
consumidores son de tipo Observer.
El tipo Observable expone una multitud de operaciones que
permiten composición, combinaciones, filtros, y/o
transformaciones de valores según éstos son añadidos al
flujo de datos por el productor.
Ojo: las operaciones en RxJava/Reactor generan un nuevo
Observable usando el patrón decorador
41. @aalmiray
FUNCIONES
Las funciones en Programación Funcional usualmente
poseen dos características:
• No exponen efectos secundarios durante su invocación.
• Dado el mismo conjunto de entradas se obtiene el mismo
resultado al invocarlas.
42. @aalmiray
IMMUTABILIDAD
Estructuras de datos immutables y/o contenedores de datos
immutables (POJOs) complementan de manera ideal a la
programación funcional.
Permiten compartir datos entre múltiples consumidores y/o
funciones sin temor de que ocurran cambios en los datos
originales.
Reducen los puntos de sincronización.
45. @aalmiray
JAVA 9 FLOW
Java 9 implementa tambien Reactive Streams con el nuevo
tipo java.util.concurrent.Flow
Este API permitará combinar streams de distintos
proveedores (RxJava , Reactor).
Adiciones al API de CompletableFuture.
46. @aalmiray
REACTIVE SPRING (WEB)
@GetMapping("/accounts/{id}/alerts")
public Flux<Alert> getAccountAlerts(@PathVariable Long id) {
return this.repository.getAccount(id)
.flatMap(account ->
this.webClient
.perform(get("/alerts/{key}", account.getKey()))
.extract(bodyStream(Alert.class)));
}
https://spring.io/blog/2016/07/28/reactive-programming-with-spring-5-0-m1
47. @aalmiray
REACTIVE SPRING (DATA+WEB)
@RestController
class PersonController {
private final PersonRepository people;
public PersonController(PersonRepository people) {
this.people = people;
}
@GetMapping("/people")
Flux<String> namesByLastname(@RequestParam Mono<String> lastname) {
Flux<Person> result = repository.findByLastname(lastname);
return result.map(it -> it.getFullName());
}
}
https://spring.io/blog/2016/11/28/going-reactive-with-spring-data