TOC

Guia para o WebFlux do Spring 5

Guia para o WebFlux do Spring 5

1. Visão geral

O framework Spring WebFlux faz parte do Spring 5 e fornece suporte de programação reativa para aplicativos da Web.

Neste tutorial, criaremos um pequeno aplicativo REST reativo usando os componentes da web reativos RestController e WebClient.

Também veremos como proteger nossos endpoints reativos usando o Spring Security.

Leitura adicional:

https://www..com/spring-5-webclient [WebClient da Primavera 5]

Descubra o WebClient da Spring 5 - uma nova alternativa reativa RestTemplate.

https://www..com/spring-5-webclient [Leia mais] →

https://www..com/spring-webclient-resttemplate [Spring WebClient vs. RestTemplate]

Aprenda a fazer chamadas HTTP do lado do servidor usando o WebClient e RestTemplate.

https://www..com/spring-webclient-resttemplate [Leia mais] →

2. Spring WebFlux Framework

*O Spring WebFlux usa internamente o http://projectreactor.io/[Project Reactor] e suas implementações de publicador - https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Flux.html[_Flux_] e _https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Mono.html [Mono] _* .

A nova estrutura suporta dois modelos de programação:

  • Componentes reativos baseados em anotações *Roteamento e manuseio funcional

Aqui, focaremos nos componentes reativos baseados em anotações, pois já exploramos o https://www..com/spring-5-functional-web [estilo funcional - roteamento e manuseio].

===* 3. Dependências *

Vamos começar com a dependência spring-boot-starter-webflux, que realmente extrai todas as outras dependências necessárias:

  • spring-boot e spring-boot-starter para configuração básica dos aplicativos Spring Boot

  • spring-webflux framework

  • reactor-core que precisamos para fluxos reativos e também reactor-netty

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
    <version>2.1.6.RELEASE</version>
</dependency>

O último spring -boot-starter-webflux pode ser baixado do Maven Central.

4. Aplicação REST reativa

Agora criaremos um aplicativo REST EmployeeManagement muito simples REST - usando o Spring WebFlux:

  • Usaremos um modelo de domínio simples - Employee com um campo id e name

  • Criaremos APIs REST para publicar e recuperar recursos Single e Collection Employee usando RestController e WebClient *E também criaremos um terminal reativo seguro usando WebFlux e Spring Security

5. RestController reativo_

O Spring WebFlux suporta as configurações baseadas em anotações da mesma maneira que a estrutura do Spring Web MVC.

Para começar,* no lado do servidor, criamos um controlador anotado que publica nossos fluxos reativos de _Employee _. *

Vamos criar nosso EmployeeController anotado:

@RestController
@RequestMapping("/employees")
public class EmployeeController {

    private final EmployeeRepository employeeRepository;

   //constructor...
}

EmployeeRepository pode ser qualquer repositório de dados que suporte fluxos reativos sem bloqueio.

5.1. Recurso único

Vamos criar um terminal em nosso controlador que publique um único recurso _Employee: _

@GetMapping("/{id}")
private Mono<Employee> getEmployeeById(@PathVariable String id) {
    return employeeRepository.findEmployeeById(id);
}
*Para um único recurso _Employee_, usamos um _Mono_ do tipo _Employee_ porque ele emitirá no máximo 1 elemento.*

5.2. Recurso de coleta

Também vamos adicionar um ponto final em nosso controlador que publique o recurso de coleção de todos os Employees:

@GetMapping
private Flux<Employee> getAllEmployees() {
    return employeeRepository.findAllEmployees();
}
*Para o recurso de coleta, usamos _Flux_ do tipo _Employee_ - já que esse é o editor focado na emissão de _0 ._. N elementos.*

6. Cliente da Web Reativo

WebClient introduzido no Spring 5 é um cliente não-bloqueador com suporte para fluxos reativos.

*No lado do cliente, usamos _WebClient_ para recuperar dados de nossos terminais criados em _EmployeeController ._*

Vamos criar um EmployeeWebClient simples:

public class EmployeeWebClient {

    WebClient client = WebClient.create("http://localhost:8080");

   //...
}

Aqui, criamos um WebClient usando seu método de fábrica create. Ele apontará para localhost: 8080 para URLs relativos.

6.1. Recuperando um único recurso

Para recuperar um recurso único do tipo Mono do terminal _/employee/\ {id} _:

Mono<Employee> employeeMono = client.get()
  .uri("/employees/{id}", "1")
  .retrieve()
  .bodyToMono(Employee.class);

employeeMono.subscribe(System.out::println);

6.2. Recuperando Recurso de Coleção

Da mesma forma, para recuperar um recurso de coleção do tipo Flux do terminal /employee:

Flux<Employee> employeeFlux = client.get()
  .uri("/employees")
  .retrieve()
  .bodyToFlux(Employee.class);

employeeFlux.subscribe(System.out::println);

Também temos um artigo detalhado em https://www..com/spring-5-webclient [configurando e trabalhando com o WebClient] .

7. Spring WebFlux Security

*Podemos usar o Spring Security para proteger nossos pontos de extremidade reativos.*

Vamos supor que tenhamos um novo terminal em nosso EmployeeController. Este terminal atualiza os detalhes do Employee e envia de volta o Employee. atualizado.

Como isso permite que os usuários alterem funcionários existentes, queremos restringir esse endpoint apenas aos usuários da função ADMIN.

Vamos adicionar um novo método ao nosso EmployeeController:

@PostMapping("/update")
private Mono<Employee> updateEmployee(@RequestBody Employee employee) {
    return employeeRepository.updateEmployee(employee);
}

Agora, para restringir o acesso a esse método, vamos criar SecurityConfig e definir algumas regras baseadas em caminho para permitir apenas usuários ADMIN:

@EnableWebFluxSecurity
public class EmployeeWebSecurityConfig {

   //...

    @Bean
    public SecurityWebFilterChain springSecurityFilterChain(
      ServerHttpSecurity http) {
        http.csrf().disable()
          .authorizeExchange()
          .pathMatchers(HttpMethod.POST, "/employees/update").hasRole("ADMIN")
          .pathMatchers("/**").permitAll()
          .and()
          .httpBasic();
        return http.build();
    }
}

Essa configuração restringirá o acesso ao terminal /employee/update. Portanto, apenas usuários com uma função ADMIN poderão acessar esse terminal e atualizar um Employee. existente.

Por fim, a anotação @ EnableWebFluxSecurity adiciona suporte ao Spring Security WebFlux com algumas configurações padrão.

Também temos um artigo detalhado em https://www..com/spring-security-5-reactive [configurando e trabalhando com a segurança do Spring WebFlux].

8. Conclusão

Neste artigo, exploramos como criar e trabalhar com componentes da web reativos suportados pela estrutura Spring WebFlux, criando um pequeno aplicativo REST reativo.

Aprendemos como usar RestController e WebClient para publicar e consumir fluxos reativos, respectivamente.

Também analisamos como criar um terminal reativo seguro com a ajuda do Spring Security.

Diferente de Reactive RestController e WebClient, o WebFlux framework também suporta WebSocket reativo e WebSocketClient correspondente para fluxo de estilo de soquete de Fluxos Reativos.

Temos um artigo detalhado focado em https://www..com/spring-5-reactive-websockets [trabalhando com o Reactive WebSocket com Spring 5].

Finalmente, o código fonte completo usado neste tutorial está disponível over no Github.

Related