Chemmy's Blog

迭代器模式

发表于 2019-11-16 更新于 2026-04-20 分类于学习笔记，设计模式

迭代器模式（Iterator Pattern）是一种经典的行为型设计模式，其核心目标是提供一种标准化方式顺序访问聚合对象中的各个元素，同时不暴露该对象的内部存储结构。它通过将遍历逻辑与集合本身解耦，让集合类专注于数据的存储与管理，迭代器类专注于遍历行为的实现，大幅提升代码的灵活性、可维护性与可扩展性，是处理集合遍历场景的核心设计范式。

迭代器模式的核心价值在于“分离遍历与存储”，它屏蔽了不同集合（如数组、链表、哈希表）的底层实现差异，为外部提供统一的遍历接口，使得调用者无需关心集合的内部结构，只需通过迭代器即可完成元素的遍历，完美契合“单一职责原则”与“开闭原则”。

一、迭代器模式的核心结构

迭代器模式的结构清晰，角色分工明确，核心由四个角色构成，各角色协同工作，共同实现“解耦遍历逻辑与集合存储”的核心目标，确保遍历行为的标准化与集合的封装性：

1.1 抽象迭代器（Iterator）

定义遍历聚合对象的通用接口，是所有具体迭代器的行为契约。通常包含两个核心方法：HasNext()（判断当前位置是否还有下一个元素，返回布尔值）和Next()（获取当前位置的下一个元素，并将遍历指针移动到下一位），部分场景可扩展Reset()（重置遍历指针）、Remove()（移除当前元素）等方法。

1.2 具体迭代器（Concrete Iterator）

实现抽象迭代器接口，是迭代器模式的核心执行类。它内部持有对应具体聚合对象的引用，维护当前遍历的位置指针，负责完成实际的遍历逻辑，同时处理迭代边界（如越界判断），确保遍历的安全性。

1.3 抽象聚合类（Aggregate）

定义聚合对象的通用接口，声明集合的核心行为（如添加、删除元素），并提供一个创建迭代器的抽象方法（如CreateIterator()）。抽象聚合类的核心作用是规范具体聚合类的行为，同时为外部提供获取迭代器的统一入口。

1.4 具体聚合类（Concrete Aggregate）

实现抽象聚合类的接口，是被遍历的目标集合，负责存储具体的元素数据（如数组、链表等底层结构）。它会返回一个与自身匹配的具体迭代器实例，将遍历逻辑委托给迭代器，自身仅专注于数据的存储与管理。

核心逻辑链路：客户端 → 实例化具体聚合类（存储数据） → 调用聚合类的CreateIterator()方法获取具体迭代器 → 通过迭代器的HasNext()和Next()方法遍历元素 → 完成遍历。整个过程中，客户端无需关注集合的内部结构，仅与迭代器接口交互。

二、多语言实现迭代器模式

为便于开发者落地实践，本文以“字符串集合遍历”为经典案例，实现多语言版本的迭代器模式，覆盖面向对象语言、动态语言、面向过程语言及Go语言的特色实现。所有实现均保证完整可运行，贴合各语言设计理念，补充规范注释、异常处理和边界判断，兼顾实用性与可读性，同时体现各语言对迭代器模式的适配方式。

2.1 C# 实现（依托内置接口，贴合语言特性）

C# 语言内置了IEnumerator（抽象迭代器）和IEnumerable（抽象聚合类）接口，天然适配迭代器模式，开发者可直接复用内置接口实现，无需自定义抽象层，代码简洁且符合.NET框架规范，适配企业级系统开发。

using System;
using System.Collections;

/// <summary>
/// 具体迭代器：实现系统内置抽象迭代器接口IEnumerator
/// 负责字符串集合的遍历逻辑，维护遍历位置，处理边界判断
/// </summary>
public class StringIterator : IEnumerator
{
    // 持有具体聚合对象的元素数组
    private readonly string[] _items;
    // 当前遍历位置指针（初始值为-1，代表未开始遍历）
    private int _position = -1;

    /// <summary>
    /// 初始化迭代器，绑定要遍历的集合元素
    /// </summary>
    /// <param name="items">字符串集合数组</param>
    public StringIterator(string[] items)
    {
        _items = items ?? throw new ArgumentNullException(nameof(items), "遍历的集合不可为null");
    }

    /// <summary>
    /// 获取当前位置的元素
    /// </summary>
    public object Current
    {
        get
        {
            // 处理越界异常，避免非法访问
            if (_position < 0 || _position >= _items.Length)
            {
                throw new InvalidOperationException("迭代器位置非法，无法获取当前元素");
            }
            return _items[_position];
        }
    }

    /// <summary>
    /// 移动到下一个元素，返回是否存在下一个元素
    /// </summary>
    /// <returns>是否存在下一个元素</returns>
    public bool MoveNext()
    {
        _position++;
        // 判断当前位置是否在集合范围内
        return _position < _items.Length;
    }

    /// <summary>
    /// 重置迭代器位置，重新开始遍历
    /// </summary>
    public void Reset()
    {
        _position = -1;
    }
}

/// <summary>
/// 具体聚合类：实现系统内置抽象聚合接口IEnumerable
/// 负责存储字符串元素，提供创建迭代器的方法
/// </summary>
public class StringCollection : IEnumerable
{
    // 底层存储元素的数组
    private readonly string[] _items;

    /// <summary>
    /// 初始化字符串集合
    /// </summary>
    /// <param name="items">要存储的字符串数组</param>
    public StringCollection(string[] items)
    {
        _items = items ?? throw new ArgumentNullException(nameof(items), "集合元素不可为null");
    }

    /// <summary>
    /// 创建并返回对应的具体迭代器实例
    /// </summary>
    /// <returns>字符串集合迭代器</returns>
    public IEnumerator GetEnumerator()
    {
        return new StringIterator(_items);
    }
}

// 客户端测试代码
class Program
{
    static void Main()
    {
        try
        {
            // 初始化具体聚合对象（存储数据）
            var collection = new StringCollection(new[] { "C#", "迭代器模式", "设计模式" });
            // 借助foreach遍历（C# foreach本质是调用迭代器的MoveNext和Current）
            Console.WriteLine("C# 迭代器遍历结果：");
            foreach (var item in collection)
            {
                Console.WriteLine(item);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"遍历异常：{ex.Message}");
        }
    }
}

2.2 Python 实现（依托迭代器协议，简洁高效）

Python 不强制要求定义抽象接口，而是通过“迭代器协议”（实现__iter__和__next__方法）实现迭代器功能，语法简洁灵活，无需繁琐的接口声明，依托GC自动管理内存，适配快速开发、脚本开发及轻量级项目场景，完美贴合Python“简洁实用”的设计理念。

# 具体迭代器：实现Python迭代器协议（__iter__和__next__方法）
class StringIterator:
    def __init__(self, items):
        """初始化迭代器"""        # 绑定要遍历的集合元素
        self._items = items if items is not None else []
        # 当前遍历位置指针（初始值为0，Python中数组下标从0开始）
        self._index = 0
    
    def __iter__(self):
        """迭代器协议要求：返回自身，支持for-in遍历"""        return self
    
    def __next__(self):
        """迭代器协议要求：获取下一个元素，无元素时抛出StopIteration终止遍历"""        if self._index < len(self._items):
            # 获取当前元素并移动指针
            result = self._items[self._index]
            self._index += 1
            return result
        # 迭代终止标志，for-in会自动捕获该异常并结束遍历
        raise StopIteration("迭代已结束，无更多元素")

# 具体聚合类：实现__iter__方法，返回迭代器实例
class StringCollection:
    def __init__(self, items):
        """初始化字符串集合"""        self._items = items if items is not None else []
    
    def __iter__(self):
        """返回具体迭代器实例，供外部遍历"""        return StringIterator(self._items)

# 客户端测试代码
if __name__ == "__main__":
    try:
        # 初始化集合并遍历
        collection = StringCollection(["Python", "迭代器模式", "设计模式"])
        print("Python 迭代器遍历结果：")
        for item in collection:
            print(item)
    except StopIteration as e:
        print(f"迭代异常：{e}")
    except Exception as e:
        print(f"其他异常：{str(e)}")

2.3 Go 实现（接口+结构体，轻量化实现）

Go 语言无类和继承概念，核心遵循“组合优于继承”的设计哲学，通过接口定义迭代器和聚合类的契约，结构体实现具体的迭代器和聚合逻辑，代码极简、高效，贴合Go语言“简洁、务实、高性能”的设计理念，适配高并发、高性能的后端开发场景。

package main

import (
    "fmt"
)

// 抽象迭代器接口：定义遍历的统一契约
type Iterator interface {
    HasNext() bool   // 判断是否有下一个元素
    Next() string    // 获取下一个元素
    Reset()          // 重置迭代器位置
}

// 具体迭代器：字符串集合迭代器
type StringIterator struct {
    items []string  // 要遍历的元素数组
    index int       // 当前遍历位置指针
}

// NewStringIterator 工厂函数：创建字符串迭代器实例
func NewStringIterator(items []string) *StringIterator {
    if items == nil {
        items = make([]string, 0)
    }
    return &StringIterator{
        items: items,
        index: 0,
    }
}

// HasNext 判断是否有下一个元素
func (it *StringIterator) HasNext() bool {
    return it.index < len(it.items)
}

// Next 获取下一个元素，若无元素则返回空字符串
func (it *StringIterator) Next() string {
    if it.HasNext() {
        item := it.items[it.index]
        it.index++
        return item
    }
    fmt.Println("迭代已结束，无更多元素")
    return ""
}

// Reset 重置迭代器位置，重新开始遍历
func (it *StringIterator) Reset() {
    it.index = 0
}

// 抽象聚合类接口：定义创建迭代器的契约
type Aggregate interface {
    CreateIterator() Iterator // 创建迭代器
}

// 具体聚合类：字符串集合
type StringCollection struct {
    items []string // 底层存储元素的数组
}

// NewStringCollection 工厂函数：创建字符串集合实例
func NewStringCollection(items []string) *StringCollection {
    if items == nil {
        items = make([]string, 0)
    }
    return &StringCollection{
        items: items,
    }
}

// CreateIterator 创建并返回迭代器实例
func (c *StringCollection) CreateIterator() Iterator {
    return NewStringIterator(c.items)
}

// 客户端测试代码
func main() {
    // 初始化具体聚合对象
    collection := NewStringCollection([]string{"Go", "迭代器模式", "设计模式"})
    // 获取迭代器
    iterator := collection.CreateIterator()

    fmt.Println("Go 迭代器遍历结果：")
    // 遍历元素
    for iterator.HasNext() {
        fmt.Println(iterator.Next())
    }

    // 重置迭代器并重新遍历
    iterator.Reset()
    fmt.Println("Go 迭代器重置后遍历结果：")
    for iterator.HasNext() {
        fmt.Println(iterator.Next())
    }
}

2.4 C++ 实现（抽象类+模板，通用化设计）

C++ 作为经典面向对象语言，通过抽象类（纯虚函数）定义迭代器和聚合类的接口，结合模板机制实现通用化设计，支持多种数据类型的遍历，兼顾灵活性与高性能，需手动管理内存，适配底层开发、高频调用场景，是底层系统、高性能应用的优选实现方式。

#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>
using namespace std;

// 抽象迭代器（模板类，支持任意数据类型）
template <typename T>
class Iterator {
public:
    virtual ~Iterator() = default; // 虚析构函数，避免多态场景下内存泄漏
    virtual bool HasNext() = 0;    // 纯虚函数：判断是否有下一个元素
    virtual T Next() = 0;         // 纯虚函数：获取下一个元素
    virtual void Reset() = 0;      // 纯虚函数：重置迭代器位置
};

// 具体迭代器（模板类，适配字符串、int等多种类型）
template <typename T>
class ConcreteIterator : public Iterator<T> {
private:
    vector<T> items;  // 存储要遍历的元素
    int index;        // 当前遍历位置指针
public:
    // 初始化迭代器，绑定集合元素
    ConcreteIterator(const vector<T>& items) : items(items), index(0) {}

    // 判断是否有下一个元素
    bool HasNext() override {
        return index < items.size();
    }

    // 获取下一个元素，越界时抛出异常
    T Next() override {
        if (HasNext()) {
            return items[index++];
        }
        throw out_of_range("迭代器越界，无更多元素");
    }

    // 重置迭代器位置
    void Reset() override {
        index = 0;
    }
};

// 抽象聚合类（模板类，支持任意数据类型）
template <typename T>
class Aggregate {
public:
    virtual ~Aggregate() = default;
    virtual Iterator<T>* CreateIterator() = 0; // 纯虚函数：创建迭代器
    virtual void Add(const T& item) = 0;       // 纯虚函数：添加元素
};

// 具体聚合类（模板类，字符串集合）
template <typename T>
class ConcreteAggregate : public Aggregate<T> {
private:
    vector<T> items; // 底层存储元素的vector容器
public:
    // 添加元素到集合
    void Add(const T& item) override {
        items.push_back(item);
    }

    // 创建并返回具体迭代器实例
    Iterator<T>* CreateIterator() override {
        return new ConcreteIterator<T>(items);
    }
};

// 客户端测试代码
int main() {
    try {
        // 初始化具体聚合对象（字符串类型）
        ConcreteAggregate<string> collection;
        // 向集合中添加元素
        collection.Add("C++");
        collection.Add("迭代器模式");
        collection.Add("设计模式");

        // 创建迭代器
        Iterator<string>* iterator = collection.CreateIterator();
        cout << "C++ 迭代器遍历结果：" << endl;

        // 遍历元素
        while (iterator->HasNext()) {
            cout << iterator->Next() << endl;
        }

        // 重置迭代器并重新遍历
        iterator->Reset();
        cout << "C++ 迭代器重置后遍历结果：" << endl;
        while (iterator->HasNext()) {
            cout << iterator->Next() << endl;
        }

        // 释放内存，避免内存泄漏
        delete iterator;
    }
    catch (const out_of_range& e) {
        cout << "迭代异常：" << e.what() << endl;
    }
    catch (const exception& e) {
        cout << "其他异常：" << e.what() << endl;
    }

    return 0;
}

2.5 纯C语言实现（结构体+函数指针，模拟实现）

纯C语言无面向对象特性，无类和多态，通过“结构体封装数据+函数指针封装行为”，手动模拟迭代器模式的核心逻辑。用结构体封装聚合对象和迭代器的属性，用函数指针模拟抽象接口的方法，需手动管理内存，代码虽略显冗余，但底层可控性强，适配嵌入式、底层开发等资源受限场景，完美还原“遍历与存储解耦”的核心思想。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义最大字符串长度，避免内存溢出
#define MAX_STR_LEN 32

// 抽象迭代器：用函数指针模拟接口方法
typedef struct {
    char** items;                // 遍历的元素数组（字符串指针数组）
    int length;                  // 数组长度
    int index;                   // 当前遍历位置指针
    int (*HasNext)(void*);       // 函数指针：判断是否有下一个元素
    char* (*Next)(void*);        // 函数指针：获取下一个元素
    void (*Reset)(void*);        // 函数指针：重置迭代器位置
} Iterator;

// 具体迭代器方法：判断是否有下一个元素
int has_next(void* iterator) {
    if (iterator == NULL) {
        printf("迭代器实例为空，无法判断是否有下一个元素\n");
        return 0;
    }
    Iterator* it = (Iterator*)iterator;
    return it->index < it->length ? 1 : 0;
}

// 具体迭代器方法：获取下一个元素
char* next(void* iterator) {
    if (iterator == NULL) {
        printf("迭代器实例为空，无法获取元素\n");
        return NULL;
    }
    Iterator* it = (Iterator*)iterator;
    if (has_next(it)) {
        // 申请内存存储返回的字符串，避免野指针
        char* item = (char*)malloc(MAX_STR_LEN * sizeof(char));
        if (item == NULL) {
            printf("内存分配失败，无法获取元素\n");
            return NULL;
        }
        strncpy(item, it->items[it->index], MAX_STR_LEN - 1);
        item[MAX_STR_LEN - 1] = '\0'; // 确保字符串结束符
        it->index++;
        return item;
    }
    printf("迭代已结束，无更多元素\n");
    return NULL;
}

// 具体迭代器方法：重置迭代器位置
void reset(void* iterator) {
    if (iterator == NULL) {
        printf("迭代器实例为空，无法重置\n");
        return;
    }
    Iterator* it = (Iterator*)iterator;
    it->index = 0;
}

// 抽象聚合类：用结构体+函数指针模拟接口
typedef struct {
    char** items;                // 存储元素的字符串指针数组
    int length;                  // 数组长度
    Iterator* (*CreateIterator)(void*); // 函数指针：创建迭代器
} Aggregate;

// 具体聚合类方法：创建迭代器实例
Iterator* create_iterator(void* aggregate) {
    if (aggregate == NULL) {
        printf("聚合对象为空，无法创建迭代器\n");
        return NULL;
    }
    Aggregate* agg = (Aggregate*)aggregate;
    // 申请迭代器内存
    Iterator* it = (Iterator*)malloc(sizeof(Iterator));
    if (it == NULL) {
        printf("内存分配失败，无法创建迭代器\n");
        return NULL;
    }
    // 绑定聚合对象的元素和长度
    it->items = agg->items;
    it->length = agg->length;
    it->index = 0;
    // 绑定迭代器方法（函数指针赋值）
    it->HasNext = has_next;
    it->Next = next;
    it->Reset = reset;
    return it;
}

// 释放迭代器内存（避免内存泄漏）
void iterator_destroy(Iterator* it) {
    if (it != NULL) {
        free(it);
        it = NULL;
    }
}

// 客户端测试代码
int main() {
    // 1. 初始化集合数据（字符串数组）
    char* items[] = {"C语言", "迭代器模式", "设计模式"};
    int len = sizeof(items) / sizeof(char*);

    // 2. 初始化聚合对象
    Aggregate aggregate;
    aggregate.items = items;
    aggregate.length = len;
    aggregate.CreateIterator = create_iterator;

    // 3. 创建迭代器
    Iterator* iterator = aggregate.CreateIterator(&aggregate);
    if (iterator == NULL) {
        return -1;
    }

    // 4. 遍历元素
    printf("C语言 迭代器遍历结果：\n");
    char* item = NULL;
    while (iterator->HasNext(iterator)) {
        item = iterator->Next(iterator);
        if (item != NULL) {
            printf("%s\n", item);
            free(item); // 释放获取元素时申请的内存
            item = NULL;
        }
    }

    // 5. 重置迭代器并重新遍历
    iterator->Reset(iterator);
    printf("C语言 迭代器重置后遍历结果：\n");
    while (iterator->HasNext(iterator)) {
        item = iterator->Next(iterator);
        if (item != NULL) {
            printf("%s\n", item);
            free(item);
            item = NULL;
        }
    }

    // 6. 释放迭代器内存
    iterator_destroy(iterator);
    return 0;
}

三、迭代器模式的优缺点

迭代器模式的核心价值是“解耦遍历逻辑与集合存储，提供统一遍历接口”，其优缺点均围绕这一核心展开。在实际开发中，需结合集合的复杂度、遍历场景的需求和性能要求，权衡使用，避免过度设计或滥用，确保既发挥其核心优势，又规避潜在问题。

3.1 核心优点

解耦遍历与集合，符合单一职责原则：集合类专注于数据的存储与管理，迭代器类专注于遍历逻辑的实现，两者职责分离，降低代码耦合度，便于后期维护和迭代。
统一遍历接口，屏蔽底层差异：无论集合的底层存储结构（数组、链表、哈希表、树等）如何，外部都通过统一的迭代器接口遍历元素，调用者无需关心集合的内部实现，降低使用成本，提升代码的通用性。
支持多态遍历，扩展灵活：可针对同一集合实现多种迭代器（如正序遍历、逆序遍历、过滤遍历、深度优先遍历），无需修改集合本身，新增遍历逻辑只需新增迭代器，符合“开闭原则”。
简化集合扩展，提升系统可维护性：新增集合类型时，只需实现对应的迭代器，无需修改已有遍历代码，降低扩展成本；同时，遍历逻辑的修改仅需调整迭代器，不影响集合和调用者。
保护集合封装性：迭代器仅暴露遍历接口，不暴露集合的内部存储结构和操作细节，避免外部直接操作集合内部数据，提升代码的安全性和封装性。

3.2 主要缺点

增加代码复杂度，冗余度提升：对于简单集合（如小型数组），直接使用下标遍历或语言内置遍历方式即可，引入迭代器会增加额外的类/结构体、接口和方法定义，导致代码冗余，增加开发和维护成本。
存在轻微性能开销：相比直接遍历集合（如数组下标访问），迭代器的方法调用（如HasNext()、Next()）会带来轻微的运行时开销，对于高频遍历、低延迟要求的场景（如底层算法、高频数据处理），可能影响性能。
双向迭代/随机访问实现复杂：基础迭代器仅支持单向顺序遍历，若需实现双向迭代（向前/向后遍历）或随机访问（直接访问指定位置元素），需扩展迭代器接口，增加设计复杂度和实现成本。
多线程场景下需额外处理同步：在多线程并发遍历集合时，若集合发生修改（添加、删除元素），迭代器可能出现遍历异常（如 ConcurrentModificationException），需额外添加同步机制，增加代码复杂度。

四、迭代器模式的使用场景

迭代器模式的核心适用场景是“需要统一遍历接口、隐藏集合内部结构，或需要灵活扩展遍历逻辑”的业务场景。以下结合具体场景及典型实战案例，帮助开发者快速判断是否适用，实现精准落地，避免滥用或错用。

4.1 核心适用场景

隐藏集合内部结构的场景：当需要对外屏蔽集合的底层实现（如自定义容器、复杂数据结构、第三方集合库），仅暴露遍历能力，避免外部依赖集合的内部结构时，如框架级别的集合组件、自定义数据容器。
统一多集合遍历方式的场景：系统中存在多种集合类型（数组、链表、哈希表、树等），需为调用者提供一致的遍历接口，降低调用者的使用成本，如通用工具类、集合框架（如C#的ICollection、Java的Collection）。
自定义遍历逻辑的场景：需要实现特殊遍历规则（如过滤元素、逆序遍历、深度优先/广度优先遍历树/图结构、分页遍历），且遍历逻辑可能频繁变化时，如数据筛选工具、树形结构遍历、分页查询结果遍历。
跨语言/框架的集合操作场景：在多语言协作或通用框架中，需标准化集合遍历行为，确保不同语言、不同组件的遍历接口一致，如跨语言RPC框架中的集合传输、通用数据处理组件。
集合扩展频繁的场景：系统中频繁新增集合类型，且需要保证遍历接口的一致性，无需修改已有遍历代码，如插件化系统中的集合扩展、动态数据结构的遍历。

4.2 典型实战案例

编程语言内置集合框架：如C#的IEnumerable/IEnumerator、Java的Iterator/Iterable、C++的STL迭代器、Python的迭代器协议，均是迭代器模式的经典实现，为开发者提供统一的集合遍历接口。
数据库查询结果集遍历：如JDBC的ResultSet、ORM框架（MyBatis、EF Core）的查询结果迭代器，将数据库查询结果封装为集合，通过迭代器逐行遍历，屏蔽数据库底层存储差异。
树形结构/图结构遍历：如二叉树的前序、中序、后序遍历，图的深度优先（DFS）、广度优先（BFS）遍历，通过自定义迭代器实现不同的遍历逻辑，无需修改树/图的核心结构。
分页数据遍历：如电商平台的商品列表分页、后台系统的订单分页查询，通过迭代器封装分页逻辑，调用者只需通过迭代器获取下一页数据，无需关心分页的实现细节。
自定义容器开发：如开发自定义的缓存容器、队列、栈等数据结构，通过迭代器暴露遍历能力，隐藏容器的内部存储结构（如数组、链表），提升容器的封装性和可扩展性。

五、总结

迭代器模式的核心是“分离遍历逻辑与数据存储，提供统一的遍历接口”，它是“单一职责原则”和“开闭原则”的典型落地方式，通过将遍历行为抽离为独立的迭代器，让集合专注于数据管理，迭代器专注于遍历实现，大幅提升代码的灵活性、可维护性和可扩展性。其本质是“封装遍历变化”，屏蔽不同集合的底层差异，为外部提供标准化的遍历体验。

从多语言实现来看，尽管各语言的语法特性、设计理念差异显著，但核心逻辑高度统一，且均能适配自身的语言特性，完整实现迭代器模式的核心价值：

面向对象语言（C#、C++）：通过接口/抽象类严格遵循迭代器模式的四大角色，结合语言内置特性（如C#的IEnumerable、C++的模板）实现通用化、规范化的迭代器，贴合经典设计范式，适配企业级系统和高性能场景；
动态语言（Python）：利用原生迭代器协议简化实现，无需显式定义抽象接口，更注重实用性和简洁性，通过__iter__和__next__方法快速实现迭代器功能，适配快速开发场景；
Go语言：以“接口为核心”，通过接口定义迭代器和聚合类的契约，结构体实现具体逻辑，轻量化实现解耦目标，贴合高并发、高性能的后端开发需求，代码简洁高效；
纯C语言：通过结构体+函数指针模拟面向对象特性，手动封装数据和遍历行为，虽代码冗余，但底层可控性强，适配嵌入式、底层开发等资源受限场景，完美还原迭代器模式“解耦遍历与存储”的核心思想。

在工程实践中，使用迭代器模式需把握三个核心原则：一是避免过度设计，对于简单集合（如小型数组），直接使用语言内置的遍历方式即可，无需引入迭代器；二是权衡性能与灵活性，高频遍历、低延迟的场景需谨慎使用，或选择轻量级迭代器实现；三是注重接口设计，确保迭代器接口的通用性和扩展性，便于后续新增遍历逻辑和集合类型。

总体而言，迭代器模式是处理集合遍历场景的核心设计工具，尤其在集合类型多样、遍历逻辑复杂、需要隐藏内部结构的场景中价值显著。理解迭代器模式的核心，不在于照搬代码结构，而在于掌握“遍历逻辑与数据存储解耦”的设计思路，合理运用可让代码结构更清晰、职责更单一、扩展更灵活，提升系统的可维护性和复用性。

命令模式

发表于 2019-11-15 更新于 2026-04-20 分类于学习笔记，设计模式

命令模式（Command Pattern）是一种经典的行为型设计模式，其核心思想是将请求封装为独立的命令对象，通过命令对象作为中介，实现请求发起者（调用者）与请求执行者（接收者）的解耦。这种设计不仅允许使用不同的请求参数化对象，还支持命令的队列执行、批量处理、撤销与重做，以及日志记录与系统恢复，是提升代码扩展性、灵活性和可维护性的重要设计手段。

命令模式的核心价值在于“行为封装与解耦”——它将“做什么”（命令）与“谁来做”（接收者）、“何时做”（调用者）分离，让调用者无需关注接收者的具体实现，只需触发命令执行即可，完美契合“开闭原则”，为系统的扩展和维护提供了极大便利。

一、命令模式的核心结构

命令模式的结构清晰，角色分工明确，通常包含5个核心角色，各角色协同工作，构建起“请求发起→命令传递→业务执行”的完整链路，确保解耦性和扩展性：

1.1 抽象命令（Command）

定义命令执行的统一接口，是所有具体命令的通用契约，通常仅包含一个核心执行方法（如Execute()），部分场景可扩展撤销（Undo()）、重做（Redo()）等方法，规范命令的行为标准。

1.2 具体命令（Concrete Command）

实现抽象命令接口，是命令模式的核心实现类。它内部持有接收者的引用，在Execute()方法中调用接收者的具体业务方法，完成命令的实际执行，同时可封装命令执行所需的参数，实现请求的参数化。

1.3 接收者（Receiver）

真正执行命令核心业务逻辑的类，包含具体的业务操作（如文件读写、数据计算、接口调用等）。接收者不关心命令的存在，仅专注于自身业务逻辑的实现，被具体命令调用以完成请求。

1.4 调用者/请求者（Invoker）

负责调用命令对象执行请求，是命令的发起入口。它不直接与接收者交互，仅持有命令对象（可单个或多个），提供触发命令执行的方法，还可实现命令的队列管理、批量执行等功能。

1.5 客户端（Client）

负责创建具体命令对象，绑定命令与接收者的关联关系，将命令对象传递给调用者，是整个命令模式的初始化入口。客户端决定创建哪些命令、绑定哪些接收者，以及如何触发命令执行。

核心逻辑链路：客户端 → 构建具体命令（绑定接收者） → 调用者接收命令 → 调用者触发命令执行 → 具体命令调用接收者业务方法 → 完成请求。整个链路中，调用者与接收者完全解耦，仅通过命令对象交互。

二、多语言实现命令模式

为便于开发者落地实践，本文以“文件操作（创建文件）”为经典案例，实现多语言版本的命令模式：接收者负责文件创建的核心业务，具体命令封装文件创建请求，调用者触发命令执行，清晰呈现代理模式“解耦与封装”的核心特性。所有实现均保证完整可运行，贴合各语言设计理念，添加规范注释，兼顾实用性与可读性，同时补充异常处理细节，提升代码健壮性。

2.1 C# 实现（面向对象标准实现）

C# 作为强类型面向对象语言，通过接口定义抽象命令，类实现具体命令与调用者，依托对象组合绑定接收者，借助GC自动管理内存，代码结构严谨、可读性高，适配企业级业务系统开发，是命令模式最常用的实现方式之一。

using System;
using System.IO;

