使用Golang实现开发中常用的【实例设计模式】

设计模式是解决常见问题的模板，可以帮助我们提升思维能力，编写更高效、可维护性更强的代码。

单例模式：

描述：确保一个类只有一个实例，并提供一个全局访问点。
优点：节省资源，避免重复创建对象。
缺点：单例对象通常是全局可访问的，容易引起耦合。

package singleton

import (
	"sync"
)

type Singleton struct {
	value string
}

var instance *Singleton
var once sync.Once

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

func (s *Singleton) SetValue(value string) {
	s.value = value
}

func (s *Singleton) GetValue() string {
	return s.value
}

工厂模式：

描述：提供一个创建对象的接口，但由子类决定实例化哪一个类。
优点：将对象的创建和使用分离，提高代码的灵活性。
缺点：增加了代码的复杂性。

package factory

type Product interface {
	Use()
}

type ConcreteProductA struct{}

func (p *ConcreteProductA) Use() {
	println("Using ConcreteProductA")
}

type ConcreteProductB struct{}

func (p *ConcreteProductB) Use() {
	println("Using ConcreteProductB")
}

type Factory interface {
	CreateProduct() Product
}

type ConcreteFactoryA struct{}

func (f *ConcreteFactoryA) CreateProduct() Product {
	return &ConcreteProductA{}
}

type ConcreteFactoryB struct{}

func (f *ConcreteFactoryB) CreateProduct() Product {
	return &ConcreteProductB{}
}

观察者模式：

描述：定义了对象之间的一对多依赖关系，当一个对象的状态改变时，所有依赖于它的对象都会得到通知。
优点：实现了对象之间的松耦合。
缺点：如果观察者数量过多，通知过程可能会变得复杂。

package observer

type Subject interface {
	RegisterObserver(observer Observer)
	RemoveObserver(observer Observer)
	NotifyObservers()
}

type Observer interface {
	Update(data string)
}

type ConcreteSubject struct {
	observers []Observer
	state     string
}

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

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

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

func (s *ConcreteSubject) SetState(state string) {
	s.state = state
	s.NotifyObservers()
}

type ConcreteObserver struct {
	name string
}

func (o *ConcreteObserver) Update(data string) {
	println(o.name, "received:", data)
}

策略模式：

描述：定义一系列算法，把它们一个个封装起来，并且使它们可以互相替换。
优点：算法的变化独立于使用算法的客户。
缺点：增加了代码的复杂性。

package strategy

type Strategy interface {
	Execute(data string) string
}

type Context struct {
	strategy Strategy
}

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

func (c *Context) ExecuteStrategy(data string) string {
	return c.strategy.Execute(data)
}

type ConcreteStrategyA struct{}

func (s *ConcreteStrategyA) Execute(data string) string {
	return "ConcreteStrategyA executed with " + data
}

type ConcreteStrategyB struct{}

func (s *ConcreteStrategyB) Execute(data string) string {
	return "ConcreteStrategyB executed with " + data
}

装饰者模式：

描述：动态地给一个对象添加一些额外的职责，而不必修改对象结构。
优点：增加了代码的灵活性和可扩展性。
缺点：增加了代码的复杂性。

package decorator

type Component interface {
	Operation() string
}

type ConcreteComponent struct{}

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

type Decorator struct {
	component Component
}

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

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

type ConcreteDecoratorA struct {
	Decorator
}

func (d *ConcreteDecoratorA) Operation() string {
	return "ConcreteDecoratorA added to " + d.Decorator.Operation()
}

type ConcreteDecoratorB struct {
	Decorator
}

func (d *ConcreteDecoratorB) Operation() string {
	return "ConcreteDecoratorB added to " + d.Decorator.Operation()
}

代理模式：

描述：为其他对象提供一种代理以控制对这个对象的访问。
优点：增加了安全性和灵活性。
缺点：增加了代码的复杂性。

package proxy

type Subject interface {
	Request() string
}

type RealSubject struct{}

func (r *RealSubject) Request() string {
	return "RealSubject handling request"
}

type Proxy struct {
	realSubject *RealSubject
}

func NewProxy() *Proxy {
	return &Proxy{
		realSubject: &RealSubject{},
	}
}

func (p *Proxy) Request() string {
	// Pre-processing
	println("Proxy: Checking access prior to firing a real request.")
	// Delegate to the real subject
	result := p.realSubject.Request()
	// Post-processing
	println("Proxy: Logging the time of request.")
	return result
}

分别调用不同模式的对象实例：

package main

import (
	"fmt"
	"singleton"
	"factory"
	"observer"
	"strategy"
	"decorator"
	"proxy"
)

func main() {
	// 单例模式
	singleton.GetInstance().SetValue("Hello, Singleton!")
	fmt.Println(singleton.GetInstance().GetValue())

	// 工厂模式
	factoryA := &factory.ConcreteFactoryA{}
	productA := factoryA.CreateProduct()
	productA.Use()

	factoryB := &factory.ConcreteFactoryB{}
	productB := factoryB.CreateProduct()
	productB.Use()

	// 观察者模式
	subject := &observer.ConcreteSubject{}
	observerA := &observer.ConcreteObserver{name: "ObserverA"}
	observerB := &observer.ConcreteObserver{name: "ObserverB"}

	subject.RegisterObserver(observerA)
	subject.RegisterObserver(observerB)

	subject.SetState("New State")

	// 策略模式
	context := &strategy.Context{}
	strategyA := &strategy.ConcreteStrategyA{}
	strategyB := &strategy.ConcreteStrategyB{}

	context.SetStrategy(strategyA)
	fmt.Println(context.ExecuteStrategy("Data"))

	context.SetStrategy(strategyB)
	fmt.Println(context.ExecuteStrategy("Data"))

	// 装饰者模式
	component := &decorator.ConcreteComponent{}
	decoratorA := &decorator.ConcreteDecoratorA{Decorator: *decorator.NewDecorator(component)}
	decoratorB := &decorator.ConcreteDecoratorB{Decorator: *decorator.NewDecorator(decoratorA)}

	fmt.Println(decoratorB.Operation())

	// 代理模式
	proxy := proxy.NewProxy()
	fmt.Println(proxy.Request())
}