Patrón Abstract Factory

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy. Lección 88 de 107.

El patrón Abstract Factory amplía el patrón Factory al crear familias de objetos relacionados sin especificar sus tipos concretos. En lugar de una única función de fábrica, defines una interfaz de fábrica que varias fábricas concretas implementan, y cada una produce un conjunto coherente de objetos relacionados.

Considera un kit de herramientas de interfaz de usuario que necesita crear botones y casillas de verificación. Los distintos sistemas operativos requieren implementaciones diferentes, pero los componentes deben funcionar juntos de manera coherente:

type Button interface {
    Render() string
}

type Checkbox interface {
    Check() string
}

// Interfaz de fábrica abstracta
type GUIFactory interface {
    CreateButton() Button
    CreateCheckbox() Checkbox
}

Cada fábrica concreta produce una familia de componentes relacionados:

// Familia Windows
type WindowsButton struct{}
func (w WindowsButton) Render() string { return "Windows Button" }

type WindowsCheckbox struct{}
func (w WindowsCheckbox) Check() string { return "Windows Checkbox" }

type WindowsFactory struct{}
func (w WindowsFactory) CreateButton() Button { return WindowsButton{} }
func (w WindowsFactory) CreateCheckbox() Checkbox { return WindowsCheckbox{} }

// Familia Mac
type MacButton struct{}
func (m MacButton) Render() string { return "Mac Button" }

type MacCheckbox struct{}
func (m MacCheckbox) Check() string { return "Mac Checkbox" }

type MacFactory struct{}
func (m MacFactory) CreateButton() Button { return MacButton{} }
func (m MacFactory) CreateCheckbox() Checkbox { return MacCheckbox{} }

El código del cliente funciona con la interfaz de fábrica y permanece independiente de las implementaciones concretas:

func BuildUI(factory GUIFactory) {
    button := factory.CreateButton()
    checkbox := factory.CreateCheckbox()
    fmt.Println(button.Render(), checkbox.Check())
}

Usa Abstract Factory cuando tu sistema necesite trabajar con varias familias de productos relacionados y quieras garantizar que los componentes de la misma familia se utilicen juntos. Es más complejo que una Factory simple, así que recurre a él solo cuando realmente necesites gestionar familias de productos.

Desafío

Fácil

¡Construyamos un sistema de tienda de muebles usando el patrón Abstract Factory! Crearás fábricas que producen familias de artículos de mobiliario relacionados: cada fábrica produce un estilo coherente (Modern o Vintage), lo que garantiza que las sillas y las mesas de la misma fábrica combinen estéticamente.

Organizarás tu código en tres archivos:

furniture.go: Define tus interfaces de producto y los tipos concretos de muebles.
Crea dos interfaces de producto:
- Chair con un método SitOn() string
- Table con un método PlaceItems() string
Implementa dos familias de muebles:
- Familia Modern: ModernChair devuelve Sitting on a sleek modern chair y ModernTable devuelve Placing items on a glass modern table
- Familia Vintage: VintageChair devuelve Sitting on an ornate vintage chair y VintageTable devuelve Placing items on a wooden vintage table
factory.go: Define tu interfaz de fábrica abstracta y las fábricas concretas.
Crea una interfaz FurnitureFactory con dos métodos:
- CreateChair() Chair
- CreateTable() Table
Implementa dos fábricas concretas:
- ModernFactory, que produce ModernChair y ModernTable
- VintageFactory, que produce VintageChair y VintageTable
Crea también una función GetFactory(style string) FurnitureFactory que devuelva la fábrica adecuada según el estilo (modern o vintage). Usa ModernFactory para los estilos no reconocidos.
main.go: Usa tus fábricas para amueblar habitaciones.
Crea una función FurnishRoom(factory FurnitureFactory) string que use la fábrica para crear una silla y una mesa, y luego devuelva una cadena formateada que muestre ambas acciones en líneas separadas.

Lee una entrada de estilo, obtén la fábrica adecuada, amuebla una habitación e imprime el resultado.

Se proporcionarán las siguientes entradas:

Línea 1: Estilo de los muebles (modern, vintage o cualquier otra cosa)

Por ejemplo, dada la siguiente entrada:

modern

Tu salida debería ser:

Sitting on a sleek modern chair
Placing items on a glass modern table

Y dada la siguiente entrada:

vintage

Tu salida debería ser:

Sitting on an ornate vintage chair
Placing items on a wooden vintage table

Y dada la siguiente entrada:

rustic

Tu salida debería ser:

Sitting on a sleek modern chair
Placing items on a glass modern table

Observa cómo la función FurnishRoom funciona con cualquier fábrica mediante la interfaz. No sabe si está creando muebles modernos o vintage. ¡Esto garantiza que todos los muebles de una habitación provengan de la misma familia, manteniendo un estilo coherente!

Pruébalo tú mismo

package main

import "fmt"

// FurnishRoom usa una fábrica para crear muebles y devuelve el resultado
// TODO: Implementa esta función
// - Usa la fábrica para crear una silla y una mesa
// - Devuelve una cadena con el resultado de SitOn() en la primera línea y el resultado de PlaceItems() en la segunda línea
func FurnishRoom(factory FurnitureFactory) string {
	// TODO: Crea silla y mesa usando la fábrica
	// TODO: Devuelve una cadena formateada con ambas acciones en líneas separadas
	return ""
}

func main() {
	var style string
	fmt.Scanln(&style)

	// TODO: Obtén la fábrica apropiada según el estilo
	// TODO: Amuebla una habitación usando la fábrica
	// TODO: Imprime el resultado
}