¿Qué es el patrón de diseño Factory Builder?

El patrón Factory Builder, o más bien Factory Method en combinación con Builder, es una combinación de dos patrones que mejora la creación de objetos complejos.

Factory Method define una interfaz para crear un objeto, pero permite a las subclases decidir qué clase instanciar. Delegan la responsabilidad de crear el objeto a las clases hijas.

Builder separa la construcción de un objeto complejo de su representación, de modo que el mismo proceso de construcción puede crear diferentes representaciones. Permite construir un objeto paso a paso, usando una cadena de llamadas a métodos.

La combinación de estos patrones se encuentra con mayor frecuencia en escenarios donde se necesita crear varias variantes de un objeto complejo. Factory Method determina qué tipo de Builder debe usarse, y luego el Builder se encarga de cómo crear ese objeto con diferentes configuraciones.

Ejemplo de uso: Cuando tienes una jerarquía de clases de objetos que requieren una inicialización compleja, y quieres crear estos objetos con diferentes configuraciones.

Estructura típica de interacción:

• Fábrica: Tiene un método que devuelve una instancia de un Builder específico dependiendo de los parámetros de entrada o de su tipo.
• Builder: Tiene métodos para configurar paso a paso los parámetros del objeto complejo y un método final build(), que devuelve el objeto listo.
• Producto: El objeto complejo que es creado por el Builder.

Ventajas:

• Mejor legibilidad y manejabilidad del código al crear objetos complejos.
• Flexibilidad para crear diferentes configuraciones del mismo tipo de objeto.
• Separación de la lógica de creación del objeto de su representación.
• Facilita la adición de nuevos tipos de productos (usando Factory Method) o nuevos métodos de construcción (usando Builder).

Desventajas:

• Aumento en la cantidad de clases en el proyecto.
• Puede ser excesivo para objetos simples.

Ejemplo (pseudocódigo):

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

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

    // Clase 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 devuelve un 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();