Spring Boot pour la création de services web : quand votre API se réveille avant vous

Spring Boot est depuis longtemps ce collègue qui arrive au bureau avant tout le monde, a déjà démarré le serveur, réglé la configuration, préparé les logs et vous regarde avec un reproche silencieux pendant que vous ouvrez encore votre IDE. Pour la création de services web, il est idéal précisément parce qu'il élimine une grande partie du travail d'infrastructure routinier : moins de XML, moins de câblage manuel des composants, et moins de danses rituelles autour du conteneur de servlets.

Au cœur de l'approche Spring Boot se trouve l'idée de convention over configuration (la convention plutôt que la configuration) : si le projet ressemble à une application web, se comporte comme une application web et possède la dépendance spring-boot-starter-web, le framework ne vous fait pas subir un interrogatoire musclé, mais lance simplement un serveur embarqué, enregistre les beans standards et permet de publier rapidement des points de terminaison HTTP.

Pourquoi Spring Boot est pratique pour les services web

La création classique d'une application web Java ressemblait autrefois à l'assemblage d'une station spatiale avec un tournevis trouvé dans une boîte de céréales. Il fallait configurer le conteneur, les descripteurs de déploiement, les versions des bibliothèques et n'oublier aucune ligne magique, sinon tout fonctionnait... jusqu'au moment de la démonstration.

Spring Boot change la donne avec plusieurs mécanismes puissants :

• Auto-configuration — le framework analyse le classpath et crée automatiquement les réglages par défaut.
• Dépendances Starter — au lieu de choisir manuellement des dizaines de bibliothèques, on utilise des ensembles prêts à l'emploi.
• Serveur embarqué (Embedded server) — Tomcat, Jetty ou Undertow démarrent directement avec l'application.
• Actuator — fournit des métriques, des bilans de santé (health checks) et des points de terminaison techniques.
• Configuration externe — les paramètres sont facilement déportés dans application.yml ou des variables d'environnement.

Une dépendance de démarrage typique pour une API HTTP ressemble à ceci :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Après cela, l'application est déjà presque prête à prétendre être un microservice de classe mondiale, même si elle ne sait pour l'instant que répondre "OK".

Structure de base de l'application

Une application Spring Boot minimale se compose d'une classe principale et d'un contrôleur. La classe principale est annotée avec @SpringBootApplication, qui combine plusieurs mécanismes importants : la configuration, le scan de composants et l'auto-configuration.

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

Un contrôleur pour un service web simple peut ressembler à ceci :

@RestController
@RequestMapping("/api")
public class HelloController {

    @GetMapping("/hello")
    public Map<String, String> hello() {
        return Map.of("message", "Salut depuis Spring Boot");
    }
}

Dans cet exemple :

• @RestController indique que les méthodes renvoient des données directement dans la réponse HTTP.
• @RequestMapping("/api") définit le chemin de base.
• @GetMapping("/hello") gère la requête GET.
• Map est automatiquement sérialisé en JSON via Jackson.

Et voilà, quelques lignes suffisent pour que le serveur commence à communiquer en JSON avec autant d'assurance que s'il était né dans un data center.

Création d'une API REST

Spring Boot est particulièrement populaire pour les API REST. L'approche typique consiste à diviser les responsabilités entre les couches :

• Controller — reçoit les requêtes HTTP.
• Service — contient la logique métier.
• Repository — interagit avec la base de données.

Par exemple, un service de gestion de livres :

@RestController
@RequestMapping("/api/books")
public class BookController {

    private final BookService bookService;

    public BookController(BookService bookService) {
        this.bookService = bookService;
    }

    @GetMapping
    public List<BookDto> findAll() {
        return bookService.findAll();
    }

    @PostMapping
    public BookDto create(@RequestBody CreateBookRequest request) {
        return bookService.create(request);
    }
}

La couche service :

@Service
public class BookService {

    public List<BookDto> findAll() {
        return List.of(
            new BookDto(1L, "Spring in Action"),
            new BookDto(2L, "Comment ne pas casser la prod un vendredi")
        );
    }

    public BookDto create(CreateBookRequest request) {
        return new BookDto(3L, request.title());
    }
}

Cette séparation aide à :

• faciliter les tests ;
• isoler la logique métier ;
• éviter de transformer le contrôleur en un entrepôt universel pour tout ce qui passe par le projet.

Validation des requêtes

Quand un service web commence à recevoir des données du monde extérieur, il faut être prêt à ce que ce dernier envoie des choses surprenantes : des champs vides, un prix négatif, une date de naissance en 3027 ou un nom de 9000 caractères, comme si l'utilisateur s'était endormi sur son clavier.

Spring Boot s'intègre parfaitement avec Bean Validation :

public record CreateBookRequest(
    @NotBlank String title,
    @NotNull @Positive BigDecimal price
) {}

Dans le contrôleur :

@PostMapping
public BookDto create(@Valid @RequestBody CreateBookRequest request) {
    return bookService.create(request);
}

Si les données ne passent pas la validation, le framework renverra une erreur 400 Bad Request. Pour des réponses plus propres, il est conseillé d'ajouter une gestion globale des exceptions via @ControllerAdvice.

Travailler avec une base de données

Pour accéder à la base de données, on utilise souvent Spring Data JPA. Cela permet de décrire une entité, un dépôt (repository) et d'effectuer des opérations classiques presque sans code "boilerplate".

