Go语言常见的设计模式有哪些？

磊丰 Go语言圈 2023-10-24 08:30 发表于中国香港

收录于合集#学Go语言哪些事儿229个

MySQL大牛

带你全面剖析与系统梳理数据库(mysql等)知识分享，总结数据库技巧和方法，提升你的技术技能。

45篇原创内容

公众号

JetBrains全家桶正式版激活码&账号开通授权，支持版本升级

https://web.52shizhan.cn/activity/jump/link

学习与交流：Go语言技术微信群

商务合作加微信：LetsFeng

现在就开始你的Go语言学习之旅吧！人生苦短，let’s Go.

Go语言中常见的设计模式包括：

1 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局访问点。

示例代码如下：

package main

import "fmt"

type Singleton struct {
    data string
}

var instance *Singleton

func GetInstance() *Singleton {
    if instance == nil {
        instance = &Singleton{data: "singleton instance"}
    }
    return instance
}

func main() {
    singleton1 := GetInstance()
    singleton2 := GetInstance()

    if singleton1 == singleton2 {
        fmt.Println("Both singletons are the same instance")
    } else {
        fmt.Println("Different instances")
    }
}

2 工厂模式（Factory Pattern）：通过工厂方法创建对象，而无需指定创建对象的具体类。

示例代码如下：

package main

import "fmt"

type Product interface {
    GetInfo() string
}

type ConcreteProduct1 struct{}

func (p *ConcreteProduct1) GetInfo() string {
    return "Product 1"
}

type ConcreteProduct2 struct{}

func (p *ConcreteProduct2) GetInfo() string {
    return "Product 2"
}

type Factory struct{}

func (f *Factory) CreateProduct(productType int) Product {
    switch productType {
    case 1:
        return &ConcreteProduct1{}
    case 2:
        return &ConcreteProduct2{}
    default:
        return nil
    }
}

func main() {
    factory := &Factory{}
    product1 := factory.CreateProduct(1)
    product2 := factory.CreateProduct(2)

    fmt.Println(product1.GetInfo())
    fmt.Println(product2.GetInfo())
}

3 装饰器模式（Decorator Pattern）：允许向现有对象添加新功能，同时保持其结构不变。

示例代码如下：

package main

import "fmt"

type Component interface {
    Operation() string
}

type ConcreteComponent struct{}

func (c *ConcreteComponent) Operation() string {
    return "Concrete Component"
}

type Decorator struct {
    component Component
}

func (d *Decorator) Operation() string {
    return "Decorator " + d.component.Operation()
}

func main() {
    component := &ConcreteComponent{}
    decorator := &Decorator{component: component}

    fmt.Println(component.Operation())
    fmt.Println(decorator.Operation())
}

4 观察者模式（Observer Pattern）：定义了对象之间的一对多依赖关系，使得当一个对象改变状态时，其所有依赖对象都会收到通知并自动更新。

示例代码如下：

package main

import "fmt"

type Observer interface {
    Update(string)
}

type Subject struct {
    observers []Observer
    state     string
}

func (s *Subject) Attach(observer Observer) {
    s.observers = append(s.observers, observer)
}

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

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

type ConcreteObserver struct {
    name string
}

func (co *ConcreteObserver) Update(state string) {
    fmt.Printf("Observer %s received the state: %s\n", co.name, state)
}

func main() {
    subject := &Subject{}
    observer1 := &ConcreteObserver{name: "Observer 1"}
    observer2 := &ConcreteObserver{name: "Observer 2"}

    subject.Attach(observer1)
    subject.Attach(observer2)

    subject.SetState("new state")
}

这些是在Go语言中常见的几种设计模式，它们可以帮助开发人员组织代码并解决特定的设计问题。在实际开发中，选择适当的设计模式取决于应用程序的需求和架构。

文章首发：

更多相关Go语言的技术文章或视频教程，请关注本公众号获取并查看，感谢你的支持与信任！

收录于合集 #学Go语言哪些事儿

229个

上一篇用 Go语言在处理队列时，redis如何做生产与消费订单任务的。守护进程又是如何写？下一篇Go语言如何在终端打开实现进度条处理数据

喜欢此内容的人还喜欢

为什么越来越多的公司选择Golang？

Go语言圈

不看的原因

内容质量低
不看此公众号

Go语言是如何实现反向代理与各种负载均衡策略的。

6.1 链式调用

构造函数可以返回结构体的指针，并且可以使用链式调用来设置结构体的字段值，从而提高代码的可读性。

func NewMyStruct() *MyStruct {
    return &MyStruct{}
}

func (s *MyStruct) WithField1(value int) *MyStruct {
    s.Field1 = value
    return s
}

func (s *MyStruct) WithField2(value string) *MyStruct {
    s.Field2 = value
    return s
}

通过按照上述章节的建议，你可以编写更清晰、可维护和可扩展的 Go 语言构造函数。这将有助于提高你的代码质量和可读性。

Go语言圈

不看的原因