Su kokiais projektavimo modeliais esate susipažinęs…

Aš pažįstu įvairius projektavimo modelius, kurie naudojami Go. Kai kurie iš dažniausiai pasitaikančių:

Kūrimo modeliai:

Singleton: Užtikrina, kad egzistuotų tik viena klasės egzempliorius ir suteikia globalią prieigą prie jo. Go dažnai įgyvendinamas naudojant 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: Apibrėžia sąsają objektui kurti, bet leidžia pogrupių spręsti, kokį klasės egzempliorių kurti. Go dažnai įgyvendinamas naudojant funkcijas, grąžinančias sąsają.

package main

type Product interface {
	Operate()
}

type ConcreteProductA struct{}

func (p *ConcreteProductA) Operate() {
	// Operacijos įgyvendinimas
}

type ConcreteProductB struct{}

func (p *ConcreteProductB) Operate() {
	// Operacijos įgyvendinimas
}

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

Abstract Factory: Suteikia sąsają kurti susijusius arba priklausomus objektus be jų konkrečių klasių nurodymo.
Builder: Atskiria sudėtingo objekto konstravimo procesą nuo jo pateikimo.

Struktūriniai modeliai:

Adapter: Paverčia vieno klases sąsają į kitą, kurią klientai reikalauja. Leidžia klasėms dirbti kartu, kitaip nesuderinamoms.
Decorator: Dinamiškai prideda naujas atsakomybės objektui. Dekoratoriai siūlo lankstesnę alternatyvą paveldėjimui funkcionalumo plėtrai.
Facade: Suteikia vieningą sąsają prie sub-sistemų sąsajų rinkinio. Apibrėžia aukšto lygio sąsają, palengvinančią sub-sistemos naudojimą.
Proxy: Suteikia kitą objektą kaip pakaitalą ar užpildą, kad valdytų prieigą prie jo.

Elgsenos modeliai:

Observer: Apibrėžia "vieno prie daug" priklausomybę tarp objektų. Kai keičiasi vieno objekto būsena, visi jo priklausomi objektai yra informuojami ir automatiškai atnaujinami.

Strategy: Apibrėžia algoritmų šeimą, juos inkapsuliuoja ir daro juos keičiamus. Leidžia algoritmams keistis nepriklausomai nuo klientų, kurie juos naudoja.

package main

type Strategy interface {
	Execute(data string)
}

type ConcreteStrategyA struct{}

func (s *ConcreteStrategyA) Execute(data string) {
	// Strategijos A įgyvendinimas
}

type ConcreteStrategyB struct{}

func (s *ConcreteStrategyB) Execute(data string) {
	// Strategijos B įgyvendinimas
}

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: Apibrėžia algoritmo karkasą operacijoje, perkeliant tam tikrus žingsnius į pogrupius. Leidžia pogrupiams keisti tam tikrus algoritmo žingsnius, nekeičiančio jo struktūros.

Be išvardytų, žinau tokius kaip Command, Chain of Responsibility, Iterator, Mediator, Memento, State, Visitor. Go taip pat dažnai naudojasi kalbos specifinėmis dizaino idiomomis, pavyzdžiui, sąsajų naudojimu abstrakcijai, gorutinomis ir kanalais paralelizmui.

Su kokiais projektavimo modeliais esate susipažinęs?