Mit welchen Entwurfsmustern sind Sie vertraut?

Ich bin mit verschiedenen Entwurfsmustern vertraut, die in Go verwendet werden. Einige der häufigsten:

Erzeugungsmuster:

• Singleton: Stellt sicher, dass nur eine Instanz einer Klasse existiert und bietet einen globalen Zugriffspunkt darauf. In Go wird es oft mit sync.Once implementiert.

  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: Definiert eine Schnittstelle zur Objekterstellung, lässt aber Unterklassen entscheiden, welche Klasse instanziiert wird. In Go wird es oft mit Funktionen umgesetzt, die Interfaces zurückgeben.

  package main
  
  type Product interface {
  	Operate()
  }
  
  type ConcreteProductA struct{}
  
  func (p *ConcreteProductA) Operate() {
  	// Implementierung der Operation
  }
  
  type ConcreteProductB struct{}
  
  func (p *ConcreteProductB) Operate() {
  	// Implementierung der Operation
  }
  
  func NewProduct(productType string) Product {
  	switch productType {
  	case "A":
  		return &ConcreteProductA{}
  	case "B":
  		return &ConcreteProductB{}
  	default:
  		return nil // Oder Fehler
  	}
  }
  

• Abstract Factory: Bietet eine Schnittstelle zur Erstellung von Familien verwandter oder abhängiger Objekte, ohne ihre konkreten Klassen anzugeben.
• Builder: Trennt den Konstruktionprozess eines komplexen Objekts von seiner Darstellung.

Strukturmuster:

• Adapter: Wandelt die Schnittstelle einer Klasse in eine andere um, die die Clients erwarten. Ermöglicht die Zusammenarbeit inkompatibler Klassen.
• Decorator: Fügt einem Objekt dynamisch zusätzliche Verantwortlichkeiten hinzu. Decorators bieten eine flexible Alternative zur Vererbung, um Funktionalitäten zu erweitern.
• Facade: Bietet eine einheitliche Schnittstelle zu einer Menge von Schnittstellen in einem Subsystem. Definiert eine höhere Abstraktion, die die Nutzung des Subsystems erleichtert.
• Proxy: Bietet einen Stellvertreter oder Platzhalter für ein anderes Objekt, um den Zugriff darauf zu steuern.

Verhaltensmuster:

• Observer: Definiert eine "1 zu vielen"-Abhängigkeit zwischen Objekten. Wenn ein Objekt seinen Zustand ändert, werden alle abhängigen Objekte benachrichtigt und automatisch aktualisiert.
• Strategy: Definiert eine Familie von Algorithmen, kapselt jeden und macht sie austauschbar. Ermöglicht es, Algorithmen unabhängig von den Clients, die sie verwenden, zu variieren.

  package main
  
  type Strategy interface {
  	Execute(data string)
  }
  
  type ConcreteStrategyA struct{}
  
  func (s *ConcreteStrategyA) Execute(data string) {
  	// Implementierung der Strategie A
  }
  
  type ConcreteStrategyB struct{}
  
  func (s *ConcreteStrategyB) Execute(data string) {
  	// Implementierung der Strategie 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: Definiert den Rahmenalgorithmus in einer Operation, wobei einige Schritte an Unterklassen delegiert werden. Ermöglicht es Unterklassen, bestimmte Schritte eines Algorithmus neu zu definieren, ohne die Struktur zu verändern.

Neben den genannten Mustern kenne ich auch Muster wie Command, Chain of Responsibility, Iterator, Mediator, Memento, State, Visitor. In Go werden auch häufig idiomatische Entwurfsmuster verwendet, wie die Nutzung von Interfaces zur Abstraktion, Goroutines und Kanäle für Parallelität.