El patrón de diseño Factory se usa ampliamente en la programación orientada a objetos. Proporciona una interfaz para crear objetos, pero permite que las subclases decidan qué clases crear instancias. En este artículo, exploraremos cómo implementar el patrón Factory en Golang, comprenderemos sus beneficios y analizaremos un ejemplo práctico de uso inspirado en situaciones cotidianas.

¿Qué es la fábrica?

Factory define una interfaz para crear objetos, pero delega la responsabilidad de crear instancias de la clase concreta a las subclases. Esto promueve la creación de objetos de forma desacoplada y flexible, permitiendo que el código sea más modular y más fácil de mantener.

Beneficios

• Desacoplamiento: Separa la creación de objetos de su implementación, promoviendo un código más limpio y modular.
• Flexibilidad: facilita la introducción de nuevas clases sin modificar el código existente.
• Mantenimiento: Hace que el código sea más fácil de mantener y evolucionar, ya que la lógica de creación está centralizada en un solo lugar.

Implementando una fábrica

Usemos un ejemplo cotidiano para ilustrar el patrón Factory: un sistema para pedir comida, donde se pueden crear diferentes tipos de comidas (pizza y ensalada).

1 - Creando la interfaz

Primero, necesitamos definir una interfaz que será implementada por todas las "clases concretas" de comidas.

package main

type Food interface {
    Prepare()
}

2 - Creando un ENUM e implementando la interfaz

Para hacernos la vida más fácil durante el desarrollo y evitar escribir algo mal durante la validación, una buena práctica es crear un ENUM para tener coherencia y también hacerlo más fácil si queremos agregar nuevos alimentos en el futuro

package main

type FoodType int

const (
    PizzaType FoodType = iota
    SaladType
)

type Food interface {
    Prepare()
}

Y ahora implementemos la interfaz de Alimentos. En el ejemplo solo mostraremos un mensaje, en la vida real aquí es donde se crearía el objeto en el que estamos trabajando

package main

type FoodType int

const (
    PizzaType FoodType = iota
    SaladType
)

type Food interface {
    Prepare()
}

type Pizza struct{}

func (p Pizza) Prepare() {
    fmt.Println("Preparing a Pizza...")
}

type Salad struct{}

func (s Salad) Prepare() {
    fmt.Println("Preparing a Salad...")
}

3 - Creando la Fábrica

Ahora, creemos la fábrica que decidirá qué clase concreta crear una instancia en función de la enumeración que recibió como parámetro.

package main

type FoodFactory struct{}

func (f FoodFactory) CreateFood(ft FoodType) Food {
    switch ft {
    case PizzaType:
        return &Pizza{}
    case SaladType:
        return &Salad{}
    default:
        return nil
    }
}

4 - Usando Fábrica

Finalmente, usaremos la fábrica para crear nuestra comida.

package main

func main() {
    kitchen := FoodFactory{}

    pizza := kitchen.CreateFood(PizzaType)
    if pizza != nil {
        pizza.Prepare()
    }

    salad := kitchen.CreateFood(SaladType)
    if salad != nil {
        salad.Prepare()
    }
}

Este será el resultado después de ejecutar nuestra aplicación:

Preparing a Pizza...
Preparing a Salad...

Resumen de lo que hicimos.

1. Interfaz de Alimentos: Define el contrato que deben seguir todas las comidas concretas, asegurando que todas implementen el método Preparar.
2. Enum FoodType: utiliza constantes escritas para representar diferentes tipos de alimentos, lo que aumenta la legibilidad y la seguridad del código.
3. Clases concretas (Pizza y Ensalada): Implementan la interfaz Food y proporcionan sus propias implementaciones del método Prepare.
4. FoodFactory: contiene lógica de creación de objetos. El método CreateFood decide qué clase concreta crear una instancia según la enumeración FoodType.
5. Método principal: demuestra el uso de factory para crear diferentes objetos y llamar a sus métodos, lo que ilustra la flexibilidad y el desacoplamiento proporcionados por el patrón Factory.

Conclusión

El patrón de diseño Factory es una herramienta poderosa para promover el desacoplamiento y la flexibilidad en la creación de objetos. En Golang la implementación de este patrón es directa y efectiva, permitiendo la creación de sistemas modulares y de fácil mantenimiento. Usando interfaces y fábricas, podemos centralizar la lógica de creación y simplificar la evolución del código a medida que surgen nuevos requisitos.