 

## 开场白：面试前的我 vs 面试后的我

如果你准备过系统设计面试，你一定懂那种感觉——打开资料一看，23个设计模式排排坐，每个都有英文名、中文名、别名、适用场景、不适用场景、优缺点、代码示例……信息量堪比一本《五年高考三年模拟》。

但好消息是：**你不需要全部背下来。**

在实际工作中，真正高频出现的就那么十几个。今天就带你用Go语言的方式，快速过一遍这15个核心模式。**别紧张，这不是考试，这是一个“哦，原来我用过它”的现场。**

## 第一部分：创建型模式——对象怎么生？

### 1. Singleton（单例）——“全世界只有一个我”

想象一下配置管理器、日志记录器、数据库连接池。如果每个地方都`new`一个，资源浪费不说，状态还不一致。

Go里怎么搞？用`sync.Once`，优雅又线程安全：

```go
package config

import "sync"

type AppConfig struct {
    Env string
}

var (
    instance *AppConfig
    once     sync.Once
)

func GetConfig() *AppConfig {
    once.Do(func() {
        instance = &AppConfig{Env: "production"}
    })
    return instance
}
```

**使用时：**

```go
cfg := config.GetConfig()
fmt.Println(cfg.Env) // production
```

**吐槽一句**：别把单例当万能药，它会让测试变得痛苦。能依赖注入就别偷懒。

### 2. Builder（建造者）——“别让我看那坨构造函数”

当一个struct有5个以上的字段，其中还有一堆可选时，构造函数就成了灾难：

```go
// 谁看得懂这个true是什么意思？？？
user := UserProfile{
    Name: "Alice",
    Email: "alice@example.com",
    Age: 29,
    City: "Berlin",
    Notifications: true,
}
```

Builder模式拯救你的可读性：

```go
type UserProfile struct {
    Name          string
    Email         string
    Age           int
    City          string
    Bio           string
    Notifications bool
}

type UserBuilder struct {
    profile UserProfile
}

func NewUserBuilder(name, email string) *UserBuilder {
    return &UserBuilder{
        profile: UserProfile{Name: name, Email: email},
    }
}

func (b *UserBuilder) Age(age int) *UserBuilder {
    b.profile.Age = age
    return b
}

func (b *UserBuilder) City(city string) *UserBuilder {
    b.profile.City = city
    return b
}

func (b *UserBuilder) Build() UserProfile {
    return b.profile
}
```

**使用时多么清爽：**

```go
user := NewUserBuilder("Alice", "alice@example.com").
    Age(29).
    City("Berlin").
    Build()
```

### 3. Factory Method（工厂方法）——“把创建对象的锅甩出去”

假设你有三种通知方式：Email、SMS、Push。每个的创建和配置逻辑都不一样：

```go
type Notification interface {
    Send(msg string)
}

type EmailNotif struct{}
func (e EmailNotif) Send(msg string) { /* 发邮件 */ }

type SMSNotif struct{}
func (s SMSNotif) Send(msg string) { /* 发短信 */ }
```

如果客户端自己`new`，就耦合死了。用工厂方法：

```go
type NotificationFactory interface {
    Create() Notification
}

type EmailFactory struct{}
func (f EmailFactory) Create() Notification {
    // 这里可以做各种配置
    return EmailNotif{}
}

type SMSFactory struct{}
func (f SMSFactory) Create() Notification {
    return SMSNotif{}
}
```

**客户端只需要依赖接口：**

```go
func SendAlert(factory NotificationFactory, msg string) {
    notif := factory.Create()
    notif.Send(msg)
}

// 用的时候随便换
SendAlert(EmailFactory{}, "订单已发货")
SendAlert(SMSFactory{}, "验证码是1234")
```

## 第二部分：结构型模式——对象怎么搭？

### 4. Adapter（适配器）——“翻译官上线”

第三方支付接口是`MakePayment(amount float64)`，你的系统用的是`Pay(cents int)`。不匹配？加个适配器：

```go
type PaymentProcessor interface {
    Pay(cents int)
}

type ExternalGateway struct{}

func (g ExternalGateway) MakePayment(dollars float64) {
    fmt.Printf("Charging $%.2f\n", dollars)
}

type GatewayAdapter struct {
    gateway ExternalGateway
}

func (a GatewayAdapter) Pay(cents int) {
    dollars := float64(cents) / 100.0
    a.gateway.MakePayment(dollars)
}
```

