TOC

Guide du printemps 5 WebFlux

1. Vue d’ensemble

  • Spring WebFlux Framework 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 utilisant les composants Web réactifs RestController et WebClient.

Nous verrons également comment sécuriser nos systèmes d’extrémité réactifs à l’aide de Spring Security.

2. Spring WebFlux Framework

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

  • Composants réactifs à base d’annotation

  • Routage et traitement fonctionnel

Ici, nous allons nous concentrer sur les composants réactifs basés sur Annotation, car nous avons déjà exploré le fonctionnel style - routage et traitement .

3. Dépendances

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

  • spring-boot et spring-boot-starter pour le démarrage de base de Spring

configuration de l’application ** __spring-webflux __framework

  • reactor-core dont nous avons besoin pour les flux réactifs et aussi

reactor-netty 

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

Le dernier https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.boot%22%20and%20a%3a%22spring-boot-starter-webflux%22&présent -boot-starter-webflux]peut être téléchargé à partir de Maven Central.

4. Application REST réactive

  • Nous allons maintenant créer une très simple application Reactive REST EmployeeManagement - avec Spring WebFlux: **

  • Nous allons utiliser un modèle de domaine simple - Employee avec un id et un name

champ ** Nous allons créer des API REST pour la publication et récupérer des fichiers Single ainsi que

Collection de ressources Employee utilisant _RestController et WebClient_ ** Nous allons également créer un point de terminaison réactif sécurisé à l’aide de WebFlux.

et sécurité de printemps

5. Réactif RestController

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

Pour commencer, côté serveur, nous créons un contrôleur annoté qui publie nos flux réactifs de Employee .

Créons notre EmployeeController annoté: 

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

    private final EmployeeRepository employeeRepository;

   //constructor...
}

__EmployeeRepository __can peut être n’importe quel référentiel de données prenant en charge des flux réactifs non bloquants.

5.1. Ressource unique

Créons un noeud final dans notre contrôleur qui publie une seule ressource Employee: 

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

  • Pour une seule ressource Employee , nous avons utilisé un Mono de type Employee car il émettra au plus 1 élément.

5.2. Ressource de collection

Ajoutons également un point de terminaison dans notre contrôleur qui publie la ressource de collecte de tous les Employees : 

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

  • Pour la ressource collection, nous avons utilisé Flux de type Employee - l’éditeur s’est concentré sur l’émission d’éléments 0 . . N. **

6. Client Web réactif

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

  • Du côté client, nous utilisons WebClient pour récupérer les données de nos points de terminaison créés dans EmployeeController . **

Créons un simple EmployeeWebClient : 

public class EmployeeWebClient {

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

   //...
}

Ici, nous avons créé un WebClient en utilisant sa méthode de fabrique create .

Il pointe sur __localhost: 8080 __pour les URL relatives.

6.1. Récupération d’une ressource unique

Pour récupérer une ressource unique de type Mono à partir du noeud final /employee/\ {id} : 

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

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

6.2. Récupérer une ressource de collection

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

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

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

Nous avons également un article détaillé sur https://www.baeldung.com/spring-5-webclient _. _

7. Sécurité WebFlux Spring

  • Nous pouvons utiliser Spring Security pour sécuriser nos terminaux réactifs. **

Supposons que nous ayons un nouveau point de terminaison dans notre _EmployeeController. Ce point de terminaison met à jour les détails de Employee et renvoie le Employee._ mis à jour.

Dans la mesure où cela permet aux utilisateurs de modifier les employés existants, nous souhaitons limiter ce noeud final aux utilisateurs du rôle ADMIN uniquement.

Ajoutons une nouvelle méthode à notre EmployeeController : 

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

Maintenant, pour restreindre l’accès à cette méthode, créons SecurityConfig et définissons des règles basées sur le chemin pour autoriser uniquement les utilisateurs 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();
    }
}

Cette configuration limitera l’accès au noeud final /employés/update . Par conséquent, seuls les utilisateurs ayant le rôle ADMIN pourront accéder à ce noeud final et mettre à jour un Employee. existant.

Enfin, l’annotation __ @ EnableWebFluxSecurity __adds prend en charge Spring Security WebFlux avec certaines configurations par défaut.

Nous avons également un article détaillé sur configuration et utilisation de la sécurité Spring WebFlux .

8. Conclusion

Dans cet article, nous avons expliqué comment créer et utiliser des composants Web réactifs pris en charge par le cadre Spring WebFlux en créant une petite application REST réactive.

Nous avons appris à utiliser RestController et _WebClient _ pour publier et consommer des flux réactifs, respectivement.

Nous avons également examiné comment créer un point de terminaison réactif sécurisé à l’aide de Spring Security.

En plus de Reactive RestController et WebClient, le framework WebFlux supporte également WebSocket réactif et WebSocketClient correspondant pour la diffusion en continu du style de socket des flux réactifs.

Nous avons un article détaillé sur working avec Reactive WebSocket avec Spring 5 .

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

Related