go语言实现常见的设计模式

1. 单例模式 (Singleton Pattern)

单例模式确保一个类只有一个实例，并提供一个全局访问点。

package main

import (
	"fmt"
	"sync"
)

type Singleton struct {
}

var (
	instance *Singleton
	once     sync.Once
)

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

func main() {
	s1 := GetInstance()
	s2 := GetInstance()

	if s1 == s2 {
		fmt.Println("Both instances are the same.")
	} else {
		fmt.Println("Instances are different.")
	}
}

2. 工厂模式 (Factory Pattern)

工厂模式提供了一种创建对象的方式，隐藏了实例化对象的复杂逻辑。

package main

import "fmt"

// Product 是定义了产品接口
type Product interface {
	Use() string
}

// ConcreteProductA 是具体产品A的实现
type ConcreteProductA struct{}

func (p *ConcreteProductA) Use() string {
	return "Using ConcreteProductA"
}

// ConcreteProductB 是具体产品B的实现
type ConcreteProductB struct{}

func (p *ConcreteProductB) Use() string {
	return "Using ConcreteProductB"
}

// Factory 是工厂结构体
type Factory struct{}

func (f *Factory) CreateProduct(productType string) Product {
	switch productType {
	case "A":
		return &ConcreteProductA{}
	case "B":
		return &ConcreteProductB{}
	default:
		return nil
	}
}

func main() {
	factory := &Factory{}

	productA := factory.CreateProduct("A")
	fmt.Println(productA.Use())

	productB := factory.CreateProduct("B")
	fmt.Println(productB.Use())
}

3. 观察者模式 (Observer Pattern)

观察者模式定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖对象都会收到通知并自动更新。

package main

import "fmt"

// Observer 是观察者接口
type Observer interface {
	Update(data string)
}

// Subject 是主题接口
type Subject interface {
	Register(observer Observer)
	Deregister(observer Observer)
	Notify()
}

// ConcreteObserver 是具体的观察者实现
type ConcreteObserver struct {
	name string
}

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

// ConcreteSubject 是具体的主题实现
type ConcreteSubject struct {
	observers []Observer
	data      string
}

func (s *ConcreteSubject) Register(observer Observer) {
	s.observers = append(s.observers, observer)
}

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

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

func (s *ConcreteSubject) SetData(data string) {
	s.data = data
	s.Notify()
}

func main() {
	subject := &ConcreteSubject{}

	observer1 := &ConcreteObserver{name: "Observer1"}
	observer2 := &ConcreteObserver{name: "Observer2"}

	subject.Register(observer1)
	subject.Register(observer2)

	subject.SetData("New Data")
}

4. 策略模式 (Strategy Pattern)

策略模式定义一系列算法，将每个算法封装起来，并使它们可以互换。

package main

import "fmt"

// Strategy 是策略接口
type Strategy interface {
	Execute(a, b int) int
}

// ConcreteStrategyAdd 是加法策略的实现
type ConcreteStrategyAdd struct{}

func (s *ConcreteStrategyAdd) Execute(a, b int) int {
	return a + b
}

// ConcreteStrategySubtract 是减法策略的实现
type ConcreteStrategySubtract struct{}

func (s *ConcreteStrategySubtract) Execute(a, b int) int {
	return a - b
}

// Context 是上下文，持有一个策略的引用
type Context struct {
	strategy Strategy
}

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

func (c *Context) ExecuteStrategy(a, b int) int {
	return c.strategy.Execute(a, b)
}

func main() {
	context := &Context{}

	context.SetStrategy(&ConcreteStrategyAdd{})
	fmt.Println("Add:", context.ExecuteStrategy(5, 3))

	context.SetStrategy(&ConcreteStrategySubtract{})
	fmt.Println("Subtract:", context.ExecuteStrategy(5, 3))
}