O que é o padrão de projeto Factory Builder?

O padrão Factory Builder, ou melhor dizendo, Factory Method em combinação com Builder, é uma combinação de dois padrões que melhora a criação de objetos complexos.

Factory Method define uma interface para criar um objeto, mas permite que as subclasses decidam qual classe instanciar. Delegam a responsabilidade de criar o objeto às subclasses.

Builder separa a construção de um objeto complexo de sua representação, de modo que o mesmo processo de construção pode criar diferentes representações. Permite construir um objeto passo a passo, usando uma cadeia de chamadas de métodos.

A combinação desses padrões é frequentemente encontrada em cenários onde é necessário criar várias variantes de um objeto complexo. O Factory Method determina qual tipo de Builder deve ser usado, e o Builder então cuida de como criar esse objeto com diferentes configurações.

Exemplo de uso: Quando se tem uma hierarquia de classes de objetos que requerem inicialização complexa, e deseja-se criar esses objetos com configurações diferentes.

Estrutura típica de interação:

• Fábrica: Possui um método que retorna uma instância de um Builder específico, dependendo dos parâmetros de entrada ou do seu tipo.
• Builder: Possui métodos para configurar passo a passo os parâmetros do objeto complexo e um método final build(), que retorna o objeto pronto.
• Produto: O objeto complexo criado pelo Builder.

Vantagens:

• Melhor legibilidade e gerência do código na criação de objetos complexos.
• Flexibilidade na criação de diferentes configurações do mesmo tipo de objeto.
• Separação da lógica de criação do objeto de sua representação.
• Facilita a adição de novos tipos de produtos (usando Factory Method) ou novos métodos de construção (usando Builder).

Desvantagens:

• Aumento no número de classes no projeto.
• Pode ser excessivo para objetos simples.

Exemplo (pseudo-código):

// Produto
class ComplexObject {
    private String partA;
    private int partB;

    // construtor privado
    private ComplexObject(String partA, int partB) {
        this.partA = partA;
        this.partB = partB;
    }

    // Classe interna Builder
    public static class Builder {
        private String partA;
        private int partB;

        public Builder setPartA(String partA) {
            this.partA = partA;
            return this;
        }

        public Builder setPartB(int partB) {
            this.partB = partB;
            return this;
        }

        public ComplexObject build() {
            return new ComplexObject(partA, partB);
        }
    }
}

// Fábrica que retorna um Builder
class ComplexObjectFactory {
    public static ComplexObject.Builder createDefaultBuilder() {
        return new ComplexObject.Builder()
                .setPartA("defaultA")
                .setPartB(10);
    }

    public static ComplexObject.Builder createSpecialBuilder() {
        return new ComplexObject.Builder()
                .setPartA("specialA")
                .setPartB(50);
    }
}

// Uso:
// ComplexObject obj1 = ComplexObjectFactory.createDefaultBuilder().build();
// ComplexObject obj2 = ComplexObjectFactory.createSpecialBuilder().setPartA("customA").build();