Penerokaan corak reka bentuk kod sumber rangka kerja golang

Corak reka bentuk rangka kerja Go: Corak Singleton: Pastikan hanya satu tika objek wujud, dilaksanakan melalui pembolehubah global dan permulaan sekali. Corak Kilang: Cipta berbilang variasi objek, cipta objek secara dinamik melalui pembekal. Corak pemerhati: Memberitahu objek bergantung apabila keadaan objek berubah, dan dilaksanakan melalui pemerhati yang boleh diperhatikan.

Penerokaan corak reka bentuk kod sumber rangka kerja

Dalam rangka kerja Go, corak reka bentuk digunakan secara meluas untuk mengoptimumkan struktur kod, meningkatkan kebolehselenggaraan dan kebolehskalaan. Artikel ini akan meneroka corak reka bentuk biasa dalam rangka kerja Go dan menunjukkan aplikasi praktikalnya melalui kes praktikal.

Singleton Pattern

Masalah: Pastikan hanya satu contoh objek wujud.

Penyelesaian: Buat pembolehubah global dan mulakannya pada akses pertama.

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
}

Corak Kilang

Masalah: Buat berbilang variasi objek.

Penyelesaian: Buat pembekal kilang untuk mencipta objek secara dinamik.

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

Corak Pemerhati

Masalah: Beritahu berbilang objek bergantung apabila keadaan objek berubah.

Penyelesaian: Buat objek yang boleh diperhatikan (boleh diperhatikan) dan berbilang pemerhati. Apabila perubahan yang diperhatikan, ia memberitahu semua pemerhati.

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
}

Corak reka bentuk ini digunakan secara meluas dalam rangka kerja Go Menguasai corak reka bentuk ini akan meningkatkan kualiti dan kebolehselenggaraan kod anda.

Atas ialah kandungan terperinci Penerokaan corak reka bentuk kod sumber rangka kerja golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!