Previously, in the decouverte series

Dans l’article précédent, je vous ai présenté l‘outil de gestion de build Gradle. Aujourd’hui, on va enfin pouvoir s’attaquer à notre jeu Guild-of-geek 😃. L’objectif de cet article, on va créer notre première API Rest avec spring-boot.

De quoi avons-nous besoin ?

On désire développer une application web. Pour commencer, on va s’intéresser au backend, c’est-à-dire à la partie serveur. On va rester de ce côté-là pour le moment et choisir Java comme langage. Il est possible qu’on switch un jour ou l’autre vers le langage Kotlin, qui est un langage que j’apprécie également 😃.

On va communiquer avec l’IHM via une API REST. Pour la développer rapidement, on va utiliser le framework Spring. Le couple java-Spring étant fortement utilisé, commençons donc par du classique 😃 .

Il nous faut également un outil pour compiler, packager, tester, gérer les dépendances de notre projet. Pour cela, je choisis Gradle (et non Maven), outil que j’apprécie tout particulièrement, dont j’ai déjà décrit les bases dans l’article précédant.

Mais tout d’abord, que faut-il installer sur notre machine ?

• Java Development Kit version 8. (on commencerapar utiliserdu java8 voire du Java7, mais quand on abordera l’ordre supérieur, les lambdas, les modules, on aura besoin de Java9. Donc autant installer directement dernière version de Java directement disponible ici).

• Un IDE. Moi, personnellement ,j’utilise Intellij, mais il est tout à fait possible d’utiliser Eclipse ou Netbeans. Il est également conseillé d’installer les plugins Gradle et Spring (voir Git pour ceux qui veulent utiliser Git depuis leur IDE). Pour les utilisateurs d’Eclipse, il existe également un Eclipse fournit par Springsource que je conseile : https://spring.io/tools/sts/all

Et c’est tout 😃.

Un petit mot sur Spring

Spring est un (immense?) framework Java qui va grandement vous aider à développer entre serveurs d’applications.

Un des avantages de Spring, est qu’il permet de lancer vos applications dans des serveurs léger de style apache-tomcat. Contrairement à une application JEE classique qui nécessite un serveur bien plus lourd compatible JEE du style JBOSS ou GlassFish.

Spring est constitué d’un grand nombre de composants qui ont pour but de fournir un ensemble cohérent, et de répondre à l’ensemble des problématiques régulièrement rencontrés lorsqu’on développe un serveur d’application. Voici une liste non exhaustive de composant Spring :

• Spring-jpa pour communiquer avec une base de données. Le mapping tables-classes étant par exemple géré avec Hibernate

• Spring-data pour créer, en un rien de temps, un repository de type CRUD (Create, Read, Update, Delete)

• Spring web pour créer une api Rest par exemple

• Spring-security pour gérer la sécurité

• Spring-cache pour mettre en place un système de cache etc.

Et Spring-boot dans tout cela ?

Spring-boot est un autre composant de Spring, mais un peu spécial. En effet, il est conçu pour être le point d’entrée d’une application Spring. Grâce à ce projet, il sera possible de mettre en place rapidement une application Spring cohérente, facile à configurer et exécutable. On pourra observer la puissance de ce composant assez rapidement dans les prochains articles

Spring-boot est un projet assez récent de spring. L’objectif est de faciliter l’utilisation et la configuration de Spring mais également de devenir le point d’entrée de Spring

Il nous reste plus qu’à commencer

Pour commencer, un moyen rapide est de passer par le site http://start.spring.io/ qui va nous permettre de générer aisément une base de projet, selon nos choix. Ce site nous propose une interface sympa pour créer des projet Spring « à la carte » en seulement quelque cliques. Enjoy 😃

Voici les critères à saisir pour créer notre projet :

• On veut un projet Gradle

• Le langage sera le Java

• La version de spring-boot : la dernière stable, à savoir 1.5.7 (au moment où j’écris ces lignes). Spring-boot 2.0 ne devrait pas tarder à sortir. Il y aura surement à l’avenir un article sur la migration vers Spring-boot 2 et Spring 5: Et il y aura beaucoup de chose à dire 😃

• groupId : fr.slickteam.decouverte.gog

• artifactID : guild-of-geek

• En dépendance Spring, on veut pouvoir faire une API REST, pour cela, on il nous faut la dépendance : Web.

Il ne reste plus qu’a télécharger le zip généré sur notre machine. Vous devriez vous retrouver avec ceci dans votre dossier Guild-of-Geek :

Le projet est un projet Gradle dont la structure est décrite dans l’article précédant. Je vous invite à lire cet article pour comprendre la structure.

A noter également que Spring nous à générer un projet avec deux fichiers particuliers :

• gradlew (pour linux et OSX)

• gradlew.bat (pour Windows)

Ces fichiers sont des scripts qui vont vous permettre d’exécuter Gradle sans avoir besoins de l’installer. Ce qui est non seulement sympa, mais qui, en plus, va nous permettre de ne pas avoir à se soucier de la version de Gradle installée sur notre machine. En fait, on n’a même plus besoin d’installer Gradle 😃

Si vous voulez savoir quelle version de Gradle, Spring vous a choisi, tapez :

./gradlew –version

Le fichier build.gradle généré par Spring

L’article précédant détaille le fonctionnement de Gradle et, en particulier, le fichier build.gradle dont l’ajout de plugins et la gestion des dépendances. Mais il y a quelques spécificités avec spring-boot qui méritent notre attention.

Observez les dépendances vers les modules Spring :

dependencies {   compile('org.springframework.boot:spring-boot-starter-web')   testCompile('org.springframework.boot:spring-boot-starter-test')}

