设计模式 - Bridge模式（桥梁模式）

作用：

将抽象部分与它的实现部分分离，使它们都可以独立地变化。

Bridge模式中存在三个核心概念：

　　1.抽象层：对实现层的上层处理或者上层调用。
　　2.实现层：对抽象层的处理或者调用，施以回应。具体实现抽象层的各种方法。
　　3.脱耦

　　实际上，Bridge就是通过抽象层与实现层的分离，来实现脱耦的目的的。

 

UML结构图：

 

 左边为抽象层，右边为实现层。他们之间的“复合”关系即为Bridge。

 

 

抽象基类：

1)Abstraction:某个抽象类,它的实现方式由Implementor完成.

2)Implementor:实现类的抽象基类,定义了实现Abastraction的基本操作,而它的派生类实现这些接口.

接口函数：

1)Implementor::OperationImpl:定义了为实现Abstraction需要的基本操作,由Implementor的派生类实现之,而在Abstraction::Operation函数中根据不同的指针多态调用这个函数.

解析:

Bridge用于将表示和实现解耦,两者可以独立的变化.在Abstraction类中维护一个Implementor类指针,需要采用不同的实现方式的时候只需要传入不同的Implementor派生类就可以了.Bridge的实现方式其实和Builde十分的相近,可以这么说:本质上是一样的,只是封装的东西不一样罢了.两者的实现都有如下的共同点:抽象出来一个基类,这个基类里面定义了共有的一些行为,形成接口函数(对接口编程而不是对实现编程),这个接口函数在Buildier中是BuildePart函数在Bridge中是OperationImpl 函数;其次,聚合一个基类的指针,如Builder模式中Director类聚合了一个Builder基类的指针,而Brige模式中Abstraction类聚合了一个Implementor基类的指针(优先采用聚合而不是继承);而在使用的时候,都把对这个类的使用封装在一个函数中,在Bridge中是封装在Director::Construct函数中,因为装配不同部分的过程是一致的,而在Bridge模式中则是封装在Abstraction::Operation函数中,在这个函数中调用对应的Implementor::OperationImpl函数.就两个模式而言,Builder封装了不同的生成组成部分的方式,而Bridge封装了不同的实现方式.因此,如果以一些最基本的面向对象的设计原则来分析这些模式的实现的话,还是可以看到很多共同的地方的. 

 

 

在什么情况下应当使用桥梁模式：

　　1.如果一个系统需要在构件的抽象层和实现层之间增加更多的灵活性，避免在两个层次之间建立静态的联系。

　　2.设计要求实现层的任何改变不应当影响客户端，或者说实现层的改变对客户端是完全透明的。

　　3.一个构件有多于一个的抽象层实例和实现层实例，系统需要它们之间进行动态耦合。

　　4.虽然在系统中使用继承是没有问题的，但是由于抽象层和实现层需要独立变化，设计要求需要独立管理这两者。

 

 

代码实现：

 

Bridge.h

 1 
 2  #ifndef BRIDEG_H
 3  #define  BRIDEG_H
 4 
 5  class  Implementor;
 6 
 7  //  维护一个Implementor类的指针
 8  class  Abstraction
 9  {
10  public :
11      Abstraction(Implementor *  pImplementor);
12       virtual   ~ Abstraction();
13 
14       void  Operation();
15 
16  protected :
17      Implementor *  m_pImplementor;
18  };
19 
20  //  为实现Abstraction定义的抽象基类,定义了实现的接口函数
21  class  Implementor
22  {
23  public :
24      Implementor(){}
25       virtual   ~ Implementor(){}
26 
27       virtual   void  OperationImpl()  =   0 ;
28  };
29 
30  //  继承自Implementor,是Implementor的不同实现之一
31  class  ConcreateImplementorA
32      :  public  Implementor
33  {
34  public :
35      ConcreateImplementorA(){}
36       virtual   ~ ConcreateImplementorA(){}
37 
38       virtual   void  OperationImpl();
39  };
40 
41  //  继承自Implementor,是Implementor的不同实现之一
42  class  ConcreateImplementorB
43      :  public  Implementor
44  {
45  public :
46      ConcreateImplementorB(){}
47       virtual   ~ ConcreateImplementorB(){}
48 
49       virtual   void  OperationImpl();
50  };
51 
52  #endif

 

Bridge.cpp

 1 
 2  #include  " Brige.h "
 3  #include  < iostream >
 4 
 5  void  ConcreateImplementorA::OperationImpl()
 6  {
 7      std::cout  <<   " Implementation by ConcreateImplementorA\n " ;
 8  }
 9 
10  void  ConcreateImplementorB::OperationImpl()
11  {
12      std::cout  <<   " Implementation by ConcreateImplementorB\n " ;
13  }
14 
15  Abstraction::Abstraction(Implementor *  pImplementor)
16      : m_pImplementor(pImplementor)
17  {
18  }
19 
20  Abstraction:: ~ Abstraction()
21  {
22      delete m_pImplementor;
23      m_pImplementor  =  NULL;
24  }
25 
26  void  Abstraction::Operation()
27  {
28      m_pImplementor -> OperationImpl();
29  }

 

 

Main.cpp

 1  #include  " Brige.h "
 2  #include  < stdlib.h >
 3  #include  < stdio.h >
 4  int  main()
 5  {
 6      ConcreateImplementorA  * pImplA  =   new  ConcreateImplementorA();
 7      Abstraction  * pAbstraction1  =   new  Abstraction(pImplA);
 8      pAbstraction1 -> Operation();
 9 
10      ConcreateImplementorB  * pImplB  =   new  ConcreateImplementorB();
11      Abstraction  * pAbstraction2  =   new  Abstraction(pImplB);
12      pAbstraction2 -> Operation();
13 
14      delete pAbstraction1;
15      delete pAbstraction2;
16 
17      system( " pause " );
18 
19       return   0 ;
20  }