创建型模式

单例模式(Singleton)

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

package singleton

import "sync"

type singleton struct{}

var instance *singleton
var once sync.Once

// GetInstance 提供全局访问点来获取唯一的实例
func GetInstance() *singleton {
	once.Do(func() {
		instance = &singleton{}
	})
	return instance
}

工厂方法模式(Factory Method)

定义一个创建对象的接口，但让实现这个接口的工厂来决定实例化哪个类。

package factorymethod

// Operator 是被创建产品对象的接口
type Operator interface {
	Operate(a, b int) int
}

// PlusOperator 是具体的产品对象
type PlusOperator struct{}
func (o *PlusOperator) Operate(a, b int) int { return a + b }

// MinusOperator 是具体的产品对象
type MinusOperator struct{}
func (o *MinusOperator) Operate(a, b int) int { return a - b }

// OperatorFactory 是工厂接口
type OperatorFactory interface {
	Create() Operator
}

// PlusOperatorFactory 是具体的工厂
type PlusOperatorFactory struct{}
func (f PlusOperatorFactory) Create() Operator { return &PlusOperator{} }

// MinusOperatorFactory 是具体的工厂
type MinusOperatorFactory struct{}
func (f MinusOperatorFactory) Create() Operator { return &MinusOperator{} }

抽象工厂模式(Abstract Factory)

创建一个工厂的工厂，用来生产一系列相关的产品，而无需指定其具体类。

package abstractfactory

// Button 是产品接口
type Button interface {
	Click()
}
// Checkbox 是另一个产品接口
type Checkbox interface {
	Check()
}

// GUIFactory 是抽象工厂接口
type GUIFactory interface {
	CreateButton() Button
	CreateCheckbox() Checkbox
}

// WinButton/WinCheckbox 是具体产品
type WinButton struct{}
func (b *WinButton) Click() {}
type WinCheckbox struct{}
func (c *WinCheckbox) Check() {}

// WinFactory 是具体工厂，生产 Windows 风格的产品族
type WinFactory struct{}
func (f *WinFactory) CreateButton() Button { return &WinButton{} }
func (f *WinFactory) CreateCheckbox() Checkbox { return &WinCheckbox{} }

// MacButton/MacCheckbox 等同理...

建造者模式(Builder)

将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。

package builder

// Message 是复杂产品
type Message struct {
	Header string
	Body   string
	Footer string
}

// Builder 是建造者接口
type Builder interface {
	SetHeader(header string) Builder
	SetBody(body string) Builder
	SetFooter(footer string) Builder
	Build() *Message
}

// concreteBuilder 是具体建造者
type concreteBuilder struct {
	msg *Message
}

func NewBuilder() Builder {
	return &concreteBuilder{msg: &Message{}}
}

func (b *concreteBuilder) SetHeader(h string) Builder { b.msg.Header = h; return b }
func (b *concreteBuilder) SetBody(body string) Builder { b.msg.Body = body; return b }
func (b *concreteBuilder) SetFooter(f string) Builder { b.msg.Footer = f; return b }
func (b *concreteBuilder) Build() *Message { return b.msg }

// 用法:
// builder := NewBuilder()
// msg := builder.SetHeader("H").SetBody("B").SetFooter("F").Build()

原型模式(Prototype)

通过复制现有实例来创建新实例，而不是通过类来创建。

package prototype

// Clonable 是原型接口
type Clonable interface {
	Clone() Clonable
}

// File 是具体原型
type File struct {
	Name string
}

func (f *File) Clone() Clonable {
	return &File{Name: f.Name + "_clone"}
}

结构型模式

适配器模式(Adapter)

将一个类型的接口转换成客户端所期望的另一个接口。

package adapter

// Target 是客户端期望的接口
type Target interface {
	Request() string
}

// Adaptee 是已存在的、但接口不兼容的类型
type Adaptee struct{}
func (a *Adaptee) SpecificRequest() string {
	return "specific request"
}

// Adapter 是适配器，它实现了 Target 接口并包含一个 Adaptee
type Adapter struct {
	adaptee *Adaptee
}

func NewAdapter(adaptee *Adaptee) Target {
	return &Adapter{adaptee: adaptee}
}

func (a *Adapter) Request() string {
	return a.adaptee.SpecificRequest()
}

桥接模式(Bridge)

将抽象部分与它的实现部分分离，使它们都可以独立地变化。

