设计模式17-适配模式

动机

• 在软件系统中由于应用环境的变化常常需要将一些现存的对象。放到新的环境中去应用。但是新环境要求的接口是这些现存对象所不满足的。
• 那么这种情况下如何应对这种迁移的变化？如何既能利用现有对象的良好实现用了满足新的应用环境所要求的接口。

适配器模式是解决两个接口不兼容的问题。通过适配器模式，我们可以将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。适配器模式主要用于以下场景：

• 当你想使用一个已经存在的类，但它的接口不符合你的需求时。
• 当你想创建一个可以重用的类，该类可以和不兼容的接口协同工作时。
• 当你想使用一些现有的子类，但是不能进行子类化来匹配接口时，因为这会导致每个子类需要调整。

定义与结构

定义

• 适配器模式将一个类的接口转换成客户希望的另一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

适配器模式包含以下主要角色：

1. 目标（Target）接口：定义客户所需的接口。
2. 适配者（Adaptee）类：定义一个已经存在的接口，这个接口需要适配。
3. 适配器（Adapter）类：将适配者接口转换成目标接口，使得客户端可以通过目标接口与适配者进行通信。

适配器模式有两种实现方式：

• 类适配器（Class Adapter）：使用多重继承实现适配。
• 对象适配器（Object Adapter）：使用组合实现适配。

类适配器模式UML图：

----------------      ----------------      -----------------
|      Target     |<---|   Adapter    |<|  Adaptee         |
|----------------|   |----------------|   |---------------|
|+request()      |   |+request()      |   |+specificRequest|
-----------------      -----------------      ---------------

对象适配器模式UML图：

----------------      ----------------      ----------------
|      Target     |<---|   Adapter    |<| Adaptee          |
|----------------|   |----------------|   |----------------|
|+request()      |   |+request()      |   |+specificRequest|
-----------------   | -adaptee: Adaptee|   -----------------
                   -------------------

C++代码推导

类适配器模式：

#include <iostream>

// 目标接口
class Target {
public:
    virtual void request() = 0;
    virtual ~Target() = default;
};

// 适配者类
class Adaptee {
public:
    void specificRequest() {
        std::cout << "Adaptee specific request." << std::endl;
    }
};

// 类适配器
class Adapter : public Target, private Adaptee {
public:
    void request() override {
        specificRequest();
    }
};

// 客户端代码
int main() {
    Target* target = new Adapter();
    target->request(); // 调用适配器的方法
    delete target;
    return 0;
}

对象适配器模式：

#include <iostream>

// 目标接口
class Target {
public:
    virtual void request() = 0;
    virtual ~Target() = default;
};

// 适配者类
class Adaptee {
public:
    void specificRequest() {
        std::cout << "Adaptee specific request." << std::endl;
    }
};

// 对象适配器
class Adapter : public Target {
private:
    Adaptee* adaptee;

public:
    Adapter(Adaptee* adaptee) : adaptee(adaptee) {}

    void request() override {
        adaptee->specificRequest();
    }
};

// 客户端代码
int main() {
    Adaptee* adaptee = new Adaptee();
    Target* target = new Adapter(adaptee);
    target->request(); // 调用适配器的方法
    delete target;
    delete adaptee;
    return 0;
}

总结

• 适配器模式主要应用于希望服用一些现存的类可用于复用环境要求不一致的情况。在遗留代码复用嗯类库迁移等方面非常常用。

• 世界模式书中定义了两种适配器模式的实现结构：对象适配器和类适配器。但是类适配器采用多继承的实现方式。一般不推荐使用。对象适配器采用对象组合的方式更符合松耦合的设计理念。

• 适配器模式可以实现的非常灵活不必拘泥于设计模式书中定义的两种结构。例如完全可以将适配器模式中的现存对象作为新的接口方法参数，来达到适配的目的。

优点：

1. 单一职责原则：可以将接口或数据转换代码从原始类中分离出来。
2. 开闭原则：无需修改客户端代码即可引入新的适配器类。
3. 灵活性高：类适配器使用多重继承，可以适配多个适配者类。对象适配器使用组合，可以在运行时对适配者进行替换。

缺点：

1. 类适配器的缺点：
   • 不支持适配多个适配者类，因为C++不支持多继承多个实现类。
   • 破坏了Adaptee类和Adapter类的独立性，因为适配器继承自适配者。
2. 对象适配器的缺点：
   • 在某些情况下，可能需要多次调用适配者的方法，导致性能开销较大。

应用

适配器模式在实际应用中非常广泛，常见的应用场景包括：

1. 使用遗留代码库：当你想使用一个现有的类，但它的接口不符合你的需求时，可以使用适配器模式进行适配。
2. 与第三方库集成：当你想使用第三方库，但它的接口与你的代码不兼容时，可以使用适配器模式进行适配。
3. 处理多种接口：当你需要创建一个可以与多个不兼容接口进行交互的类时，可以使用适配器模式进行适配。

具体应用示例

以下是一个适配器模式的具体应用示例：将一个旧的日志系统适配到新的日志系统中。

旧日志系统：

#include <iostream>

class OldLogger {
public:
    void oldLog(const std::string& message) {
        std::cout << "OldLogger: " << message << std::endl;
    }
};

新日志系统接口：

class NewLogger {
public:
    virtual void log(const std::string& message) = 0;
    virtual ~NewLogger() = default;
};

适配器类：

class LoggerAdapter : public NewLogger {
private:
    OldLogger* oldLogger;

public:
    LoggerAdapter(OldLogger* logger) : oldLogger(logger) {}

    void log(const std::string& message) override {
        oldLogger->oldLog(message);
    }
};

客户端代码：

int main() {
    OldLogger* oldLogger = new OldLogger();
    NewLogger* logger = new LoggerAdapter(oldLogger);

    logger->log("This is a log message."); // 使用适配器进行日志记录

    delete logger;
    delete oldLogger;
    return 0;
}

通过上述示例，我们将旧的日志系统适配到新的日志系统接口中，使得客户端代码可以无缝使用旧的日志系统，同时保持代码的灵活性和可维护性。这就是适配器模式在实际开发中的典型应用。