Go 设计模式学习笔记(23 种 GoF 模式 × Go 惯用实现)

package main

import (
	"fmt"
	"sync"
)

// Config 全局唯一配置对象；字段不导出，外部只能通过 GetConfig 访问
type Config struct {
	serverName string
	port       int
}

var (
	cfgInstance *Config
	cfgOnce     sync.Once
)

// GetConfig 返回全局唯一配置实例。
// 用 sync.Once 保证并发调用时初始化逻辑也只会执行一次。
func GetConfig() *Config {
	cfgOnce.Do(func() {
		cfgInstance = &Config{
			serverName: "demo-server",
			port:       8080,
		}
	})
	return cfgInstance
}

// String 实现 fmt.Stringer，便于直接打印
func (c *Config) String() string {
	return fmt.Sprintf("%s:%d", c.serverName, c.port)
}

func main() {
	// 无论调用多少次，拿到的都是同一个实例
	a := GetConfig()
	b := GetConfig()
	fmt.Printf("a 与 b 是同一个实例：%t\n", a == b)
	fmt.Printf("当前配置：%s\n", a)
}

a 与 b 是同一个实例：true
当前配置：demo-server:8080

package main

import "fmt"

// Sender 抽象产品：所有通知发送器都必须实现 Send
type Sender interface {
	Send(to, msg string) error
}

// EmailSender 具体产品：邮件发送器
type EmailSender struct{}

func (EmailSender) Send(to, msg string) error {
	fmt.Printf("[邮件] 收件人=%s 内容=%s\n", to, msg)
	return nil
}

// SmsSender 具体产品：短信发送器
type SmsSender struct{}

func (SmsSender) Send(to, msg string) error {
	fmt.Printf("[短信] 收件人=%s 内容=%s\n", to, msg)
	return nil
}

// NewSender 工厂方法：按渠道返回对应的发送器。
// 调用方只依赖 Sender 接口，不关心具体类型是邮件还是短信。
func NewSender(channel string) Sender {
	switch channel {
	case "email":
		return EmailSender{}
	case "sms":
		return SmsSender{}
	default:
		return EmailSender{}
	}
}

func main() {
	email := NewSender("email")
	sms := NewSender("sms")

	email.Send("alice@example.com", "你好，欢迎注册")
	sms.Send("13800000000", "验证码：1234")
}

[邮件] 收件人=alice@example.com 内容=你好，欢迎注册
[短信] 收件人=13800000000 内容=验证码：1234

package main

import "fmt"

// Button 抽象产品：按钮
type Button interface {
	Render() string
}

// Checkbox 抽象产品：复选框
type Checkbox interface {
	Render() string
}

// ThemeFactory 抽象工厂：创建一组配套的 UI 组件
type ThemeFactory interface {
	CreateButton() Button
	CreateCheckbox() Checkbox
}

// LightButton 浅色主题按钮
type LightButton struct{}

func (LightButton) Render() string { return "浅色按钮" }

// LightCheckbox 浅色主题复选框
type LightCheckbox struct{}

func (LightCheckbox) Render() string { return "浅色复选框" }

// LightThemeFactory 浅色主题产品族
type LightThemeFactory struct{}

func (LightThemeFactory) CreateButton() Button     { return LightButton{} }
func (LightThemeFactory) CreateCheckbox() Checkbox { return LightCheckbox{} }

// DarkButton 深色主题按钮
type DarkButton struct{}

func (DarkButton) Render() string { return "深色按钮" }

// DarkCheckbox 深色主题复选框
type DarkCheckbox struct{}

func (DarkCheckbox) Render() string { return "深色复选框" }

// DarkThemeFactory 深色主题产品族
type DarkThemeFactory struct{}

func (DarkThemeFactory) CreateButton() Button     { return DarkButton{} }
func (DarkThemeFactory) CreateCheckbox() Checkbox { return DarkCheckbox{} }

// renderUI 客户端：只依赖抽象工厂与抽象产品接口
func renderUI(factory ThemeFactory) {
	button := factory.CreateButton()
	checkbox := factory.CreateCheckbox()
	fmt.Printf("%s + %s\n", button.Render(), checkbox.Render())
}

func main() {
	fmt.Println("=== 浅色主题 ===")
	renderUI(LightThemeFactory{})
	fmt.Println("=== 深色主题 ===")
	renderUI(DarkThemeFactory{})
}

=== 浅色主题 ===
浅色按钮 + 浅色复选框
=== 深色主题 ===
深色按钮 + 深色复选框

package main

import (
	"fmt"
	"strings"
)

