La programmation réactive implémente des services de non-bloqueur à faible latence et à faible latence en Java via Project Reactor et Spring Webflux. 1. Project Reactor fournit deux types de noyaux: Mono et Flux, prend en charge le traitement déclaratif des flux de données asynchrones et convertis, filtres et autres opérations via des cha?nes d'opérateurs; 2. Spring WebFlux est construit sur Reactor, prend en charge deux modèles de programmation d'annotation et de fonctionnel. Il fonctionne sur des serveurs non bloquants tels que Netty et peut gérer efficacement de grandes quantités de connexions simultanées; 3. L'utilisation du réacteur WebFlux peut améliorer les capacités de concurrence et l'utilisation des ressources dans les scénarios à forte intensité d'E / O, prend naturellement prend en charge les communications en streaming telles que SSE et WebSocket, et s'intègre de manière transparente à des bases de données réactives telles que R2DBC et MongoDB; 4. Dans les applications réelles, le code de blocage doit être évité, la logique métier ne doit pas être écrite en abonnement, et les mécanismes de garantie de délai et d'erreur doivent être utilisés raisonnablement; 5. Bien que la courbe d'apprentissage soit raide et ne convient pas aux taches à forte intensité de processeur, cette combinaison peut améliorer considérablement le débit du système et la résilience dans les microservices, les passerelles et les systèmes en temps réel, et mérite d'être adopté dans des scénarios appropriés.

La programmation réactive est devenue de plus en plus importante en Java ces dernières années, en particulier dans les applications Web modernes avec une concurrence élevée et une faible latence. Avec Project Reactor et Spring WebFlux , les développeurs Java peuvent facilement créer des services non bloquants et modérés. Voyons comment ils travaillent ensemble et pourquoi vous devriez envisager de les utiliser.

Qu'est-ce que la programmation réactive?

La programmation réactive est un paradigme de programmation pour le flux de données et la propagation des changements . Il vous permet de gérer les flux de données asynchrones de manière déclarative, tels que les demandes HTTP, les réponses de la base de données, les files d'attente de messages, etc.

Dans la programmation de blocage traditionnelle, chaque demande occupe un fil et attend la fin de l'opération d'E / S. Dans la programmation réactive, les threads ne sont pas bloqués, mais ne sont traités que lorsque les données sont disponibles via le mécanisme "rappel" ou "publier-abonnement".

Réacteur du projet: la bibliothèque de base pour la programmation réactive

Project Reactor est une bibliothèque JVM de base créée par l'équipe Spring pour les systèmes réactifs. Il s'agit d'une implémentation de Reactor 3 et est entièrement compatible avec la spécification des flux réactifs .

Il fournit deux types de noyau:

• Mono<t></t> : représente une séquence asynchrone de 0 ou 1 élément (par exemple: résultats de requête utilisateur unique)
• Flux<t></t> : représente un flux de données asynchrones de 0 vers n éléments (par exemple: obtenir tous les utilisateurs)

 // Exemple: créer un flux
Flux <string> noms = flux.Just ("Alice", "Bob", "Charlie");

// Créer un mono
Mono <string> single = mono.Just ("Hello");

Vous pouvez encha?ner ces flux, tels que map , filter , flatMap , delayElements , etc .:

 noms
    .map (String :: ToupperCase)
    .DelayElements (durée.ofmillis (500))
    .Subscribe (System.out :: println);

Remarque: Le code ci-dessus n'est pas bloquant et ne sera pas exécuté immédiatement, mais "déclarer" le comportement du flux de données et ne sera déclenché qu'à un "abonné" n'appara?t.

Spring Webflux: Framework Web réactif

Spring WebFlux est un cadre Web réactif introduit par le printemps 5. Il peut remplacer le Spring MVC traditionnel et prend en charge deux modèles de programmation:

1. Contr?leur annoté (similaire à Spring MVC):

    @RestController
   classe publique UserController {
   
       @Getmapping ("/ utilisateurs")
       FLUX PUBLIQUE <UTERD> GETALLUSERS () {
           return userservice.findall (); // Retour FLUX <DERS
       }
   
       @Getmapping ("/ utilisateurs / {id}")
       public mono <User> getUserById (@pathvariable String id) {
           return userService.FindById (id); // retourne mono <servy>
       }
   }

