Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Builder por etapas mediante interfaces

Un builder por etapas mediante interfaces divide la construcción de objetos en pasos tipados. Cada método de transición devuelve la interfaz de la etapa siguiente, por lo que en una cadena de llamadas normal `build()` solo está disponible después de proporcionar los datos requeridos. Esto no sustituye la validación de esos datos en tiempo de ejecución.

Versión: Java SE 21; repository runtime, production runtime not attested

Sintaxis

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

El builder por etapas mediante interfaces es un patrón de diseño, no una construcción propia del lenguaje Java. Las interfaces describen las operaciones disponibles en cada etapa. El tipo de retorno de un método guía al usuario hacia la etapa siguiente; la implementación puede ser un único objeto que implemente todas las interfaces de etapa.

En el ejemplo, builder() devuelve Start, host(String) devuelve PortStep y port(int) devuelve Ready. Solo Ready declara build(). Por tanto, builder().build() no compila, mientras que builder().host("localhost").port(8080).build() crea un Endpoint. Un builder fluent normal permite encadenar llamadas, pero devolver únicamente this no impone este orden.

Aquí los tipos imponen el orden de las llamadas, no la validez de los argumentos. Los métodos siguen comprobando que host no esté en blanco y que port esté dentro del rango permitido. La protección se aplica al usar los tipos de etapa declarados: las conversiones explícitas pueden eludir el recorrido previsto porque el objeto implementa todas las etapas. Por eso, build() también comprueba que estén presentes los valores necesarios.

La implementación privada oculta los detalles, pero el builder mutable no está pensado para compartirse entre hilos. Las referencias conservadas a etapas anteriores aún pueden modificarlo; las etapas no se consumen exactamente una vez. El Endpoint resultante almacena sus propios campos final. Usa este patrón para unos pocos pasos importantes; muchas combinaciones de campos necesarios pueden aumentar considerablemente el número de interfaces.

Ejemplos

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

Resultado

localhost:8080

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes