Padrão Factory

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy. Lição 87 de 107.

O padrão Factory delega a criação de objetos a uma função ou método separado, permitindo que você crie instâncias sem expor a lógica de criação. Diferentemente do Singleton, que controla a quantidade de instâncias, o Factory concentra-se na criação flexível de objetos com base em parâmetros de entrada.

Em Go, uma fábrica normalmente é uma função que retorna um tipo de interface, permitindo criar diferentes tipos concretos por meio de uma 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{}
    }
}

A função de fábrica NewNotifier encapsula a decisão sobre qual tipo concreto criar. O código cliente trabalha apenas com a interface Notifier, permanecendo alheio à implementação específica:

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

Este padrão se destaca quando você precisa criar objetos com base em condições de execução, quer centralizar uma lógica complexa de inicialização ou precisa adicionar novos tipos facilmente sem modificar o código do cliente. Basta adicionar uma nova struct que implemente a interface e atualizar a função de fábrica.

Desafio

Fácil

Vamos criar um sistema de conversão de documentos usando o padrão Factory! Você criará uma fábrica que produz diferentes conversores de documentos com base no formato de destino, permitindo que o código cliente trabalhe com qualquer conversor por meio de uma interface unificada.

Você organizará seu código em dois arquivos:

converter.go: Defina sua interface de conversor e as implementações concretas.
Crie uma interface Converter com um método Convert(content string) string que recebe o conteúdo do documento e retorna a saída convertida.

Implemente três tipos de conversor:
- PDFConverter: seu método Convert retorna PDF: [content]
- HTMLConverter: seu método Convert retorna HTML: <p>[content]</p>
- MarkdownConverter: seu método Convert retorna MD: # [content]
Crie uma função de fábrica NewConverter(format string) Converter que retorna o conversor apropriado com base na string de formato (pdf, html ou markdown). Para qualquer formato não reconhecido, retorne um PDFConverter como padrão.
main.go: Use sua fábrica para criar conversores e processar documentos.
Leia um tipo de formato e o conteúdo do documento. Use a fábrica para criar o conversor apropriado, depois converta o conteúdo e imprima o resultado.

As seguintes entradas serão fornecidas:

Linha 1: Tipo de formato (pdf, html, markdown ou qualquer outra coisa)
Linha 2: Conteúdo do documento a ser convertido

Por exemplo, dada a entrada:

html
Welcome to Go Programming

Sua saída deve ser:

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

E dada a entrada:

markdown
Chapter One

Sua saída deve ser:

MD: # Chapter One

E dada a entrada:

pdf
Annual Report 2024

Sua saída deve ser:

PDF: Annual Report 2024

E dada a entrada:

docx
Meeting Notes

Sua saída deve ser:

PDF: Meeting Notes

Observe como o código principal não precisa conhecer os tipos específicos de conversor. Ele apenas solicita um conversor à fábrica e usa a interface. Isso facilita a adição de novos formatos posteriormente, sem alterar o código cliente!

Experimente você mesmo

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Ler o tipo de formato
	scanner.Scan()
	format := scanner.Text()
	
	// Ler o conteúdo do documento
	scanner.Scan()
	content := scanner.Text()
	
	// TODO: Use a factory para criar o conversor apropriado
	// TODO: Converta o conteúdo e imprima o resultado
	
	fmt.Println(result)
}