Spring Boot, les bases

Qu'est-ce que Spring Boot ?

Spring est un framework Java très répandu pour construire des applications d'entreprise. Spring Boot en est la version « prête à l'emploi » : il fournit un serveur web intégré (Tomcat), l'auto-configuration et des starters (paquets de dépendances tout prêts). Résultat : on écrit une API REST en quelques lignes, sans configuration lourde.

Les trois idées à retenir :

• Starters — une dépendance = un ensemble cohérent (ex. spring-boot-starter-web apporte tout le nécessaire pour le web).
• Auto-configuration — Spring devine et configure les composants d'après les dépendances présentes.
• Serveur intégré — l'application est un simple .jar exécutable qui démarre son propre serveur sur le port 8080.

Créer un projet

On génère un projet vierge sur Spring Initializr (start.spring.io), en choisissant Java, Maven et les dépendances utiles.

Réglages conseillés

Project   : Maven          Language : Java (21)
Packaging : Jar            Dependencies : Spring Web

Structure générée (l'essentiel)

src/main/java/com/exemple/demo/
    DemoApplication.java     // point d'entrée
src/main/resources/
    application.properties   // configuration
pom.xml                      // dépendances Maven

Lancer l'application

La classe principale, annotée @SpringBootApplication, démarre tout. On l'exécute depuis l'IDE ou en ligne de commande.

La classe de démarrage

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Lancer en ligne de commande

mvn spring-boot:run

Résultat (console)

Premier contrôleur REST

Un contrôleur relie une URL à une méthode Java. @RestController déclare la classe ; @GetMapping associe une URL à une méthode répondant aux requêtes GET.

Exemple

@RestController
public class BonjourController {

    @GetMapping("/bonjour")
    public String bonjour() {
        return "Bonjour depuis Spring Boot !";
    }
}

Requête

GET http://localhost:8080/bonjour

Résultat

Renvoyer du JSON

Si une méthode renvoie un objet (ou une liste), Spring le convertit automatiquement en JSON. On utilise volontiers un record Java, concis et immuable.

Un record produit

public record Produit(int id, String nom, double prix) {}

Le contrôleur

@RestController
public class ProduitController {

    @GetMapping("/produits")
    public List<Produit> lister() {
        return List.of(
            new Produit(1, "Fioul 500L", 620.0),
            new Produit(2, "Fioul 1000L", 1180.0)
        );
    }
}

Résultat (réponse JSON)

Les paramètres d'URL

Deux façons de recevoir des valeurs : @PathVariable (dans le chemin) et @RequestParam (après le ?).

@PathVariable — une valeur dans le chemin

@GetMapping("/produits/{id}")
public String consulter(@PathVariable int id) {
    return "Produit demandé : " + id;
}
// GET /produits/2   →   "Produit demandé : 2"

@RequestParam — après le point d'interrogation

@GetMapping("/produits")
public String filtrer(@RequestParam String ville) {
    return "Filtre ville : " + ville;
}
// GET /produits?ville=Limoges   →   "Filtre ville : Limoges"

Recevoir des données (POST)

Pour créer une ressource, le client envoie un corps JSON en POST. @RequestBody transforme ce JSON en objet Java automatiquement.

Exemple

@PostMapping("/produits")
public String creer(@RequestBody Produit p) {
    return "Créé : " + p.nom() + " à " + p.prix() + " €";
}

Requête (corps JSON envoyé par le client)

POST http://localhost:8080/produits
Content-Type: application/json

{ "id": 3, "nom": "Fioul 2000L", "prix": 2300.0 }

Résultat

Les principaux verbes HTTP et leurs annotations :

Architecture en couches & injection

On ne met pas la logique dans le contrôleur : on la délègue à un service. Spring crée et fournit ces objets tout seul : c'est l'injection de dépendances (le contrôleur ne fait pas new).

Le service (@Service)

@Service
public class ProduitService {
    public List<Produit> lister() {
        return List.of(new Produit(1, "Fioul 500L", 620.0));
    }
}

Le contrôleur reçoit le service (injection par constructeur)

@RestController
public class ProduitController {
    private final ProduitService service;

    public ProduitController(ProduitService service) {  // injecté par Spring
        this.service = service;
    }

    @GetMapping("/produits")
    public List<Produit> lister() { return service.lister(); }
}

La configuration

Le fichier application.properties (ou .yml) centralise les réglages : port, connexion à la base, etc.

application.properties

server.port=8080
spring.application.name=fioul-api
spring.data.mongodb.uri=mongodb://localhost:27017/fioul

Documenter avec Swagger

Une seule dépendance (springdoc-openapi) génère une interface web qui documente et permet de tester l'API depuis le navigateur.

La dépendance (pom.xml)

<dependency>
  <groupId>org.springdoc</groupId>
  <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
  <version>2.6.0</version>
</dependency>

Résultat — sans aucune configuration

Ressources Spring Boot