Chemmy's Blog

代理模式

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

代理模式（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-03-05 分类于学习笔记，设计模式

享元模式（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-03-05 分类于学习笔记，设计模式

在软件开发中，复杂系统往往由多个相互依赖、各司其职的子模块协同构成。若客户端直接与这些子模块交互，不仅需要深入了解各子模块的实现细节与调用逻辑，还会导致代码耦合度激增、可读性下降、维护成本居高不下。外观模式（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-03-05 分类于学习笔记，设计模式

组合模式（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-03-05 分类于学习笔记，设计模式

装饰模式（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-03-05 分类于学习笔记，设计模式

桥接模式（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-03-05 分类于学习笔记，设计模式

适配器模式（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）：通过结构体+函数指针模拟面向对象特性，实现适配逻辑，代码冗余但底层可控，适合嵌入式、底层开发场景。

在工程实践中，使用适配器模式需注意两点：一是优先选择对象适配器，降低代码耦合度；二是避免过度使用——若接口差异过大，或适配逻辑过于复杂，重构接口可能比引入适配器更高效。适配器模式并非万能，但在接口兼容、组件集成场景中，能有效提升系统的复用性、扩展性和可维护性，是每一位开发者都应掌握的设计模式。

原型模式

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

原型模式是一种创建型设计模式，其核心思想是通过复制已有对象（原型）来创建新对象，而非通过构造函数从头初始化。这种模式能有效减少重复初始化的开销，尤其适用于创建复杂对象或大量相似对象的场景。本文将从核心结构、多语言实现、优缺点、使用场景等维度全面解析原型模式。

一、原型模式核心结构

原型模式的核心包含两个关键角色，同时需重点区分浅拷贝与深拷贝，这是原型模式的核心要点：

1.1 核心角色

抽象原型（Prototype）：定义克隆自身的接口，通常包含一个Clone方法，声明对象拷贝的规范，是所有具体原型的公共约束。
具体原型（Concrete Prototype）：实现抽象原型的Clone方法，完成自身的拷贝逻辑，根据需求实现浅拷贝或深拷贝。

1.2 核心概念：浅拷贝与深拷贝

原型模式的核心差异的在于拷贝的深度，直接决定新旧对象的独立性：

浅拷贝：仅复制对象本身及基本类型成员，引用类型成员（如指针、对象引用）仅复制引用地址，新旧对象共享同一引用对象，一方修改会影响另一方。
深拷贝：完全复制对象及所有嵌套的引用类型成员，为每个引用类型成员重新分配内存并复制内容，新旧对象相互独立，修改互不影响。

二、多语言实现原型模式

不同语言因语法特性、内置工具差异，原型模式的实现方式各有侧重，以下结合C#、Python、Golang、C++、纯C五种语言，实现统一场景（拷贝包含引用类型成员的Person对象），清晰展示深浅拷贝的实现逻辑。

2.1 C# 实现（内置接口+序列化）

C# 内置ICloneable接口作为抽象原型，通过MemberwiseClone实现浅拷贝，深拷贝可借助序列化快速实现，无需手动处理嵌套引用，适配面向对象开发场景。

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

// 抽象原型接口（复用系统内置ICloneable，简化开发）
public interface IPrototype : ICloneable { }

// 具体原型（包含引用类型成员）
[Serializable] // 深拷贝需添加序列化标记，否则无法序列化引用类型
public class Person : IPrototype
{
    public string Name { get; set; }
    public int Age { get; set; }
    public Address Address { get; set; } // 引用类型成员（嵌套对象）

    // 浅拷贝实现：调用系统内置方法，仅拷贝值类型和引用地址
    public object Clone()
    {
        return this.MemberwiseClone(); // 内置浅拷贝方法，高效简洁
    }

    // 深拷贝实现：通过二进制序列化/反序列化，自动处理嵌套引用
    public Person DeepClone()
    {
        using (var ms = new MemoryStream())
        {
            var formatter = new BinaryFormatter();
            formatter.Serialize(ms, this); // 序列化对象
            ms.Position = 0; // 重置流位置
            return (Person)formatter.Deserialize(ms); // 反序列化生成新对象
        }
    }
}

// 引用类型成员（需同步添加序列化标记）
[Serializable]
public class Address
{
    public string City { get; set; }
    public string Street { get; set; }
}

// 测试代码（验证深浅拷贝效果）
class Program
{
    static void Main()
    {
        // 初始化原型对象
        var prototype = new Person
        {
            Name = "张三",
            Age = 25,
            Address = new Address { City = "北京", Street = "朝阳路" }
        };

        // 浅拷贝测试
        var shallowCopy = (Person)prototype.Clone();
        shallowCopy.Address.City = "上海"; // 修改引用成员
        Console.WriteLine($"浅拷贝后原型地址：{prototype.Address.City}"); // 输出：上海（原型受影响）

        // 深拷贝测试
        var deepCopy = prototype.DeepClone();
        deepCopy.Address.City = "广州"; // 修改引用成员
        Console.WriteLine($"深拷贝后原型地址：{prototype.Address.City}"); // 输出：上海（原型不受影响）
    }
}

2.2 Python 实现（内置copy模块）

Python 遵循“鸭子类型”，无需显式定义抽象原型接口，copy模块内置copy()（浅拷贝）和deepcopy()（深拷贝）方法，可直接复用，大幅简化代码，适配快速开发场景。

import copy

# 引用类型：地址类
class Address:
    def __init__(self, city, street):
        self.city = city
        self.street = street

# 具体原型类：人员类
class Person:
    def __init__(self, name, age, address):
        self.name = name  # 基本类型
        self.age = age    # 基本类型
        self.address = address  # 引用类型成员

    # 浅拷贝方法：复用copy模块
    def shallow_clone(self):
        return copy.copy(self)

    # 深拷贝方法：复用copy模块，自动处理嵌套引用
    def deep_clone(self):
        return copy.deepcopy(self)

# 测试代码
if __name__ == "__main__":
    # 初始化原型对象
    prototype = Person("张三", 25, Address("北京", "朝阳路"))

    # 浅拷贝验证
    shallow_copy = prototype.shallow_clone()
    shallow_copy.address.city = "上海"
    print(f"浅拷贝后原型地址：{prototype.address.city}")  # 输出：上海

    # 深拷贝验证
    deep_copy = prototype.deep_clone()
    deep_copy.address.city = "广州"
    print(f"深拷贝后原型地址：{prototype.address.city}")  # 输出：上海

2.3 Golang 实现（结构体方法+序列化）

Golang 无类和继承，通过结构体模拟原型，浅拷贝可通过结构体值传递实现，深拷贝可借助JSON序列化实现通用逻辑，兼顾简洁性与性能，符合Go语言极简设计哲学。

package main

import (
    coding/json"
  fmt"
)

// 引用类型：地址结构体
type Address struct {
    y   string
     et string
}

// 具体原型：人员结构体
type Person struct {
    e    string
 Age     int
         *Address // 指针类型（引用类型）
}

// 浅拷贝：结构体值传递，指针成员仅复制地址
func (p *Person) ShallowClone() *Person {
     e := *p // 值拷贝，指针成员仍指向原地址
  eturn &clone
}

// 深拷贝：通过JSON序列化/反序列化，通用且无需手动处理嵌套
func (p *Person) DeepClone() (*Person, error) {
    序列化原对象
 data, err := json.Marshal(p)
      r != nil {
   eturn nil, err
        序列化生成新对象
   r clone Person
        ern.Unmarshal(data, &clone)
  f err != nil {
  return nil, err
      turn &clone, nil
}

func main() {
  / 初始化原型对象
 prototype := &Person{
  Name: "张三",
   ge:  25,
   ddress: &Address{
   City:   "北京",
    treet: "朝阳路",
      }

  / 浅拷贝测试
 shallowCopy := prototype.ShallowClone()
 shallowCopy.Address.City = "上海"
 fmt.Printf("浅拷贝后原型地址：%s\n", prototype.Address.City) // 输出：上海

  / 深拷贝测试
    pCopy, _ := prototype.DeepClone()
 deepCopy.Address.City = "广州"
 fmt.Printf("深拷贝后原型地址：%s\n", prototype.Address.City) // 输出：上海
}
                  dee      /                           /          },
                     S                                  A             A                                  /  }
        re                    ir = jso     va}
        // 反             r  if er            //      r   clonAddress           Nam   Stre    Cit      "    "en

