A programação responsiva tem sido popular entre a comunidade de desenvolvedores e os clientes nos últimos anos devido à sua capacidade de criar aplicativos de maneira declarativa, em vez de forçá -los a formar aplicações mais sensíveis e resilientes. O fato de a primavera 5 incorporar sistemas de reação em sua estrutura principal mostrou uma mudança de paradigma para a programação declarativa.
A programação responsiva gerencia fluxos de dados assíncronos entre produtores de dados e consumidores, que precisam responder aos dados de maneira suave. Portanto, a programação responsiva é um aplicativo suave que é assíncrono e orientado a eventos, exigindo um pequeno número de encadeamentos para escalar.
A programação responsiva é difícil de criar arquiteturas baseadas em roscas devido à alta complexidade envolvida na expansão de aplicações com base em estados, threads e bloqueios mutáveis compartilhados.
No contexto da programação responsiva, "Quando há dados em um fluxo, tudo é um fluxo e se comporta de maneira suave".
A abstração de alto nível e a programação responsiva levam a uma melhor legibilidade do código, para que os desenvolvedores possam se concentrar principalmente na interdependência de eventos que definem a lógica de negócios.
Em ambientes altamente simultâneos, o padrão de resposta é naturalmente adequado para o processamento de mensagens, que é um caso de uso corporativo comum.
Devido à natureza da contrapressão da execução, uma abordagem responsiva é mais adequada para controlar o tráfego entre produtores e consumidores, o que ajudará a evitar a exaustão da memória.
Para um ou vários threads, as tarefas de ligação de IO podem ser executadas de forma assíncrona e não bloqueadora sem bloquear o thread atual.
As notificações dos subsistemas de múltiplos conexões podem ser acionadas em aplicações de alta interação e em tempo real ou em qualquer operação/eventos; nesse caso, a programação responsiva pode ser gerenciada com mais eficiência.
O "Fluxo de resposta" define uma especificação da API que contém um conjunto mínimo de interfaces que divulgam métodos para definir operações e entidades de fluxos de dados que não bloqueiam a contrapressão.
Com a introdução da pressão de volta, o fluxo de resposta permite ao usuário controlar a taxa de troca de dados do editor.
A API de streaming de resposta java.util.Concurrent.Flow tornou -se oficialmente parte do Java 9.
O fluxo de resposta é usado principalmente como uma camada de interoperabilidade.
Tanto o módulo reativo da Web Web quanto o MVC da primavera suportam a mesma programação @Controller, mas a reativa de mola-a-web é executada nos motores reativos e não bloqueadores.
Siga este documento, consulte:
http://docs.spring.io/spring-framework/docs/5.0.0.build-snapshot/spring-framework-reference/html/web-reactive.html
O módulo reativo da mola e a MVC da mola compartilham muitos algoritmos comuns, mas o módulo reativo da mola redefinida redefiniu muitos contratos de MVC de mola, como manipulamento e manipulador), para torná-las assíncronas e não bloquear e resultar em respostas e responsabilidades e respostas e respostas e respostas e respostas e as respostas e as respostas e as respostas e as respostas e as respostas e as respostas e as respostas e as respostas e as respostas e as respostas e as respostas e as respostas e as respostas.
Além do RESTTEMPLATE existente, um novo WebClient responsivo também é introduzido na primavera 5.
Os clientes HTTP que oferecem suporte a programação responsiva (como reator, rede, sublow) adotaram uma série de abstrações responsivas ao clientehttprequest e clienthttproponse que expõem solicitações e órgãos de resposta como fluxo <Catabuffer> e fornecem suporte abrangente no lado de leitura e gravação.
O Spring 5 Framework apresenta o reator como uma implementação da especificação de fluxos reativos.
O reator é a biblioteca reativa da próxima geração para criar aplicativos não bloqueadores na JVM.
O reator estende o contrato básico do editor de fluxos reativos e define tipos de API de fluxo e mono para fornecer operações declarativas para sequências de dados de 0..n e 0..1, respectivamente.
O Spring Web Reactive usa o Servlet 3.1 para fornecer E/S não bloqueador e executa nos contêineres Servlet 3.1.
O Spring Webflux oferece dois modelos de programação para escolher.
A primavera 5 inclui a reativa da Web da primavera (no módulo reativo da mola na web) e MVC da Web Spring (no módulo Spring-WebMVC).
Embora os módulos MVC reativos e da Web da primavera compartilhem muitos algoritmos, porque o reativo da Web da primavera pode ser executado nos fluxos reativos não bloqueadores responsivos, a camada de adaptador HTTP, eles não compartilham o código entre eles.
A execução do MVC da primavera requer um contêiner de servlet, enquanto o Spring Web Reactive também pode ser executado em tempos de execução sem serviço, como na Netty e na Underlow.
Se você precisar usar uma pilha da web não bloqueadora com uma estrutura Web leve e funcional e usá-la com Java 8 Lambda ou Kotlin, considere mudar de aplicativos MVC da Spring MVC para reativo da Web da primavera.
Esta é uma versão 2.0.0 m5 do pom.xml que se baseia no webfiux.
<Parent> <rugniid> org.springframework.boot </groupId> <TRATIFACTID> Spring-boot-starter-parent </ArtifactId> <Versão> 2.0.0.m5 </version> </parentled> <TarfactId> Spring-boot-Starter-Webflux </ArtifactId> </Dependency> </Dependências>
Método tradicional vs. método de resposta
Nos métodos tradicionais, a execução será bloqueada e esperará até que a execução do seu serviço seja concluída. No código a seguir, após a primeira declaração de impressão, a execução do programa será bloqueada e aguardará a conclusão da execução do serviço. Após a conclusão da execução do serviço, a execução do programa é retomada e uma segunda declaração de impressão é executada.
@GetMapping ("/tradicional") Lista pública <CROTDE> getAllProducts () {System.out.println ("Tradicional Way iniciado"); List <Product> Products = ProderService.getProducts ("Tradicional"); System.out.println ("Way Tradicional concluída"); Return Products;}No método de resposta, a execução do programa continuará sem aguardar a conclusão da execução do serviço. No código a seguir, após a primeira declaração de impressão, a segunda declaração de impressão será executada de maneira não bloqueadora sem esperar a execução do serviço ser concluída. O fluxo de fluxo será preenchido com a disponibilidade de dados do produto.
@GetMapping (value = "/reativo", .text_event_stream_value) public flux <Product> getall () {System.out.println ("maneira reativa usando o fluxo iniciado"); Flux <Product> FluxProducts = ProdService.getProductSStream ("Flux"); System.out.println ("maneira reativa usando o fluxo concluído"); retornar fluxproducts;}Além do RestTemplate existente, a Spring 5 também introduziu o WebClient reativo.
As abstrações ClientHttPrequest e ClientHttpResponse expõem os órgãos de solicitação e resposta usando o Flux <Databuffer> e fornecem suporte completo de contrapressão no lado de leitura e gravação.
As abstrações do codificador e do decodificador do núcleo da mola também são usadas no lado do cliente para serializar ou transmitir FLUS endian em objetos de tipo.
Aqui está um exemplo de um webclient reativo que chama o terminal e recebe e processa objetos de fluxo de fluxo reativo.
@GetMapping ("/Accouts/{id}/alertas") public Flux <Alert> getAccountalerts (@PathVariable Long Id) {webclient webclient = new webClient (novo reactorClientHttpConnector ()); Retorne this.repository.getAccount (id) .flatmap (conta -> webclient.perform (get ("/alerts/{key}", conta.getKey ()). Extract (bodyStream (alert.class));}O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.