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

Pont en Go

Le Pont est un patron de conception structurel qui scinde la logique métier ou divise de grandes classes dans des hiérarchies de classes séparées qui vont ensuite évoluer indépendamment.

Une de ces hiérarchies (souvent appelée l’abstraction) gardera une référence vers un objet de la seconde hiérarchie (l’implémentation). L’abstraction pourra déléguer certains (parfois la majorité) de ses appels aux objets de l’implémentation. Puisque toutes les implémentations ont une interface commune, elles sont interchangeables à l’intérieur de l’abstraction.

Exemple conceptuel

Prenons deux types d’ordinateurs : un sous Mac et un sous Windows. Prenons également deux types d’imprimantes : Epson et HP. Ces ordinateurs et imprimantes doivent pouvoir fonctionner ensemble dans toutes les combinaisons possibles. Le client ne veut pas s’occuper des détails de la connexion entre imprimantes et ordinateurs.

Si nous ajoutons de nouvelles imprimantes, nous ne voulons pas que notre code croisse exponentiellement. Plutôt que de créer quatre structs pour les 2 x 2 combinaisons, nous mettons en place deux hiérarchies :

  • Une hiérarchie d’abstraction : pour nos ordinateurs.
  • Une hiérarchie d’implémentation : pour nos imprimantes.

Ces deux hiérarchies communiquent ensemble via un pont, l’abstraction (ordinateur) gardant une référence vers l’implémentation (imprimante). L’abstraction et l’implémentation peuvent être développées indépendamment l’une de l’autre.

computer.go: Abstraction

package main

type computer interface {
	print()
	setPrinter(printer)
}

mac.go: Abstraction spécialisée

package main

import "fmt"

type mac struct {
	printer printer
}

func (m *mac) print() {
	fmt.Println("Print request for mac")
	m.printer.printFile()
}

func (m *mac) setPrinter(p printer) {
	m.printer = p
}

windows.go: Abstraction spécialisée

package main

import "fmt"

type windows struct {
	printer printer
}

func (w *windows) print() {
	fmt.Println("Print request for windows")
	w.printer.printFile()
}

func (w *windows) setPrinter(p printer) {
	w.printer = p
}

printer.go: Implémentation

package main

type printer interface {
	printFile()
}

epson.go: Implémentation concrète

package main

import "fmt"

type epson struct {
}

func (p *epson) printFile() {
	fmt.Println("Printing by a EPSON Printer")
}

hp.go: Implémentation concrète

package main

import "fmt"

type hp struct {
}

func (p *hp) printFile() {
	fmt.Println("Printing by a HP Printer")
}

main.go: Code client

package main

import "fmt"

func main() {

	hpPrinter := &hp{}
	epsonPrinter := &epson{}

	macComputer := &mac{}

	macComputer.setPrinter(hpPrinter)
	macComputer.print()
	fmt.Println()

	macComputer.setPrinter(epsonPrinter)
	macComputer.print()
	fmt.Println()

	winComputer := &windows{}

	winComputer.setPrinter(hpPrinter)
	winComputer.print()
	fmt.Println()

	winComputer.setPrinter(epsonPrinter)
	winComputer.print()
	fmt.Println()
}

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

Print request for mac
Printing by a HP Printer

Print request for mac
Printing by a EPSON Printer

Print request for windows
Printing by a HP Printer

Print request for windows

Pont dans les autres langues

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