2.4 C++ 实现（拷贝构造函数）

C++ 通过拷贝构造函数实现原型模式，默认拷贝构造为浅拷贝，深拷贝需手动重载拷贝构造函数或自定义克隆方法，需注意内存管理，避免内存泄漏，适配高性能底层开发场景。

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

// 引用类型：地址类
class Address {
public:
    string city;
    string street;
    // 构造函数
    Address(string c, string s) : city(c), street(s) {}
};

// 具体原型：人员类
class Person {
private:
    string name;
    int age;
    Address* address; // 指针（引用类型）
public:
    // 构造函数
    Person(string n, int a, Address* addr) : name(n), age(a), address(addr) {}

    // 浅拷贝构造函数（默认行为，仅复制指针）
    Person(const Person& other) {
        this->name = other.name;
        this->age = other.age;
        this->address = other.address; // 共享指针，浅拷贝
    }

    // 深拷贝方法：手动创建新的引用对象，实现完全拷贝
    Person* DeepClone() {
        Address* newAddr = new Address(this->address->city, this->address->street);
        return new Person(this->name, this->age, newAddr);
    }

    // 析构函数：释放内存，避免泄漏
    ~Person() {
        delete address;
    }

    // 辅助方法：修改地址城市
    void setCity(string c) {
        this->address->city = c;
    }

    // 辅助方法：获取地址城市
    string getCity() {
        return this->address->city;
    }
};

// 测试代码
int main() {
    // 初始化原型对象
    Address* addr = new Address("北京", "朝阳路");
    Person* prototype = new Person("张三", 25, addr);

    // 浅拷贝测试
    Person shallowCopy = *prototype; // 调用浅拷贝构造函数
    shallowCopy.setCity("上海");
    cout << "浅拷贝后原型地址：" << prototype->getCity() << endl; // 输出：上海

    // 深拷贝测试
    Person* deepCopy = prototype->DeepClone();
    deepCopy->setCity("广州");
    cout << "深拷贝后原型地址：" << prototype->getCity() << endl; // 输出：上海

    // 释放内存
    delete prototype;
    delete deepCopy;
    return 0;
}

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

纯C语言无面向对象特性，通过结构体封装数据，函数模拟克隆行为，深浅拷贝均需手动处理指针和内存分配，代码冗余但底层可控，适配嵌入式、底层开发场景。

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

// 引用类型：地址结构体
typedef struct {
    char* city;
    char* street;
} Address;

// 具体原型：人员结构体
typedef struct {
    char* name;
    int age;
    Address* address;
} Person;

// 工具函数：初始化Address
Address* address_init(const char* city, const char* street) {
    Address* addr = (Address*)malloc(sizeof(Address));
    addr->city = (char*)malloc(strlen(city) + 1);
    strcpy(addr->city, city);
    addr->street = (char*)malloc(strlen(street) + 1);
    strcpy(addr->street, street);
    return addr;
}

// 工具函数：初始化Person
Person* person_init(const char* name, int age, Address* addr) {
    Person* p = (Person*)malloc(sizeof(Person));
    p->name = (char*)malloc(strlen(name) + 1);
    strcpy(p->name, name);
    p->age = age;
    p->address = addr;
    return p;
}

// 浅拷贝函数：仅复制结构体，共享指针成员
Person* person_shallow_clone(Person* p) {
    Person* clone = (Person*)malloc(sizeof(Person));
    clone->name = p->name; // 共享字符串指针
    clone->age = p->age;   // 复制基本类型
    clone->address = p->address; // 共享Address指针
    return clone;
}

// 深拷贝函数：手动复制所有指针成员，分配新内存
Person* person_deep_clone(Person* p) {
    // 深拷贝Address
    Address* newAddr = (Address*)malloc(sizeof(Address));
    newAddr->city = (char*)malloc(strlen(p->address->city) + 1);
    strcpy(newAddr->city, p->address->city);
    newAddr->street = (char*)malloc(strlen(p->address->street) + 1);
    strcpy(newAddr->street, p->address->street);

    // 深拷贝Person
    Person* clone = (Person*)malloc(sizeof(Person));
    clone->name = (char*)malloc(strlen(p->name) + 1);
    strcpy(clone->name, p->name);
    clone->age = p->age;
    clone->address = newAddr;
    return clone;
}

// 工具函数：释放Person内存
void person_free(Person* p) {
    free(p->name);
    free(p->address->city);
    free(p->address->street);
    free(p->address);
    free(p);
}

// 测试代码
int main() {
    // 初始化原型对象
    Address* addr = address_init("北京", "朝阳路");
    Person* prototype = person_init("张三", 25, addr);

    // 浅拷贝测试
    Person* shallowCopy = person_shallow_clone(prototype);
    // 修改浅拷贝对象的引用成员（需先释放原内存，避免内存泄漏）
    free(shallowCopy->address->city);
    shallowCopy->address->city = (char*)malloc(strlen("上海") + 1);
    strcpy(shallowCopy->address->city, "上海");
    printf("浅拷贝后原型地址：%s\n", prototype->address->city); // 输出：上海

    // 深拷贝测试
    Person* deepCopy = person_deep_clone(prototype);
    free(deepCopy->address->city);
    deepCopy->address->city = (char*)malloc(strlen("广州") + 1);
    strcpy(deepCopy->address->city, "广州");
    printf("深拷贝后原型地址：%s\n", prototype->address->city); // 输出：上海

    // 释放内存
    person_free(prototype);
    free(shallowCopy); // 浅拷贝仅释放结构体，不释放共享指针
    person_free(deepCopy);

    return 0;
}

三、原型模式的优缺点

原型模式的价值与局限均围绕“拷贝替代创建”的核心逻辑，需结合场景权衡使用，避免过度设计。

3.1 核心优点

降低对象创建开销：对于初始化成本高的对象（如数据库连接、大文件解析、复杂计算对象），拷贝比重新初始化更高效，减少重复操作。
简化对象创建逻辑：无需关注构造函数的参数、访问权限等限制，直接复制已有原型对象，降低创建复杂度，提升开发效率。
支持动态扩展：可在运行时动态修改原型对象，生成不同变体的新对象，无需修改原有代码，符合“开闭原则”。
保护原型状态：深拷贝可保留原型对象的初始状态，新对象的修改不会影响原型，适用于需要基准模板的场景。

3.2 主要缺点

深拷贝实现复杂：嵌套引用类型越多，深拷贝逻辑越繁琐，易出现内存泄漏（如C/C++）、循环引用（如Python）等问题，增加开发难度。
维护成本较高：当原型对象的属性或结构发生变更时，需同步修改拷贝逻辑（尤其是深拷贝），否则会出现拷贝不完整的问题。
性能损耗差异：深拷贝涉及大量内存复制，在高频拷贝、大对象拷贝场景下，性能损耗明显高于浅拷贝和直接创建。
非面向对象语言适配差：纯C等无面向对象特性的语言，需手动模拟原型结构和拷贝逻辑，代码冗余度高，维护不便。

四、原型模式的使用场景

原型模式的核心适用场景是“对象创建成本高、需批量生成相似对象”，同时需根据引用类型的存在与否，选择浅拷贝或深拷贝。

