Padrões de Projetos - Builder

Afluentes: Modelos, métodos e técnicas da engenharia de software

Definição

O padrão de projeto Builder (ou Construtor em português) é um padrão criacional que separa a construção de um objeto complexo de sua representação final. Ele permite que o mesmo processo de construção crie diferentes representações do objeto, facilitando a criação de objetos com muitas opções ou parâmetros, sem sobrecarregar o construtor com muitos argumentos.

Objetivo

O principal objetivo do Builder é fornecer uma maneira flexível e controlada de criar objetos complexos, onde o processo de criação pode ser dividido em etapas, cada uma configurando uma parte específica do objeto. Isso é particularmente útil para objetos que têm muitos atributos opcionais ou para situações em que a criação envolve um processo complicado.

Componentes principais

• Builder (Construtor): Define uma interface que descreve como construir as diferentes partes de um objeto complexo.
• ConcreteBuilder (Construtor Concreto): Implementa a interface Builder e constrói as partes específicas do produto.
• Product (Produto): O objeto final que será construído.
• Director (Diretor): Opcionalmente, o Director é responsável por gerenciar o processo de construção e garantir que as diferentes partes do objeto sejam criadas em uma ordem específica.

Quando usar o Builder

• Quando a criação de um objeto é complicada e envolve muitos parâmetros opcionais.
• Quando o objeto é imutável, mas tem muitas configurações que precisam ser definidas no momento da construção.
• Quando há várias representações possíveis de um objeto (por exemplo, diferentes variações do mesmo tipo de produto).

Exemplo em Java

Imagine que estamos criando uma classe Carro que tem vários parâmetros opcionais, como modelo, ano, motor e cor. Em vez de ter um construtor com muitos parâmetros, podemos usar o padrão Builder para facilitar a construção do objeto.

Exemplo de um construtor de Carro:

// Produto: o objeto final que será construído
class Carro {
    private String modelo;
    private String cor;
    private int ano;
    private String motor;

    // Construtor privado para forçar a criação via Builder
    private Carro(CarroBuilder builder) {
        this.modelo = builder.modelo;
        this.cor = builder.cor;
        this.ano = builder.ano;
        this.motor = builder.motor;
    }

    @Override
    public String toString() {
        return "Carro [modelo=" + modelo + ", cor=" + cor + ", ano=" + ano + ", motor=" + motor + "]";
    }

    // Classe estática Builder
    public static class CarroBuilder {
        private String modelo;
        private String cor;
        private int ano;
        private String motor;

        // Métodos de configuração do Builder
        public CarroBuilder setModelo(String modelo) {
            this.modelo = modelo;
            return this;
        }

        public CarroBuilder setCor(String cor) {
            this.cor = cor;
            return this;
        }

        public CarroBuilder setAno(int ano) {
            this.ano = ano;
            return this;
        }

        public CarroBuilder setMotor(String motor) {
            this.motor = motor;
            return this;
        }

        // Método de construção que retorna o objeto final
        public Carro build() {
            return new Carro(this);
        }
    }
}

public class BuilderPatternDemo {
    public static void main(String[] args) {
        // Usando o Builder para construir um objeto Carro
        Carro carro = new Carro.CarroBuilder()
                            .setModelo("SUV")
                            .setCor("Preto")
                            .setAno(2023)
                            .setMotor("V8")
                            .build();

        System.out.println(carro);
    }
}

Explicação

1. Produto (Carro): A classe Carro é o objeto que será construído. Ela tem muitos atributos opcionais (modelo, cor, ano, motor). O construtor de Carro é privado para garantir que ele só possa ser criado pelo CarroBuilder.
2. Builder (CarroBuilder): A classe interna CarroBuilder tem métodos para configurar cada atributo do Carro. Esses métodos retornam o próprio builder (com return this;), permitindo encadear chamadas (técnica chamada de fluent interface).
3. Método build(): O método build() no CarroBuilder é o responsável por criar o objeto Carro final, passando o builder como argumento para o construtor privado de Carro.
4. Cliente: O código no main demonstra como usar o CarroBuilder para configurar um objeto Carro e depois construí-lo.

Vantagens do Builder

• Código mais legível: Permite a criação de objetos complexos com código que é mais fácil de entender, especialmente quando há muitos parâmetros opcionais.
• Flexibilidade: O processo de construção pode ser personalizado ou dividido em várias etapas.
• Imutabilidade: Pode ser usado para construir objetos imutáveis, pois o objeto final é completamente configurado antes de ser criado.
• Evitam construtores longos: Em vez de usar um construtor com muitos parâmetros, o Builder permite definir parâmetros de maneira flexível.

Desvantagens do Builder

• Mais código: Implementar o padrão Builder pode resultar em mais classes e código, o que pode parecer um overhead em casos simples.
• Necessidade de configuração: Para objetos relativamente simples, a configuração adicional do Builder pode não ser justificada.

Quando não usar o Builder

• Quando a criação de objetos é simples e envolve poucos parâmetros.
• Quando não há necessidade de criar diferentes variações do objeto.

Aplicações comuns

O padrão Builder é amplamente utilizado para a criação de objetos que possuem muitos parâmetros opcionais, como:

• Objetos de configuração em APIs e frameworks.
• Criação de objetos complexos como carros, casas, ou documentos.
• Em bibliotecas como o próprio Java, o padrão Builder é utilizado em classes como StringBuilder (embora tecnicamente não seja o padrão formal de design "Builder", ele oferece uma interface fluente similar).

Resumo

O padrão Builder é um padrão criacional que facilita a construção de objetos complexos, separando o processo de construção em etapas configuráveis. Ele permite criar diferentes representações de um objeto, tornando o código mais legível e flexível, especialmente quando há muitos atributos opcionais ou parâmetros.