// SQLBuilder SQL 查询构建器：把复杂的查询语句拆成一步步链式调用
type SQLBuilder struct {
	table   string
	columns []string
	where   []string
}

// NewSQLBuilder 返回一个空的构建器
func NewSQLBuilder() *SQLBuilder {
	return &SQLBuilder{}
}

// Table 指定目标表
func (b *SQLBuilder) Table(name string) *SQLBuilder {
	b.table = name
	return b
}

// Select 指定要查询的列（可多个）
func (b *SQLBuilder) Select(cols ...string) *SQLBuilder {
	b.columns = cols
	return b
}

// Where 追加一个查询条件，可多次调用
func (b *SQLBuilder) Where(cond string) *SQLBuilder {
	b.where = append(b.where, cond)
	return b
}

// Build 根据已收集的信息拼出最终 SQL 语句
func (b *SQLBuilder) Build() string {
	sql := "SELECT " + strings.Join(b.columns, ", ") + " FROM " + b.table
	if len(b.where) > 0 {
		sql += " WHERE " + strings.Join(b.where, " AND ")
	}
	return sql
}

func main() {
	// 链式调用：每个设置方法都返回自身，调用看起来像自然语言
	query := NewSQLBuilder().
		Table("users").
		Select("id", "name", "email").
		Where("age > 18").
		Where("active = 1").
		Build()

	fmt.Println(query)
}

SELECT id, name, email FROM users WHERE age > 18 AND active = 1

package main

import "fmt"

// Prototype 原型接口：所有可克隆对象都要实现 Clone
type Prototype interface {
	Clone() Prototype
}

// ServerConfig 服务器配置原型：带一个切片字段，用于演示深拷贝
type ServerConfig struct {
	Name     string
	Port     int
	Features []string
}

// Clone 深拷贝实现。
// 注意：直接赋值结构体只会做浅拷贝，Features 仍共享同一个底层数组，
// 因此这里新建切片并 copy，保证修改克隆体不影响原对象。
func (c *ServerConfig) Clone() Prototype {
	features := make([]string, len(c.Features))
	copy(features, c.Features)
	return &ServerConfig{
		Name:     c.Name,
		Port:     c.Port,
		Features: features,
	}
}

func main() {
	// 原型：一份默认配置
	base := &ServerConfig{
		Name:     "default",
		Port:     8080,
		Features: []string{"tls", "metrics"},
	}

	// 从原型复制并修改，得到全新的实例
	dev := base.Clone().(*ServerConfig)
	dev.Name = "dev"
	dev.Features[0] = "debug" // 修改克隆体的切片元素

	fmt.Printf("原型: %+v\n", base)
	fmt.Printf("克隆: %+v\n", dev)
	fmt.Printf("切片底层数组已隔离：%t\n", dev.Features[0] != base.Features[0])
}

原型: &{Name:default Port:8080 Features:[tls metrics]}
克隆: &{Name:dev Port:8080 Features:[debug metrics]}
切片底层数组已隔离：true

type Target interface {
	Request()
}
type Adaptee struct{} // 已有组件
func (Adaptee) SpecificRequest() {}
type Adapter struct{ adaptee Adaptee }
func (a Adapter) Request() { a.adaptee.SpecificRequest() } // 翻译调用

package main

import "fmt"

// Payment 是应用内统一的支付接口，客户端只依赖它。
type Payment interface {
	Pay(amount float64) error
}

// WeChatPay 是微信支付 SDK 自带的实现，方法签名与接口天然吻合。
type WeChatPay struct{ balance float64 }

func (w *WeChatPay) Pay(amount float64) error {
	if w.balance < amount {
		return fmt.Errorf("余额不足，当前 %.2f 元", w.balance)
	}
	w.balance -= amount
	fmt.Printf("微信支付成功：%.2f 元，剩余 %.2f 元\n", amount, w.balance)
	return nil
}

// AlipaySDK 是支付宝 SDK：方法签名与 Payment 完全不同，无法直接使用。
type AlipaySDK struct{ balance float64 }

// Transfer 是支付宝自己的「转账」语义，接口不匹配。
func (a *AlipaySDK) Transfer(to string, amount float64) error {
	if a.balance < amount {
		return fmt.Errorf("余额不足，当前 %.2f 元", a.balance)
	}
	a.balance -= amount
	fmt.Printf("支付宝转账给 %s：%.2f 元，剩余 %.2f 元\n", to, amount, a.balance)
	return nil
}

// AlipayAdapter 是适配器：包装 AlipaySDK，把 Transfer 翻译成 Pay。
type AlipayAdapter struct {
	sdk   *AlipaySDK
	owner string
}

