Le modèle de conception Factory est largement utilisé dans la programmation orientée objet. Il fournit une interface pour créer des objets, mais permet aux sous-classes de décider quelles classes instancier. Dans cet article, nous explorerons comment implémenter le modèle Factory dans Golang, comprendrons ses avantages et analyserons un exemple pratique d'utilisation inspiré de situations quotidiennes.

Qu’est-ce que l’usine ?

Factory définit une interface pour créer des objets, mais délègue la responsabilité de l'instanciation de la classe concrète aux sous-classes. Cela favorise la création d'objets de manière découplée et flexible, permettant au code d'être plus modulaire et plus facile à maintenir.

Avantages

• Découplage : sépare la création d'objets de leur implémentation, favorisant ainsi un code plus propre et plus modulaire.
• Flexibilité : facilite l'introduction de nouvelles classes sans modifier le code existant.
• Maintenance : facilite la maintenance et l'évolution du code, car la logique de création est centralisée en un seul endroit.

Implémentation d'une usine

Utilisons un exemple quotidien pour illustrer le modèle Factory : un système de commande de nourriture, où différents types de repas (Pizza et Salade) peuvent être créés.

1 - Création de l'interface

Tout d'abord, nous devons définir une interface qui sera implémentée par toutes les « classes concrètes » de repas.

package main

type Food interface {
    Prepare()
}

2 - Créer un ENUM et implémenter l'interface

Pour nous faciliter la vie lors du développement et éviter de taper quelque chose de mal lors de la validation, une bonne pratique consiste à créer un ENUM pour avoir de la cohérence et également faciliter la tâche si nous souhaitons ajouter de nouveaux aliments à l'avenir

package main

type FoodType int

const (
    PizzaType FoodType = iota
    SaladType
)

type Food interface {
    Prepare()
}

Et maintenant, implémentons l'interface Food. Dans l'exemple nous allons juste afficher un message, dans la vraie vie c'est ici que serait créé l'objet sur lequel nous travaillons

package main

type FoodType int

const (
    PizzaType FoodType = iota
    SaladType
)

type Food interface {
    Prepare()
}

type Pizza struct{}

func (p Pizza) Prepare() {
    fmt.Println("Preparing a Pizza...")
}

type Salad struct{}

func (s Salad) Prepare() {
    fmt.Println("Preparing a Salad...")
}

3 - Création de l'usine

Maintenant, créons la fabrique qui décidera quelle classe concrète instancier en fonction de l'énumération qu'elle a reçue en paramètre.

package main

type FoodFactory struct{}

func (f FoodFactory) CreateFood(ft FoodType) Food {
    switch ft {
    case PizzaType:
        return &Pizza{}
    case SaladType:
        return &Salad{}
    default:
        return nil
    }
}

4 - Utiliser l'usine

Enfin, nous utiliserons l'usine pour créer nos aliments.

package main

func main() {
    kitchen := FoodFactory{}

    pizza := kitchen.CreateFood(PizzaType)
    if pizza != nil {
        pizza.Prepare()
    }

    salad := kitchen.CreateFood(SaladType)
    if salad != nil {
        salad.Prepare()
    }
}

Ceci sera le résultat après avoir exécuté notre application :

Preparing a Pizza...
Preparing a Salad...

Résumé de ce que nous avons fait

1. Food Interface : définit le contrat que tous les repas concrets doivent suivre, en garantissant qu'ils mettent tous en œuvre la méthode Prepare.
2. Enum FoodType : utilise des constantes typées pour représenter différents types d'aliments, augmentant ainsi la lisibilité et la sécurité du code.
3. Classes concrètes (Pizza et Salad) : implémentez l'interface Food et fournissent leurs propres implémentations de la méthode Prepare.
4. FoodFactory : contient la logique de création d’objets. La méthode CreateFood décide quelle classe concrète instancier en fonction de l'énumération FoodType.
5. Méthode principale : démontre l'utilisation de l'usine pour créer différents objets et appeler leurs méthodes, illustrant la flexibilité et le découplage fournis par le modèle Factory.

Conclusion

Le modèle de conception Factory est un outil puissant pour promouvoir le découplage et la flexibilité dans la création d'objets. Chez Golang, la mise en œuvre de ce modèle est directe et efficace, permettant la création de systèmes modulaires et faciles à entretenir. À l'aide d'interfaces et d'usines, nous pouvons centraliser la logique de création et simplifier l'évolution du code à mesure que de nouvelles exigences émergent.