Programmation réactive

Sommaire

> Découvrir la programmation réactive

> Traitement d'une donnée unique

> Traitement de données multiples

> Traitement des erreurs

> Utiliser Spring Data avec Redis

Découvrir la programmation réactive

Afin d'illustrer la programmation réactive, nous allons utiliser le framework reactor.

Étapes à suivre :

Ajouter la dépendance MAVEN suivante

<dependency>
    <groupId>io.projectreactor</groupId>
    <artifactId>reactor-core</artifactId>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
</dependency>

Créer un package myboot.app6.test.

Traitement d'une donnée unique

Dans la programmation réactive, les actions sont toutes asynchrones et déclenchées par l'arrivée d'une donnée à traiter. Cette donnée peut être unique (ou absente) ou bien multiple. Dans Reactor, les données uniques sont codées par la classe Mono. Voici un exemple

package myboot.app6.test;

import org.junit.jupiter.api.Test;

import reactor.core.publisher.Mono;

public class testReactor {

    @Test
    public void testMono() {
        System.out.println("-- test Mono");
        Mono.just(10)//
                .subscribe(System.out::println);
    }

}

L'installation d'un consommateur de donnée (avec la méthode subsribe) active le traitement et la donnée 10 est transmise à println.

Lire la documentation de Mono et tester la méthode log.

...
        Mono.just(10)//
                .log()//
                .subscribe(System.out::println);
...

La méthode block termine la chaîne des traitements asynchrones et renvoie la valeur résultante. C'est donc une action bloquante. Tester cette possibilité.

Nous pouvons maintenant appliquer un traitement (asynchrone) sur cette donnée avec la méthode map :

...
        Mono.just(10)//
                .map(i -> i + 10)//
                .subscribe(System.out::println);
...

Nous pouvons aussi faire en sorte que le traitement change le type de la donnée transmise :

...
        Mono.just(10)//
                .map(v -> v + 10)//
                .map(v -> "Message " + v)//
                .map(v -> v.toUpperCase())//
                .subscribe(System.out::println);
...

Nous pouvons nous abonner à des événements intéressants. Essayer les méthodes doFirst, doOnNext et doAfterTerminate.

Traitement de données multiples

Dans Reactor, les données multiples sont traitées par la classe Flux. Voici trois exemples :

Flux.just(1, 2, 3)//
        .subscribe(System.out::println);

Flux.range(1, 10)//
        .subscribe(System.out::println);

Mono.just(5)//
        .repeat(10)//
        .subscribe(System.out::println);

Tester la méthode filter. Utiliser les méthodes bloquantes blockFirst et blockLast pour développer des tests unitaires. Utiliser ensuite collectList et block.

Tester les méthodes all et any. Utiliser la méthode block pour développer des tests unitaires.

Utiliser ensuite sort et distinct pour filtrer un flux.

Agrandir ensuite un flux avec concatWith et concatWithValues.

Ajouter un traitement (map) qui va freiner le flux pour observer les effets sur les étapes suivantes.

Avec (flatMap) ajouter la production d'un flux.

Tester la création d'un buffer avec buffer(n), bufferUntil et bufferUntilChanged

Avec zipWith créer un flux qui résulte du traitement de deux autres flux. Quel est le résultat si les flux n'ont pas la même taille ?

Avec zip (méthode statique) agréger deux (ou trois) autres flux. Quel est le résultat ?

Utiliser les méthodes then et thenMany pour enchaîner la fin des traitements d'un Flux avec d'autres traitements sur un autre flux.

Traitement des erreurs

Générer un flux d'entiers entre 1 et 20. Ajouter un traitement qui va générer un erreur sur les entiers entre 10 et 15. Quel est le résultat ?

Utiliser la méthode onErrorContinue pour capter l'erreur.

Utiliser Spring Data avec Redis

Commencez, dans une autre fenêtre, à charger et à compiler la dernière version de la BD NoSql Redis (à partir des sources).

Suivez ce cette documentation pour utiliser Redis avec Spring Data. Attention : Utilisez la configuration alternative ci-dessous

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

Nous remplacons le composant lettuce-core (un client Redis) par le composant jedis (un autre client plus récent).

Vérifier avec le client ligne de commande l'insertion des données dans la base Redis (commandes KEYS * et HGETALL Student:Eng2015001).