Pattern Factory

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 87 sur 107.

Le pattern Factory délègue la création des objets à une fonction ou une méthode distincte, ce qui vous permet de créer des instances sans exposer la logique de création. Contrairement au Singleton, qui contrôle le nombre d’instances, le Factory se concentre sur la création flexible d’objets en fonction des paramètres d’entrée.

En Go, une fabrique est généralement une fonction qui renvoie un type d’interface, ce qui vous permet de créer différents types concrets via une API unifiée :

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 fonction d’usine NewNotifier encapsule la décision concernant le type concret à créer. Le code client fonctionne uniquement avec l’interface Notifier, sans connaître l’implémentation spécifique :

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

Ce modèle est particulièrement utile lorsque vous devez créer des objets en fonction de conditions d’exécution, centraliser une logique d’initialisation complexe ou ajouter facilement de nouveaux types sans modifier le code client. Il vous suffit d’ajouter une nouvelle structure qui implémente l’interface et de mettre à jour la fonction fabrique.

Défi

Facile

Construisons un système de conversion de documents à l’aide du pattern Factory ! Vous allez créer une fabrique qui produit différents convertisseurs de documents en fonction du format cible, permettant au code client de fonctionner avec n’importe quel convertisseur via une interface unifiée.

Vous allez organiser votre code sur deux fichiers :

converter.go : définissez votre interface de convertisseur et vos implémentations concrètes.
Créez une interface Converter avec une méthode Convert(content string) string qui prend le contenu d’un document et renvoie le résultat converti.

Implémentez trois types de convertisseurs :
- PDFConverter : sa méthode Convert renvoie PDF: [content]
- HTMLConverter : sa méthode Convert renvoie HTML: <p>[content]</p>
- MarkdownConverter : sa méthode Convert renvoie MD: # [content]
Créez une fonction fabrique NewConverter(format string) Converter qui renvoie le convertisseur approprié en fonction de la chaîne de format (pdf, html ou markdown). Pour tout format non reconnu, renvoyez un PDFConverter par défaut.
main.go : utilisez votre fabrique pour créer des convertisseurs et traiter des documents.
Lisez un type de format et le contenu d’un document. Utilisez la fabrique pour créer le convertisseur approprié, puis convertissez le contenu et affichez le résultat.

Les entrées suivantes seront fournies :

Ligne 1 : type de format (pdf, html, markdown ou autre chose)
Ligne 2 : contenu du document à convertir

Par exemple, avec :

html
Welcome to Go Programming

Votre sortie doit être :

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

Et avec :

markdown
Chapter One

Votre sortie doit être :

MD: # Chapter One

Et avec :

pdf
Annual Report 2024

Votre sortie doit être :

PDF: Annual Report 2024

Et avec :

docx
Meeting Notes

Votre sortie doit être :

PDF: Meeting Notes

Remarquez que le code principal n’a pas besoin de connaître les types de convertisseurs spécifiques. Il demande simplement un convertisseur à la fabrique et utilise l’interface. Il devient ainsi facile d’ajouter de nouveaux formats ultérieurement sans modifier le code client !

Essayez vous-même

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Lire le type de format
	scanner.Scan()
	format := scanner.Text()
	
	// Lire le contenu du document
	scanner.Scan()
	content := scanner.Text()
	
	// TODO: Utiliser la factory pour créer le convertisseur approprié
	// TODO: Convertir le contenu et afficher le résultat
	
	fmt.Println(result)
}