适配器模式（Adapter Pattern）

本节我们开始学结构型设计模式中的适配器模式。

结构型设计模式更多的是关注如何将类和对象组装成较大的结构，同时保持结构的灵活性和高效性。

定义

• 适配器模式(Adapter Pattern)是一种结构型设计模式，它允许不兼容的接口之间能够协同工作。

适配器模式是将一个类的接口转换成客户端期望的另一个接口，就像现实世界中的电源适配器一样，让不同规格的插头能够插入到插座中。

• 我们常用两种实现方式：

  • 类设配器：使用多重继承

  • 对象适配器：使用组合

结构

• Target（目标接口）

  客户端期望的接口

• Adaptee（被适配者）

  需要被适配的现有接口

• Adapter（适配器）

  将Adaptee接口转换为Target接口

• Client（客户端）

  使用Target接口的对象

代码实现

• 例如我们需要对数据的格式进行转换

C++实现

#include <iostream>
#include <string>

// 新系统期望的JSON格式接口
class JsonParser {
public:
    virtual void parseJson(const std::string& json) = 0;
};

// 旧的XML解析器（需要被适配）
class XmlParser {
public:
    void parseXml(const std::string& xml) {
        std::cout << "解析XML: " << xml << std::endl;
    }
};

// 适配器：将JSON转换为XML
class JsonToXmlAdapter : public JsonParser {
private:
    XmlParser xmlParser;
    
public:
    void parseJson(const std::string& json) override {
        std::string xml = convertJsonToXml(json);
        xmlParser.parseXml(xml);
    }
    
private:
    std::string convertJsonToXml(const std::string& json) {
        return "<data>" + json + "</data>";  // 简化的转换
    }
};

// 使用
int main() {
    JsonToXmlAdapter adapter;
    adapter.parseJson("{\"name\":\"John\",\"age\":30}");
    return 0;
}

数据格式转换例子中的角色分析

1. Target（目标接口）

class JsonParser {
public:
    virtual void parseJson(const std::string& json) = 0;  // ← 目标接口
};

2. Adaptee（被适配者）

class XmlParser {
public:
    void parseXml(const std::string& xml) {  // ← 需要被适配的方法
        std::cout << "解析XML: " << xml << std::endl;
    }
};

3. Adapter（适配器）

class JsonToXmlAdapter : public JsonParser {  // ← 实现目标接口
private:
    XmlParser xmlParser;  // ← 包含被适配者
    
public:
    void parseJson(const std::string& json) override {  // ← 适配逻辑
        std::string xml = convertJsonToXml(json);  // ← 转换逻辑
        xmlParser.parseXml(xml);  // ← 调用被适配者
    }
};

4. Client（客户端）

int main() {
    JsonToXmlAdapter adapter;  // ← 客户端使用适配器
    adapter.parseJson("{\"name\":\"John\"}");  // ← 调用目标接口
    return 0;
}

C#实现

using System;

// JSON接口
public interface IJsonParser {
    void ParseJson(string json);
}

// XML解析器
public class XmlParser {
    public void ParseXml(string xml) {
        Console.WriteLine($"解析XML: {xml}");
    }
}

// 适配器
public class JsonToXmlAdapter : IJsonParser {
    private XmlParser xmlParser = new XmlParser();
    
    public void ParseJson(string json) {
        string xml = ConvertJsonToXml(json);
        xmlParser.ParseXml(xml);
    }
    
    private string ConvertJsonToXml(string json) {
        return "<data>" + json + "</data>";
    }
}

class Program {
    static void Main(string[] args) {
        JsonToXmlAdapter adapter = new JsonToXmlAdapter();
        adapter.ParseJson("{\"name\":\"John\",\"age\":30}");
    }
}

1. Target（目标接口）

public interface IJsonParser {
    void ParseJson(string json);  // ← 目标接口
}

• 角色: Target
• 职责: 定义JSON解析接口

2. Adaptee（被适配者）

public class XmlParser {
    public void ParseXml(string xml) {  // ← 需要被适配的方法
        Console.WriteLine($"解析XML: {xml}");
    }
}

• 角色: Adaptee
• 职责: 提供XML解析功能

3. Adapter（适配器）

public class JsonToXmlAdapter : IJsonParser {  // ← 实现目标接口
    private XmlParser xmlParser = new XmlParser();  // ← 包含被适配者
    
    public void ParseJson(string json) {  // ← 适配逻辑
        string xml = ConvertJsonToXml(json);  // ← 转换逻辑
        xmlParser.ParseXml(xml);  // ← 调用被适配者
    }
    
    private string ConvertJsonToXml(string json) {
        return "<data>" + json + "</data>";
    }
}

• 角色: Adapter
• 职责: JSON到XML的转换桥梁

4. Client（客户端）

class Program {
    static void Main(string[] args) {
        JsonToXmlAdapter adapter = new JsonToXmlAdapter();  // ← 客户端使用适配器
        adapter.ParseJson("{\"name\":\"John\",\"age\":30}");  // ← 调用目标接口
    }
}

• 角色: Client
• 职责: 使用JSON解析功能

C# 与 C++ 实现的主要区别

C# 版本的适配器模式由于语言的特性，代码更加简洁清晰，特别是接口的定义和使用更加明确，这有助于更好地理解和维护适配器模式的结构。

核心思想总结

• 适配器模式的核心就是：创建一个中间层（适配器），将不兼容的接口转换为兼容的接口。