Modello Factory

Fa parte della sezione Programmazione orientata agli oggetti del percorso GO di Coddy. Lezione 87 di 107.

Il pattern Factory delega la creazione degli oggetti a una funzione o a un metodo separato, consentendoti di creare istanze senza esporre la logica di creazione. A differenza del Singleton, che controlla il numero di istanze, Factory si concentra sulla creazione flessibile di oggetti in base ai parametri di input.

In Go, una factory è in genere una funzione che restituisce un tipo di interfaccia, consentendoti di creare diversi tipi concreti tramite un'API unificata:

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 funzione factory NewNotifier incapsula la decisione su quale tipo concreto creare. Il codice client lavora solo con l’interfaccia Notifier, senza conoscere l’implementazione specifica:

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

Questo schema è particolarmente utile quando devi creare oggetti in base a condizioni di runtime, vuoi centralizzare una logica di inizializzazione complessa o hai bisogno di aggiungere facilmente nuovi tipi senza modificare il codice client. Ti basta aggiungere una nuova struct che implementa l’interfaccia e aggiornare la funzione factory.

Sfida

Facile

Costruiamo un sistema di conversione di documenti usando il modello Factory! Creerai una factory che produce diversi convertitori di documenti in base al formato di destinazione, consentendo al codice client di lavorare con qualsiasi convertitore tramite un'interfaccia unificata.

Organizzerai il codice in due file:

converter.go: definisci l'interfaccia del convertitore e le implementazioni concrete.
Crea un'interfaccia Converter con un metodo Convert(content string) string che accetta il contenuto del documento e restituisce il risultato convertito.

Implementa tre tipi di convertitore:
- PDFConverter: il suo metodo Convert restituisce PDF: [content]
- HTMLConverter: il suo metodo Convert restituisce HTML: <p>[content]</p>
- MarkdownConverter: il suo metodo Convert restituisce MD: # [content]
Crea una funzione factory NewConverter(format string) Converter che restituisce il convertitore appropriato in base alla stringa del formato (pdf, html o markdown). Per qualsiasi formato non riconosciuto, restituisci un PDFConverter come valore predefinito.
main.go: usa la tua factory per creare convertitori ed elaborare documenti.
Leggi un tipo di formato e il contenuto di un documento. Usa la factory per creare il convertitore appropriato, quindi converti il contenuto e stampa il risultato.

Verranno forniti i seguenti input:

Riga 1: tipo di formato (pdf, html, markdown o altro)
Riga 2: contenuto del documento da convertire

Per esempio, dato:

html
Welcome to Go Programming

Il tuo output dovrebbe essere:

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

E dato:

markdown
Chapter One

Il tuo output dovrebbe essere:

MD: # Chapter One

E dato:

pdf
Annual Report 2024

Il tuo output dovrebbe essere:

PDF: Annual Report 2024

E dato:

docx
Meeting Notes

Il tuo output dovrebbe essere:

PDF: Meeting Notes

Nota che il codice principale non ha bisogno di conoscere i tipi specifici di convertitore. Chiede semplicemente alla factory un convertitore e usa l'interfaccia. In questo modo sarà facile aggiungere nuovi formati in seguito senza modificare il codice client!

Provalo tu

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Leggi il tipo di formato
	scanner.Scan()
	format := scanner.Text()
	
	// Leggi il contenuto del documento
	scanner.Scan()
	content := scanner.Text()
	
	// TODO: Usa la factory per creare il convertitore appropriato
	// TODO: Converti il contenuto e stampa il risultato
	
	fmt.Println(result)
}