Micronaut Reactive HTTP Request Processing

Comme Micronaut est construit sur Netty, il est possible d'effectuer des E / S non bloquantes.

If your controller method returns a non-blocking type such as an RxJava Observable or a CompletableFuture then Micronaut will use the Event loop thread to subscribe to the result.

Lorsque la méthode Controller renvoie le RxJava ʻObservable ou CompletableFuture, elle utilise le thread de la boucle Event pour s'abonner au résultat du Controller`.

If however you return any other type then Micronaut will execute your @Controller method in a preconfigured I/O thread pool.

S'il renvoie un autre type, il utilisera le pool de threads d'E / S.

Le type de la valeur de retour de Controller est important.

Eh bien, c'est facile, mais utilisons-le.

environnement

Cliquez ici pour cet environnement.

$ mn -V
| Micronaut Version: 1.0.4
| JVM Version: 1.8.0_191

Exemple d'application

Pour le moment, créez un projet modèle.

$ mn create-app hello-reactive --build maven
$ cd hello-reactive

Laissez la classe avec la méthode main telle quelle pour le moment

src/main/java/hello/reactive/Application.java

package hello.reactive;

import io.micronaut.runtime.Micronaut;

public class Application {

    public static void main(String[] args) {
        Micronaut.run(Application.class);
    }
}

Faisons de Controller.

src/main/java/hello/reactive/HelloReactiveController.java

package hello.reactive;

import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;

import io.micronaut.http.MediaType;
import io.micronaut.http.annotation.Body;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.Post;
import io.reactivex.Flowable;
import org.reactivestreams.Publisher;

@Controller("/reactive")
public class HelloReactiveController {

}

Écrivons le contenu de la méthode.

Tout d'abord, vérifions le document pour voir quel type doit être retourné.

Reactive Responses

org.reactivestreams.Publisher
RxJava Single et ʻObservable`
"Mono" et "Flux" de Reactor
java.util.concurrent.CompletableFuture

Ça ressemble à ça.

De plus, il semble que vous puissiez utiliser le type CompletableFuture ou Reactive pour l'argument de la méthode.

Créons une méthode text / event-stream qui renvoie un message toutes les secondes.

    @Get(value = "/hello", produces = MediaType.TEXT_EVENT_STREAM)
    public Publisher<String> hello() {
        return Flowable
                .fromArray("Hello Reactive")
                .repeat(10)
                .delay(1, TimeUnit.SECONDS)
                .map(m -> String.format("[%s] %s", LocalDateTime.now(), m));
    }

Quand j'ai vérifié les dépendances du projet créé, j'ai trouvé RxJava, donc j'ai utilisé ceci.

$ ./mvnw dependency:tree

[INFO] +- io.micronaut:micronaut-runtime:jar:1.0.4:compile
[INFO] |  +- io.micronaut:micronaut-aop:jar:1.0.4:compile
[INFO] |  +- com.fasterxml.jackson.core:jackson-databind:jar:2.9.8:compile
[INFO] |  |  +- com.fasterxml.jackson.core:jackson-annotations:jar:2.9.8:compile
[INFO] |  |  \- com.fasterxml.jackson.core:jackson-core:jar:2.9.8:compile
[INFO] |  +- io.reactivex.rxjava2:rxjava:jar:2.2.2:compile

Commencez et vérifiez.

$ curl -i localhost:8080/reactive/hello
HTTP/1.1 200 OK
transfer-encoding: chunked
Date: Wed, 20 Feb 2019 13:00:07 GMT
transfer-encoding: chunked
content-type: text/event-stream

data: [2019-02-20T13:00:08.861] Hello Reactive

data: [2019-02-20T13:00:09.940] Hello Reactive

data: [2019-02-20T13:00:10.943] Hello Reactive

data: [2019-02-20T13:00:11.946] Hello Reactive

data: [2019-02-20T13:00:12.948] Hello Reactive

data: [2019-02-20T13:00:13.950] Hello Reactive

data: [2019-02-20T13:00:14.953] Hello Reactive

data: [2019-02-20T13:00:15.954] Hello Reactive

data: [2019-02-20T13:00:16.956] Hello Reactive

data: [2019-02-20T13:00:17.959] Hello Reactive

D'une manière ou d'une autre, cela fonctionne comme ça.

Écrivons quelque chose qui prend un argument.

    @Post(value = "echo", consumes = MediaType.TEXT_PLAIN, produces = MediaType.TEXT_EVENT_STREAM)
    public Publisher<String> echo(@Body Flowable<String> text) {
        return text.map(t -> "★" + t + "★");
    }

L'entrée n'est pas diffusée non plus ...

$ curl -i -XPOST -H 'Content-Type: text/plain' localhost:8080/reactive/echo -d 'hello'
HTTP/1.1 200 OK
transfer-encoding: chunked
Date: Wed, 20 Feb 2019 13:01:29 GMT
transfer-encoding: chunked
content-type: text/event-stream

data: ★hello★

Est-il acceptable de placer Reactor dans la dépendance?

Pour le moment, j'ai pu faire une simple confirmation.

[JAVA] Ecrire un serveur réactif avec Micronaut

environnement

Exemple d'application