// 接收者：文件操作类（负责核心业务逻辑）
public class FileReceiver
{
    /// <summary>
    /// 核心业务方法：创建文件
    /// </summary>
    /// <param name="fileName">文件名称（含路径）</param>
    public void CreateFile(string fileName)
    {
        try
        {
            if (!File.Exists(fileName))
            {
                // 创建文件并及时关闭，避免资源泄漏
                using (FileStream stream = File.Create(fileName)) { }
                Console.WriteLine($"C#: 接收者成功创建文件 - {fileName}");
            }
            else
            {
                Console.WriteLine($"C#: 文件 {fileName} 已存在，无需重复创建");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"C#: 创建文件失败，异常信息：{ex.Message}");
        }
    }
}

// 抽象命令接口（定义命令执行的统一契约）
public interface ICommand
{
    /// <summary>
    /// 命令执行方法
    /// </summary>
    void Execute();
}

// 具体命令：创建文件命令（封装请求与接收者关联）
public class CreateFileCommand : ICommand
{
    // 持有接收者引用，通过构造函数注入，实现解耦
    private readonly FileReceiver _receiver;
    // 命令执行所需参数
    private readonly string _fileName;

    /// <summary>
    /// 初始化创建文件命令
    /// </summary>
    /// <param name="receiver">文件操作接收者</param>
    /// <param name="fileName">要创建的文件名称</param>
    public CreateFileCommand(FileReceiver receiver, string fileName)
    {
        _receiver = receiver ?? throw new ArgumentNullException(nameof(receiver), "接收者实例不可为null");
        _fileName = fileName ?? throw new ArgumentNullException(nameof(fileName), "文件名称不可为null");
    }

    /// <summary>
    /// 执行命令：调用接收者的核心业务方法
    /// </summary>
    public void Execute()
    {
        _receiver.CreateFile(_fileName);
    }
}

// 调用者：命令触发与管理（不直接依赖接收者）
public class CommandInvoker
{
    // 持有当前要执行的命令
    private ICommand _command;

    /// <summary>
    /// 设置要执行的命令
    /// </summary>
    /// <param name="command">具体命令实例</param>
    public void SetCommand(ICommand command)
    {
        _command = command;
    }

    /// <summary>
    /// 触发命令执行
    /// </summary>
    public void ExecuteCommand()
    {
        if (_command != null)
        {
            _command.Execute();
        }
        else
        {
            Console.WriteLine("C#: 未设置任何命令，无法执行");
        }
    }
}

// 客户端（初始化命令、绑定接收者、触发执行）
class Program
{
    static void Main(string[] args)
    {
        // 1. 初始化接收者（核心业务执行者）
        FileReceiver receiver = new FileReceiver();
        // 2. 初始化具体命令（绑定接收者与参数）
        ICommand createCommand = new CreateFileCommand(receiver, "csharp_file.txt");
        // 3. 初始化调用者（命令触发者）
        CommandInvoker invoker = new CommandInvoker();

        // 4. 执行命令
        invoker.SetCommand(createCommand);
        invoker.ExecuteCommand();
    }
}

2.2 Python 实现（动态语言简洁实现）

Python 遵循“鸭子类型”，无需显式定义接口，通过类的继承关系实现抽象命令逻辑，语法简洁灵活，无需繁琐的类型声明，依托GC自动管理内存，适配快速开发、脚本开发及轻量级项目场景，完整保留命令模式的核心逻辑与解耦特性。

import os

# 接收者：文件操作类（核心业务逻辑实现）
class FileReceiver:
    def create_file(self, file_name):
        """核心业务方法：创建文件"""        try:
            if not os.path.exists(file_name):
                # 以写入模式创建文件，自动关闭资源
                with open(file_name, "w", encoding="utf-8") as f:
                    pass
                print(f"Python: 接收者成功创建文件 - {file_name}")
            else:
                print(f"Python: 文件 {file_name} 已存在，无需重复创建")
        except Exception as e:
            print(f"Python: 创建文件失败，异常信息：{str(e)}")

# 抽象命令（基类，定义统一执行接口）
class Command:
    def execute(self):
        """命令执行抽象方法，子类必须实现"""        raise NotImplementedError("子类必须重写execute方法，实现命令逻辑")

# 具体命令：创建文件命令（封装请求与接收者）
class CreateFileCommand(Command):
    def __init__(self, receiver, file_name):
        """初始化创建文件命令"""        self.receiver = receiver  # 持有接收者引用
        self.file_name = file_name  # 命令执行参数
    
    def execute(self):
        """执行命令：调用接收者的核心业务方法"""        self.receiver.create_file(self.file_name)

# 调用者：命令触发与管理
class CommandInvoker:
    def __init__(self):
        self._command = None  # 持有当前命令
    
    def set_command(self, command):
        """设置要执行的命令"""        self._command = command
    
    def execute_command(self):
        """触发命令执行"""        if self._command:
            self._command.execute()
        else:
            print("Python: 未设置任何命令，无法执行")

# 客户端调用
if __name__ == "__main__":
    # 初始化接收者、命令、调用者
    receiver = FileReceiver()
    create_command = CreateFileCommand(receiver, "python_file.txt")
    invoker = CommandInvoker()
    
    # 执行命令
    invoker.set_command(create_command)
    invoker.execute_command()

2.3 Golang 实现（接口至上的极简实现）

Go 语言无类和继承概念，核心遵循“组合优于继承”的设计哲学，通过接口定义命令的统一契约，结构体实现具体命令、接收者和调用者，代码极简、高效，贴合Go语言“简洁、务实、高性能”的设计理念，适配高并发、高性能的后端开发场景。

package main

import (
    "fmt"
    "os"
)

// 接收者：文件操作结构体（核心业务逻辑实现）
type FileReceiver struct{}

// CreateFile 核心业务方法：创建文件
func (f *FileReceiver) CreateFile(fileName string) {
    // 检查文件是否存在
    if _, err := os.Stat(fileName); os.IsNotExist(err) {
        // 创建文件并延迟关闭，避免资源泄漏
        file, err := os.Create(fileName)
        if err != nil {
            fmt.Printf("Golang: 创建文件失败，异常信息：%v\n", err)
            return
        }
        defer file.Close()
        fmt.Printf("Golang: 接收者成功创建文件 - %s\n", fileName)
    } else {
        fmt.Printf("Golang: 文件 %s 已存在，无需重复创建\n", fileName)
    }
}

// 抽象命令接口（定义命令执行的统一契约）
type Command interface {
    Execute() // 命令执行方法
}

// 具体命令：创建文件命令（封装接收者与参数）
type CreateFileCommand struct {
    receiver  *FileReceiver // 持有接收者引用
    fileName string         // 命令执行参数
}

// NewCreateFileCommand 工厂函数：创建创建文件命令实例
func NewCreateFileCommand(receiver *FileReceiver, fileName string) *CreateFileCommand {
    return &CreateFileCommand{
        receiver:  receiver,
        fileName: fileName,
    }
}

// Execute 执行命令：调用接收者的核心业务方法
func (c *CreateFileCommand) Execute() {
    c.receiver.CreateFile(c.fileName)
}

// 调用者：命令触发与管理
type CommandInvoker struct {
    command Command // 持有当前命令
}

// SetCommand 设置要执行的命令
func (i *CommandInvoker) SetCommand(command Command) {
    i.command = command
}

// ExecuteCommand 触发命令执行
func (i *CommandInvoker) ExecuteCommand() {
    if i.command != nil {
        i.command.Execute()
    } else {
        fmt.Println("Golang: 未设置任何命令，无法执行")
    }
}

// 客户端调用
func main() {
    // 初始化接收者
    receiver := &FileReceiver{}
    // 初始化具体命令（绑定接收者与参数）
    createCommand := NewCreateFileCommand(receiver, "golang_file.txt")
    // 初始化调用者
    invoker := &CommandInvoker{}
    
    // 执行命令
    invoker.SetCommand(createCommand)
    invoker.ExecuteCommand()
}

2.4 C++ 实现（面向对象经典实现）

C++ 作为经典面向对象语言，通过抽象类（纯虚函数）定义抽象命令，子类实现具体命令与接收者，依托继承关系和对象组合实现解耦，需手动管理内存（通过析构函数释放对象），兼顾灵活性与高性能，适配底层开发、高频调用场景，是底层系统、高性能应用的优选实现方式。

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

// 接收者：文件操作类（核心业务逻辑实现）
class FileReceiver {
public:
    /// <summary>
    /// 核心业务方法：创建文件
    /// </summary>
    /// <param name="fileName">文件名称（含路径）</param>
    void createFile(const string& fileName) {
        // 检查文件是否存在
        ifstream file(fileName);
        if (!file.good()) {
            // 创建文件并关闭
            ofstream newFile(fileName);
            if (newFile.is_open()) {
                newFile.close();
                cout << "C++: 接收者成功创建文件 - " << fileName << endl;
            } else {
                cout << "C++: 创建文件失败，无法打开文件流" << endl;
            }
        } else {
            cout << "C++: 文件 " << fileName << " 已存在，无需重复创建" << endl;
        }
        file.close();
    }
};

// 抽象命令类（纯虚函数定义统一契约）
class Command {
public:
    virtual ~Command() = default; // 虚析构函数，避免多态场景下内存泄漏
    virtual void execute() = 0;   // 纯虚函数，命令执行方法，子类必须实现
};

// 具体命令：创建文件命令（封装接收者与参数）
class CreateFileCommand : public Command {
private:
    FileReceiver* receiver; // 持有接收者指针
    string fileName;        // 命令执行参数
public:
    /// <summary>
    /// 初始化创建文件命令
    /// </summary>
    /// <param name="recv">文件操作接收者指针</param>
    /// <param name="name">要创建的文件名称</param>
    CreateFileCommand(FileReceiver* recv, string name) : receiver(recv), fileName(name) {}

    /// <summary>
    /// 执行命令：调用接收者的核心业务方法
    /// </summary>
    void execute() override {
        if (receiver != nullptr) {
            receiver->createFile(fileName);
        } else {
            cout << "C++: 接收者实例为空，无法执行命令" << endl;
        }
    }
};

// 调用者：命令触发与管理
class CommandInvoker {
private:
    Command* command; // 持有当前命令指针
public:
    CommandInvoker() : command(nullptr) {}
    ~CommandInvoker() {
        // 释放命令对象，避免内存泄漏
        delete command;
        command = nullptr;
    }

    /// <summary>
    /// 设置要执行的命令
    /// </summary>
    /// <param name="cmd">具体命令指针</param>
    void setCommand(Command* cmd) {
        // 先释放原有命令，避免内存泄漏
        delete command;
        command = cmd;
    }

    /// <summary>
    /// 触发命令执行
    /// </summary>
    void executeCommand() {
        if (command != nullptr) {
            command->execute();
        } else {
            cout << "C++: 未设置任何命令，无法执行" << endl;
        }
    }
};

// 客户端调用
int main() {
    // 初始化接收者
    FileReceiver* receiver = new FileReceiver();
    // 初始化具体命令（绑定接收者与参数）
    Command* createCommand = new CreateFileCommand(receiver, "cpp_file.txt");
    // 初始化调用者
    CommandInvoker* invoker = new CommandInvoker();

    // 执行命令
    invoker->setCommand(createCommand);
    invoker->executeCommand();

    // 释放资源，避免内存泄漏
    delete receiver;
    delete invoker;
    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C语言无面向对象特性，无类和多态，通过“结构体封装数据+函数指针封装行为”，手动模拟命令模式的核心逻辑，用函数指针实现命令的统一执行接口，用结构体封装接收者、命令和调用者，需手动管理内存，代码虽略显冗余，但底层可控性强，适配嵌入式、底层开发等资源受限场景，完美还原“命令封装、解耦调用”的核心思想。

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <string.h>

// 接收者：文件操作结构体（封装数据，无额外属性时可仅作为标识）
typedef struct {
    // 可扩展接收者属性（如文件路径前缀、权限等）
} FileReceiver;

// 接收者核心业务方法：创建文件
void file_receiver_create_file(FileReceiver* receiver, const char* fileName) {
    (void)receiver; // 未使用接收者属性，仅占位，保证接口一致性
    // 检查文件是否存在
    if (access(fileName, F_OK) != 0) {
        FILE* file = fopen(fileName, "w");
        if (file != NULL) {
            fclose(file);
            printf("C: 接收者成功创建文件 - %s\n", fileName);
        } else {
            printf("C: 创建文件失败，无法打开文件\n");
        }
    } else {
        printf("C: 文件 %s 已存在，无需重复创建\n", fileName);
    }
}

// 抽象命令：函数指针（模拟命令执行的统一接口）
typedef void (*CommandExecuteFunc)(void*);

// 具体命令结构体：封装接收者、执行参数、执行函数
typedef struct {
    FileReceiver* receiver;    // 持有接收者引用
    const char* fileName;      // 命令执行参数
    CommandExecuteFunc execute;// 命令执行函数指针
} CreateFileCommand;

// 具体命令执行逻辑：调用接收者的核心业务方法
void create_file_command_execute(void* command) {
    if (command == NULL) {
        printf("C: 命令实例为空，无法执行\n");
        return;
    }
    CreateFileCommand* cmd = (CreateFileCommand*)command;
    if (cmd->receiver != NULL && cmd->fileName != NULL) {
        file_receiver_create_file(cmd->receiver, cmd->fileName);
    } else {
        printf("C: 接收者或文件名称为空，无法执行命令\n");
    }
}

// 调用者结构体：持有命令，负责触发执行
typedef struct {
    void* command; // 通用命令指针（适配所有具体命令）
} CommandInvoker;

// 调用者方法：设置要执行的命令
void command_invoker_set_command(CommandInvoker* invoker, void* cmd) {
    if (invoker != NULL) {
        invoker->command = cmd;
    } else {
        printf("C: 调用者实例为空，无法设置命令\n");
    }
}

// 调用者方法：触发命令执行
void command_invoker_execute_command(CommandInvoker* invoker) {
    if (invoker == NULL) {
        printf("C: 调用者实例为空，无法执行命令\n");
        return;
    }
    if (invoker->command != NULL) {
        CreateFileCommand* cmd = (CreateFileCommand*)invoker->command;
        // 调用命令的执行函数
        cmd->execute(invoker->command);
    } else {
        printf("C: 未设置任何命令，无法执行\n");
    }
}

// 创建接收者实例
FileReceiver* file_receiver_create() {
    FileReceiver* receiver = (FileReceiver*)malloc(sizeof(FileReceiver));
    if (receiver == NULL) {
        printf("C: 接收者实例创建失败\n");
    }
    return receiver;
}

// 创建创建文件命令实例
CreateFileCommand* create_file_command_create(FileReceiver* receiver, const char* fileName) {
    if (receiver == NULL || fileName == NULL) {
        printf("C: 接收者或文件名称为空，无法创建命令\n");
        return NULL;
    }
    CreateFileCommand* cmd = (CreateFileCommand*)malloc(sizeof(CreateFileCommand));
    if (cmd == NULL) {
        printf("C: 命令实例创建失败\n");
        return NULL;
    }
    cmd->receiver = receiver;
    cmd->fileName = fileName;
    cmd->execute = create_file_command_execute;
    return cmd;
}

// 创建调用者实例
CommandInvoker* command_invoker_create() {
    CommandInvoker* invoker = (CommandInvoker*)malloc(sizeof(CommandInvoker));
    if (invoker == NULL) {
        printf("C: 调用者实例创建失败\n");
    }
    invoker->command = NULL;
    return invoker;
}

// 释放资源
void file_receiver_destroy(FileReceiver* receiver) {
    if (receiver != NULL) {
        free(receiver);
        receiver = NULL;
    }
}

void create_file_command_destroy(CreateFileCommand* cmd) {
    if (cmd != NULL) {
        free(cmd);
        cmd = NULL;
    }
}

void command_invoker_destroy(CommandInvoker* invoker) {
    if (invoker != NULL) {
        free(invoker);
        invoker = NULL;
    }
}

// 客户端调用
int main() {
    // 1. 初始化接收者
    FileReceiver* receiver = file_receiver_create();
    if (receiver == NULL) return -1;
    
    // 2. 初始化具体命令（绑定接收者与参数）
    CreateFileCommand* createCommand = create_file_command_create(receiver, "c_file.txt");
    if (createCommand == NULL) {
        file_receiver_destroy(receiver);
        return -1;
    }
    
    // 3. 初始化调用者
    CommandInvoker* invoker = command_invoker_create();
    if (invoker == NULL) {
        create_file_command_destroy(createCommand);
        file_receiver_destroy(receiver);
        return -1;
    }
    
    // 4. 执行命令
    command_invoker_set_command(invoker, createCommand);
    command_invoker_execute_command(invoker);
    
    // 5. 释放资源，避免内存泄漏
    command_invoker_destroy(invoker);
    create_file_command_destroy(createCommand);
    file_receiver_destroy(receiver);
    
    return 0;
}

三、命令模式的优缺点

命令模式的核心价值是“解耦调用者与接收者、灵活管理请求”，其优缺点均围绕这一核心展开。在实际开发中，需结合业务场景的复杂度、扩展需求和性能要求，权衡使用，避免过度设计或滥用，确保既发挥其核心优势，又规避潜在问题，实现架构设计的合理性。

3.1 核心优点

解耦性极强，符合开闭原则：调用者与接收者完全解耦，调用者无需知道接收者的具体实现、方法名和参数，只需调用命令的执行方法即可；新增命令时，只需实现抽象命令接口/结构体，无需修改现有调用者和接收者代码，扩展性极强。
请求管理灵活：支持命令的队列执行、批量处理、异步执行，可将多个命令组合成复合命令（如事务操作），实现“要么全部执行，要么全部回滚”的逻辑，适配复杂业务场景。
支持撤销与重做：通过扩展Undo()、Redo()方法，可实现命令的回滚和重复执行（如文本编辑器的撤销功能、软件的操作回滚），提升用户体验和系统容错性。
便于日志记录与系统恢复：可将命令的执行过程序列化到日志，系统崩溃或异常后，通过重新执行日志中的命令，恢复系统状态，尤其适用于金融、电商等对数据一致性要求高的场景。
请求参数化与复用：命令对象可封装请求所需的参数，同一个命令可被不同调用者复用，也可通过修改参数实现不同的请求逻辑，提升代码复用率。

3.2 主要缺点

类/结构体数量膨胀：每个具体命令都需要对应一个类/结构体，当系统中命令数量较多时，会导致类/结构体数量激增，增加代码的复杂度和维护成本。
存在轻微性能开销：命令模式通过“调用者→命令→接收者”的三层调用链路实现请求执行，相比直接调用接收者方法，会增加少量运行时开销，对极致性能优化的场景（如高频调用、低延迟需求）不友好。
逻辑间接性提升，调试难度增加：请求的执行链路变长，出现问题时，需依次排查调用者、命令、接收者三层逻辑，定位问题的难度提升，增加调试成本。
复合命令实现复杂：当需要实现命令的组合、撤销/重做时，逻辑会变得复杂（如需要维护命令执行历史、处理命令依赖关系），增加开发难度。

四、命令模式的使用场景

命令模式的核心适用场景是“需要解耦请求发起与请求执行、且需灵活管理请求（如队列、撤销、日志）”的业务场景。以下结合具体场景及典型实战案例，帮助开发者快速判断是否适用，实现精准落地，避免滥用或错用。

4.1 核心适用场景

GUI交互场景：按钮点击、菜单选择、快捷键操作等（如点击“保存”按钮，触发保存命令，按钮无需知道如何保存，只需触发命令执行），典型案例：桌面应用的菜单操作、网页按钮交互。
撤销/重做功能场景：文本编辑器、绘图工具、代码编辑器的撤销（Undo）、重做（Redo）操作，通过记录命令执行历史，实现操作的回滚和重复执行。
批处理与异步执行场景：命令队列、任务调度、异步任务处理（如定时任务执行、消息队列消费、批量数据处理），将多个命令放入队列，依次执行或异步执行，提升系统吞吐量。
事务操作场景：数据库事务、分布式事务的提交/回滚，将多个操作封装为复合命令，要么全部执行成功，要么全部回滚，确保数据一致性，典型案例：电商订单创建（扣减库存、创建订单、扣减余额）。
远程调用与RPC场景：RPC框架中，将客户端的请求封装为命令对象，通过网络传输到服务端，服务端执行命令并返回结果，屏蔽网络通信细节，实现客户端与服务端的解耦。
日志恢复与审计场景：金融、电商、政务系统的操作日志，记录用户的每一步操作（命令），系统故障后重新执行命令恢复数据，同时用于操作审计，追溯操作行为。
插件化与扩展场景：系统插件开发，将插件的功能封装为命令，主程序通过调用命令实现插件功能，无需修改主程序代码，提升系统的可扩展性。

4.2 典型实战案例

文本编辑器的撤销/重做：如Notepad++、VS Code的撤销功能，每一次编辑操作（输入、删除、格式调整）都封装为命令，存入命令历史栈，撤销时弹出最后一个命令执行Undo()，重做时重新执行命令。
电商订单处理：订单创建流程包含“扣减库存、创建订单记录、扣减用户余额、发送通知”四个步骤，将每个步骤封装为命令，组合成复合命令，执行成功则提交，任意步骤失败则全部回滚，确保数据一致性。
消息队列与任务调度：如RabbitMQ、Kafka的消息消费，将每条消息的处理逻辑封装为命令，消费者从队列中获取命令并执行，实现异步处理和解耦；定时任务框架（如Quartz），将定时任务封装为命令，到点触发执行。
RPC框架的请求封装：如Dubbo、gRPC，客户端发起的请求被封装为命令对象（包含请求参数、接口信息），通过网络传输到服务端，服务端解析命令并执行对应的业务逻辑，返回结果。
游戏开发的技能释放：游戏中角色的技能释放，将每个技能封装为命令，包含技能效果、冷却时间等参数，调用者（角色）触发技能命令，接收者（技能系统）执行技能效果，支持技能的队列释放、撤销（如技能打断）。

五、总结

命令模式的核心是“请求封装、解耦调用、灵活管理”，它通过将请求封装为独立的命令对象，实现了调用者与接收者的完全解耦，让请求的执行、组合、撤销、日志记录变得灵活可控，是行为型设计模式中“解耦与扩展”的典型代表。其本质是将“行为”抽象为对象，让行为具备可复用、可管理、可扩展的特性，完美契合“开闭原则”和“单一职责原则”。

从多语言实现来看，尽管各语言的语法特性差异显著，但核心逻辑高度统一，且均能适配自身的设计理念，完整实现命令模式的核心价值：

面向对象语言（C#、Python、C++）：通过接口/抽象类定义命令的统一契约，具体命令绑定接收者并实现执行逻辑，依托面向对象的封装、多态特性，实现逻辑清晰、易于维护的代码结构，适配大多数业务场景，尤其适合企业级系统开发；
Go语言：遵循“接口至上”和“组合优于继承”，通过接口定义命令规范，结构体实现命令、接收者和调用者，代码极简高效，贴合高并发、高性能的后端开发需求，是后端服务开发的优选实现方式；
纯C语言：通过结构体+函数指针模拟面向对象特性，用函数指针实现命令的统一执行接口，用结构体封装数据和行为，手动管理内存和命令生命周期，底层可控性强，适配嵌入式、底层开发等资源受限场景，虽代码冗余，但能完整还原命令模式的核心思想。

在工程实践中，使用命令模式需把握三个核心原则：一是判断业务场景是否需要解耦请求发起与执行，是否需要命令的队列、撤销、日志等功能，简单的方法调用无需引入命令模式，避免过度设计；二是控制命令的数量和复杂度，命令过多时可通过复合命令、命令工厂等方式简化管理；三是权衡性能开销，高频调用、低延迟的场景需谨慎使用，或选择轻量级的命令实现方式。

总体而言，命令模式是解耦系统、提升扩展性和灵活性的高效工具，尤其在GUI交互、事务处理、异步任务、日志恢复等场景中价值显著。合理使用命令模式，可让代码结构更清晰、职责更单一、扩展更灵活，同时提升系统的可维护性和容错性，是每一位开发者必备的架构设计工具。

模板方法

发表于 2019-11-14 更新于 2026-04-20 分类于学习笔记，设计模式

模板方法模式（Template Method Pattern）是一种经典的行为型设计模式，其核心思想是定义一个算法的骨架流程，将算法中不变的核心步骤固化在父类的模板方法中，而将算法中可变的具体实现步骤延迟到子类中实现。通过这种“固定骨架、灵活填充”的设计，既能保证算法整体流程的一致性，又能让子类在不改变算法结构的前提下，灵活定制具体步骤的实现，是软件设计中实现代码复用、规范流程、提升扩展性的重要手段。

模板方法模式的核心价值在于“封装不变、扩展可变”，它将多个子类共有的通用逻辑提取到父类中，避免代码冗余，同时通过抽象方法预留扩展点，让子类按需实现差异化逻辑，完美契合“开闭原则”——对扩展开放，对修改关闭。

一、模板方法模式的核心结构

模板方法模式的结构简洁清晰，核心角色分为两类，二者协同工作，实现“骨架固定、细节灵活”的设计目标，确保算法流程的一致性与实现的灵活性：

1.1 抽象类（Abstract Class）

模板方法模式的核心角色，负责定义算法的骨架流程。它包含两种类型的方法：

模板方法（Template Method）：定义算法的整体执行流程，通常为非抽象方法（可加final修饰，防止子类重写破坏流程），依次调用算法的各个步骤，包括不变的通用步骤和可变的抽象步骤。
基本方法：构成算法流程的具体步骤，分为两种：一是抽象方法（Abstract Method），由子类实现的可变步骤，父类仅定义方法签名，不提供具体实现；二是具体方法（Concrete Method），父类提供的不变通用步骤，子类可直接复用，无需重写（也可根据需求重写，称为“钩子方法”）。

1.2 具体子类（Concrete Class）

继承抽象类，负责实现抽象类中定义的抽象方法，即填充算法流程中可变的具体步骤。子类无需修改算法的整体流程，仅需专注于自身业务场景下的步骤实现，确保算法流程的一致性，同时实现差异化逻辑。

核心逻辑链路：客户端调用抽象类的模板方法 → 模板方法按固定流程调用基本方法（通用步骤+子类实现的可变步骤） → 完成算法执行。整个过程中，算法骨架不变，可变细节由子类灵活实现。

二、多语言实现模板方法模式

为便于开发者落地实践，本文以“饮品制作流程”为经典案例，实现多语言版本的模板方法模式：饮品制作的整体流程（烧水→冲泡→倒入容器→添加配料）为固定骨架，其中“冲泡”和“添加配料”为可变步骤（不同饮品实现不同），“烧水”和“倒入容器”为通用步骤（所有饮品均可复用）。所有实现均保证完整可运行，贴合各语言设计理念，添加规范注释，兼顾实用性与可读性。

2.1 C# 实现（面向对象标准实现）

C# 作为强类型面向对象语言，通过抽象类定义算法骨架，抽象方法定义可变步骤，具体方法定义通用步骤，模板方法用final（C#中为sealed）修饰防止子类破坏流程，代码结构严谨、可读性高，适配企业级业务系统开发，是最常用的实现方式之一。

using System;

// 抽象类：饮品制作模板（定义算法骨架）
public abstract class BeverageTemplate
{
    /// <summary>
    /// 模板方法：定义饮品制作的固定流程（不可重写，防止破坏流程）
    /// </summary>
    public sealed void MakeBeverage()
    {
        BoilWater();       // 通用步骤：烧水
        Brew();            // 可变步骤：冲泡（子类实现）
        PourInCup();       // 通用步骤：倒入容器
        AddCondiments();   // 可变步骤：添加配料（子类实现）
        Console.WriteLine("饮品制作完成！\n");
    }

    /// <summary>
    /// 具体方法：通用步骤 - 烧水（所有饮品复用）
    /// </summary>
    protected void BoilWater()
    {
        Console.WriteLine("步骤1：烧开水（100℃）");
    }

    /// <summary>
    /// 抽象方法：可变步骤 - 冲泡（子类实现差异化逻辑）
    /// </summary>
    protected abstract void Brew();

    /// <summary>
    /// 具体方法：通用步骤 - 倒入容器（所有饮品复用）
    /// </summary>
    protected void PourInCup()
    {
        Console.WriteLine("步骤3：将饮品倒入杯子中");
    }

    /// <summary>
    /// 抽象方法：可变步骤 - 添加配料（子类实现差异化逻辑）
    /// </summary>
    protected abstract void AddCondiments();
}

// 具体子类1：咖啡制作（实现可变步骤）
public class Coffee : BeverageTemplate
{
    protected override void Brew()
    {
        Console.WriteLine("步骤2：用沸水冲泡咖啡粉");
    }

    protected override void AddCondiments()
    {
        Console.WriteLine("步骤4：添加牛奶和方糖");
    }
}

// 具体子类2：茶制作（实现可变步骤）
public class Tea : BeverageTemplate
{
    protected override void Brew()
    {
        Console.WriteLine("步骤2：用沸水冲泡茶叶");
    }

    protected override void AddCondiments()
    {
        Console.WriteLine("步骤4：添加柠檬片");
    }
}

// 客户端调用（仅依赖抽象类，符合依赖倒置原则）
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("制作咖啡：");
        BeverageTemplate coffee = new Coffee();
        coffee.MakeBeverage();

        Console.WriteLine("制作茶：");
        BeverageTemplate tea = new Tea();
        tea.MakeBeverage();
    }
}

2.2 Python 实现（动态语言简洁实现）

Python 遵循“鸭子类型”，无需显式定义抽象类（可借助abc模块模拟），通过类的继承关系实现模板方法模式，语法简洁灵活，无需繁琐的类型声明，依托GC自动管理内存，适配快速开发、脚本开发及轻量级项目场景，完整保留模板方法模式的核心逻辑。

from abc import ABC, abstractmethod

