Golang常用设计模式解析与实践指南

以下是针对Go语言中单例模式、观察者模式、工厂模式和桥接模式的实现示例：

单例模式

package singleton

import (
    "sync"
)

type Singleton struct {
    value string
}

var (
    instance *Singleton
    once     sync.Once
)

func GetInstance() *Singleton {
    once.Do(func() {
        instance = &Singleton{value: "initial value"}
    })
    return instance
}

func (s *Singleton) GetValue() string {
    return s.value
}

func (s *Singleton) SetValue(v string) {
    s.value = v
}

观察者模式

package observer

import "fmt"

type Observer interface {
    Update(message string)
}

type Subject interface {
    Register(observer Observer)
    Deregister(observer Observer)
    Notify()
}

type ConcreteSubject struct {
    observers []Observer
    state     string
}

func (s *ConcreteSubject) Register(observer Observer) {
    s.observers = append(s.observers, observer)
}

func (s *ConcreteSubject) Deregister(observer Observer) {
    for i, obs := range s.observers {
        if obs == observer {
            s.observers = append(s.observers[:i], s.observers[i+1:]...)
            break
        }
    }
}

func (s *ConcreteSubject) Notify() {
    for _, observer := range s.observers {
        observer.Update(s.state)
    }
}

func (s *ConcreteSubject) SetState(state string) {
    s.state = state
    s.Notify()
}

type ConcreteObserver struct {
    id string
}

func (o *ConcreteObserver) Update(message string) {
    fmt.Printf("Observer %s received: %s\n", o.id, message)
}

工厂模式

package factory

import "fmt"

type Product interface {
    Use() string
}

type ConcreteProductA struct{}

func (p *ConcreteProductA) Use() string {
    return "Product A"
}

type ConcreteProductB struct{}

func (p *ConcreteProductB) Use() string {
    return "Product B"
}

type Creator interface {
    CreateProduct() Product
}

type ConcreteCreatorA struct{}

func (c *ConcreteCreatorA) CreateProduct() Product {
    return &ConcreteProductA{}
}

type ConcreteCreatorB struct{}

func (c *ConcreteCreatorB) CreateProduct() Product {
    return &ConcreteProductB{}
}

func CreateProduct(creator Creator) {
    product := creator.CreateProduct()
    fmt.Println(product.Use())
}

桥接模式

package bridge

import "fmt"

type Implementor interface {
    OperationImpl() string
}

type ConcreteImplementorA struct{}

func (c *ConcreteImplementorA) OperationImpl() string {
    return "Implementor A"
}

type ConcreteImplementorB struct{}

func (c *ConcreteImplementorB) OperationImpl() string {
    return "Implementor B"
}

type Abstraction interface {
    Operation() string
}

type RefinedAbstraction struct {
    implementor Implementor
}

func (r *RefinedAbstraction) Operation() string {
    return fmt.Sprintf("Abstraction using %s", r.implementor.OperationImpl())
}

func NewRefinedAbstraction(impl Implementor) *RefinedAbstraction {
    return &RefinedAbstraction{implementor: impl}
}

使用示例

package main

import (
    "fmt"
    "yourmodule/singleton"
    "yourmodule/observer"
    "yourmodule/factory"
    "yourmodule/bridge"
)

func main() {
    // 单例模式使用
    s1 := singleton.GetInstance()
    s2 := singleton.GetInstance()
    fmt.Println(s1 == s2) // true
    
    // 观察者模式使用
    subject := &observer.ConcreteSubject{}
    obs1 := &observer.ConcreteObserver{id: "1"}
    obs2 := &observer.ConcreteObserver{id: "2"}
    
    subject.Register(obs1)
    subject.Register(obs2)
    subject.SetState("new state")
    
    // 工厂模式使用
    creatorA := &factory.ConcreteCreatorA{}
    creatorB := &factory.ConcreteCreatorB{}
    
    factory.CreateProduct(creatorA)
    factory.CreateProduct(creatorB)
    
    // 桥接模式使用
    implA := &bridge.ConcreteImplementorA{}
    implB := &bridge.ConcreteImplementorB{}
    
    abstraction1 := bridge.NewRefinedAbstraction(implA)
    abstraction2 := bridge.NewRefinedAbstraction(implB)
    
    fmt.Println(abstraction1.Operation())
    fmt.Println(abstraction2.Operation())
}

这些示例展示了Go语言中设计模式的典型实现方式，利用了Go的接口、结构体和并发原语等特性。