Entité :

@Entity
public class Book {

    @Id
    @GeneratedValue
    private Long id;

    private String title;

    protected Book() {}

    public Book(String title) {
        this.title = title;
    }

    public Long getId() { return id; }
    public String getTitle() { return title; }
}

Dépôt :

public interface BookRepository extends JpaRepository<Book, Long> {
}

Configuration dans application.yml :

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/app
    username: app
    password: secret
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

Cela permet de connecter rapidement PostgreSQL, H2 ou une autre base. L'important est de ne pas utiliser ddl-auto: update en production sans réfléchir, car le schéma de base de données mérite respect, mémoire et plan de migration, plutôt que des surprises soudaines à trois heures du matin.

Configuration et profils

Spring Boot permet de gérer la configuration de manière flexible via :

• application.properties
• application.yml
• les variables d'environnement
• les profils d'environnement (dev, test, prod)

Exemple :

server:
  port: 8081

spring:
  profiles:
    active: dev

On peut créer séparément un application-dev.yml et un application-prod.yml pour :

• utiliser une base locale en dev ;
• une base en mémoire en test ;
• une vraie configuration en prod, sans improvisations du style "laissons juste temporairement le mot de passe admin/admin".

Pour une configuration typée, il est pratique d'utiliser @ConfigurationProperties :

@ConfigurationProperties(prefix = "app")
public record AppProperties(String title, String version) {
}

Gestion des erreurs

Un service web de qualité se distingue non seulement par le fait qu'il fonctionne, mais aussi par sa manière de se tromper : avec élégance, de façon prévisible et sans agressivité passive. Au lieu de renvoyer des stack traces chaotiques, il vaut mieux retourner un JSON structuré.

Exemple de gestionnaire global :

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(EntityNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public Map<String, String> handleNotFound(EntityNotFoundException ex) {
        return Map.of("error", ex.getMessage());
    }
}

Cela rend l'API plus compréhensible pour les clients et réduit considérablement les situations où l'équipe frontend regarde la réponse du serveur comme des archéologues face à une tablette mystérieuse d'une civilisation inconnue.

Tester les services web

Spring Boot offre un excellent support pour les tests. On peut tester :

• des classes isolées avec JUnit et Mockito ;
• la couche web via @WebMvcTest ;
• des scénarios d'intégration avec @SpringBootTest.

Exemple d'un test de contrôleur :

@WebMvcTest(BookController.class)
class BookControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private BookService bookService;

    @Test
    void shouldReturnBooks() throws Exception {
        when(bookService.findAll())
            .thenReturn(List.of(new BookDto(1L, "Test Book")));

        mockMvc.perform(get("/api/books"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$[0].title").value("Test Book"));
    }
}

Cette approche permet de vérifier le comportement HTTP sans démarrer toute l'infrastructure. Ce qui, à son tour, préserve le système nerveux du build et réduit la probabilité qu'un seul test dure plus longtemps qu'un hiver moyen.

Surveillance et fonctionnalités prêtes pour la production

Pour les services web réels, la "surveillabilité" (observability) est cruciale. C'est là que Spring Boot Actuator entre en jeu.

Dépendance :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Points de terminaison utiles :

• /actuator/health
• /actuator/info
• /actuator/metrics
• /actuator/prometheus

Actuator permet de :

• vérifier l'état du service ;
• s'intégrer avec Prometheus et Grafana ;
• visualiser les métriques de la JVM, des requêtes HTTP, des pools de connexions.

La production aime le calme, les métriques et les comportements prévisibles. Elle n'aime pas les phrases "ça marche sur ma machine" ou "c'est très bizarre", surtout lorsqu'elles sont prononcées lors du même appel.

Avantages et défis typiques

Avantages

• démarrage rapide du projet ;
• minimum de configuration manuelle ;
• intégration aisée avec l'écosystème Spring ;
• excellent support pour les tests ;
• prêt pour la production grâce à Actuator, aux logs, aux profils et aux métriques.

Défis

• magie excessive de l'auto-configuration si l'on ne comprend pas ce qui se passe réellement ;
• risque de créer un monolithe "obèse" avec des centaines de beans ;
• nécessité de contrôler le temps de démarrage et l'utilisation de la mémoire ;
• complexité du diagnostic quand quelque chose s'est "configuré tout seul" différemment de ce qui était attendu.

Spring Boot accélère merveilleusement le développement, mais il ne dispense pas de réflexion architecturale. Si l'on empile tout n'importe comment dans un service, même l'auto-configuration la plus élégante finira par s'essouffler.

Conclusion

Spring Boot est l'un des outils les plus efficaces pour créer des services web en Java. Il offre un démarrage rapide, un modèle de développement pratique et une intégration puissante avec REST, la validation, l'accès aux données, les tests et la surveillance. Pour une équipe, cela signifie moins de temps passé sur des détails d'infrastructure et plus de temps sur la création de fonctionnalités métier.

En résumé, Spring Boot permet de bâtir un service web pour qu'il ait l'air sérieux, fonctionne de manière stable et n'exige pas du développeur une sorcellerie quotidienne sur les fichiers de configuration. Et dans le développement moderne, c'est presque devenu une forme de luxe pour ingénieur.