Comment créer une API Micronaut en 2026 (Tutoriel)

Introduction

Micronaut est un framework JVM moderne, conçu pour les microservices et les applications serverless. Contrairement à Spring Boot, il compile en AOT (Ahead-Of-Time), ce qui réduit drastiquement la consommation mémoire et le temps de démarrage – idéal pour Kubernetes ou les fonctions cloud. En 2026, avec Java 21+, Micronaut excelle dans les APIs REST scalables, les GraphQL et les gRPC.

Ce tutoriel beginner vous guide pas à pas pour créer une API REST complète : un endpoint GET listant des utilisateurs, un POST pour en ajouter, avec un service métier injecté. Vous apprendrez l'injection de dépendances native, les annotations réactives et le hot-reload. À la fin, votre app sera production-ready, testable en 5 minutes. Pourquoi c'est crucial ? Les frameworks legacy comme Spring pèsent lourd ; Micronaut démarre en <100ms et consomme <50MB RAM. Parfait pour les devs Java voulant booster leurs perf sans réécrire tout.

Prérequis

Java 17 ou supérieur (idéalement 21+ pour les virtual threads)
SDKMAN installé pour gérer les outils CLI
Un IDE comme IntelliJ IDEA Community (gratuit) avec plugin Micronaut
Connaissances de base en Java et HTTP (REST)
Terminal (bash/zsh sur macOS/Linux, Git Bash sur Windows)

Installer Micronaut CLI

terminal-install.sh

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk version
sdk install java 21.0.4-tem
sdk install micronaut
mn --version

Ce script installe SDKMAN, Java 21 et Micronaut CLI (version 4+ en 2026). Exécutez-le une seule fois. Vérifiez avec mn --version : vous devez voir 4.x.x. Évitez les installations manuelles pour les mises à jour automatiques.

Créer le projet de base

Nous utilisons la CLI pour générer un squelette HTTP-ready. Cela crée un projet Gradle avec tout le nécessaire : build.gradle, Application.java et hot-reload via DevTools.

Générer l'application

terminal-create.sh

mn create-app ma-premiere-api --features http,graalvm --build=gradle --lang=java
cd ma-premiere-api
gradle build

Crée un projet avec support HTTP et GraalVM (pour native image). --lang=java force Java pur. gradle build compile et teste. Le dossier src/main est prêt. Piège : n'oubliez pas cd avant build.

Créer le contrôleur API

src/main/java/example/UserController.java

package example;

import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.Post;
import io.micronaut.http.annotation.Body;

import java.util.List;
import java.util.ArrayList;

@Controller("/users")
public class UserController {

    private List<String> users = new ArrayList<>();

    @Get
    public List<String> list() {
        return users;
    }

    @Post
    public String add(@Body String name) {
        users.add(name);
        return "User " + name + " added";
    }
}

Ce contrôleur expose /users (GET liste, POST ajoute). Annotations Micronaut gèrent routing et binding auto. Liste en mémoire pour simplicité. Piège : toujours spécifier package ; testez sans DB d'abord.

Ajouter un service métier

Pour découpler, injectons un service via @Inject. Cela démontre le DI zero-config de Micronaut, sans XML ni scans.

Implémenter le service UserService

src/main/java/example/UserService.java

package example;

import jakarta.inject.Singleton;

import java.util.List;
import java.util.ArrayList;

@Singleton
public class UserService {

    private List<String> users = new ArrayList<>();

    public List<String> list() {
        return new ArrayList<>(users); // Defensive copy
    }

    public String add(String name) {
        users.add(name);
        return "User " + name + " added";
    }
}

@Singleton enregistre le bean auto. Méthodes simples avec copie défensive pour thread-safety. En prod, remplacez par une DB comme PostgreSQL. Avantage : injecté partout sans config.

Mettre à jour le contrôleur avec injection

src/main/java/example/UserController.java

package example;

import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.Post;
import io.micronaut.http.annotation.Body;

import jakarta.inject.Inject;

import java.util.List;

@Controller("/users")
public class UserController {

    @Inject
    private UserService userService;

    @Get
    public List<String> list() {
        return userService.list();
    }

    @Post
    public String add(@Body String name) {
        return userService.add(name);
    }
}

Injection via @Inject – Micronaut résout au runtime/AOT. Contrôleur plus fin : délègue au service. Piège : import jakarta.inject.Inject (pas javax en 2026). Hot-reload auto en dev.

Lancer et tester l'API

Compilez, lancez en mode dev et testez avec curl. L'app écoute sur port 8080 par défaut.

Lancer et tester

terminal-run-test.sh

gradle run --continuous

# Dans un autre terminal :
curl http://localhost:8080/users
curl -X POST -H "Content-Type: text/plain" -d "Alice" http://localhost:8080/users
curl http://localhost:8080/users

--continuous active hot-reload. Premier curl : []. POST ajoute Alice, second : [Alice]. Arrêtez avec Ctrl+C. Piège : port libre ; utilisez gradle micronautFeatureAot:compile pour AOT.

Compiler en native (optionnel)

terminal-native.sh

gradle nativeCompile
./build/native/nativeCompile/ma_premiere_api

Compile en executable natif GraalVM (<50MB, startup 10ms). Nécessite GraalVM installé via SDKMAN. Testez endpoints identiques. Idéal pour Docker/K8s en 2026.

Bonnes pratiques

Utilisez toujours des singletons pour services : Micronaut optimise la portée par défaut.
Activez validation : Ajoutez @Valid sur @Body avec Bean Validation 3.0.
Sécurisez tôt : Intégrez Micronaut Security avec --features jwt dès le create-app.
Tests unitaires : Écrivez avec @MicronautTest pour mock auto.
Logs structurés : Configurez SLF4J + JSON en application.yml.

Erreurs courantes à éviter

Oublier @Inject : NoSuchBeanException au runtime – toujours injecter explicitement.
Java <17 : Erreurs de compatibilité ; vérifiez sdk current java.
Pas de hot-reload : Utilisez gradle run --continuous, pas java -jar.
CORS ignoré : Ajoutez @CrossOrigin sur controller pour frontend.

Pour aller plus loin

Maîtrisez Micronaut avec notre formation Java Avancé. Lisez la doc officielle et explorez Data, Security, Kubernetes. Essayez Micronaut Launch online pour prototypes rapides.

Comment créer une première API Micronaut en 2026