func (a *AlipayAdapter) Pay(amount float64) error {
	return a.sdk.Transfer(a.owner, amount)
}

func main() {
	var payment Payment = &WeChatPay{balance: 100}
	if err := payment.Pay(30); err != nil {
		fmt.Println("支付失败：", err)
	}

	// 支付宝 SDK 通过适配器也能当作 Payment 使用。
	payment = &AlipayAdapter{sdk: &AlipaySDK{balance: 200}, owner: "自己"}
	if err := payment.Pay(50); err != nil {
		fmt.Println("支付失败：", err)
	}
}

type Sender interface {
	Send(msg string)
}            // 实现维度
type Message interface {
	SendTo(s Sender)
}            // 抽象维度

package main

import "fmt"

// Sender 是实现维度：消息通过什么渠道发送。
type Sender interface {
	Send(msg string)
}

// EmailSender 具体实现之一：邮件渠道。
type EmailSender struct{ address string }

func (e EmailSender) Send(msg string) {
	fmt.Printf("发邮件到 %s：%s\n", e.address, msg)
}

// SMSSender 具体实现之二：短信渠道。
type SMSSender struct{ phone string }

func (s SMSSender) Send(msg string) {
	fmt.Printf("发短信到 %s：%s\n", s.phone, msg)
}

// Message 是抽象维度：消息的类型。把实现（Sender）作为参数传入，
// 二者在调用时自由组合，互不感知。
type Message interface {
	Compose() string
	SendTo(s Sender)
}

// TextMessage 抽象实现：纯文本消息。
type TextMessage struct{ content string }

func (m TextMessage) Compose() string { return "【文本】" + m.content }

func (m TextMessage) SendTo(s Sender) { s.Send(m.Compose()) }

// HTMLMessage 抽象实现：富文本消息。
type HTMLMessage struct{ title, body string }

func (m HTMLMessage) Compose() string {
	return fmt.Sprintf("<h1>%s</h1><p>%s</p>", m.title, m.body)
}

func (m HTMLMessage) SendTo(s Sender) { s.Send(m.Compose()) }

func main() {
	email := EmailSender{address: "boss@example.com"}
	sms := SMSSender{phone: "13800000000"}

	// 文本消息 × 两种渠道。
	msg := Message(TextMessage{content: "今晚八点开会"})
	msg.SendTo(email)
	msg.SendTo(sms)

	// HTML 消息 × 两种渠道：两个维度自由组合。
	msg = HTMLMessage{title: "周报", body: "本周进展顺利"}
	msg.SendTo(email)
}

type Component interface{ Size() int64 }
type File struct{ size int64 }
func (f File) Size() int64 { return f.size }
type Directory struct{ children []Component }
func (d Directory) Size() (total int64) {
	for _, c := range d.children {
		total += c.Size()
	}
	return
}

package main

import "fmt"

// Component 是组合模式的核心：叶子与容器统一接口。
type Component interface {
	Name() string
	Size() int64
}

// File 是叶子节点：没有子组件。
type File struct {
	name string
	size int64
}

func (f *File) Name() string { return f.name }
func (f *File) Size() int64  { return f.size }

// Directory 是容器节点：可以包含任意子组件（叶子或容器）。
type Directory struct {
	name     string
	children []Component
}

func (d *Directory) Name() string { return d.name }

// Size 递归累加所有子节点大小，客户端无需区分叶子与容器。
func (d *Directory) Size() (total int64) {
	for _, c := range d.children {
		total += c.Size()
	}
	return
}

func (d *Directory) Add(c Component) {
	d.children = append(d.children, c)
}

// PrintTree 用统一的 Component 视角递归打印整棵树。
func PrintTree(c Component, indent string) {
	fmt.Printf("%s%s（%.1f KB）\n", indent, c.Name(), float64(c.Size())/1024)
	if dir, ok := c.(*Directory); ok {
		for _, child := range dir.children {
			PrintTree(child, indent+"  ")
		}
	}
}

func main() {
	src := &Directory{name: "src"}
	src.Add(&File{name: "main.go", size: 2048})
	src.Add(&File{name: "util.go", size: 1024})

	docs := &Directory{name: "docs"}
	docs.Add(&File{name: "README.md", size: 512})

	root := &Directory{name: "project"}
	root.Add(src)
	root.Add(docs)
	root.Add(&File{name: "go.mod", size: 128})

	PrintTree(root, "")
	fmt.Printf("项目总大小：%.1f KB\n", float64(root.Size())/1024)
}

type Handler func(...) // 组件接口
func withLog(next Handler) Handler {
	return func(...) {
		log(...)
		next(...)
	}
}

package main

