El patrón de diseño Builder se utiliza para construir objetos complejos de forma incremental, permitiendo la creación de diferentes representaciones de un objeto utilizando el mismo proceso de construcción. En este artículo, exploraremos cómo implementar el patrón Builder en Golang, comprenderemos sus beneficios y analizaremos un ejemplo práctico de uso.

¿Qué es el constructor?

El patrón Builder separa la construcción de un objeto complejo de su representación, permitiendo que el mismo proceso de construcción cree diferentes representaciones. Esto es especialmente útil cuando es necesario crear un objeto en varios pasos o con múltiples configuraciones posibles.

Beneficios del constructor

• Separación de Construcción y Representación: Permite separar la construcción de un objeto de su representación final.
• Construcción Incremental: Permite la construcción de objetos complejos de forma incremental y paso a paso.
• Reutilización de código: facilita la reutilización de código al definir pasos de compilación comunes que se pueden combinar de múltiples maneras.

Implementando un constructor

Para implementar nuestro Builder, imaginemos un objeto complejo donde será necesario inicializar varios campos e incluso otros objetos agrupados. ¿Qué tal una casa? Donde tendremos dos tipos de construcción, una convencional donde se utilizará hormigón y ladrillos, y una segunda hecha de madera.

1 - Definición de la estructura

Primero, necesitamos definir la estructura del objeto que queremos construir. Como dije antes, vamos a construir una casa. Dentro de este Struct colocaremos lo necesario para crear uno.

// house.go

package main

type House struct {
    Foundation string
    Structure  string
    Roof       string
    Interior   string
}

2 - Definición de la interfaz del constructor

Aún en el mismo archivo, definiremos nuestra interfaz Builder que especifica los métodos necesarios para construir las diferentes partes de la Casa.

//house.go

package main

type House struct {
    Foundation string
    Structure  string
    Roof       string
    Interior   string
}

type HouseBuilder interface {
    SetFoundation()
    SetStructure()
    SetRoof()
    SetInterior()
    GetHouse() House
}

3 - Implementación concreta del Builder

Creemos dos archivos nuevos, concreteHouse y woodHouse. Serán la implementación de una clase concreta que sigue la interfaz HouseBuilder.

//concreteHouse.go

package main

type ConcreteHouseBuilder struct {
    house House
}

func (b *ConcreteHouseBuilder) SetFoundation() {
    b.house.Foundation = "Concrete, brick, and stone"
}

func (b *ConcreteHouseBuilder) SetStructure() {
    b.house.Structure = "Wood and brick"
}

func (b *ConcreteHouseBuilder) SetRoof() {
    b.house.Roof = "Concrete and reinforced steel"
}

func (b *ConcreteHouseBuilder) SetInterior() {
    b.house.Interior = "Gypsum board, plywood, and paint"
}

func (b *ConcreteHouseBuilder) GetHouse() House {
    return b.house
}

//woodHouse.go

package main

type WoodHouseBuilder struct {
    house House
}

func (b *WoodHouseBuilder) SetFoundation() {
    b.house.Foundation = "Wooden piles"
}

func (b *WoodHouseBuilder) SetStructure() {
    b.house.Structure = "Wooden frame"
}

func (b *WoodHouseBuilder) SetRoof() {
    b.house.Roof = "Wooden shingles"
}

func (b *WoodHouseBuilder) SetInterior() {
    b.house.Interior = "Wooden panels and paint"
}

func (b *WoodHouseBuilder) GetHouse() House {
    return b.house
}

4 - Definiendo al Director

El Director es una clase que gestiona la construcción de un objeto, asegurando que los pasos de construcción se realicen en el orden correcto. No sabe nada sobre los detalles de implementaciones específicas de Builder, simplemente llama a los métodos de Builder en una secuencia lógica para crear el producto final.

//director.go

package main

type Director struct {
    builder HouseBuilder
}

func (d *Director) Build() {
    d.builder.SetFoundation()
    d.builder.SetStructure()
    d.builder.SetRoof()
    d.builder.SetInterior()
}

func (d *Director) SetBuilder(b HouseBuilder) {
    d.builder = b
}

5 - Usando el Constructor

Finalmente, usaremos el Director y los Constructores de concreto para construir diferentes tipos de casas.

//main.go

package main

import (
    "fmt"
)

func main() {
    cb := &builder.ConcreteHouseBuilder{}
    director := builder.Director{Builder: cb}

    director.Build()
    concreteHouse := cb.GetHouse()

    fmt.Println("Concrete House")
    fmt.Println("Foundation:", concreteHouse.Foundation)
    fmt.Println("Structure:", concreteHouse.Structure)
    fmt.Println("Roof:", concreteHouse.Roof)
    fmt.Println("Interior:", concreteHouse.Interior)
    fmt.Println("-------------------------------------------")

    wb := &builder.WoodHouseBuilder{}
    director.SetBuilder(wb)

    director.Build()
    woodHouse := wb.GetHouse()

    fmt.Println("Wood House")
    fmt.Println("Foundation:", woodHouse.Foundation)
    fmt.Println("Structure:", woodHouse.Structure)
    fmt.Println("Roof:", woodHouse.Roof)
    fmt.Println("Interior:", woodHouse.Interior)
}

En breve

1. Struct House: Representa el producto final que estamos construyendo.
2. Interfaz HouseBuilder: Define los métodos para construir las diferentes partes de la casa.
3. Implementaciones de hormigón (ConcreteHouseBuilder y WoodHouseBuilder): implemente la interfaz de HouseBuilder y defina pasos de construcción específicos.
4. Director: Gestiona el proceso de construcción, asegurando que los pasos se realicen en el orden correcto.
5. Función principal: Demuestra el uso del patrón Builder para construir diferentes tipos de casas, llamando al Director para gestionar el proceso y obtener el producto final.

Conclusión

El patrón Builder es una herramienta para construir objetos complejos de forma incremental y flexible. En Golang la implementación de este patrón es directa y efectiva, permitiendo la creación de sistemas modulares y fáciles de mantener. Al utilizar interfaces y clases concretas, podemos centralizar la lógica de construcción y simplificar la evolución del código a medida que surgen nuevos requisitos.