Modèle Builder avec API fluide
Construisez des objets complexes étape par étape avec un builder fluide afin d’éviter les constructeurs télescopiques.
Modèle Builder avec API fluide est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.
Le problème des constructeurs télescopiques
Lorsqu’une classe possède de nombreux paramètres facultatifs, les constructeurs se multiplient : à 2 paramètres, à 3 paramètres, à 4 paramètres… Le modèle Builder résout ce problème grâce à une API de configuration fluide, étape par étape.
// Without builder — hard to read:
Pizza p = new Pizza("large", "thin", true, false, true, false, "mozzarella");Structure de base de Builder
Créez une classe Builder imbriquée statique. La classe externe possède un constructeur privé qui reçoit le builder. Chaque méthode de définition du builder renvoie this pour permettre l’enchaînement fluide des appels.
public final class Pizza {
private final String size, crustType, cheese;
private final boolean extraSauce, pepperoni;
private Pizza(Builder b) {
this.size = b.size; this.crustType = b.crustType;
this.cheese = b.cheese; this.extraSauce = b.extraSauce;
this.pepperoni = b.pepperoni;
}
public static class Builder {
private final String size;
private String crustType = "regular", cheese = "mozzarella";
private boolean extraSauce, pepperoni;
public Builder(String size) { this.size = size; }
public Builder crustType(String c) { this.crustType = c; return this; }
public Builder cheese(String c) { this.cheese = c; return this; }
public Builder extraSauce() { this.extraSauce = true; return this; }
public Builder pepperoni() { this.pepperoni = true; return this; }
public Pizza build() { return new Pizza(this); }
}
}Utilisation d’une API fluide
Le builder se lit comme une phrase. Placez les paramètres obligatoires dans le constructeur, et utilisez des appels de méthode pour les paramètres facultatifs. L’appel final à build() produit l’objet immuable.
Pizza p = new Pizza.Builder("large")
.crustType("thin")
.extraSauce()
.pepperoni()
.build();
System.out.println(p);Validation dans build()
Ajoutez la logique de validation dans build() avant de construire l’objet. Lancez IllegalStateException ou IllegalArgumentException pour les combinaisons non valides.
public Pizza build() {
if (size == null || size.isBlank())
throw new IllegalArgumentException("Size required");
if (extraSauce && crustType.equals("stuffed"))
throw new IllegalStateException("No extra sauce on stuffed crust");
return new Pizza(this);
}Builder pour les objets immuables
Comme la classe externe est créée en une seule fois à partir du builder, tous les champs peuvent être final, ce qui rend l’objet obtenu entièrement immuable et sûr pour les threads.
public final class Address {
private final String street, city, country;
private final String postalCode;
private Address(Builder b) { ... } // all finals
// no setters — immutable!
}Builder générique avec le type SELF
Pour les hiérarchies d’héritage, utilisez un paramètre de type générique récursif (SELF extends Builder<SELF>) afin que les builders des sous-classes renvoient le type de la sous-classe dans les méthodes enchaînées.
public abstract static class Builder<SELF extends Builder<SELF>> {
String name;
@SuppressWarnings("unchecked")
public SELF name(String n) { this.name = n; return (SELF) this; }
public abstract Vehicle build();
}Lombok @Builder
@Builder de Lombok génère toute l’infrastructure du builder lors de la compilation. Utilisez @Builder.Default pour les valeurs par défaut des champs et @Singular pour les collections.
@Builder
public class Report {
private final String title;
@Builder.Default private final int pageCount = 1;
@Singular private final List<String> authors;
}
// Usage:
Report r = Report.builder().title("Q4").author("Alice").author("Bob").build();Builder dans le JDK
De nombreuses classes du JDK utilisent des API de style builder : StringBuilder, HttpRequest.newBuilder(), ProcessBuilder, Stream.Builder. Sachez reconnaître ce modèle.
HttpRequest req = HttpRequest.newBuilder()
.uri(URI.create("https://api.example.com/users"))
.header("Accept", "application/json")
.GET()
.build();Builder et fabrique
Utilisez Builder lorsqu’un objet exige de nombreux paramètres et une configuration étape par étape. Utilisez une fabrique lorsque toutes les variantes sont simples et que la création peut être effectuée en un seul appel.
Builder pour les données de test
Les builders sont particulièrement utiles dans les tests : créez un builder de base dans un utilitaire, puis remplacez uniquement les champs pertinents pour chaque cas de test, afin de garder les tests DRY et lisibles.
User defaultUser() { return new User.Builder("test@example.com").name("Test User").build(); }
User adminUser() { return new User.Builder("admin@example.com").name("Admin").role(ADMIN).build(); }Sécurité des threads
Le builder lui-même n’est pas sûr pour les threads : ne partagez pas un Builder entre plusieurs threads. Le produit construit à partir de celui-ci peut être immuable et sûr pour les threads si tous les champs sont finaux et qu’aucun objet mutable n’est partagé.
Vérification rapide
Qu’est-ce qui rend une méthode de builder « fluide » ?
Récapitulatif
Builder résout le problème des constructeurs télescopiques. Utilisez une classe Builder imbriquée statique, renvoyez this depuis chaque méthode de définition, validez dans build() et produisez un objet immuable. Lombok @Builder automatise le code répétitif.
Questions Fréquemment Posées
La leçon « Modèle Builder avec API fluide » est-elle gratuite ?
Oui — le texte complet de « Modèle Builder avec API fluide » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Modèle Builder avec API fluide » ?
Construisez des objets complexes étape par étape avec un builder fluide afin d’éviter les constructeurs télescopiques. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Java Academy ?
Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Modèle Builder avec API fluide » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?
Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Singleton : implémentations sûres vis-à-vis des threads
- Modèle de méthode de fabrique
- Fabrique abstraite pour des familles de produits
- Modèle Builder avec API fluide