Go框架中常见的设计模式有哪些？-Golang

首页 2024-07-03 01:32:43

go 常见的框架 4 大型设计模式是：单例模式：确保只有一个实例模式，通常用于控制资源访问或提供全球缓存。工厂模式：在没有指定类别的情况下，提供创建对象界面，使应用程序能够动态创建对象。观察者模式：定义主题和观察者，在主题状态发生变化时通知观察者，实现松散耦合。战略模式：定义界面，使算法行为独立于其类别，并在运行过程中切换算法。

Go 常见的框架 4 大设计模式

为了解决软件开发中常见的问题，设计模式是一种可重用的解决方案。Go 各种设计模式广泛应用于框架中。本文将介绍 4 一种最常见的模式，并提供实战案例来演示它们的应用。

1. 单例模式

单例模式确保一个类只有一个例子，并提供一个全球访问点。它通常用于控制资源访问或提供全球缓存。

实战案例：数据库连接池：

// dbConnPool is a singleton instance of the database connection pool.
var dbConnPool = &DBConnPool{
    MaxConnections: 10,
    DBConnections:  make([]*sql.DB, 0, 10),
}

// New returns a new instance of *DBConnPool.
func New() *DBConnPool {
    dbConnPool = new(DBConnPool)
    return dbConnPool
}

// GetConn retrieves a connection from the pool.
func (db *DBConnPool) GetConn() (*sql.DB, error) {
    // ... logic to get a connection from the pool
}

2. 工厂模式

工厂模式在不指定具体类别的情况下，为创建对象提供界面。这使得应用程序可以在不了解底层实现的情况下动态创建对象。

实战案例：日志记录器

type LoggerFactory interface {
    CreateLogger(loggerType string) Logger
}

type Logger interface {
    Log(level string, message string)
}

type LoggerFactoryImpl struct {
    // ...
}

func (lf *LoggerFactoryImpl) CreateLogger(loggerType string) Logger {
    switch loggerType {
    case "console":
        return &ConsoleLogger{}
    case "file":
        return &FileLogger{}
    default:
        return &DefaultLogger{}
    }
}

func main() {
    lf := &LoggerFactoryImpl{}
    logger := lf.CreateLogger("console")
    logger.Log("INFO", "Hello world!")
}

3. 观察者模式

观察者模式定义了一个对象（主题）和多个依赖对象的集合（观察者）。当主题状态发生变化时，它会通知所有观察者。这允许松散耦合的组件对事件做出反应。

实战案例：事件处理

// Subject is the interface for an event subject.
type Subject interface {
    Attach(o Observer)
    Detach(o Observer)
    NotifyAll()
}

// Observer is the interface for an event observer.
type Observer interface {
    Update(subject Subject)
}

type EventDispatcher struct {
    observers []Observer
}

// Attach attaches an observer to the event dispatcher.
func (ed *EventDispatcher) Attach(o Observer) {
    ed.observers = append(ed.observers, o)
}

// Detach detaches an observer from the event dispatcher.
func (ed *EventDispatcher) Detach(o Observer) {
    for i, observer := range ed.observers {
        if observer == o {
            ed.observers = append(ed.observers[:i], ed.observers[i 1:]...)
            break
        }
    }
}

// NotifyAll notifies all observers.
func (ed *EventDispatcher) NotifyAll() {
    for _, observer := range ed.observers {
        observer.Update(ed)
    }
}

4. 策略模式

策略模式定义了一个允许算法在一个类中独立于使用它的类的界面。这使得应用程序在运行过程中可以动态切换算法。

实战案例：排序算法

type SortAlgorithm interface {
    Sort(data []int)
}

type BubbleSortAlgorithm struct {
    // ...
}

func (b *BubbleSortAlgorithm) Sort(data []int) {
    // ... bubble sort algorithm logic
}

type SelectionSortAlgorithm struct {
    // ...
}

func (s *SelectionSortAlgorithm) Sort(data []int) {
    // ... selection sort algorithm logic
}

func main() {
    data := []int{5, 3, 1, 2, 4}

    // Use bubble sort
    bubbleSort := &BubbleSortAlgorithm{}
    bubbleSort.Sort(data)

    // Use selection sort
    selectionSort := &SelectionSortAlgorithm{}
    selectionSort.Sort(data)
}

Go框架中常见的设计模式有哪些？详情请关注其他相关文章！

阅读全文

上一篇：极致体验，首选远程桌面软件之巅峰之作！
下一篇：没有了

Go框架中常见的设计模式有哪些？-Golang

首页 2024-07-03 01:32:43

最新文章

相关文章