Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Builder par étapes avec des interfaces

Un builder par étapes avec des interfaces divise la construction d’un objet en étapes typées. Chaque méthode de transition renvoie l’interface de l’étape suivante, de sorte que, dans une chaîne d’appels ordinaire, `build()` n’est disponible qu’une fois les données requises fournies. Cela ne remplace pas la validation de ces données à l’exécution.

Version : Java SE 21; repository runtime, production runtime not attested

Syntaxe

Start builder() → Start.host(String) : PortStep → PortStep.port(int) : Ready → Ready.build() : Endpoint

Le builder par étapes avec des interfaces est un patron de conception, et non une construction propre au langage Java. Les interfaces décrivent les opérations disponibles à chaque étape. Le type de retour d’une méthode guide l’appelant vers l’étape suivante ; l’implémentation peut être un seul objet qui implémente toutes les interfaces d’étape.

Dans l’exemple, builder() renvoie Start, host(String) renvoie PortStep et port(int) renvoie Ready. Seul Ready déclare build(). Par conséquent, builder().build() ne compile pas, tandis que builder().host("localhost").port(8080).build() crée un Endpoint. Un builder fluent ordinaire permet d’enchaîner les appels, mais le simple fait de renvoyer this n’impose pas cet ordre.

Les types imposent ici l’ordre des appels, et non la validité des arguments. Les méthodes vérifient toujours que host n’est pas vide et que port se trouve dans la plage autorisée. Cette protection s’applique lorsque les types d’étape déclarés sont utilisés : des conversions explicites peuvent contourner le parcours prévu, car l’objet implémente toutes les étapes. build() vérifie donc aussi la présence des valeurs requises.

L’implémentation privée masque les détails, mais le builder mutable n’est pas destiné à être partagé entre plusieurs threads. Des références conservées vers des étapes antérieures peuvent toujours le modifier ; les étapes ne sont pas consommées une seule fois. L’Endpoint obtenu stocke ses propres champs final. Utilisez ce patron pour quelques étapes pertinentes ; de nombreuses combinaisons de champs requis peuvent augmenter considérablement le nombre d’interfaces.

Exemples

public final class Main {
    public interface Start {
        PortStep host(String host);
    }

    public interface PortStep {
        Ready port(int port);
    }

    public interface Ready {
        Endpoint build();
    }

    public static final class Endpoint {
        private final String host;
        private final int port;

        private Endpoint(String host, int port) {
            this.host = host;
            this.port = port;
        }

        @Override
        public String toString() {
            return host + ":" + port;
        }
    }

    private static final class Builder implements Start, PortStep, Ready {
        private String host;
        private int port;

        @Override
        public PortStep host(String host) {
            if (host == null || host.isBlank()) {
                throw new IllegalArgumentException("host must not be blank");
            }
            this.host = host;
            return this;
        }

        @Override
        public Ready port(int port) {
            if (port < 1 || port > 65535) {
                throw new IllegalArgumentException("port out of range");
            }
            this.port = port;
            return this;
        }

        @Override
        public Endpoint build() {
            if (host == null || port == 0) {
                throw new IllegalStateException("missing required values");
            }
            return new Endpoint(host, port);
        }
    }

    public static Start builder() {
        return new Builder();
    }

    public static void main(String[] args) {
        Endpoint endpoint = builder().host("localhost").port(8080).build();
        System.out.println(endpoint);
        // builder().build(); // Does not compile: Start has no build().
    }
}

Résultat

localhost:8080

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources