1. Qu’est-ce qu’un contrôleur?
Le contrôleur en Springboot c’est votre interface avec l’extérieur. Si vous connaissez le modèle MVC (Modèle Vue Controleur), et bien le contrôleur est vous l’aurez deviné… la Vue. Si ça ne vous paraît pas évident, je vais vous expliquer. Le MVC:
Vue <=> Contrôleur <=> Modèle
La vue est-ce à quoi à accès l’utilisateur, la vue demande des informations au contrôleur, dans le contrôleur il y a l’algorithme de l’application. Le contrôleur (MVC) est donc la partie intelligente, pour donner des informations à la vue, le contrôleur (MVC) a besoin de données qui sont stockées dans le modèle. Le contrôleur (MVC) va alors traiter les données que le modèle lui a donné pour les renvoyer à la vue.
Donc le modèle MVC de Springboot s’articule ainsi :
- Vue => Contrôleur
- Contrôleur => Service (Que nous verrons plus tard)
- Modèle => Repository (Que nous verrons encore plus tard)
Dans notre exemple nous allons utiliser Springboot afin qu’il présente des APIs REST JSON. Et l’écriture de notre Contrôleur va nous permettre de présenter les différentes requêtes HTTP possible.
2. On va faire un CRUD
On va faire un CRUD ensemble, y a des CRUDs bien et des CRUDs moins bien dans la vie. On va essayer de faire un bon truc ensemble. Commençons par une définition :
- Create => Cela va nous permettre de créer des objets
- Read => Ce qui a de bien quand on a créé un objet, c’est de pouvoir le lire
- Update => On va pouvoir aussi modifier notre objet
- Delete => Et le supprimer s’il ne nous plaît pas
Voilà ce que veut dire l’acronyme CRUD, pour chacune de ces opérations, on a un équivalent en HTTP :
- Create <=> POST => C’est avec PUT, la seule requête qui peut avoir un corps (en JSON ici), signifie poster en français, tout est fait pour que ça fonctionne mieux que la poste.
- Read <=> GET => C’est la requête de base que fait votre navigateur quand vous tapez « https://raphlys.com », signifie obtenir en français
- Update <=> PUT => Comme Post, il permet d’avoir un corps (en JSON ici), signifie mettre en français
- Delete <=> DELETE => Lui, il est facile.
3. Les dépendances
Nous allons ajouter la dépendant Springboot Web, qui va nous permettre de faire du web. Plus exactement nous allons remplacer la dépendance Springboot par Springboot Web. Ouvrez le fichier « build.gradle », trouvez la ligne :
implementation 'org.springframework.boot:spring-boot-starter'Et remplacez par :
implementation 'org.springframework.boot:spring-boot-starter-web'Vous avez donc tous ce qu’il faut pour faire une API Springboot. Maintenant faites un clic droit à la racine de votre projet => « Gradle » => « Refresh Gradle Project ». Eclipse sera alors synchronisé avec les configurations GRADLE de votre projet et notamment les dépendances.
4. Notre Contrôleur
D’abord créons un package ‘com.raphlys.controller’. Pour ça clic droit sur le package ‘com.raphlys’ => New => Package
Une fenêtre s’ouvre, dans le champ « Name », on tape ‘com.raphlys.controller’ qui est notre nouveau package. On peut alors cliquer sur « Finish ».
Sur ce package ont fait un clic droit => « New » => « Class »
Une fenêtre s’ouvre, on indique juste le champ « Name: » avec le nom de la classe. Dans notre cas ‘RaphlysController’.
On clique alors sur « Finish ».
On peut enfin éditer la classe. On ajoute juste au-dessus de la déclaration de la classe les annotations suivantes (du package « org.springframework.web.bind.annotation »):
- @RestController()
- Ceci permet d’indiquer à Springboot, que cette classe est une entrée de notre API
- @RequestMapping(« raph »)
- Ceci permet d’indiquer par quel chemin notre API doit être accessible, si vous ne mettez pas cette annotation, l’API de ce contrôleur sera accessible à partir de la racine de votre URL ( sauf si une autre configuration est mise en place dont nous parlerons plus tard)
5. Les méthodes
Voici le code que nous allons écrire avec les commentaires de celui-ci :
package com.raphlys.controller;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* Contrôleur REST pour gérer les opérations CRUD sur des objets Truck.
*/
@RestController()
@RequestMapping("raph")
public class RaphlysController {
// Dernier identifiant utilisé pour un camion
private Long last_id = 0l;
// Map pour stocker les camions avec leur identifiant
private final Map<Long, Truck> TRUCKS = new HashMap<>();
/**
* Récupère tous les camions.
* @return une collection de tous les camions.
*/
@GetMapping("all")
public Collection<Truck> getAll() {
return TRUCKS.values();
}
/**
* Crée un nouveau camion.
* @param truck les détails du camion à créer.
* @return l'identifiant du camion créé.
*/
@PostMapping()
public Long createTruck(@RequestBody() Truck truck) {
truck.setId(last_id);
TRUCKS.put(truck.getId(), truck);
last_id++;
return truck.getId();
}
/**
* Met à jour un camion existant.
* @param truck les détails du camion à mettre à jour.
* @return l'ancien camion associé à l'identifiant donné.
*/
@PutMapping()
public Truck updateTruck(@RequestBody() Truck truck) {
return TRUCKS.put(truck.getId(), truck);
}
/**
* Supprime un camion par son identifiant.
* @param id l'identifiant du camion à supprimer.
* @return true si le camion a été supprimé, false sinon.
*/
@DeleteMapping("{id}")
public boolean deleteTruck(@PathVariable("id") Long id) {
return TRUCKS.remove(id) != null;
}
/**
* Classe interne représentant un camion.
*/
public static class Truck {
// Identifiant unique du camion
private Long id;
// Marque du camion
private String brand;
// Nom du camion
private String name;
// Getters et setters pour les propriétés de Truck
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
}
Quelques explications maintenant, on a ajouté les annotations suivantes (package « org.springframework.web.bind.annotation ») :
- @GetMapping(« all »)
- Permet de faire des requêtes HTTP de type GET à l’adresse localhost:8080/raph/all , vous comprenez donc que la chaîne caractères « all » correspond à la fin du path
- @PostMapping()
- Permet de faire des requêtes HTTP de type POST à l’adresse localhost:8080/raph , comme nous n’avons pas mis de chaîne de caractères, le path se termine au niveau du path du controleur.
- @RequestBody()
- Va prendre le corps de la requête HTTP, qui doit être un JSON et va le mettre dans le paramètre de la méthode qui suit.
- @PutMapping()
- Permet de faire des requêtes HTTP de type PUT à l’adresse localhost:8080/raph
- @DeleteMapping(« {id} »)
- Permet de faire des requêtes HTTP de type DELETE à l’adresse localhost:8080/raph/{id} où {id} est une chaîne de caractère.
- @PathVariable(« id »)
- Va prendre la variable du path représentée précédemment par {id} et va la mettre dans le paramètre de la méthode suivant. Ici le paramètre est un Long, il faut donc que {id} soit un nombre.
6. On lance le tout
Vous pouvez alors vous rendre sur votre « RaphlysDemoApplication.java », faire un clique droit => « Run As » => « Spring Boot App ». Et voilà votre application est lancée sur le port 8080. C’est vraiment incroyable, de se dire qu’en si peu de temps vous avez réussi à faire un CRUD. Malheureusement celui-ci n’est pas branché à une base de données, mais ça viendra.
Nous verrons la prochaine fois comment requêter, votre application avec un outil comme postman.
Laisser un commentaire