VT2020-Helidon-Demo

Cette page contient une démonstration simple, qui explique et expose les différent composants de Helison SE leur fonctionnement.

=Démonstration=

Génération du code
Il est très facile de démarrer avec Helidon SE il suffit de lancer l'archetype suivant avec maven :

mvn -U archetype:generate -DinteractiveMode=false \ -DarchetypeGroupId=io.helidon.archetypes \ -DarchetypeArtifactId=helidon-quickstart-se \ -DarchetypeVersion=2.1.0 \ -DgroupId=io.helidon.examples \ -DartifactId=helidon-quickstart-se \ -Dpackage=io.helidon.examples.quickstart.se

Le résultat est alors un projet simple qui montre les bases de la configuration du serveur Web et de l'implémentation des règles de routage de base.

Il faut ensuite entrer dans le dossier helidon-quickstart-se

cd helidon-quickstart-se

Explication du code
Il faut d'abord savoir qu'Helidon utilise l'outil de gestionnaire de projet Maven, ainsi pour démarrer avec l’API WebServer, nous devons ajouter la dépendance requise Maven au fichier pom.xml :

io.helidon.webserver helidon-webserver

Inspiré par NodeJS et d'autres frameworks Java, le composant serveur Web d'Helidon est une API asynchrone et réactive qui s'exécute au-dessus de Netty.

Commençons par configurer ce serveur web :

Config config = Config.create;

Tout d'abord, nous devons construire une instance de l'interface Config en invoquant sa méthode create pour lire notre fichier de configuration du classpath, qui correspond au fichier application.yalm.

Le fichier application.yalm est le suivant :

app: greeting: "Hello" server: port: 8080 host: 0.0.0.0

On instancie et construit le serveur avec la méthode JSONP méthode permettant d'envoyer des données structurées au format JSON entre différents domaines. L'acronyme signifie JSON (JavaScript Object Notation) with Padding (avec formatage).

WebServer server = WebServer.builder(createRouting(config)) .config(config.get("server")) .addMediaSupport(JsonpSupport.create) .build;

La méthode get (String key), fournie par Config, renvoie un nœud, ou un sous- nœud spécifique, à partir du fichier de configuration spécifié par key. Dans notre exemple la méthode config.get("server"), permet donc de récupérer tout le nœud serveur c’est-à-dire port:8080 et host:0.0.0.0

Ainsi le serveur va être configuré avec sur le port 8080 et il sera accessible par tous les adresse IPV4 de la machine locale (host:0.0.0.0).

D’autre part la méthode createRouting permet de configuré le routage :

En effet, cette méthode va nous permettre de créer de spécifier des routes pour accéder aux Health support, au Metric support via respectivement l’URL suivante :

http://localhost:8080/health

http://localhost:8080/metrics

Mais elle nous permet surtout dec configurer un service :

avec

GreetService greetService = new GreetService(config)

.register("/greet", greetService)

En effet selon la requête de l’utilisateur et donc l’url d'entrée la réponse va être différent :

@Override public void update(Routing.Rules rules) { rules .get("/", this::getDefaultMessageHandler) .get("/{name}", this::getMessageHandler) .put("/greeting", this::updateGreetingHandler); }

Ainsi si l’url entrée est http://localhost:8080/greet ou la commande :

curl -X GET http://localhost:8080/greet :

L’Api nous retournera Hello World.

Si l’url entrée est http://localhost:8080/greet/RICM ou la commande  :

curl -X GET http://localhost:8080/greet/RICM :

L’Api nous retournera Hello RICM.

On également intéragir avec l’api avec une requête de type Put par exemple : de la manière suivante :

curl -X PUT -H "Content-Type: application/json" -d '{"greeting" : "Salut"}' http://localhost:8080/greet/greeting

Ainsi la méthode updateGreetingHandler est appellée cette méthode modifie la valeur de greeting: "Salut"

Ainsi si on éxécute la commande suivante :

curl -X GET http://localhost:8080/greet/RICM

L’api répond : Salut RICM.

Deploiement
Il est possible de déployer l'application sous différentes forme.

Sous la forme classique d'un jar :

On package l'application avec maven :

mvn package

Et on démarre le jar obtenu :

java -jar target/helidon-quickstart-se.jar

Il est possible de très facilement construire une image docker de l’application et de la démarrer, puisque le projet contient un fichier DockerFile.

Pour construire une image docker et la démarrer il suffit lancer les commandes suivante :

docker build -t helidon-quickstart-se. docker run --rm -p 8080:8080 helidon-quickstart-se:latest

Mais il faut savoir que Helidon permet générer plusieurs image Docker et les démarrer. Il existe trois mode, le mode standard est celui que nous venons de voir, mais il est possible de la démarrer avec le mode jlink ou le mode natif (GraalVM). Pour plus de précision je vous invite à consulter les pages officielles de Helidon :


 * 1) https://helidon.io/docs/latest/#/se/guides/36_graalnative


 * 1) https://helidon.io/docs/latest/#/se/guides/37_jlink_image