对象创建成本高：如创建包含大量数据的缓存对象、需频繁读取文件/数据库的配置对象、经过复杂计算初始化的对象。
批量生成相似对象：如游戏中的角色、粒子系统、NPC，电商系统中的批量订单，仅属性略有差异，通过拷贝原型可快速生成。
动态生成对象变体：如根据模板生成不同主题的UI组件、不同配置的接口请求对象，无需重复编写初始化逻辑。
避免构造函数耦合：当对象构造逻辑复杂，且创建逻辑需与业务逻辑隔离时，拷贝原型可降低代码耦合度。
浅拷贝适用场景：对象无引用类型成员，或引用成员为只读数据、无需独立修改，追求拷贝效率。
深拷贝适用场景：对象包含嵌套引用类型，且新旧对象需完全独立（如多线程操作、对象修改不影响原型、需保留基准状态）。

典型实战案例

设计工具的“复制粘贴”功能（如PS图层、Axure组件），本质是原型模式的浅拷贝/深拷贝应用；
数据库连接池中的连接对象克隆，避免频繁创建/关闭连接，提升数据库访问性能；
序列化/反序列化场景（如JSON、二进制序列化），核心是深拷贝的实现，用于对象传输、持久化；
游戏开发中的角色实例生成，通过原型拷贝快速创建大量相似角色，仅修改属性（如血量、攻击力）。

五、总结

原型模式以“拷贝替代创建”为核心，核心价值在于平衡对象创建的性能与复杂度，其核心难点是深浅拷贝的选择与实现。不同语言的实现方式，反映了语言本身的设计理念和适用场景：

高级面向对象语言（C#、Python）：提供内置工具（接口、模块）简化拷贝逻辑，深拷贝可通过序列化快速实现，开发效率高；
静态语言（Golang）：通过结构体方法+序列化实现通用拷贝，兼顾简洁性与性能，贴合语言极简特性；
编译型语言（C++）：需手动管理拷贝构造函数和内存，深拷贝实现灵活但易出错，适配高性能底层开发；
纯C语言：通过结构体+函数模拟原型模式，代码冗余但底层可控，适用于嵌入式等资源受限场景。

在工程实践中，原型模式并非万能，需注意：浅拷贝虽高效但存在数据共享风险，深拷贝虽安全但性能开销较高；当对象结构简单、创建成本低时，直接使用构造函数更简洁。原型模式可与工厂模式、单例模式协同使用（如单例管理原型对象，工厂负责克隆分发），最大化发挥其价值，成为优化复杂对象创建流程的重要工具。

建造者模式

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

在软件开发中，创建复杂对象往往需要经历多个步骤，且不同场景下对象的组件配置、构建顺序可能存在差异。建造者模式（Builder Pattern）作为经典的创建型设计模式，核心价值在于将复杂对象的构建过程与最终表示分离，让相同的构建流程能生成不同的产品形态，同时屏蔽底层构建细节，大幅提升代码的灵活性与可维护性。

一、建造者模式核心结构

建造者模式通过分层设计解耦对象构建逻辑，其经典结构包含5个核心角色，各角色分工明确、协同完成复杂对象的创建，确保构建过程的规范性与灵活性。

1.1 核心角色及职责

角色	核心职责
产品（Product）	待构建的复杂对象，由多个组件/部分组成（如电脑包含CPU、内存、硬盘等核心组件）。
抽象建造者（Builder）	定义构建产品各组件的抽象接口，声明“构建组件”和“获取产品”的核心方法，为所有具体建造者提供统一规范。
具体建造者（ConcreteBuilder）	实现抽象建造者的接口，完成产品各组件的具体构建逻辑，内部持有最终构建的产品实例，负责组件的组装与初始化。
指挥者（Director）	控制构建流程的执行顺序，调用具体建造者的方法完成对象构建，隔离客户端与底层构建细节，确保流程的一致性。
客户端（Client）	创建指挥者和具体建造者实例，通过指挥者触发构建流程，无需关注构建细节，最终获取成品对象。

1.2 核心设计思想

建造者模式的核心逻辑的是“分离构建与表示”：客户端只需指定具体建造者的类型，指挥者便会按照预设流程调用建造者的组件构建方法，无需关注组件如何组装、顺序如何安排，即可生成不同配置的产品。这种设计既保证了构建流程的规范性，又实现了产品变体的灵活扩展。

二、多语言实现建造者模式

为便于跨语言对比理解，本文以“构建不同配置的电脑”为统一场景（产品：电脑；具体建造者：游戏电脑建造者、办公电脑建造者；指挥者：电脑组装指挥者），分别通过C#、Python、Golang、C++、纯C语言实现建造者模式，贴合各语言特性与工程实践规范，所有代码均可直接编译运行。

2.1 C# 实现（抽象类+继承，经典面向对象落地）

C#作为强类型面向对象语言，完全契合建造者模式的经典类结构，通过抽象类定义建造规范，子类实现具体构建逻辑，具备良好的类型安全性和代码可读性，适合企业级系统开发。

using System;

// 产品：电脑（封装核心组件）
public class Computer
{
    public string CPU { get; set; }
    public string RAM { get; set; }
    public string HardDisk { get; set; }

    // 重写ToString，便于展示产品配置
    public override string ToString()
    {
        return $"电脑配置：CPU={CPU}，内存={RAM}，硬盘={HardDisk}";
    }
}

// 抽象建造者：定义电脑构建的统一接口
public abstract class ComputerBuilder
{
    protected Computer _computer = new Computer(); // 持有产品实例，供子类操作
    public abstract void BuildCPU();   // 构建CPU组件
    public abstract void BuildRAM();   // 构建内存组件
    public abstract void BuildHardDisk(); // 构建硬盘组件
    public Computer GetComputer() => _computer; // 返回构建完成的产品
}

// 具体建造者1：游戏电脑建造者（高性能配置）
public class GamingComputerBuilder : ComputerBuilder
{
    public override void BuildCPU() => _computer.CPU = "Intel i9-14900K";
    public override void BuildRAM() => _computer.RAM = "32GB DDR5 6400";
    public override void BuildHardDisk() => _computer.HardDisk = "2TB NVMe PCIe4.0";
}

// 具体建造者2：办公电脑建造者（高性价比配置）
public class OfficeComputerBuilder : ComputerBuilder
{
    public override void BuildCPU() => _computer.CPU = "Intel i5-13400";
    public override void BuildRAM() => _computer.RAM = "16GB DDR4 3200";
    public override void BuildHardDisk() => _computer.HardDisk = "1TB SATA3 SSD";
}

// 指挥者：控制电脑构建的流程顺序
public class ComputerDirector
{
    // 统一构建流程，屏蔽底层实现细节
    public Computer Construct(ComputerBuilder builder)
    {
        builder.BuildCPU(); // 优先构建核心CPU
        builder.BuildRAM(); // 其次构建内存
        builder.BuildHardDisk(); // 最后构建存储设备
        return builder.GetComputer();
    }
}

// 客户端调用示例
class Program
{
    static void Main(string[] args)
    {
        ComputerDirector director = new ComputerDirector();
        
        // 构建游戏电脑
        ComputerBuilder gamingBuilder = new GamingComputerBuilder();
        Computer gamingPC = director.Construct(gamingBuilder);
        Console.WriteLine(gamingPC);

        // 切换建造者，构建办公电脑（无需修改其他逻辑）
        ComputerBuilder officeBuilder = new OfficeComputerBuilder();
        Computer officePC = director.Construct(officeBuilder);
        Console.WriteLine(officePC);
    }
}

2.2 Python 实现（动态特性+极简设计）

Python无严格的抽象类语法，通过基类抛出异常实现“抽象接口”的约束，结合动态语言的灵活性简化代码，无需繁琐的类型声明，兼顾可读性与开发效率，适合快速迭代场景。

# 产品：电脑
class Computer:
    def __init__(self):
        self.cpu = None  # CPU组件
        self.ram = None  # 内存组件
        self.hard_disk = None  # 硬盘组件

    def __str__(self):
        return f"电脑配置：CPU={self.cpu}，内存={self.ram}，硬盘={self.hard_disk}"

# 抽象建造者（基类，定义规范）
class ComputerBuilder:
    def __init__(self):
        self.computer = Computer()  # 初始化产品实例

    def build_cpu(self):
        # 抽象方法，子类必须实现
        raise NotImplementedError("子类必须重写build_cpu方法，实现CPU构建逻辑")

    def build_ram(self):
        raise NotImplementedError("子类必须重写build_ram方法，实现内存构建逻辑")

    def build_hard_disk(self):
        raise NotImplementedError("子类必须重写build_hard_disk方法，实现硬盘构建逻辑")

    def get_computer(self):
        # 返回构建完成的产品
        return self.computer

# 具体建造者1：游戏电脑建造者
class GamingComputerBuilder(ComputerBuilder):
    def build_cpu(self):
        self.computer.cpu = "AMD Ryzen 9 7950X"

    def build_ram(self):
        self.computer.ram = "64GB DDR5 6000"

    def build_hard_disk(self):
        self.computer.hard_disk = "4TB NVMe PCIe5.0"

# 具体建造者2：办公电脑建造者
class OfficeComputerBuilder(ComputerBuilder):
    def build_cpu(self):
        self.computer.cpu = "AMD Ryzen 5 7600"

    def build_ram(self):
        self.computer.ram = "8GB DDR4 3200"

    def build_hard_disk(self):
        self.computer.hard_disk = "512GB SATA3 SSD"

# 指挥者：静态方法简化调用，控制构建流程
class ComputerDirector:
    @staticmethod
    def construct(builder):
        # 固定构建顺序，确保组件兼容性
        builder.build_cpu()
        builder.build_ram()
        builder.build_hard_disk()
        return builder.get_computer()

# 客户端调用
if __name__ == "__main__":
    # 构建游戏电脑
    gaming_builder = GamingComputerBuilder()
    gaming_pc = ComputerDirector.construct(gaming_builder)
    print(gaming_pc)

    # 构建办公电脑
    office_builder = OfficeComputerBuilder()
    office_pc = ComputerDirector.construct(office_builder)
    print(office_pc)

2.3 Golang 实现（接口+结构体，面向接口编程）

Golang无类和继承特性，核心是“面向接口编程”，通过接口定义建造者规范，结构体实现接口方法，贴合Go语言“极简、高效”的设计哲学，代码无冗余、执行效率高。

package main

import "fmt"

// 产品：电脑（封装核心组件）
type Computer struct {
	CPU      string // 中央处理器
	RAM      string // 内存
	HardDisk string // 硬盘
}

// 自定义String方法，用于展示产品配置
func (c *Computer) String() string {
	return fmt.Sprintf("电脑配置：CPU=%s，内存=%s，硬盘=%s", c.CPU, c.RAM, c.HardDisk)
}

// 抽象建造者：接口定义电脑构建的规范
type ComputerBuilder interface {
	BuildCPU()        // 构建CPU
	BuildRAM()        // 构建内存
	BuildHardDisk()   // 构建硬盘
	GetComputer() *Computer // 获取成品电脑
}

// 具体建造者1：游戏电脑建造者
type GamingComputerBuilder struct {
	computer *Computer // 持有产品实例
}

// 初始化游戏电脑建造者
func NewGamingComputerBuilder() *GamingComputerBuilder {
	return &GamingComputerBuilder{computer: &Computer{}}
}

func (g *GamingComputerBuilder) BuildCPU() {
	g.computer.CPU = "Intel i7-14700KF"
}

func (g *GamingComputerBuilder) BuildRAM() {
	g.computer.RAM = "48GB DDR5 6200"
}

func (g *GamingComputerBuilder) BuildHardDisk() {
	g.computer.HardDisk = "2TB NVMe PCIe4.0"
}

func (g *GamingComputerBuilder) GetComputer() *Computer {
	return g.computer
}

// 具体建造者2：办公电脑建造者
type OfficeComputerBuilder struct {
	computer *Computer // 持有产品实例
}

// 初始化办公电脑建造者
func NewOfficeComputerBuilder() *OfficeComputerBuilder {
	return &OfficeComputerBuilder{computer: &Computer{}}
}

func (o *OfficeComputerBuilder) BuildCPU() {
	o.computer.CPU = "Intel i3-12100"
}

func (o *OfficeComputerBuilder) BuildRAM() {
	o.computer.RAM = "8GB DDR4 2666"
}

func (o *OfficeComputerBuilder) BuildHardDisk() {
	o.computer.HardDisk = "512GB SATA3 SSD"
}

func (o *OfficeComputerBuilder) GetComputer() *Computer {
	return o.computer
}

// 指挥者：控制构建流程，解耦客户端与建造细节
type ComputerDirector struct{}

func (d *ComputerDirector) Construct(builder ComputerBuilder) *Computer {
	// 按固定顺序调用构建方法
	builder.BuildCPU()
	builder.BuildRAM()
	builder.BuildHardDisk()
	return builder.GetComputer()
}

// 客户端调用
func main() {
	director := &ComputerDirector{}
	
	// 构建游戏电脑
	gamingBuilder := NewGamingComputerBuilder()
	gamingPC := director.Construct(gamingBuilder)
	fmt.Println(gamingPC)

	// 构建办公电脑
	officeBuilder := NewOfficeComputerBuilder()
	officePC := director.Construct(officeBuilder)
	fmt.Println(officePC)
}

2.4 C++ 实现（抽象类+多态，高性能落地）

C++通过纯虚函数定义抽象建造者接口，子类继承并实现具体构建逻辑，需注意定义虚析构函数以避免内存泄漏，兼顾多态特性与性能，适合高性能、底层开发场景，是建造者模式的经典落地方式。

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

// 产品：电脑
class Computer {
private:
    string cpu;    // CPU组件
    string ram;    // 内存组件
    string hardDisk; // 硬盘组件
public:
    // 设置组件的setter方法
    void setCPU(string cpu) { this->cpu = cpu; }
    void setRAM(string ram) { this->ram = ram; }
    void setHardDisk(string hardDisk) { this->hardDisk = hardDisk; }
    
    // 展示产品配置
    string toString() {
        return "电脑配置：CPU=" + cpu + "，内存=" + ram + "，硬盘=" + hardDisk;
    }
};

// 抽象建造者：抽象类定义构建接口
class ComputerBuilder {
protected:
    Computer* computer; // 持有产品实例
public:
    ComputerBuilder() { computer = new Computer(); }
    virtual ~ComputerBuilder() { delete computer; } // 虚析构函数，避免内存泄漏
    virtual void buildCPU() = 0; // 纯虚函数，强制子类实现
    virtual void buildRAM() = 0;
    virtual void buildHardDisk() = 0;
    Computer* getComputer() { return computer; } // 返回成品
};

// 具体建造者1：游戏电脑建造者
class GamingComputerBuilder : public ComputerBuilder {
public:
    void buildCPU() override { computer->setCPU("AMD Ryzen 7 7800X3D"); }
    void buildRAM() override { computer->setRAM("32GB DDR5 5600"); }
    void buildHardDisk() override { computer->setHardDisk("2TB NVMe PCIe4.0"); }
};

// 具体建造者2：办公电脑建造者
class OfficeComputerBuilder : public ComputerBuilder {
public:
    void buildCPU() override { computer->setCPU("AMD Ryzen 3 7300X"); }
    void buildRAM() override { computer->setRAM("16GB DDR4 3200"); }
    void buildHardDisk() override { computer->setHardDisk("1TB SATA3 HDD"); }
};

// 指挥者：控制构建流程
class ComputerDirector {
public:
    Computer* construct(ComputerBuilder* builder) {
        // 按顺序调用构建方法，确保组件正常组装
        builder->buildCPU();
        builder->buildRAM();
        builder->buildHardDisk();
        return builder->getComputer();
    }
};

// 客户端调用
int main() {
    ComputerDirector director;
    
    // 构建游戏电脑
    ComputerBuilder* gamingBuilder = new GamingComputerBuilder();
    Computer* gamingPC = director.construct(gamingBuilder);
    cout << gamingPC->toString() << endl;

    // 构建办公电脑
    ComputerBuilder* officeBuilder = new OfficeComputerBuilder();
    Computer* officePC = director.construct(officeBuilder);
    cout << officePC->toString() << endl;

    // 释放内存，避免泄漏
    delete gamingBuilder;
    delete officeBuilder;
    delete gamingPC;
    delete officePC;
    return 0;
}

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

纯C语言无面向对象特性，通过“结构体封装数据、函数指针封装行为”模拟抽象建造者和多态特性，核心是解耦构建流程与组件实现，代码轻量化、执行高效，适合嵌入式、底层开发场景。

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

// 产品：电脑（结构体封装核心组件）
typedef struct {
    char cpu[32];      // CPU组件
    char ram[32];      // 内存组件
    char hard_disk[32];// 硬盘组件
} Computer;

// 抽象建造者：函数指针模拟构建行为，定义统一规范
typedef struct {
    Computer* computer;
    void (*build_cpu)(struct ComputerBuilder*);    // 构建CPU的函数指针
    void (*build_ram)(struct ComputerBuilder*);    // 构建内存的函数指针
    void (*build_hard_disk)(struct ComputerBuilder*); // 构建硬盘的函数指针
} ComputerBuilder;

// 具体建造者1：游戏电脑建造者（组合抽象建造者，模拟继承）
typedef struct {
    ComputerBuilder builder;
} GamingComputerBuilder;

// 游戏电脑CPU构建逻辑
void gaming_build_cpu(ComputerBuilder* b) {
    strcpy(b->computer->cpu, "Intel i9-14900KF");
}

// 游戏电脑内存构建逻辑
void gaming_build_ram(ComputerBuilder* b) {
    strcpy(b->computer->ram, "64GB DDR5 6400");
}

// 游戏电脑硬盘构建逻辑
void gaming_build_hard_disk(ComputerBuilder* b) {
    strcpy(b->computer->hard_disk, "4TB NVMe PCIe5.0");
}

// 初始化游戏电脑建造者（绑定函数指针，完成初始化）
GamingComputerBuilder* new_gaming_builder() {
    GamingComputerBuilder* builder = (GamingComputerBuilder*)malloc(sizeof(GamingComputerBuilder));
    builder->builder.computer = (Computer*)malloc(sizeof(Computer));
    builder->builder.build_cpu = gaming_build_cpu;
    builder->builder.build_ram = gaming_build_ram;
    builder->builder.build_hard_disk = gaming_build_hard_disk;
    return builder;
}

// 具体建造者2：办公电脑建造者（组合抽象建造者，模拟继承）
typedef struct {
    ComputerBuilder builder;
} OfficeComputerBuilder;

// 办公电脑CPU构建逻辑
void office_build_cpu(ComputerBuilder* b) {
    strcpy(b->computer->cpu, "Intel i5-12400");
}

// 办公电脑内存构建逻辑
void office_build_ram(ComputerBuilder* b) {
    strcpy(b->computer->ram, "16GB DDR4 3200");
}

// 办公电脑硬盘构建逻辑
void office_build_hard_disk(ComputerBuilder* b) {
    strcpy(b->computer->hard_disk, "1TB SATA3 SSD");
}

// 初始化办公电脑建造者
OfficeComputerBuilder* new_office_builder() {
    OfficeComputerBuilder* builder = (OfficeComputerBuilder*)malloc(sizeof(OfficeComputerBuilder));
    builder->builder.computer = (Computer*)malloc(sizeof(Computer));
    builder->builder.build_cpu = office_build_cpu;
    builder->builder.build_ram = office_build_ram;
    builder->builder.build_hard_disk = office_build_hard_disk;
    return builder;
}

// 指挥者：控制构建流程，调用建造者的构建方法
Computer* construct(ComputerBuilder* builder) {
    builder->build_cpu(builder);
    builder->build_ram(builder);
    builder->build_hard_disk(builder);
    return builder->computer;
}

// 打印电脑配置
void print_computer(Computer* pc) {
    printf("电脑配置：CPU=%s，内存=%s，硬盘=%s\n", pc->cpu, pc->ram, pc->hard_disk);
}

// 客户端调用
int main() {
    // 构建游戏电脑
    GamingComputerBuilder* gaming_builder = new_gaming_builder();
    Computer* gaming_pc = construct(&gaming_builder->builder);
    print_computer(gaming_pc);

    // 构建办公电脑
    OfficeComputerBuilder* office_builder = new_office_builder();
    Computer* office_pc = construct(&office_builder->builder);
    print_computer(office_pc);

    // 释放内存，避免泄漏
    free(gaming_builder->builder.computer);
    free(gaming_builder);
    free(office_builder->builder.computer);
    free(office_builder);
    free(gaming_pc);
    free(office_pc);
    return 0;
}

三、建造者模式的优缺点

建造者模式是为解决复杂对象构建问题而生的，其优势与劣势均源于“分离构建与表示”的设计思路，需结合实际业务场景权衡使用。

3.1 核心优点

解耦构建与表示：产品的内部结构、组件组装逻辑封装在具体建造者中，产品结构变化时仅需修改建造者，无需改动指挥者和客户端，完全符合“开闭原则”。
灵活扩展产品变体：替换具体建造者即可快速生成不同配置的产品，无需修改构建流程，适配多变体产品的创建需求，降低扩展成本。
精细化控制构建过程：指挥者统一管理构建步骤，可实现分步构建、暂停/恢复构建，甚至动态调整组件配置，适用于需逐步组装的复杂对象。
提升代码可维护性：客户端无需关注复杂的构建细节，只需指定建造者类型，代码逻辑清晰、可读性强，便于后期迭代与调试。

3.2 主要缺点

适用场景受限：仅适用于“复杂对象+构建步骤固定”的场景，对于结构简单、无需分步构建的对象，使用建造者模式会增加代码冗余，降低开发效率。
类/结构体数量膨胀：每新增一种产品变体，需对应新增一个具体建造者，当产品变体过多时，会导致类/结构体数量激增，增加代码维护成本。
依赖固定构建流程：指挥者的构建顺序固定，若不同产品的构建顺序差异较大，需修改指挥者代码，违反“开闭原则”，灵活性不足。

四、建造者模式的使用场景

建造者模式的核心价值在于“复杂对象的分步构建与灵活扩展”，适用于以下核心场景，能显著提升代码的可维护性与扩展性：

复杂对象分步构建：对象由多个组件组成，且组件构建有明确顺序（如汽车组装：底盘→发动机→车身→内饰；文档生成：标题→正文→页码→格式）。
多变体产品创建：同一类产品有多种配置变体，且构建逻辑相似（如不同配置的电脑、不同规格的订单、不同样式的报表），需灵活切换产品形态。
屏蔽构建细节：希望客户端仅关注产品结果，无需了解组件如何组装、依赖如何处理（如框架中的对象工厂、SDK中的实例创建），降低客户端使用成本。
动态调整构建过程：需在构建过程中动态修改组件配置（如分步构建HTTP请求：先设置Header，再添加Body，最后设置请求参数）。

典型实战案例

JDK中的StringBuilder（简化版建造者，无指挥者，自身完成字符序列的分步构建）；
MyBatis的SqlSessionFactoryBuilder（分步构建SqlSessionFactory，支持不同配置文件适配）；
前端框架中复杂表单/组件的构建器（如Element UI的表单构建器，支持分步配置表单字段）；
电商系统中的订单构建（不同类型订单的组件配置不同，通过建造者模式统一构建流程）。

五、总结

建造者模式的核心是“分离复杂对象的构建流程与组件实现”，通过抽象建造者定义规范、具体建造者实现细节、指挥者控制顺序，既解决了复杂对象构建的灵活性问题，又屏蔽了底层构建细节，提升了代码的可维护性与扩展性。

从多语言实现来看，尽管各语言的语法特性差异显著，但核心逻辑高度统一，均围绕“解耦构建与表示”展开：

面向对象语言（C#、Python、Golang、C++）：通过类/接口/结构体+多态实现，贴合经典设计模式结构，代码更易理解与扩展，适配中高层开发场景；
过程式语言（纯C）：通过结构体+函数指针模拟面向对象特性，核心是封装构建行为，代码轻量化、执行高效，适配嵌入式、底层开发场景。

使用建造者模式的关键是“匹配业务场景”：若对象结构简单、变体较少，无需使用建造者模式，避免过度设计；若对象复杂且需灵活定制、分步构建，建造者模式能发挥其最大价值。同时，无需拘泥于“指挥者+建造者”的固定结构，简化版建造者（无指挥者）在实际开发中也广泛应用，核心是把握“构建与表示分离”的本质，而非形式。

抽象工厂模式

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

抽象工厂模式是GoF 23种经典创建型设计模式的核心成员，作为工厂方法模式的进阶版本，它专为解决多等级、多系列产品的创建问题而生。其核心价值在于为客户端提供一套创建“产品族”的统一接口，屏蔽具体产品的实现细节，实现对象创建与使用的解耦，在复杂系统设计中应用广泛。本文将从核心结构、多语言实现、优缺点、使用场景及总结五个维度，全面拆解抽象工厂模式，助力开发者快速掌握其设计思想与落地技巧。

一、核心结构与设计思想

抽象工厂模式在工厂方法模式的基础上，进一步强化了对“产品族”的管理能力，核心围绕4个角色构建，各角色职责清晰、协同工作，其设计核心是“分离产品族的抽象定义与具体实现”。

1.1 核心角色定义

抽象工厂（Abstract Factory）：定义创建多等级产品的抽象接口，包含多个创建不同类型产品的方法，通常通过抽象类或接口实现，是整个模式的核心契约。
具体工厂（Concrete Factory）：实现抽象工厂的所有抽象方法，负责创建某一特定产品族下的全部具体产品，确保同一工厂生产的产品具备兼容性和关联性。
抽象产品（Abstract Product）：定义某一等级产品的通用规范，描述产品的核心行为与特性，抽象工厂模式中会存在多个不同等级的抽象产品（如“电视机”“空调”）。
具体产品（Concrete Product）：实现对应抽象产品的接口，是抽象工厂模式的最终实例化对象，由特定具体工厂创建，与具体工厂形成“一对多”的关联关系。

1.2 核心概念辨析

理解抽象工厂模式的关键，是区分两个核心概念：

产品族：由同一具体工厂生产、属于不同产品等级的一组关联产品（如海尔工厂生产的电视机+空调，同属海尔品牌，具备协同适配特性）。
产品等级：同一类产品的不同实现（如所有品牌的电视机，均属于“电视机”这一产品等级）。

抽象工厂模式的核心目标，就是对产品族的创建进行标准化管理，让客户端无需关注产品的具体品牌和实现细节，仅通过抽象接口即可获取所需的一组关联产品。

二、多语言落地实现（统一场景：电器产品族）

为便于跨语言对比理解，本文以“电器生产”为统一场景：定义两个产品族（海尔、TCL），两个产品等级（电视机、空调），分别通过C#、Python、Golang、C++及纯C语言实现抽象工厂模式，贴合各语言的语法特性与最佳实践。

2.1 C# 实现（抽象类+继承，经典落地）

C#作为强类型面向对象语言，天然支持抽象类与接口，完美契合抽象工厂模式的经典设计，代码可读性高、类型安全，适合企业级系统开发。

using System;

// 抽象产品1：电视机（定义电视机的通用行为）
public abstract class TV
{
    public abstract void ShowInfo(); // 展示产品信息
}

// 抽象产品2：空调（定义空调的通用行为）
public abstract class AirConditioner
{
    public abstract void ShowInfo(); // 展示产品信息
}

// 具体产品1-1：海尔电视机（实现电视机抽象接口）
public class HaierTV : TV
{
    public override void ShowInfo() => Console.WriteLine("【海尔电视机】- 智能4K，节能护眼");
}

// 具体产品1-2：海尔空调（实现空调抽象接口）
public class HaierAirConditioner : AirConditioner
{
    public override void ShowInfo() => Console.WriteLine("【海尔空调】- 一级能效，静音节能");
}

// 具体产品2-1：TCL电视机（实现电视机抽象接口）
public class TCLTV : TV
{
    public override void ShowInfo() => Console.WriteLine("【TCL电视机】- 量子点屏幕，高刷清晰");
}

// 具体产品2-2：TCL空调（实现空调抽象接口）
public class TCLAirConditioner : AirConditioner
{
    public override void ShowInfo() => Console.WriteLine("【TCL空调】- 快速制冷，智能控温");
}

// 抽象工厂：电器工厂（定义产品族的创建接口）
public abstract class ElectricApplianceFactory
{
    public abstract TV CreateTV(); // 创建电视机
    public abstract AirConditioner CreateAirConditioner(); // 创建空调
}

// 具体工厂1：海尔工厂（生产海尔产品族）
public class HaierFactory : ElectricApplianceFactory
{
    public override TV CreateTV() => new HaierTV();
    public override AirConditioner CreateAirConditioner() => new HaierAirConditioner();
}

// 具体工厂2：TCL工厂（生产TCL产品族）
public class TCLFactory : ElectricApplianceFactory
{
    public override TV CreateTV() => new TCLTV();
    public override AirConditioner CreateAirConditioner() => new TCLAirConditioner();
}

// 客户端调用（面向抽象编程，屏蔽具体实现）
class Client
{
    static void Main(string[] args)
    {
        // 1. 使用海尔工厂，获取海尔产品族
        ElectricApplianceFactory haierFactory = new HaierFactory();
        haierFactory.CreateTV().ShowInfo();
        haierFactory.CreateAirConditioner().ShowInfo();

        // 2. 切换为TCL工厂，获取TCL产品族（无需修改其他代码）
        ElectricApplianceFactory tclFactory = new TCLFactory();
        tclFactory.CreateTV().ShowInfo();
        tclFactory.CreateAirConditioner().ShowInfo();
    }
}

2.2 Python 实现（abc模块+动态特性，简洁灵活）

Python无严格的抽象类语法，通过abc模块实现抽象接口，结合动态语言的灵活性，无需繁琐的类型声明，代码简洁易读，适合快速开发场景。

from abc import ABC, abstractmethod

# 抽象产品1：电视机
class TV(ABC):
    @abstractmethod
    def show_info(self):
        """抽象方法：展示产品信息"""
        pass

# 抽象产品2：空调
class AirConditioner(ABC):
    @abstractmethod
    def show_info(self):
        """抽象方法：展示产品信息"""
        pass

# 具体产品1-1：海尔电视机
class HaierTV(TV):
    def show_info(self):
        print("【海尔电视机】- 智能4K，节能护眼")

# 具体产品1-2：海尔空调
class HaierAirConditioner(AirConditioner):
    def show_info(self):
        print("【海尔空调】- 一级能效，静音节能")

# 具体产品2-1：TCL电视机
class TCLTV(TV):
    def show_info(self):
        print("【TCL电视机】- 量子点屏幕，高刷清晰")

# 具体产品2-2：TCL空调
class TCLAirConditioner(AirConditioner):
    def show_info(self):
        print("【TCL空调】- 快速制冷，智能控温")

# 抽象工厂：电器工厂
class ElectricApplianceFactory(ABC):
    @abstractmethod
    def create_tv(self):
        """抽象方法：创建电视机"""
        pass

    @abstractmethod
    def create_air_conditioner(self):
        """抽象方法：创建空调"""
        pass

# 具体工厂1：海尔工厂
class HaierFactory(ElectricApplianceFactory):
    def create_tv(self):
        return HaierTV()

    def create_air_conditioner(self):
        return HaierAirConditioner()

# 具体工厂2：TCL工厂
class TCLFactory(ElectricApplianceFactory):
    def create_tv(self):
        return TCLTV()

    def create_air_conditioner(self):
        return TCLAirConditioner()

# 客户端调用
if __name__ == "__main__":
    # 获取海尔产品族
    haier_factory = HaierFactory()
    haier_factory.create_tv().show_info()
    haier_factory.create_air_conditioner().show_info()

    # 切换为TCL产品族
    tcl_factory = TCLFactory()
    tcl_factory.create_tv().show_info()
    tcl_factory.create_air_conditioner().show_info()

2.3 Golang 实现（接口+结构体，面向接口编程）

Golang无类和继承特性，核心是“面向接口编程”，通过接口模拟抽象工厂与抽象产品，结构体实现接口方法，贴合Go语言的极简设计理念，代码高效、无冗余。

package main

import "fmt"

// 抽象产品1：电视机接口（定义电视机的行为规范）
type TV interface {
  howInfo() // 展示产品信息
}

// 抽象产品2：空调接口（定义空调的行为规范）
type AirConditioner interface {
      nfo() // 展示产品信息
}

// 具体产品1-1：海尔电视机（实现TV接口）
type HaierTV struct{}

func (h *HaierTV) ShowInfo() {
  mt.Println("【海尔电视机】- 智能4K，节能护眼")
}

// 具体产品1-2：海尔空调（实现AirConditioner接口）
type HaierAirConditioner struct{}

func (h *HaierAirConditioner) ShowInfo() {
 fmt.Println("【海尔空调】- 一级能效，静音节能")
}

// 具体产品2-1：TCL电视机（实现TV接口）
type TCLTV struct{}

func (t *TCLTV) ShowInfo() {
 fmt.Println("【TCL电视机】- 量子点屏幕，高刷清晰")
}

// 具体产品2-2：TCL空调（实现AirConditioner接口）
type TCLAirConditioner struct{}

func (t *TCLAirConditioner) ShowInfo() {
 fmt.Println("【TCL空调】- 快速制冷，智能控温")
}

// 抽象工厂：电器工厂接口（定义产品族创建规范）
type ElectricApplianceFactory interface {
  reateTV() TV // 创建电视机
  reateAirConditioner() AirConditioner // 创建空调
}

// 具体工厂1：海尔工厂（实现电器工厂接口）
type HaierFactory struct{}

func (h *HaierFactory) CreateTV() TV {
 return &HaierTV{}
}

func (h *HaierFactory) CreateAirConditioner() AirConditioner {
  eturn &HaierAirConditioner{}
}

// 具体工厂2：TCL工厂（实现电器工厂接口）
type TCLFactory struct{}

func (t *TCLFactory) CreateTV() TV {
 return &TCLTV{}
}

func (t *TCLFactory) CreateAirConditioner() AirConditioner {
   turn &TCLAirConditioner{}
}

// 客户端调用（依赖接口，不依赖具体实现）
func main() {
    使用海尔工厂
   r haierFactory ElectricApplianceFactory = &HaierFactory{}
 haierFactory.CreateTV().ShowInfo()
  aierFactory.CreateAirConditioner().ShowInfo()

    切换为TCL工厂
     tclFactory ElectricApplianceFactory = &TCLFactory{}
    Factory.CreateTV().ShowInfo()
      ctory.CreateAirConditioner().ShowInfo()
}
  tclFa    tcl    var    //       h            va     //     re             r             C      C                           f  ShowI      S

2.4 C++ 实现（纯虚函数+继承，高性能落地）

C++通过纯虚函数定义抽象类（抽象工厂/抽象产品），子类继承并实现具体逻辑，需注意定义虚析构函数避免内存泄漏，适合高性能、底层开发场景，是抽象工厂模式的经典落地方式。

#include <iostream>
using namespace std;

// 抽象产品1：电视机
class TV {
public:
    virtual void ShowInfo() = 0; // 纯虚函数，定义抽象接口
    virtual ~TV() = default; // 虚析构函数，避免内存泄漏
};

// 抽象产品2：空调
class AirConditioner {
public:
    virtual void ShowInfo() = 0; // 纯虚函数，定义抽象接口
    virtual ~AirConditioner() = default; // 虚析构函数
};

// 具体产品1-1：海尔电视机
class HaierTV : public TV {
public:
    void ShowInfo() override {
        cout << "【海尔电视机】- 智能4K，节能护眼" << endl;
    }
};

// 具体产品1-2：海尔空调
class HaierAirConditioner : public AirConditioner {
public:
    void ShowInfo() override {
        cout << "【海尔空调】- 一级能效，静音节能" << endl;
    }
};

// 具体产品2-1：TCL电视机
class TCLTV : public TV {
public:
    void ShowInfo() override {
        cout << "【TCL电视机】- 量子点屏幕，高刷清晰" << endl;
    }
};

// 具体产品2-2：TCL空调
class TCLAirConditioner : public AirConditioner {
public:
    void ShowInfo() override {
        cout << "【TCL空调】- 快速制冷，智能控温" << endl;
    }
};

// 抽象工厂：电器工厂
class ElectricApplianceFactory {
public:
    virtual TV* CreateTV() = 0; // 抽象创建方法
    virtual AirConditioner* CreateAirConditioner() = 0; // 抽象创建方法
    virtual ~ElectricApplianceFactory() = default; // 虚析构函数
};

// 具体工厂1：海尔工厂
class HaierFactory : public ElectricApplianceFactory {
public:
    TV* CreateTV() override {
        return new HaierTV();
    }
    AirConditioner* CreateAirConditioner() override {
        return new HaierAirConditioner();
    }
};

// 具体工厂2：TCL工厂
class TCLFactory : public ElectricApplianceFactory {
public:
    TV* CreateTV() override {
        return new TCLTV();
    }
    AirConditioner* CreateAirConditioner() override {
        return new TCLAirConditioner();
    }
};

