动机

由于某些类型的固有实现逻辑，使得它们具有两个变化的维度，乃至多个维度的变化。

如何应对这种“多维度的变化”？如何利用面向对象技术来使得类型可以轻松地沿着两个乃至多个方向变化，而不引入额外的复杂度？

代码：通信模块

第一个版本

  1. Messager通信类，是抽象类，表示通信
  2. 继承与Messager的平台具体实现类：PCMessagerBase、MobileMessagerBase

  3. 继承PCMessagerBase的经典版PCMessagerLite、完美版PCMessagerPerfect；继承MobileMessagerBase的经典版MobileMessagerLite、完美版MobileMessagerPerfect ```cpp //////通信 class Messager { public: virtual void Login(string username, string password)=0; virtual void SendMessage(string message)=0; virtual void SendPicture(Image image)=0; //播放声音 virtual void PlaySound()=0; //画图形 virtual void DrawShape()=0; //写数据 virtual void WriteText()=0; //连接网络 virtual void Connect()=0;

    virtual ~Messager(){} };

//////平台实现：不同平台中，播放声音、在界面上画图形的实现可能不同 //PC平台 class PCMessagerBase : public Messager{ public: virtual void PlaySound(){ //** } virtual void DrawShape(){ //** } virtual void WriteText(){ //** } virtual void Connect(){ //** } };

//移动版 class MobileMessagerBase : public Messager{ public: virtual void PlaySound(){ //========== } virtual void DrawShape(){ //========== } virtual void WriteText(){ //========== } virtual void Connect(){ //========== } };

//////业务抽象：推出两个版本，经典版和完美版。在里面实现一些函数 //PC的经典版 class PCMessagerLite : public PCMessagerBase { public: virtual void Login(string username, string password){ PCMessagerBase::Connect(); //…….. } virtual void SendMessage(string message){ PCMessagerBase::WriteText(); //…….. } virtual void SendPicture(Image image){ PCMessagerBase::DrawShape(); //…….. } };

//PC的完美版 class PCMessagerPerfect : public PCMessagerBase { public: virtual void Login(string username, string password){ //登录的时候播放一些声音 PCMessagerBase::PlaySound(); //** PCMessagerBase::Connect(); //…….. } virtual void SendMessage(string message){ //发送消息的时候播放一些声音 PCMessagerBase::PlaySound(); //** PCMessagerBase::WriteText(); //…….. } virtual void SendPicture(Image image){ //发送图片的时候，播放一些声音 PCMessagerBase::PlaySound(); //** PCMessagerBase::DrawShape(); //…….. } };

//移动端经典版 class MobileMessagerLite : public MobileMessagerBase { public: virtual void Login(string username, string password){ MobileMessagerBase::Connect(); //…….. } virtual void SendMessage(string message){ MobileMessagerBase::WriteText(); //…….. } virtual void SendPicture(Image image){ MobileMessagerBase::DrawShape(); //…….. } };

//移动端完美版 class MobileMessagerPerfect : public MobileMessagerBase { public: virtual void Login(string username, string password){ MobileMessagerBase::PlaySound(); //** MobileMessagerBase::Connect(); //…….. } virtual void SendMessage(string message){

  1.     MobileMessagerBase::PlaySound();
  2.     //********
  3.     MobileMessagerBase::WriteText();
  4.     //........
  5. }
  6. virtual void SendPicture(Image image){
  8.     MobileMessagerBase::PlaySound();
  9.     //********
  10.     MobileMessagerBase::DrawShape();
  11.     //........
  12. }

};

//使用的时候 void Process(){ //编译时装配 Messager *m = new MobileMessagerPerfect(); }

  1. 如果把平面实现的变化（分支）列为n，把业务抽象的变化（分支）列为m。那么类的数目就有1+n+(m+n)
  3. 不难发现，上面其实还有很多重复的代码。
  4. ```cpp
  5. class PCMessagerPerfect : public PCMessagerBase {
  6. public:
  7.     virtual void Login(string username, string password){
  8.         PCMessagerBase::PlaySound();
  9.         //********
  10.         PCMessagerBase::Connect();
  11.         //........
  12.     }
  13.     //...
  14. };
  16. //移动端完美版
  17. class MobileMessagerPerfect : public MobileMessagerBase {
  18. public:
  19.     virtual void Login(string username, string password){
  20.         MobileMessagerBase::PlaySound();
  21.         //********
  22.         MobileMessagerBase::Connect();
  23.         //........
  24.     }
  25.     //...
  26. };
  1. 第5行-第17行；第7行-第19行是一样的；
  2. 第4行-第16行；第6行-第18行表面上是不一样的，但其实又是一样的，它们是同一样的虚函数

