C++设计模式之桥接模式(bridge)(结构型)

设想如果要绘制矩形、圆形、椭圆、正方形，我们至少需要4个形状类，但是如果绘制的图形需要具有不同的颜色，如红色、绿色、蓝色等，此时至少有如下两种设计方案：

• 第一种设计方案是为每一种形状都提供一套各种颜色的版本。

• 第二种设计方案是根据实际需要对形状和颜色进行组合。

假设我们需要对每种图形需要10种颜色，使用方案一，那么总共需要4种图形*10种颜色=40个类。如果我们使用方案二需要4种图形+10种颜色=14个类。为什么会出现这么大的差别呢？仔细分析就会发现，画图的时候不仅对图形有要求，而且还对颜色有要求，也就是说有两个引起变化的点或者说有两个变化的维度。方案一把图形和颜色直接绑定在一起了，他们二者完全融合（耦合）在一起了，他们的属性从生产出来就已经固化了（是静态的），不能被改变了。 而方案二对图形和颜色来说是毫无关系（解耦），二者互不相干，只有在使用的时候用户决定用什么颜色画什么图形（动态设置），这个时候图形和颜色才动态发生关系。

对于这种有两个变化维度（即两个变化的原因）的系统，采用方案二来进行设计系统中类的个数更少，且系统扩展更为方便。设计方案二即是桥接模式的应用。桥接模式将继承关系转换为关联关系，从而降低了类与类之间的耦合，减少了代码编写量。

一、 模式定义

桥连模式：将抽象部分与实现部分分离，使它们都可以独立的变化。它是一种结构性模式，又称柄体（Handle and body）模式或者接口（Interface）模式。

二 、模式分析 

当一个抽象可能有多个实现时，通常用继承来协调他们。抽象类的定义对该抽象的接口。而具体的子类则用不同的方式加以实现，但是此方法有时不够灵活。继承机制将抽象部分与他的视线部分固定在一起，使得难以对抽象部分和实现部分独立地进行修改、扩充和充用。

理解桥接模式，重点需要理解如何将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化。

•抽象化：抽象化就是忽略一些信息，把不同的实体当作同样的实体对待。在面向对象中，将对象的共同性质抽取出来形成类的过程即为抽象化的过程。

•实现化：针对抽象化给出的具体实现，就是实现化，抽象化与实现化是一对互逆的概念，实现化产生的对象比抽象化更具体，是对抽象化事物的进一步具体化的产物。

•脱耦：脱耦就是将抽象化和实现化之间的耦合解脱开，或者说是将它们之间的强关联改换成弱关联，将两个角色之间的继承关系改为关联关系。桥接模式中的所谓脱耦，就是指在一个软件系统的抽象化和实现化之间使用关联关系（组合或者聚合关系）而不是继承关系，从而使两者可以相对独立地变化，这就是桥接模式的用意。

三、 ULM图

1、Abstraction（抽象类）：

用于定义抽象类的接口，它一般是抽象类而不是接口，其中定义了一个Implementor（实现类接口）类型的对象并可以维护该对象，它与Implementor之间具有关联关系，它既可以包含抽象业务方法，也可以包含具体业务方法。

2、RefinedAbstraction（扩充抽象类）：

扩充由Abstraction定义的接口，通常情况下它不再是抽象类而是具体类，它实现了在Abstraction中声明的抽象业务方法，在RefinedAbstraction中可以调用在Implementor中定义的业务方法。

3、Implementor（实现类接口）：

定义实现类的接口，这个接口不一定要与Abstraction的接口完全一致，事实上这两个接口可以完全不同，一般而言，Implementor接口仅提供基本操作，而Abstraction定义的接口可能会做更多更复杂的操作。Implementor接口对这些基本操作进行了声明，而具体实现交给其子类。通过关联关系，在Abstraction中不仅拥有自己的方法，还可以调用到Implementor中定义的方法，使用关联关系来替代继承关系。

4、ConcreteImplementor（具体实现类）：

具体实现Implementor接口，在不同的ConcreteImplementor中提供基本操作的不同实现，在程序运行时，ConcreteImplementor对象将替换其父类对象，提供给抽象类具体的业务操作方法。

四 实例

4.1 模拟毛笔

