Abstract Factory est un modèle de conception créationnel qui vous permet de créer des objets associés sans spécifier leurs classes concrètes.

Énoncé du problème

Imaginez que vous développez une boîte à outils GUI qui devrait prendre en charge plusieurs normes d'apparence (par exemple, Windows, macOS, Linux). Chaque norme d'apparence nécessite un ensemble différent de composants d'interface utilisateur tels que des boutons, des cases à cocher et des barres de défilement.

Sans le modèle Abstract Factory, vous auriez à écrire beaucoup de code conditionnel pour gérer la création de ces composants basés sur la norme d'apparence actuelle. Cette approche n'est pas évolutive et rend la base de code difficile à maintenir et à étendre.

En utilisant le modèle Abstract Factory, vous pouvez créer une interface pour créer des familles d'objets associés (par exemple, des boutons, des cases à cocher, des barres de défilement) et implémenter cette interface pour chaque norme d'apparence. De cette façon, le code client peut fonctionner avec n'importe quelle norme d'apparence sans connaître les détails de la façon dont les composants sont créés.

Exemple concret

Prenons l'exemple d'une usine de meubles qui produit des chaises et des tables dans différents styles, tels que classique et moderne.

Chaque style nécessite un ensemble différent de composants (par exemple, pieds, dossier, accoudoirs) et de matériaux (par exemple, bois, métal, plastique).

Mise en œuvre

• Exécutez l'exemple en exécutant go run abstract-factory/main.go.

package main

import "fmt"

// Abstract Factory
type FurnitureFactory interface {
    MakeChair() Chair
    MakeTable() Table
}

func NewFurnitureFactory(style string) (FurnitureFactory, error) {
    if style == "classic" {
        return &Classic{}, nil
    }

    if style == "modern" {
        return &Modern{}, nil
    }

    return nil, fmt.Errorf("Style %s is not supported", style)
}

type Chair struct {
    Name     string
    Material string
}

type Table struct {
    Name     string
    Material string
}

// Concrete Classic Factory
type Classic struct{}

func (a *Classic) MakeChair() Chair {
    return Chair{
        Name:     "Classic Chair",
        Material: "Wood",
    }
}

func (a *Classic) MakeTable() Table {
    return Table{
        Name:     "Classic Table",
        Material: "Wood",
    }
}

// Concrete Modern Factory
type Modern struct{}

func (n *Modern) MakeChair() Chair {
    return Chair{
        Name:     "Modern Chair",
        Material: "Plastic",
    }
}

func (n *Modern) MakeTable() Table {
    return Table{
        Name:     "Modern Table",
        Material: "Plastic",
    }
}

func main() {
    factory, _ := NewFurnitureFactory("classic")

    chair := factory.MakeChair()
    table := factory.MakeTable()

    fmt.Printf("Chair: %s\n", chair.Name)
    fmt.Printf("Table: %s\n", table.Name)

    factory, _ = NewFurnitureFactory("modern")

    chair = factory.MakeChair()
    table = factory.MakeTable()

    fmt.Printf("Chair: %s\n", chair.Name)
    fmt.Printf("Table: %s\n", table.Name)
}

Explication

Ce code démontre le modèle Abstract Factory en créant des meubles (chaises et tables) dans différents styles (classique et moderne). Il définit une interface pour créer des familles d'objets associés et des implémentations concrètes pour chaque style, permettant une évolutivité et une maintenance faciles.