# 抽象类：饮品制作模板（借助ABC模块模拟抽象类）
class BeverageTemplate(ABC):
    def make_beverage(self):
        """模板方法：定义饮品制作的固定流程（不可重写，Python中通过命名规范约束）"""        self.boil_water()       # 通用步骤：烧水
        self.brew()            # 可变步骤：冲泡（子类实现）
        self.pour_in_cup()      # 通用步骤：倒入容器
        self.add_condiments()   # 可变步骤：添加配料（子类实现）
        print("饮品制作完成！\n")
    
    def boil_water(self):
        """具体方法：通用步骤 - 烧水（所有饮品复用）"""        print("步骤1：烧开水（100℃）")
    
    @abstractmethod
    def brew(self):
        """抽象方法：可变步骤 - 冲泡（子类必须实现）"""        pass
    
    def pour_in_cup(self):
        """具体方法：通用步骤 - 倒入容器（所有饮品复用）"""        print("步骤3：将饮品倒入杯子中")
    
    @abstractmethod
    def add_condiments(self):
        """抽象方法：可变步骤 - 添加配料（子类必须实现）"""        pass

# 具体子类1：咖啡制作
class Coffee(BeverageTemplate):
    def brew(self):
        print("步骤2：用沸水冲泡咖啡粉")
    
    def add_condiments(self):
        print("步骤4：添加牛奶和方糖")

# 具体子类2：茶制作
class Tea(BeverageTemplate):
    def brew(self):
        print("步骤2：用沸水冲泡茶叶")
    
    def add_condiments(self):
        print("步骤4：添加柠檬片")

# 客户端调用
if __name__ == "__main__":
    print("制作咖啡：")
    coffee = Coffee()
    coffee.make_beverage()
    
    print("制作茶：")
    tea = Tea()
    tea.make_beverage()

2.3 Go 实现（接口+结构体的极简实现）

Go 语言无类和继承概念，核心遵循“组合优于继承”的设计哲学，通过接口定义可变步骤的契约，结构体嵌入实现通用步骤，模板方法定义固定流程，代码极简、高效，贴合Go语言“简洁、务实、高性能”的设计理念，适配高并发、高性能的后端开发场景。

package main

import (
    "fmt"
)

// 定义可变步骤的接口（抽象方法契约）
type BeverageInterface interface {
    Brew()            // 可变步骤：冲泡
    AddCondiments()   // 可变步骤：添加配料
}

// 抽象模板结构体：实现通用步骤，嵌入接口实现可变步骤
type BeverageTemplate struct {
    BeverageInterface // 嵌入接口，实现依赖注入
}

// 模板方法：定义固定流程（不可重写，Go中通过结构体方法实现）
func (t *BeverageTemplate) MakeBeverage() {
    t.BoilWater()       // 通用步骤：烧水
    t.Brew()            // 可变步骤：调用接口方法（子类实现）
    t.PourInCup()       // 通用步骤：倒入容器
    t.AddCondiments()   // 可变步骤：调用接口方法（子类实现）
    fmt.Println("饮品制作完成！\n")
}

// 通用步骤：烧水（所有饮品复用）
func (t *BeverageTemplate) BoilWater() {
    fmt.Println("步骤1：烧开水（100℃）")
}

// 通用步骤：倒入容器（所有饮品复用）
func (t *BeverageTemplate) PourInCup() {
    fmt.Println("步骤3：将饮品倒入杯子中")
}

// 具体子类1：咖啡制作（实现接口的可变步骤）
type Coffee struct{}

func (c *Coffee) Brew() {
    fmt.Println("步骤2：用沸水冲泡咖啡粉")
}

func (c *Coffee) AddCondiments() {
    fmt.Println("步骤4：添加牛奶和方糖")
}

// 具体子类2：茶制作（实现接口的可变步骤）
type Tea struct{}

func (t *Tea) Brew() {
    fmt.Println("步骤2：用沸水冲泡茶叶")
}

func (t *Tea) AddCondiments() {
    fmt.Println("步骤4：添加柠檬片")
}

// 客户端调用
func main() {
    fmt.Println("制作咖啡：")
    coffee := &Coffee{}
    coffeeTemplate := &BeverageTemplate{BeverageInterface: coffee}
    coffeeTemplate.MakeBeverage()
    
    fmt.Println("制作茶：")
    tea := &Tea{}
    teaTemplate := &BeverageTemplate{BeverageInterface: tea}
    teaTemplate.MakeBeverage()
}

2.4 C++ 实现（面向对象经典实现）

C++ 作为经典面向对象语言，通过抽象类（纯虚函数）定义可变步骤，具体方法定义通用步骤，模板方法用final修饰防止子类重写，依托继承关系实现代码复用，需手动管理内存，兼顾灵活性与高性能，适配底层开发、高频调用场景，是底层系统、高性能应用的优选实现方式。

#include <iostream>
using namespace std;

// 抽象类：饮品制作模板（定义算法骨架）
class BeverageTemplate {
public:
    // 模板方法：固定流程，final修饰防止子类重写
    final void makeBeverage() {
        boilWater();       // 通用步骤：烧水
        brew();            // 可变步骤：冲泡（纯虚函数，子类实现）
        pourInCup();       // 通用步骤：倒入容器
        addCondiments();   // 可变步骤：添加配料（纯虚函数，子类实现）
        cout << "饮品制作完成！\n" << endl;
    }

protected:
    // 具体方法：通用步骤 - 烧水（所有饮品复用）
    void boilWater() {
        cout << "步骤1：烧开水（100℃）" << endl;
    }

    // 纯虚函数：可变步骤 - 冲泡（子类必须实现）
    virtual void brew() = 0;

    // 具体方法：通用步骤 - 倒入容器（所有饮品复用）
    void pourInCup() {
        cout << "步骤3：将饮品倒入杯子中" << endl;
    }

    // 纯虚函数：可变步骤 - 添加配料（子类必须实现）
    virtual void addCondiments() = 0;

    // 析构函数：虚析构，避免多态场景下内存泄漏
    virtual ~BeverageTemplate() = default;
};

// 具体子类1：咖啡制作
class Coffee : public BeverageTemplate {
protected:
    void brew() override {
        cout << "步骤2：用沸水冲泡咖啡粉" << endl;
    }

    void addCondiments() override {
        cout << "步骤4：添加牛奶和方糖" << endl;
    }
};

// 具体子类2：茶制作
class Tea : public BeverageTemplate {
protected:
    void brew() override {
        cout << "步骤2：用沸水冲泡茶叶" << endl;
    }

    void addCondiments() override {
        cout << "步骤4：添加柠檬片" << endl;
    }
};