现需要提供大中小3种型号的画笔，能够绘制5种不同颜色，如果使用蜡笔，我们需要准备3*5=15支蜡笔，也就是说必须准备15个具体的蜡笔类。而如果使用毛笔的话，只需要3种型号的毛笔，外加5个颜料盒，用3+5=8个类就可以实现15支蜡笔的功能。

实际上，蜡笔和毛笔的关键一个区别就在于笔和颜色是否能够分离。即将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化"。关键就在于能否脱耦。蜡笔的颜色和蜡笔本身是分不开的，所以就造成必须使用15支色彩、大小各异的蜡笔来绘制图画。而毛笔与颜料能够很好的脱耦，各自独立变化，便简化了操作。在这里，抽象层面的概念是："毛笔用颜料作画"，而在实现时，毛笔有大中小三号，颜料有红绿蓝黑白等5种，于是便可出现3×5种组合。每个参与者（毛笔与颜料）都可以在自己的自由度上随意转换。蜡笔由于无法将笔与颜色分离，造成笔与颜色两个自由度无法单独变化，使得只有创建15种对象才能完成任务。

Bridge模式将继承关系转换为组合关系，从而降低了系统间的耦合，减少了代码编写量。

ULM如下图：

代码如下：

#include <iostream>
#include <string>

//实现类接口Color（颜色类)
class Color 
{
public:
	virtual void bepaint(const std::string&, const std::string&) = 0;
};

//具体实现类Red
class Red : public Color {
public:
	void bepaint(const std::string& penType, const std::string& name) 
	{
		std::cout << penType + "红色的" + name + "." << std::endl;
	}
};

//具体实现类Green
class Green : public Color {
public:
	void bepaint(const std::string& penType, const std::string& name) 
	{
		std::cout << penType + "绿色的" + name + "." << std::endl;
	}
};

//抽象类Pen
class Pen {
public:
	virtual void draw(const std::string& name) = 0;
	void setColor(Color* color) 
	{
		this->color = color;
	}
protected:
	Color* color;
};

//扩充抽象类BigPen
class BigPen : public Pen {
public:
	void draw(const std::string& name) {
		std::string penType = "大号毛笔绘制";
		this->color->bepaint(penType, name);
	}
};

//扩充抽象类SmallPen
class SmallPen : public Pen {
public:
	void draw(const std::string& name) {
		std::string penType = "小号毛笔绘制";
		this->color->bepaint(penType, name);
	}
};

//客户端测试类
int main(void) {
	Color* color;
	Pen* pen;

	//这里假装用反射获取 
	color = (Color*) new Green();
	pen = (Pen*) new SmallPen();

	pen->setColor(color);
	pen->draw("圣诞树");

	delete color;
	delete pen;

	return 0;
}
           

 结果如下：

4.2 安装操作系统

考虑装操作系统，有多种配置的计算机，同样也有多款操作系统。如何运用桥接模式呢？可以将操作系统和计算机分别抽象出来，让它们各自发展，减少它们的耦合度。当然了，两者之间有标准的接口。这样设计，不论是对于计算机，还是操作系统都是非常有利的。下面给出这种设计的UML图，其实就是桥接模式的UML图。

#include <iostream>

//操作系统
class OS
{
public:
	virtual void InstallOS_Imp() = 0;
};
class WindowOS : public OS
{
public:
	void InstallOS_Imp() 
	{ 
		std::cout << "安装Window操作系统" << std::endl; 
	}
};
class LinuxOS : public OS
{
public:
	void InstallOS_Imp() 
	{ 
		std::cout << "安装Linux操作系统" << std::endl; 
	}
};
class MacOS : public OS
{
public:
	void InstallOS_Imp() 
	{ 
		std::cout << "安装Mac操作系统" << std::endl; 
	}
};
//计算机
class Computer
{
public:
	virtual void InstallOS(OS* os) = 0;
};

class AppleComputer : public Computer
{
public:
	void InstallOS(OS* os) 
	{ 
		std::cout << "在苹果电脑上";
		os->InstallOS_Imp(); 
	}
};
class HPComputer : public Computer
{
public:
	void InstallOS(OS* os) 
	{ 
		std::cout << "在惠普电脑上";
		os->InstallOS_Imp(); 
	}
};

int main()
{
	OS* os1 = new WindowOS();
	OS* os2 = new MacOS();
	
	Computer* computer1 = new AppleComputer();
	computer1->InstallOS(os1);
	computer1->InstallOS(os2);

	OS* os3 = new LinuxOS();
	Computer* computer2 = new HPComputer();
	computer2->InstallOS(os3);

	delete os1;
	delete os2;
	delete os3;
    
	return 0;
}
           