现在你的系统毫不知情地用着外部服务，完美！

### 5. Facade（外观）——“一键完成所有脏活”

上传视频要压缩→生成缩略图→上传到存储→存数据库→发通知……客户端不想管这些破事。给它一个Facade：

```go
type VideoPublishingFacade struct {
    compressor  Compressor
    storage     Storage
    repository  Repository
    notifier    Notifier
}

func (f *VideoPublishingFacade) Publish(videoPath string) {
    compressed := f.compressor.Compress(videoPath)
    thumb := f.storage.UploadThumbnail(compressed)
    url := f.storage.UploadVideo(compressed)
    f.repository.Save(url, thumb)
    f.notifier.Notify(url)
}
```

**客户端只需一行：**

```go
facade.Publish("cat_video.mp4")
```

### 6. Proxy（代理）——“别急，我帮你挡一下”

高分辨率图片，一创建就加载会卡死。用代理延迟加载：

```go
type Image interface {
    Display()
}

type HighResImage struct {
    filename string
}

func NewHighResImage(name string) *HighResImage {
    img := &HighResImage{filename: name}
    img.loadFromDisk() // 立刻加载，卡！
    return img
}

type ImageProxy struct {
    filename  string
    realImage *HighResImage
}

func (p *ImageProxy) Display() {
    if p.realImage == nil {
        p.realImage = NewHighResImage(p.filename) // 真正需要时才加载
    }
    p.realImage.Display()
}
```

### 7. Decorator（装饰器）——“套娃式加功能”

文本编辑器需要加粗、斜体、下划线任意组合。总不能为每种组合写一个子类吧？装饰器模式：

```go
type TextView interface {
    Render() string
}

type PlainText struct {
    text string
}

func (p PlainText) Render() string {
    return p.text
}

type BoldDecorator struct {
    wrapped TextView
}

func (d BoldDecorator) Render() string {
    return "<b>" + d.wrapped.Render() + "</b>"
}

type ItalicDecorator struct {
    wrapped TextView
}

func (d ItalicDecorator) Render() string {
    return "<i>" + d.wrapped.Render() + "</i>"
}
```

**组合起来为所欲为：**

```go
text := PlainText{"Design Patterns"}
bold := BoldDecorator{text}
boldItalic := ItalicDecorator{BoldDecorator{text}}
```

### 8. Composite（组合）——“文件和文件夹一视同仁”

文件系统里，文件和文件夹都该有`GetSize()`方法：

```go
type FileSystemItem interface {
    GetSize() int64
    Print(indent string)
}

type FileItem struct {
    name string
    size int64
}

func (f FileItem) GetSize() int64 { return f.size }

type Folder struct {
    name     string
    children []FileSystemItem
}

func (f *Folder) Add(item FileSystemItem) {
    f.children = append(f.children, item)
}

func (f *Folder) GetSize() int64 {
    var total int64
    for _, child := range f.children {
        total += child.GetSize()
    }
    return total
}
```

现在一个文件夹里可以嵌套文件夹，而调用方完全不用区分：

```go
root := &Folder{name: "project"}
root.Add(FileItem{name: "README.md", size: 2000})
src := &Folder{name: "src"}
src.Add(FileItem{name: "main.go", size: 8000})
root.Add(src)
fmt.Println(root.GetSize()) // 10000
```

## 第三部分：行为型模式——对象怎么互动？

### 9. Strategy（策略）——“换条路走，不换车”

导航App有开车、步行、骑车多种路线算法。千万别在`RoutePlanner`里写满`if else`：

```go
type RouteStrategy interface {
    BuildRoute(start, dest string)
}

type DrivingStrategy struct{}
func (d DrivingStrategy) BuildRoute(start, dest string) {
    fmt.Println("开车最快路线")
}

type WalkingStrategy struct{}
func (w WalkingStrategy) BuildRoute(start, dest string) {
    fmt.Println("步行友好路线")
}

type RoutePlanner struct {
    strategy RouteStrategy
}

func (r *RoutePlanner) SetStrategy(s RouteStrategy) {
    r.strategy = s
}

func (r *RoutePlanner) BuildRoute(start, dest string) {
    r.strategy.BuildRoute(start, dest)
}
```

**运行时动态切换：**