On peut noter ceci :

• Les numéros de version ne sont pas présents.

• Toutes les dépendances commencent par spring-boot-starter

L’article précédant vous présentait la complexité de la gestion des dépendances et en en particulier les grandes difficultés qu’on peut rencontrer entre les différentes versions de vos dépendances. Spring est un framework qui peut vous amener très rapidement à dépendre d’un très (trop ?) grand nombre de dépendances (Il est aisé de dépendre de bien plus plus de 100 jars par exemple). Même avec Gradle ou Maven, on peut rapidement avoir un conflit de dépendance difficile à gérer. Les concepteurs de spring-boot ont tenté de résoudre ce souci. Comment ? En gérant ces versions à notre place. Regardons comment Spring-boot les gères. Pour Gradle (C’est également le cas avec Maven) il existe un plugin spring-boot. Les lignes suivantes montrent comment on ajoute le plugin spring-boot 1.5.7.RELEASE avec Gradle.

buildscript {   ext {      springBootVersion = '1.5.7.RELEASE'   }   repositories {      mavenCentral()   }   dependencies {      classpath("org.springframework.boot:spring-boot-gradle-plugin:$")   }}

Ici, on utilise la version 1.5.7.RELEASE. Spring boot connait (pour la version 1.5.7 ici) toutes les versions de dépendances dont il a besoin. Il est donc fortement déconseillé de saisir manuellement une version.

Retenez ceci, quand on utilise spring-boot :

• On utilise de préférence des dépendances ayant des noms commençant par spring-boot-starter

• On évite de saisir le numéro de version d’une dépendance

Une première exécution

Dans un terminal, que ce soit sous Windows ou Linux, placez vous à la racine du projet, là où vous l’avez dézippée. Puis, exécutons «Guild-of-Geeks» à l’aide de cette commande :

./gradlew bootRun

et pour windows

gradlew.bat bootRun

La première exécution peut être assez longue, les suivantes seront beaucoup plus rapides.

Lorque, vous voyez un résultat ressemblant à l’image ci-dessus, dans votre navigateur, aller à l’Url suivante : http://localhost:8080/, Et vous devriez voir ceci :

Une page d’erreur oui. Mais, pour une fois, celle-ci est « normale ». En effet, notre projet est vide. On n’y a pas touché. Enfin, pas si vide que ça tout de même. En effet, avec une commande Gradle on a pu lancer un serveur Tomcat avec comme webapp «Guild-of-Geeks» et qui nous permet d’avoir une page d’erreur générique en cas de saisie de page non trouvée. Maintenant, ajoutons notre première API Rest.

On va, pour finir cet article, créer un simple « hello world ». l’objectif est d’afficher la chaîne de caractère suivante : « Hello world! » lorsqu’on va sur la page à l’adresse suivante : http://localhost:8080/home dans un navigateur web.

On désire donc une requête HTTP te type GET /hello qui nous retourne en réponse « Hello World »

Pour faire une API Rest en Spring, il nous faut ce qu’on appelle un controller. Ceci se fait dans une simple classe Java annotée @RestController

Chaque requête d’une API REST en Spring correspond à une méthode d’une classe Java de type Controller» qui sera annotée @RestController. Dans la cas d’une requête de type GET, on utilise l’annotation @GetMapping("/hello") sur notre méthode.

Bien, on peut commencer :

1. Commencez par ouvrir votre projet Guild-of-Geeks dans notre IDE préféré. Je vous laisse regarder la documentation de voter IDE pour ouvrir un projet Gradle. Pour rappel, la structure d’un projet Gradle ressemble à celui-ci. Vous pouvez lire l’article précédant sur la découverte de Gradle pour en savoir plus

Créons notre premier controller. Pour cela :

2. créez un package nommé controller dans le package fr.slictkeam.decouvert.gog

3. créez une class HomeController dans ce package

4. Annotez cette classe avec l’annotation @RestController

@RestControllerpublic class HomeController {

4) Créez une méthode hello qui retourne le String « Hello world»

5) Ajoutez l’annotation @GetMapping(« /hello») sur notre méthode hello()

6) Relancez maintenant l’application via la commande

 ./gradlew bootRun

7. Allez ensuite dans votre navigateur à l’Url suivant : http://localhost:8080/hello. Vous devriez avoir, sans surprise, cette page (comme par magie :D) :

Cet exemple est bien évidemment très simple. Mais il met en place une base solide sur laquelle on va s’appuyer pour les prochains articles.

En conclusion

Dans cet article, nous avons pu créer une application avec une API Rest simple from scratch. Pour cela, on a généré un projet spring-boot avec le site http://start.spring.io/. Nous avons vu ce qu’était un controller pour Spring. Ce controller est une simple classe Java annotée avec des annotation Spring (@RestController, @GetMapping ). Ce controller peut récupérer les informations des requêtes http ainsi que générer des requêtes http.

Les sources GIT

Pour chaque article de cette série découverte, les sources seront présentes sur github à cette adresse: https://github.com/Slickteam/Guild-of-Geeks.

Pour chaque article, les sources à récupérer seront sur des tags git qui respecterons ce nommage :

• decouverte<NOARTICLE>_start

• decouverte<NOARTICLE>_solution

donc pour cet article les tags sont :

• decouverte02start (qui correspond à l’archive téléchargée depuis http://start.spring.io/)

• decouverte02solution pour la résultat final

In the next episode

On dit : «Tester c’est douter» 😉. Vous le devinez, je ne partage pas du tout cet avis. Donc dans le prochain article, on va regarder comment on peut tester notre mini API Rest.