（五）设计模式之桥接模式

1. 意图

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

【GOF95】在提出桥梁模式的时候指出，桥梁模式的用意是"将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化"。这句话有三个关键词，也就是抽象化、实现化和脱耦。

• 抽象化

存在于多个实体中的共同的概念性联系，就是抽象化。作为一个过程，抽象化就是忽略一些信息，从而把不同的实体当做同样的实体对待【LISKOV94】。

• 实现化

抽象化给出的具体实现，就是实现化。

• 脱耦

所谓耦合，就是两个实体的行为的某种强关联。而将它们的强关联去掉，就是耦合的解脱，或称脱耦。在这里，脱耦是指将抽象化和实现化之间的耦合解脱开，或者说是将它们之间的强关联改换成弱关联。

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

2. 结构

桥梁模式所涉及的角色有：
抽象化(Abstraction)角色：抽象化给出的定义，并保存一个对实现化对象的引用。
修正抽象化(Refined Abstraction)角色：扩展抽象化角色，改变和修正父类对抽象化的定义。
实现化(Implementor)角色：这个角色给出实现化角色的接口，但不给出具体的实现。必须指出的是，这个接 口不一定和抽象化角色的接口定义相同，实际上，这两个接口可以非常不一样。实现化角色应当只给出底层操作，而抽象化角色应当只给出基于底层操作的更高一层 的操作。
具体实现化(Concrete Implementor)角色：这个角色给出实现化角色接口的具体实现。

3. 例子

模拟游戏引擎的实现，假装使用OpenGL和DirectX两种引擎来绘制图形

1. 下图为不使用设计模式时的代码，当绘制的图形需要扩展时或者需要扩展使用其它的引擎时，就会出现问题，需要修改每个类的实现，非常繁琐，容易出错。

using UnityEngine;

public class DM2Bridge : MonoBehaviour {

    void Start()
    {
        Sphere sphere=new Sphere();
        sphere.Draw();
        Cube cube = new Cube();
        cube.Draw();
    }
}

public class Sphere
{
    
    public string name = "Sphere";
    public OpenGL openGL = new OpenGL();
    public DirectX directX = new DirectX();

    public void Draw()
    {
        //openGL.Render(name);
        directX.Render(name);
    }
}

public class Cube
{
    
    public string name = "Cube";
    public OpenGL openGL = new OpenGL();
    public DirectX directX = new DirectX();

    public void Draw()
    {
        //openGL.Render(name);
        directX.Render(name);
    }
}
public class OpenGL
{
    public void Render(string name)
    {
        Debug.Log("OpenGL绘制出来了：" + name);
    }
}
public class DirectX
{
    public void Render(string name)
    {
        Debug.Log("DirectX绘制出来了：" + name);
    }
}

2. 使用桥接模式，经过重构之后提取出公有类，使用接口类来调用，当有新的需求时，只需更改调用即可

using UnityEngine;

public class DM2Bridge : MonoBehaviour {

    void Start()
    {
        IRenderEngine renderEngine=new OpenGL();

        Sphere sphere=new Sphere(renderEngine);
        sphere.Draw();
        Cube cube = new Cube(renderEngine);
        cube.Draw();
    }
}

public class IShape
{
    public string name;
    public IRenderEngine renderEngine;

    public IShape(IRenderEngine renderEngine)
    {
        this.renderEngine = renderEngine;
    }
    public void Draw()
    {
        renderEngine.Render(name);
    }
}

public abstract class IRenderEngine
{
    public abstract void Render(string name);
}
public class Sphere:IShape
{
    public Sphere(IRenderEngine re):base(re)
    {
        name = "Sphere";
    }
    public string name = "Sphere";
    public OpenGL openGL = new OpenGL();
    public DirectX directX = new DirectX();

    public void Draw()
    {
        openGL.Render(name);
        directX.Render(name);
    }
}

public class Cube:IShape
{
    public Cube(IRenderEngine re):base(re)
    {
        name = "Cube";
    }
    public string name = "Cube";
    public OpenGL openGL = new OpenGL();
    public DirectX directX = new DirectX();

    public void Draw()
    {
        openGL.Render(name);
        directX.Render(name);
    }
}
public class OpenGL:IRenderEngine
{
    public override void Render(string name)
    {
        Debug.Log("OpenGL绘制出来了：" + name);
    }
}
public class DirectX:IRenderEngine
{
    public override void Render(string name)
    {
        Debug.Log("DirectX绘制出来了：" + name);
    }
}

4. 桥接模式和适配器模式的区别

很多时候经常容易把桥接模式和适配器模式弄混。那什么时候用桥接，什么时候用适配器呢 ？

共同点：
桥接和适配器都是让两个东西配合工作

不同点：出发点不同。
　　适配器：改变已有的两个接口，让他们相容。
　　桥接模式：分离抽象化和实现，使两者的接口可以不同，目的是分离。

所以说，如果你拿到两个已有模块，想让他们同时工作，那么你使用的适配器。 如果你还什么都没有，但是想分开实现，那么桥接是一个选择。

桥接是先有桥，才有两端的东西 适配是先有两边的东西，才有适配器 。
桥接是在桥好了之后，两边的东西还可以变化。

桥模式并不同于适配器模式，适配器模式其实是一个事后诸葛亮，当发现以前的东西不适用了才去做一个弥补的措施。桥模式相对来说所做的改变比适配器模式早，它可以适用于有两个甚至两个以上维度的变化。

桥接模式将继承关系转换为关联关系，从而降低了类与类之间的耦合，减少了代码编写量。