这是啥设计模式-适配模式

有一个广告召回系统，输入用户id就可以给用户推荐相应的广告，一开始我们只有布尔检索和向量检索两种方式。

1. 面向接口编程，而非实现

第一点就是定义接口，客户端关注的是接口，对客户端来说，他只关心检索引擎提供出来的接口是什么样子，不在意检索引擎是如何实现的。所以第一点就是抽象出接口。

class Recall {
public:
    virtual ~Recall() = default;
    virtual void recall(std::string uid) = 0;
};

2. 实现接口

我们有两个检索引擎，一个倒排，一个向量，根据接口分别实现这两种召回

// 倒排检索
class InvertRecall : public Recall {
    void recall(std::string uid) override {
        std::cout << uid << ": invert recall\n";
    }
};

// 向量检索
class VectorRecall : public Recall {
    void recall(std::string uid) override {
        std::cout << uid << ": vector recall\n";
    }
};

3. 客户端调用

我们给客户端提供了两种召回方式，客户端其实并不关心的，他只关心接口是什么，通过这个接口他就可以拿到自己想要的结果

Recall* vectorRecall = new InvertRecall(); // 倒排召回
Recall* invertRecall = new VectorRecall(); // 向量召回
invertRecall->recall(uid);
vectorRecall->recall(uid);

我特意把名字写反了，就是为了表示客户端其实并不关心具体的召回方式是什么，谁来都一样，他只关心recall接口，根据recall接口就可以得到自己想要的结果，我们在改进一下

class AggRecall {
private:
    std::vector<std::shared_ptr<Recall>> m_recall;
public:
    void addRecall(const std::shared_ptr<Recall> &recall) {
        m_recall.emplace_back(recall);
    }

    void recall(std::string uid) {
        for (auto &recall: m_recall) {
            recall->recall(uid);
        }
    }
};

4. 新增了三方接口

除了我们自己实现的两种召回方式，还有一些其他的三方召回方式。当然，人家也很专业，也是面向接口编程，同时提供了一种实现方案。

// 三方代码勿动，以so方式提供
class ThirdPartyRecall {
public:
    virtual ~ThirdPartyRecall() = default;

    virtual void process(std::string uid, std::string thirdParty) = 0;
};

class ThirdPartyRecallImp : public ThirdPartyRecall {
public:
    void process(std::string uid, std::string thirdParty) override {
        std::cout << thirdParty << " recall" << std::endl;
    }
};

这个时候客户端实现的AggRecall方案就要发生一些变化了，因此三方的接口名字和参数和我们实现的召回接口不一样，一种想当然的方式就是把所有召回引擎的接口统一，大家都叫recall，或者大家都叫process。

5. 统一接口

三方的召回接口是以so的方式提供的，我们想要修改代码也不现实了，一种愚蠢的方法就是修改自己的recall接口，但是你有没有想过，如果又有一个其他三方接口不一致怎么办呢？

// 三方代码勿动，以so方式提供
class GoogleRecall {
public:
    virtual ~GoogleRecall() = default;
    virtual void search(std::string uid) = 0;
};

class GoogleRecallImp : public GoogleRecall {
public:
    void search(std::string uid) override {
        std::cout << uid << ": google search" << std::endl;
    }
};

6. 适配器

现在的问题就是如何把这些接口统一了，其实很简单，我们把三方的接口包一层不久可以了吗，或者说重命名不就可以了吗

class ThirdPartyAdapter : public Recall {
private:
    std::shared_ptr<ThirdPartyRecallImp> thirdPartyRecall;
public:
    explicit ThirdPartyAdapter(std::shared_ptr<ThirdPartyRecallImp> recall) : thirdPartyRecall(std::move(recall)) {}

    void recall(std::string uid) override {
        thirdPartyRecall->process(uid, "baidu");
    }
};

同样可以对其他的三方接口进行转换

class GoogleAdapter : public Recall {
private:
    std::shared_ptr<GoogleRecallImp> googleRecall;
public:
    explicit ThirdPartyAdapter(std::shared_ptr<GoogleRecallImp> recall) : googleRecall(std::move(recall)) {}

    void search(std::string uid) override {
        googleRecall->search(uid);
    }
};

就是这么简单，我们把process函数用一个recall函数包装起来，这样客户端在调用的时候依然调用的是recall函数，而且也继承了Recall接口

int main() {
    auto invertRecall = std::make_shared<InvertRecall>();
    auto vectorRecall = std::make_shared<VectorRecall>();
    auto thirdRecall = std::make_shared<ThirdPartyRecallImp>();
    auto googleRecall = std::make_shared<ThirdPartyAdapter>(thirdRecall);
    auto aggRecall = std::make_shared<AggRecall>();
    aggRecall->addRecall(invertRecall);
    aggRecall->addRecall(vectorRecall);
    aggRecall->addRecall(googleRecall);
    aggRecall->doRecall();
}

这个呢，就叫适配器，把其他接口转换成我们想要的接口。