[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
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