[JAVA] Essayez de lancer un serveur WebAP sur le micro à l'aide d'Helidon

Aperçu

Dans cette entrée, une boîte à outils pour le développement de types de microservices Java ["Helidon"](https: // helidon.), Qui a été publiée la semaine dernière version 1.0. Lançons un service web sur le micro en utilisant io / # /). En un mot, il se concentre sur le lancement compact de l'API Web IF, qui est nécessaire pour les microservices, et vise la configuration minimale plutôt que la pile complète.

Lecteur supposé

• Ingénieur Java
• Si possible, ayez une connaissance des frameworks tels que Spring Boot et Micronaut.

Qu'est-ce que Helidon

Aperçu

Helidon est fabriqué par Oracle et est publié sur GitHub en tant que logiciel open source sous une licence Apache2. Ce qui suit est une traduction rapide de l'explication en haut du site.

――Simple et rapide ~ Compact et rapide car il s'agit simplement d'ajouter une bibliothèque basée sur Netty

• Prend en charge MicroProfile ~ La petite bibliothèque de classes de MicroProfile est au cœur, et le support JSON (JAX-RS, JSON-P / B) et l'injection de dépendances (CDI) sont supprimés. ――Dispose d'un serveur Web réactif ~ Puisque Netty est intégré en tant que serveur Web, vous pouvez démarrer immédiatement et utiliser les fonctionnalités de Netty dans le sens de Reactive. ――Dispose de divers points observables ~ Il a des points d'observation tels que les métriques et le traçage qui sont nécessaires pour les micro-services, et il est facile à combiner avec Prometheus, Zipkin, Kubernetes, etc.

Pour ceux qui comprennent, vous pouvez y voir la position suivante. --En Java, Micronaut plutôt que Spring ――En Ruby, Sinatra plutôt que Rails --Dans Scala, Scalatra plutôt que Play --En termes de Node, Koa plutôt qu'Express

Structure générale

Le tableau ci-dessous résume ce qui est écrit à la page 1 de [Introduction] du site (https://helidon.io/docs/latest/#/about/01_introduction). C'est tout ce que nous avons.

Essayez de bouger

supposition

Tant que Java8 fonctionne, cette entrée utilise Corretto.

$ java -version
openjdk version "1.8.0_202"
OpenJDK Runtime Environment Corretto-8.202.08.2 (build 1.8.0_202-b08)
OpenJDK 64-Bit Server VM Corretto-8.202.08.2 (build 25.202-b08, mixed mode)

Ecrire la source

Déplaçons la source dans Introduction.

La classe principale est OK uniquement avec ce qui suit. (Pour plus de simplicité, il jette sans gérer les principales exceptions)

package io.hrkt.helidontest;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import io.helidon.webserver.Routing;
import io.helidon.webserver.WebServer;

public class HelidontestApplication {

    public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
        WebServer webServer = WebServer
                .create(Routing.builder()
                        .any((req, res) -> res.send("It works!")).build())
                .start().toCompletableFuture().get(10, TimeUnit.SECONDS);

        System.out.println(
                "Server started at: http://localhost:" + webServer.port());
    }

}

Le fichier build.gradle pour l'exécution sur Gradle ressemble à ceci:

plugins {
	id 'application'
	id 'java'
	id 'idea'
	id 'eclipse'
}

group = 'io.hrkt'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
mainClassName = "io.hrkt.helidontest.HelidontestApplication"

repositories {
	mavenCentral()
}

dependencies {
	implementation group: 'io.helidon.webserver', name: 'helidon-webserver', version: '1.0.0'
}

Commencez

Lançons-le avec la tâche "run" en utilisant le plug-in "application" de gradle.

$ ./gradlew run

> Task :run
2 21, 2019 6:21:17 h 00.helidon.webserver.NettyWebServer lambda$start$7
information: Channel '@default' started: [id: 0x229c8f03, L:/0:0:0:0:0:0:0:0:53721]
Server started at: http://localhost:53721
<=========----> 75% EXECUTING [6s]
> :run

J'essaierai d'y accéder.

$ curl localhost:53721
It works!

Ça a marché. La source à ce stade est vers GitHub en tant que 0.0.1.

Ajouter des paramètres

Si vous n'utilisez que ce qui précède, vous ne pouvez pas réellement l'utiliser, alors essayons d'ajouter des paramètres tels que la spécification du numéro de port.

Modifiez un peu la source ci-dessus et utilisez la classe ServerConfiguration pour effectuer les opérations suivantes:

        int port = 8080;
        
        ServerConfiguration configuration = ServerConfiguration.builder().port(port).build();
        Routing routing = Routing.builder()
                .any((req, res) -> res.send("It works!")).build();
        WebServer webServer = WebServer
                .create(configuration, routing)
                .start().toCompletableFuture().get(10, TimeUnit.SECONDS);

        System.out.println(
                "Server started at: http://localhost:" + webServer.port());

$ ./gradlew run
> Task :run
2 21, 2019 7:30:45 heures du matin.helidon.webserver.NettyWebServer lambda$start$7
information: Channel '@default' started: [id: 0x4a177e3e, L:/0:0:0:0:0:0:0:0:8080]
Server started at: http://localhost:8080

De cette manière, lors du démarrage de WebServer, divers paramètres de fonctionnement sont transmis et le routage est transmis pour générer le service.

La source à ce stade est à GitHub en tant que 0.0.2.

Essayez d'ajouter des ressources Jersey (JAX-RS)

Ajoutez une classe de ressources comme celle ci-dessous.

package io.hrkt.helidontest.resource;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.core.Response;

@Path("/")
public class HelloWorld {

    @GET
    @Path("hello")
    public Response hello() {
        return Response.ok("Hello World!").build();
    }
}

Ajoutez les paramètres au routage de la classe principale. Pour la source ci-dessus, cela ressemble à ceci:

        Routing routing = Routing.builder().register("/jersey", 
                JerseySupport.builder()
                .register(HelloWorld.class) 
                .build())
                .any((req, res) -> res.send("It works!")).build();

Essayez d'accéder à / hello sous le chemin ajouté en tant que / jersey.

$ curl localhost:8080/jersey/hello
Hello World!

J'ai reçu le message que j'attendais. Pour les autres chemins, "It Works" est affiché comme décrit ci-dessus.

Essayez de lire le fichier de configuration

Essayez les fonctionnalités de Config. Préparez le fichier de configuration en tant que src / main / resources / application.properties.

web.port=9801

Dans le code source ci-dessus, la partie de lecture est comme ça.

        Config config = Config.create();
        int port = config.get("web.port").asInt().orElse(8080);

Je vais le démarrer.

$ ./gradlew run

> Task :run
[DEBUG](main) Using Console logging
2 21, 2019 8:08:21 h 00.helidon.webserver.NettyWebServer lambda$start$7
information: Channel '@default' started: [id: 0x4ea36bbe, L:/0:0:0:0:0:0:0:0:9801]
Server started at: http://localhost:9801

Vous pouvez voir ci-dessus que la valeur spécifiée dans le fichier de configuration (9801) est lue et que la valeur de secours (8080) n'est pas utilisée.

Pour le fichier de configuration, selon le document, YAML, HOCON et JSON peuvent être utilisés en plus des "propriétés" utilisées ci-dessus. Utilisez les fichiers jar correspondants en plus des dépendances.

Config enregistre le temps de chargement. Il a également une fonction pour détecter la mise à jour du fichier de paramètres et démarrer le gestionnaire correspondant. Ceci est utile lorsque vous souhaitez modifier la configuration de manière dynamique après le déploiement de l'application.

        Instant loadTime = config.timestamp();
        System.out.println("Configfile was loaded at : " + loadTime);

Résumé

J'ai expliqué Helidon et essayé d'exécuter un serveur Web.

Au moment de la rédaction de l'entrée, il y avait certaines parties où le code du didacticiel ne fonctionnait pas tel quel (comme le système de lecture des fichiers de paramètres comme dans la note de publication), probablement parce que la version 1.0 était sortie et que c'était peu de temps, mais le code de test et C'est un cadre compact que vous pouvez voir à peu près en regardant autour de l'exemple.

La source de cette entrée est sur GitHub (https://github.com/hrkt/helidontest).

Je voudrais écrire une autre entrée sur l'ajout de sécurité.