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.
Monteur

Monteur en Go

Le Monteur est un patron de conception de création qui permet de construire des objets complexes étape par étape.

Le monteur n’est pas comme les autres patrons de création : les produits n’ont pas besoin d’avoir une interface commune. Il est ainsi possible de créer différents produits en utilisant le même procédé de fabrication.

Exemple conceptuel

Le monteur est également utilisé lorsqu’un produit est complexe et requiert plusieurs étapes pour être fabriqué. Dans ce cas, il est plus simple de mettre en place plusieurs méthodes de construction qu’un seul constructeur monstrueux. Ce processus de fabrication en plusieurs étapes peut poser problème, car on va potentiellement pouvoir passer un produit incomplet et instable au client. Le monteur pallie à ce problème en gardant le produit privé jusqu’à ce qu’il soit complètement fabriqué.

Dans le code ci-dessous, plusieurs types de maisons (igloo et normalHouse) sont construites par iglooBuilder et normalBuilder. Chaque type de maison comporte les mêmes étapes de construction. La struct directeur (facultative) nous aide à organiser le processus de montage.

iBuilder.go: Interface du monteur

package main

type iBuilder interface {
	setWindowType()
	setDoorType()
	setNumFloor()
	getHouse() house
}

func getBuilder(builderType string) iBuilder {
	if builderType == "normal" {
		return &normalBuilder{}
	}

	if builderType == "igloo" {
		return &iglooBuilder{}
	}
	return nil
}

normalBuilder.go: Monteur concret

package main

type normalBuilder struct {
	windowType string
	doorType   string
	floor      int
}

func newNormalBuilder() *normalBuilder {
	return &normalBuilder{}
}

func (b *normalBuilder) setWindowType() {
	b.windowType = "Wooden Window"
}

func (b *normalBuilder) setDoorType() {
	b.doorType = "Wooden Door"
}

func (b *normalBuilder) setNumFloor() {
	b.floor = 2
}

func (b *normalBuilder) getHouse() house {
	return house{
		doorType:   b.doorType,
		windowType: b.windowType,
		floor:      b.floor,
	}
}

iglooBuilder.go: Monteur concret

package main

type iglooBuilder struct {
	windowType string
	doorType   string
	floor      int
}

func newIglooBuilder() *iglooBuilder {
	return &iglooBuilder{}
}

func (b *iglooBuilder) setWindowType() {
	b.windowType = "Snow Window"
}

func (b *iglooBuilder) setDoorType() {
	b.doorType = "Snow Door"
}

func (b *iglooBuilder) setNumFloor() {
	b.floor = 1
}

func (b *iglooBuilder) getHouse() house {
	return house{
		doorType:   b.doorType,
		windowType: b.windowType,
		floor:      b.floor,
	}
}

house.go: Produit

package main

type house struct {
	windowType string
	doorType   string
	floor      int
}

director.go: Directeur

package main

type director struct {
	builder iBuilder
}

func newDirector(b iBuilder) *director {
	return &director{
		builder: b,
	}
}

func (d *director) setBuilder(b iBuilder) {
	d.builder = b
}

func (d *director) buildHouse() house {
	d.builder.setDoorType()
	d.builder.setWindowType()
	d.builder.setNumFloor()
	return d.builder.getHouse()
}

main.go: Code client

package main

import "fmt"

func main() {
	normalBuilder := getBuilder("normal")
	iglooBuilder := getBuilder("igloo")

	director := newDirector(normalBuilder)
	normalHouse := director.buildHouse()

	fmt.Printf("Normal House Door Type: %s\n", normalHouse.doorType)
	fmt.Printf("Normal House Window Type: %s\n", normalHouse.windowType)
	fmt.Printf("Normal House Num Floor: %d\n", normalHouse.floor)

	director.setBuilder(iglooBuilder)
	iglooHouse := director.buildHouse()

	fmt.Printf("\nIgloo House Door Type: %s\n", iglooHouse.doorType)
	fmt.Printf("Igloo House Window Type: %s\n", iglooHouse.windowType)
	fmt.Printf("Igloo House Num Floor: %d\n", iglooHouse.floor)

}

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

Normal House Door Type: Wooden Door
Normal House Window Type: Wooden Window
Normal House Num Floor: 2

Igloo House Door Type: Snow Door
Igloo House Window Type: Snow Window
Igloo House Num Floor: 1

Monteur dans les autres langues

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