package bridge

// MessageSender 是实现部分的接口 (Implementation)
type MessageSender interface {
	Send(message string)
}

// EmailSender 是具体的实现
type EmailSender struct{}
func (s *EmailSender) Send(msg string) { /* 发送邮件 */ }

// SMSSender 是具体的实现
type SMSSender struct{}
func (s *SMSSender) Send(msg string) { /* 发送短信 */ }

// Notification 是抽象部分的接口 (Abstraction)
type Notification interface {
	Notify(message string)
}

// UrgentNotification 是具体的抽象
type UrgentNotification struct {
	Sender MessageSender
}
func (n *UrgentNotification) Notify(msg string) {
	n.Sender.Send("URGENT: " + msg)
}

组合模式(Composite)

将对象组合成树形结构以表示“部分-整体”的层次结构。

package composite

// Component 是组合中的对象声明接口
type Component interface {
	Search(keyword string)
}

// File 是叶子节点
type File struct {
	Name string
}
func (f *File) Search(keyword string) { /* 搜索文件 */ }

// Folder 是容器节点
type Folder struct {
	Name       string
	Components []Component
}
func (f *Folder) Search(keyword string) {
	// 对容器内的每个子节点递归执行 Search
	for _, c := range f.Components {
		c.Search(keyword)
	}
}

装饰器模式(Decorator)

动态地给一个对象添加一些额外的职责。

package decorator

// Component 是被装饰对象的接口
type Component interface {
	Operation() string
}

// ConcreteComponent 是具体的被装饰对象
type ConcreteComponent struct{}
func (c *ConcreteComponent) Operation() string {
	return "ConcreteComponent"
}

// Decorator 是装饰器
type Decorator struct {
	component Component
}

func (d *Decorator) Operation() string {
	return d.component.Operation() // 委派给被包装对象
}

// ConcreteDecoratorA 是具体的装饰器，添加了新功能
type ConcreteDecoratorA struct {
	Decorator
}

func NewConcreteDecoratorA(c Component) Component {
	return &ConcreteDecoratorA{Decorator{component: c}}
}

func (d *ConcreteDecoratorA) Operation() string {
	return "DecoratorA(" + d.component.Operation() + ")"
}

外观模式(Facade)

为子系统中的一组接口提供一个一致的、简化的界面。

package facade

// 子系统A, B, C...
type SubSystemA struct{}
func (s *SubSystemA) OperationA() {}
type SubSystemB struct{}
func (s *SubSystemB) OperationB() {}

// Facade 是外观，为子系统提供简化接口
type Facade struct {
	a *SubSystemA
	b *SubSystemB
}

func NewFacade() *Facade {
	return &Facade{a: &SubSystemA{}, b: &SubSystemB{}}
}

// Operation 封装了对子系统的复杂调用
func (f *Facade) Operation() {
	f.a.OperationA()
	f.b.OperationB()
}

享元模式(Flyweight)

运用共享技术来有效地支持大量细粒度的对象，避免对象数量过多导致内存溢出。

package flyweight

// ShapeFlyweight 是享元接口
type ShapeFlyweight interface {
	Draw(x, y int)
}

// Circle 是具体享元（包含内部状态 color）
type Circle struct {
	Color string
}
func (c *Circle) Draw(x, y int) { /* 绘制一个颜色为c.Color在(x,y)的圆*/ }

// ShapeFactory 是享元工厂
type ShapeFactory struct {
	shapes map[string]ShapeFlyweight
}
func NewShapeFactory() *ShapeFactory {
	return &ShapeFactory{shapes: make(map[string]ShapeFlyweight)}
}

// GetCircle 根据颜色获取享元对象，如果不存在则创建
func (f *ShapeFactory) GetCircle(color string) ShapeFlyweight {
	if _, ok := f.shapes[color]; !ok {
		f.shapes[color] = &Circle{Color: color}
	}
	return f.shapes[color]
}

代理模式(Proxy)

为其他对象提供一种代理以控制对这个对象的访问。

package proxy

// Subject 是真实对象和代理的共同接口
type Subject interface {
	Request()
}

// RealSubject 是真实对象
type RealSubject struct{}
func (s *RealSubject) Request() { /* 处理请求 */ }

// Proxy 是代理
type Proxy struct {
	realSubject *RealSubject
}