2. Modèle de routage fonctionnel (léger, fonctionnel):

    @Haricot
   Public RouterFunction <ServerResponse> Route (UserHandler Handler) {
       Retour Route (get ("/ utilisateurs"), Handler :: getAllusers)
              .AndRoute (get ("/ utilisateurs / {id}"), Handler :: getUserById);
   }

WebFlux prend en charge les serveurs non bloquants tels que Netty et Undertow, Netty est recommandé (la valeur par défaut est intégrée dans Spring Boot pour utiliser Reactor Netty).

Pourquoi utiliser le réacteur Webflux?

1. Capacité de concurrence plus élevée
   Tomcat traditionnel occupe un fil par demande et le pool de threads est limité. WebFlux utilise un petit nombre de threads de boucle d'événements (boucles d'événements) qui peuvent gérer des milliers de connexions simultanées.

2. Meilleure utilisation des ressources
   Les E / S non bloquantes réduisent l'attente du thread, ce qui rend l'utilisation du processeur et de la mémoire plus efficace.

3. Support naturel pour les données de streaming
   Des scénarios tels que SSE (événements de serveur), WebSocket, flux de fichiers, push en temps réel, etc. sont très appropriés.

4. Intégration transparente avec Spring Eco
   Prend en charge MongoDB réactif, PostgreSQL (via R2DBC), Redis (laitue), Kafka, etc.

Recommandations et précautions pour une utilisation

Bien que les avantages de la programmation réactive soient évidents, ce n'est pas une solution miracle. Voici quelques points clés:

• ? Convient pour les scénarios à forte intensité d'E / O : tels que l'appel des API externes, l'accès à la base de données et le traitement des messages.
• ?Con ne convient pas aux taches à forte intensité de processeur : la réactivité n'améliore pas les performances informatiques, mais peut augmenter la complexité.
• ?? Ne mélangez pas le code de blocage : l'appel Thread.sleep() ou le blocage de l'accès à la base de données en Mono/Flux détruira l'avantage réactif.
• ? évitez d'écrire une logique commerciale en abonnez-vous : essayez d'utiliser le traitement de la cha?ne des opérateurs pour maintenir le style fonctionnel.
• ? La courbe d'apprentissage est plus raide : les concepts de contre-pression, le planificateur, le flux chaud et froid nécessitent du temps pour ma?triser.

Exemple pratique: appeler une API externe

Supposons que nous souhaitions obtenir des informations utilisateur à partir d'un service externe et effectuer la conversion:

 @Service
classe publique UserService {

    privé final webClient webClient = webClient.create ("https://api.example.com");

    public Mono <User> fetchuser (String id) {
        return webClient.get ()
            .uri ("/ utilisateurs / {id}", id)
            .récupérer()
            .BodyTomono (externalUser.class)
            .map (ceci :: ConvertTousser)
            .Timeout (durée.ofseconds (3)) // TimeOut Control.OnErrorTurn (user.Empty ()); // Garantie d&#39;erreur}
}

L'ensemble du processus est non bloquant et plusieurs demandes peuvent être traitées en parallèle sans consommer des threads supplémentaires.

Résumer

• Project Reactor fournit des opérations de base pour les flux réactifs ( Mono / Flux )
• Spring Webflux est construit sur Reactor pour implémenter des services Web réactifs
• Combinaison des deux, adaptées à des applications à forte concurrence et à intensités d'E / S
• Lorsque vous l'utilisez, vous devez éviter de bloquer les opérations et comprendre le mécanisme de contre-pression et de planification

La programmation réactive n'est pas nécessaire partout, mais dans le bon scénario, il peut améliorer considérablement le débit et la résilience du système. Si vous construisez un microservice, une passerelle, une interface en temps réel ou un système de traitement de flux, le réacteur WebFlux mérite une considération sérieuse.

Fondamentalement, tout est, pas compliqué, mais il est facile d'ignorer les détails.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!