第一次修改：把继承改成组成（继承转组合），然后使用基类指针多态调用

  1. class PCMessagerPerfect {
  2.     PCMessagerBase* messager; //申明成指针，指针才有多态性
  4. public:
  5.     virtual void Login(string username, string password) {
  6.         messager->PlaySound();
  7.         //*****
  8.         messager->Connect();
  9.         //....
  10.     }
  11.     ....
  12. }
  14. class MobileMessagerPerfect {
  15.     MobileMessagerBase* messager;
  17. public:
  18.     virtual void Login(string username, string password) {
  19.         messager->PlaySound();
  20.         //******
  21.         messager->Connect();
  22.         //......
  23.     }
  24. }

第二次修改：PCMessagerBase和MobileMessagerBase又可以申明成同一个基类

  1. class PCMessagerPerfect {
  2.     Messager* messager; //申明成父类，在使用的时候 =new PCMessagerBase()
  4. public:
  5.     virtual void Login(string username, string password) {
  6.         messager->PlaySound();
  7.         //*****
  8.         messager->Connect();
  9.         //....
  10.     }
  11.     ....
  12. }
  14. class MobileMessagerPerfect {
  15.     Messager* messager; //在使用时（即运行的时候） = new MobileMessagerBase
  17. public:
  18.     virtual void Login(string username, string password) {
  19.         messager->PlaySound();
  20.         //******
  21.         messager->Connect();
  22.         //......
  23.     }
  24. }

