结构型模式-桥接模式

情景：由于产品线的壮大，现考虑将当前UI库扩展到其他平台，即一个可移植的Window抽象部分的实现，这一抽象部分应该允许用户开发一些在X Window System和IBM的Presentation Manager(PM)系统中都可以使用的窗体应用程序（Target）。

分析：看起来似乎不简单，于是我们立马着手开干。首先运用继承机制，我们可以定义Window抽象类和它的两个子类XWindow和PMWindow，由它们分别实现不同系统平台上的Window界面，事情发展得不错~

问题：当我们准备使Window的一个子类IconWindow（用于图标处理）支持两个系统平台时，我们发现必须实现两个新类XIconWindow和PMIconWindow，更为糟糕的是，我们必须对每一种类型的窗口都要定义两个类，考虑到后面还可能会支持其他平台，每增加一个平台都需要对类型窗口定义新的Window子类，另外，继承机制使得客户代码与平台相关，每当客户创建一个窗口，都必须要实例化一个具体的类，这个类有特定的实现方式，这将使得很难将客户代码移植到其他平台上去。换句话来说，创建窗口时不应该涉及具体的实现部分（不同平台会有不同），应该仅仅让窗口的实现部分依赖于应用运行的平台，创建窗口这个过程不应涉及特定平台。

解决方案：使用桥接模式，即将Window抽象和它的实现部分分别放在独立的类层次结构中，其中一个类层次结构针对窗口接口（Window、IconWindow）另外一个独立的类层次结构针对平台相关的窗口实现部分（绘制、布局），这个类层次结构的根类为WindowImp(如XWindowImp提供了一个基于X Window系统的实现)，Window子类的所有操作都是用WindowImp接口中的抽象操作实现的。这就将窗口的抽象与系统平台相关的实现部分分离开来。我们将Window与WindowImp之间的关系称之为桥接，因为它在抽象类与它的实现之间起到了桥梁的作用。

桥接模式.png

RefinedAbstraction(IconWindow)--扩充由Abstraction定义的接口

Implementor(WindowImp)--定义实现类的接口，Implementor接口提供基本操作，而Abstraction则定义了基于这些基本操作的较高层次的操作

ConcreteImplementor(XWindowImp)--实现Implementor接口并定义它的具体实现

实现：

struct Point
{
public:
    Point(int x, int y) :m_iX(x), m_iY(y) {};

    int X() const { return m_iX; }
    int Y() const { return m_iY; }

private:
    int m_iX;
    int m_iY;
};

class View
{
public:
    void DrawOn(Window *);

};

class WindowImp;

class Window
{
public:
    Window(View *content);

    virtual void DrawContents();

    virtual void Open();
    virtual void Close();
    virtual void Iconify();
    virtual void Deiconify();

    virtual void SetOrigin(const Point &at);
    virtual void SetExtent(const Point &extent);
    virtual void Raise();
    virtual void Lower();
    virtual void DrawLine(const Point &, const Point &);
    virtual void DrawRect(const Point &, const Point &);
    virtual void DrawPolygon(const Point *,int n);
    virtual void DrawText(const char *, const Point &);

protected:
    WindowImp* GetWindowImp();
    View* GetView();

private:
    WindowImp *m_pWinImp;
    View *m_pView;
};

void Window::DrawRect(const Point &p1, const Point &p2)
{
    WindowImp *imp = GetWindowImp();
    if (imp != nullptr)
    {
        imp->DeviceRect(p1.X(), p1.Y(), p1.X(), p1.Y());
    }
}

void Window::DrawText(const char *text, const Point &p1)
{
    WindowImp *imp = GetWindowImp();
    if (imp != nullptr)
    {
        imp->DeviceText(text, p1.X(), p1.Y());
    }
}

class ApplicationWindow : public Window
{
public:
    virtual void DrawContents();
};

void ApplicationWindow::DrawContents()
{
    GetView()->DrawOn(this);
}

class IconWindow : public Window
{
public:
    virtual void DrawContents();
private:
    const char *m_bitmapName;
};

void IconWindow::DrawContents()
{
    WindowImp *imp = GetWindowImp();
    if (imp != nullptr)
    {
        imp->DeviceBitmap(m_bitmapName, 0, 0);
    }
}

class  WindowImp
{
public:
    virtual void ImpTop() = 0;
    virtual void ImpBottom() = 0;
    virtual void ImpSetExtent(const Point &) = 0;
    virtual void ImpSetExtent(const Point &) = 0;

    virtual void DeviceRect(int, int, int, int) = 0;
    virtual void DeviceText(const char *, int, int) = 0;
    virtual void DeviceBitmap(const char *, int, int) = 0;

protected:
    WindowImp();

};

class Display;
class GC;
void XDrawRectangle(Display *display, int iWindowId, GC* gc, int x, int y, int width, int height);
class XWindowImp : public WindowImp
{
public:
    XWindowImp();
    virtual void DeviceRect(int, int, int, int);

private:
    //system-specific state
    Display *m_pDisplay;
    int m_iWindowId;    //window id
    GC *m_pGc;          //window graphic context
};

void XWindowImp::DeviceRect(int x0, int y0, int x1, int y1)
{
    int x = ::round(std::min(x0, x1));
    int y = ::round(std::min(y0, y1));
    int w = ::round(std::abs(x0 - x1));
    int h = ::round(std::abs(y0 - y1));
    XDrawRectangle(m_pDisplay, m_iWindowId, m_pGc, x, y, w, h);
}

class HPS;
class PMWindowImp : public WindowImp
{
public:
    PMWindowImp();
    virtual void DeviceRect(int, int, int, int);

private:
    //system-specific state
    HPS *m_pHps;            
};

void PMWindowImp::DeviceRect(int x0, int y0, int x1, int y1)
{
    int left = std::min(x0, x1);
    int right = std::max(x0, x1);
    int bottom = std::min(y0, y1);
    int top = std::max(y0, y1);

    Point points[4] = 
    {
        Point (left,top),
        Point(right,top), 
        Point(right,bottom), 
        Point(left,bottom)
    };

    // to do draw graphic...
}

WindowImp* Window::GetWindowImp()
{
    if (m_pWinImp == nullptr)
    {
        m_pWinImp = WindowSystemFactor::Instance()->MakeWindowImp();
    }
    return m_pWinImp;
}

class WindowSystemFactor
{
public:
    static WindowSystemFactor *Instance();
    WindowImp *MakeWindowImp();

protected:
    WindowSystemFactor();
};

适用性：

• 你不希望在抽象和它的实现部分之间有一个固定的绑定关系。例如，在程序运行时刻实现部分应可以被选择或者切换
• 类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充，Bridge模式可以对不同的抽象接口和实现部分进行组合，并对他们进行扩充。
• 对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。

应用：
1.libg++类库定义了一些类用于实现公共的数据结构，例如Set、LinkedSet、HashSet、LinkedList和HashTable。Set是一个抽象类，它定义了一组抽象接口，而LinkedList和HashTable则分别是连表和hash表的具体实现，LinkedSet和HashSet是Set的实现者，它们桥接了Set和它们具体所对应LinkedList和HashTable。
2.Android View视图层级中的CheckBox、Button、TextView和View之间构成一个继承关系的视图层级，每一个视图定义了该类控件所拥有的基本属性和行为，但正真绘制到屏幕上的部分是由与View相关的功能实现类DisplayList、HardwareLayer、Canvas负责，这两部分的关系可以看作是对桥接模式的应用。