```go
planner := &RoutePlanner{strategy: DrivingStrategy{}}
planner.BuildRoute("北京", "上海") // 开车路线

planner.SetStrategy(WalkingStrategy{})
planner.BuildRoute("北京", "上海") // 步行路线
```

### 10. Observer（观察者）——“一呼百应”

订单发货后要：发邮件、扣库存、加积分、发推送。别让`OrderService`直接依赖所有服务：

```go
type OrderObserver interface {
    OnOrderShipped(order Order)
}

type EmailObserver struct{}
func (e EmailObserver) OnOrderShipped(order Order) {
    fmt.Println("发送发货邮件")
}

type InventoryObserver struct{}
func (i InventoryObserver) OnOrderShipped(order Order) {
    fmt.Println("扣减库存")
}

type OrderService struct {
    observers []OrderObserver
}

func (o *OrderService) Subscribe(obs OrderObserver) {
    o.observers = append(o.observers, obs)
}

func (o *OrderService) ShipOrder(order Order) {
    // 业务逻辑...
    for _, obs := range o.observers {
        obs.OnOrderShipped(order)
    }
}
```

**解耦就是这么简单：**

```go
service := &OrderService{}
service.Subscribe(EmailObserver{})
service.Subscribe(InventoryObserver{})
service.ShipOrder(order)
```

### 11. State（状态）——“状态不同，行为不同”

订单有：新建→已支付→已发货→已送达。每个状态下执行操作的效果不同。把状态逻辑抽到独立struct里：

```go
type OrderState interface {
    Pay(order *Order)
    Ship(order *Order)
    Deliver(order *Order)
}

type NewState struct{}
func (s NewState) Pay(order *Order) {
    fmt.Println("支付完成")
    order.SetState(PaidState{})
}
func (s NewState) Ship(order *Order) {
    fmt.Println("请先支付")
}
// ...其他方法

type PaidState struct{}
func (s PaidState) Ship(order *Order) {
    fmt.Println("已发货")
    order.SetState(ShippedState{})
}
// ...其他方法

type Order struct {
    state OrderState
}

func (o *Order) SetState(s OrderState) { o.state = s }
func (o *Order) Pay()                  { o.state.Pay(o) }
func (o *Order) Ship()                 { o.state.Ship(o) }
```

**调用时浑然不觉状态切换：**

```go
order := &Order{state: NewState{}}
order.Pay()  // 支付完成，状态变为已支付
order.Ship() // 已发货，状态变为已发货
```

### 12. Command（命令）——“把操作打包成对象”

文本编辑器需要撤销功能。把每个操作变成Command：

```go
type Command interface {
    Execute()
    Undo()
}

type TextEditor struct {
    content string
}

type AddTextCommand struct {
    editor *TextEditor
    text   string
}

func (c *AddTextCommand) Execute() {
    c.editor.content += c.text
}
func (c *AddTextCommand) Undo() {
    // 回退添加的文本
    c.editor.content = c.editor.content[:len(c.editor.content)-len(c.text)]
}

type CommandManager struct {
    history []Command
}

func (m *CommandManager) Execute(cmd Command) {
    cmd.Execute()
    m.history = append(m.history, cmd)
}

func (m *CommandManager) Undo() {
    if len(m.history) > 0 {
        cmd := m.history[len(m.history)-1]
        cmd.Undo()
        m.history = m.history[:len(m.history)-1]
    }
}
```

**撤销就是这么丝滑：**

```go
editor := &TextEditor{}
manager := &CommandManager{}
manager.Execute(&AddTextCommand{editor: editor, text: "Design "})
manager.Execute(&AddTextCommand{editor: editor, text: "Patterns"})
fmt.Println(editor.content) // Design Patterns
manager.Undo()
fmt.Println(editor.content) // Design
```

### 13. Template Method（模板方法）——“骨架我来定，细节你发挥”

CSV和JSON导入流程一样：读取→解析→校验→保存。把通用流程放父类，让子类只实现解析：

```go
type DataImporter interface {
    parse(content string) []Record
}

type BaseImporter struct{}

func (b BaseImporter) Import(path string, parser DataImporter) {
    content := readFile(path)
    records := parser.parse(content)
    validate(records)
    save(records)
    generateReport(records)
}

type CSVImporter struct{ BaseImporter }
func (c CSVImporter) parse(content string) []Record {
    // CSV特有解析逻辑
    return []Record{}
}

type JSONImporter struct{ BaseImporter }
func (j JSONImporter) parse(content string) []Record {
    // JSON特有解析逻辑
    return []Record{}
}
```

