「Golang设计模式」Golang 常见设计模式介绍

Golang 作为一门新兴的编程语言，也拥有着自己的设计模式。设计模式是软件开发经验的总结和教训的体现，是能用于解决某类问题的模板或范本，它不是代码，而是一种面向对象的设计思想。本文将对 Golang 常见的设计模式进行介绍。

一. 创建型模式

1. 单例模式

单例模式是一种常见的创建型模式，它保证某个类只有一个实例，并提供一个全局访问点。在 Golang 中，单例模式可以通过 sync.Once 实现一次性的代码执行，从而保证只有一次实例化。

```go
type singleton struct{}

var instance *singleton
var once sync.Once

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

2. 工厂模式

工厂模式是一个创建对象的接口，让子类决定实例化哪一个类。在 Golang 中，工厂模式可以通过一个工厂函数实现，返回一个接口或结构体实例，隐藏了对象的创建过程。

```go
type IProduct interface {
    printProduct()
}

type ConcreteProductA struct{}

func (c *ConcreteProductA) printProduct() {
    fmt.Println("Product A")
}

type ConcreteProductB struct{}

func (c *ConcreteProductB) printProduct() {
    fmt.Println("Product B")
}

func CreateProduct(productType string) IProduct {
    switch productType {
    case "A":
        return &ConcreteProductA{}
    case "B":
        return &ConcreteProductB{}
    default:
        return nil
    }
}
```

二. 结构型模式

1. 适配器模式

适配器模式将一个类的接口转换成客户希望的另外一个接口。在 Golang 中，适配器模式可以使用接口实现，将不兼容的接口转换成需要的接口。

```go
type Target interface {
    request() string
}

type Adaptee struct {}

func (*Adaptee) specificRequest() string {
    return "Adaptee"
}

type Adapter struct {
    adaptee *Adaptee
}

func (a *Adapter) request() string {
    return a.adaptee.specificRequest()
}

func NewAdapter(adaptee *Adaptee) Target {
    return &Adapter{adaptee: adaptee}
}
```

2. 装饰器模式

装饰器模式可以在不改变原有对象结构的情况下，动态地给对象添加一些职责。在 Golang 中，装饰器模式可以使用匿名组合实现。

```go
type Component interface {
    operation() string
}

type ConcreteComponent struct {}

func (*ConcreteComponent) operation() string {
    return "ConcreteComponent"
}

type Decorator struct {
    component Component
}

func (d *Decorator) operation() string {
    return d.component.operation()
}

type ConcreteDecoratorA struct {
    Decorator
}

func (c *ConcreteDecoratorA) operation() string {
    return "ConcreteDecoratorA " + c.component.operation()
}

type ConcreteDecoratorB struct {
    Decorator
}

func (c *ConcreteDecoratorB) operation() string {
    return "ConcreteDecoratorB " + c.component.operation()
}
```

三. 行为型模式

1. 策略模式

策略模式定义一系列算法，将它们封装起来，并且使它们可以相互替换。在 Golang 中，策略模式可以通过接口实现。

```go
type Strategy interface {
    doStrategy() string
}

type Context struct {
    strategy Strategy
}

func (c *Context) setStrategy(strategy Strategy) {
    c.strategy = strategy
}

func (c *Context) execute() string {
    return c.strategy.doStrategy()
}

type ConcreteStrategyA struct{}

func (*ConcreteStrategyA) doStrategy() string {
    return "Strategy A"
}

type ConcreteStrategyB struct{}

func (*ConcreteStrategyB) doStrategy() string {
    return "Strategy B"
}
```

2. 观察者模式

观察者模式定义了一个一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。在 Golang 中，观察者模式可以使用 channel 和 goroutine 实现。

```go
type IObserver interface {
    update(msg string)
}

type ISubject interface {
    register(observer IObserver)
    unregister(observer IObserver)
    notifyAll()
}

type Subject struct {
    observers []IObserver
}

func (s *Subject) register(observer IObserver) {
    s.observers = append(s.observers, observer)
}

func (s *Subject) unregister(observer IObserver) {
    for i, o := range s.observers {
        if o == observer {
            s.observers = append(s.observers[:i], s.observers[i+1:]...)
            break
        }
    }
}

func (s *Subject) notifyAll(msg string) {
    for _, o := range s.observers {
        go o.update(msg)
    }
}

type ConcreteObserverA struct{}

func (*ConcreteObserverA) update(msg string) {
    fmt.Println("Observer A : ", msg)
}

type ConcreteObserverB struct{}

func (*ConcreteObserverB) update(msg string) {
    fmt.Println("Observer B : ", msg)
}
```

以上就是 Golang 常见的设计模式介绍了。设计模式在实际编程中具有重要的意义，它能提高代码的质量、可维护性和可扩展性，值得我们深入学习和应用。