Hourra ! La version française est enfin sortie ! Laissez-nous un message svp, si vous voulez nous faire part de vos commentaires ou signaler une erreur.
Fabrique abstraite

Fabrique abstraite en Go

La Fabrique abstraite est un patron de conception de création qui permet de créer des familles de produits complètes sans avoir à préciser leurs classes concrètes.

La fabrique abstraite définit une interface pour la création de chaque produit, mais délègue la véritable création des produits aux classes concrètes de la fabrique. Chaque type de fabrique correspond à une certaine variété de produits.

Le code client appelle les méthodes de création d’un objet Fabrique plutôt que de créer directement les produits à l’aide d’un constructeur (opérateur new). Comme chaque fabrique possède sa propre variante de produit, tous ses produits seront compatibles.

Le code client manipule les fabriques et les produits uniquement via leurs interfaces abstraites, ce qui lui permet de travailler avec n’importe quelle variante de produit créée par un objet Fabrique. Créez juste une nouvelle classe concrète Fabrique et passez-la au code client.

Lisez notre Comparaison des fabriques si vous avez du mal à comprendre la différence entre les divers concepts et patrons.

Exemple conceptuel

Prenons le cas où vous voulez acheter des affaires de sport et plus précisément un ensemble de deux produits : une paire de chaussures et un maillot. Vous aimeriez acquérir une tenue assortie de la même marque.

Pour transformer tout ceci en code, la fabrique abstraite va nous aider à créer des ensembles de produits qui seraient systématiquement assortis.

iSportsFactory.go: Interface de la fabrique abstraite

package main

import "fmt"

type iSportsFactory interface {
	makeShoe() iShoe
	makeShirt() iShirt
}

func getSportsFactory(brand string) (iSportsFactory, error) {
	if brand == "adidas" {
		return &adidas{}, nil
	}

	if brand == "nike" {
		return &nike{}, nil
	}

	return nil, fmt.Errorf("Wrong brand type passed")
}

adidas.go: Fabrique concrète

package main

type adidas struct {
}

func (a *adidas) makeShoe() iShoe {
	return &adidasShoe{
		shoe: shoe{
			logo: "adidas",
			size: 14,
		},
	}
}

func (a *adidas) makeShirt() iShirt {
	return &adidasShirt{
		shirt: shirt{
			logo: "adidas",
			size: 14,
		},
	}
}

nike.go: Fabrique concrète

package main

type nike struct {
}

func (n *nike) makeShoe() iShoe {
	return &nikeShoe{
		shoe: shoe{
			logo: "nike",
			size: 14,
		},
	}
}

func (n *nike) makeShirt() iShirt {
	return &nikeShirt{
		shirt: shirt{
			logo: "nike",
			size: 14,
		},
	}
}

iShoe.go: Produit abstrait

package main

type iShoe interface {
	setLogo(logo string)
	setSize(size int)
	getLogo() string
	getSize() int
}

type shoe struct {
	logo string
	size int
}

func (s *shoe) setLogo(logo string) {
	s.logo = logo
}

func (s *shoe) getLogo() string {
	return s.logo
}

func (s *shoe) setSize(size int) {
	s.size = size
}

func (s *shoe) getSize() int {
	return s.size
}

adidasShoe.go: Produit concret

package main

type adidasShoe struct {
	shoe
}

nikeShoe.go: Produit concret

package main

type nikeShoe struct {
	shoe
}

iShirt.go: Produit abstrait

package main

type iShirt interface {
	setLogo(logo string)
	setSize(size int)
	getLogo() string
	getSize() int
}

type shirt struct {
	logo string
	size int
}

func (s *shirt) setLogo(logo string) {
	s.logo = logo
}

func (s *shirt) getLogo() string {
	return s.logo
}

func (s *shirt) setSize(size int) {
	s.size = size
}

func (s *shirt) getSize() int {
	return s.size
}

adidasShirt.go: Produit concret

package main

type adidasShirt struct {
	shirt
}

nikeShirt.go: Produit concret

package main

type nikeShirt struct {
	shirt
}

main.go: Code client

package main

import "fmt"

func main() {
	adidasFactory, _ := getSportsFactory("adidas")
	nikeFactory, _ := getSportsFactory("nike")

	nikeShoe := nikeFactory.makeShoe()
	nikeShirt := nikeFactory.makeShirt()

	adidasShoe := adidasFactory.makeShoe()
	adidasShirt := adidasFactory.makeShirt()

	printShoeDetails(nikeShoe)
	printShirtDetails(nikeShirt)

	printShoeDetails(adidasShoe)
	printShirtDetails(adidasShirt)
}

func printShoeDetails(s iShoe) {
	fmt.Printf("Logo: %s", s.getLogo())
	fmt.Println()
	fmt.Printf("Size: %d", s.getSize())
	fmt.Println()
}

func printShirtDetails(s iShirt) {
	fmt.Printf("Logo: %s", s.getLogo())
	fmt.Println()
	fmt.Printf("Size: %d", s.getSize())
	fmt.Println()
}

output.txt: Résultat de l’exécution

Logo: nike
Size: 14
Logo: nike
Size: 14
Logo: adidas
Size: 14
Logo: adidas
Size: 14

Fabrique abstraite dans les autres langues

Patrons de conception : Fabrique abstraite en Java Patrons de conception : Fabrique abstraite en C# Patrons de conception : Fabrique abstraite en C++ Patrons de conception : Fabrique abstraite en PHP Patrons de conception : Fabrique abstraite en Python Patrons de conception : Fabrique abstraite en Ruby Patrons de conception : Fabrique abstraite en Swift Patrons de conception : Fabrique abstraite en TypeScript