Création de mono

---

Préface

        Reactor Est basé sur JVM Bibliothèque de base d'application asynchrone au - dessus.Pour Java 、Groovy Et autres JVM Le langage fournit une bibliothèque abstraite pour construire des applications basées sur des événements et des données,Utilisez - le pour construire une application de données de flux efficace dans le temps,Rendre l'application efficace、Transmission asynchrone des messages.
        Reactor Performance assez élevée,Sur la dernière plateforme matérielle,Il est possible de traiter toutes les secondes avec un distributeur sans blocage 1500 Événement Wan.
        Reactor Deux concepts importants sontFlux Et Mono.Mono Indique que contient 0 Ou 1 Séquence asynchrone des éléments.Flux Indique que contient 0 À N Séquence asynchrone des éléments.Ils contiennent trois types différents de notifications de messages：Message normal contenant des éléments、Message de fin de séquence et message d'erreur de séquence.

Un.、Flux de données réactifs

        Flux de données réactifs En tant que nouvelle spécification de flux de données pour Java 9 Et ses versions ultérieures,Conçu pour fournir les mêmes/Contrôle asynchrone du flux de données séquentielles.

1、Interface de flux de données réactive

org.reactivestreams.Pubslisher：Éditeur de flux de données(Signal de 0 À N,N Peut être infini).Deux événements terminaux optionnels sont disponibles：Erreurs et achèvement.
org.reactivestreams.Subscriber： Consommateurs de flux de données (Signal de 0 À N,N Peut être infini). Lors de l'initialisation du consommateur , Combien de données le producteur doit - il actuellement s'abonner? .Autres situations, Interagir avec le producteur de données par le biais d'un rappel d'interface : Article suivant(Nouvelles informations)Et l'état.Le statut comprend:：Terminé./Erreur,Facultatif.
org.reactivestreams.Subscription： La phase d'initialisation passe un petit traceur à l'abonné . Il contrôle la quantité de données que nous sommes prêts à consommer. , Et quand nous voulons arrêter de consommer (Annulation).
org.reactivestreams.Processor： Étiquetage des composants en tant qu'éditeur et abonné .

2、 Protocole de diffusion en continu réactif

Les abonnés ont deux façons de demander des données à l'éditeur ：

Illimité： Les abonnés n'ont qu'à appeler Subscription#request(Long.MAX_VALUE) C'est tout..
Borné： Les abonnés conservent les références de données ,Appelezrequest(long) Consommation méthodologique.

2.、MonoCréation de

（1）empty

Ne contient aucun élément, Peut publier un message de fin

	@Test
    public void empty(){
    
        Mono.empty().subscribe(System.out::println);
    }

（2）just

Contient l'élément spécifié

    @Test
    public void just(){
    
        Mono.just("hello mono").subscribe(System.out::println);
    }

（3）justOrEmpty

Lorsqu'il y a un élément just,
Équivalent sans élément empty,
L'élément estOptionalHeure,SelonOptional Y a - t - il des valeurs pour créer justOuempty.

 	@Test
    public void justOrEmpty(){
    
        Mono.justOrEmpty("hello mono").subscribe(System.out::println);
    }

（4）never

Ne contient aucun élément

	@Test
    public void never(){
    
        Mono.never().subscribe(System.out::println);
    }

（5）from

 	@Test
    public void from() {
    
        //De Publisher Générer Mono
        Mono.from(Mono.just("hello mono")).subscribe(System.out::println);
        //De Publisher Générer Mono,Oui.FluxType à emballer
        Mono.fromDirect(Mono.just("hello mono")).subscribe(System.out::println);
        //De Supplier Générer Mono
        Mono.fromSupplier(() -> "hello mono").subscribe(System.out::println);
        //De Runnable Générer Mono
        Mono.fromRunnable(() -> System.out.println("hello mono")).subscribe(System.out::println);
        //De Callable Générer Mono
        Mono.fromCallable(() ->"hello mono").subscribe(System.out::println);
        //De CompletableFuture Générer Mono
        Mono.fromFuture(CompletableFuture.completedFuture("hello mono")).subscribe(System.out::println);
        //De CompletionStage Générer Mono
        Mono.fromCompletionStage(CompletableFuture.completedFuture("hello mono")).subscribe(System.out::println);
        //De Supplier<? extends CompletionStage<? extends T> Générer Mono
        Mono.fromCompletionStage(() -> CompletableFuture.completedFuture("hello mono")).subscribe(System.out::println);
    }

（6）defer

  	@Test
    public void defer() {
    
        //De Supplier Accès mono
        Mono.defer(() -> Mono.just("hello mono")).subscribe(System.out::println);
        //De Function<ContextView, ? extends Mono<? extends T>> Accès mono
        Mono.deferContextual(view -> Mono.just("hello mono")).subscribe(System.out::println);
    }

（7）delay

    @Test
    public void delay() throws InterruptedException {
    
        // Spécifier le délai , La valeur de publication est 0
        Mono.delay(Duration.of(5, ChronoUnit.SECONDS)).subscribe(System.out::println);
        Mono.delay(Duration.of(5, ChronoUnit.SECONDS), Schedulers.parallel()).subscribe(System.out::println);

        TimeUnit.SECONDS.sleep(15);
    }

（8）error

	@Test
    public void error() throws InterruptedException {
    
        //Contient une exception mono
        Mono.error(new RuntimeException("Une erreur s'est produite")).subscribe(System.out::println);
        //Supplier  Fournir des exceptions  mono
        Mono.error(() -> new RuntimeException("Une erreur s'est produite")).subscribe(System.out::println);
    }

（9）first

 	@Test
    public void first() throws InterruptedException {
    
        //Traiter le premier mono, Si la première annulation ,Traiter la deuxième...
        Mono.firstWithSignal(Mono.empty(), Mono.just("mono hello")).subscribe(System.out::println);
        Mono.firstWithValue(Mono.just("hello mono"), Mono.just("mono hello")).subscribe(System.out::println);
        Mono.firstWithSignal(List.of(Mono.just("hello mono"), Mono.just("mono hello"))).subscribe(System.out::println);
        Mono.firstWithValue(List.of(Mono.just("hello mono"), Mono.just("mono hello"))).subscribe(System.out::println);
    }

（10）sequenceEqual

	@Test
    public void sequenceEqual() throws InterruptedException {
    
        //Comparer deux mono  C'est pareil. 
        Mono.sequenceEqual(Mono.just("hello mono"), Mono.just("hello mono")).subscribe(System.out::println);
        Mono.sequenceEqual(Mono.just("hello mono"), Mono.just("hello mono"), Object::equals).subscribe(System.out::println);
        Mono.sequenceEqual(Mono.just("hello mono"), Mono.just("hello mono"), Object::equals, 16).subscribe(System.out::println);
    }

（11）using

    @Test
    public void using() throws InterruptedException {
    
        //callableRetourmono,
        //functionC'est exact.monoExécution des opérations
        //consumerEffectuer des opérations de nettoyage
        //eager PourtrueHeure,consumerInsubscribePrécédemment appelé
        Mono.using(() -> Mono.just("hello mono"), Function.identity(), t -> System.out.println(t)).subscribe(System.out::println);
    }

（12）when

 	@Test
    public void when() throws InterruptedException {
    
        // Effectuer des opérations prédéfinies 
        Mono.when(Mono.just("hello mono").filter(a -> a.equals("hello mono"))).subscribe(System.out::println);
    }

（13）zip

Opération de compression