import (
	"fmt"
	"log"
	"net/http"
	"net/http/httptest"
	"time"
)

// 核心 handler：真实业务逻辑，本身不关心被哪些装饰器包裹。
func helloHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "Hello, 装饰器!")
}

// withLogging 是装饰器：记录每次请求的方法、路径与耗时。
func withLogging(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		next.ServeHTTP(w, r)
		log.Printf("请求 %s %s 耗时 %s", r.Method, r.URL.Path, time.Since(start))
	})
}

// withHeader 是装饰器：给所有响应统一附加一个自定义头。
func withHeader(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("X-Go-Pattern", "decorator")
		next.ServeHTTP(w, r)
	})
}

func main() {
	// 层层包装形成中间件链：withHeader -> withLogging -> helloHandler。
	var h http.Handler = http.HandlerFunc(helloHandler)
	h = withLogging(h)
	h = withHeader(h)

	// 用 httptest 模拟一次真实请求，无需启动服务器。
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodGet, "/greet", nil)
	h.ServeHTTP(rec, req)

	fmt.Println("响应体：", rec.Body.String())
	fmt.Println("响应头 X-Go-Pattern：", rec.Header().Get("X-Go-Pattern"))
}

type VideoConverter struct{}

func (VideoConverter) Convert(file, format string) string {
	// 内部依次调用解封装、解码、编码、混音……
}

package main

import "fmt"

// ---- 复杂子系统：客户端本不必接触的多个组件 ----

// Demuxer 把容器拆成独立的视频流与音频流。
type Demuxer struct{}

func (Demuxer) Extract(file string) (video, audio string) {
	return file + ".video", file + ".audio"
}

// VideoDecoder 解码视频流。
type VideoDecoder struct{}

func (VideoDecoder) Decode(stream string) string {
	return "解码后的视频帧(" + stream + ")"
}

// AudioDecoder 解码音频流。
type AudioDecoder struct{}

func (AudioDecoder) Decode(stream string) string {
	return "PCM音频(" + stream + ")"
}

// AudioMixer 混音。
type AudioMixer struct{}

func (AudioMixer) Mix(audio string) string {
	return "混音后的" + audio
}

// VideoEncoder 按目标格式编码。
type VideoEncoder struct{}

func (VideoEncoder) Encode(frames, format string) string {
	return format + "格式(" + frames + ")"
}

// ---- 外观 Facade ----

// VideoConverter 是外观：客户端只调用 Convert 一个方法，
// 内部把解封装、解码、混音、编码按正确顺序编排起来。
type VideoConverter struct{}

func (VideoConverter) Convert(file, format string) string {
	d := Demuxer{}
	video, audio := d.Extract(file)

	frames := VideoDecoder{}.Decode(video)
	pcm := AudioDecoder{}.Decode(audio)
	mixed := AudioMixer{}.Mix(pcm)

	return VideoEncoder{}.Encode(frames+mixed, format)
}

func main() {
	converter := VideoConverter{}
	result := converter.Convert("猫和老鼠.avi", "mp4")
	fmt.Println("转换结果：", result)
}

type styleFactory struct{ cache map[string]*CharStyle }

func (f *styleFactory) get(key string) *CharStyle {
	if s, ok := f.cache[key]; ok {
		return s
	}
	s := &CharStyle{}
	f.cache[key] = s
	return s
}

package main

import "fmt"

// CharStyle 是享元对象：字符共享的「内在状态」，不可变。
type CharStyle struct {
	font string
	size int
	bold bool
}

// CharGlyph 是客户端持有的字形：每个字符独有的「外在状态」+ 共享样式。
type CharGlyph struct {
	ch    rune
	style *CharStyle // 指向享元，多个字符可共享同一个指针
}

// styleFactory 是享元工厂：按样式特征缓存，保证相同样式只有一个实例。
type styleFactory struct {
	cache map[string]*CharStyle
}

func newStyleFactory() *styleFactory {
	return &styleFactory{cache: make(map[string]*CharStyle)}
}

func (f *styleFactory) get(font string, size int, bold bool) *CharStyle {
	key := fmt.Sprintf("%s-%d-%v", font, size, bold)
	if s, ok := f.cache[key]; ok {
		return s // 命中缓存，复用既有对象
	}
	s := &CharStyle{font: font, size: size, bold: bold}
	f.cache[key] = s
	return s
}

func (f *styleFactory) count() int { return len(f.cache) }

