Cu ce modele de proiectare sunteți familiarizat…

Sunt familiarizat cu diferite modele de proiectare utilizate în Go. Unele dintre cele mai frecvente:

Modele creational:

Singleton: Asigură că există doar o instanță a unei clase și oferă un punct de acces global la ea. În Go, este adesea implementat folosind sync.Once.

package main

import (
	"sync"
)

type singleton struct{}

var instance *singleton
var once sync.Once

func GetInstance() *singleton {
	once.Do(func() {
		instance = &singleton{}
	})
	return instance
}

Factory Method: Definește o interfață pentru crearea unui obiect, dar permite subclasei să decidă ce clasă să instanțieze. În Go, este adesea implementat folosind funcții care returnează interfețe.

package main

type Product interface {
	Operate()
}

type ConcreteProductA struct{}

func (p *ConcreteProductA) Operate() {
	// Implementarea operației
}

type ConcreteProductB struct{}

func (p *ConcreteProductB) Operate() {
	// Implementarea operației
}

func NewProduct(productType string) Product {
	switch productType {
	case "A":
		return &ConcreteProductA{}
	case "B":
		return &ConcreteProductB{}
	default:
		return nil // Sau eroare
	}
}

Abstract Factory: Oferă o interfață pentru crearea familiilor de obiecte legate sau dependente fără a specifica clasele lor concrete.
Builder: Separă procesul de construire a unui obiect complex de reprezentarea sa.

Modele structurale:

Adapter: Convertește interfața unei clase într-una cerută de clienți. Permite colaborarea claselor incompatibile.
Decorator: Adaugă responsabilități noi unui obiect în mod dinamic. Decoratorii oferă o alternativă flexibilă la moștenire pentru extinderea funcționalității.
Facade: Oferă o interfață unificată pentru un set de interfețe dintr-un subsistem. Definește o interfață de nivel înalt care facilitează utilizarea subsistemului.
Proxy: Oferă un înlocuitor sau reprezentant pentru alt obiect pentru a controla accesul la acesta.

Modele comportamentale:

Observer: Definește o dependență "unu-la-mulți" între obiecte. Când starea unui obiect se schimbă, toate obiectele dependente sunt notificate și actualizate automat.

Strategy: Definește o familie de algoritmi, îi încapsulează pe fiecare și îi face interschimbabili. Permite variația algoritmilor independent de clienții care îi utilizează.

package main

type Strategy interface {
	Execute(data string)
}

type ConcreteStrategyA struct{}

func (s *ConcreteStrategyA) Execute(data string) {
	// Implementarea strategiei A
}

type ConcreteStrategyB struct{}

func (s *ConcreteStrategyB) Execute(data string) {
	// Implementarea strategiei B
}

type Context struct {
	strategy Strategy
}

func (c *Context) SetStrategy(strategy Strategy) {
	c.strategy = strategy
}

func (c *Context) ExecuteStrategy(data string) {
	c.strategy.Execute(data)
}

Template Method: Definește scheletul unui algoritm într-o operație, lăsând anumite pași subclasei. Permite subclasei să redefinească anumite pași ai unui algoritm fără a-i modifica structura.

Pe lângă modelele menționate, cunosc și modele precum Command, Chain of Responsibility, Iterator, Mediator, Memento, State, Visitor. În Go, se folosesc adesea și idiome de proiectare specifice limbajului, cum ar fi utilizarea interfețelor pentru abstractizare, goroutines și canale pentru paralelism.

Cu ce modele de proiectare sunteți familiarizat?