Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Builder por etapas através de interfaces

Um builder por etapas através de interfaces divide a construção de objetos em passos tipados. Cada método de transição devolve a interface da etapa seguinte, pelo que, numa cadeia normal de chamadas, `build()` só fica disponível depois de serem fornecidos os dados necessários. Isto não substitui a validação desses dados em tempo de execução.

Versão: Java SE 21; repository runtime, production runtime not attested

Sintaxe

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

O builder por etapas através de interfaces é um padrão de conceção, não uma construção própria da linguagem Java. As interfaces descrevem as operações disponíveis em cada etapa. O tipo devolvido por um método orienta quem o chama para a etapa seguinte; a implementação pode ser um único objeto que implementa todas as interfaces das etapas.

No exemplo, builder() devolve Start, host(String) devolve PortStep e port(int) devolve Ready. Só Ready declara build(). Assim, builder().build() não compila, ao passo que builder().host("localhost").port(8080).build() cria um Endpoint. Um builder fluent normal permite encadear chamadas, mas devolver apenas this não impõe esta ordem.

Aqui, os tipos impõem a ordem das chamadas, não a validade dos argumentos. Os métodos continuam a verificar se host não está em branco e se port está dentro do intervalo permitido. A proteção aplica-se quando se usam os tipos de etapa declarados: conversões explícitas podem contornar o percurso previsto, porque o objeto implementa todas as etapas. Por isso, build() também verifica se os valores necessários estão presentes.

A implementação privada oculta os detalhes, mas o builder mutável não se destina a ser partilhado entre threads. As referências guardadas a etapas anteriores ainda o podem modificar; as etapas não são consumidas uma única vez. O Endpoint resultante guarda os seus próprios campos final. Use este padrão para alguns passos importantes; muitas combinações de campos obrigatórios podem aumentar consideravelmente o número de interfaces.

Exemplos

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

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes