适配器模式

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

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