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

[BSB] primeiros passos com webflux

[BSB] primeiros passos com webflux

Transcript

  1. Programação reativa com Java Primeiros passos com Spring Webflux github.com/kamilahsantos

    in/kamila-santos-oliveira/ @kamilah_santos https://dev.to/kamilahsantos
  2. Backend Developer github.com/kamilahsantos in/kamila-santos-oliveira/ @kamilah_santos https://dev.to/kamilahsantos

  3. None
  4. Reactive Manifest https://www.reactivemanifesto.org/ @kamilah_santos

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

  6. Resiliente O sistema permanece responsivo a falhas @kamilah_santos

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

    de trabalho variável. @kamilah_santos
  8. Message Driven Os aplicativos reativos contam com a passagem de

    mensagens assíncronas para estabelecer um limite entre os componentes, garantindo acoplamento flexível, isolamento e transparência @kamilah_santos
  9. Reactive Streams Iniciativa para fornecer um padrão / guia /

    regras para processamento de fluxo assíncrono com backpressure NIO @kamilah_santos
  10. interface Flow.Publisher<T> métodos para produzir streams e demais eventos @kamilah_santos

  11. @kamilah_santos

  12. interface Flow.Subscriber<T> métodos para receber streams e demais eventos @kamilah_santos

  13. @kamilah_santos

  14. interface Flow.Subscription métodos para vincular o Publisher e o Subscriber.

    @kamilah_santos
  15. @kamilah_santos

  16. interface Flow.Processor<T,R> define métodos para fazer algumas operações avançadas, como

    transformar itens de publishers para subscriber @kamilah_santos
  17. @kamilah_santos

  18. class SubmissionPublisher<T> implements Flow.Publisher<T> Producer flexível de itens, em conformidade

    com a Reactive Streams. @kamilah_santos
  19. @kamilah_santos

  20. Reactive streams destinado a ambientes de tempo de execução (JVM),

    bem como protocolos de rede. https://github.com/reactive-streams/reactive-streams-jv m @kamilah_santos
  21. Reactive streams o objetivo principal é definir a troca de

    dados de fluxo através de um limite assíncrono. @kamilah_santos
  22. Reactive streams seu escopo é encontrar um conjunto mínimo de

    métodos, interfaces e protocolos que irão descrever as operações e entidades necessárias para ter fluxos de dados assíncronos com backpressure NIO. @kamilah_santos
  23. Functional Features Java 8+ @kamilah_santos

  24. @kamilah_santos

  25. @kamilah_santos

  26. @kamilah_santos

  27. @kamilah_santos

  28. @kamilah_santos

  29. @kamilah_santos

  30. Conceitos de programação reativa @kamilah_santos

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

    dados desejado por meio do software. Feedback do receptor ao produtor de que ele não está suportando a carga @kamilah_santos
  32. Stream Sequência de objetos que suporta vários métodos que podem

    ser operados para produzir um resultado @kamilah_santos
  33. Stream vinculado a uma fonte de dados, um stream é

    capaz de emitir três eventos: @kamilah_santos
  34. onNext() representa algum valor, vá para o próximo valor de

    uma lista @kamilah_santos
  35. onError() houve um erro na execução @kamilah_santos

  36. onComplete() no caso de eventos finitos, indica que foi concluído

    @kamilah_santos
  37. Flux Pode emitir de 0 to N eventos, passando por

    OnNext (), OnComplete () e onError. @kamilah_santos
  38. Mono Emite um evento ou nenhum (0 to 1 event).

    @kamilah_santos
  39. Observable um observable pode passar mensagens de forma assíncrona. @kamilah_santos

  40. Subscriber consome os dados recebidos da subscription @kamilah_santos

  41. Publisher produz os dados que serão consumidos pela assinatura. @kamilah_santos

  42. Subscription conexão entre o Subscriber e o Publisher @kamilah_santos

  43. Cold Observable a sequência de eventos só é executada se

    o Observable tiver um subscriber associado @kamilah_santos
  44. Hot Observable ele emite eventos independentemente de haver um subscriber

    associado @kamilah_santos
  45. Por que o WebFlux foi criado? 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 default embutido em seu arquitetura. @kamilah_santos
  46. Por que o WebFlux foi criado? 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. @kamilah_santos
  47. https://docs.spring.io/spring-framework/docs/5.0.0.BUILD-SNAPSHOT/spring-framework-reference/ html/web-reactive.html @kamilah_santos

  48. Spring Webflux foi desenvolvido porque precisávamos de aplicativos não bloqueantes

    que pudessem trabalhar com um pequeno número de threads simultaneamente e que pudessem ser executados com alguns recursos de hardware. @kamilah_santos
  49. no Servlet 3.1, uma API NIO foi fornecida, mas seu

    uso não corresponde ao resto da API e a todos os conceitos por trás do Servlet, que possui contratos de bloqueio. @kamilah_santos
  50. Estes fatores foram decisivos para o desenvolvimento de uma nova

    API que fosse utilizada independentemente do tempo de execução e de forma não bloqueante, o que foi possível com os servidores (Netty por exemplo) que se consolidaram na operação assíncrona e não bloqueante. @kamilah_santos
  51. Outra razão é que o WebFlux torna mais fácil entender

    e usar conceitos de programação funcional / reativa. Com a adição de recursos funcionais do Java 8 e Flowable API no Java 9 , que permitiu ao Spring WebFlux ter functional endpoints e annotated controllers nos aplicativos. @kamilah_santos
  52. Como as requests funcionam? @kamilah_santos

  53. Este modelo, dependendo do volume de requisições e da forma

    como foi desenvolvido, pode causar lentidão na sua aplicação e até mesmo um erro de Out Of Memory (este tipo de erro geralmente ocorre quando mantemos objetos por muito tempo ou tentamos processar muito de dados de uma vez) @kamilah_santos
  54. @kamilah_santos

  55. Com este modelo de design de API tradicional, não oferecemos

    suporte para Backpressure, a escrita da API é imperativa e, como já foi dito, funciona de forma síncrona e bloqueante @kamilah_santos
  56. @kamilah_santos

  57. @kamilah_santos

  58. E no Webflux? @kamilah_santos

  59. Neste modelo de requisição, para cada item deste Flux que

    é lido e retornado do banco de dados, um onNext () é chamado e quando atinge o último recebe um “sinal” de onComplete () ou se ocorre um erro, ele receberá um onError (). @kamilah_santos
  60. @kamilah_santos

  61. Os pedidos disparados por um cliente, são recebidos pelo Netty,

    que é o nosso servidor não bloqueante, que será recebido pelo loop de eventos, que irá receber este evento e enviá-lo, o adaptador reativo (reactor-netty) passará este para o dispatcher handler que é responsável pelo terminal para passar essas informações de volta ao cliente, isso ocorre de forma assíncrona e não bloqueante. @kamilah_santos
  62. @kamilah_santos

  63. O adaptador reativo geralmente é fornecido por uma biblioteca, aqui

    cobrirá o projeto do Reactor. @kamilah_santos
  64. Project Reactor @kamilah_santos

  65. É uma biblioteca baseada nas Reactive Streams Specifications, é 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 backpressure prontos para TCP, UDP e HTTP (incluindo sockets da web). @kamilah_santos
  66. Seus operators e schedulers podem suportar um grande volume de

    transferência (até 10 milhões de solicitações por segundo, de acordo com a documentação do Reactor https://projectreactor.io/), também foi a primeira biblioteca reativa a implementar alguns pontos sugeridos pela reactive streams applications( https://github.com/reactor/reactive-streams-common s), que mais tarde também foram implementados por RxJava2. @kamilah_santos
  67. Seus módulos são fluxos reativos abstratos e interoperáveis para facilitar

    o seu desenvolvimento, podendo ser utilizados com: Spring Frameworks Drivers e clientes (por exemplo CloudFoundry Java Client https://github.com/cloudfoundry/cf-java-client) - em protocolos / contratos como R2DBC (https://r2dbc.io/) e RSocket (https://rsocket.io/), por exemplo. @kamilah_santos
  68. Reactor Core é a parte principal desta biblioteca, os outros

    módulos são dependentes dela, ela fornece tipos reativos que implementam um Publisher que fornece Flux e Mono @kamilah_santos
  69. Reactor Netty é o servidor de nosso aplicativo NIO, usada

    para o desenvolvimento de servidores altamente escaláveis. @kamilah_santos
  70. Reactor Test é responsável por apoiar testes reativos e asserções

    @kamilah_santos
  71. Netty é possível trabalhar no nível do socket e criar

    seus próprios protocolos de comunicação @kamilah_santos
  72. Netty Para essas configurações de servidor NIO, é bom ter

    conhecimento de threads, event loop, buffers e gerenciamento de memória @kamilah_santos
  73. @kamilah_santos

  74. Exemplo @kamilah_santos

  75. Performance @kamilah_santos

  76. Palestra completa em: https://www.youtube.com/watch?v=ODzY5uJfzDI&t=3s @kamilah_santos

  77. Palestra completa em: https://www.youtube.com/watch?v=ODzY5uJfzDI&t=3s @kamilah_santos

  78. Palestra completa em: https://www.youtube.com/watch?v=ODzY5uJfzDI&t=3s @kamilah_santos

  79. Palestra completa em: https://www.youtube.com/watch?v=ODzY5uJfzDI&t=3s @kamilah_santos

  80. Palestra completa em: https://www.youtube.com/watch?v=ODzY5uJfzDI&t=3s @kamilah_santos

  81. Exemplos dos testes: https://github.com/violetagg/web-benchmarks/tree/experimental @kamilah_santos

  82. Beneficios @kamilah_santos

  83. - não bloqueante, o que gera certo ganho de desempenho.

    - menos threads, menos memória usada / gasta - visão mais clara dos recursos funcionais da linguagem - processa diferentes formas de solicitação de forma assíncrona @kamilah_santos
  84. - segue os princípios do manifesto reativo: aplicativos responsivos, resilientes,

    elásticos e orientados por mensagens. - Backpressure - Com o Reactor temos: maior legibilidade do código, grande variedade de operadores para manipular os dados e um alto nível de abstração. @kamilah_santos
  85. Problemas @kamilah_santos

  86. - Uma forma diferente de programação (programação declarativa) - Difícil

    de depurar (rastreamento de pilha mais complicado de entender). - Nem todos os drivers de banco de dados estão totalmente prontos para programação reativa. @kamilah_santos
  87. Quando usar @kamilah_santos

  88. - Se você tem fast producers (emissão de informação mais

    rápida) e consumidores baixos (consumidores lentos e bloqueadores), sem suporte de contrapressão. - Tráfego variável - Chamadas constantes ao banco de dados e esse banco de dados já possui um driver reativo, a mudança para o webflux pode diminuir o tempo de latência. - Muitos fluxos, eventos no aplicativo. - Quando este serviço é consumido via celular e possui alto volume de tráfego. @kamilah_santos
  89. Quando não usar @kamilah_santos

  90. - se o seu aplicativo não tiver um volume de

    tráfego muito alto, ele não terá várias fontes de solicitação - Se não houver acúmulo de solicitações, isso ocorre devido a processos de bloqueio. - Se as dependências já utilizadas em seus serviços estão bloqueando @kamilah_santos
  91. My contacts Example

  92. 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://www.journaldev.com/20723/java-9-reactive-streams 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 https://developer.okta.com/blog/2018/09/21/reactive-programming-with-spring https://speakerdeck.com/olehdokuka/get-reactive-with-project-reactor-and-spring-5

    https://speakerdeck.com/kamilahsantos/2020-d0013e50-afdf-4e9c-b411-7f22d2f3d64c https://speakerdeck.com/kamilahsantos/tdc-floripa-melhorando-a-performance-e-legibilidade-de-aplicacoes-java-c om-spring-web-flux https://www.baeldung.com/spring-webflux https://docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html https://docs.spring.io/spring-framework/docs/5.0.0.BUILD-SNAPSHOT/spring-framework-reference/html/web-react ive.html @kailah_santos