Spring Boot Initiation
Khalid Nafil
12 Septembre 2024
IDE : IntelliJ IDEA 2024.2.1 (Ultimate Edition)
ENSIAS
Spring Boot Project
Dans cet atelier nous allons essayer de créer une application Spring Boot en utilisant l’IDE IntelliJ IDEA et
en passant par un projet Maven. L’idée derrière cette application c’est de voir la pertinence de Spring Boot
au niveau de la création rapide d’un projet Spring sans aucune configuration préalable et en même temps
de découvrir le concept de Contrôleur au niveau de Spring. L’atelier sera une opportunité aussi pour
découvrir les webservices sous Spring Boot. Pour commencer, veuillez suivre les étapes suivantes :
1. Commencez par créer un projet Spring Boot sous IntelliJ IDEA, comme par ici :
[Link]
2. Ouvrez l’IDE IntelliJ IDEA et choisissez File -> New Project. Sélectionnez dans le menu à gauche, dans la
section ‘Generators’, Spring Boot. Donnez un nom au projet, par exemple ‘tp1’. Choisissez ‘Java’ en tant que
Langage et ‘Maven’ en tant que Type du projet. Dans le champ ‘Group’, mettez par exemple ‘[Link]’ et
dans le champ ‘Artifact’, mettez par exemple ‘tp1’. Sélectionnez votre version du langage Java et appuyez
sur ‘Next’ comme ci-dessous.
2
3
3. Dans la fenêtre suivante, vous allez ajouter la dépendance ‘Spring web’ et après validez en appuyant sur le
bouton ‘Create’.
4. Une fois le projet créé et ouvert, il va se présenter comme ci-dessous. On observe le package principal
‘[Link].tp1’ au sein du ‘[Link]’ (ça c’est l’architecture Maven d’un projet Java). Du moment que
c’est un projet ‘Spring Boot’, il y a alors la classe ‘Tp1Application’ qui a été générée et qui comporte
l’annotation @SpringBootApplication annonçant qu’il s’agit bien d’une application Spring Boot qui n’est rien
d’autre qu’une application Java Standalone. Vous pouvez aussi remarquer la création du fameux fichier
‘[Link]’ et qui comporte un starter parent ‘spring-boot-starter-parent’et deux starters
‘spring-boot-starter-web et ‘spring-boot-starter-test.
4
5. Nous pouvons maintenant lancer l’exécution du projet en appuyant sur le bouton ‘Run’ pour avoir l’aperçu
suivant. Nous voyons que le serveur d’application Tomcat intégré est lancé par défaut sur le port 8080.
6. Le serveur une fois lancé avec succès nous rassure que le projet Spring Boot est bien mis en place.
Nous allons ajouter alors un ‘Contrôleur’ qui est une classe Java avec des annotations et qui a des
informations par rapport à l’Url à accéder et à la méthode à invoquer lorsqu’on accèdera à cette url. Nous
allons donc créer une classe java ‘HelloSpringBoot’ dans le package ‘[Link]’. Pour que
cette classe soit considérée comme ‘Contrôleur’ on doit ajouter l’annotation @RestController juste avant sa
déclaration. @RestController est un élément clé dans Spring Boot pour développer des applications RESTful.
Un API RESTful (Representational State Transfer) est un style architectural pour concevoir des services web
qui utilisent les méthodes HTTP pour interagir avec des ressources. @RestController simplifie la création de
contrôleurs qui gèrent les requêtes HTTP et renvoient des réponses dans un format approprié, généralement
JSON ou XML. Supposons maintenant que la classe contient une méthode sayHello() et que nous voulons
associer cette méthode avec l’url ‘/hellospring’ alors on doit la faire précéder par l'annotation
@RequestMapping(“/hellospring”) comme suit :
package [Link];
5
import [Link];
import [Link];
@RestController
public class HelloSpringBoot {
@RequestMapping("/hellospring")
public String sayHello() {
return "Hello Spring Boot";
}
}
7. @RequestMapping est utilisée pour mapper les requêtes HTTP à des méthodes spécifiques d'un contrôleur.
C'est l'annotation qui permet de lier les URL demandées par les clients aux méthodes du contrôleur qui vont
traiter ces requêtes.
8. L’architecture du projet se présente ainsi :
9. Sauvegardez et exécutez à nouveau le projet et lancez cette fois le terminal au niveau de IntelliJ IDEA. En
principe vous allez voir s’afficher le message “Hello Spring Boot”.
et depuis le navigateur, vous allez pouvoir afficher le message ‘Hello Spring Boot!’ de la méthode ‘sayHello()’
6
10. Par la suite, nous allons ajouter d’autres contrôleurs à notre application. Pour cela, ajoutez la classe
ModuleControleur dans le package ‘[Link]’ comme suit:
package [Link];
import [Link];
import [Link];
@RestController
public class ModuleController {
@RequestMapping("/modules")
public String getModules(){
return "Ceci est la liste de tous les modules";
}
}
11. Exécuter l’application de la même façon qu'auparavant et au niveau de l’url tapez cette fois çi :
[Link] normalement la page va afficher « Ceci est la liste de tous les modules »
comme indiqué par le contrôleur.
12. Maintenant nous allons créer une classe ‘Module’ dans le package ‘[Link]’ qui contient les
attributs ‘id’, ‘nom’ et ‘description’ comme suit :
public class Module {
/* au cas où on a utilisé lombok
import [Link];
import [Link];
import [Link];
*/
//@AllArgsConstructor
//@NoArgsConstructor
//@Data
private int id;
private String nom;
private String description;
public Module() {
}
public Module(int id, String nom, String description) {
[Link] = id;
[Link] = nom;
7
[Link] = description;
}
//ajouter les setters et gettersau cas où Lombok n’est pas utilisé
}
13. Côté Contrôleur, nous allons modifier légèrement la méthode getModules() pour pouvoir éventuellement
retourner une liste des modules comme suit :
//import
@RestController
public class ModuleController {
@RequestMapping(“/modules”)
public List<Module> getModules() {
return [Link]( new Module(1, “La plateforme Java Standard Edition”, “Description de la plateforme
Java SE”) , new Module(2, “La plateforme Java Enterprise Edition”, “Description de la plateforme Java EE”));
14. Sauvegardez et exécutez à nouveau votre projet. Vous allez pouvoir afficher la liste des deux modules avec
l’url d’exécution ‘[Link]
15. Nous allons maintenant faire un peu d’organisation dans notre architecture et créer une classe ‘Service’ pour
tous les Modules. Cette classe va s’occuper de tous les contrôleurs associés à la classe ‘Module’. Pour ce
faire, créer une classe ModuleService dans le package ‘[Link]’ et veuillez l’annoter par ‘@Service’.
16. Nous voulons maintenant injecter une dépendance de ModuleService au niveau du contrôleur, c’est possible
en ajoutant l’annotation @Autowired comme suit :
import [Link];
import [Link];
import [Link];
//suite import
@Service
public class ModuleService {
private List<Module> modules= [Link] ( new Module(1, “La plateforme Java Standard Edition”, “Description de
la plateforme Java SE”),
new Module (2, “La plateforme Java Enterprise Edition”, “Description de la plateforme Java EE”));
public List<Module> getModules() {
return modules;
}
8
17. L’annotation @Autowired est un mécanisme essentiel de Spring pour la gestion des dépendances. Elle
permet d'injecter automatiquement des dépendances dans les composants d'une application Spring,
facilitant ainsi l'inversion de contrôle (IoC) et la gestion des beans (objets gérés par le conteneur Spring).
@Autowired indique à Spring qu'il doit automatiquement rechercher et injecter une instance appropriée du
bean dans la classe où l'annotation est utilisée. Spring fait correspondre le type de la variable annotée avec
un bean de même type disponible dans le contexte d'application.
18. Dans la classe [Link], apportez les modifications suivantes :
@RestController
public class ModuleController {
@Autowired
private ModuleService moduleService;
@RequestMapping(« /modules »)
public List<Module> getModules() {
return [Link]();
19. Nous allons maintenant ajouter d’autres méthodes au contrôleur :
@RequestMapping(« /modules/{id} »)
public Module getModule(@PathVariable Integer id){
return [Link](id);
20. Et dans Service, nous modifions ainsi :
public Module getModule(Integer id) {
for (Module module : modules) {
if ([Link]([Link]())) {
return module;
}
}
return null;
}
21. Maintenant, vous sauvegardez et relancez l’application. Au niveau de l’url, vous tapez la chaîne suivante :
localhost:8080/modules/1 ; et vous allez pouvoir afficher le premier module qui porte l’id 1.
9
22. Nous allons aussi ajouter d’autres contrôleurs au niveau de ‘ModuleControleur’ comme suit:
@RequestMapping(method=[Link], value="/modules")
public void ajouterModule(@RequestBody Module module) {
[Link](module);
}
23. Nous allons maintenant ajouter la méthode ‘ajouterModule’ au Service comme suit :
public void ajouterModule(Module module) {
[Link](module);
}
24. Nous allons modifier légèrement l’attribut ‘modules’ afin de pouvoir y ajouter des éléments :
import [Link];
private List<Module> modules=
new ArrayList<>([Link](new Module(10 ,"Java SE", "Description de la plateforme
Java SE"),
new Module (12, "Java EE", "Description de la plateforme Java
EE")));
25. Sauvegarder et relancer le projet. Avant de l’exécuter, lancer l’application ‘PostMan’ (ça suppose
que Postman est déjà installé) et dans header vous changez les valeurs comme suit : Key:
Content-type et Value: application/json
26. Vous insérez un tuple JSON, vous passez sur POST et tapez [Link] et
vous appuyez sur Send.
27. Normalement aucun message d’erreur. Pour s’assurer vous n’avez qu’à relancer le GET.
28. Maintenant nous voulons mettre à jour un seul enregistrement que nous allons spécifier via le
champ Id. Nous allons utiliser pour ce faire la méthode PUT. Nous allons apporter une
modification aux deux classes ModuleService et ModuleController comme suit.
29. Au niveau de la classe ModuleService, nous allons ajouter la méthode modifierModule qui va
avoir deux paramètres Id et module.
30. public void modifierModule(Integer id, Module module) {
for (int i=0; i<[Link](); i++) {
Module m = [Link](i);
if ([Link]([Link]())) {
[Link](i, module);
return;
}
}
}
35. Au niveau de la classe ModuleController nous créons la classe modifierModule qui va appeler la
méthode modifierModule de la classe ModuleService que nous venons de créer ci haut. Le code
de cette nouvelle classe est comme suit :
36. @RequestMapping(method=[Link], value="/modules/{id}")
10
public void modifierModule(@RequestBody Module module, @PathVariable Integer id) {
[Link](id, module);
}
37. Nous sauvegardons et nous lançons l’application.
38. Ouvrez Postman, vous sélectionnez la méthode PUT, au niveau de la chaîne mettez par exemple
[Link] modifiez les champs nom et description et vous validez par le
bouton Send. Pour vérifier, lancez la méthode GET.
39. Dans l’étape qui suit, nous allons essayer de supprimer un module parmi les modules existants
en fournissant son Id. Là aussi, nous allons ajouter deux méthodes, une dans ModuleService et
l’autre dans ModuleController. Nous commençons par ajouter la méthode supprimerModule au
niveau de la classe ModuleController comme suit :
40. @RequestMapping(method=[Link], value="/modules/{id}")
public void supprimerModule(@PathVariable Integer id) {
[Link](id);
}
41. Puis au niveau de la classe ModuleService nous allons ajouter la méthode supprimerModule
comme suit :
42. public void supprimerModule(Integer id) {
[Link](m -> [Link]([Link]()));
}
43. Nous sauvegardons et lançons l’application. Sur Postman, vous choisissez la méthode DELETE et
vous mentionnez la chaîne [Link] et vous appuyez sur Send pour supprimer le
module ayant l’Id numéro 1. Vous pouvez relancer la méthode GET pour vérifier la suppression.
44. Voilà !!!!!!