Upgrade to Pro — share decks privately, control downloads, hide ads and more …

[Jornada Summit 2021] Programação reativa com Java: o que é preciso saber antes do primeiro projeto

[Jornada Summit 2021] Programação reativa com Java: o que é preciso saber antes do primeiro projeto

Transcript

  1. Programação reativa com Java: o que é preciso saber antes

    do primeiro projeto Kamila Santos
  2. Kamila santos Backend Developer Co-autora do livro Jornada Java Criadora

    de conteúdo de tech no perfil @kamila_code
  3. Paradigma reativo É um paradigma de programação orientado para fluxos

    de dados / eventos, bem como sua propagação de forma assíncrona. @kamila_code
  4. Paradigma reativo Como funciona de forma assíncrona, é altamente recomendável

    lidar com grandes volumes de dados que sofrem grandes alterações em tempo real. @kamila_code
  5. Manifesto Reativo Responsivo Resiliente Elástico Message Driven @kamila_code

  6. Responsivo O sistema responde em tempo hábil, se possível @kamila_code

  7. Resiliente O sistema permanece responsivo a falhas @kamila_code

  8. Elástico O sistema permanece responsivo em face de uma carga

    de trabalho variável. @kamila_code
  9. Message Driven Os aplicativos reativos contam com mensagens assíncronas para

    estabelecer um limite entre os componentes, garantindo acoplamento flexível, isolamento e transparência @kamila_code
  10. RxJava @kamila_code

  11. RxJava É uma implementação para o Reactive Extensions JVM, que

    é uma biblioteca assíncrona e baseada em eventos que funciona com sequências observables. @kamila_code
  12. RxJava Estende do padrão observer -> cada objeto chamado (sujeito),

    possui uma lista de dependentes (observadores) que são notificados automaticamente pelo sujeito a cada mudança de estado por meio de seus operadores e métodos. @kamila_code
  13. RxJava Suporta sequências de dados e eventos para compor suas

    strings de eventos de forma declarativa. @kamila_code
  14. Reactive Streams Iniciativa que visa forncece um guia/padrão para fluxo

    de mensagens assíncronas de forma NIO. @kamila_code
  15. INTERFACE FLOW.PUBLISHER<T> métodos para produzir fluxos e outros eventos @kamila_code

  16. INTERFACE FLOW.SUBSCRIBER<T> métodos para receber fluxos e outros eventos @kamila_code

  17. INTERFACE FLOW.SUBSCRIPTION vínculo entre Publisher e Subscriber @kamila_code

  18. INTERFACE FLOW.PROCESSOR<T,R> Define métodos capazes de fazer operações mais avançadas,

    como transformar publisher para subscriber @kamila_code
  19. Reactive Streams Desenvolvida para ambientes de runtime como a JVM,

    bem como alguns protocolos de comunicação: https: //github.com/reactive-streams/reactive-streams-jvm @kamila_code
  20. Reactive Streams Em resumo, é um conjunto de métodos, interfaces

    e protocolos que vão descrever as operações entidades necessárias para o transporte de informações de forma assíncrona. @kamila_code
  21. Conceitos base da programação reativa @kamila_code

  22. Backpressure Resistência ou força que se opõe ao fluxo de

    dados desejado através do software. Feedback do receptor para o produtor de que ele não está suportando a carga. @kamila_code
  23. Stream Sequência de objetos que suporta vários métodos que podem

    ser operados para produzir um resultado. @kamila_code
  24. OnNext() representa algum valor/passo, deverá executar uma próxima ação @kamila_code

  25. OnError() Indica qual ação será executada em caso de erro

    @kamila_code
  26. OnComplete() Indica qual ação será executada em de término de

    uma sequência de ações @kamila_code
  27. Flux Pode emitir de 0 a N eventos, passando por

    OnNext(), onComplete() e OnError(); @kamila_code
  28. Mono Pode emitir de 0 a 1 eventos, passando por

    OnNext(), onComplete() e OnError(); @kamila_code
  29. Observable Tem a capacidade de passar mensagens de forma assíncrona.

    @kamila_code
  30. Subscriber Consome os dados recebidos de uma subscription @kamila_code

  31. Publisher Produz as informações que serão consumida pela subscription e

    lida pelo subscriber. @kamila_code
  32. Cold Observable a sequência de eventos só é executada se

    Observable tiver um Subscriber associado @kamila_code
  33. Hot Observable ele transmite eventos independentemente de haver um Subscriber

    associado @kamila_code
  34. Spring WebFlux @kamila_code

  35. Spring WebFlux Spring WebFlux pode ser definido como uma versão

    “paralela” ao já conhecido e amplamente utilizado Spring MVC (servlet), tendo como principal diferença o suporte para streams NIO reativos e por suportar o conceito de backpressure com o servidor Netty vindo por padrão embutido em sua arquitetura. @kamila_code
  36. Spring WebFlux A partir da versão 5.0 do Spring Framework

    temos uma parte reativa além da estrutura Servlet que já existia, cada módulo destes é opcional, você pode usar a parte Servlet, a parte reativa ou mesmo ambas em suas aplicações. @kamila_code
  37. Spring WebFlux HTTPS://DOCS.SPRING.IO/SPRING-FRAMEWORK/DOCS/5.0.0.BUILD-SNAPSHOT/SPRING- FRAMEWORK-REFERENCE/HTML/WEB-REACTIVE.HTML @kamila_code

  38. Spring WebFlux Spring Webflux foi desenvolvido porque precisávamos de aplicativos

    não bloqueantes que pudessem funcionar com um pequeno número de threads simultaneamente e que pudessem ser executados com alguns recursos de hardware. @kamila_code
  39. Projeto Reactor É uma biblioteca baseada nas Reactive Streams Specification,

    é totalmente não bloqueante e interage diretamente com a API Java funcional (Stream, Duration e Completable Future), para composição de elementos utilizando Flux e Mono em arquiteturas de microsserviços, oferecendo mecanismos de contrapressão prontos para TCP , UDP e HTTP (incluindo web sockets). @kamila_code
  40. Projeto Reactor Reactor Core Reactor Netty Reactor Test @kamila_code

  41. Exemplos @kamila_code

  42. Exemplos @kamila_code

  43. Exemplos @kamila_code

  44. Exemplos @kamila_code

  45. Exemplos @kamila_code

  46. Exemplos @kamila_code

  47. Exemplos @kamila_code

  48. Exemplos @kamila_code

  49. Exemplos @kamila_code

  50. Exemplos @kamila_code

  51. Benefícios

  52. Pontos Negativos

  53. Referências https://www.baeldung.com/rx-java https://github.com/reactive-streams/reactive-streams-jvm https://timurisachenko.com/experiment-3-reactive-spring- webflux-r2dbc-todo-rest-api/ https://www.baeldung.com/rsocket https://rsocket.io/ https://r2dbc.io/

  54. Referências https://tech.io/playgrounds/929/reactive-programming- with-reactor-3/transform https://www.callicoder.com/reactive-rest-apis-spring- webflux-reactive-mongo/ http://reactivex.io/languages.html https://projectreactor.io/ http://www.trieu.xyz/2019/04/netty-cookbook.html https://dzone.com/articles/build-a-simple-netty-application- with-and-without

    https://www.baeldung.com/netty
  55. Referências https://tech.io/playgrounds/929/reactive-programming- with-reactor-3/transform https://www.callicoder.com/reactive-rest-apis-spring- webflux-reactive-mongo/ http://reactivex.io/languages.html https://projectreactor.io/ http://www.trieu.xyz/2019/04/netty-cookbook.html https://dzone.com/articles/build-a-simple-netty-application- with-and-without

    https://www.baeldung.com/netty
  56. Obrigada :) https://www.linkedin.com/in/kamila-santos-oliveira/ kamila_code kamilah_santos kamilahsantos