Entwurfsmuster in Go mit Beispielen: von A bis Z

Entwurfsmuster in Go mit Beispielen: von A bis Z

Entwurfsmuster (Design Patterns) sind bewährte architektonische Lösungen, die Go-Entwicklern helfen, flexiblen, skalierbaren und wartbaren Code zu erstellen. Im Gegensatz zu klassischen OOP-Sprachen bietet Go einen einzigartigen Ansatz zur Implementierung von Mustern durch Interfaces, Komposition und Goroutinen. In diesem Artikel analysieren wir die wichtigsten Entwurfsmuster in Go mit konkreten Codebeispielen.

1. Erzeugungsmuster (Creational Patterns)

Erzeugungsmuster sind für die Objekterstellung verantwortlich und machen das System unabhängig von der Art und Weise ihrer Erstellung.

1.1. Singleton (Einzelstück)

Singleton stellt sicher, dass eine Klasse nur eine Instanz hat. In Go wird dies oft mit sync.Once für Threadsicherheit implementiert.

package main

import (    "fmt"    "sync")

type Database struct {    connection string}

var (    instance *Database    once     sync.Once)

func GetDatabaseInstance() *Database {    once.Do(func() {        instance = &Database{connection: "postgres://localhost:5432/mydb"}        fmt.Println("Einzige Datenbankverbindung erstellt")    })    return instance}

func main() {    db1 := GetDatabaseInstance()    db2 := GetDatabaseInstance()    fmt.Println(db1 == db2) // true}

1.2. Factory Method (Fabrikmethode)

Die Factory delegiert die Objekterstellung an Unterklassen. In Go wird dies mit Interfaces umgesetzt.

package main

import "fmt"

// Produkt-Interfacetype Transport interface {    Deliver() string}

// Konkrete Produktetype Truck struct{}func (t Truck) Deliver() string { return "Lieferung auf dem Landweg" }

type Ship struct{}func (s Ship) Deliver() string { return "Lieferung auf dem Seeweg" }

// Factorytype LogisticsFactory interface {    CreateTransport() Transport}

type RoadLogistics struct{}func (r RoadLogistics) CreateTransport() Transport { return Truck{} }

type SeaLogistics struct{}func (s SeaLogistics) CreateTransport() Transport { return Ship{} }

func main() {    var factory LogisticsFactory = RoadLogistics{}    transport := factory.CreateTransport()    fmt.Println(transport.Deliver()) // Lieferung auf dem Landweg}

2. Strukturmuster (Structural Patterns)

Strukturmuster helfen, Klassen und Objekte in größere Strukturen zu organisieren.

2.1. Adapter (Adapter)

Der Adapter ermöglicht es Objekten mit inkompatiblen Interfaces, zusammenzuarbeiten. In Go wird dies durch einen Wrapper gelöst.

package main

import "fmt"

// Altes Interfacetype OldPrinter interface {    PrintOld(data string)}

type LegacyPrinter struct{}func (l LegacyPrinter) PrintOld(data string) {    fmt.Println("Legacy:", data)}

// Neues Interfacetype NewPrinter interface {    PrintNew(data string)}

// Adaptertype PrinterAdapter struct {    OldPrinter OldPrinter}

func (a PrinterAdapter) PrintNew(data string) {    a.OldPrinter.PrintOld(data)}

func main() {    legacy := LegacyPrinter{}    adapter := PrinterAdapter{OldPrinter: legacy}    adapter.PrintNew("Hello, Go!") // Legacy: Hello, Go!}

2.2. Composite (Kompositum)

Das Kompositum ermöglicht die Behandlung von Gruppen von Objekten als einzelnes Objekt. Ideal für Baumstrukturen.

package main

import "fmt"

// Komponenten-Interfacetype Graphic interface {    Draw() string}

// Blattelementtype Circle struct{}func (c Circle) Draw() string { return "Kreis zeichnen" }

// Containertype CompoundGraphic struct {    children []Graphic}

func (cg *CompoundGraphic) Add(g Graphic) {    cg.children = append(cg.children, g)}

func (cg *CompoundGraphic) Draw() string {    result := "Zusammengesetzte Figur:"    for _, child := range cg.children {        result += "  - " + c