// 客户端调用
int main() {
    cout << "制作咖啡：" << endl;
    BeverageTemplate* coffee = new Coffee();
    coffee->makeBeverage();
    delete coffee; // 释放资源

    cout << "制作茶：" << endl;
    BeverageTemplate* tea = new Tea();
    tea->makeBeverage();
    delete tea; // 释放资源

    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C语言无面向对象特性，无类和继承，通过“结构体封装数据+函数指针封装行为”，手动模拟模板方法模式的核心逻辑，用函数指针实现可变步骤，用普通函数实现通用步骤，需手动管理内存，代码虽略显冗余，但底层可控性强，适配嵌入式、底层开发等资源受限场景，完美还原“固定骨架、灵活填充”的核心思想。

#include <stdio.h>
#include <stdlib.h>

// 定义可变步骤的函数指针（模拟抽象方法）
typedef void (*BrewFunc)();
typedef void (*AddCondimentsFunc)();

// 抽象模板结构体：封装通用步骤和可变步骤的函数指针
typedef struct {
    BrewFunc brew;                // 可变步骤：冲泡
    AddCondimentsFunc add_condiments; // 可变步骤：添加配料
} BeverageTemplate;

// 通用步骤：烧水（所有饮品复用）
void boil_water() {
    printf("步骤1：烧开水（100℃）\n");
}

// 通用步骤：倒入容器（所有饮品复用）
void pour_in_cup() {
    printf("步骤3：将饮品倒入杯子中\n");
}

// 模板方法：定义固定流程
void make_beverage(BeverageTemplate* template) {
    if (template == NULL || template->brew == NULL || template->add_condiments == NULL) {
        printf("模板初始化失败，无法制作饮品\n");
        return;
    }
    boil_water();
    template->brew();
    pour_in_cup();
    template->add_condiments();
    printf("饮品制作完成！\n\n");
}

// 具体实现1：咖啡的冲泡和添加配料方法
void coffee_brew() {
    printf("步骤2：用沸水冲泡咖啡粉\n");
}
void coffee_add_condiments() {
    printf("步骤4：添加牛奶和方糖\n");
}

// 具体实现2：茶的冲泡和添加配料方法
void tea_brew() {
    printf("步骤2：用沸水冲泡茶叶\n");
}
void tea_add_condiments() {
    printf("步骤4：添加柠檬片\n");
}

// 创建咖啡模板实例
BeverageTemplate* create_coffee_template() {
    BeverageTemplate* template = (BeverageTemplate*)malloc(sizeof(BeverageTemplate));
    if (template == NULL) return NULL;
    template->brew = coffee_brew;
    template->add_condiments = coffee_add_condiments;
    return template;
}

// 创建茶模板实例
BeverageTemplate* create_tea_template() {
    BeverageTemplate* template = (BeverageTemplate*)malloc(sizeof(BeverageTemplate));
    if (template == NULL) return NULL;
    template->brew = tea_brew;
    template->add_condiments = tea_add_condiments;
    return template;
}

// 释放模板资源
void destroy_template(BeverageTemplate* template) {
    if (template != NULL) {
        free(template);
        template = NULL;
    }
}

// 客户端调用
int main() {
    printf("制作咖啡：\n");
    BeverageTemplate* coffee = create_coffee_template();
    make_beverage(coffee);
    destroy_template(coffee);

    printf("制作茶：\n");
    BeverageTemplate* tea = create_tea_template();
    make_beverage(tea);
    destroy_template(tea);

    return 0;
}

三、模板方法模式的优缺点

模板方法模式的核心价值是“封装不变、扩展可变”，其优缺点均围绕这一核心展开。在实际开发中，需结合业务场景的流程复杂度、扩展需求，权衡使用，避免过度设计或滥用，确保既发挥其核心优势，又规避潜在问题，实现架构设计的合理性。

3.1 核心优点

代码复用性高：将多个子类共有的通用逻辑提取到抽象类中，避免代码冗余，子类仅需实现差异化的可变步骤，减少重复开发工作量，提升开发效率。
流程规范统一：模板方法定义了算法的固定骨架，确保所有子类的执行流程一致，避免因子类实现差异导致流程混乱，提升系统的规范性和可维护性。
扩展性强，符合开闭原则：新增业务场景时，无需修改抽象类的模板方法和通用步骤，仅需新增子类并实现抽象方法即可，实现“对扩展开放，对修改关闭”，降低代码修改风险。
解耦通用逻辑与差异化逻辑：抽象类负责封装通用逻辑，子类负责实现差异化逻辑，职责划分清晰，便于代码的维护和迭代，降低后期修改成本。

3.2 主要缺点

灵活性受限：模板方法固定了算法的整体流程，若需修改流程结构，必须修改抽象类的模板方法，违反开闭原则，难以适配流程频繁变化的场景。
子类依赖抽象类：子类的实现依赖抽象类的模板设计，若抽象类发生修改（如新增通用步骤），可能导致所有子类需要调整，增加维护成本。
抽象类复杂度提升：当算法流程步骤较多、通用逻辑复杂时，抽象类的代码会变得繁琐，难以理解和维护，尤其当通用步骤与可变步骤耦合较深时，会降低代码可读性。
子类数量可能激增：每新增一种差异化场景，就需要新增一个子类，若场景过多，会导致子类数量激增，增加系统的管理成本。

四、模板方法模式的使用场景

模板方法模式的核心适用场景是“存在多个具有相同执行流程、仅部分步骤实现不同的业务场景”。以下结合具体场景及典型实战案例，帮助开发者快速判断是否适用，实现精准落地，避免滥用或错用。

4.1 核心适用场景

流程固定、细节可变的场景：多个业务场景的执行流程完全一致，仅部分步骤的具体实现不同，如各类文件解析（读取文件→解析内容→校验数据→保存结果）、各类任务执行（初始化→执行核心逻辑→日志记录→清理资源）。
需要统一流程规范的场景：要求所有子类遵循统一的执行流程，避免流程混乱，如框架开发中的流程模板、企业级系统中的业务流程规范（如订单处理、支付流程）。
需要提升代码复用的场景：多个子类存在大量重复的通用逻辑，需提取到父类中复用，减少代码冗余，如各类工具类、业务服务的通用流程封装。
需要灵活扩展的场景：后期可能新增多种差异化场景，且新增场景不改变原有流程，仅需扩展具体步骤，如插件开发、多类型数据处理。

4.2 典型实战案例

框架开发中的流程模板：如Spring的生命周期、JUnit的单元测试流程，框架定义固定的执行骨架（初始化→执行核心逻辑→销毁），开发者仅需实现核心逻辑步骤，无需关注整体流程。
文件解析工具：如Excel、CSV、JSON等多种格式的文件解析，整体流程均为“读取文件→解析内容→校验数据→保存结果”，仅解析步骤的实现不同，通过模板方法模式封装通用流程，子类实现差异化解析逻辑。
业务流程规范：如电商系统的订单处理流程（创建订单→库存扣减→支付验证→订单确认→日志记录），通用步骤（日志记录、参数校验）提取到抽象类，子类实现不同类型订单（普通订单、秒杀订单）的差异化步骤。
工具类封装：如各类数据导出工具（导出Excel、PDF、Word），流程均为“查询数据→格式化数据→生成文件→下载文件”，仅生成文件的步骤不同，通过模板方法模式提升代码复用率。
游戏开发中的角色技能释放：不同角色的技能释放流程一致（前置准备→技能释放→效果展示→冷却计时），仅技能释放和效果展示的逻辑不同，通过模板方法模式规范流程，灵活扩展不同角色的技能。

五、总结

模板方法模式的核心是“固定骨架、灵活填充”，它通过抽象类封装算法的不变流程，用抽象方法预留扩展点，让子类实现差异化细节，既保证了流程的一致性和代码复用性，又实现了功能的灵活扩展，是“开闭原则”的典型落地方式。其本质是将“流程控制”与“细节实现”分离，让抽象类负责把控全局流程，子类专注于具体细节，提升代码的可维护性和扩展性。

从多语言实现来看，尽管各语言的语法特性差异显著，但核心逻辑高度统一，且均能适配自身的设计理念，完整实现模板方法模式的核心价值：

面向对象语言（C#、Python、C++）：通过抽象类+继承关系实现，抽象类定义模板方法和通用步骤，子类继承并实现抽象方法，依托面向对象的封装、多态特性，实现逻辑清晰、易于维护的代码结构，适配大多数业务场景；
Go语言：遵循“组合优于继承”，通过接口定义可变步骤契约，结构体嵌入接口实现通用步骤，模板方法定义固定流程，代码极简高效，贴合高并发、高性能的后端开发需求；
纯C语言：通过结构体+函数指针模拟面向对象特性，用函数指针实现可变步骤，用普通函数实现通用步骤，手动管理模板实例，底层可控性强，适配嵌入式、底层开发等资源受限场景，虽代码冗余，但能完整还原“固定骨架、灵活填充”的核心思想。

在工程实践中，使用模板方法模式需把握三个核心原则：一是判断业务场景是否具备“固定流程、细节可变”的特征，流程频繁变化的场景不适合使用；二是控制抽象类的复杂度，避免通用步骤与可变步骤耦合，确保职责单一；三是合理设计扩展点，抽象方法的定义需贴合业务扩展需求，避免过度设计抽象方法导致子类实现成本增加。

总体而言，模板方法模式是实现代码复用、规范流程、提升扩展性的高效工具，尤其在框架开发、业务流程规范、工具类封装等场景中价值显著。合理使用模板方法模式，可让代码结构更清晰、流程更规范、扩展更灵活，是每一位开发者必备的架构设计工具。

代理模式

发表于 2019-11-13 更新于 2026-04-20 分类于学习笔记，设计模式

代理模式（Proxy Pattern）是一种经典的结构型设计模式，其核心思想是为目标对象提供一个代理对象，由代理对象充当客户端与目标对象之间的中介，从而控制对目标对象的访问。代理模式不改变目标对象的核心业务逻辑，而是在调用目标方法的前后嵌入附加逻辑，实现权限控制、延迟加载、日志记录、耗时统计、远程调用等增强功能，是软件设计中解耦代码、扩展功能、提升系统可维护性的重要手段。

一、代理模式的核心结构

代理模式的核心价值在于“隔离与增强”，其结构清晰且角色分工明确，共包含三个核心角色，三者协同工作，确保代理逻辑与核心业务逻辑的解耦，同时保证客户端调用的一致性：

1.1 抽象主题（Subject）

定义目标对象与代理对象的共同接口（或抽象类），是客户端与对象交互的统一契约。该接口封装了目标对象的核心业务方法，确保代理对象能够完全替代目标对象，客户端无需区分是直接调用目标对象还是通过代理对象调用，符合“里氏替换原则”。

1.2 真实主题（Real Subject）

实现抽象主题接口，是核心业务逻辑的实际执行者，也是代理对象所代理的目标。它专注于自身的核心业务实现，不关心任何附加逻辑，保持代码的单一职责，便于单独维护和迭代。

1.3 代理（Proxy）

同样实现抽象主题接口，内部持有真实主题的引用（或指针），是客户端直接交互的对象。代理对象的核心作用的是“中转与增强”：一方面接收客户端的调用请求，另一方面在调用真实主题的核心方法前后，嵌入附加逻辑（如权限校验、日志记录、耗时统计等），最终调用真实主题的方法完成核心业务，实现“不侵入核心代码即可扩展功能”的目标。

核心逻辑链路：客户端 → 代理对象（执行附加逻辑） → 真实主题对象（执行核心业务） → 代理对象（执行后置附加逻辑） → 客户端。整个过程中，客户端无需感知真实主题的存在，代理对象完全透明。

二、多语言实现代理模式

为便于开发者落地实践，本文以“图片加载”为经典案例，实现多语言版本的代理模式：真实主题负责核心的图片加载业务，代理对象在图片加载前后，实现日志记录、加载耗时统计的附加功能，清晰呈现代理模式的“增强”特性。所有实现均保证完整可运行，贴合各语言设计理念，添加规范注释，兼顾实用性与可读性。

2.1 C# 实现（面向对象标准实现）

C# 作为强类型面向对象语言，通过接口定义抽象主题，类实现真实主题与代理，依托对象组合持有真实主题引用，借助GC自动管理内存，代码结构严谨、可读性高，适配企业级业务系统开发，是最常用的实现方式之一。

using System;
using System.Diagnostics;

// 抽象主题：图片加载接口（客户端与对象交互的统一契约）
public interface IImageLoader
{
    /// <summary>
    /// 加载图片核心方法
    /// </summary>
    /// <param name="path">图片路径</param>
    void LoadImage(string path);
}

// 真实主题：本地图片加载器（核心业务逻辑实现）
public class LocalImageLoader : IImageLoader
{
    public void LoadImage(string path)
    {
        Console.WriteLine($"[真实主题] 开始执行本地图片加载，路径：{path}");
        // 模拟图片加载耗时（模拟IO操作延迟）
        System.Threading.Thread.Sleep(100);
        Console.WriteLine($"[真实主题] 本地图片加载完成");
    }
}

// 代理：带日志和耗时统计的图片加载代理（附加逻辑增强）
public class ImageLoaderProxy : IImageLoader
{
    // 持有真实主题引用，通过构造函数注入，实现解耦
    private readonly IImageLoader _realLoader;

    /// <summary>
    /// 初始化代理对象，注入真实主题
    /// </summary>
    /// <param name="realLoader">真实主题实例</param>
    public ImageLoaderProxy(IImageLoader realLoader)
    {
        _realLoader = realLoader ?? throw new ArgumentNullException(nameof(realLoader), "真实主题实例不可为null");
    }

    public void LoadImage(string path)
    {
        // 代理前置附加逻辑：日志记录+计时开始
        Console.WriteLine($"\n[代理] 图片加载请求触发，路径：{path}，触发时间：{DateTime.Now:yyyy-MM-dd HH:mm:ss}");
        Stopwatch stopwatch = Stopwatch.StartNew();

        // 调用真实主题的核心业务方法
        _realLoader.LoadImage(path);

        // 代理后置附加逻辑：停止计时+耗时统计
        stopwatch.Stop();
        Console.WriteLine($"[代理] 图片加载全流程完成，总耗时：{stopwatch.ElapsedMilliseconds}ms");
    }
}

// 客户端调用（仅与代理交互，无需感知真实主题）
class Program
{
    static void Main(string[] args)
    {
        // 初始化真实主题与代理
        IImageLoader realLoader = new LocalImageLoader();
        IImageLoader proxy = new ImageLoaderProxy(realLoader);

        // 客户端仅调用代理方法，实现增强功能与核心业务的统一执行
        proxy.LoadImage("D:/photos/nature.jpg");&#xA;    }&#xA;}&#xA;

2.2 Python 实现（动态语言简洁实现）

Python 遵循“鸭子类型”，无需显式定义接口，通过类的多态特性实现代理模式，语法简洁灵活，无需繁琐的类型声明，依托GC自动管理内存，适配快速开发、脚本开发及轻量级项目场景，完整保留代理模式的核心逻辑与增强特性。

import time

# 真实主题：本地图片加载器（核心业务实现）
class LocalImageLoader:
    def load_image(self, path):
        print(f"[真实主题] 开始执行本地图片加载，路径：{path}")
        # 模拟图片加载耗时（模拟IO操作延迟）
        time.sleep(0.1)
        print(f"[真实主题] 本地图片加载完成")

# 代理：带日志和耗时统计的图片加载代理（附加逻辑增强）
class ImageLoaderProxy:
    def __init__(self, real_loader):
        # 持有真实主题引用，通过构造函数注入
        self.real_loader = real_loader
    
    def load_image(self, path):
        # 代理前置附加逻辑：日志记录+计时开始
        print(f"\n[代理] 图片加载请求触发，路径：{path}，触发时间：{time.ctime()}")
        start_time = time.time()
        
        # 调用真实主题的核心业务方法
        self.real_loader.load_image(path)
        
        # 代理后置附加逻辑：耗时统计
        end_time = time.time()
        elapsed = (end_time - start_time) * 1000
        print(f"[代理] 图片加载全流程完成，总耗时：{elapsed:.0f}ms")

# 客户端调用
if __name__ == "__main__":
    # 初始化真实主题与代理
    real_loader = LocalImageLoader()
    proxy = ImageLoaderProxy(real_loader)
    
    # 客户端仅与代理交互，透明调用核心业务+附加功能
    proxy.load_image("/home/photos/nature.jpg")

2.3 Go 实现（接口至上的极简实现）

Go 语言遵循“接口至上”的设计理念，无类和继承概念，通过接口定义抽象主题，结构体实现真实主题与代理，依托对象组合持有真实主题引用，代码极简、高效，贴合Go语言“简洁、务实、高性能”的特性，适配高并发、高性能的后端开发场景。

package main

import (
    "fmt"
    "time"
)

// 抽象主题：图片加载接口（定义统一交互契约）
type ImageLoader interface {
    LoadImage(path string)
}

// 真实主题：本地图片加载器（核心业务逻辑实现）
type LocalImageLoader struct{}

// LoadImage 实现抽象接口，执行图片加载核心逻辑
func (l *LocalImageLoader) LoadImage(path string) {
    fmt.Printf("[真实主题] 开始执行本地图片加载，路径：%s\n", path)
    // 模拟图片加载耗时（模拟IO操作延迟）
    time.Sleep(100 * time.Millisecond)
    fmt.Printf("[真实主题] 本地图片加载完成\n")
}

// 代理：带日志和耗时统计的图片加载代理（附加逻辑增强）
type ImageLoaderProxy struct {
    realLoader ImageLoader // 持有真实主题引用
}

// NewImageLoaderProxy 工厂函数，创建代理实例并注入真实主题
func NewImageLoaderProxy(realLoader ImageLoader) *ImageLoaderProxy {
    return &ImageLoaderProxy{realLoader: realLoader}
}

// LoadImage 实现抽象接口，执行代理逻辑+核心业务逻辑
func (p *ImageLoaderProxy) LoadImage(path string) {
    // 代理前置附加逻辑：日志记录+计时开始
    fmt.Printf("\n[代理] 图片加载请求触发，路径：%s，触发时间：%s\n", path, time.Now().Format("2006-01-02 15:04:05"))
    start := time.Now()
    
    // 调用真实主题的核心业务方法
    p.realLoader.LoadImage(path)
    
    // 代理后置附加逻辑：耗时统计
    elapsed := time.Since(start)
    fmt.Printf("[代理] 图片加载全流程完成，总耗时：%dms\n", elapsed.Milliseconds())
}

// 客户端调用
func main() {
    // 初始化真实主题与代理
    var realLoader ImageLoader = &LocalImageLoader{}
    proxy := NewImageLoaderProxy(realLoader)
    
    // 客户端仅调用代理方法，透明实现增强功能
    proxy.LoadImage("/usr/photos/nature.jpg")
}

2.4 C++ 实现（面向对象经典实现）

C++ 作为经典面向对象语言，通过抽象类（纯虚函数）定义抽象主题，子类实现真实主题与代理，依托对象组合持有真实主题指针，需手动管理内存（通过析构函数释放对象），兼顾灵活性与高性能，适配底层开发、高频调用场景，是底层系统、高性能应用的优选实现方式。

#include <iostream>
#include <string>
#include <chrono>
#include <thread>
using namespace std;

// 抽象主题：图片加载接口（纯虚函数定义统一契约）
class ImageLoader {
public:
    // 虚析构函数：避免多态场景下内存泄漏
    virtual ~ImageLoader() = default;
    // 纯虚函数：图片加载核心方法
    virtual void LoadImage(const string& path) = 0;
};

// 真实主题：本地图片加载器（核心业务逻辑实现）
class LocalImageLoader : public ImageLoader {
public:
    void LoadImage(const string& path) override {
        cout << "[真实主题] 开始执行本地图片加载，路径：" << path << endl;
        // 模拟图片加载耗时（模拟IO操作延迟）
        this_thread::sleep_for(chrono::milliseconds(100));
        cout << "[真实主题] 本地图片加载完成" << endl;
    }
};

// 代理：带日志和耗时统计的图片加载代理（附加逻辑增强）
class ImageLoaderProxy : public ImageLoader {
private:
    ImageLoader* realLoader; // 持有真实主题指针
public:
    // 构造函数：注入真实主题实例
    ImageLoaderProxy(ImageLoader* loader) : realLoader(loader) {}
    // 析构函数：释放真实主题和代理对象，避免内存泄漏
    ~ImageLoaderProxy() override {
        delete realLoader;
        realLoader = nullptr;
    }

    void LoadImage(const string& path) override {
        // 代理前置附加逻辑：日志记录+计时开始
        auto now = chrono::system_clock::now();
        time_t now_c = chrono::system_clock::to_time_t(now);
        cout << "\n[代理] 图片加载请求触发，路径：" << path << "，触发时间：" << ctime(&now_c);
        auto start = chrono::high_resolution_clock::now();

        // 调用真实主题的核心业务方法
        realLoader->LoadImage(path);

        // 代理后置附加逻辑：耗时统计
        auto end = chrono::high_resolution_clock::now();
        auto elapsed = chrono::duration_cast<chrono::milliseconds>(end - start).count();
        cout << "[代理] 图片加载全流程完成，总耗时：" << elapsed << "ms" << endl;
    }
};

// 客户端调用
int main() {
    // 初始化真实主题与代理
    ImageLoader* realLoader = new LocalImageLoader();
    ImageLoader* proxy = new ImageLoaderProxy(realLoader);

    // 客户端仅调用代理方法，透明执行增强功能与核心业务
    proxy->LoadImage("/mnt/photos/nature.jpg");

    // 释放代理对象（内部自动释放真实主题）
    delete proxy;
    proxy = nullptr;
    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C语言无面向对象特性，无类和多态，通过“结构体封装数据+函数指针封装行为”，手动模拟代理模式的核心逻辑，需手动管理内存，代码虽略显冗余，但底层可控性强，适配嵌入式、底层开发等资源受限场景，完美还原“代理中转、功能增强”的核心思想。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
// Windows下使用Sleep，Linux下替换为unistd.h并使用usleep(100000)
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#define Sleep(x) usleep(x*1000)
#endif

// 抽象主题：图片加载函数指针（模拟接口方法）
typedef void (*LoadImageFunc)(const char* path);

// 真实主题：本地图片加载器结构体（封装数据与核心方法）
typedef struct {
    LoadImageFunc load_image; // 绑定核心业务方法
} LocalImageLoader;

// 真实主题的核心方法实现：图片加载逻辑
void LocalImageLoader_LoadImage(const char* path) {
    printf("[真实主题] 开始执行本地图片加载，路径：%s\n", path);
    // 模拟图片加载耗时（模拟IO操作延迟）
    Sleep(100);
    printf("[真实主题] 本地图片加载完成\n");
}

// 代理：图片加载代理结构体（封装真实主题引用与代理方法）
typedef struct {
    LocalImageLoader* real_loader; // 持有真实主题引用
    LoadImageFunc load_image;      // 代理方法（增强逻辑+核心逻辑）
} ImageLoaderProxy;

// 代理方法实现：附加逻辑+调用真实主题方法
void ImageLoaderProxy_LoadImage(const char* path) {
    // 代理前置附加逻辑：日志记录+计时开始
    time_t now = time(NULL);
    printf("\n[代理] 图片加载请求触发，路径：%s，触发时间：%s", path, ctime(&now));
    clock_t start = clock();

    // 调用真实主题的核心业务方法
    LocalImageLoader_LoadImage(path);

    // 代理后置附加逻辑：耗时统计
    clock_t end = clock();
    double elapsed = (double)(end - start) * 1000 / CLOCKS_PER_SEC;
    printf("[代理] 图片加载全流程完成，总耗时：%.0fms\n", elapsed);
}

// 创建真实主题实例：初始化方法指针
LocalImageLoader* LocalImageLoader_Create() {
    LocalImageLoader* loader = (LocalImageLoader*)malloc(sizeof(LocalImageLoader));
    if (loader == NULL) {
        printf("真实主题实例创建失败\n");
        return NULL;
    }
    loader->load_image = LocalImageLoader_LoadImage;
    return loader;
}

// 创建代理实例：注入真实主题，绑定代理方法
ImageLoaderProxy* ImageLoaderProxy_Create(LocalImageLoader* real_loader) {
    if (real_loader == NULL) {
        printf("真实主题实例不可为NULL，代理创建失败\n");
        return NULL;
    }
    ImageLoaderProxy* proxy = (ImageLoaderProxy*)malloc(sizeof(ImageLoaderProxy));
    if (proxy == NULL) {
        printf("代理实例创建失败\n");
        return NULL;
    }
    proxy->real_loader = real_loader;
    proxy->load_image = ImageLoaderProxy_LoadImage;
    return proxy;
}

// 释放真实主题资源
void LocalImageLoader_Destroy(LocalImageLoader* loader) {
    if (loader != NULL) {
        free(loader);
        loader = NULL;
    }
}

// 释放代理资源（递归释放真实主题）
void ImageLoaderProxy_Destroy(ImageLoaderProxy* proxy) {
    if (proxy != NULL) {
        LocalImageLoader_Destroy(proxy->real_loader);
        free(proxy);
        proxy = NULL;
    }
}

// 客户端调用
int main() {
    // 初始化真实主题与代理
    LocalImageLoader* real_loader = LocalImageLoader_Create();
    ImageLoaderProxy* proxy = ImageLoaderProxy_Create(real_loader);

    // 客户端仅调用代理方法，实现增强功能与核心业务的统一执行
    if (proxy != NULL) {
        proxy->load_image("C:\\photos\\nature.jpg");
    }

    // 释放资源，避免内存泄漏
    ImageLoaderProxy_Destroy(proxy);
    return 0;
}

三、代理模式的优缺点

代理模式的核心价值是“解耦与增强”，其优缺点均围绕这一核心展开。在实际开发中，需结合业务场景的复杂度、功能扩展需求，权衡使用，避免过度设计或滥用，确保既发挥其核心优势，又规避潜在问题，实现架构设计的合理性。

3.1 核心优点

解耦性强，符合开闭原则：代理对象隔离了客户端与真实主题，客户端无需直接依赖真实主题，修改真实主题的实现（如优化核心业务逻辑）无需改动客户端代码；同时，新增附加功能仅需修改代理类，无需侵入真实主题的核心代码，扩展性极强。
功能扩展灵活，无侵入性：可在不修改核心业务代码的前提下，通过代理对象嵌入日志记录、权限校验、耗时统计、缓存、异常处理等附加功能，实现“核心业务与附加功能的分离”，提升代码的可维护性。
精细化控制对象访问：可实现延迟加载（如大对象仅在需要时初始化，减少内存占用）、权限过滤（如仅允许特定角色调用目标方法）、访问频率限制等精细化控制，适配复杂场景的需求。
隐藏真实主题细节：代理对象可屏蔽真实主题的实现细节（如远程调用的网络通信、复杂对象的初始化逻辑），让客户端专注于自身业务，降低客户端的使用成本。

3.2 主要缺点

增加系统复杂度：引入代理类后，系统的类/结构体数量增加，简单场景下会导致代码冗余；同时，代理逻辑的维护也会增加开发成本，尤其当代理类过多时，会提升系统的理解难度。
存在轻微性能损耗：代理对象在客户端与真实主题之间增加了一层调用链路，高频调用场景下（如每秒百万次调用），会产生轻微的性能开销，虽在大多数业务场景下可忽略不计，但极致性能优化场景需谨慎使用。
调试难度提升：当系统出现问题时，需排查代理逻辑与真实主题逻辑两部分，尤其当代理逻辑复杂（如多层代理）时，会增加问题定位的难度，降低调试效率。
多层代理易引发链路混乱：若过度使用多层代理（如代理的代理），会导致调用链路过长，不仅增加性能损耗，还会让代码逻辑变得晦涩，难以维护。

四、代理模式的使用场景

代理模式的核心适用场景是“需要控制对象访问、扩展核心业务功能，且不希望侵入核心代码”。以下结合具体场景及典型实战案例，帮助开发者快速判断是否适用，实现精准落地，避免滥用或错用。

4.1 核心适用场景

远程代理场景：为远程服务器上的对象提供本地代理，屏蔽网络通信、序列化/反序列化等细节，让客户端像调用本地对象一样调用远程对象，如RPC框架中的服务代理、分布式系统中的远程接口调用。
虚拟代理场景：延迟加载大对象或耗时对象，仅在真正需要时初始化，减少系统启动时间和内存占用，如图片预览功能（先加载缩略图，点击后再加载原图）、大型文件加载、复杂对象的懒初始化。
保护代理场景：控制对对象的访问权限，校验用户身份、角色或权限后，再允许调用核心业务方法，如权限管理系统、接口访问控制、敏感操作的权限校验。
日志/监控代理场景：在调用目标方法前后记录日志、统计耗时、监控调用频率、捕获异常，用于系统监控、问题排查、性能分析，如接口调用监控系统、接口日志收集。
缓存代理场景：缓存目标方法的返回结果，重复调用时直接返回缓存数据，减少重复计算或数据库查询的开销，提升系统响应速度，如数据库查询缓存、接口返回结果缓存。
装饰代理场景：为核心业务添加额外的装饰性功能，如数据加密/解密、参数校验、结果格式化，无需修改核心业务代码，实现功能的动态扩展。

4.2 典型实战案例

RPC框架代理：如Dubbo、gRPC等RPC框架，客户端通过代理对象调用远程服务，代理对象负责封装网络通信、请求序列化、响应反序列化等细节，客户端无需关注远程调用的底层实现。
Spring AOP：Spring AOP的核心实现就是代理模式，通过动态代理（JDK动态代理、CGLIB代理）为目标方法添加日志、事务、权限校验等增强功能，实现“切面编程”，完全不侵入核心业务代码。
图片懒加载：前端或客户端的图片预览功能，通过代理对象先加载缩略图，当用户点击查看原图时，再由代理对象触发原图加载，减少初始加载的资源消耗，提升页面/客户端启动速度。
权限管理系统：接口调用前，通过代理对象校验用户的身份和权限，只有权限通过的用户才能调用核心业务接口，实现接口的安全访问控制。
缓存框架：如Redis缓存、本地缓存（Caffeine、Guava Cache），通过代理对象拦截数据库查询或接口调用，先查询缓存，缓存命中则直接返回，未命中则调用核心方法并缓存结果。

五、总结

代理模式的核心是“代理中转、功能增强、解耦隔离”，它通过在客户端与真实主题之间引入代理对象，既保证了核心业务逻辑的纯粹性，又实现了附加功能的灵活扩展，是软件设计中“开闭原则”的典型落地方式。代理模式的本质不是“替代真实主题”，而是“增强真实主题”，让核心业务与附加功能分离，提升代码的可维护性、可扩展性和安全性。

从多语言实现来看，尽管各语言的语法特性差异显著，但核心逻辑高度统一，且均能适配自身的设计理念，完整实现代理模式的核心价值：

面向对象语言（C#、Python、C++）：通过接口/抽象类定义统一契约，类实现真实主题与代理，依托对象组合持有真实主题引用，借助面向对象的封装、多态特性，实现逻辑清晰、易于维护的代码结构，适配大多数业务场景；
Go语言：遵循“接口至上”，通过接口+结构体实现代理逻辑，依托对象组合注入真实主题，代码极简高效，贴合高并发、高性能的后端开发需求；
纯C语言：通过结构体+函数指针模拟面向对象特性，手动管理内存和代理逻辑，底层可控性强，适配嵌入式、底层开发等资源受限场景，虽代码冗余，但能完整还原“代理中转、功能增强”的核心思想。

在工程实践中，使用代理模式需把握三个核心原则：一是明确是否需要“增强功能”或“控制访问”，简单场景（无附加功能、无需控制访问）无需强行使用，避免过度设计；二是控制代理逻辑的复杂度，避免代理类成为“万能类”，可通过拆分代理类、引入切面编程等方式，简化代理逻辑；三是权衡性能损耗，高频调用、极致性能优化的场景，需谨慎使用代理模式，或选择轻量级代理实现。

总体而言，代理模式是解耦代码、扩展功能的高效工具，尤其在分布式系统、权限管理、监控日志、缓存优化等场景中价值显著。合理使用代理模式，可让代码结构更清晰、功能扩展更灵活、系统更具可维护性，是每一位开发者必备的架构设计工具。

享元模式

发表于 2019-11-12 更新于 2026-04-20 分类于学习笔记，设计模式

享元模式（Flyweight Pattern）是一种经典的结构型设计模式，其核心要义在于通过共享复用技术，高效支撑大量细粒度对象的重复使用，从而显著减少内存占用、降低对象创建与销毁的性能开销，提升系统整体运行效率。它的核心设计思路的是将对象属性拆分為“内部状态”与“外部状态”：内部状态具备可共享、不随环境变化的特性，是对象复用的核心基础；外部状态则不可共享、随场景动态变化，需由客户端传入并按需处理，通过这种状态分离，实现相似对象的高效复用与资源优化。

一、享元模式的核心结构

享元模式的核心价值在于“复用可共享对象，隔离可变状态”，其结构清晰且角色分工明确，共包含5个核心角色，其中前3个为必选角色，后2个为可选角色，协同实现对象池的管理与对象复用逻辑：

1.1 抽象享元（Flyweight）

定义享元对象的统一接口，是所有具体享元类的基类或抽象规范。接口中需声明接收并处理外部状态的方法，明确享元对象的核心行为，同时隐藏内部状态的实现细节，为客户端提供一致的调用入口。

1.2 具体享元（Concrete Flyweight）

实现抽象享元接口，负责存储可共享的内部状态，且内部状态一旦初始化后便不可修改，确保复用过程中不会因状态变更引发异常。同时，通过接口方法接收客户端传入的外部状态，完成具体的业务逻辑处理，实现“共享不变部分，适配可变部分”的设计目标。

1.3 享元工厂（Flyweight Factory）

享元模式的核心管理角色，负责创建、维护享元对象池（通常采用哈希表、字典等键值对结构存储），核心职责是保证“相同内部状态的对象仅被创建一次”。当客户端请求享元对象时，工厂先检查对象池中是否存在匹配内部状态的对象，存在则直接返回复用，不存在则创建新对象并加入池中，同时提供查询对象池大小等辅助方法，便于监控资源复用情况。

1.4 非共享具体享元（Unshared Concrete Flyweight）

可选角色，代表无需共享的享元对象。这类对象通常因外部状态过于独特、复用率极低，或内部状态不可共享（如包含动态可变的私有属性），无需纳入对象池管理，直接由客户端创建和使用，不参与复用逻辑，避免因强制共享增加系统复杂度。

1.5 客户端（Client）

负责维护所有享元对象的外部状态，明确自身所需的内部状态类型，通过享元工厂获取享元对象，并将外部状态传入享元对象的方法中，触发业务逻辑执行。客户端无需关注享元对象的创建细节和复用逻辑，仅需通过工厂接口获取对象，降低开发复杂度。

核心原则：内部状态与外部状态的拆分是享元模式的灵魂。内部状态必须满足“可共享、不可变”，外部状态必须满足“不可共享、可动态传入”，二者分离才能实现对象复用与场景适配的平衡，避免因状态混淆导致复用失效。

二、多语言实现享元模式

为便于开发者落地实践，本文以“文字排版系统”为经典案例，实现多语言版本的享元模式：字符本身（如’A’、’B’）作为享元对象，字符内容为内部状态（可共享、固定不变），字体、颜色、大小为外部状态（不可共享、随排版需求动态变化）。所有实现均保证完整可运行，贴合各语言设计理念，添加规范注释，兼顾实用性与可读性。

2.1 C# 实现（面向对象标准实现）

C# 作为强类型面向对象语言，通过接口定义抽象享元，类实现具体享元，依托字典构建享元池，借助GC自动管理内存，代码结构严谨、可读性高，适配企业级业务系统开发，无需手动处理内存释放，是最常用的实现方式之一。

using System;
using System.Collections.Generic;

// 抽象享元：字符接口，定义接收外部状态的方法
public interface ICharacter
{
    /// <summary>
    /// 显示字符（接收外部状态：字体、颜色、大小）
    /// </summary>
    /// <param name="font">字体（外部状态）</param>
    /// <param name="color">颜色（外部状态）</param>
    /// <param name="size">大小（外部状态）</param>
    void Display(string font, string color, int size);
}

// 具体享元：字符类，存储内部状态，实现显示逻辑
public class Character : ICharacter
{
    // 内部状态：字符内容（可共享、不可变）
    private readonly char _char;

    /// <summary>
    /// 初始化字符对象，设置内部状态
    /// </summary>
    /// <param name="c">字符内容（内部状态）</param>
    public Character(char c)
    {
        _char = c;
    }

    /// <summary>
    /// 实现显示方法，结合外部状态完成字符渲染
    /// </summary>
    public void Display(string font, string color, int size)
    {
        Console.WriteLine($"字符：{_char}，字体：{font}，颜色：{color}，大小：{size}");
    }
}

// 享元工厂：字符工厂，管理享元池，实现对象复用
public class CharacterFactory
{
    // 享元池：存储字符对象，key为字符内容（内部状态），value为享元对象
    private readonly Dictionary<char, ICharacter> _characterPool = new Dictionary<char, ICharacter>();

    /// <summary>
    /// 获取享元对象，存在则复用，不存在则创建
    /// </summary>
    /// <param name="c">字符内容（内部状态）</param>
    /// <returns>享元对象</returns>
    public ICharacter GetCharacter(char c)
    {
        // 检查池中是否存在该字符，不存在则创建并加入池
        if (!_characterPool.ContainsKey(c))
        {
            _characterPool[c] = new Character(c);
            Console.WriteLine($"创建新字符：{c}");
        }
        return _characterPool[c];
    }

    /// <summary>
    /// 获取享元池大小，用于监控复用情况
    /// </summary>
    /// <returns>享元池中的对象数量</returns>
    public int GetPoolSize()
    {
        return _characterPool.Count;
    }
}

// 客户端：使用享元工厂获取对象，传入外部状态执行逻辑
class Program
{
    static void Main(string[] args)
    {
        CharacterFactory factory = new CharacterFactory();

        // 复用字符'A'，仅改变外部状态（字体、颜色、大小）
        ICharacter a1 = factory.GetCharacter('A');
        a1.Display("宋体", "黑色", 12);

        ICharacter a2 = factory.GetCharacter('A');
        a2.Display("微软雅黑", "红色", 14);

        // 创建并复用字符'B'
        ICharacter b1 = factory.GetCharacter('B');
        b1.Display("宋体", "蓝色", 12);

        // 输出享元池大小（预期为2：仅创建A、B两个对象）
        Console.WriteLine($"享元池大小：{factory.GetPoolSize()}");
    }
}

2.2 Python 实现（动态语言简洁实现）

Python 遵循“鸭子类型”，无需显式定义接口，通过抽象基类（ABC）模拟抽象享元，类实现具体享元，依托字典构建享元池，语法简洁灵活，无需繁琐的类型声明，依托GC自动管理内存，适配快速开发、脚本开发及轻量级项目场景，完整保留享元模式的核心逻辑。

from abc import ABC, abstractmethod

# 抽象享元：字符抽象基类，定义显示接口
class ICharacter(ABC):
    @abstractmethod
    def display(self, font, color, size):
        """显示字符，接收外部状态"""
        pass

# 具体享元：字符类，存储内部状态（字符内容）
class Character(ICharacter):
    def __init__(self, char):
        # 内部状态：字符内容，初始化后不可修改
        self._char = char
    
    def display(self, font, color, size):
        # 结合外部状态，完成字符渲染
        print(f"字符：{self._char}，字体：{font}，颜色：{color}，大小：{size}")

# 享元工厂：字符工厂，管理享元池，实现对象复用
class CharacterFactory:
    def __init__(self):
        # 享元池：key为字符内容，value为字符对象
        self._character_pool = {}
    
    def get_character(self, char):
        """获取享元对象，复用已有对象，无则创建"""
        if char not in self._character_pool:
            self._character_pool[char] = Character(char)
            print(f"创建新字符：{char}")
        return self._character_pool[char]
    
    def get_pool_size(self):
        """获取享元池大小"""
        return len(self._character_pool)

# 客户端调用
if __name__ == "__main__":
    factory = CharacterFactory()
    
    # 复用字符'A'，传入不同外部状态
    a1 = factory.get_character('A')
    a1.display("宋体", "黑色", 12)
    
    a2 = factory.get_character('A')
    a2.display("微软雅黑", "红色", 14)
    
    # 复用字符'B'
    b1 = factory.get_character('B')
    b1.display("宋体", "蓝色", 12)
    
    print(f"享元池大小：{factory.get_pool_size()}")  # 输出2

2.3 Go 实现（组合优于继承的极简实现）

Go 语言无类和继承概念，核心遵循“组合优于继承”的设计哲学，通过接口定义抽象享元，结构体实现具体享元，依托map构建享元池，通过工厂函数初始化实例，代码极简、高效，贴合Go语言“简洁、务实、高性能”的设计理念，适配高并发、高性能的后端开发场景。

package main

import (
    "fmt"
)

// 抽象享元：字符接口，定义显示方法
type ICharacter interface {
    Display(font, color string, size int)
}

// 具体享元：字符结构体，存储内部状态
type Character struct {
    char rune // 内部状态：字符内容，不可修改
}

// NewCharacter 创建具体享元对象，初始化内部状态
func NewCharacter(char rune) *Character {
    return &Character{char: char}
}

// Display 实现抽象接口，结合外部状态完成渲染
func (c *Character) Display(font, color string, size int) {
    fmt.Printf("字符：%c，字体：%s，颜色：%s，大小：%d\n", c.char, font, color, size)
}

// 享元工厂：字符工厂，管理享元池
type CharacterFactory struct {
    characterPool map[rune]ICharacter // 享元池，key为字符，value为享元对象
}

// NewCharacterFactory 创建享元工厂，初始化享元池
func NewCharacterFactory() *CharacterFactory {
    return &CharacterFactory{
        characterPool: make(map[rune]ICharacter),
    }
}

// GetCharacter 获取享元对象，复用已有对象，无则创建
func (f *CharacterFactory) GetCharacter(char rune) ICharacter {
    if _, ok := f.characterPool[char]; !ok {
        f.characterPool[char] = NewCharacter(char)
        fmt.Printf("创建新字符：%c\n", char)
    }
    return f.characterPool[char]
}

// GetPoolSize 获取享元池大小
func (f *CharacterFactory) GetPoolSize() int {
    return len(f.characterPool)
}

// 客户端调用
func main() {
    factory := NewCharacterFactory()
    
    // 复用字符'A'，传入不同外部状态
    a1 := factory.GetCharacter('A')
    a1.Display("宋体", "黑色", 12)
    
    a2 := factory.GetCharacter('A')
    a2.Display("微软雅黑", "红色", 14)
    
    // 复用字符'B'
    b1 := factory.GetCharacter('B')
    b1.Display("宋体", "蓝色", 12)
    
    fmt.Printf("享元池大小：%d\n", factory.GetPoolSize()) // 输出2
}

2.4 C++ 实现（面向对象经典实现）

C++ 作为经典面向对象语言，通过抽象类（纯虚函数）定义抽象享元，子类实现具体享元，依托unordered_map构建享元池，需手动管理内存（通过析构函数释放对象），兼顾灵活性与高性能，适配底层开发、高性能场景，是底层系统、高频调用场景的优选实现方式。

#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;

// 抽象享元：字符抽象类，定义纯虚函数（接口）
class ICharacter {
public:
    // 虚析构函数：避免多态场景下内存泄漏
    virtual ~ICharacter() = default;
    // 纯虚函数：显示字符，接收外部状态
    virtual void Display(const string& font, const string& color, int size) = 0;
};

// 具体享元：字符类，实现抽象接口
class Character : public ICharacter {
private:
    char _char; // 内部状态：字符内容，不可修改
public:
    // 构造函数：初始化内部状态
    Character(char c) : _char(c) {}

    // 实现显示方法，结合外部状态完成渲染
    void Display(const string& font, const string& color, int size) override {
        cout << "字符：" << _char << "，字体：" << font << "，颜色：" << color << "，大小：" << size << endl;
    }
};

// 享元工厂：字符工厂，管理享元池
class CharacterFactory {
private:
    // 享元池：key为字符，value为享元对象指针
    unordered_map<char, ICharacter*> _characterPool;
public:
    // 析构函数：释放享元池中的所有对象，避免内存泄漏
    ~CharacterFactory() {
        for (auto& pair : _characterPool) {
            delete pair.second;
        }
        _characterPool.clear();
    }

    // 获取享元对象，复用已有对象，无则创建
    ICharacter* GetCharacter(char c) {
        if (_characterPool.find(c) == _characterPool.end()) {
            _characterPool[c] = new Character(c);
            cout << "创建新字符：" << c << endl;
        }
        return _characterPool[c];
    }

    // 获取享元池大小
    int GetPoolSize() const {
        return _characterPool.size();
    }
};

// 客户端调用
int main() {
    CharacterFactory factory;
    
    // 复用字符'A'，传入不同外部状态
    ICharacter* a1 = factory.GetCharacter('A');
    a1->Display("宋体", "黑色", 12);
    
    ICharacter* a2 = factory.GetCharacter('A');
    a2->Display("微软雅黑", "红色", 14);
    
    // 复用字符'B'
    ICharacter* b1 = factory.GetCharacter('B');
    b1->Display("宋体", "蓝色", 12);
    
    cout << "享元池大小：" << factory.GetPoolSize() << endl; // 输出2
    
    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C语言无面向对象特性，无类和多态，通过“结构体封装数据+函数指针封装行为+数组模拟哈希表”，手动模拟享元模式的核心逻辑，需手动管理内存，代码虽略显冗余，但底层可控性强，适配嵌入式、底层开发等资源受限场景，完美还原“共享复用、状态分离”的核心思想。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_POOL_SIZE 256 // 享元池最大容量（覆盖ASCII字符范围）

// 抽象享元：字符操作函数指针（模拟接口方法）
typedef void (*DisplayFunc)(void*, const char*, const char*, int);

// 具体享元：字符结构体（模拟对象）
typedef struct {
    char ch; // 内部状态：字符内容，不可修改
    DisplayFunc display; // 显示方法指针（模拟类的成员方法）
} Character;

// 享元工厂：字符池（数组模拟哈希表，ASCII码作为索引）
typedef struct {
    Character* pool[MAX_POOL_SIZE]; // 存储享元对象指针
    int size; // 池内有效对象数量
} CharacterFactory;

// 具体享元的Display方法实现：结合外部状态渲染字符
void Character_Display(void* character, const char* font, const char* color, int size) {
    Character* c = (Character*)character;
    printf("字符：%c，字体：%s，颜色：%s，大小：%d\n", c->ch, font, color, size);
}

// 创建具体享元对象：初始化内部状态和方法指针
Character* Character_Create(char ch) {
    Character* c = (Character*)malloc(sizeof(Character));
    if (c == NULL) return NULL; // 内存分配失败处理，提升健壮性
    c->ch = ch;
    c->display = Character_Display;
    printf("创建新字符：%c\n", ch);
    return c;
}

// 初始化享元工厂：清空池，设置初始大小为0
void CharacterFactory_Init(CharacterFactory* factory) {
    memset(factory->pool, 0, sizeof(factory->pool));
    factory->size = 0;
}

// 获取享元对象：复用已有对象，无则创建
Character* CharacterFactory_GetCharacter(CharacterFactory* factory, char ch) {
    int index = (unsigned char)ch; // ASCII码作为数组索引，避免负数
    if (factory->pool[index] == NULL) {
        factory->pool[index] = Character_Create(ch);
        factory->size++;
    }
    return factory->pool[index];
}

// 获取享元池大小
int CharacterFactory_GetPoolSize(CharacterFactory* factory) {
    return factory->size;
}

// 释放享元工厂内存：递归释放池内所有对象
void CharacterFactory_Destroy(CharacterFactory* factory) {
    for (int i = 0; i < MAX_POOL_SIZE; i++) {
        if (factory->pool[i] != NULL) {
            free(factory->pool[i]);
            factory->pool[i] = NULL;
        }
    }
    factory->size = 0;
}

// 客户端调用
int main() {
    CharacterFactory factory;
    CharacterFactory_Init(&factory);
    
    // 复用字符'A'，传入不同外部状态
    Character* a1 = CharacterFactory_GetCharacter(&factory, 'A');
    a1->display(a1, "宋体", "黑色", 12);
    
    Character* a2 = CharacterFactory_GetCharacter(&factory, 'A');
    a2->display(a2, "微软雅黑", "红色", 14);
    
    // 复用字符'B'
    Character* b1 = CharacterFactory_GetCharacter(&factory, 'B');
    b1->display(b1, "宋体", "蓝色", 12);
    
    printf("享元池大小：%d\n", CharacterFactory_GetPoolSize(&factory)); // 输出2
    
    // 释放内存，避免内存泄漏
    CharacterFactory_Destroy(&factory);
    return 0;
}

三、享元模式的优缺点

享元模式的核心价值是“通过复用优化内存与性能”，其优缺点均围绕这一核心展开。在实际开发中，需结合业务场景的复杂度、对象复用率、内存资源情况，权衡使用，避免过度设计或滥用，确保既发挥其核心优势，又规避潜在问题。

3.1 核心优点

大幅减少内存占用：通过复用大量相同/相似对象，减少系统中对象的总数量，尤其在创建海量细粒度对象的场景（如文字渲染、游戏粒子）中，可显著降低内存消耗，提升系统内存利用率。
提升系统性能：减少对象创建与销毁的频繁调用，降低内存分配、GC（垃圾回收）的压力（面向对象语言），同时减少重复初始化的开销，提升系统响应速度，尤其适配高频创建对象的场景。
解耦状态管理：将内部状态（共享、不变）与外部状态（独立、可变）分离，使享元对象更稳定，便于单独维护和扩展；外部状态由客户端灵活传入，提升场景适配能力。
优化资源利用率：对于创建成本高、复用率高的对象（如数据库连接、线程），通过享元池管理，避免资源浪费，实现资源的高效复用，降低系统运行成本。

3.2 主要缺点

增加系统复杂度：需要拆分内部/外部状态，设计享元工厂管理对象池，还要保证内部状态的不可变性，增加了代码的理解、开发和维护成本，尤其在状态拆分不清晰的场景中，易引发逻辑混乱。
可能降低读取性能：外部状态需由客户端传入享元对象，若外部状态复杂（如多个参数、复杂数据结构），会增加参数传递和处理的开销，可能抵消复用带来的性能收益。
线程安全风险：享元对象是共享的，若内部状态设计存在缺陷（如被意外修改），会导致所有复用该对象的场景出现错误；多线程环境下，享元工厂的对象池操作需额外处理线程安全（如加锁），进一步增加复杂度。
状态拆分难度高：并非所有对象都能清晰拆分为内部状态和外部状态，若拆分不合理，可能导致复用失效，或增加状态管理的复杂度，反而降低开发效率。

四、享元模式的使用场景

享元模式的核心适用场景是“存在大量细粒度相似对象，且对象的复用率高、内部状态可共享”。以下结合具体场景及典型实战案例，帮助开发者快速判断是否适用，实现精准落地，避免滥用或错用。

4.1 核心适用场景

海量细粒度对象场景：系统中需要频繁创建大量相似的细粒度对象，且这些对象的内存占用总和较高，如文字编辑器的字符、游戏中的粒子系统、地图瓦片、GUI组件等。
对象复用率高、创建成本高：对象的创建过程消耗大量内存或CPU资源，且对象的内部状态稳定、可共享，复用率高，如数据库连接、线程、网络连接等（池化技术本质是享元模式的变种）。
内存资源紧张场景：系统内存资源有限，需通过优化对象存储方式，减少内存占用，提升系统运行稳定性，如嵌入式系统、移动端应用、高频并发系统等。
对象状态可拆分场景：对象的属性可清晰拆分为内部状态（共享、不变）和外部状态（可变、独立），且内部状态的占比高，具备复用价值。

4.2 典型实战案例

文本编辑器/排版系统：如本文案例，文档中的字符是海量细粒度对象，字符内容为内部状态（可共享），字体、颜色、大小、位置为外部状态（可变），通过享元模式复用字符对象，大幅减少内存占用。
游戏开发：游戏中的粒子系统（如火焰、雨滴、雪花）、地图瓦片、角色模型等，均为大量相似对象，通过享元模式复用基础对象，仅修改位置、颜色等外部状态，提升游戏运行流畅度。
池化技术实现：数据库连接池、线程池、HTTP连接池等，核心是通过享元模式复用连接/线程对象，减少对象创建销毁的开销，提升资源利用率和系统并发能力。
缓存系统：Redis缓存、本地内存缓存（如Caffeine），将频繁访问的数据作为享元对象存入缓存池，复用数据对象，减少重复查询或计算的开销，提升系统响应速度。
GUI组件库：按钮、输入框、下拉框等基础GUI组件，相同样式的组件可作为享元对象复用，仅修改位置、文本等外部状态，减少组件创建的开销，提升界面渲染效率。
字符串常量池：JDK中的String常量池、C#中的字符串驻留池，核心是享元模式的应用，相同字符串仅存储一份，复用对象，减少内存占用。

五、总结

享元模式的核心是“共享复用可不变状态，隔离适配可变状态”，它通过拆分对象状态、构建享元池、依托工厂管理对象，实现海量细粒度相似对象的高效复用，最终达到减少内存占用、提升系统性能的目标。它不是“创建更少的对象”，而是“复用更多的对象”，是内存优化和性能提升的重要设计工具。

从多语言实现来看，尽管各语言的语法特性差异显著，但核心逻辑高度统一，且均能适配自身的设计理念，完整实现享元模式的核心价值：

面向对象语言（C#、Python、C++）：通过接口/抽象类定义享元规范，类实现具体享元，依托字典/哈希表构建对象池，借助面向对象的封装、多态特性，实现逻辑清晰、易于维护的代码结构，适配大多数业务场景；
Go语言：遵循“组合优于继承”，通过接口+结构体实现享元逻辑，依托map构建对象池，代码极简高效，贴合高并发、高性能的后端开发需求；
纯C语言：通过结构体+函数指针+数组模拟面向对象特性，手动管理内存和对象池，底层可控性强，适配嵌入式、底层开发等资源受限场景，虽代码冗余，但能完整还原享元模式的核心思想。

在工程实践中，使用享元模式需把握三个核心原则：一是明确对象的“可共享状态”是否占主导，且对象数量足够大，复用带来的收益大于设计和维护成本；二是严格拆分内部状态与外部状态，确保内部状态不可变，避免因状态修改引发复用风险；三是平衡复杂度与性能，避免过度设计——对于对象数量少、复用率低的场景，无需强行使用享元模式，否则会增加代码复杂度，得不偿失。

总体而言，享元模式是应对海量细粒度对象、优化内存与性能的高效解决方案，尤其在游戏开发、高频并发、嵌入式系统等场景中价值显著。合理使用享元模式，结合池化技术、缓存技术，可显著提升系统的资源利用率和稳定性，是每一位开发者必备的架构设计工具。

外观模式

发表于 2019-11-11 更新于 2026-04-20 分类于学习笔记，设计模式

在软件开发中，复杂系统往往由多个相互依赖、各司其职的子模块协同构成。若客户端直接与这些子模块交互，不仅需要深入了解各子模块的实现细节与调用逻辑，还会导致代码耦合度激增、可读性下降、维护成本居高不下。外观模式（Facade Pattern）作为经典的结构型设计模式，核心解决方案是提供一个统一的高层接口，封装系统的底层复杂性，让客户端无需关注子模块的内部实现，仅通过该接口即可完成复杂业务流程的调用，实现“简化交互、解耦分层”的设计目标。本文将深入解析外观模式的核心结构，通过C#、Python、Go、C++、纯C五种语言的完整可运行实现示例，结合其优缺点、使用场景展开全面分析，助力开发者快速落地应用。

一、外观模式的核心结构

外观模式的设计精髓在于“封装复杂，暴露简单”，其核心结构简洁清晰，仅包含两类核心角色，二者分工明确、协同工作，共同实现系统复杂性的屏蔽与交互简化，是模式发挥价值的核心支撑：

1.1 子系统角色（Subsystem）

子系统是构成复杂系统的底层模块集合，每个子模块独立承载特定的业务功能，具备完整的内部逻辑，且不感知外观类的存在。子模块之间可存在依赖关系，但无需关心自身如何被客户端调用，仅专注于自身职责的高效实现。例如，电商下单系统的子模块可包括库存检查、支付处理、物流创建、订单记录等，各模块协同联动，完成下单全流程的核心逻辑。

1.2 外观角色（Facade）

外观角色是客户端与子系统之间的“中介”，对外提供统一的高层接口，内部封装子模块的调用顺序、依赖关系和交互逻辑。它不替代子系统的功能，也不新增业务逻辑，仅负责协调子模块有序执行，屏蔽子系统的底层复杂性。客户端只需调用外观类的接口，即可完成复杂的业务操作，无需与任何子模块直接交互，实现“一键调用”的极简体验。

核心逻辑：外观类的核心价值是“解耦”与“简化”——解耦客户端与子系统的直接依赖，简化客户端的调用流程，同时保留子系统的独立性，便于子模块的单独维护、迭代与扩展，实现“高内聚、低耦合”的架构设计。

二、多语言实现外观模式

为便于理解和落地，本文以“智能家居控制系统”为经典案例展开多语言实现：子系统包含灯光、空调、窗帘三个独立模块，各自实现开关、调节等基础功能；外观类封装“一键回家”“一键离家”两个高频场景，整合子模块的操作逻辑，让客户端通过简单调用即可完成复杂的场景化控制。以下实现均保证可运行性，添加规范注释，贴合各语言的设计理念和企业级开发规范，兼顾实用性与可读性。

2.1 C# 实现（面向对象标准实现）

C# 作为强类型面向对象语言，通过类封装子系统和外观类，依托构造函数初始化子系统实例，代码结构严谨、可读性高，贴合企业级开发规范，无需额外处理内存管理（依赖GC自动回收），是业务系统开发的优选实现方式。

using System;

// 子系统1：灯光模块（独立实现灯光的开关功能）
public class Light
{
    /// <summary>
    /// 打开灯光
    /// </summary>
    public void TurnOn() => Console.WriteLine("灯光已打开，营造温馨氛围");

    /// <summary>
    /// 关闭灯光
    /// </summary>
    public void TurnOff() => Console.WriteLine("灯光已关闭，节约用电");
}

// 子系统2：空调模块（独立实现温度调节和关闭功能）
public class AirConditioner
{
    /// <summary>
    /// 设置空调温度
    /// </summary>
    /// <param name="temp">目标温度（℃）</param>
    public void SetTemperature(int temp) => Console.WriteLine($"空调温度设置为{temp}℃，体感舒适");

    /// <summary>
    /// 关闭空调
    /// </summary>
    public void TurnOff() => Console.WriteLine("空调已关闭，减少能耗");
}

// 子系统3：窗帘模块（独立实现窗帘的开关功能）
public class Curtain
{
    /// <summary>
    /// 关闭窗帘（遮光、隐私保护）
    /// </summary>
    public void Close() => Console.WriteLine("窗帘已关闭，保障隐私");

    /// <summary>
    /// 打开窗帘（采光、通风）
    /// </summary>
    public void Open() => Console.WriteLine("窗帘已打开，引入自然光线");
}

// 外观类：智能家居统一控制接口（封装子系统交互逻辑）
public class SmartHomeFacade
{
    // 持有子系统实例（通过构造函数初始化，解耦实例创建与调用逻辑）
    private readonly Light _light;
    private readonly AirConditioner _airConditioner;
    private readonly Curtain _curtain;

    /// <summary>
    /// 初始化外观类，创建所有子系统实例
    /// </summary>
    public SmartHomeFacade()
    {
        _light = new Light();
        _airConditioner = new AirConditioner();
        _curtain = new Curtain();
    }

    /// <summary>
    /// 一键回家模式（整合子系统操作，适配回家场景）
    /// </summary>
    public void HomeMode()
    {
        Console.WriteLine("\n===== 执行回家模式 =====");
        _light.TurnOn();       // 打开灯光，营造温馨氛围
        _airConditioner.SetTemperature(26); // 设置舒适温度，适配人体体感
        _curtain.Open();       // 打开窗帘，引入自然采光
    }

    /// <summary>
    /// 一键离家模式（整合子系统操作，适配离家场景）
    /// </summary>
    public void LeaveMode()
    {
        Console.WriteLine("\n===== 执行离家模式 =====");
        _light.TurnOff();      // 关闭灯光，节约用电
        _airConditioner.TurnOff(); // 关闭空调，减少能耗
        _curtain.Close();      // 关闭窗帘，保障家居隐私
    }
}

// 客户端调用（仅与外观类交互，无需关注子系统细节）
class Program
{
    static void Main(string[] args)
    {
        // 初始化外观类，获取统一控制接口
        SmartHomeFacade smartHome = new SmartHomeFacade();

        // 调用回家模式，完成一系列场景化操作
        smartHome.HomeMode();

        // 调用离家模式，完成一系列场景化操作
        smartHome.LeaveMode();
    }
}

2.2 Python 实现（动态语言简洁实现）

Python 遵循“鸭子类型”，无需显式定义接口，通过类封装子系统和外观类，语法简洁灵活，无需繁琐的类型声明，依托GC自动管理内存，适配快速开发、脚本开发及轻量级项目场景，同时完整保留外观模式“封装复杂、简化调用”的核心逻辑。

class Light:
    """子系统1：灯光模块，实现灯光开关功能"""
    def turn_on(self):
        """打开灯光"""
        print("灯光已打开，营造温馨氛围")
    
    def turn_off(self):
        """关闭灯光"""
        print("灯光已关闭，节约用电")

class AirConditioner:
    """子系统2：空调模块，实现温度调节和关闭功能"""
    def set_temperature(self, temp):
        """设置空调温度"""
        print(f"空调温度设置为{temp}℃，体感舒适")
    
    def turn_off(self):
        """关闭空调"""
        print("空调已关闭，减少能耗")

class Curtain:
    """子系统3：窗帘模块，实现窗帘开关功能"""
    def close(self):
        """关闭窗帘，保障隐私"""
        print("窗帘已关闭，保障隐私")
    
    def open(self):
        """打开窗帘，引入采光"""
        print("窗帘已打开，引入自然光线")

class SmartHomeFacade:
    """外观类：智能家居统一控制接口，封装子系统交互逻辑"""
    def __init__(self):
        # 初始化所有子系统实例，隐藏子模块创建细节
        self.light = Light()
        self.air_conditioner = AirConditioner()
        self.curtain = Curtain()
    
    def home_mode(self):
        """一键回家模式：整合子系统操作，适配回家场景"""
        print("\n===== 执行回家模式 =====")
        self.light.turn_on()
        self.air_conditioner.set_temperature(26)
        self.curtain.open()
    
    def leave_mode(self):
        """一键离家模式：整合子系统操作，适配离家场景"""
        print("\n===== 执行离家模式 =====")
        self.light.turn_off()
        self.air_conditioner.turn_off()
        self.curtain.close()

# 客户端调用：仅与外观类交互，简化调用流程
if __name__ == "__main__":
    # 初始化外观类，获取统一控制入口
    smart_home = SmartHomeFacade()
    # 调用场景化接口，完成复杂操作
    smart_home.home_mode()
    smart_home.leave_mode()

2.3 Go 实现（组合优于继承的极简实现）

Go 语言无类和继承概念，核心遵循“组合优于继承”的设计哲学，通过结构体封装子系统和外观类，依托方法绑定实现功能，通过工厂函数初始化实例，代码极简、高效，贴合Go语言“简洁、务实、高效”的设计理念，适配高并发、高性能的后端开发场景。

package main

import "fmt"

// 子系统1：灯光模块
type Light struct{}

// TurnOn 打开灯光
func (l *Light) TurnOn() {
   t.Println("灯光已打开，营造温馨氛围")
}

// TurnOff 关闭灯光
func (l *Light) TurnOff() {
 fmt.Println("灯光已关闭，节约用电")
}

// 子系统2：空调模块
type AirConditioner struct{}

// SetTemperature 设置空调温度
func (ac *AirConditioner) SetTemperature(temp int) {
 fmt.Printf("空调温度设置为%d℃，体感舒适\n", temp)
}

// TurnOff 关闭空调
func (ac *AirConditioner) TurnOff() {
  mt.Println("空调已关闭，减少能耗")
}

// 子系统3：窗帘模块
type Curtain struct{}

// Close 关闭窗帘
func (c *Curtain) Close() {
   t.Println("窗帘已关闭，保障隐私")
}

// Open 打开窗帘
func (c *Curtain) Open() {
 fmt.Println("窗帘已打开，引入自然光线")
}

// 外观类：智能家居统一控制接口
type SmartHomeFacade struct {
 light           *Light
     onditioner  *AirConditioner
 curtain         *Curtain
}

// NewSmartHomeFacade 工厂函数：创建外观类实例，初始化子系统
func NewSmartHomeFacade() *SmartHomeFacade {
  eturn &SmartHomeFacade{
  light:           &Light{},
  airConditioner:  &AirConditioner{},
    rtain:         &Curtain{},
  
}

// HomeMode 一键回家模式，整合子系统操作
func (f *SmartHomeFacade) HomeMode() {
 fmt.Println("\n===== 执行回家模式 =====")
  .light.TurnOn()
   airConditioner.SetTemperature(26)
 f.curtain.Open()
}

// LeaveMode 一键离家模式，整合子系统操作
func (f *SmartHomeFacade) LeaveMode() {
 fmt.Println("\n===== 执行离家模式 =====")
 f.light.TurnOff()
 f.airConditioner.TurnOff()
 f.curtain.Close()
}

// 客户端调用：通过外观类统一交互，屏蔽子系统细节
func main() {
 // 初始化外观类，获取统一控制入口
  martHome := NewSmartHomeFacade()
 // 调用场景化接口，完成复杂业务操作
 smartHome.HomeMode()
 smartHome.LeaveMode()
}
                           s                                               f.      f             }     cu                                         r          airC                   fm      f                   fm

2.4 C++ 实现（面向对象经典实现）

C++ 作为经典面向对象语言，通过类封装子系统和外观类，依托构造函数初始化子系统实例，析构函数释放内存，兼顾灵活性与性能，适配底层开发、高性能场景，需手动管理内存以避免泄漏，是底层系统、高性能应用的优选实现方式。

#include <iostream>
using namespace std;

// 子系统1：灯光模块
class Light {
public:
    // 打开灯光
    void turnOn() {
        cout << "灯光已打开，营造温馨氛围" << endl;
    }

    // 关闭灯光
    void turnOff() {
        cout << "灯光已关闭，节约用电" << endl;
    }
};

// 子系统2：空调模块
class AirConditioner {
public:
    // 设置空调温度
    void setTemperature(int temp) {
        cout << "空调温度设置为" << temp << "℃，体感舒适" << endl;
    }

    // 关闭空调
    void turnOff() {
        cout << "空调已关闭，减少能耗" << endl;
    }
};

// 子系统3：窗帘模块
class Curtain {
public:
    // 关闭窗帘
    void close() {
        cout << "窗帘已关闭，保障隐私" << endl;
    }

    // 打开窗帘
    void open() {
        cout << "窗帘已打开，引入自然光线" << endl;
    }
};

// 外观类：智能家居统一控制接口
class SmartHomeFacade {
private:
    // 持有子系统指针，通过构造函数初始化
    Light* light;
    AirConditioner* airConditioner;
    Curtain* curtain;

public:
    // 构造函数：初始化所有子系统实例
    SmartHomeFacade() {
        light = new Light();
        airConditioner = new AirConditioner();
        curtain = new Curtain();
    }

    // 析构函数：释放子系统内存，避免内存泄漏
    ~SmartHomeFacade() {
        delete light;
        delete airConditioner;
        delete curtain;
    }

    // 一键回家模式，整合子系统操作
    void homeMode() {
        cout << "\n===== 执行回家模式 =====" << endl;
        light->turnOn();
        airConditioner->setTemperature(26);
        curtain->open();
    }

    // 一键离家模式，整合子系统操作
    void leaveMode() {
        cout << "\n===== 执行离家模式 =====" << endl;
        light->turnOff();
        airConditioner->turnOff();
        curtain->close();
    }
};

// 客户端调用
int main() {
    // 初始化外观类，获取统一控制入口
    SmartHomeFacade* smartHome = new SmartHomeFacade();
    // 调用场景化接口，完成复杂业务操作
    smartHome->homeMode();
    smartHome->leaveMode();
    // 释放外观类内存（触发析构函数，递归释放子系统内存）
    delete smartHome;
    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C语言无面向对象特性，无类和多态，通过“结构体封装数据+函数指针封装行为”，模拟子系统和外观类的核心逻辑，手动管理内存，代码虽略显冗余，但底层可控性强，适配嵌入式、底层开发等资源受限场景，完美还原外观模式“统一接口、屏蔽复杂”的核心思想。

#include <stdio.h>
#include <stdlib.h>

// 子系统1：灯光模块（结构体+函数指针模拟类的行为）
typedef struct {
    void (*turnOn)(void);  // 打开灯光函数指针
    void (*turnOff)(void); // 关闭灯光函数指针
} Light;

// 灯光打开实现
void Light_TurnOn(void) {
    printf("灯光已打开，营造温馨氛围\n");
}

// 灯光关闭实现
void Light_TurnOff(void) {
    printf("灯光已关闭，节约用电\n");
}

// 工厂函数：创建灯光实例，初始化函数指针
Light* CreateLight() {
    Light* light = (Light*)malloc(sizeof(Light));
    if (light == NULL) return NULL; // 内存分配失败处理，提升代码健壮性
    light->turnOn = Light_TurnOn;
    light->turnOff = Light_TurnOff;
    return light;
}

// 子系统2：空调模块
typedef struct {
    void (*setTemperature)(int); // 设置温度函数指针
    void (*turnOff)(void);       // 关闭空调函数指针
} AirConditioner;

// 空调温度设置实现
void AC_SetTemperature(int temp) {
    printf("空调温度设置为%d℃，体感舒适\n", temp);
}

// 空调关闭实现
void AC_TurnOff(void) {
    printf("空调已关闭，减少能耗\n");
}

// 工厂函数：创建空调实例
AirConditioner* CreateAirConditioner() {
    AirConditioner* ac = (AirConditioner*)malloc(sizeof(AirConditioner));
    if (ac == NULL) return NULL;
    ac->setTemperature = AC_SetTemperature;
    ac->turnOff = AC_TurnOff;
    return ac;
}

// 子系统3：窗帘模块
typedef struct {
    void (*close)(void); // 关闭窗帘函数指针
    void (*open)(void);  // 打开窗帘函数指针
} Curtain;

// 窗帘关闭实现
void Curtain_Close(void) {
    printf("窗帘已关闭，保障隐私\n");
}

// 窗帘打开实现
void Curtain_Open(void) {
    printf("窗帘已打开，引入自然光线\n");
}

// 工厂函数：创建窗帘实例
Curtain* CreateCurtain() {
    Curtain* curtain = (Curtain*)malloc(sizeof(Curtain));
    if (curtain == NULL) return NULL;
    curtain->close = Curtain_Close;
    curtain->open = Curtain_Open;
    return curtain;
}

// 外观类：智能家居统一控制接口（结构体封装子系统指针和方法）
typedef struct {
    Light* light;                // 灯光子系统指针
    AirConditioner* ac;          // 空调子系统指针
    Curtain* curtain;            // 窗帘子系统指针
    void (*homeMode)(struct SmartHomeFacade*); // 回家模式函数指针
    void (*leaveMode)(struct SmartHomeFacade*); // 离家模式函数指针
} SmartHomeFacade;

// 回家模式实现：整合子系统操作，适配回家场景
void Facade_HomeMode(SmartHomeFacade* facade) {
    printf("\n===== 执行回家模式 =====\n");
    facade->light->turnOn();
    facade->ac->setTemperature(26);
    facade->curtain->open();
}

// 离家模式实现：整合子系统操作，适配离家场景
void Facade_LeaveMode(SmartHomeFacade* facade) {
    printf("\n===== 执行离家模式 =====\n");
    facade->light->turnOff();
    facade->ac->turnOff();
    facade->curtain->close();
}

// 工厂函数：创建外观类实例，初始化子系统和方法
SmartHomeFacade* CreateSmartHomeFacade() {
    SmartHomeFacade* facade = (SmartHomeFacade*)malloc(sizeof(SmartHomeFacade));
    if (facade == NULL) return NULL;
    // 初始化子系统实例，隐藏子模块创建细节
    facade->light = CreateLight();
    facade->ac = CreateAirConditioner();
    facade->curtain = CreateCurtain();
    // 绑定外观类方法，封装交互逻辑
    facade->homeMode = Facade_HomeMode;
    facade->leaveMode = Facade_LeaveMode;
    return facade;
}

// 释放资源：递归释放外观类和子系统内存，避免内存泄漏
void DestroySmartHomeFacade(SmartHomeFacade* facade) {
    if (facade == NULL) return;
    free(facade->light);
    free(facade->ac);
    free(facade->curtain);
    free(facade);
}

// 客户端调用：仅与外观类交互，无需关注子系统细节
int main() {
    // 创建外观类实例
    SmartHomeFacade* smartHome = CreateSmartHomeFacade();
    if (smartHome == NULL) {
        fprintf(stderr, "外观类实例创建失败\n");
        return -1;
    }
    // 调用场景化接口，完成复杂业务操作
    smartHome->homeMode(smartHome);
    smartHome->leaveMode(smartHome);
    // 释放内存，提升代码健壮性
    DestroySmartHomeFacade(smartHome);
    return 0;
}

三、外观模式的优缺点

外观模式的核心价值是“简化交互、解耦分层”，其优缺点均围绕这一核心展开。在实际开发中，需结合业务场景的复杂度、扩展需求，权衡使用，避免过度设计或滥用，确保既发挥其核心优势，又规避潜在问题，实现架构设计的合理性。

3.1 核心优点

简化客户端调用，降低使用成本：客户端无需了解复杂子系统的内部结构、调用顺序和依赖关系，仅需调用外观类的统一接口，即可完成复杂业务流程，大幅降低客户端的开发、调试和维护成本，提升开发效率。
降低系统耦合度，提升可维护性：外观类作为客户端与子系统的隔离层，子系统的内部修改（如接口调整、逻辑优化、替换子模块）不会直接影响客户端，完全符合“开闭原则”，同时降低系统的整体耦合度，便于子模块的单独维护、迭代与扩展。
统一入口管理，便于扩展：通过外观类集中管理子系统的交互逻辑，新增业务场景（如“睡眠模式”“影院模式”）时，仅需在外观类中新增接口、整合子系统操作，无需修改客户端和子系统代码，扩展便捷，且不破坏原有逻辑。
屏蔽底层差异，提升代码一致性：在多语言、多模块协同开发场景中，外观类可统一不同子系统的调用方式，屏蔽底层实现差异（如不同支付渠道、不同硬件设备的接口差异），让客户端调用更简洁、一致，降低团队协作成本。
适配遗留系统改造，降低改造风险：对于接口混乱、耦合度高的遗留系统，无需修改原有代码，通过外观类封装遗留系统接口，为新系统提供统一调用方式，实现新老系统的兼容对接，降低改造风险和成本。

3.2 主要缺点

违背单一职责原则：外观类需整合多个子系统的交互逻辑，若业务场景复杂、子系统较多，会导致外观类变得庞大、逻辑臃肿，自身职责过重，增加后期维护和迭代的成本。
灵活度不足，扩展受限：外观类的接口是固定的场景化调用，若客户端需要灵活组合子系统的功能（如仅打开空调、不操作灯光），现有接口可能无法满足，需新增接口或修改原有逻辑，破坏开闭原则，降低系统的灵活性。
存在少量性能损耗：外观类作为中间调用层，会增加少量的函数调用开销，虽在大多数业务场景下可忽略不计，但在高频调用、极致性能优化的场景中（如嵌入式系统、高频交易系统），可能影响系统性能。
子系统依赖隐藏，排查问题难度提升：外观类封装了子系统的依赖关系，若子系统之间的依赖发生变化，可能导致外观类逻辑失效，且问题排查需逐层追溯子系统的交互逻辑，增加问题定位的难度。

四、外观模式的使用场景

外观模式的核心适用场景是“客户端需要简化与复杂系统的交互，且无需关注子系统内部实现”。以下结合具体场景及典型实战案例，帮助开发者快速判断是否适用，实现精准落地，避免滥用或错用。

4.1 核心适用场景

复杂系统简化交互：当系统由多个子模块构成，客户端调用流程繁琐、需了解大量子模块细节时，如框架封装（Spring的ApplicationContext封装底层IOC容器逻辑）、SDK开发（支付SDK封装不同支付渠道的接口）、智能家居控制系统等，通过外观模式可大幅简化客户端调用。
遗留系统改造：老旧系统接口混乱、耦合度高，无法直接修改原有代码，需为新系统提供统一调用方式时，通过外观类封装遗留系统接口，实现新老系统的兼容对接，降低改造风险和成本，无需重构遗留代码。
多层架构解耦：分层架构（如表现层、业务层、数据层）中，为减少层与层之间的直接依赖，通过外观类封装业务层和数据层的核心逻辑，让表现层仅与外观类交互，提升架构的清晰性和可维护性，避免层间耦合过高。
团队协作开发：不同团队负责不同子系统（如支付团队、物流团队、库存团队），通过外观类作为统一出口，协调各子系统的交互逻辑，降低团队之间的沟通成本，避免接口调用混乱，提升协作效率。
高频场景化调用：存在大量场景化的高频调用（如电商的“下单流程”“退款流程”），需整合多个子系统的操作，通过外观类封装为单一接口，提升开发效率，减少重复代码，便于后期维护。

4.2 典型实战案例

框架封装：Spring框架的ApplicationContext，封装了Bean的创建、依赖注入、生命周期管理等复杂逻辑，客户端仅需通过getBean()方法即可获取Bean实例，无需关注底层实现，大幅简化框架的使用。
支付SDK开发：支付宝、微信支付SDK，封装了签名、请求发送、结果解析、异常处理等子模块，客户端仅需调用统一的支付接口，即可完成支付流程，无需关注不同支付渠道的底层差异，实现多支付渠道的无缝对接。
操作系统API封装：操作系统的底层API复杂且繁多，应用程序通过系统调用的外观接口（如Windows的API函数），简化对底层资源（文件、内存、进程）的操作，无需了解操作系统的底层实现细节。
智能家居控制系统：如本文案例，通过外观类封装灯光、空调、窗帘等子系统，提供“回家”“离家”等场景化接口，简化用户操作，让用户无需逐一控制每个设备，实现场景化智能控制。
电商下单系统：外观类封装库存检查、支付处理、物流创建、订单记录、消息通知等子系统，客户端调用“createOrder()”接口即可完成下单全流程，无需逐一调用各子系统接口，简化业务逻辑，提升开发效率。

五、总结

外观模式是一种“极简主义”的结构型设计模式，其核心价值在于封装系统复杂性，暴露统一简单的高层接口，本质是通过“中介者”的设计思想，隔离客户端与子系统的直接交互，实现“简化调用、解耦分层”的设计目标。它不改变子系统的功能和内部逻辑，仅负责协调子系统的交互顺序与依赖关系，让客户端从复杂的子模块调用中解放出来，专注于自身业务逻辑的实现，提升代码的可读性、可维护性和开发效率。

从多语言实现来看，尽管各语言的语法特性差异显著，但核心逻辑高度统一，且均能适配自身的设计理念，实现外观模式的核心价值：

面向对象语言（C#、Python、C++）：通过类封装子系统和外观类，依托构造函数初始化实例，借助面向对象的特性（封装、多态），实现逻辑的清晰分离，适配大多数业务场景；
Go语言：遵循“组合优于继承”，通过结构体+方法绑定实现功能，依托工厂函数初始化实例，代码极简高效，贴合高并发、高性能的后端开发需求；
纯C语言：通过结构体+函数指针模拟面向对象特性，手动管理内存，底层可控性强，适配嵌入式、底层开发等资源受限场景，虽代码冗余，但能完整实现外观模式的核心逻辑。

在工程实践中，使用外观模式需把握三个核心原则：一是明确业务场景是否存在“客户端需简化复杂系统交互”的需求，避免在简单系统中滥用；二是平衡外观类的职责，避免外观类成为“万能类”，可通过拆分外观类、引入子外观类，缓解职责过重的问题；三是兼顾灵活性与简化性，对于需灵活组合子系统功能的场景，可保留子系统的直接调用入口，避免外观类完全屏蔽子系统，实现“简化调用”与“灵活扩展”的平衡。

总体而言，外观模式是简化复杂系统交互、降低系统耦合的高效工具，尤其适用于复杂系统、多层架构、遗留系统改造等场景。合理使用外观模式，可让代码更简洁、架构更清晰、维护更高效，是每一位开发者必备的架构设计工具。

组合模式

发表于 2019-11-10 更新于 2026-04-20 分类于学习笔记，设计模式

组合模式（Composite Pattern）是结构型设计模式的核心成员之一，其核心设计思想是将对象组合成树形结构，用以表示“部分-整体”的层次关系，核心目标是让客户端对单个对象（叶子节点）和组合对象（容器节点）的访问具有一致性——无需区分两者类型，即可通过统一接口完成操作，从而简化客户端逻辑，提升系统的可扩展性与可维护性。

组合模式的核心价值在于“统一访问”与“层次化管理”，尤其适配具有明显层级结构的业务场景，它将复杂的树形结构封装为统一的组件接口，让客户端无需关注结构的复杂性，只需专注于业务逻辑的实现。

一、组合模式的核心结构

组合模式通过四个核心角色的分工协作，构建“部分-整体”的树形结构，实现单个对象与组合对象的统一访问，各角色职责清晰、边界明确，共同支撑模式的核心逻辑：

抽象组件（Component）：定义单个对象和组合对象的公共接口，是客户端与所有组件交互的统一入口。接口中需包含所有组件的通用操作（如遍历、计算、添加/删除子节点等），其中添加、删除等组合节点特有操作，可在叶子节点中做空实现或抛出异常，兼顾接口统一性与角色特殊性。
叶子节点（Leaf）：树形结构中的最小功能单元，无任何子节点，是“部分”的具体实现。它仅需实现抽象组件中与自身相关的核心操作，对于添加、删除子节点等组合节点特有操作，无需实现（或抛出不支持的异常）。
组合节点（Composite）：树形结构中的容器单元，可包含子节点（叶子节点或其他组合节点），是“整体”的具体实现。它不仅要实现抽象组件的所有通用操作，核心职责还包括管理子节点（添加、删除、遍历），并通过递归调用子节点的方法，完成整体功能的聚合。
客户端（Client）：通过抽象组件接口访问所有节点，无需区分叶子节点与组合节点，无需关注树形结构的层级细节，实现“一键操作”所有组件（单个或组合）。

组合模式的核心逻辑可概括为：树形结构 + 统一接口 + 递归遍历。其中，递归是组合节点处理子节点、聚合整体功能的核心方式，也是实现“统一访问”的关键——组合节点通过递归调用子节点的方法，将自身的操作传递给所有子节点，最终完成整体功能的计算或执行。

二、多语言实现组合模式

组合模式的核心是“树形结构的统一访问”，不同语言因语法特性差异，实现方式略有不同，但核心逻辑高度统一。以下基于“文件系统”这一经典场景（文件=叶子节点，文件夹=组合节点，支持遍历、计算大小等操作），实现C#、Python、Golang、C++、纯C五种语言的完整可运行案例，代码均添加规范注释，便于直接复用，同时贴合各语言的设计理念。

2.1 C# 实现（面向对象标准实现）

C# 作为强类型面向对象语言，通过抽象类定义抽象组件接口，明确所有组件的通用操作，叶子节点与组合节点分别继承抽象类，实现各自的核心逻辑，代码结构严谨、可维护性高，贴合企业级开发规范。

using System;
using System.Collections.Generic;

// 抽象组件：文件系统节点，定义统一接口
public abstract class FileSystemComponent
{
    protected string Name; // 节点名称

    // 构造函数：初始化节点名称
    public FileSystemComponent(string name) => Name = name;
    
    // 公共操作：计算节点大小（核心通用操作）
    public abstract long GetSize();

    // 组合节点特有操作：添加子节点（叶子节点默认抛异常）
    public virtual void Add(FileSystemComponent component) => 
        throw new NotSupportedException($"{Name} 是叶子节点，不支持添加子节点");

    // 组合节点特有操作：删除子节点（叶子节点默认抛异常）
    public virtual void Remove(FileSystemComponent component) => 
        throw new NotSupportedException($"{Name} 是叶子节点，不支持删除子节点");
}

// 叶子节点：文件（无子类节点，仅实现核心操作）
public class File : FileSystemComponent
{
    private long _size; // 文件大小（单位：字节）

    // 构造函数：初始化文件名称和大小
    public File(string name, long size) : base(name) => _size = size;
    
    // 实现计算大小的核心方法
    public override long GetSize()
    {
        Console.WriteLine($"文件【{Name}】大小：{_size} 字节");
        return _size;
    }
}

// 组合节点：文件夹（包含子节点，管理子节点并聚合功能）
public class Folder : FileSystemComponent
{
    // 存储子节点（支持叶子节点和其他组合节点）
    private List<FileSystemComponent> _children = new List<FileSystemComponent>();

    // 构造函数：初始化文件夹名称
    public Folder(string name) : base(name) { }
    
    // 实现添加子节点方法
    public override void Add(FileSystemComponent component) => _children.Add(component);

    // 实现删除子节点方法
    public override void Remove(FileSystemComponent component) => _children.Remove(component);

    // 实现计算大小方法：递归遍历子节点，聚合总大小
    public override long GetSize()
    {
        long totalSize = 0;
        Console.WriteLine($"文件夹【{Name}】包含的文件大小：");
        // 递归调用所有子节点的GetSize方法，累加总大小
        foreach (var component in _children)
        {
            totalSize += component.GetSize();
        }
        Console.WriteLine($"文件夹【{Name}】总大小：{totalSize} 字节\n");
        return totalSize;
    }
}

// 客户端调用：统一操作叶子节点和组合节点
class Program
{
    static void Main()
    {
        // 构建文件系统树形结构
        // 叶子节点：创建两个文件
        File file1 = new File("笔记.txt", 1024); // 1KB
        File file2 = new File("图片.png", 20480); // 20KB

        // 组合节点1：创建“文档”文件夹，添加文件子节点
        Folder folder1 = new Folder("文档");
        folder1.Add(file1);
        folder1.Add(file2);

        // 叶子节点：创建视频文件
        File file3 = new File("视频.mp4", 102400); // 100KB

        // 组合节点2：创建“根目录”文件夹，添加子文件夹和文件
        Folder root = new Folder("根目录");
        root.Add(folder1);
        root.Add(file3);
        
        // 统一调用GetSize方法，无需区分叶子和组合节点
        Console.WriteLine("=== 计算文件系统总大小 ===");
        root.GetSize();
    }
}

2.2 Python 实现（动态语言简洁实现）

Python 遵循“鸭子类型”，无需显式定义抽象类接口，通过基类模拟抽象组件，叶子节点与组合节点继承基类并实现对应方法，语法简洁灵活，无需繁琐的类型声明，适配快速开发与脚本场景，同时保留组合模式的核心逻辑。

class FileSystemComponent:
    """抽象组件（基类）：定义文件系统节点的统一接口"""
    def __init__(self, name):
        self.name = name  # 节点名称

    def get_size(self):
        """公共方法：计算节点大小，子类必须实现"""
        raise NotImplementedError("子类必须实现get_size方法，用于计算节点大小")

    def add(self, component):
        """组合节点特有方法：添加子节点，叶子节点默认抛出异常"""
        raise NotImplementedError(f"{self.name} 是叶子节点，不支持添加子节点")

    def remove(self, component):
        """组合节点特有方法：删除子节点，叶子节点默认抛出异常"""
        raise NotImplementedError(f"{self.name} 是叶子节点，不支持删除子节点")

class File(FileSystemComponent):
    """叶子节点：文件，无子类节点，实现核心计算逻辑"""
    def __init__(self, name, size):
        super().__init__(name)
        self.size = size  # 文件大小（单位：字节）

    def get_size(self):
        """实现计算文件大小的方法"""
        print(f"文件【{self.name}】大小：{self.size} 字节")
        return self.size

class Folder(FileSystemComponent):
    """组合节点：文件夹，管理子节点并聚合计算总大小"""
    def __init__(self, name):
        super().__init__(name)
        self.children = []  # 存储子节点（文件或文件夹）

    def add(self, component):
        """实现添加子节点的方法"""
        self.children.append(component)

    def remove(self, component):
        """实现删除子节点的方法"""
        self.children.remove(component)

    def get_size(self):
        """实现计算文件夹总大小的方法：递归遍历子节点"""
        total_size = 0
        print(f"文件夹【{self.name}】包含的文件大小：")
        for child in self.children:
            total_size += child.get_size()  # 递归调用子节点的get_size
        print(f"文件夹【{self.name}】总大小：{total_size} 字节\n")
        return total_size

# 客户端调用：统一操作所有节点
if __name__ == "__main__":
    # 构建文件系统树形结构
    file1 = File("笔记.txt", 1024)
    file2 = File("图片.png", 20480)
    folder1 = Folder("文档")
    folder1.add(file1)
    folder1.add(file2)

    file3 = File("视频.mp4", 102400)
    root = Folder("根目录")
    root.add(folder1)
    root.add(file3)

    # 统一调用get_size，无需区分叶子和组合节点
    print("=== 计算文件系统总大小 ===")
    root.get_size()

2.3 Go 实现（组合优于继承的极简实现）

Go 语言无类和继承概念，核心遵循“组合优于继承”的设计哲学，通过接口定义抽象组件的统一规范，结构体分别实现接口方法（叶子节点与组合节点），无需继承，代码极简、高效，贴合Go语言的设计理念，同时完美实现组合模式的核心逻辑。

package main

import (
	"fmt"
)

// 抽象组件：FileSystemComponent接口，定义统一操作规范
type FileSystemComponent interface {
	GetSize() int64                // 公共方法：计算节点大小
	Add(component FileSystemComponent) error // 组合节点特有：添加子节点
	Remove(component FileSystemComponent) error // 组合节点特有：删除子节点
}

// 叶子节点：File结构体，实现FileSystemComponent接口
type File struct {
	name string // 文件名称
	size int64  // 文件大小（单位：字节）
}

// 工厂方法：创建文件节点
func NewFile(name string, size int64) *File {
	return &File{name: name, size: size}
}

// 实现GetSize方法：计算文件大小
func (f *File) GetSize() int64 {
	fmt.Printf("文件【%s】大小：%d 字节\n", f.name, f.size)
	return f.size
}

// 实现Add方法：叶子节点不支持添加子节点，返回错误
func (f *File) Add(component FileSystemComponent) error {
	return fmt.Errorf("文件【%s】不支持添加子节点", f.name)
}

// 实现Remove方法：叶子节点不支持删除子节点，返回错误
func (f *File) Remove(component FileSystemComponent) error {
	return fmt.Errorf("文件【%s】不支持删除子节点", f.name)
}

// 组合节点：Folder结构体，实现FileSystemComponent接口
type Folder struct {
	name     string                    // 文件夹名称
	children []FileSystemComponent     // 存储子节点（文件或文件夹）
}

// 工厂方法：创建文件夹节点
func NewFolder(name string) *Folder {
	return &Folder{name: name, children: make([]FileSystemComponent, 0)}
}

// 实现Add方法：添加子节点
func (f *Folder) Add(component FileSystemComponent) error {
	f.children = append(f.children, component)
	return nil
}

// 实现Remove方法：删除子节点
func (f *Folder) Remove(component FileSystemComponent) error {
	// 遍历查找子节点，找到后删除
	for i, c := range f.children {
		if c == component {
			f.children = append(f.children[:i], f.children[i+1:]...)
			return nil
		}
	}
	return fmt.Errorf("子节点不存在，删除失败")
}

// 实现GetSize方法：递归遍历子节点，计算总大小
func (f *Folder) GetSize() int64 {
	var totalSize int64 = 0
	fmt.Printf("文件夹【%s】包含的文件大小：\n", f.name)
	for _, child := range f.children {
		totalSize += child.GetSize() // 递归调用子节点的GetSize
	}
	fmt.Printf("文件夹【%s】总大小：%d 字节\n\n", f.name, totalSize)
	return totalSize
}

// 客户端调用：统一操作所有节点
func main() {
	// 构建文件系统树形结构
	file1 := NewFile("笔记.txt", 1024)
	file2 := NewFile("图片.png", 20480)
	folder1 := NewFolder("文档")
	folder1.Add(file1)
	folder1.Add(file2)

	file3 := NewFile("视频.mp4", 102400)
	root := NewFolder("根目录")
	root.Add(folder1)
	root.Add(file3)

	// 统一调用GetSize，无需区分叶子和组合节点
	fmt.Println("=== 计算文件系统总大小 ===")
	root.GetSize()
}

2.4 C++ 实现（面向对象经典实现）

C++ 作为经典面向对象语言，通过抽象类（纯虚函数）定义抽象组件接口，明确通用操作规范，叶子节点与组合节点继承抽象类并实现对应方法，依托多态特性实现统一访问，兼顾灵活性与性能，适配底层开发与高性能场景，同时完善内存管理逻辑。

#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>

// 抽象组件：FileSystemComponent抽象类，定义统一接口
class FileSystemComponent {
protected:
    std::string name; // 节点名称
public:
    // 构造函数：初始化节点名称
    FileSystemComponent(const std::string& name) : name(name) {}
    // 虚析构函数：避免析构时内存泄漏（多态场景必备）
    virtual ~FileSystemComponent() = default;

    // 纯虚函数：计算节点大小（核心通用操作，子类必须实现）
    virtual long long getSize() = 0;

    // 虚函数：添加子节点（组合节点实现，叶子节点抛异常）
    virtual void add(FileSystemComponent* component) {
        throw std::runtime_error(name + " 是叶子节点，不支持添加子节点");
    }

    // 虚函数：删除子节点（组合节点实现，叶子节点抛异常）
    virtual void remove(FileSystemComponent* component) {
        throw std::runtime_error(name + " 是叶子节点，不支持删除子节点");
    }
};

// 叶子节点：File类，继承FileSystemComponent
class File : public FileSystemComponent {
private:
    long long size; // 文件大小（单位：字节）
public:
    // 构造函数：初始化文件名称和大小
    File(const std::string& name, long long size) : FileSystemComponent(name), size(size) {}

    // 实现getSize方法：计算文件大小
    long long getSize() override {
        std::cout << "文件【" << name << "】大小：" << size << " 字节" << std::endl;
        return size;
    }
};

// 组合节点：Folder类，继承FileSystemComponent
class Folder : public FileSystemComponent {
private:
    // 存储子节点指针（支持File和Folder）
    std::vector<FileSystemComponent*> children;
public:
    // 构造函数：初始化文件夹名称
    Folder(const std::string& name) : FileSystemComponent(name) {}

    // 析构函数：递归释放所有子节点内存，避免内存泄漏
    ~Folder() override {
        for (auto child : children) {
            delete child;
        }
    }

    // 实现add方法：添加子节点
    void add(FileSystemComponent* component) override {
        children.push_back(component);
    }

    // 实现remove方法：删除子节点并释放内存
    void remove(FileSystemComponent* component) override {
        for (auto it = children.begin(); it != children.end(); ++it) {
            if (*it == component) {
                children.erase(it);
                delete component; // 释放子节点内存
                break;
            }
        }
    }

    // 实现getSize方法：递归遍历子节点，计算总大小
    long long getSize() override {
        long long totalSize = 0;
        std::cout << "文件夹【" << name << "】包含的文件大小：" << std::endl;
        for (auto child : children) {
            totalSize += child->getSize(); // 递归调用子节点的getSize
        }
        std::cout << "文件夹【" << name << "】总大小：" << totalSize << " 字节" << std::endl << std::endl;
        return totalSize;
    }
};

// 客户端调用：统一操作叶子节点和组合节点
int main() {
    // 构建文件系统树形结构
    FileSystemComponent* file1 = new File("笔记.txt", 1024);
    FileSystemComponent* file2 = new File("图片.png", 20480);
    Folder* folder1 = new Folder("文档");
    folder1->add(file1);
    folder1->add(file2);

    FileSystemComponent* file3 = new File("视频.mp4", 102400);
    Folder* root = new Folder("根目录");
    root->add(folder1);
    root->add(file3);

    // 统一调用getSize方法，无需区分叶子和组合节点
    std::cout << "=== 计算文件系统总大小 ===" << std::endl;
    root->getSize();

    // 释放根目录内存（递归释放所有子节点）
    delete root;
    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C语言无面向对象特性，无类和多态，通过“结构体封装数据+函数指针模拟接口+类型标记区分节点类型”，手动模拟组合模式的核心逻辑，实现叶子节点与组合节点的统一访问。代码虽冗余，但底层可控，适配嵌入式、底层开发等资源受限场景，同时完善内存管理，避免内存泄漏。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 组件类型枚举：标记节点是文件（叶子）还是文件夹（组合）
typedef enum {
    TYPE_FILE,   // 叶子节点：文件
    TYPE_FOLDER  // 组合节点：文件夹
} ComponentType;

// 前向声明：解决结构体之间的循环引用问题
typedef struct FileSystemComponent FileSystemComponent;

// 抽象组件的函数指针类型（模拟接口方法）
typedef long long (*GetSizeFunc)(FileSystemComponent*);  // 计算大小
typedef int (*AddFunc)(FileSystemComponent*, FileSystemComponent*);  // 添加子节点
typedef int (*RemoveFunc)(FileSystemComponent*, FileSystemComponent*);  // 删除子节点

// 抽象组件结构体（模拟接口）
struct FileSystemComponent {
    ComponentType type;       // 节点类型标记
    char name[256];           // 节点名称（最大255个字符）
    GetSizeFunc get_size;     // 计算大小函数指针
    AddFunc add;              // 添加子节点函数指针
    RemoveFunc remove;        // 删除子节点函数指针
};

// 叶子节点：File结构体（嵌套抽象组件，模拟“继承”）
typedef struct {
    FileSystemComponent base; // 基组件（抽象接口）
    long long size;           // 文件大小（单位：字节）
} File;

// 组合节点：Folder结构体（嵌套抽象组件，模拟“继承”）
typedef struct {
    FileSystemComponent base; // 基组件（抽象接口）
    FileSystemComponent** children; // 子节点数组（存储文件或文件夹指针）
    int count;                // 当前子节点数量
    int capacity;             // 子节点数组容量（动态扩容）
} Folder;

// -------------------------- 叶子节点（File）方法实现 --------------------------
// 计算文件大小
long long file_get_size(FileSystemComponent* component) {
    File* file = (File*)component; // 类型转换：基组件 -> 文件节点
    printf("文件【%s】大小：%lld 字节\n", file->base.name, file->size);
    return file->size;
}

// 叶子节点添加子节点（不支持，返回错误）
int file_add(FileSystemComponent* component, FileSystemComponent* child) {
    fprintf(stderr, "错误：文件【%s】是叶子节点，不支持添加子节点\n", component->name);
    return -1; // 返回-1表示失败
}

// 叶子节点删除子节点（不支持，返回错误）
int file_remove(FileSystemComponent* component, FileSystemComponent* child) {
    fprintf(stderr, "错误：文件【%s】是叶子节点，不支持删除子节点\n", component->name);
    return -1; // 返回-1表示失败
}

// 工厂函数：创建文件节点（初始化函数指针和数据）
FileSystemComponent* create_file(const char* name, long long size) {
    File* file = (File*)malloc(sizeof(File));
    if (file == NULL) return NULL; // 内存分配失败

    // 初始化基组件
    file->base.type = TYPE_FILE;
    strncpy(file->base.name, name, sizeof(file->base.name) - 1); // 避免越界
    file->base.get_size = file_get_size;
    file->base.add = file_add;
    file->base.remove = file_remove;

    // 初始化文件特有属性
    file->size = size;
    return (FileSystemComponent*)file; // 转换为基组件指针，统一返回
}

// -------------------------- 组合节点（Folder）方法实现 --------------------------
// 计算文件夹总大小：递归遍历子节点
long long folder_get_size(FileSystemComponent* component) {
    Folder* folder = (Folder*)component; // 类型转换：基组件 -> 文件夹节点
    long long total_size = 0;
    printf("文件夹【%s】包含的文件大小：\n", folder->base.name);

    // 递归调用所有子节点的get_size方法
    for (int i = 0; i < folder->count; i++) {
        total_size += folder->children[i]->get_size(folder->children[i]);
    }

    printf("文件夹【%s】总大小：%lld 字节\n\n", folder->base.name, total_size);
    return total_size;
}

// 文件夹添加子节点（支持动态扩容）
int folder_add(FileSystemComponent* component, FileSystemComponent* child) {
    Folder* folder = (Folder*)component;

    // 动态扩容：当子节点数量达到容量时，扩容为原来的2倍
    if (folder->count >= folder->capacity) {
        folder->capacity = (folder->capacity == 0) ? 4 : folder->capacity * 2;
        folder->children = (FileSystemComponent**)realloc(
            folder->children, sizeof(FileSystemComponent*) * folder->capacity
        );
        if (folder->children == NULL) return -1; // 扩容失败
    }

    // 添加子节点
    folder->children[folder->count++] = child;
    return 0; // 返回0表示成功
}

// 文件夹删除子节点（释放子节点内存）
int folder_remove(FileSystemComponent* component, FileSystemComponent* child) {
    Folder* folder = (Folder*)component;

    // 遍历查找子节点
    for (int i = 0; i < folder->count; i++) {
        if (folder->children[i] == child) {
            // 移除子节点：移动后续元素，覆盖当前位置
            for (int j = i; j < folder->count - 1; j++) {
                folder->children[j] = folder->children[j + 1];
            }
            folder->count--;
            free(child); // 释放被删除子节点的内存
            return 0; // 成功
        }
    }

    fprintf(stderr, "错误：子节点不存在，删除失败\n");
    return -1; // 失败
}

// 工厂函数：创建文件夹节点（初始化函数指针和数据）
FileSystemComponent* create_folder(const char* name) {
    Folder* folder = (Folder*)malloc(sizeof(Folder));
    if (folder == NULL) return NULL; // 内存分配失败

    // 初始化基组件
    folder->base.type = TYPE_FOLDER;
    strncpy(folder->base.name, name, sizeof(folder->base.name) - 1);
    folder->base.get_size = folder_get_size;
    folder->base.add = folder_add;
    folder->base.remove = folder_remove;

    // 初始化文件夹特有属性
    folder->children = NULL;
    folder->count = 0;
    folder->capacity = 0;
    return (FileSystemComponent*)folder; // 转换为基组件指针，统一返回
}

// 递归释放节点内存（避免内存泄漏）
void free_component(FileSystemComponent* component) {
    if (component == NULL) return;

    // 如果是文件夹，先递归释放所有子节点
    if (component->type == TYPE_FOLDER) {
        Folder* folder = (Folder*)component;
        for (int i = 0; i < folder->count; i++) {
            free_component(folder->children[i]);
        }
        free(folder->children); // 释放子节点数组内存
    }

    free(component); // 释放当前节点内存
}

// -------------------------- 客户端调用 --------------------------
int main() {
    // 构建文件系统树形结构
    FileSystemComponent* file1 = create_file("笔记.txt", 1024);
    FileSystemComponent* file2 = create_file("图片.png", 20480);
    FileSystemComponent* folder1 = create_folder("文档");
    folder1->add(folder1, file1);
    folder1->add(folder1, file2);

    FileSystemComponent* file3 = create_file("视频.mp4", 102400);
    FileSystemComponent* root = create_folder("根目录");
    root->add(root, folder1);
    root->add(root, file3);

    // 统一调用get_size方法，无需区分叶子和组合节点
    printf("=== 计算文件系统总大小 ===\n");
    root->get_size(root);

    // 递归释放所有节点内存，避免内存泄漏
    free_component(root);
    return 0;
}

三、组合模式的优缺点

组合模式的核心价值是“统一访问接口、简化树形结构操作”，其优缺点均围绕这一核心展开，需结合业务场景的层级复杂度、扩展需求，权衡使用，避免过度设计或滥用。

3.1 核心优点

客户端访问一致性：客户端无需区分叶子节点与组合节点，统一通过抽象组件接口操作，无需关注“部分”与“整体”的差异，大幅简化客户端代码逻辑，降低使用成本。
系统扩展性强：新增叶子节点或组合节点时，只需实现抽象组件接口，无需修改现有代码（完全符合开闭原则），可快速扩展树形结构的层级和功能。
树形结构天然适配：完美契合“部分-整体”的层次化业务场景（如文件系统、菜单树、组织架构），代码结构与业务结构高度一致，提升代码的可读性和可维护性。
简化聚合操作：组合节点通过递归遍历子节点，可轻松实现整体功能的聚合（如计算总大小、批量删除、批量更新），无需手动遍历整个树形结构。

3.2 主要缺点

接口设计难度高：抽象组件接口需兼顾叶子节点与组合节点的操作，若接口包含过多组合节点特有的操作（如add/remove），叶子节点需做空实现或抛出异常，违反接口隔离原则，增加接口设计的复杂度。
性能开销明显：组合节点的功能实现依赖递归遍历，对于深层、庞大的树形结构，递归调用会带来一定的性能损耗，且可能出现栈溢出风险。
内存管理复杂：无垃圾回收机制的语言（如C语言），需手动递归释放树形结构的所有节点，易出现内存泄漏，增加开发和维护成本。
子节点类型限制困难：若需限制组合节点的子节点类型（如某文件夹只能包含特定类型的文件），需在add方法中增加类型判断逻辑，增加代码复杂度，且违背“统一接口”的设计初衷。

四、组合模式的使用场景

组合模式的核心适用场景是“存在‘部分-整体’层次关系、客户端需统一操作单个对象与组合对象”，以下是具体场景及典型实战案例，便于快速落地应用：

树形层次结构场景：业务场景天然呈现树形层级，需表示“部分-整体”关系，如文件系统（文件=叶子，文件夹=组合）、菜单树（菜单项=叶子，菜单组=组合）、组织架构树（员工=叶子，部门=组合）、XML/JSON节点树、UI组件树（按钮=叶子，面板=组合）。
客户端统一操作场景：希望客户端以相同方式处理单个对象和组合对象，无需区分类型，如批量计算树形结构中所有节点的数值（如文件总大小、菜单总数量）、批量遍历所有节点、批量执行某一操作（如批量删除文件、批量禁用菜单）。
动态扩展结构场景：树形结构的层级和节点数量不固定，需频繁添加、删除子节点，且扩展时无需修改现有代码，如动态生成的导航菜单、可自定义的组织架构、可扩展的商品分类树。
聚合功能需求场景：需对树形结构的“整体”进行聚合计算或操作，如计算文件夹总大小、统计部门总人数、汇总商品分类的总销量，通过组合节点的递归逻辑可快速实现。

典型实战案例

办公软件的“形状组合”：单个图形（矩形、圆形）为叶子节点，组合图形为组合节点，客户端可统一操作单个图形或组合图形（移动、缩放、删除），无需区分类型。
电商系统的“商品分类树”：一级分类、二级分类为组合节点，具体商品为叶子节点，客户端可统一遍历所有分类和商品，或计算某一分类下的商品总数、总销量。
权限系统的“角色树”：父角色（如管理员）为组合节点，子角色（如普通管理员）、具体权限（如查看、编辑）为叶子节点，可统一校验角色的所有权限，或批量分配权限。
日志系统的“日志层级”：单个日志项为叶子节点，日志组（如按模块划分的日志）为组合节点，可统一查询某一组日志的所有内容，或统计日志总数。

五、总结

组合模式的核心是“统一单个对象与组合对象的访问接口”，通过树形结构封装“部分-整体”的层次关系，借助递归逻辑实现组合节点的功能聚合，让客户端无需关注结构的复杂性，只需通过统一接口操作所有节点，大幅简化代码逻辑，提升系统的可扩展性。

从多语言实现来看，尽管各语言的语法特性差异显著，但核心逻辑高度统一，且均能适配自身的设计理念：

面向对象语言（C#、Python、C++）：通过抽象类/接口+多态特性，天然实现组合模式的统一访问，代码结构清晰、优雅，适配大多数企业级开发场景，无需手动模拟接口和多态。
Go语言：遵循“组合优于继承”，通过接口定义统一规范，结构体组合实现节点功能，无需继承，代码极简、高效，贴合语言的设计哲学，同时完美支撑树形结构的管理。
纯C语言：通过结构体+函数指针+类型标记，手动模拟面向对象的接口和多态，虽代码冗余、内存管理复杂，但能实现组合模式的核心逻辑，适配嵌入式、底层开发等资源受限场景。

在工程实践中，使用组合模式需把握三个核心原则：一是明确业务场景是否存在“部分-整体”的树形层次关系，避免在无层级结构的场景中滥用；二是平衡接口的统一性与纯度，避免接口包含过多冗余操作，减少叶子节点的空实现或异常抛出；三是控制树形结构的深度，避免深层递归带来的性能损耗和栈溢出风险。

总体而言，当业务场景具备明显的层级结构、且需要客户端统一操作单个对象与组合对象时，组合模式是最优设计方案之一，它能让层次化业务的代码更清晰、易维护、可扩展，是每一位开发者必备的架构设计工具。

装饰模式

发表于 2019-11-09 更新于 2026-04-20 分类于学习笔记，设计模式

装饰模式（Decorator Pattern）是结构型设计模式中极具灵活性的一种，其核心设计思想是在不改变原有对象结构和核心逻辑的前提下，动态地为对象添加额外职责。它摒弃了传统继承带来的强耦合与类爆炸问题，以“组合替代继承”的方式，实现功能的灵活扩展与叠加，完美契合“开闭原则”——对功能扩展开放，对原有代码修改关闭，是动态扩展对象能力的核心解决方案。

一、装饰模式的核心结构

装饰模式的设计核心是“动态附加职责”，通过四个角色的分工协作，实现核心功能与扩展功能的解耦，确保扩展逻辑可灵活组合、独立迭代，各角色职责清晰、边界明确：

抽象组件（Component）：定义对象的核心行为接口，是被装饰者（具体组件）和装饰者（抽象装饰器）的共同基类/接口，规范了所有对象的统一行为，确保装饰器与被装饰对象可无缝兼容。
具体组件（Concrete Component）：实现抽象组件的核心功能，是装饰模式的“基础对象”，也是被装饰的原始载体，专注于实现业务核心逻辑，不关注任何扩展功能。
抽象装饰器（Decorator）：继承或实现抽象组件，同时持有一个抽象组件的实例引用，作为所有具体装饰器的基类。其核心作用是搭建“装饰桥梁”，确保具体装饰器能嵌套包装被装饰对象，同时转发核心方法调用。
具体装饰器（Concrete Decorator）：继承抽象装饰器，是扩展功能的具体实现载体。它在调用被装饰对象核心方法的基础上，附加额外的扩展逻辑，完成“装饰”效果，且多个具体装饰器可嵌套组合，实现功能叠加。

核心逻辑拆解：抽象装饰器通过持有抽象组件的引用，实现对被装饰对象的“包装”；具体装饰器在不修改被装饰对象代码的前提下，动态附加新功能，且装饰器之间可灵活组合，形成链式装饰效果。例如：一杯基础咖啡（具体组件），可依次添加牛奶（具体装饰器1）、糖（具体装饰器2）、冰块（具体装饰器3），每一步装饰都不改变咖啡本身，却不断丰富其功能。

二、多语言实现装饰模式

装饰模式的核心是“动态包装与功能叠加”，不同语言因语法特性差异，实现方式略有不同，但核心逻辑高度统一。以下基于“饮品加料”的通用场景（基础饮品为核心组件，加料为装饰器），实现C#、Python、Golang、C++、纯C五种语言的完整可运行案例，清晰呈现各语言的适配方式，代码均添加规范注释，便于直接复用。

2.1 C# 实现（面向对象标准实现）

C# 作为强类型面向对象语言，通过接口清晰界定抽象组件规范，抽象装饰器继承接口并组合组件实例，具体装饰器实现扩展逻辑，代码结构严谨、可维护性高，贴合企业级开发规范。

using System;

// 抽象组件：饮品接口，定义饮品的核心行为（描述、价格）
public interface IDrink
{
    // 获取饮品描述
    string GetDescription();
    // 获取饮品价格
    decimal GetCost();
}

// 具体组件：基础咖啡（被装饰的原始对象）
public class Coffee : IDrink
{
    // 核心逻辑：返回基础咖啡描述
    public string GetDescription() => "基础咖啡（纯黑）";
    // 核心逻辑：返回基础咖啡价格
    public decimal GetCost() => 10.00m;
}

// 抽象装饰器：饮品装饰器，实现IDrink接口并持有被装饰对象引用
public abstract class DrinkDecorator : IDrink
{
    // 持有抽象组件引用，建立装饰与被装饰的关联
    protected IDrink _drink;

    // 构造函数注入被装饰对象，实现松耦合
    public DrinkDecorator(IDrink drink)
    {
        _drink = drink;
    }

    // 抽象方法，由具体装饰器实现扩展逻辑
    public abstract string GetDescription();
    public abstract decimal GetCost();
}

// 具体装饰器1：加牛奶（扩展功能：添加牛奶，增加价格）
public class MilkDecorator : DrinkDecorator
{
    public MilkDecorator(IDrink drink) : base(drink) { }

    // 扩展逻辑：在基础描述上添加“+牛奶”
    public override string GetDescription() => $"{_drink.GetDescription()} + 鲜牛奶";
    // 扩展逻辑：在基础价格上增加2元牛奶费用
    public override decimal GetCost() => _drink.GetCost() + 2.00m;
}

// 具体装饰器2：加糖（扩展功能：添加糖，增加价格）
public class SugarDecorator : DrinkDecorator
{
    public SugarDecorator(IDrink drink) : base(drink) { }

    // 扩展逻辑：在基础描述上添加“+糖”
    public override string GetDescription() => $"{_drink.GetDescription()} + 白砂糖";
    // 扩展逻辑：在基础价格上增加1元糖费用
    public override decimal GetCost() => _drink.GetCost() + 1.00m;
}

// 具体装饰器3：加冰块（扩展功能：添加冰块，不增加价格）
public class IceDecorator : DrinkDecorator
{
    public IceDecorator(IDrink drink) : base(drink) { }

    public override string GetDescription() => $"{_drink.GetDescription()} + 冰块";
    public override decimal GetCost() => _drink.GetCost(); // 冰块免费，无价格增加
}

// 客户端调用：测试装饰模式的动态组合效果
class Program
{
    static void Main()
    {
        // 1. 基础咖啡（无装饰）
        IDrink drink = new Coffee();
        Console.WriteLine($"{drink.GetDescription()}：{drink.GetCost():F2}元");
        
        // 2. 咖啡 + 牛奶（单层装饰）
        drink = new MilkDecorator(drink);
        Console.WriteLine($"{drink.GetDescription()}：{drink.GetCost():F2}元");
        
        // 3. 咖啡 + 牛奶 + 糖 + 冰块（多层嵌套装饰）
        drink = new SugarDecorator(drink);
        drink = new IceDecorator(drink);
        Console.WriteLine($"{drink.GetDescription()}：{drink.GetCost():F2}元");
    }
}

2.2 Python 实现（动态语言简洁实现）

Python 遵循“鸭子类型”，无需显式定义接口，通过基类模拟抽象组件，抽象装饰器继承基类并组合被装饰对象，具体装饰器实现扩展逻辑，代码简洁灵活，无需繁琐的类型声明，适配快速开发与脚本场景。

# 抽象组件：饮品基类，模拟接口规范
class Drink:
    def get_description(self):
        """获取饮品描述，子类需实现该方法"""
        raise NotImplementedError("具体饮品需实现描述方法")
    
    def get_cost(self):
        """获取饮品价格，子类需实现该方法"""
        raise NotImplementedError("具体饮品需实现价格方法")

# 具体组件：基础咖啡（被装饰的原始对象）
class Coffee(Drink):
    def get_description(self):
        return "基础咖啡（纯黑）"
    
    def get_cost(self):
        return 10.0

# 抽象装饰器：饮品装饰器基类，持有被装饰对象
class DrinkDecorator(Drink):
    def __init__(self, drink):
        # 组合被装饰对象，建立装饰关联
        self._drink = drink

# 具体装饰器1：加牛奶
class MilkDecorator(DrinkDecorator):
    def get_description(self):
        # 调用被装饰对象的核心方法，附加扩展描述
        return f"{self._drink.get_description()} + 鲜牛奶"
    
    def get_cost(self):
        # 调用被装饰对象的核心方法，附加扩展价格
        return self._drink.get_cost() + 2.0

# 具体装饰器2：加糖
class SugarDecorator(DrinkDecorator):
    def get_description(self):
        return f"{self._drink.get_description()} + 白砂糖"
    
    def get_cost(self):
        return self._drink.get_cost() + 1.0

# 具体装饰器3：加冰块
class IceDecorator(DrinkDecorator):
    def get_description(self):
        return f"{self._drink.get_description()} + 冰块"
    
    def get_cost(self):
        return self._drink.get_cost()  # 冰块免费

# 客户端调用：测试多层装饰组合
if __name__ == "__main__":
    # 基础咖啡
    drink = Coffee()
    print(f"{drink.get_description()}：{drink.get_cost():.2f}元")
    
    # 咖啡 + 牛奶
    drink = MilkDecorator(drink)
    print(f"{drink.get_description()}：{drink.get_cost():.2f}元")
    
    # 咖啡 + 牛奶 + 糖 + 冰块
    drink = SugarDecorator(drink)
    drink = IceDecorator(drink)
    print(f"{drink.get_description()}：{drink.get_cost():.2f}元")

2.3 Go 实现（组合优于继承的极简实现）

Go 语言无类和继承概念，核心遵循“组合优于继承”的设计哲学，通过接口定义抽象组件规范，通过结构体组合实现装饰器与被装饰对象的关联，无需继承，代码极简、高效，贴合Go语言的设计理念。

package main

import "fmt"

// 抽象组件：饮品接口，定义核心行为
type Drink interface {
    Description() string // 获取饮品描述
   tCost() float64       // 获取饮品价格
}

// 具体组件：基础咖啡（被装饰的原始对象）
type Coffee struct{}

// 实现Drink接口的描述方法
func (c *Coffee) GetDescription() string {
        "基础咖啡（纯黑）"
}

// 实现Drink接口的价格方法
func (c *Coffee) GetCost() float64 {
  eturn 10.0
}

// 抽象装饰器：饮品装饰器结构体，组合Drink接口（持有被装饰对象）
type DrinkDecorator struct {
  rink Drink // 持有抽象组件引用，建立装饰关联
}

// 具体装饰器1：加牛奶，嵌套抽象装饰器结构体
type MilkDecorator struct {
 DrinkDecorator
}

// 工厂方法：创建牛奶装饰器，注入被装饰对象
func NewMilkDecorator(drink Drink) *MilkDecorator {
 return &MilkDecorator{DrinkDecorator{drink: drink}}
}

// 实现Drink接口的描述方法，附加扩展逻辑
func (m *MilkDecorator) GetDescription() string {
  eturn fmt.Sprintf("%s + 鲜牛奶", m.drink.GetDescription())
}

// 实现Drink接口的价格方法，附加扩展逻辑
func (m *MilkDecorator) GetCost() float64 {
   turn m.drink.GetCost() + 2.0
}

// 具体装饰器2：加糖
type SugarDecorator struct {
    nkDecorator
}

func NewSugarDecorator(drink Drink) *SugarDecorator {
 return &SugarDecorator{DrinkDecorator{drink: drink}}
}

func (s *SugarDecorator) GetDescription() string {
     rn fmt.Sprintf("%s + 白砂糖", s.drink.GetDescription())
}

func (s *SugarDecorator) GetCost() float64 {
   turn s.drink.GetCost() + 1.0
}

// 具体装饰器3：加冰块
type IceDecorator struct {
  rinkDecorator
}

func NewIceDecorator(drink Drink) *IceDecorator {
        &IceDecorator{DrinkDecorator{drink: drink}}
}

func (i *IceDecorator) GetDescription() string {
   turn fmt.Sprintf("%s + 冰块", i.drink.GetDescription())
}

func (i *IceDecorator) GetCost() float64 {
  eturn i.drink.GetCost()
}

// 客户端调用：测试装饰组合效果
func main() {
 // 基础咖啡
   r drink Drink = &Coffee{}
   t.Printf("%s：%.2f元\n", drink.GetDescription(), drink.GetCost())

  / 咖啡 + 牛奶
  rink = NewMilkDecorator(drink)
    .Printf("%s：%.2f元\n", drink.GetDescription(), drink.GetCost())

         牛奶 + 糖 + 冰块
    nk = NewSugarDecorator(drink)
  rink = NewIceDecorator(drink)
 fmt.Printf("%s：%.2f元\n", drink.GetDescription(), drink.GetCost())
}
             d    dri// 咖啡 +    fmt      d      /     fm     va             r     re return      D     re   retu           Dri     re      r                    d      r return     Ge    Get

2.4 C++ 实现（面向对象经典实现）

C++ 作为经典面向对象语言，通过抽象类（纯虚函数）定义抽象组件和抽象装饰器，具体装饰器继承抽象装饰器并持有组件指针，依托多态实现动态装饰，兼顾灵活性与性能，适配底层开发与高性能场景。

#include <iostream>
#include <string>
#include <iomanip> // 用于格式化输出

// 抽象组件：饮品抽象类，定义核心行为
class Drink {
public:
    // 虚析构函数，避免析构时内存泄漏
    virtual ~Drink() = default;
    // 纯虚函数：获取饮品描述
    virtual std::string getDescription() = 0;
    // 纯虚函数：获取饮品价格
    virtual double getCost() = 0;
};

// 具体组件：基础咖啡（被装饰的原始对象）
class Coffee : public Drink {
public:
    std::string getDescription() override {
        return "基础咖啡（纯黑）";
    }
    double getCost() override {
        return 10.0;
    }
};

// 抽象装饰器：饮品装饰器抽象类，继承Drink并持有被装饰对象指针
class DrinkDecorator : public Drink {
protected:
    Drink* _drink; // 持有被装饰对象指针，建立关联
public:
    // 构造函数注入被装饰对象
    DrinkDecorator(Drink* drink) : _drink(drink) {}
    // 虚析构函数，释放被装饰对象内存
    virtual ~DrinkDecorator() { delete _drink; }
};

// 具体装饰器1：加牛奶
class MilkDecorator : public DrinkDecorator {
public:
    MilkDecorator(Drink* drink) : DrinkDecorator(drink) {}

    std::string getDescription() override {
        return _drink->getDescription() + " + 鲜牛奶";
    }
    double getCost() override {
        return _drink->getCost() + 2.0;
    }
};

// 具体装饰器2：加糖
class SugarDecorator : public DrinkDecorator {
public:
    SugarDecorator(Drink* drink) : DrinkDecorator(drink) {}

    std::string getDescription() override {
        return _drink->getDescription() + " + 白砂糖";
    }
    double getCost() override {
        return _drink->getCost() + 1.0;
    }
};

// 具体装饰器3：加冰块
class IceDecorator : public DrinkDecorator {
public:
    IceDecorator(Drink* drink) : DrinkDecorator(drink) {}

    std::string getDescription() override {
        return _drink->getDescription() + " + 冰块";
    }
    double getCost() override {
        return _drink->getCost();
    }
};

// 客户端调用：测试多层装饰效果
int main() {
    // 1. 基础咖啡
    Drink* drink = new Coffee();
    std::cout << drink->getDescription() << "：" << std::fixed << std::setprecision(2) << drink->getCost() << "元" << std::endl;

    // 2. 咖啡 + 牛奶
    drink = new MilkDecorator(drink);
    std::cout << drink->getDescription() << "：" << std::fixed << std::setprecision(2) << drink->getCost() << "元" << std::endl;

    // 3. 咖啡 + 牛奶 + 糖 + 冰块
    drink = new SugarDecorator(drink);
    drink = new IceDecorator(drink);
    std::cout << drink->getDescription() << "：" << std::fixed << std::setprecision(2) << drink->getCost() << "元" << std::endl;

    // 释放内存，避免泄漏
    delete drink;
    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C语言无面向对象特性，通过“结构体封装数据+函数指针模拟方法”，模拟抽象组件、具体组件和装饰器的核心逻辑，依托结构体嵌套和函数指针赋值，实现动态装饰与功能叠加，代码虽冗余但底层可控，适配嵌入式、底层开发场景。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

// 定义函数指针类型，模拟饮品的核心方法
typedef char* (*GetDescriptionFunc)(void*);
typedef double (*GetCostFunc)(void*);

// 抽象组件：饮品结构体（模拟接口）
typedef struct {
    GetDescriptionFunc get_description; // 描述方法指针
    GetCostFunc get_cost;               // 价格方法指针
} Drink;

// 具体组件：基础咖啡（被装饰的原始对象）
typedef struct {
    Drink drink; // 嵌套Drink结构体，模拟“继承”
} Coffee;

// 咖啡的描述方法实现
char* Coffee_GetDescription(void* self) {
    return "基础咖啡（纯黑）";
}

// 咖啡的价格方法实现
double Coffee_GetCost(void* self) {
    return 10.0;
}

// 工厂函数：创建咖啡对象，初始化函数指针
Coffee* Coffee_Create() {
    Coffee* coffee = (Coffee*)malloc(sizeof(Coffee));
    if (coffee == NULL) return NULL;
    coffee->drink.get_description = Coffee_GetDescription;
    coffee->drink.get_cost = Coffee_GetCost;
    return coffee;
}

// 抽象装饰器：饮品装饰器结构体，持有被装饰对象
typedef struct {
    Drink drink;         // 模拟“继承”Drink接口
    Drink* wrapped_drink;// 持有被装饰的Drink对象指针
} DrinkDecorator;

// 具体装饰器1：加牛奶
typedef struct {
    DrinkDecorator decorator; // 嵌套抽象装饰器
} MilkDecorator;

// 牛奶装饰器的描述方法实现（扩展逻辑）
char* Milk_GetDescription(void* self) {
    MilkDecorator* decorator = (MilkDecorator*)self;
    // 调用被装饰对象的核心方法
    char* base_desc = decorator->decorator.wrapped_drink->get_description(decorator->decorator.wrapped_drink);
    // 拼接扩展描述，分配内存（需手动释放）
    char* new_desc = (char*)malloc(strlen(base_desc) + strlen(" + 鲜牛奶") + 1);
    strcpy(new_desc, base_desc);
    strcat(new_desc, " + 鲜牛奶");
    return new_desc;
}

// 牛奶装饰器的价格方法实现（扩展逻辑）
double Milk_GetCost(void* self) {
    MilkDecorator* decorator = (MilkDecorator*)self;
    return decorator->decorator.wrapped_drink->get_cost(decorator->decorator.wrapped_drink) + 2.0;
}

// 工厂函数：创建牛奶装饰器，注入被装饰对象
MilkDecorator* MilkDecorator_Create(Drink* drink) {
    MilkDecorator* decorator = (MilkDecorator*)malloc(sizeof(MilkDecorator));
    if (decorator == NULL) return NULL;
    decorator->decorator.drink.get_description = Milk_GetDescription;
    decorator->decorator.drink.get_cost = Milk_GetCost;
    decorator->decorator.wrapped_drink = drink;
    return decorator;
}

// 具体装饰器2：加糖
typedef struct {
    DrinkDecorator decorator;
} SugarDecorator;

char* Sugar_GetDescription(void* self) {
    SugarDecorator* decorator = (SugarDecorator*)self;
    char* base_desc = decorator->decorator.wrapped_drink->get_description(decorator->decorator.wrapped_drink);
    char* new_desc = (char*)malloc(strlen(base_desc) + strlen(" + 白砂糖") + 1);
    strcpy(new_desc, base_desc);
    strcat(new_desc, " + 白砂糖");
    return new_desc;
}

double Sugar_GetCost(void* self) {
    SugarDecorator* decorator = (SugarDecorator*)self;
    return decorator->decorator.wrapped_drink->get_cost(decorator->decorator.wrapped_drink) + 1.0;
}

SugarDecorator* SugarDecorator_Create(Drink* drink) {
    SugarDecorator* decorator = (SugarDecorator*)malloc(sizeof(SugarDecorator));
    if (decorator == NULL) return NULL;
    decorator->decorator.drink.get_description = Sugar_GetDescription;
    decorator->decorator.drink.get_cost = Sugar_GetCost;
    decorator->decorator.wrapped_drink = drink;
    return decorator;
}

// 具体装饰器3：加冰块
typedef struct {
    DrinkDecorator decorator;
} IceDecorator;

char* Ice_GetDescription(void* self) {
    IceDecorator* decorator = (IceDecorator*)self;
    char* base_desc = decorator->decorator.wrapped_drink->get_description(decorator->decorator.wrapped_drink);
    char* new_desc = (char*)malloc(strlen(base_desc) + strlen(" + 冰块") + 1);
    strcpy(new_desc, base_desc);
    strcat(new_desc, " + 冰块");
    return new_desc;
}

double Ice_GetCost(void* self) {
    IceDecorator* decorator = (IceDecorator*)self;
    return decorator->decorator.wrapped_drink->get_cost(decorator->decorator.wrapped_drink);
}

IceDecorator* IceDecorator_Create(Drink* drink) {
    IceDecorator* decorator = (IceDecorator*)malloc(sizeof(IceDecorator));
    if (decorator == NULL) return NULL;
    decorator->decorator.drink.get_description = Ice_GetDescription;
    decorator->decorator.drink.get_cost = Ice_GetCost;
    decorator->decorator.wrapped_drink = drink;
    return decorator;
}

// 客户端调用：测试装饰模式的动态组合与功能叠加
int main() {
    // 1. 基础咖啡（无装饰）
    Coffee* coffee = Coffee_Create();
    Drink* drink = (Drink*)coffee;
    printf("%s：%.2f元\n", drink->get_description(coffee), drink->get_cost(coffee));

    // 2. 咖啡 + 牛奶（单层装饰）
    MilkDecorator* milk = MilkDecorator_Create(drink);
    drink = (Drink*)milk;
    char* desc1 = drink->get_description(milk);
    printf("%s：%.2f元\n", desc1, drink->get_cost(milk));
    free(desc1); // 释放动态分配的描述字符串

    // 3. 咖啡 + 牛奶 + 糖 + 冰块（多层装饰）
    SugarDecorator* sugar = SugarDecorator_Create(drink);
    drink = (Drink*)sugar;
    IceDecorator* ice = IceDecorator_Create(drink);
    drink = (Drink*)ice;
    char* desc2 = drink->get_description(ice);
    printf("%s：%.2f元\n", desc2, drink->get_cost(ice));
    free(desc2);

    // 释放内存，避免泄漏
    free(ice);
    free(sugar);
    free(milk);
    free(coffee);
    return 0;
}

三、装饰模式的优缺点

装饰模式的核心价值是“动态扩展、解耦职责”，其优缺点均围绕这一核心展开，需结合系统复杂度和扩展需求权衡使用，避免过度设计或滥用。

3.1 核心优点

灵活性远超继承：无需创建大量子类（避免类爆炸问题），可在运行时动态为对象添加/移除职责，灵活组合多个装饰器，实现功能的叠加扩展，比继承更具弹性。
完全符合开闭原则：扩展新功能只需新增具体装饰器类/结构体，无需修改原有核心代码（抽象组件、具体组件），降低系统修改风险，提升可维护性。
职责清晰解耦：核心功能与扩展功能分离，具体组件专注于实现业务核心逻辑，装饰器专注于实现扩展逻辑，代码职责单一，便于维护和迭代。
支持多层嵌套装饰：多个装饰器可嵌套组合，实现复杂功能的叠加（如咖啡+牛奶+糖+冰块），且装饰器之间相互独立，可自由组合。
不改变原有对象结构：装饰器仅通过“包装”方式附加功能，不修改原有对象的代码和结构，避免破坏原有逻辑的稳定性。

3.2 主要缺点

增加系统复杂度：过多的装饰器会导致系统中类/结构体数量增加，同时多层嵌套装饰会形成调用链，增加代码的理解成本和调试难度。
装饰器顺序敏感：部分场景下，装饰器的执行顺序会影响最终结果（如“权限校验装饰器”需在“日志记录装饰器”之前执行），顺序错误会导致业务逻辑异常。
调试难度提升：多层装饰嵌套后，定位问题需逐层追溯装饰器的调用流程，无法直接定位到问题源头，增加调试成本。
纯C等语言实现繁琐：无面向对象特性的语言，需通过结构体+函数指针模拟装饰逻辑，代码冗余度高，维护不便。

四、装饰模式的使用场景

装饰模式的核心适用场景是“需动态扩展对象功能、避免继承爆炸、核心功能与扩展功能解耦”，具体场景如下，同时补充典型实战案例，便于理解落地：

动态扩展对象功能：需在运行时为对象添加/移除职责，且扩展功能不固定（如电商系统中，订单的折扣、满减、优惠券等优惠规则，可通过装饰器动态组合，不同订单适用不同优惠组合）。
避免继承导致的类爆炸：当一个对象的扩展方向较多（如UI组件的边框、阴影、高亮、禁用等样式），若用继承需为每种样式组合创建子类，装饰模式可通过组合装饰器实现，大幅减少类数量。
功能可叠加/撤销：需实现功能的多层叠加，或支持动态撤销扩展功能（如IO流操作：文件流+缓冲流+加密流，可自由组合或移除某一层流；日志框架的多处理器：控制台日志+文件日志+远程上报日志，可动态添加或移除日志输出方式）。
核心功能稳定，扩展功能多变：基础核心逻辑稳定，扩展功能频繁迭代（如支付系统的基础支付功能不变，扩展微信支付、支付宝、银联等支付渠道时，用装饰器封装各渠道的差异化逻辑，不影响核心支付流程）。
不允许修改原有对象代码：第三方组件、遗留系统的对象，无法修改其源码，需通过装饰器附加新功能，实现兼容扩展。

典型实战案例

IO流框架：如Java的InputStream/OutputStream、C#的FileStream，通过装饰器模式实现缓冲、加密、压缩等功能的叠加（如BufferedInputStream装饰FileInputStream，实现缓冲读取）。
日志框架：如Log4j、NLog，通过装饰器动态添加日志过滤、格式化、多输出源（控制台、文件、数据库）等功能，灵活配置日志输出规则。
UI组件库：如前端的按钮、输入框，通过装饰器添加边框、阴影、hover效果、禁用状态等样式，避免为每种样式组合创建独立组件。
权限校验系统：接口请求的权限校验、参数校验、日志记录，通过装饰器嵌套实现（如先校验权限，再校验参数，最后记录日志），职责分离且可灵活组合。
电商优惠系统：订单结算时，折扣、满减、优惠券、积分抵扣等优惠规则，通过装饰器动态组合，不同订单匹配不同优惠组合，扩展性极强。

五、总结

装饰模式的核心是“动态包装、职责解耦”，其本质是通过“组合替代继承”，解决了继承带来的灵活性不足、类爆炸等痛点，实现对象功能的动态扩展与叠加。它的核心价值不在于“简化代码”，而在于“优化扩展能力”，让系统在不修改原有代码的前提下，快速迭代新功能，同时保持核心逻辑的稳定性。

从多语言实现来看，尽管语法形式差异显著，但核心逻辑高度统一，且适配不同语言的设计理念：

面向对象语言（C#、Python、C++）：依托接口/抽象类定义核心规范，通过继承扩展装饰器，通过组合建立装饰关联，代码结构清晰、易维护，适配大多数企业级开发场景；
Go语言：遵循“组合优于继承”，通过接口定义组件规范，通过结构体嵌套组合装饰器与被装饰对象，极简高效，贴合语言的设计哲学；
纯C语言：通过结构体+函数指针模拟面向对象特性，手动实现装饰逻辑，底层可控，适配嵌入式、底层开发等资源受限场景。

在工程实践中，使用装饰模式需注意三点：一是控制装饰器的数量，避免过度嵌套导致的复杂度提升；二是明确装饰器的执行顺序，避免因顺序错误引发业务异常；三是避免滥用，简单场景（无动态扩展需求）下，直接添加方法或使用继承更简洁。当系统需要动态扩展功能、核心与扩展逻辑解耦、避免类爆炸时，装饰模式是最优设计方案之一，是每一位开发者必备的架构设计工具。

桥接模式

发表于 2019-11-08 更新于 2026-04-20 分类于学习笔记，设计模式

桥接模式（Bridge Pattern）是结构型设计模式的核心成员之一，其核心设计思想是将抽象部分与它的实现部分分离，使两者能够独立地定义、扩展，互不干扰。这种模式摒弃了传统继承带来的强耦合问题，通过“组合替代继承”的方式，让抽象维度与实现维度可以沿着各自的方向灵活迭代，是解决多维度扩展、避免继承体系臃肿的关键设计方案。

一、桥接模式核心结构

桥接模式的设计核心的是“解耦双维度”，通过四个角色的分工协作，实现抽象与实现的分离，确保两个维度可独立扩展，各角色职责清晰、边界明确：

抽象化（Abstraction）：定义抽象层的核心接口，同时持有一个指向实现化对象的引用，是“抽象维度”的顶层抽象，负责封装抽象层的通用逻辑，不直接依赖具体实现。
扩展抽象化（Refined Abstraction）：继承或实现抽象化接口，是抽象维度的具体扩展，在抽象层基础上增加特定业务逻辑，无需关注实现层的具体细节。
实现化（Implementor）：定义实现层的核心接口，仅声明实现层的基础方法，供扩展抽象化调用，是“实现维度”的顶层规范，与抽象层解耦。
具体实现化（Concrete Implementor）：实现实现化接口，是实现维度的具体落地，负责提供底层的实现逻辑，可独立扩展新的实现方式，无需修改抽象层代码。

核心逻辑拆解：抽象维度通过持有实现维度的引用，间接调用实现维度的方法，实现“抽象依赖实现、实现不依赖抽象”的解耦效果。当需要扩展时，可单独新增抽象维度的扩展类（如新增智能遥控器）或实现维度的具体类（如新增投影仪），无需修改原有代码，完全符合“开闭原则”。

二、多语言实现桥接模式

桥接模式的核心是“双维度分离与组合”，不同语言因语法特性差异，实现方式略有不同，但核心逻辑高度统一。以下基于“设备控制”的统一场景（遥控器_抽象维度_与设备_实现维度_的桥接），实现C#、Python、Golang、C++、纯C五种语言的完整可运行案例，清晰呈现各语言的适配方式。

2.1 C# 实现（面向对象标准实现）

C# 作为强类型面向对象语言，通过接口清晰界定实现化规范，通过抽象类定义抽象层，依托继承与组合完成桥接，代码结构严谨，贴合企业级开发规范。

using System;
using System.Threading;

// 实现化接口（Implementor）：设备的核心操作规范
public interface IDevice
{
    // 设备开机方法
    void TurnOn();
    // 设备关机方法
    void TurnOff();
}

// 具体实现化1：电视（设备维度的具体实现）
public class TV : IDevice
{
    public void TurnOn() => Console.WriteLine("电视已开机，正在加载节目...");
    public void TurnOff() => Console.WriteLine("电视已关机，已保存观看记录\n");
}

// 具体实现化2：空调（设备维度的扩展实现）
public class AirConditioner : IDevice
{
    public void TurnOn() => Console.WriteLine("空调已开机，正在调节至26℃...");
    public void TurnOff() => Console.WriteLine("空调已关机，已关闭节能模式\n");
}

// 抽象化（Abstraction）：遥控器的抽象层，持有设备引用
public abstract class RemoteControl
{
    // 持有实现化对象的引用，建立抽象与实现的桥接
    protected IDevice _device;

    // 构造函数注入设备，实现松耦合
    public RemoteControl(IDevice device)
    {
        _device = device;
    }

    // 抽象方法：遥控器核心操作（由扩展抽象化实现）
    public abstract void PowerOperation();
}

// 扩展抽象化：普通遥控器（抽象维度的具体实现）
public class BasicRemote : RemoteControl
{
    public BasicRemote(IDevice device) : base(device) { }

    // 实现抽象方法，封装遥控器的操作逻辑
    public override void PowerOperation()
    {
        Console.WriteLine("执行普通遥控器电源操作：");
        _device.TurnOn();
        Thread.Sleep(1000); // 模拟设备运行1秒
        _device.TurnOff();
    }
}

// 客户端调用：仅关注抽象层与实现层的组合，无需感知桥接细节
class Program
{
    static void Main()
    {
        // 组合1：普通遥控器 + 电视
        IDevice tv = new TV();
        RemoteControl tvRemote = new BasicRemote(tv);
        tvRemote.PowerOperation();

        // 组合2：普通遥控器 + 空调
        IDevice ac = new AirConditioner();
        RemoteControl acRemote = new BasicRemote(ac);
        acRemote.PowerOperation();
    }
}

2.2 Python 实现（动态语言简洁实现）

Python 遵循“鸭子类型”，无需显式定义接口，通过类的继承模拟抽象层与实现层，依托组合建立桥接关系，代码简洁灵活，无需繁琐的类型声明，适配快速开发场景。

import time

# 实现化类（Implementor）：设备的抽象基类，定义实现层规范
class Device:
    def turn_on(self):
        """设备开机方法，由具体设备实现"""
        raise NotImplementedError("具体设备需实现开机方法")

    def turn_off(self):
        """设备关机方法，由具体设备实现"""
        raise NotImplementedError("具体设备需实现关机方法")

# 具体实现化1：电视
class TV(Device):
    def turn_on(self):
        print("电视已开机，正在加载节目...")

    def turn_off(self):
        print("电视已关机，已保存观看记录\n")

# 具体实现化2：空调
class AirConditioner(Device):
    def turn_on(self):
        print("空调已开机，正在调节至26℃...")

    def turn_off(self):
        print("空调已关机，已关闭节能模式\n")

# 抽象化类（Abstraction）：遥控器抽象层，持有设备引用
class RemoteControl:
    def __init__(self, device):
        # 组合设备对象，建立桥接
        self.device = device

    def power_operation(self):
        """遥控器核心操作，由扩展抽象化实现"""
        raise NotImplementedError("具体遥控器需实现电源操作方法")

# 扩展抽象化：普通遥控器
class BasicRemote(RemoteControl):
    def power_operation(self):
        print("执行普通遥控器电源操作：")
        self.device.turn_on()
        time.sleep(1)  # 模拟设备运行1秒
        self.device.turn_off()

# 客户端调用：灵活组合抽象与实现
if __name__ == "__main__":
    # 组合1：普通遥控器控制电视
    tv = TV()
    tv_remote = BasicRemote(tv)
    tv_remote.power_operation()

    # 组合2：普通遥控器控制空调
    ac = AirConditioner()
    ac_remote = BasicRemote(ac)
    ac_remote.power_operation()

2.3 Go 实现（组合优于继承的极简实现）

Go 语言无类和继承概念，核心遵循“组合优于继承”的设计哲学，通过接口定义实现化规范，通过结构体组合建立抽象与实现的桥接，贴合Go语言极简、高效的开发理念。

package main

import (
   mt"
  time"
)

// 实现化接口（Implementor）：设备操作接口
type Device interface {
   rnOn()  // 开机方法
 TurnOff() // 关机方法
}

// 具体实现化1：电视
type TV struct{}

// 实现Device接口的开机方法
func (t *TV) TurnOn() {
     Println("电视已开机，正在加载节目...")
}

// 实现Device接口的关机方法
func (t *TV) TurnOff() {
        ftln("电视已关机，已保存观看记录\n")
}

// 具体实现化2：空调
type AirConditioner struct{}

// 实现Device接口的开机方法
func (a *AirConditioner) TurnOn() {
  mt.Println("空调已开机，正在调节至26℃...")
}

// 实现Device接口的关机方法
func (a *AirConditioner) TurnOff() {
     Println("空调已关机，已关闭节能模式\n")
}

// 抽象化结构体（Abstraction）：遥控器抽象层，组合设备接口
type RemoteControl struct {
  evice Device // 持有实现化接口引用，建立桥接
}

// 扩展抽象化：普通遥控器，组合抽象化结构体
type BasicRemote struct {
 RemoteControl // 嵌入结构体，实现抽象层的继承效果
}

// 扩展抽象化的核心操作方法
func (b *BasicRemote) PowerOperation() {
 fmt.Println("执行普通遥控器电源操作：")
 b.device.TurnOn()
  ime.Sleep(1 * time.Second) // 模拟设备运行1秒
  .device.TurnOff()
}

// 客户端调用：通过接口组合，实现灵活适配
func main() {
  / 组合1：普通遥控器 + 电视
 tv := &TV{}
 tvRemote := &BasicRemote{RemoteControl{device: tv}}
 tvRemote.PowerOperation()

  / 组合2：普通遥控器 + 空调
       &AirConditioner{}
  cRemote := &BasicRemote{RemoteControl{device: ac}}
   Remote.PowerOperation()
}
     ac      a  ac :=      /                           /      b      t                           d   fmt.      fmt.Prin   fmt.            Tu      "     "f

2.4 C++ 实现（面向对象经典实现）

C++ 作为经典面向对象语言，通过纯虚函数定义抽象接口（抽象化与实现化），依托类继承实现扩展，通过指针持有实现化对象，完成桥接逻辑，兼顾灵活性与性能，适配底层开发场景。

#include <iostream>
#include <chrono>
#include <thread>

// 实现化接口（Implementor）：设备操作抽象接口
class Device {
public:
    // 纯虚函数，定义设备开机规范
    virtual void turnOn() = 0;
    // 纯虚函数，定义设备关机规范
    virtual void turnOff() = 0;
    // 虚析构函数，避免析构时内存泄漏
    virtual ~Device() = default;
};

// 具体实现化1：电视
class TV : public Device {
public:
    void turnOn() override {
        std::cout << "电视已开机，正在加载节目..." << std::endl;
    }
    void turnOff() override {
        std::cout << "电视已关机，已保存观看记录\n" << std::endl;
    }
};

// 具体实现化2：空调
class AirConditioner : public Device {
public:
    void turnOn() override {
        std::cout << "空调已开机，正在调节至26℃..." << std::endl;
    }
    void turnOff() override {
        std::cout << "空调已关机，已关闭节能模式\n" << std::endl;
    }
};

// 抽象化类（Abstraction）：遥控器抽象层
class RemoteControl {
protected:
    Device* device; // 持有实现化对象指针，建立桥接
public:
    // 构造函数注入设备
    RemoteControl(Device* dev) : device(dev) {}
    // 虚析构函数
    virtual ~RemoteControl() = default;
    // 纯虚函数，定义遥控器核心操作
    virtual void powerOperation() = 0;
};

// 扩展抽象化：普通遥控器
class BasicRemote : public RemoteControl {
public:
    BasicRemote(Device* dev) : RemoteControl(dev) {}
    // 实现核心操作方法
    void powerOperation() override {
        std::cout << "执行普通遥控器电源操作：" << std::endl;
        device->turnOn();
        // 模拟设备运行1秒
        std::this_thread::sleep_for(std::chrono::seconds(1));
        device->turnOff();
    }
};

// 客户端调用：管理抽象与实现的组合，释放内存
int main() {
    // 组合1：普通遥控器 + 电视
    Device* tv = new TV();
    RemoteControl* tvRemote = new BasicRemote(tv);
    tvRemote->powerOperation();

    // 组合2：普通遥控器 + 空调
    Device* ac = new AirConditioner();
    RemoteControl* acRemote = new BasicRemote(ac);
    acRemote->powerOperation();

    // 释放内存，避免泄漏
    delete tvRemote;
    delete tv;
    delete acRemote;
    delete ac;

    return 0;
}

2.5 纯C语言实现（结构体+函数指针模拟实现）

纯C语言无面向对象特性，通过“结构体封装数据+函数指针模拟接口”，模拟抽象化与实现化的分离，依托结构体嵌套和函数指针赋值，建立桥接关系，代码虽冗余但底层可控，适配嵌入式、底层开发场景。

#include <stdio.h>
#include <unistd.h>

// 实现化结构体（模拟Implementor接口）：设备操作规范
typedef struct Device {
    void (*turn_on)(struct Device*);  // 开机函数指针
    void (*turn_off)(struct Device*); // 关机函数指针
} Device;

// 具体实现化1：电视（嵌入Device结构体，实现设备接口）
typedef struct TV {
    Device device; // 嵌套实现化结构体，建立桥接基础
} TV;

// 电视的开机实现
void tv_turn_on(Device* dev) {
    printf("电视已开机，正在加载节目...\n");
}

// 电视的关机实现
void tv_turn_off(Device* dev) {
    printf("电视已关机，已保存观看记录\n\n");
}

// 初始化电视：绑定函数指针，实现设备接口
void tv_init(TV* tv) {
    tv->device.turn_on = tv_turn_on;
    tv->device.turn_off = tv_turn_off;
}

// 具体实现化2：空调（嵌入Device结构体）
typedef struct AirConditioner {
    Device device; // 嵌套实现化结构体
} AirConditioner;

// 空调的开机实现
void ac_turn_on(Device* dev) {
    printf("空调已开机，正在调节至26℃...\n");
}

// 空调的关机实现
void ac_turn_off(Device* dev) {
    printf("空调已关机，已关闭节能模式\n\n");
}

// 初始化空调：绑定函数指针
void ac_init(AirConditioner* ac) {
    ac->device.turn_on = ac_turn_on;
    ac->device.turn_off = ac_turn_off;
}

// 抽象化结构体（模拟Abstraction）：遥控器抽象层
typedef struct RemoteControl {
    Device* device; // 持有实现化结构体指针，建立桥接
    void (*power_operation)(struct RemoteControl*); // 核心操作函数指针
} RemoteControl;

// 扩展抽象化：普通遥控器的核心操作实现
void basic_remote_power_operation(RemoteControl* remote) {
    printf("执行普通遥控器电源操作：\n");
    remote->device->turn_on(remote->device);
    sleep(1); // 模拟设备运行1秒
    remote->device->turn_off(remote->device);
}

// 初始化遥控器：绑定设备和核心操作方法
void remote_control_init(RemoteControl* remote, Device* dev) {
    remote->device = dev;
    remote->power_operation = basic_remote_power_operation;
}

// 客户端调用：手动组合抽象与实现，完成桥接逻辑
int main() {
    // 组合1：普通遥控器 + 电视
    TV tv;
    tv_init(&tv);
    RemoteControl tv_remote;
    remote_control_init(&tv_remote, (Device*)&tv);
    tv_remote.power_operation(&tv_remote);

    // 组合2：普通遥控器 + 空调
    AirConditioner ac;
    ac_init(&ac);
    RemoteControl ac_remote;
    remote_control_init(&ac_remote, (Device*)&ac);
    ac_remote.power_operation(&ac_remote);

    return 0;
}

三、桥接模式的优缺点

桥接模式的核心价值的是“解耦双维度、优化扩展能力”，其优缺点均围绕这一核心展开，需结合系统复杂度和扩展需求权衡使用，避免过度设计。

3.1 核心优点

彻底解耦抽象与实现：抽象层与实现层完全分离，两者可独立迭代，新增抽象维度或实现维度无需修改原有代码，符合“开闭原则”，降低系统维护成本。
避免继承爆炸：解决了多维度扩展带来的继承体系臃肿问题（例如“遥控器类型×设备类型”的组合，若用继承会产生大量子类），通过组合实现更灵活的扩展。
提升系统扩展性：抽象维度和实现维度可单独扩展，例如新增“语音遥控器”（扩展抽象化）无需修改设备代码，新增“投影仪”（具体实现化）无需修改遥控器代码。
符合合成复用原则：优先使用对象组合而非继承，降低代码耦合度，提升代码的可复用性和可维护性。
支持动态切换实现：可在运行时动态更换实现化对象，例如遥控器可切换控制电视、空调等不同设备，灵活性极高。

3.2 主要缺点

增加系统复杂度：引入抽象层、实现层及桥接关系，会增加代码量和类/结构体数量，简单场景下会提升理解成本和开发成本。
设计门槛较高：需要提前精准识别系统中的“抽象维度”和“实现维度”，对设计人员的架构能力要求较高，若维度划分不当，反而会导致代码更难维护。
间接调用带来轻微性能损耗：抽象层通过引用/指针调用实现层方法，存在少量间接调用开销（通常可忽略，仅在高频调用场景下需关注）。

四、桥接模式的使用场景

桥接模式的核心适用场景是“系统存在两个及以上独立变化的维度”，且需要长期扩展，具体场景如下：

系统存在双独立扩展维度：例如“产品类型（抽象）与产品品牌（实现）”“UI组件（抽象）与渲染引擎（实现）”“遥控器（抽象）与设备（实现）”，两者需独立扩展。
避免继承体系臃肿：当一个类的扩展方向超过一个时，继承会导致子类数量呈指数级增长（继承爆炸），桥接模式可通过组合替代继承，简化架构。
抽象与实现需解耦：例如跨平台开发中，“业务逻辑（抽象）”与“平台API（实现）”分离，适配不同操作系统（Windows、Linux、Mac），无需修改业务逻辑代码。
需要动态切换实现：需在运行时灵活切换对象的实现方式，例如视频播放器的“播放逻辑（抽象）”与“解码方式（实现）”，可动态切换硬解码、软解码。
复用现有实现：已有多个实现类，需在不修改其代码的前提下，为其提供统一的抽象接口，实现多实现的统一调用。

典型实战案例

图形界面框架：“窗口样式（抽象维度：普通窗口、弹窗、全屏窗口）”与“底层渲染（实现维度：DirectX、OpenGL、CPU渲染）”分离，支持灵活扩展。
数据库驱动：“数据库操作接口（抽象维度：查询、插入、删除）”与“不同数据库适配（实现维度：MySQL、PostgreSQL、Oracle）”分离，统一操作接口。
外设控制库：“控制逻辑（抽象维度：普通控制、智能控制）”与“外设协议（实现维度：蓝牙、WiFi、红外）”分离，适配不同类型外设。
日志框架：“日志操作（抽象维度：普通日志、异步日志）”与“日志输出方式（实现维度：文件输出、控制台输出、远程上报）”分离，支持动态切换输出方式。

五、总结

桥接模式的核心是“分离抽象与实现，通过组合实现解耦”，其本质是打破继承的强耦合枷锁，让两个独立变化的维度能够自由扩展、互不干扰。它不是为了简化代码，而是为了优化系统架构，提升系统的可扩展性和可维护性，尤其适用于复杂系统的多维度扩展场景。

从多语言实现来看，尽管语法形式差异显著，但核心逻辑高度统一，且适配不同语言的设计理念：

面向对象语言（C#、Python、C++）：依托接口/抽象类定义双维度规范，通过继承扩展抽象层，通过组合建立桥接，代码结构清晰、易维护；
Go语言：遵循“组合优于继承”，通过接口定义实现化规范，通过结构体嵌套组合抽象层与实现层，极简且高效，贴合语言特性；
纯C语言：通过结构体+函数指针模拟面向对象特性，手动实现双维度分离与桥接，底层可控，适配嵌入式等资源受限场景。

在工程实践中，使用桥接模式需注意两点：一是明确识别系统的双独立维度，避免维度划分不当导致的架构冗余；二是避免过度使用，简单场景（无多维度扩展需求）下，直接使用继承或组合更简洁。当系统需要长期扩展、存在多维度变化时，桥接模式是平衡扩展性与耦合度的最优设计方案之一，是每一位开发者必备的架构设计工具。

适配器模式

发表于 2019-11-07 更新于 2026-04-20 分类于学习笔记，设计模式

适配器模式（Adapter Pattern）是软件工程中经典的结构型设计模式，其核心价值在于解决接口不兼容问题——将一个类或模块的接口，转换为客户端期望的另一种接口，使得原本因接口差异无法协同工作的组件，能够无缝集成、正常交互。类比现实场景，电源适配器可让不同插头规格的电器适配统一插座，而适配器模式正是软件世界中的“接口转换器”，是系统集成、遗留代码改造的核心工具。

一、适配器模式核心结构

适配器模式的设计围绕“接口转换”展开，核心包含四个角色，各角色分工明确、协同完成适配逻辑，确保客户端与适配者的解耦：

目标接口（Target）：客户端期望的标准接口，定义了客户端可直接调用的方法规范，是客户端与系统交互的统一入口。
适配者（Adaptee）：现有系统中已存在的组件（类/模块），其功能符合需求，但接口格式与目标接口不兼容，是需要被适配的核心对象。
适配器（Adapter）：模式的核心角色，一边实现目标接口，一边持有适配者的引用，负责将客户端的请求转换为适配者能识别的调用，完成接口适配。
客户（Client）：仅依赖目标接口进行交互，无需感知适配者的存在，也无需关注接口转换的细节，实现与适配者的完全解耦。

根据实现方式的不同，适配器模式分为两类，适配不同语言特性与业务场景：

类适配器：通过继承适配者、实现目标接口完成适配，依赖语言的多继承特性（如C++），耦合度略高，灵活性有限。
对象适配器：通过组合方式持有适配者实例、实现目标接口完成适配，不依赖继承，耦合度低、灵活性高，是更通用的实现方式（如C#、Python、Go、纯C）。

二、多语言实现适配器模式

不同语言因语法特性（如继承机制、接口定义、动态特性）差异，适配器模式的实现方式各有侧重，但核心逻辑一致——通过适配器完成接口转换。以下基于“第三方组件集成”的统一场景（支付、日志组件适配），实现C#、Python、Golang、C++、纯C五种语言的完整案例，均可直接编译运行。

2.1 C# 实现（对象适配器）

C# 不支持多继承，因此优先采用对象适配器模式，依托接口定义目标规范，通过组合方式持有适配者实例，兼顾解耦性与代码可读性，贴合.NET开发规范。

using System;

// 目标接口：客户端期望的统一支付接口
public interface IPayment
{
    void Pay(double amount); // 统一支付方法，参数为支付金额
}

// 适配者：第三方支付宝SDK（接口不兼容，方法名、参数类型可能存在差异）
public class AlipaySDK
{
    // 第三方SDK的支付方法，参数为decimal类型，方法名与目标接口不一致
    public void DoAlipayPayment(decimal money)
    {
        Console.WriteLine($"支付宝支付：{money:F1} 元");
    }
}

// 适配器：将AlipaySDK适配为IPayment接口，完成接口转换
public class AlipayAdapter : IPayment
{
    // 组合适配者实例，实现松耦合
    private readonly AlipaySDK _alipaySDK;

    // 构造函数注入适配者，提升灵活性
    public AlipayAdapter(AlipaySDK alipaySDK)
    {
        _alipaySDK = alipaySDK;
    }

    // 实现目标接口的Pay方法，完成参数转换与方法转发
    public void Pay(double amount)
    {
        // 将客户端传入的double类型金额，转换为第三方SDK所需的decimal类型
        _alipaySDK.DoAlipayPayment(Convert.ToDecimal(amount));
    }
}

// 客户端调用：仅依赖目标接口，无需感知适配者细节
class Client
{
    static void Main(string[] args)
    {
        // 初始化适配者与适配器
        IPayment payment = new AlipayAdapter(new AlipaySDK());
        // 客户端直接调用目标接口方法，适配逻辑被适配器封装
        payment.Pay(100.5); // 输出：支付宝支付：100.5 元
    }
}

2.2 Python 实现（对象适配器）

Python 是动态语言，无需显式定义接口（遵循“鸭子类型”），通过类的组合实现对象适配器，代码简洁灵活，无需繁琐的类型声明，适配快速开发场景。

# 目标接口（约定）：客户端期望的统一支付接口，定义pay方法
class PaymentTarget:
    def pay(self, amount):
        """统一支付方法，子类需实现该方法"""
        raise NotImplementedError("请实现pay方法以完成支付适配")

# 适配者：第三方微信支付SDK（接口不兼容，方法名与目标接口不一致）
class WeChatPaySDK:
    def do_wechat_pay(self, money):
        """第三方微信支付方法"""
        print(f"微信支付：{money:.1f} 元")

# 适配器：继承目标接口约定，组合适配者，完成接口转换
class WeChatPayAdapter(PaymentTarget):
    def __init__(self, wechat_sdk):
        # 组合适配者实例，实现松耦合
        self.wechat_sdk = wechat_sdk

    def pay(self, amount):
        """实现目标接口的pay方法，转发请求到适配者"""
        self.wechat_sdk.do_wechat_pay(amount)

# 客户端调用：仅与目标接口交互，无需关注适配细节
if __name__ == "__main__":
    # 初始化适配者与适配器
    payment = WeChatPayAdapter(WeChatPaySDK())
    # 调用统一支付方法
    payment.pay(200.8)  # 输出：微信支付：200.8 元

2.3 Go 实现（对象适配器）

Go 语言无类和继承概念，核心是“面向接口编程”，通过结构体组合适配者、实现目标接口完成适配，接口匹配遵循“鸭子类型”（只需方法签名一致），贴合Go语言极简、高效的设计哲学。

package main

import "fmt"

// 目标接口：客户端期望的统一支付接口
type Payment interface {
     amount float64) // 统一支付方法，参数为float64类型
}

// 适配者：第三方银联支付SDK（接口不兼容，参数类型与目标接口不一致）
type UnionPaySDK struct{}

// 第三方SDK的支付方法，参数为float32类型
func (u *UnionPaySDK) DoUnionPay(money float32) {
  mt.Printf("银联支付：%.1f 元\n", money)
}

// 适配器：结构体组合适配者，实现目标接口
type UnionPayAdapter struct {
   ionPay *UnionPaySDK // 持有适配者实例
}

// 实现目标接口的Pay方法，完成参数转换与请求转发
func (a *UnionPayAdapter) Pay(amount float64) {
      户端传入的float64类型，转换为适配者所需的float32类型
  .unionPay.DoUnionPay(float32(amount))
}

// 客户端调用：依赖目标接口，解耦适配者
func main() {
 // 初始化适配器（注入适配者）
 var payment Payment = &UnionPayAdapter{unionPay: &UnionPaySDK{}}
  / 调用统一支付方法
 payment.Pay(300.6) // 输出：银联支付：300.6 元
}
             /                    a  // 将客     un      f   Pay(

2.4 C++ 实现（类适配器+对象适配器）

C++ 支持多继承，可同时实现类适配器与对象适配器。类适配器通过继承适配者和目标接口完成适配，耦合度略高；对象适配器通过组合实现，更推荐使用。以下重点展示类适配器，兼顾两种实现的特性。

#include <iostream>
#include <string>
using namespace std;

// 目标接口：客户端期望的统一日志接口
class LogTarget {
public:
    // 纯虚函数，定义统一日志方法
    virtual void Log(string msg) = 0;
    // 虚析构函数，避免析构时内存泄漏
    virtual ~LogTarget() = default;
};

// 适配者：第三方文件日志SDK（接口不兼容，方法参数与目标接口不一致）
class FileLogSDK {
public:
    // 第三方日志方法，参数为const char*类型
    void WriteFileLog(const char* message) {
        cout << "文件日志：" << message << endl;
    }
};

// 类适配器：继承目标接口和适配者，完成接口转换
class FileLogAdapter : public LogTarget, public FileLogSDK {
public:
    // 实现目标接口的Log方法
    void Log(string msg) override {
        // 将string类型转换为const char*，调用适配者的日志方法
        WriteFileLog(msg.c_str());
    }
};

// 客户端调用：依赖目标接口，无需感知适配者
int main() {
    LogTarget* logger = new FileLogAdapter();
    logger->Log("系统启动成功，日志记录正常"); // 输出：文件日志：系统启动成功，日志记录正常
    delete logger; // 释放内存，避免泄漏
    return 0;
}

2.5 纯C语言实现（对象适配器）

纯C语言无类和接口概念，通过“结构体封装数据、函数指针模拟接口”，模拟面向对象的特性，实现对象适配器。核心是通过结构体组合适配者，用函数指针实现目标接口，手动完成请求转发，适配嵌入式、底层开发场景。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 目标接口：用函数指针模拟统一支付接口
typedef struct {
    // 目标接口方法：参数为适配器实例和支付金额
    void (*Pay)(void* adapter, float amount);
} PaymentInterface;

// 适配者：第三方苹果支付SDK（用结构体模拟“类”）
typedef struct {
    char name[20]; // SDK版本信息
} ApplePaySDK;

// 适配者的支付方法（模拟类的成员方法）
void ApplePaySDK_DoPay(ApplePaySDK* sdk, float money) {
    printf("苹果支付：%.1f 元（SDK版本：%s）\n", money, sdk->name);
}

// 适配器：结构体组合适配者，实现目标接口
typedef struct {
    PaymentInterface interface; // 目标接口（函数指针）
    ApplePaySDK* applePay;     // 组合适配者实例
} ApplePayAdapter;

// 适配器的Pay方法实现（目标接口的具体逻辑）
void ApplePayAdapter_Pay(void* adapter, float amount) {
    // 类型转换，获取适配器实例
    ApplePayAdapter* adapterObj = (ApplePayAdapter*)adapter;
    // 转发请求到适配者的支付方法
    ApplePaySDK_DoPay(adapterObj->applePay, amount);
}

// 客户端调用：通过函数指针调用目标接口
int main() {
    // 初始化适配者
    ApplePaySDK* applePay = (ApplePaySDK*)malloc(sizeof(ApplePaySDK));
    strcpy(applePay->name, "ApplePay v1.0");
    
    // 初始化适配器：绑定目标接口方法，关联适配者
    ApplePayAdapter* adapter = (ApplePayAdapter*)malloc(sizeof(ApplePayAdapter));
    adapter->interface.Pay = ApplePayAdapter_Pay;
    adapter->applePay = applePay;
    
    // 客户端调用目标接口，无需关注适配细节
    adapter->interface.Pay(adapter, 400.9); // 输出：苹果支付：400.9 元（SDK版本：ApplePay v1.0）
    
    // 释放内存，避免泄漏
    free(applePay);
    free(adapter);
    return 0;
}

三、适配器模式的优缺点

适配器模式的核心价值是“兼容旧接口、集成新组件”，其优缺点均围绕“接口转换”的核心逻辑展开，需结合业务场景权衡使用，避免过度设计。

3.1 核心优点

解决接口兼容问题：无需修改原有适配者代码和客户端代码，即可实现不兼容接口的协同工作，完全符合“开闭原则”，降低系统改造风险。
解耦客户端与适配者：客户端仅依赖目标接口，无需感知适配者的实现细节和接口差异，降低代码耦合度，提升系统可维护性。
复用现有组件：无需为适配新接口重写现有组件逻辑，充分复用已有代码（如第三方SDK、遗留系统组件），减少开发工作量。
灵活性高：可灵活替换不同的适配者，适配不同版本的第三方组件或遗留系统，无需修改客户端和目标接口，扩展成本低。

3.2 主要缺点

增加系统复杂度：引入适配器类/结构体后，会增加系统的代码量和类结构复杂度，提升代码理解和维护成本。
存在轻微性能损耗：适配过程中的参数转换、方法转发，会带来少量性能开销（通常可忽略，仅在高频调用场景下需关注）。
类适配器局限性强：类适配器依赖多继承，耦合度高于对象适配器，且受限于语言的继承特性（如C#、Java不支持多继承），灵活性不足。
适配逻辑维护成本高：若适配者接口发生变更，需同步修改适配器的转换逻辑，增加后期维护成本。

四、适配器模式的使用场景

适配器模式的核心适用场景是“接口不兼容但功能需复用”，尤其在系统集成、遗留代码改造、第三方组件引入等场景中，能发挥重要作用，具体如下：

集成第三方组件：项目引入第三方SDK（如支付、日志、缓存、地图组件），其接口格式与项目现有接口不兼容，无需修改SDK源码，通过适配器完成适配。
改造遗留系统：维护老旧系统时，需将遗留组件接入新的业务系统，无需重构遗留代码，通过适配器适配新系统的接口规范，降低改造风险。
多版本接口兼容：同一功能存在多个版本的接口（如API v1/v2），通过适配器统一对外暴露的接口，让客户端无需感知版本差异，提升兼容性。
跨语言交互：多语言协同开发的项目中，适配不同语言的接口规范（如C语言接口适配Go/Python的调用逻辑），实现跨语言组件的无缝集成。
单元测试场景：单元测试中，适配测试桩（Mock对象）到目标接口，模拟第三方依赖的行为，确保测试用例的独立性和可执行性。

典型实战案例

电商系统集成多种支付方式（支付宝、微信、银联），通过适配器统一支付接口，客户端无需区分支付类型；
日志系统适配不同的日志组件（文件日志、控制台日志、第三方日志服务），通过适配器统一日志输出接口；
旧系统迁移时，通过适配器让遗留模块适配新系统的接口，逐步替换旧组件，实现平滑过渡；
框架开发中，适配不同的数据库驱动（MySQL、PostgreSQL、Oracle），统一数据库操作接口，提升框架兼容性。

五、总结

适配器模式的核心是“接口转换”，本质是通过一个中间层（适配器），屏蔽接口差异，实现不兼容组件的协同工作，其核心价值在于“兼容现有代码、降低集成成本”，是系统扩展和重构的重要工具。

从多语言实现来看，尽管语法形式差异显著，但核心逻辑高度统一，且适配不同语言的特性：

面向对象语言（C#、Python、C++）：依托类、接口、继承/组合实现适配，其中对象适配器因耦合度低、灵活性高，成为主流实现方式；
静态语言（Go、C++、C#）：需关注类型转换和接口匹配，代码严谨性高，适合高性能、企业级开发场景；
动态语言（Python）：无需显式定义接口，适配逻辑更简洁，适合快速开发、迭代场景；
过程式语言（纯C）：通过结构体+函数指针模拟面向对象特性，实现适配逻辑，代码冗余但底层可控，适合嵌入式、底层开发场景。

在工程实践中，使用适配器模式需注意两点：一是优先选择对象适配器，降低代码耦合度；二是避免过度使用——若接口差异过大，或适配逻辑过于复杂，重构接口可能比引入适配器更高效。适配器模式并非万能，但在接口兼容、组件集成场景中，能有效提升系统的复用性、扩展性和可维护性，是每一位开发者都应掌握的设计模式。