Guide de Spring 5 WebFlux

1. Vue d'ensemble

Spring WebFlux fait partie de Spring 5 et fournit un support de programmation réactive pour les applications Web.

Dans ce didacticiel, nous allons créer une petite application REST réactive à l'aide des composants Web réactifs RestController et WebClient.

Nous examinerons également comment sécuriser nos points de terminaison réactifs à l'aide de Spring Security.

2. Spring WebFlux Framework

Spring WebFlux utilise en interne Project Reactor et ses implémentations d'éditeur - Flux et Mono .

Le nouveau cadre prend en charge deux modèles de programmation:

  • Composants réactifs basés sur les annotations
  • Routage et gestion fonctionnels

Nous allons nous concentrer sur les composants réactifs basés sur les annotations, car nous avons déjà exploré le style fonctionnel - le routage et la gestion dans un autre tutoriel.

3. Dépendances

Commençons par la dépendance spring-boot-starter-webflux , qui extrait toutes les autres dépendances requises:

  • spring-boot et spring-boot-starter pour la configuration de base de l'application Spring Boot
  • framework spring-webflux
  • réacteur-coeur dont nous avons besoin pour les flux réactifs et aussi réacteur-netty
 org.springframework.boot spring-boot-starter-webflux 2.2.6.RELEASE 

Le dernier spring-boot-starter-webflux peut être téléchargé depuis Maven Central.

4. Application REST réactive

Nous allons maintenant créer une application REST EmployeeManagement réactive très simple - en utilisant Spring WebFlux:

  • Nous utiliserons un modèle de domaine simple - Employé avec un identifiant et un champ de nom
  • Nous allons créer une API REST avec un RestController pour publier les ressources des employés en tant que ressource unique et en tant que collection
  • Nous allons créer un client avec WebClient pour récupérer la même ressource
  • Nous allons créer un point de terminaison réactif sécurisé à l'aide de WebFlux et Spring Security

5. RestController réactif

Spring WebFlux prend en charge les configurations basées sur les annotations de la même manière que le framework Spring Web MVC.

Pour commencer, sur le serveur, nous créons un contrôleur annoté qui publie un flux réactif de la ressource Employé .

Créons notre EmployeeController annoté :

@RestController @RequestMapping("/employees") public class EmployeeController { private final EmployeeRepository employeeRepository; // constructor... }

EmployeeRepository peut être n'importe quel référentiel de données prenant en charge les flux réactifs non bloquants.

5.1. Ressource unique

Créons un point de terminaison dans notre contrôleur qui publie une seule ressource Employee :

@GetMapping("/{id}") private Mono getEmployeeById(@PathVariable String id) { return employeeRepository.findEmployeeById(id); }

Nous enveloppons une seule ressource Employé dans un Mono car nous renvoyons au plus un employé.

5.2. Ressource de collection

Ajoutons également un point de terminaison qui publie la ressource de collection de tous les employés :

@GetMapping private Flux getAllEmployees() { return employeeRepository.findAllEmployees(); }

Pour la ressource de collection, nous utilisons un Flux de type Employee - puisque c'est l'éditeur des éléments 0. .n.

6. Client Web réactif

WebClient introduit dans Spring 5 est un client non bloquant prenant en charge les flux réactifs.

Nous pouvons utiliser WebClient pour créer un client afin de récupérer des données à partir des points de terminaison fournis par EmployeeController.

Créons un simple EmployeeWebClient :

public class EmployeeWebClient { WebClient client = WebClient.create("//localhost:8080"); // ... }

Ici, nous avons créé un WebClient en utilisant sa méthode de fabrique create . Il pointera vers localhost: 8080 afin que nous puissions utiliser ou des URL relatives pour les appels effectués par cette instance cliente.

6.1. Récupération d'une seule ressource

Pour récupérer une seule ressource de type Mono à partir du point de terminaison / employé / {id} :

Mono employeeMono = client.get() .uri("/employees/{id}", "1") .retrieve() .bodyToMono(Employee.class); employeeMono.subscribe(System.out::println);

6.2. Récupération d'une ressource de collection

De même, pour récupérer une ressource de collection de type Flux à partir du point de terminaison / des employés :

Flux employeeFlux = client.get() .uri("/employees") .retrieve() .bodyToFlux(Employee.class); employeeFlux.subscribe(System.out::println);

Nous avons également un article détaillé sur la configuration et l'utilisation de WebClient .

7. Sécurité de Spring WebFlux

Nous pouvons utiliser Spring Security pour sécuriser nos points de terminaison réactifs.

Supposons que nous ayons un nouveau point de terminaison dans notre EmployeeController. Ce point de terminaison met à jour les détails de l' employé et renvoie l' employé mis à jour .

Étant donné que cela permet aux utilisateurs de modifier les employés existants, nous souhaitons limiter ce point de terminaison aux utilisateurs du rôle ADMIN uniquement.

Ajoutons une nouvelle méthode à notre EmployeeController :

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

Now, to restrict access to this method let's create SecurityConfig and define some path-based rules to only allow ADMIN users:

@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(); } }

This configuration will restrict access to the endpoint /employees/update. Therefore only users having a role ADMIN will be able to access this endpoint and update an existing Employee.

Finally, the annotation @EnableWebFluxSecurity adds Spring Security WebFlux support with some default configurations.

We also have a detailed article on configuring and working with Spring WebFlux security.

8. Conclusion

In this article, we've explored how to create and work with reactive web components as supported by the Spring WebFlux framework. As an example, we've built a small Reactive REST application.

We learned how to use RestController and WebClient to publish and consume reactive streams.

We also looked into how to create a secured reactive endpoint with the help of Spring Security.

Other than Reactive RestController and WebClient, the WebFlux framework also supports reactive WebSocket and the corresponding WebSocketClient for socket style streaming of Reactive Streams.

We have a detailed article focused on working with Reactive WebSocket with Spring 5.

Enfin, le code source complet utilisé dans ce tutoriel est disponible à l'adresse over sur Github.