Modèles de conception en Go avec exemples pour développeurs

Patrons de conception en Go (Golang) avec exemples de code

Les patrons de conception sont des solutions éprouvées aux problèmes de développement courants. En Go, avec sa syntaxe concise et l'absence d'POO classique, de nombreux patrons trouvent une implémentation unique. Dans cet article, nous allons analyser trois groupes de patrons : les patrons de création, les patrons structurels et les patrons comportementaux — avec des exemples pratiques en Golang.

Ce contenu sera utile aussi bien aux débutants qu'aux développeurs Go expérimentés cherchant à écrire un code propre, réutilisable et testable.

1. Patrons de création (Creational Patterns)

Les patrons de création gèrent le processus de création d'objets. En Go, où il n'y a ni constructeurs ni héritage, leur implémentation est particulièrement élégante.

1.1. Singleton (Singleton)

Garantit qu'un type n'a qu'une seule instance et fournit un point d'accès global à celle-ci. En Go, il est souvent implémenté via sync.Once.

package singleton

import (    "sync")

type Database struct {    connection string}

var (    instance *Database    once     sync.Once)

func GetDatabase() *Database {    once.Do(func() {        instance = &Database{connection: "postgres://user:pass@localhost/db"}    })    return instance}

Quand l'utiliser : travail avec un pool de connexions, un cache, un logger.

1.2. Méthode de fabrique (Factory Method)

Définit une interface pour créer un objet, mais permet aux sous-classes de modifier le type d'objet créé. En Go, la méthode de fabrique est simplement une fonction qui retourne une interface.

package factory

import "fmt"

// Product interfacetype INotification interface {    Send(message string) string}

// Concrete productstype Email struct{}

func (e *Email) Send(msg string) string {    return fmt.Sprintf("Email sent: %s", msg)}

type SMS struct{}

func (s *SMS) Send(msg string) string {    return fmt.Sprintf("SMS sent: %s", msg)}

// Factory functionfunc CreateNotification(notifType string) INotification {    switch notifType {    case "email":        return &Email{}    case "sms":        return &SMS{}    default:        return nil    }}

Quand l'utiliser : lorsque le type d'objet à créer est inconnu à l'avance.

1.3. Monteur (Builder)

Sépare la construction d'un objet complexe de sa représentation. En Go, le monteur est une structure avec des méthodes setter qui retournent elles-mêmes pour permettre un appel en chaîne.

package builder

type Pizza struct {    Size     string    Cheese   bool    Pepperoni bool}

type PizzaBuilder struct {    pizza Pizza}

func NewPizzaBuilder() *PizzaBuilder {    return &PizzaBuilder{}}

func (b *PizzaBuilder) SetSize(size string) *PizzaBuilder {    b.pizza.Size = size    return b}

func (b *PizzaBuilder) AddCheese() *PizzaBuilder {    b.pizza.Cheese = true    return b}

func (b *PizzaBuilder) AddPepperoni() *PizzaBuilder {    b.pizza.Pepperoni = true    return b}

func (b *PizzaBuilder) Build() Pizza {    return b.pizza}

Quand l'utiliser : lorsque l'objet a de nombreux paramètres optionnels.

2. Patrons structurels (Structural Patterns)

Les patrons structurels définissent des moyens d'assembler des objets et des classes en structures plus grandes, tout en conservant flexibilité et efficacité.

2.1. Adaptateur (Adapter)

Permet à des objets avec des interfaces incompatibles de fonctionner ensemble. En Go, on utilise pour cela des interfaces et des structures d'encapsulation.

package adapter

import "fmt"

// Target interfacetype USB interface {    ConnectWithUSB() string}

// Adaptee (classe incompatible)type MemoryCard struct{}

func (m *MemoryCard) ReadFromCard() string {    return "Data read from memory card"}

// Adaptertype CardReader struct {    card *MemoryC