> 注：Go没有继承，用组合和接口实现同样的效果。

### 14. Iterator（迭代器）——“遍历不暴露内部”

播放列表内部是数组还是链表，客户端不关心：

```go
type Song struct {
    Title string
}

type Playlist struct {
    songs []Song
}

func (p *Playlist) Iterator() *PlaylistIterator {
    return &PlaylistIterator{
        playlist: p,
        index:    0,
    }
}

type PlaylistIterator struct {
    playlist *Playlist
    index    int
}

func (it *PlaylistIterator) HasNext() bool {
    return it.index < len(it.playlist.songs)
}

func (it *PlaylistIterator) Next() Song {
    song := it.playlist.songs[it.index]
    it.index++
    return song
}
```

**客户端只需`HasNext()`和`Next()`：**

```go
for it := playlist.Iterator(); it.HasNext(); {
    song := it.Next()
    fmt.Println(song.Title)
}
```

### 15. Chain of Responsibility（责任链）——“流水线式处理请求”

API请求要经过：认证→授权→限流→校验。别写成一坨`if`，用责任链：

```go
type Request struct {
    UserID     string
    Endpoint   string
    IsAuth     bool
    IsAuthorized bool
    UnderLimit bool
    Valid      bool
}

type Handler interface {
    SetNext(handler Handler) Handler
    Handle(req *Request) bool
}

type BaseHandler struct {
    next Handler
}

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

func (h *BaseHandler) Handle(req *Request) bool {
    if h.next != nil {
        return h.next.Handle(req)
    }
    return true
}

type AuthHandler struct{ BaseHandler }
func (h AuthHandler) Handle(req *Request) bool {
    if !req.IsAuth {
        fmt.Println("认证失败")
        return false
    }
    return h.BaseHandler.Handle(req)
}

type RateLimitHandler struct{ BaseHandler }
func (h RateLimitHandler) Handle(req *Request) bool {
    if !req.UnderLimit {
        fmt.Println("限流了")
        return false
    }
    return h.BaseHandler.Handle(req)
}
```

**动态组装流水线：**

```go
chain := &AuthHandler{}
chain.SetNext(&RateLimitHandler{}).SetNext(&ValidationHandler{})
chain.Handle(req) // 按顺序过，任何一个失败就停
```

## 最后：选模式就像选工具

> **别为了用模式而用模式。** 没有哪条法律规定必须用设计模式。

| 场景 | 该用谁 |
|------|--------|
| 全局只有一个实例 | Singleton |
| 对象构造参数太多 | Builder |
| 创建逻辑需要隔离 | Factory Method |
| 接口不兼容 | Adapter |
| 复杂系统想简化 | Facade |
| 访问需要控制/延迟 | Proxy |
| 动态添加功能 | Decorator |
| 树形结构统一处理 | Composite |
| 算法可以互换 | Strategy |
| 一事件多响应 | Observer |
| 状态决定行为 | State |
| 需要撤销/队列 | Command |
| 流程固定部分可变 | Template Method |
| 遍历不暴露内部 | Iterator |
| 处理链灵活组合 | Chain of Responsibility |

这15个模式，**不用背，理解问题比记住解法重要**。下次遇到类似场景，翻翻这张表，答案就在眼前。 

如果你准备过系统设计面试，你一定懂那种感觉——打开资料一看，23个设计模式排排坐，每个都有英文名、中文名、别名、适用场景、不适用场景、优缺点、代码示例……信息量堪比一本《五年高考三年模拟》。

15个系统设计模式，20分钟带你速通

编程语言

面试系统设计必知15个Go语言核心模式，覆盖创建型、结构型与行为型设计。用单例、工厂、适配器、观察者等模式解决实际开发痛点，搭配可运行代码示例，帮你从死记硬背转向场景化理解，快速提升架构设计能力。

数据库连接池

文件系统

代码解释

验证码

数据库

短信

JSON

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

15个系统设计模式，20分钟带你速通-腾讯云开发者社区-腾讯云

15个系统设计模式，20分钟带你速通

15个系统设计模式，20分钟带你速通

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