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

Fabrique en Go

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

La fabrique définit une méthode qui doit être utilisée pour créer des objets à la place de l’appel au constructeur (opérateur new). Les sous-classes peuvent redéfinir cette méthode pour modifier la classe des objets qui seront créés.

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

Exemple conceptuel

Le patron de conception fabrique classique ne peut pas être implémenté en Go dû à l’absence de fonctionnalités POO comme les classes et l’héritage. Ceci étant, nous pouvons tout de même implémenter la version basique du patron, la fabrique simple.

Dans cet exemple, nous allons construire différents types d’armes à feu en utilisant une struct fabrique.

Tout d’abord, nous créons l’interface iGun qui définit les méthodes que n’importe quelle arme à feu devrait avoir. Une struct gun implémente l’interface iGun. Deux armes à feu concrètes (ak47 et musket) sont imbriquées dans la struct gun et implémentent indirectement toutes les méthodes de iGun.

La struct gunFactory sert de fabrique qui crée des armes à feu du type demandé en fonction de l’argument fourni. main.go sert de client. Il repose sur gunFactory pour créer des instances des différentes armes à feu au lieu d’interagir directement avec ak47 ou musket et n’utilise que des paramètres sous forme de chaînes de caractère pour contrôler la production.

iGun.go: Interface produit

package main

type iGun interface {
	setName(name string)
	setPower(power int)
	getName() string
	getPower() int
}

gun.go: Produit concret

package main

type gun struct {
	name  string
	power int
}

func (g *gun) setName(name string) {
	g.name = name
}

func (g *gun) getName() string {
	return g.name
}

func (g *gun) setPower(power int) {
	g.power = power
}

func (g *gun) getPower() int {
	return g.power
}

ak47.go: Produit concret

package main

type ak47 struct {
	gun
}

func newAk47() iGun {
	return &ak47{
		gun: gun{
			name:  "AK47 gun",
			power: 4,
		},
	}
}

musket.go: Produit concret

package main

type musket struct {
	gun
}

func newMusket() iGun {
	return &musket{
		gun: gun{
			name:  "Musket gun",
			power: 1,
		},
	}
}

gunFactory.go: Fabrique

package main

import "fmt"

func getGun(gunType string) (iGun, error) {
	if gunType == "ak47" {
		return newAk47(), nil
	}
	if gunType == "musket" {
		return newMusket(), nil
	}
	return nil, fmt.Errorf("Wrong gun type passed")
}

main.go: Code client

package main

import "fmt"

func main() {
	ak47, _ := getGun("ak47")
	musket, _ := getGun("musket")

	printDetails(ak47)
	printDetails(musket)
}

func printDetails(g iGun) {
	fmt.Printf("Gun: %s", g.getName())
	fmt.Println()
	fmt.Printf("Power: %d", g.getPower())
	fmt.Println()
}

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

Gun: AK47 gun
Power: 4
Gun: Musket gun
Power: 1

Fabrique dans les autres langues

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