Patrón Factory

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy — lección 87 de 107.

El patrón Factory delega la creación de objetos a una función o método independiente, permitiéndote crear instancias sin exponer la lógica de creación. A diferencia de Singleton, que controla el recuento de instancias, Factory se centra en la creación flexible de objetos basada en parámetros de entrada.

En Go, una fábrica es típicamente una función que devuelve un tipo de interfaz, permitiéndote crear diferentes tipos concretos a través de una API unificada:

type Notifier interface {
    Send(message string) string
}

type EmailNotifier struct{}
type SMSNotifier struct{}

func (e EmailNotifier) Send(message string) string {
    return "Email: " + message
}

func (s SMSNotifier) Send(message string) string {
    return "SMS: " + message
}

func NewNotifier(notifierType string) Notifier {
    switch notifierType {
    case "email":
        return EmailNotifier{}
    case "sms":
        return SMSNotifier{}
    default:
        return EmailNotifier{}
    }
}

La función de fábrica NewNotifier encapsula la decisión de qué tipo concreto crear. El código cliente trabaja solo con la interfaz Notifier, permaneciendo ajeno a la implementación específica:

notifier := NewNotifier("sms")
result := notifier.Send("Hello!")  // "SMS: Hello!"

Este patrón destaca cuando necesitas crear objetos basados en condiciones de tiempo de ejecución, quieres centralizar una lógica de inicialización compleja o necesitas añadir fácilmente nuevos tipos sin modificar el código cliente. Simplemente añade un nuevo struct que implemente la interface y actualiza la factory function.

Desafío

Fácil

¡Vamos a construir un sistema convertidor de documentos utilizando el patrón Factory! Crearás una fábrica que produce diferentes convertidores de documentos basados en el formato de destino, permitiendo que el código del cliente trabaje con cualquier convertidor a través de una interfaz unificada.

Organizarás tu código en dos archivos:

converter.go: Define tu interfaz de convertidor e implementaciones concretas.
Crea una interfaz Converter con un método Convert(content string) string que reciba el contenido del documento y devuelva la salida convertida.

Implementa tres tipos de convertidores:
- PDFConverter — su método Convert devuelve PDF: [content]
- HTMLConverter — su método Convert devuelve HTML: <p>[content]</p>
- MarkdownConverter — su método Convert devuelve MD: # [content]
Crea una función de fábrica NewConverter(format string) Converter que devuelva el convertidor apropiado basado en la cadena de formato (pdf, html, o markdown). Para cualquier formato no reconocido, devuelve un PDFConverter por defecto.
main.go: Usa tu fábrica para crear convertidores y procesar documentos.
Lee un tipo de formato y el contenido del documento. Usa la fábrica para crear el convertidor apropiado, luego convierte el contenido e imprime el resultado.

Se proporcionarán las siguientes entradas:

Línea 1: Tipo de formato (pdf, html, markdown, u otro)
Línea 2: Contenido del documento a convertir

Por ejemplo, dado:

html
Welcome to Go Programming

Tu salida debería ser:

HTML: <p>Welcome to Go Programming</p>

Y dado:

markdown
Chapter One

Tu salida debería ser:

MD: # Chapter One

Y dado:

pdf
Annual Report 2024

Tu salida debería ser:

PDF: Annual Report 2024

Y dado:

docx
Meeting Notes

Tu salida debería ser:

PDF: Meeting Notes

¡Observa cómo el código principal no necesita conocer los tipos de convertidores específicos; simplemente le pide a la fábrica un convertidor y utiliza la interfaz. ¡Esto facilita la adición de nuevos formatos más adelante sin cambiar el código del cliente!

Hoja de referencia

El patrón Factory delega la creación de objetos a una función separada, lo que permite crear instancias sin exponer la lógica de creación. Se centra en la creación flexible de objetos basada en parámetros de entrada.

Una función factory devuelve un tipo de interfaz, lo que permite la creación de diferentes tipos concretos a través de una API unificada:

type Notifier interface {
    Send(message string) string
}

type EmailNotifier struct{}
type SMSNotifier struct{}

func (e EmailNotifier) Send(message string) string {
    return "Email: " + message
}

func (s SMSNotifier) Send(message string) string {
    return "SMS: " + message
}

func NewNotifier(notifierType string) Notifier {
    switch notifierType {
    case "email":
        return EmailNotifier{}
    case "sms":
        return SMSNotifier{}
    default:
        return EmailNotifier{}
    }
}

El código del cliente trabaja solo con la interfaz, permaneciendo ajeno a las implementaciones específicas:

notifier := NewNotifier("sms")
result := notifier.Send("Hello!")  // "SMS: Hello!"

Este patrón es útil cuando se necesita crear objetos basados en condiciones de tiempo de ejecución, se desea centralizar la lógica de inicialización compleja o se necesita agregar nuevos tipos sin modificar el código del cliente.

Pruébalo tú mismo

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Leer el tipo de formato
	scanner.Scan()
	format := scanner.Text()
	
	// Leer el contenido del documento
	scanner.Scan()
	content := scanner.Text()
	
	// TODO: Usar la fábrica para crear el convertidor apropiado
	// TODO: Convertir el contenido e imprimir el resultado
	
	fmt.Println(result)
}