第三次修改

  1. 发现这两个类其实一模一样，就可以合并成一个了。把PCMessagerPerfect和MobileMessagerPerfect改成MessagerPerfect
  2. 那MessagerLite也是可以如法炮制 ```cpp class MessagerPerfect { Messager* messager; //申明成父类，在使用的时候 =new PCMessagerBase()

public: virtual void Login(string username, string password) { messager->PlaySound(); //* messager->Connect(); //…. } …. }

class MessagerLite{ Messager* messager; public: virtual void Login(string username, string password) { messger->Connect(); //… } //… }

  2. 问题：
  4. 1. `MessagerPerfect::messager = new PCMessagerBase()`是不成立的。因为`PCMessagerBase`还是一个抽象类，PCMessagerBase只override了部分虚函数，还有一些虚函数（Login、SendMessage、SendPicture）没有实现
  5. 1. `MessagerLite`、`MessagerPerfect`也只实现了部分的虚函数，还有虚函数没有实现。所以它们也是抽象类
  7. 原因：Messager中的Login、SendMessger、SendPicture 和 Messager中的PlaySound、DrawShape、WriteText、Connect是两类东西，放在一起是不合适的。应该把它们拆分开。
  9. <a name="a2Mw2"></a>
  10. ### 第二个版本
  11. 把Messager中的Login、SendMessger、SendPicture和Messager中的PlaySound、DrawShape、WriteText、Connect拆分成两个类。<br />其中一个类称之为MessagerImp，是具体的平台实现。
  12. ```cpp
  13. //消息
  14. class Messager{
  15. public:
  16.     virtual void Login(string username, string password)=0;
  17.     virtual void SendMessage(string message)=0;
  18.     virtual void SendPicture(Image image)=0;
  20.     virtual ~Messager(){}
  21. };
  23. //具体的平台实现
  24. class MessagerImp{ 
  25. public:
  26.     virtual void PlaySound()=0;
  27.     virtual void DrawShape()=0;
  28.     virtual void WriteText()=0;
  29.     virtual void Connect()=0;
  31.     virtual MessagerImp(){}
  32. };
  35. //平台实现 n
  36. class PCMessagerImp : public MessagerImp{
  37. public:
  38.     virtual void PlaySound(){
  39.         //**********
  40.     }
  41.     virtual void DrawShape(){
  42.         //**********
  43.     }
  44.     virtual void WriteText(){
  45.         //**********
  46.     }
  47.     virtual void Connect(){
  48.         //**********
  49.     }
  50. };
  51. class MobileMessagerImp : public MessagerImp{
  52. public:
  53.     virtual void PlaySound(){
  54.         //==========
  55.     }
  56.     virtual void DrawShape(){
  57.         //==========
  58.     }
  59.     virtual void WriteText(){
  60.         //==========
  61.     }
  62.     virtual void Connect(){
  63.         //==========
  64.     }
  65. };
  67. //业务抽象
  68. class MessagerLite :public Messager { //经典版
  69.     MessagerImp* messageImp; // 运行时在放入， = new PCMessagerBase()
  70. public:
  72.     virtual void Login(string username, string password){
  74.         messagerImp->Connect();
  75.         //........
  76.     }
  77.     virtual void SendMessage(string message){
  79.         messagerImp->WriteText();
  80.         //........
  81.     }
  82.     virtual void SendPicture(Image image){
  84.         messagerImp->DrawShape();
  85.         //........
  86.     }
  87. };
  89. class MessagerPerfect  :public Messager { //完美版
  90.     MessagerImp* messageImp; //运行时，在赋值。= new MobileMessagerImp
  91. public:
  92.     virtual void Login(string username, string password){
  94.         messagerImp->PlaySound();
  95.         //********
  96.         messagerImp->Connect();
  97.         //........
  98.     }
  99.     virtual void SendMessage(string message){
  101.         messagerImp->PlaySound();
  102.         //********
  103.         messagerImp->WriteText();
  104.         //........
  105.     }
  106.     virtual void SendPicture(Image image){
  108.         messagerImp->PlaySound();
  109.         //********
  110.         messagerImp->DrawShape();
  111.         //........
  112.     }
  113. };
  115. void Process(){
  116.     //运行时装配
  117.     MessagerImp* mImp = new PCMessagerImp();
  118.     Messager *m =new Messager(mImp);
  119. }

第三个版本：桥模式

其实不难看出，MessagerLite、MessagerPerfect还存在冗余代码。它们有着一个相同的成员变量MessagerImp* messageImp。

如果某一个类的多个子类有着共同的字段，我们可以把这个字段往上提一层——马丁·福勒经典重构理论

