设计模式探秘-26-桥梁模式

桥梁模式的学习与实践

模式定义

桥梁模式也叫桥接模式,其定义:将抽象和实现解耦,使得两者可以独立地变化。

类图

  1. Abstraction 抽象化角色 主要职责是定义该角色的行为,同时保存一个对实现化角色的引用,该角色是一般为抽象类。
  2. Implementor 实现化角色 接口或者抽象类,定义角色必须的行为和属性。
  3. RefinedAbstraction 修正抽象化角色 引用实现化角色对抽象化角色进行修正。
  4. ConcreteImplementor 具体具现化角色 实现接口或者抽象类定义的方法和属性。

抽象角色引用实现角色,或者说抽象角色的部分实现是由实现角色完成的。
桥梁模式使用类间的聚合关系、继承、覆写等常用功能提供了非常清晰、稳定的架构。

优点

  1. 抽象和实现分离 完全是为了解决继承的缺点而提出的设计模式。该模式下实现可以不受抽象的约束,不用再绑定在一个固定的抽象层次上。
  2. 优秀的扩充能力。
  3. 实现细节对用户透明 客户不关心细节的实现,已经由抽象层通过聚合关系完成了封装。

缺点

使用场景

  1. 不希望或不适用使用继承的场景
  2. 接口或抽象类不稳定的场景
  3. 重用性要求高的场景

注意事项

使用桥梁模式主要考虑如何拆分抽象和实现,并不是一涉及继承就要考虑使用该模式,桥梁模式的意图还是对变化的封装,尽量把可能变化的因素封装到最细、最小的逻辑单元中,避免风险扩散。当系统设计时发现类的继承有N层时,可以考虑使用桥梁模式。

扩展

实践

Bridge是设计模式中比较复杂和难理解的模式之一,在OO开发中经常会使用到.使用组合(委托)的方式将抽象和实现彻底地解耦,抽象和实现分别独立的变化,系统的耦合性得到了下降。   
桥梁模式要抽象和实现分离,这里的实现不是指抽象基类中虚函数(接口)的实现,而是指如何去实现用户的需求,通过组合(委托)方式去实现,并不是指通过继承基类、实现基类接口,而是指通过对象组合实现用户的需求。

简单实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#include <iostream>

using namespace std;

//桥梁模式
class AbstractionImp;

class Abstraction
{
public:
virtual ~Abstraction() {};
virtual void Operation() = 0;
protected:
Abstraction() {};
};

class AbstractionImp
{
public:
virtual ~AbstractionImp() {}
virtual void Operation() = 0;
protected:
AbstractionImp() {}
};

void AbstractionImp::Operation()
{
cout<<"IMP"<<__FUNCTION__<<endl;
}


class RefinedAbstraction : public Abstraction
{
public:
RefinedAbstraction(AbstractionImp *imp)
{
m_pImp = imp;
}
~RefinedAbstraction() {}
void Operation()
{
m_pImp->Operation();
}
private:
AbstractionImp *m_pImp;
};

class ConcreteAbstractionImpA : public AbstractionImp
{
public:
ConcreteAbstractionImpA() {}
~ConcreteAbstractionImpA() {}
virtual void Operation()
{
cout<<"A"<<__FUNCTION__<<endl;
}
};

class ConcreteAbstractionImpB : public AbstractionImp
{
public:
ConcreteAbstractionImpB() {}
~ConcreteAbstractionImpB() {}
virtual void Operation()
{
cout<<"B"<<__FUNCTION__<<endl;
}
};

int main()
{
AbstractionImp *impa = new ConcreteAbstractionImpA();
Abstraction *absa = new RefinedAbstraction(impa);
absa->Operation();

AbstractionImp *impb = new ConcreteAbstractionImpB();
Abstraction *absb = new RefinedAbstraction(impb);
absb->Operation();
return 0;
}

参考资料

  1. 设计模式之禅
  2. GoF+23种设计模式解析