第七十四天

项目中用到哪些设计模式?

Go语言的设计模式深受Go语言特性的影响，它鼓励简洁明了、并发友好、易于理解的设计风格。以下是一些在Go语言中常见的设计模式：

1. 单例模式（Singleton）
   在Go中，由于没有构造函数，通常通过初始化全局变量并在包内部暴露一个公开函数来获取实例的方式来实现单例模式。

package singleton

var instance *Singleton

type Singleton struct {}

func GetInstance() *Singleton {
    if instance == nil {
        instance = &Singleton{}
    }
    return instance
}

2. 工厂模式（Factory）
   Go语言通过函数返回不同类型的值或者接口实现工厂模式。例如，创建不同类型数据库连接的工厂函数。

package db

type DB interface {
    Connect() error
    Close() error
    // Other methods...
}

func NewMySQLDB(conf Config) DB {
    return &mysqlDB{config: conf}
}

func NewPostgreSQLDB(conf Config) DB {
    return &postgresDB{config: conf}
}

3. 观察者模式（Observer）
   Go语言可以通过channels实现发布订阅（pub/sub）模式，进而实现观察者模式。例如，通过channel传递事件给多个订阅者。

type Event struct {
    Type string
    Data interface{}
}

type Observer interface {
    Update(event Event)
}

type Observable struct {
    observers []Observer
    events    chan Event
}

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

func (o *Observable) Notify(event Event) {
    for _, observer := range o.observers {
        observer.Update(event)
    }

    // 或者通过channel异步通知
    o.events <- event
}

func (o *Observable) HandleEvents() {
    for event := range o.events {
        // 处理事件
    }
}

4. 责任链模式（Chain of Responsibility）
   可以通过嵌入接口和委托的方式构建一个处理链，每个链节点都有机会处理请求，如果不能处理则转发给下一个节点。

type Handler interface {
    Handle(request Request) error
    SetNext(next Handler)
}

type ConcreteHandlerA struct {
    next Handler
}

func (h *ConcreteHandlerA) Handle(req Request) error {
    // 如果条件满足则处理
    if shouldHandle(req) {
        return handle(req)
    }

    // 否则传递给下一个处理器
    if h.next != nil {
        return h.next.Handle(req)
    }

    return errors.New("not handled")
}

func (h *ConcreteHandlerA) SetNext(next Handler) {
    h.next = next
}

5. 装饰器模式（Decorator）
   Go语言可以通过嵌入结构体和组合的方式来实现装饰器模式，动态地给对象添加额外的责任。

type Component interface {
    Operation() string
}

type ConcreteComponent struct{}

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

type Decorator struct {
    component Component
}

func (d *Decorator) Operation() string {
    before := "Before " + d.component.Operation()
    after := d.component.Operation() + " After"
    return before + " " + after
}

func NewDecorator(component Component) *Decorator {
    return &Decorator{component: component}
}

promethus如何使用的?

https://www.topgoer.cn/docs/prometheus/prometheus-1cct91no7mknf