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

有一个广告召回系统，输入用户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();
}

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