Entwurfsmuster in Go mit Beispielen für Entwickler

Entwurfsmuster in Go (Golang) mit Codebeispielen

Entwurfsmuster sind bewährte Lösungen für typische Entwicklungsaufgaben. In Go, mit seiner prägnanten Syntax und dem Fehlen klassischer OOP, erhalten viele Muster eine einzigartige Implementierung. In diesem Artikel werden wir drei Gruppen von Mustern behandeln: Erzeugungs-, Struktur- und Verhaltensmuster – mit praktischen Beispielen in Golang.

Das Material wird sowohl für Anfänger als auch für erfahrene Go-Entwickler nützlich sein, die sauberen, wiederverwendbaren und testbaren Code schreiben möchten.

1. Erzeugungsmuster (Creational Patterns)

Erzeugungsmuster verwalten den Prozess der Objekterstellung. In Go, wo es keine Konstruktoren und Vererbung gibt, ist ihre Implementierung besonders elegant.

1.1. Singleton (Einzelstück)

Stellt sicher, dass von einem Typ nur eine Instanz existiert, und bietet einen globalen Zugriffspunkt darauf. In Go wird es oft über sync.Once implementiert.

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}

Wann verwenden: Arbeit mit Verbindungspools, Cache, Logger.

1.2. Factory Method (Fabrikmethode)

Definiert eine Schnittstelle zur Erstellung eines Objekts, ermöglicht es Unterklassen jedoch, den Typ des erstellten Objekts zu ändern. In Go ist die Factory Method einfach eine Funktion, die ein Interface zurückgibt.

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    }}

Wann verwenden: wenn der Typ des zu erstellenden Objekts im Voraus nicht bekannt ist.

1.3. Builder (Erbauer)

Trennt die Konstruktion eines komplexen Objekts von seiner Darstellung. In Go ist der Builder eine Struktur mit Setter-Methoden, die sich selbst für den Methodenverkettung zurückgeben.

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}

Wann verwenden: wenn ein Objekt viele optionale Parameter hat.

2. Strukturmuster (Structural Patterns)

Strukturmuster definieren Möglichkeiten, Objekte und Klassen zu größeren Strukturen zusammenzusetzen, wobei Flexibilität und Effizienz erhalten bleiben.

2.1. Adapter (Anpasser)

Ermöglicht Objekten mit inkompatiblen Schnittstellen, zusammenzuarbeiten. In Go werden dafür Interfaces und Wrapper-Strukturen verwendet.

package adapter

import "fmt"

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

// Adaptee (inkompatible Klasse)type MemoryCard struct{}

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

// Adaptertype CardReader struct {    card *MemoryC