结果如下：

 4.3 Java虚拟机

(1) Java语言通过Java虚拟机实现了平台的无关性。

2) 一个 Java桌面软件总是带有所在操作系统的视感(LookAndFeel)，如果一个Java软件是在Unix系统上开发的，那么开发人员看到的是Motif用户界面的视感；在Windows上面使用这个系统的用户看到的是Windows用户界面的视感；而一个在Macintosh上面使用的用户看到的则是Macintosh用户界面的视感，Java语言是通过所谓的Peer架构做到这一点的。Java为AWT中的每一个GUI构件都提供了一个Peer构件，在AWT中的Peer架构就使用了桥接模式。

    (3) JDBC驱动程序也是桥接模式的应用之一。使用JDBC驱动程序的应用系统就是抽象角色，而所使用的数据库是实现角色。一个JDBC驱动程序可以动态地将一个特定类型的数据库与一个Java应用程序绑定在一起，从而实现抽象角色与实现角色的动态耦合。

另外我们在window上使用的画图，visio等都是很好的例子。

五、桥接模式的优点

1. 分离抽象接口及其实现部分。桥接模式使用“对象间的关联关系”解耦了抽象和实现之间固有的绑定关系，使得抽象和实现可以沿着各自的维度来变化。所谓抽象和实现沿着各自维度的变化，也就是说抽象和实现不再在同一个继承层次结构中，而是“子类化”它们，使它们各自都具有自己的子类，以便各自子类的组合，从而获得多维度组合对象。
2. 在很多情况下，桥接模式可以取代多层继承方案，多层继承方案违背了“单一职责原则(SRP)”，复用性较差，且类的个数非常多，桥接模式是比多层继承方案更好的解决方法，它极大减少了类的个数。
3. 桥接模式提高了系统的可扩展性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统，符合“开闭原则(OCP)”。

六、桥接模式的缺点

1. 桥接模式的使用会增加系统的理解与设计难度，由于关联关系建立在抽象层，要求开发者一开始就就要针对抽象层进行设计与编程。
2. 桥接模式要求正确识别出系统中两个独立变化的维度，因此其使用范围具有一定的局限性，如何正确识别两个独立维度也需要一定的经验积累。

七、桥接模式的使用场景

1. 如果一个系统需要在抽象化和具体化之间增加更多的灵活性，避免在两个层次之间建立静态的继承关系，通过桥接模式可以使它们在抽象层建立一个关联关系。
2. “抽象部分”和“实现部分”可以以继承的方式独立扩展而互不影响，在程序运行时可以动态将一个抽象化子类的对象和一个实现化子类的对象进行组合，即系统需要对抽象化角色和实现化角色进行动态耦合。
3. 一个类存在两个（或多个）独立变化的维度，且这两个（或多个）维度都需要独立进行扩展。
4. 对于那些不希望使用继承或因为多层继承导致系统类的个数急剧增加的系统，使用桥接模式。

八、模式扩展

8.1 抽象工厂（Abstract Factory 模式可以用来创建和配置一个特定的Bridge模式。

8.2 适配器模式与桥接模式的联用

    • 桥接模式和适配器模式用于设计的不同阶段，桥接模式用于系统的初步设计，对于存在两个独立变化维度的类可以将其分为抽象化和实现化两个角色，使它们可以分别进行变化；而在初步设计完成之后，当发现系统与已有类无法协同工作时，可以采用适配器模式。但有时候在设计初期也需要考虑适配器模式，特别是那些涉及到大量第三方应用接口的情况。

8.3  桥接模式与装饰的区别:

这两个模式在一定程度上都是为了减少子类的数目，避免出现复杂的继承关系，但是它们解决的方法却各有不同.

装饰模式: 装饰模式把子类中比基类中多出来的部分放到单独的类里面，以适应新功能增加的需要，当我们把描述新功能的类封装到基类的对象里面时，就得到了所需要的子类对象，这些描述新功能的类通过组合可以实现很多的功能组合 .

桥接模式：桥接模式则把原来的基类的实现化细节抽象出来，在构造到一个实现化的结构中，然后再把原来的基类改造成一个抽象化的等级结构，这样就可以实现系统在多个维度上的独立变化 。