在现代软件开发中，设计模式是一种被广泛采用的思维工具，它可以帮助我们解决复杂的问题，并提供一种优雅和可维护的代码结构。对于Golang开发者来说，熟悉并应用设计模式是非常重要的。本文将介绍一些常见的设计模式，并给出相应的Golang代码示例，帮助读者更好地理解和应用这些模式。

单例模式

单例模式是一种创建型模式，它保证一个类只有一个实例，并提供一个全局访问点。在Golang中，我们可以通过使用sync包的Once类型来实现单例模式。下面是一个简单的例子：

package singleton

import "sync"

type Singleton struct {
    // ...
}

var instance *Singleton
var once sync.Once

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

在上面的代码中，我们将Singleton类型定义为一个结构体，并使用sync包中的Once类型实现线程安全的惰性初始化。GetInstance函数确保只有在第一次调用时才会进行实例化，而后续的调用都返回同一个实例。

工厂模式

工厂模式是一种创建型模式，它提供了一种创建对象的接口，但具体的实现由子类决定。在Golang中，我们可以使用工厂函数来实现工厂模式。下面是一个示例：

package factory

type Vehicle interface {
    Drive() string
}

type Car struct {}

func (c Car) Drive() string {
    return "Driving car..."
}

type Bus struct {}

func (b Bus) Drive() string {
    return "Driving bus..."
}

func CreateVehicle(vehicleType string) (Vehicle, error) {
    switch vehicleType {
    case "car":
        return Car{}, nil
    case "bus":
        return Bus{}, nil
    default:
        return nil, fmt.Errorf("unknown vehicle type")
    }
}

在上面的代码中，我们定义了一个Vehicle接口和两个实现了该接口的结构体：Car和Bus。CreateVehicle函数根据传入的vehicleType参数返回相应的对象实例。通过使用工厂模式，我们可以将具体的对象创建逻辑与客户端代码解耦，从而使代码更加可扩展和可维护。

观察者模式

观察者模式是一种行为型模式，它定义了对象之间的一对多依赖关系，使得每当一个对象状态发生改变时，其依赖对象都会收到通知并自动更新。在Golang中，我们可以使用channel实现观察者模式。下面是一个简单的示例：

package observer

type Observer interface {
    Update(string)
}

type Subject struct {
    observers []Observer
}

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

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

type ConcreteObserver struct {
    name string
}

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

在上面的代码中，我们定义了Observer接口和Subject结构体。Subject结构体内部维护一个Observer的切片，可以通过Attach方法添加观察者，通过Notify方法发送通知。ConcreteObserver结构体实现了Observer接口，并定义了自己的更新逻辑。通过使用观察者模式，我们可以实现松耦合的对象之间的通信。