把MessagerImp* messageImp字段提到Messager类中

  1. class Messager{
  2. protected:
  3.      MessagerImp* messagerImp;
  4.         //将MessagerLite、MessagerPerfect的公共字段提到父类Messager
  5. public:
  6.     virtual void Login(string username, string password)=0;
  7.     virtual void SendMessage(string message)=0;
  8.     virtual void SendPicture(Image image)=0;
  10.     virtual ~Messager(){}
  11. };
  13. //消息函数的接口（到具体平台中再实现）
  14. class MessagerImp{
  15. public:
  16.     virtual void PlaySound()=0;
  17.     virtual void DrawShape()=0;
  18.     virtual void WriteText()=0;
  19.     virtual void Connect()=0;
  21.     virtual MessagerImp(){}
  22. };
  25. //平台实现 n
  26. class PCMessagerImp : public MessagerImp{
  27. public:
  28.     virtual void PlaySound(){
  29.         //**********
  30.     }
  31.     virtual void DrawShape(){
  32.         //**********
  33.     }
  34.     virtual void WriteText(){
  35.         //**********
  36.     }
  37.     virtual void Connect(){
  38.         //**********
  39.     }
  40. };
  41. class MobileMessagerImp : public MessagerImp{
  42. public:
  44.     virtual void PlaySound(){
  45.         //==========
  46.     }
  47.     virtual void DrawShape(){
  48.         //==========
  49.     }
  50.     virtual void WriteText(){
  51.         //==========
  52.     }
  53.     virtual void Connect(){
  54.         //==========
  55.     }
  56. };
  59. //业务抽象 m
  60. //类的数目：1+n+m
  61. class MessagerLite :public Messager {
  62. public:
  63.     virtual void Login(string username, string password){
  64.         messagerImp->Connect();
  65.         //........
  66.     }
  67.     virtual void SendMessage(string message){
  68.         messagerImp->WriteText();
  69.         //........
  70.     }
  71.     virtual void SendPicture(Image image){
  72.         messagerImp->DrawShape();
  73.         //........
  74.     }
  75. };
  77. class MessagerPerfect  :public Messager {
  78. public:
  79.     virtual void Login(string username, string password){
  81.         messagerImp->PlaySound();
  82.         //********
  83.         messagerImp->Connect();
  84.         //........
  85.     }
  86.     virtual void SendMessage(string message){
  88.         messagerImp->PlaySound();
  89.         //********
  90.         messagerImp->WriteText();
  91.         //........
  92.     }
  93.     virtual void SendPicture(Image image){
  95.         messagerImp->PlaySound();
  96.         //********
  97.         messagerImp->DrawShape();
  98.         //........
  99.     }
  100. };
  102. //使用
  103. void Process(){
  104.     //运行时装配（运行时把它们组合在一起）
  105.     MessagerImp* mImp=new PCMessagerImp();
  106.     Messager *m =new Messager(mImp);
  107. }

类的个数变成了1+n+m。但是运行时，还是有n*m的功能，它们可以相互交叉组合。

总结

反过来思考。其实，你在第一个版本中，在一个类（即Messager）中，放了两组责任不同的函数（如下），它们是两种不同的变化方向，一个是平台实现，一个是业务方向。

  1. Login、SendMessage、SendPicture => 业务抽象，即有经典版、有完美版
  2. PlaySound、DrawShape、WriteText、Connect => 平台实现，即有移动端、有PC端

这两个不同变化的方向，使子类往不同的方向变化，会导致类的暴增。所以，就不应该把它们放在一个类里，这也是单一职责所倡导的。

模式定义

将抽象部分（业务功能）与实现部分（平台实现）分离，使它们都可以独立地变化。——《设计模式》GOF

结构

image.png

  1. Abstraction => Messager
  2. Implementor => MessagerImp
  3. RefinedAbstraction => MessagerLite、MessagerPerfect，即抽象类的变化
  4. ConcreteImplementorA、ConcreteImplementorB => PCMessagerImp、MobileMessagerImp，即具体的实现类，比如PC平台、移动端

两个方向分开变化，而不是像在第一个版本中，搅在一起变化。

要点总结

要点一：Bridge模式使用“对象间的组合关系”解耦了抽象和实现之间固有的绑定关系，使得抽象和实现可以沿着各自的维度来变化。所谓抽象和实现沿着各自维度的变化，就是“子类化”它们。

要点二：Bridge模式有时候类似于多继承方案，但是多继承方案往往违背单一职责原则（即一个类只有一个变化的原因），复用性比较差。Bridge模式是比多继承方案更好的解决方案

要点三：Bridge模式的应用一般在“有两个非常强的变化维度”上。有时一个类也有多于两个的变化维度，这时可以使用Bridge的扩展模式

  • Bridge其实提供了一种思路，把属于其他变化维度的东西通过组合的方式合在一起。打包一个基类，然后用一个抽象指针指向它。
  • 如果有多个变化维度，可以一个维度一个抽象指针 ```cpp class Messager{ protected: MessagerImp messagerImp; //第二个变化维度 //如果还有别的变化维度，可以再填加抽象指针 MessagerImp2 messagerImp2; //第三个变化维度 //….

public: //Messager自己本身是一个变化维度 => 第一个变化维度 virtual void Login(string username, string password)=0; virtual void SendMessage(string message)=0; virtual void SendPicture(Image image)=0;

  1. virtual ~Messager(){}

}; ```