Ar kuriem dizaina modeļiem jūs esat iepazinies…

Es zinu dažādus projektēšanas modeļus, kas tiek izmantoti Go. Daži no biežāk sastopamajiem:

Izveides modeļi:

Singleton: Nodrošina, ka pastāv tikai viens klases instances un nodrošina globālu piekļuvi tam. Go bieži realizē ar 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: Definē saskarni objektu izveidei, bet ļauj apakšklasēm izlemt, kuru klasi instancēt. Go bieži realizē ar funkcijām, kas atgriež saskarni.

package main

type Product interface {
	Operate()
}

type ConcreteProductA struct{}

func (p *ConcreteProductA) Operate() {
	// Operācijas realizācija
}

type ConcreteProductB struct{}

func (p *ConcreteProductB) Operate() {
	// Operācijas realizācija
}

func NewProduct(productType string) Product {
	switch productType {
	case "A":
		return &ConcreteProductA{}
	case "B":
		return &ConcreteProductB{}
	default:
		return nil // Vai kļūda
	}
}

Abstract Factory: Nodrošina saskarni saistītu vai atkarīgu objektu sēriju izveidei bez to konkrētu klasu norādīšanas.
Builder: Atšķir sarežģīta objekta būvniecības procesu no tā prezentācijas.

Strukturālie modeļi:

Adapter: Pārvērš viena klases saskarni citā, kas nepieciešama klientiem. Ļauj klasēm sadarboties, kas citādi būtu nesaderīgas.
Decorator: Dinamiski pievieno jaunas atbildības objektam. Dekoratori nodrošina elastīgāku alternatīvu mantošanai funkcionalitātes paplašināšanai.
Facade: Nodrošina vienotu saskarni pie sub-sistēmas saskarnēm. Definē augstākā līmeņa saskarni, kas atvieglo sub-sistēmas izmantošanu.
Proxy: Nodrošina aizstājēju vai aizpildītāju citam objektam, lai pārvaldītu piekļuvi tam.

Uzvedības modeļi:

Observer: Definē "viena pret daudz" atkarību starp objektiem. Kad mainās viena objekta stāvoklis, visi tā atkarīgie objekti tiek informēti un automātiski atjaunināti.

Strategy: Definē algoritmu ģimeni, to inkapsulē un padara tos maināmus. Ļauj algoritmiem mainīties neatkarīgi no klientiem, kas tos izmanto.

package main

type Strategy interface {
	Execute(data string)
}

type ConcreteStrategyA struct{}

func (s *ConcreteStrategyA) Execute(data string) {
	// Stratēģijas A realizācija
}

type ConcreteStrategyB struct{}

func (s *ConcreteStrategyB) Execute(data string) {
	// Stratēģijas B realizācija
}

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: Definē algoritma karkasu operācijā, pārvietojot dažus soļus uz apakšklasēm. Ļauj apakšklasēm pārdefinēt noteiktus algoritma soļus, nemainot tā struktūru.

Papildus uzskaitītajiem, zinu arī tādus kā Command, Chain of Responsibility, Iterator, Mediator, Memento, State, Visitor. Go bieži izmanto arī valodas specifiskas dizaina idiomas, piemēram, saskarnes abstrakcijai, gorutinas un kanālus paralēlismam.

Ar kuriem dizaina modeļiem jūs esat iepazinies?