Exploration of golang framework source code design patterns

Go framework design pattern: Singleton pattern: Ensure that only one object instance exists, implemented through global variables and one-time initialization. Factory Pattern: Create multiple variants of an object, create objects dynamically through providers. Observer pattern: Notifies dependent objects when the object state changes, and is implemented through observers that can be observed.

Exploration of Go framework source code design patterns

In the Go framework, design patterns are widely used to optimize code structure and improve maintainability performance and scalability. This article will explore commonly used design patterns in the Go framework and demonstrate their practical applications through practical cases.

Singleton pattern

Question: Ensure that only one instance of the object exists.

Solution: Create global variables and initialize them on first access.

package main

import (
    "fmt"
    "sync"
)

type Singleton struct {}

var (
    once sync.Once
    instance *Singleton
)

func GetInstance() *Singleton {
    once.Do(func() {
        instance = &Singleton{}
    })
    return instance
}

func main() {
    instance1 := GetInstance()
    instance2 := GetInstance()
    fmt.Println(instance1 == instance2) // 输出: true
}

Factory Pattern

Problem: Creating multiple variants of an object.

Solution: Create a factory provider to dynamically create objects.

package main

type Animal interface {
    Speak() string
}

type Dog struct {}

func (d *Dog) Speak() string {
    return "Woof!"
}

type Cat struct {}

func (c *Cat) Speak() string {
    return "Meow!"
}

type AnimalFactory struct {}

func (f *AnimalFactory) CreateAnimal(name string) (Animal, error) {
    switch name {
        case "dog":
            return &Dog{}, nil
        case "cat":
            return &Cat{}, nil
        
        default:
            return nil, fmt.Errorf("Unsupported animal type: %s", name)
    }
}

func main() {
    factory := AnimalFactory{}
    dog, _ := factory.CreateAnimal("dog")
    cat, _ := factory.CreateAnimal("cat")
    fmt.Println(dog.Speak()) // 输出: "Woof!"
    fmt.Println(cat.Speak()) // 输出: "Meow!"
}

Observer Pattern

Problem: Notify multiple dependent objects when the state of an object changes.

Solution: Create an observable object (observable) and multiple observers. When the observed changes, it notifies all observers.

package main

import "fmt"

type Observable struct {
    observers []Observer
    state int
}

func (o *Observable) AddObserver(observer Observer) {
    o.observers = append(o.observers, observer)
}

func (o *Observable) NotifyObservers() {
    for _, observer := range o.observers {
        observer.Update(o.state)
    }
}

type Observer interface {
    Update(state int)
}

type ConcreteObserver1 struct {}

func (c *ConcreteObserver1) Update(state int) {
    fmt.Println("Observer 1:", state)
}

type ConcreteObserver2 struct {}

func (c *ConcreteObserver2) Update(state int) {
    fmt.Println("Observer 2:", state)
}

func main() {
    observable := Observable{}
    observer1 := ConcreteObserver1{}
    observer2 := ConcreteObserver2{}
    observable.AddObserver(observer1)
    observable.AddObserver(observer2)
    observable.state = 10
    observable.NotifyObservers()  // 输出: Observer 1: 10, Observer 2: 10
}

These design patterns are widely used in the Go framework. Mastering these design patterns will greatly improve the quality and maintainability of your code.

The above is the detailed content of Exploration of golang framework source code design patterns. For more information, please follow other related articles on the PHP Chinese website!