Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Builder a fasi tramite interfacce

Un builder a fasi tramite interfacce suddivide la costruzione di un oggetto in passaggi tipizzati. Ogni metodo di transizione restituisce l’interfaccia della fase successiva, quindi in una normale catena di chiamate `build()` è disponibile solo dopo aver fornito i dati richiesti. Questo non sostituisce la convalida a runtime di tali dati.

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

Sintassi

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

Il builder a fasi tramite interfacce è un pattern di progettazione, non una funzionalità specifica del linguaggio Java. Le interfacce descrivono le operazioni disponibili in ogni fase. Il tipo restituito da un metodo guida il chiamante verso la fase successiva; l’implementazione può essere un unico oggetto che implementa tutte le interfacce di fase.

Nell’esempio, builder() restituisce Start, host(String) restituisce PortStep e port(int) restituisce Ready. Solo Ready dichiara build(). Di conseguenza, builder().build() non viene compilato, mentre builder().host("localhost").port(8080).build() crea un Endpoint. Un normale builder fluent consente di concatenare le chiamate, ma restituire semplicemente this non impone quest’ordine.

Qui i tipi impongono l’ordine delle chiamate, non la validità degli argomenti. I metodi continuano a verificare che host non sia vuoto e che port rientri nell’intervallo consentito. La protezione vale quando si usano i tipi di fase dichiarati: i cast espliciti possono aggirare il percorso previsto, perché l’oggetto implementa tutte le fasi. Perciò build() verifica anche che siano presenti i valori richiesti.

L’implementazione privata nasconde i dettagli, ma il builder mutabile non è pensato per essere condiviso tra thread. I riferimenti conservati alle fasi precedenti possono ancora modificarlo; le fasi non vengono consumate una sola volta. L’Endpoint risultante memorizza campi final propri. Usa questo pattern per pochi passaggi significativi; molte combinazioni di campi richiesti possono aumentare notevolmente il numero di interfacce.

Esempi

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().
    }
}

Risultato

localhost:8080

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti