Abstract Factory es un patrón de diseño creacional que te permite crear objetos relacionados sin especificar sus clases concretas.

Declaración del problema

Imagine que está desarrollando un conjunto de herramientas GUI que debería admitir múltiples estándares de apariencia (por ejemplo, Windows, macOS, Linux). Cada estándar de apariencia requiere un conjunto diferente de componentes de interfaz de usuario, como botones, casillas de verificación y barras de desplazamiento.

Sin el patrón Abstract Factory, tendría que escribir una gran cantidad de código condicional para manejar la creación de estos componentes según el estándar de apariencia actual. Este enfoque no es escalable y dificulta el mantenimiento y la ampliación del código base.

Al utilizar el patrón Abstract Factory, puede crear una interfaz para crear familias de objetos relacionados (por ejemplo, botones, casillas de verificación, barras de desplazamiento) e implementar esta interfaz para cada estándar de apariencia. De esta manera, el código del cliente puede funcionar con cualquier estándar de apariencia sin conocer los detalles de cómo se crean los componentes.

Ejemplo del mundo real

Considere una fábrica de muebles que produzca sillas y mesas en diferentes estilos, como clásico y moderno.

Cada estilo requiere un conjunto diferente de componentes (p. ej., patas, respaldo, reposabrazos) y materiales (p. ej., madera, metal, plástico).

Implementación

• Ejecute el ejemplo ejecutando go run abstract-factory/main.go.

package main

import "fmt"

// Abstract Factory
type FurnitureFactory interface {
    MakeChair() Chair
    MakeTable() Table
}

func NewFurnitureFactory(style string) (FurnitureFactory, error) {
    if style == "classic" {
        return &Classic{}, nil
    }

    if style == "modern" {
        return &Modern{}, nil
    }

    return nil, fmt.Errorf("Style %s is not supported", style)
}

type Chair struct {
    Name     string
    Material string
}

type Table struct {
    Name     string
    Material string
}

// Concrete Classic Factory
type Classic struct{}

func (a *Classic) MakeChair() Chair {
    return Chair{
        Name:     "Classic Chair",
        Material: "Wood",
    }
}

func (a *Classic) MakeTable() Table {
    return Table{
        Name:     "Classic Table",
        Material: "Wood",
    }
}

// Concrete Modern Factory
type Modern struct{}

func (n *Modern) MakeChair() Chair {
    return Chair{
        Name:     "Modern Chair",
        Material: "Plastic",
    }
}

func (n *Modern) MakeTable() Table {
    return Table{
        Name:     "Modern Table",
        Material: "Plastic",
    }
}

func main() {
    factory, _ := NewFurnitureFactory("classic")

    chair := factory.MakeChair()
    table := factory.MakeTable()

    fmt.Printf("Chair: %s\n", chair.Name)
    fmt.Printf("Table: %s\n", table.Name)

    factory, _ = NewFurnitureFactory("modern")

    chair = factory.MakeChair()
    table = factory.MakeTable()

    fmt.Printf("Chair: %s\n", chair.Name)
    fmt.Printf("Table: %s\n", table.Name)
}

Explicación

Este código demuestra el patrón Abstract Factory mediante la creación de muebles (sillas y mesas) en diferentes estilos (clásico y moderno). Define una interfaz para crear familias de objetos relacionados e implementaciones concretas para cada estilo, lo que permite una fácil escalabilidad y mantenimiento.