桥接模式

定义

将抽象部分与它的实现部分分离，使它们都可以独立地变化。它是一种对象结构型模式，又称为柄体(Handle and Body)模式或接口(Interface)模式。

上面的定义太简单了点，并不能很好的解释什么是桥接模式，看了很多文章觉得还是 LoveLin的解释最为直接。

试想一下，当我们在绘画时需要大中小三种型号的画笔，并且能绘制12种颜色。当我们选择蜡笔时，为了满足这个需求，我们需要 12*3=36 支蜡笔。而同样的情况，如果我们选择油彩笔时，我们仅需3支不同型号的油彩笔，配合12种不同的颜料就可以了，总共需要 3+12=15 个物品。而且当我们需要增加一种型号的画笔并且也需要绘制12种颜色，蜡笔需要增加12支，而油彩笔仅需要增加一支不同型号的笔就行。为什么同样一个需求，选择不同的画笔会有不同的结果呢？

这里我们注意到绘画需求中对画笔有两个属性的需求，型号与颜色，这两个属性都是可变可拓展的，选择蜡笔时每一支蜡笔上这两个属性都非常明确，这就导致了两种属性有多少种组合，我们就需要多少支蜡笔。而相对的，选择油彩笔时，这两个属性是分开的，油彩笔仅仅具有型号的属性，而颜色的属性由颜料提供。

这就是桥接模式最生动的演示，当我们在软件开发时，某一个类存在两个独立变化的维度时，通过桥接模式，可以将这两个维度分离出来，使两者可以单独扩展变化，让系统更符合“单一职责”原则。

UML图

上面是桥接模式最常见的结构图，它包含下面几个角色：

Abstraction（抽象类）：用于定义抽象类的接口，它一般是抽象类而不是接口，其中定义了一个Implementor（实现类接口）类型的对象并可以维护该对象，它与Implementor之间具有关联关系，它既可以包含抽象业务方法，也可以包含具体业务方法。
RefinedAbstraction（扩充抽象类）：扩充由Abstraction定义的接口，通常情况下它不再是抽象类而是具体类，它实现了在Abstraction中声明的抽象业务方法，在RefinedAbstraction中可以调用在Implementor中定义的业务方法。
Implementor（实现类接口）：定义实现类的接口，这个接口不一定要与Abstraction的接口完全一致，事实上这两个接口可以完全不同，一般而言，Implementor接口仅提供基本操作，而Abstraction定义的接口可能会做更多更复杂的操作。Implementor接口对这些基本操作进行了声明，而具体实现交给其子类。通过关联关系，在Abstraction中不仅拥有自己的方法，还可以调用到Implementor中定义的方法，使用关联关系来替代继承关系。
ConcreteImplementor（具体实现类）：具体实现Implementor接口，在不同的ConcreteImplementor中提供基本操作的不同实现，在程序运行时，ConcreteImplementor对象将替换其父类对象，提供给抽象类具体的业务操作方法。

PS: 上面的介绍 copy的，解释的很书面，读不惯的还是直接看代码吧 😂

具体到我们前面的例子，Abstraction对应的就是油彩笔的抽象对象，具有型号这个属性，RefinedAbstraction对应的就是具体三种型号的油彩笔，Implementor对应的就是颜料的抽象对象，ConcreteImplementor对应的就是具体的有不同颜色的颜料。

代码

//Abstraction抽象类，保持Implementor的引用
public abstract class Abstraction {
    protected Implementor impl;
    public void setImpl(Implementor impl){
        this.impl = impl;
    }
	
	//抽象操作方法
    public abstract void operation();
}
//Implementor 接口
public interface Implementor {
    void operationImpl();
}
//Abstraction抽象类的具体实现
public class DefindAbstraction extends Abstraction {
    @Override
    public void operation() {
        impl.operationImpl();
    }
}
//Implementor 接口的具体实现
public class ConcreteImplementorA implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("this is ConcreteImplementorA operation!");
    }
}
//Implementor 接口的具体实现
public class ConcreteImplementorB implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("this is ConcreteImplementorB operation!");
    }
}