func (p *Proxy) Request() {
	if p.realSubject == nil {
		p.realSubject = &RealSubject{} // 懒加载
	}
	// 可以在调用真实对象前后做一些额外操作，如权限检查
	p.realSubject.Request()
}

行为型模式

责任链模式(Chain of Responsibility)

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

package chainofresponsibility

// Handler 是处理者接口
type Handler interface {
	SetNext(handler Handler)
	HandleRequest(request int)
}

// ConcreteHandlerA 是具体处理者
type ConcreteHandlerA struct {
	next Handler
}
func (h *ConcreteHandlerA) SetNext(next Handler) { h.next = next }
func (h *ConcreteHandlerA) HandleRequest(req int) {
	if req >= 0 && req < 10 {
		// 处理请求
	} else if h.next != nil {
		h.next.HandleRequest(req) // 传递给下一个处理者
	}
}
// ConcreteHandlerB 同理...

命令模式(Command)

将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化。

package command

// Command 接口
type Command interface {
	Execute()
}

// Receiver 是请求的接收者
type Receiver struct{}
func (r *Receiver) Action() {}

// ConcreteCommand 是具体命令，它包含一个 Receiver
type ConcreteCommand struct {
	receiver *Receiver
}

func (c *ConcreteCommand) Execute() {
	c.receiver.Action()
}

// Invoker 是请求的发起者
type Invoker struct {
	command Command
}
func (i *Invoker) SetCommand(cmd Command) { i.command = cmd }
func (i *Invoker) ExecuteCommand()      { i.command.Execute() }

解释器模式(Interpreter)

给定一个语言，定义它的文法的一种表示，并定义一个解释器

package interpreter

// Expression 解释器接口
type Expression interface {
	Interpret() int
}

// Number 是终结符表达式
type Number struct{ value int }
func (n *Number) Interpret() int { return n.value }

// Plus是非终结符表达式
type Plus struct {
	left, right Expression
}
func (p *Plus) Interpret() int {
	return p.left.Interpret() + p.right.Interpret()
}
// 用法： expr := &Plus{left: &Number{1}, right: &Number{2}} -> 结果是 3

迭代器模式(Iterator)

提供一种方法顺序访问一个聚合对象中各个元素，而又无须暴露该对象的内部表示。

package iterator

// Iterator 接口
type Iterator interface {
	HasNext() bool
	Next() interface{}
}

// Container 容器接口
type Container interface {
	CreateIterator() Iterator
}

// concreteIterator 是具体迭代器
type concreteIterator struct {
	collection []interface{}
	index      int
}
func (it *concreteIterator) HasNext() bool { return it.index < len(it.collection) }
func (it *concreteIterator) Next() interface{} {
	if it.HasNext() {
		val := it.collection[it.index]
		it.index++
		return val
	}
	return nil
}

中介者模式(Mediator)

用一个中介对象来封装一系列的对象交互。

package mediator

// Mediator 中介者接口
type Mediator interface {
	Send(message string, colleague Colleague)
}

// Colleague 同事类接口
type Colleague interface {
	SetMediator(mediator Mediator)
}

// ConcreteColleagueA
type ConcreteColleagueA struct{ mediator Mediator }
func (c *ConcreteColleagueA) SetMediator(m Mediator) { c.mediator = m }
func (c *ConcreteColleagueA) Send(msg string)      { c.mediator.Send(msg, c) }

// ConcreteMediator 具体中介者
type ConcreteMediator struct {
	colleagueA *ConcreteColleagueA
	// colleagueB ...
}
func (m *ConcreteMediator) Send(msg string, colleague Colleague) {
	if colleague == m.colleagueA {
		// colleagueB 接收消息...
	}
}

备忘录模式(Memento)

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

package memento

// Memento 存储 Originator 的状态
type Memento struct {
	state string
}
func (m *Memento) GetState() string { return m.state }

// Originator 是需要被保存状态的对象
type Originator struct {
	state string
}
func (o *Originator) SetState(s string)      { o.state = s }
func (o *Originator) CreateMemento() *Memento { return &Memento{state: o.state} }
func (o *Originator) RestoreMemento(m *Memento) { o.state = m.GetState() }

// Caretaker 负责保存备忘录
type Caretaker struct {
	memento *Memento
}

观察者模式(Observer)

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知并自动更新。

package observer