func main() {
	factory := newStyleFactory()

	text := []rune("Hello, 享元模式")
	glyphs := make([]CharGlyph, 0, len(text)+1)
	for _, r := range text {
		// 正文字符全部共享同一个样式对象。
		glyphs = append(glyphs, CharGlyph{ch: r, style: factory.get("宋体", 12, false)})
	}
	// 标题单独一个样式，也是全篇唯一。
	glyphs = append(glyphs, CharGlyph{ch: '!', style: factory.get("黑体", 24, true)})

	fmt.Printf("共渲染 %d 个字符，但只创建了 %d 个样式对象（享元）\n", len(glyphs), factory.count())
	for _, g := range glyphs {
		fmt.Printf("  %q -> 字体=%s 字号=%d 加粗=%v\n", g.ch, g.style.font, g.style.size, g.style.bold)
	}
}

type ImageLoader interface{ Load(path string) ([]byte, error) }
type CachingProxy struct {
	real  ImageLoader
	cache map[string][]byte
}

func (p *CachingProxy) Load(path string) ([]byte, error) {
	if data, ok := p.cache[path]; ok {
		return data, nil // 缓存代理
	}
	return p.real.Load(path)
}

package main

import "fmt"

// ImageLoader 是主题接口：客户端只依赖它，不关心是真实加载还是代理。
type ImageLoader interface {
	Load(path string) ([]byte, error)
}

// DiskImageLoader 是真实主题：模拟从磁盘读取图片（代价昂贵）。
type DiskImageLoader struct{}

func (DiskImageLoader) Load(path string) ([]byte, error) {
	// 模拟磁盘 IO 开销。
	return []byte("image-data:" + path), nil
}

// CachingProxy 是代理：先查缓存，未命中才调用真实加载，命中则直接返回。
type CachingProxy struct {
	real  ImageLoader
	cache map[string][]byte
}

func NewCachingProxy(real ImageLoader) *CachingProxy {
	return &CachingProxy{real: real, cache: make(map[string][]byte)}
}

func (p *CachingProxy) Load(path string) ([]byte, error) {
	if data, ok := p.cache[path]; ok {
		fmt.Printf("[代理] 命中缓存：%s\n", path)
		return data, nil
	}
	fmt.Printf("[代理] 缓存未命中，调用真实加载：%s\n", path)
	data, err := p.real.Load(path)
	if err != nil {
		return nil, err
	}
	p.cache[path] = data
	return data, nil
}

func main() {
	loader := NewCachingProxy(DiskImageLoader{})

	// 第一次加载触发真实 IO。
	data, err := loader.Load("cat.png")
	if err != nil {
		fmt.Println("加载失败：", err)
		return
	}
	fmt.Println("第一次内容：", string(data))

	// 第二次加载直接命中缓存，不再访问真实对象。
	data, err = loader.Load("cat.png")
	if err != nil {
		fmt.Println("加载失败：", err)
		return
	}
	fmt.Println("第二次内容：", string(data))
}

package main

import "fmt"

// Handler 抽象处理者：处理请求，并可把请求转发给链上的下一个节点
type Handler interface {
	// SetNext 设置责任链中的下一个处理器
	SetNext(Handler) Handler
	// Handle 处理消息，返回 true 表示已处理完毕
	Handle(msg string) bool
}

// BaseHandler 提供 next 字段与默认转发逻辑，供具体处理器嵌入复用
type BaseHandler struct {
	next Handler
}

func (b *BaseHandler) SetNext(h Handler) Handler {
	b.next = h
	return h
}

// passToNext 把消息转发给链上的下一个节点
func (b *BaseHandler) passToNext(msg string) bool {
	if b.next != nil {
		return b.next.Handle(msg)
	}
	return false // 到达链尾，无人处理
}

// DebugHandler 只处理 DEBUG 级别的消息
type DebugHandler struct {
	BaseHandler // 嵌入基础处理器，获得 SetNext 与转发能力
}

func (h *DebugHandler) Handle(msg string) bool {
	if msg == "DEBUG" {
		fmt.Println("[DEBUG] 处理了调试日志")
		return true
	}
	return h.passToNext(msg) // 不归自己管，转给下一个
}

// InfoHandler 只处理 INFO 级别的消息
type InfoHandler struct {
	BaseHandler
}

func (h *InfoHandler) Handle(msg string) bool {
	if msg == "INFO" {
		fmt.Println("[INFO] 处理了信息日志")
		return true
	}
	return h.passToNext(msg)
}

func main() {
	// 构建责任链：DEBUG -> INFO
	debug := &DebugHandler{}
	info := &InfoHandler{}
	debug.SetNext(info)

	for _, msg := range []string{"DEBUG", "INFO", "WARN"} {
		fmt.Printf("收到消息: %s\n", msg)
		debug.Handle(msg)
	}
}