客户端调用代码

public class Client {
    public static void main(String[] args) {
        Abstraction abstraction;
        Implementor implementor;
        abstraction = new DefindAbstraction();
        implementor = new ConcreteImplementorA();
        abstraction.setImpl(implementor);
        abstraction.operation();
        implementor = new ConcreteImplementorB();
        abstraction.setImpl(implementor);
        abstraction.operation();
    }
}

调用结果

this is ConcreteImplementorA operation!
this is ConcreteImplementorB operation!

创建不同维度的具体实现，通过桥接模式配合使用极大的简化了系统复杂度。

实例

老规矩，还是来一个实例演示一下

某软件公司欲开发一个数据转换工具，可以将数据库中的数据转换成多种文件格式，例如txt、xml、pdf等格式，同时该工具需要支持多种不同的数据库。试使用桥接模式对其进行设计。

分析需求可知，这里数据转换的类型是一个维度，支持的数据库类型也是一个维度，分离两个维度进行设计。

UML图

代码

//抽象类 保持一个DaProviderImp的引用
public abstract class DataParser {
    protected DataProviderImp dpi;
    public void setDpi(DataProviderImp dpi) {
        this.dpi = dpi;
    }
    public abstract void parseData();
}
//DataProviderImp 接口
public interface DataProviderImp {
    String readData();
}

具体实现如下

public class TXTDataParser extends DataParser {
    @Override
    public void parseData() {
        String str = dpi.readData();
        System.out.println("Parse "+str+" to TXT");
        System.out.println("---------------------------------------");
    }
}
public class XMLDataParser extends DataParser {
    @Override
    public void parseData() {
        String str = dpi.readData();
        System.out.println("Parse "+str+" to XML");
        System.out.println("---------------------------------------");
    }
}
...
public class OracleDataProvider implements DataProviderImp {
    @Override
    public String readData() {
        System.out.println("Connect DB ---- Oracle");
        System.out.println("Read Data from Oracle");
        return "Data from Oracle";
    }
}
public class MysqlDataProvider implements DataProviderImp {
    @Override
    public String readData() {
        System.out.println("Connect DB ---- Mysql");
        System.out.println("Read Data from Mysql");
        return "Data from Mysql";
    }
}
...

客户端代码如下

public class Client {
    public static void main(String[] args){
        DataParser dataParser;
        DataProviderImp dataProviderImp;
        dataParser = new TXTDataParser();
        dataProviderImp = new OracleDataProvider();
        dataParser.setDpi(dataProviderImp);
        dataParser.parseData();
        dataParser = new XMLDataParser();
        dataProviderImp = new MysqlDataProvider();
        dataParser.setDpi(dataProviderImp);
        dataParser.parseData();
        dataParser = new PDFDataParser();
        dataProviderImp = new SqlServerDataProvider();
        dataParser.setDpi(dataProviderImp);
        dataParser.parseData();
    }
}

运行结果如下

Connect DB ---- Oracle
Read Data from Oracle
Parse Data from Oracle to TXT
---------------------------------------
Connect DB ---- Mysql
Read Data from Mysql
Parse Data from Mysql to XML
---------------------------------------
Connect DB ---- SqlServer
Read Data from SqlServer
Parse Data from SqlServer to PDF
---------------------------------------

小结

在LovaLin的文章中曾提出过如果有两个以上的维度该怎么解决，相信看完桥接模式的所有代码后，大家应该有个答案，两个维度或多个维度，多出的维度都可以分离出一个实现部分，通过抽象部分关联来解决。

桥接模式极大的提高了提供的扩展性，且大大减少了系统代码量，分离多个维度更符合“单一职责”原则，且各个维度的扩展都不用修改原系统代码，符合“开闭原则”。但桥接模式的使用也会一定程度上增加系统的理解与设计难度，需要有一定的经验才能很好的分别出系统的不同维度。

源码：https://github.com/lichenming0516/DesignPattern