// Observer 观察者接口
type Observer interface {
	Update(subject *Subject)
}

// Subject 被观察者（主题）
type Subject struct {
	observers []Observer
	state     int
}
func (s *Subject) Attach(o Observer) { s.observers = append(s.observers, o) }
func (s *Subject) Notify() {
	for _, o := range s.observers {
		o.Update(s)
	}
}
func (s *Subject) SetState(state int) {
	s.state = state
	s.Notify()
}

// ConcreteObserver 是具体观察者
type ConcreteObserver struct{}
func (o *ConcreteObserver) Update(s *Subject) { /* 响应 s.state 的变化 */ }

状态模式(State)

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

package state

// State 状态接口
type State interface {
	Handle(ctx *Context)
}

// Context 维护一个 State 实例，这个实例定义当前状态
type Context struct {
	state State
}
func (c *Context) SetState(s State) { c.state = s }
func (c *Context) Request()         { c.state.Handle(c) }

// ConcreteStateA 是具体状态
type ConcreteStateA struct{}
func (s *ConcreteStateA) Handle(ctx *Context) {
	// 处理逻辑并可能切换到下一个状态
	ctx.SetState(&ConcreteStateB{})
}

// ConcreteStateB 是另一个具体状态
type ConcreteStateB struct{}
func (s *ConcreteStateB) Handle(ctx *Context) { /* ... */ }

策略模式(Strategy)

定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

package strategy

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

// AddStrategy 是具体策略
type AddStrategy struct{}
func (s *AddStrategy) Execute(a, b int) int { return a + b }

// SubtractStrategy 是具体策略
type SubtractStrategy struct{}
func (s *SubtractStrategy) Execute(a, b int) int { return a - b }

// Context 是使用策略的上下文
type Context struct {
	strategy Strategy
}
func (c *Context) SetStrategy(s Strategy) { c.strategy = s }
func (c *Context) ExecuteStrategy(a, b int) int {
	return c.strategy.Execute(a, b)
}

模板方法模式(Template Method)

定义一个操作中的算法骨架，而将一些步骤延迟到子类中。

package templatemethod

// AbstractTemplate 定义算法骨架
type AbstractTemplate struct{}

func (t *AbstractTemplate) Step1() {} // 具体步骤
func (t *AbstractTemplate) Step3() {} // 具体步骤

// TemplateMethod 是模板方法，封装了算法流程
func (t *AbstractTemplate) TemplateMethod(impl interface{ Step2() }) {
	t.Step1()
	impl.Step2() // 延迟到实现者
	t.Step3()
}

// ConcreteImpl 实现变化的步骤
type ConcreteImpl struct {
	AbstractTemplate
}
func (c *ConcreteImpl) Step2() { /* 实现特定步骤2 */ }

// 用法:
// impl := &ConcreteImpl{}
// impl.TemplateMethod(impl)

访问者模式(Visitor)

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

package visitor

// Visitor 访问者接口，为每个元素类型定义一个访问方法
type Visitor interface {
	VisitElementA(e *ElementA)
	VisitElementB(e *ElementB)
}

// Element 元素接口
type Element interface {
	Accept(v Visitor)
}

// ElementA 是具体元素
type ElementA struct{}
func (e *ElementA) Accept(v Visitor) { v.VisitElementA(e) }

// ElementB 是具体元素
type ElementB struct{}
func (e *ElementB) Accept(v Visitor) { v.VisitElementB(e) }

// ConcreteVisitor 是具体访问者
type ConcreteVisitor struct{}
func (v *ConcreteVisitor) VisitElementA(e *ElementA) { /* 对 A 的操作 */ }
func (v *ConcreteVisitor) VisitElementB(e *ElementB) { /* 对 B 的操作 */ }

空对象模式(Null Object)

用一个符合接口的空对象来代替 nil，避免 nil 检查。

package nullobject

// AbstractObject 接口
type AbstractObject interface {
	Operation() string
}

// RealObject 是真实对象
type RealObject struct{}
func (o *RealObject) Operation() string { return "I am real" }

// NullObject 是空对象，实现了同样接口但做“无用功”
type NullObject struct{}
func (o *NullObject) Operation() string { return "" } // 不做任何事或返回默认值

// 工厂函数，避免返回 nil
func GetObject(real bool) AbstractObject {
	if real {
		return &RealObject{}
	}
	return &NullObject{}
}