// 客户端调用
int main() {
    // 1. 使用海尔工厂
    ElectricApplianceFactory* haierFactory = new HaierFactory();
    haierFactory->CreateTV()->ShowInfo();
    haierFactory->CreateAirConditioner()->ShowInfo();

    // 2. 切换为TCL工厂
    ElectricApplianceFactory* tclFactory = new TCLFactory();
    tclFactory->CreateTV()->ShowInfo();
    tclFactory->CreateAirConditioner()->ShowInfo();

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

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

纯C语言无面向对象特性，通过“结构体嵌套+函数指针”模拟抽象接口与继承，将产品行为和工厂创建逻辑封装为函数指针，实现类似多态的效果，适合底层嵌入式开发场景。

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

// 抽象产品1：电视机（结构体+函数指针模拟抽象接口）
typedef struct TV {
    void (*ShowInfo)(struct TV*); // 展示产品信息的函数指针
} TV;

// 抽象产品2：空调（结构体+函数指针模拟抽象接口）
typedef struct AirConditioner {
    void (*ShowInfo)(struct AirConditioner*); // 展示产品信息的函数指针
} AirConditioner;

// 具体产品1-1：海尔电视机（嵌套TV结构体，模拟继承）
typedef struct HaierTV {
    TV tv;
} HaierTV;

// 海尔电视机的具体实现
void HaierTV_ShowInfo(TV* tv) {
    printf("【海尔电视机】- 智能4K，节能护眼\n");
}

// 具体产品1-2：海尔空调（嵌套AirConditioner结构体，模拟继承）
typedef struct HaierAirConditioner {
    AirConditioner ac;
} HaierAirConditioner;

// 海尔空调的具体实现
void HaierAirConditioner_ShowInfo(AirConditioner* ac) {
    printf("【海尔空调】- 一级能效，静音节能\n");
}

// 具体产品2-1：TCL电视机（嵌套TV结构体，模拟继承）
typedef struct TCLTV {
    TV tv;
} TCLTV;

// TCL电视机的具体实现
void TCLTV_ShowInfo(TV* tv) {
    printf("【TCL电视机】- 量子点屏幕，高刷清晰\n");
}

// 具体产品2-2：TCL空调（嵌套AirConditioner结构体，模拟继承）
typedef struct TCLAirConditioner {
    AirConditioner ac;
} TCLAirConditioner;

// TCL空调的具体实现
void TCLAirConditioner_ShowInfo(AirConditioner* ac) {
    printf("【TCL空调】- 快速制冷，智能控温\n");
}

// 抽象工厂：电器工厂（结构体+函数指针模拟抽象接口）
typedef struct ElectricApplianceFactory {
    TV* (*CreateTV)(struct ElectricApplianceFactory*); // 创建电视机
    AirConditioner* (*CreateAirConditioner)(struct ElectricApplianceFactory*); // 创建空调
} ElectricApplianceFactory;

// 具体工厂1：海尔工厂（嵌套电器工厂结构体，模拟继承）
typedef struct HaierFactory {
    ElectricApplianceFactory factory;
} HaierFactory;

// 海尔工厂创建电视机
TV* HaierFactory_CreateTV(ElectricApplianceFactory* factory) {
    HaierTV* haierTV = (HaierTV*)malloc(sizeof(HaierTV));
    haierTV->tv.ShowInfo = HaierTV_ShowInfo; // 绑定函数指针
    return (TV*)haierTV;
}

// 海尔工厂创建空调
AirConditioner* HaierFactory_CreateAirConditioner(ElectricApplianceFactory* factory) {
    HaierAirConditioner* haierAC = (HaierAirConditioner*)malloc(sizeof(HaierAirConditioner));
    haierAC->ac.ShowInfo = HaierAirConditioner_ShowInfo; // 绑定函数指针
    return (AirConditioner*)haierAC;
}

// 具体工厂2：TCL工厂（嵌套电器工厂结构体，模拟继承）
typedef struct TCLFactory {
    ElectricApplianceFactory factory;
} TCLFactory;

// TCL工厂创建电视机
TV* TCLFactory_CreateTV(ElectricApplianceFactory* factory) {
    TCLTV* tclTV = (TCLTV*)malloc(sizeof(TCLTV));
    tclTV->tv.ShowInfo = TCLTV_ShowInfo; // 绑定函数指针
    return (TV*)tclTV;
}

// TCL工厂创建空调
AirConditioner* TCLFactory_CreateAirConditioner(ElectricApplianceFactory* factory) {
    TCLAirConditioner* tclAC = (TCLAirConditioner*)malloc(sizeof(TCLAirConditioner));
    tclAC->ac.ShowInfo = TCLAirConditioner_ShowInfo; // 绑定函数指针
    return (AirConditioner*)tclAC;
}

// 客户端调用
int main() {
    // 1. 初始化海尔工厂，获取海尔产品族
    HaierFactory haierFactory;
    haierFactory.factory.CreateTV = HaierFactory_CreateTV;
    haierFactory.factory.CreateAirConditioner = HaierFactory_CreateAirConditioner;
    
    TV* haierTV = haierFactory.factory.CreateTV((ElectricApplianceFactory*)&haierFactory);
    haierTV->ShowInfo(haierTV);
    AirConditioner* haierAC = haierFactory.factory.CreateAirConditioner((ElectricApplianceFactory*)&haierFactory);
    haierAC->ShowInfo(haierAC);

    // 2. 初始化TCL工厂，获取TCL产品族
    TCLFactory tclFactory;
    tclFactory.factory.CreateTV = TCLFactory_CreateTV;
    tclFactory.factory.CreateAirConditioner = TCLFactory_CreateAirConditioner;
    
    TV* tclTV = tclFactory.factory.CreateTV((ElectricApplianceFactory*)&tclFactory);
    tclTV->ShowInfo(tclTV);
    AirConditioner* tclAC = tclFactory.factory.CreateAirConditioner((ElectricApplianceFactory*)&tclFactory);
    tclAC->ShowInfo(tclAC);

    // 释放内存，避免泄漏
    free(haierTV);
    free(haierAC);
    free(tclTV);
    free(tclAC);
    return 0;
}

三、抽象工厂模式的优缺点

抽象工厂模式是为复杂产品族场景设计的，其优势与劣势均源于“产品族的标准化管理”，需结合实际场景权衡使用。

3.1 核心优点

解耦创建与使用：客户端仅面向抽象接口编程，无需关注具体产品的创建逻辑、实现细节，降低代码耦合度，提升系统可维护性。
统一管理产品族：同一具体工厂负责生产一组关联产品，确保产品间的兼容性，避免客户端因误用不同产品族的产品而出现问题。
支持产品族扩展：新增产品族时，仅需新增具体工厂和对应具体产品，无需修改原有抽象工厂、已有工厂及客户端代码，完美契合开闭原则。
切换产品族便捷：客户端切换产品族时，仅需替换具体工厂实例，无需修改其他业务逻辑，提升系统的灵活性和适配性。

3.2 主要缺点

产品等级扩展困难：新增产品等级（如在电视机、空调外新增冰箱）时，需修改抽象工厂和所有具体工厂的接口，违反开闭原则，扩展成本高。
系统复杂度提升：多产品族、多产品等级场景下，会产生大量的工厂类和产品类，增加代码量和维护成本，降低系统可读性。
产品族约束严格：系统默认“一次仅消费一个产品族”，若需同时使用多个产品族的产品，需额外处理，灵活性受限。

四、使用场景

抽象工厂模式适合“多产品族、多产品等级，且产品族需统一管理”的场景，具体应用如下：

跨环境/跨平台组件开发：如跨操作系统的UI组件（Windows/Linux/macOS下的按钮、输入框、弹窗），每个操作系统对应一个产品族，同一组件对应一个产品等级，通过抽象工厂统一创建，确保组件在不同环境下的兼容性。
品牌化产品系列管理：如电器、汽车等品牌化产品，每个品牌对应一个产品族，每个产品类型（如电视机、空调）对应一个产品等级，通过抽象工厂实现品牌产品的标准化生产。
数据源/框架切换场景：如数据库访问框架（SQL Server/MySQL/Oracle），每种数据库对应一个产品族，数据库连接、命令、适配器对应不同产品等级，切换数据源时仅需替换具体工厂。
复杂产品关联场景：当系统中的产品存在强关联关系，需确保同一产品族的产品协同工作（如分布式系统中的服务注册、配置中心、日志组件），抽象工厂可统一管理这些关联产品的创建。

注意：若仅需创建单等级产品，优先使用工厂方法模式；若产品等级频繁变化，不建议使用抽象工厂模式；若产品族固定、产品等级稳定，抽象工厂模式是最优选择。

五、总结

抽象工厂模式的核心是“对产品族的抽象与封装”，它在工厂方法模式的基础上，进一步解决了多等级产品的创建与管理问题，其设计思想是“面向抽象编程，屏蔽具体实现”，最终实现系统的解耦与扩展。

从多语言实现来看，尽管各语言的语法特性差异显著，但核心逻辑高度一致：

面向对象语言（C#、Python、Golang、C++）：通过接口/抽象类定义规范，结合继承/结构体实现具体逻辑，利用多态特性实现产品族的灵活切换，贴合模式的经典设计。
纯C语言：通过结构体嵌套+函数指针模拟面向对象的继承与多态，核心是封装行为与创建逻辑，满足底层开发的无面向对象特性限制的需求。

在实际开发中，选择抽象工厂模式的关键的是“判断系统是否存在稳定的产品族和产品等级”。其核心价值在于提升系统的可扩展性和可维护性，但需避免过度设计——若系统产品结构简单、无需扩展产品族，工厂方法模式或简单工厂模式更简洁高效。只有当系统需要管理多组关联产品、且产品族需灵活扩展时，抽象工厂模式才能发挥其最大价值。