结构型设计模式—桥接模式

结构型设计模式—桥接模式

欢迎长按图片加好友，我会第一时间和你分享持续更多的开发知识，面试资源，学习方法等等。

假设你要买一张新桌子，你有两个选择：一种是木制的桌子，另一种是金属制的桌子。

无论你选择哪种材质，你还希望这张桌子可以有不同的颜色，比如红色、蓝色或者绿色。如果你想要一种桌子，就需要一个“桌子”类，里面包含了所有可能的组合：木制红色、木制蓝色、木制绿色、金属红色、金属蓝色、金属绿色等等。

这时候问题就来了，如果你有两种材质和三种颜色，那你就需要六个类来表示这些组合。随着材质和颜色的增加，你需要的类数量会成倍增长，维护和扩展也变得越来越困难。

为了解决这个问题，你可以将材质和颜色分开来处理。你定义一个“材质”类，比如“木制”和“金属”，然后定义一个“颜色”类，比如“红色”、“蓝色”和“绿色”。然后你只需要一个“桌子”类，它可以组合不同的材质和颜色。

这就是桥接模式的思想。通过将材质和颜色这两个变化的维度分离开来，你可以减少类的数量，同时还可以轻松地增加新的材质和颜色，而不必创建新的类。

在软件设计中，桥接模式也能帮助我们将抽象部分和实现部分分离，使它们可以独立变化。这样一来，扩展系统时就不需要更改现有的代码，可以更加灵活地应对变化。

桥接模式概述

桥接模式是一种很实用的结构型设计模式。如果软件系统中某个类存在两个独立变化的维度，通过该模式可以将这两个维度分离出来，使两者可以独立扩展，让系统更加符合单一职责原则。

与多层继承方案不同，它将两个独立变化的维度设计为两个独立的继承等级结构，并且在抽象层建立一个抽象关联，该关联关系类似一条连接两个独立继承结构的桥，故名桥接模式。桥接模式用一种巧妙的方式处理多层继承存在的问题。

桥接模式采用抽象关联取代了传统的多层继承，将类之间的静态继承关系转换为动态的对象组合关系，使得系统更加灵活，并易于扩展，同时有效控制了系统中类的个数。

桥接模式（Bridge Pattern）：将抽象部分与其实现部分分离，使它们都可以独立地变化。它是一种对象结构型模式，又称为柄体（Handle and Body）模式或接口（Interface）模式。桥接模式的结构与其名称一样，存在一条连接两个独立继承等级结构的桥。

桥接模式结构如图所示。

在桥接模式中包含以下4个角色：

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

桥接模式是一个非常有用的模式，在桥接模式中体现了很多面向对象设计原则的思想，包括单一职责原则、开闭原则、合成复用原则、里氏代换原则、依赖倒转原则等。熟悉桥接模式有助于深入理解这些设计原则，也有助于形成正确的设计思想和培养良好的设计风格。

在使用桥接模式时，首先应该识别出一个类所具有的两个独立变化的维度，将它们设计为两个独立的继承等级结构，为两个维度都提供抽象层，并建立抽象耦合。

通常情况下，将具有两个独立变化维度的类的一些普通业务方法和与之关系最密切的维度设计为抽象类层次结构（抽象部分），而将另一个维度设计为实现类层次结构（实现部分）。

例如，对于桌子而言，由于材质是其固有的维度，因此可以设计一个抽象的桌子类，在该类中声明并部分实现桌子的业务方法，而将各种材质的桌子作为其子类。

颜色是桌子的另一个维度，由于它与桌子之间存在一种“设置”的关系，因此可以提供一个抽象的颜色接口，而将具体的颜色作为实现该接口的子类。在此，材质可认为是桌子的抽象部分，而颜色是桌子的实现部分。

// 1. 抽象部分：桌子（Table）类
// 首先，我们将桌子设计为抽象部分。因为桌子的材质是一个最主要的维度，我们将它设计为抽象类层次结构。
// 这意味着不同类型的桌子（如木制桌子和金属桌子）将继承自这个抽象类，并且可以有自己的实现。

// 抽象类：Table
abstract class Table {
    protected Color color;

    public Table(Color color) {
        this.color = color;
    }

    public abstract void produce();
}

// 2. 实现部分：颜色（Color）类
// 接下来，我们将颜色设计为实现部分。颜色是一个独立的变化维度，
// 因此它将被设计为一个接口或抽象类，并且可以有不同的具体实现。

// 实现部分：Color接口
interface Color {
    void applyColor();
}

// 具体实现类：Red
class Red implements Color {
    public void applyColor() {
        System.out.println("Applying red color");
    }
}

// 具体实现类：Blue
class Blue implements Color {
    public void applyColor() {
        System.out.println("Applying blue color");
    }
}

// 具体实现类：Green
class Green implements Color {
    public void applyColor() {
        System.out.println("Applying green color");
}

// 3. 具体类：不同材质的桌子
// 然后，我们创建具体的桌子类，这些类继承自Table抽象类。
// 每种具体的桌子类都可以使用不同的颜色（即通过组合颜色实现类）。

// 具体类：WoodenTable
class WoodenTable extends Table {
    public WoodenTable(Color color) {
        super(color);
    }

    public void produce() {
        System.out.print("Producing wooden table with ");
        color.applyColor();
    }
}

// 具体类：MetalTable
class MetalTable extends Table {
    public MetalTable(Color color) {
        super(color);
    }

    public void produce() {
        System.out.print("Producing metal table with ");
        color.applyColor();
    }
}

// 4. 使用桥接模式
// 可以通过桥接模式来创建不同的桌子组合，例如木制红色桌子或金属蓝色桌子：

public class BridgePatternExample {
    public static void main(String[] args) {
        Table woodenRedTable = new WoodenTable(new Red());
        woodenRedTable.produce();  // Producing wooden table with Applying red color

        Table metalBlueTable = new MetalTable(new Blue());
        metalBlueTable.produce();  // Producing metal table with Applying blue color
    }
}

通过桥接模式，我们成功地将桌子的材质和颜色两个独立的维度分离开来，并将材质设计为抽象部分，颜色设计为实现部分。这样一来，添加新材质或新颜色时，不需要修改现有的类，只需增加新的实现类即可，系统变得更加灵活且易于扩展。

如果以后需要添加新的桌子材质（如塑料）或新的颜色（如黄色），只需添加相应的类，而不必创建组合类，从而减少了类的数量和系统的复杂性。

如果存在2个以上的维度，系统该如何设计

如果系统中存在两个以上的变化维度，是否可以使用桥接模式进行处理？如果可以，系统该如何设计？

实际应用中，如果系统中存在多个独立变化的维度，我们可以通过组合多个桥接模式来实现这些维度的分离和独立变化。系统设计时，可以将每一个变化维度抽象出来，分别设计为抽象类层次结构（抽象部分）和实现类层次结构（实现部分），然后在具体类中组合这些抽象类和实现类。

假设在桌子的设计中，除了“材质”和“颜色”这两个维度外，还有“风格”（例如现代风格、古典风格）这一维度需要考虑。我们可以通过增加一个“风格”维度来扩展这个系统。

// 1. 抽象部分：桌子（Table）类

首先，我们保持“材质”作为抽象部分的一部分。

abstract class Table {
    protected Color color;
    protected Style style;

    public Table(Color color, Style style) {
        this.color = color;
        this.style = style;
    }

    public abstract void produce();
}

// 2. 实现部分一：颜色（Color）类

颜色维度仍然作为实现部分。

interface Color {
    void applyColor();
}

class Red implements Color {
    public void applyColor() {
        System.out.println("Applying red color");
    }
}

class Blue implements Color {
    public void applyColor() {
        System.out.println("Applying blue color");
    }
}

class Green implements Color {
    public void applyColor() {
        System.out.println("Applying green color");
    }
}

// 3. 实现部分二：风格（Style）类

新增的风格维度可以作为另一个实现部分。

interface Style {
    void applyStyle();
}

class ModernStyle implements Style {
    public void applyStyle() {
        System.out.println("Applying modern style");
    }
}

class ClassicalStyle implements Style {
    public void applyStyle() {
        System.out.println("Applying classical style");
    }
}

// 4. 具体类：不同材质和风格的桌子

我们创建不同材质的桌子，并在这些具体类中组合颜色和风格两个实现部分。

class WoodenTable extends Table {
    public WoodenTable(Color color, Style style) {
        super(color, style);
    }

    public void produce() {
        System.out.print("Producing wooden table with ");
        color.applyColor();
        style.applyStyle();
    }
}

class MetalTable extends Table {
    public MetalTable(Color color, Style style) {
        super(color, style);
    }

    public void produce() {
        System.out.print("Producing metal table with ");
        color.applyColor();
        style.applyStyle();
    }
}

// 5. 使用扩展后的桥接模式

通过扩展后的桥接模式，可以灵活创建不同组合的桌子，如木制红色现代风格的桌子或金属蓝色古典风格的桌子。
public class BridgePatternExample {
    public static void main(String[] args) {
        Table woodenModernRedTable = new WoodenTable(new Red(), new ModernStyle());
        woodenModernRedTable.produce();  // Producing wooden table with Applying red color Applying modern style

        Table metalClassicalBlueTable = new MetalTable(new Blue(), new ClassicalStyle());
        metalClassicalBlueTable.produce();  // Producing metal table with Applying blue color Applying classical style
    }
}

当系统中有两个以上的变化维度时，桥接模式仍然适用。系统设计时可以通过以下步骤来处理：

1. 识别变化维度：识别出系统中所有独立变化的维度。
2. 抽象部分：将其中一个主要维度设计为抽象类层次结构，这将成为抽象部分。
3. 实现部分：将其他维度设计为接口或抽象类，并提供具体实现类。
4. 组合模式：在具体类中组合这些抽象类和实现类，使得每个变化维度独立变化，不相互影响。

通过这种方式，系统变得更加灵活，可扩展性更强。当增加新的变化维度或扩展现有维度时，只需增加相应的类，而无需修改现有的代码。

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

在软件开发中，适配器模式通常可以与桥接模式联合使用。适配器模式可以解决两个已有接口间不兼容问题，在这种情况下被适配的类往往是一个黑盒子，有时候用户不想也不能改变这个被适配的类，也不能控制其扩展。适配器模式通常用于现有系统与第三方产品功能的集成，采用增加适配器的方式将第三方类集成到系统中。

桥接模式则不同，用户可以通过接口继承或类继承的方式来对系统进行扩展。

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

适配器模式和桥接模式可以联合使用，特别是在系统中需要连接不兼容的接口，同时还需要处理多个独立变化的维度时。下面通过一个具体实例来说明这两个模式如何联合使用。

假设我们要设计一个音频播放系统，该系统需要支持多种音频格式（如MP3、WAV、AAC），并且能够在不同的设备上播放（如电脑、智能手机、智能音箱）。不同设备有不同的播放实现，而不同音频格式需要使用不同的解码器。

在这种情况下：

• 桥接模式 可以帮助我们处理音频格式和设备两个独立变化的维度。
• 适配器模式 可以帮助我们将现有的解码器类适配到我们的播放系统中。

// 1. 使用桥接模式处理设备和音频格式两个维度

抽象部分：音频播放器（AudioPlayer）

首先，我们定义一个抽象的音频播放器类，该类包含设备和音频格式两个独立的维度。

abstract class AudioPlayer {
    protected Device device;
    protected AudioFormat format;

    public AudioPlayer(Device device, AudioFormat format) {
        this.device = device;
        this.format = format;
    }

    public abstract void play();
}

// 实现部分一：设备（Device）

设备是其中一个维度，我们可以将其设计为一个接口，并创建不同设备的具体实现。

interface Device {
    void playAudio(String audioType);
}

class Computer implements Device {
    public void playAudio(String audioType) {
        System.out.println("Playing " + audioType + " on computer");
    }
}

class Smartphone implements Device {
    public void playAudio(String audioType) {
        System.out.println("Playing " + audioType + " on smartphone");
    }
}

class SmartSpeaker implements Device {
    public void playAudio(String audioType) {
        System.out.println("Playing " + audioType + " on smart speaker");
    }
}

// 实现部分二：音频格式（AudioFormat）

音频格式是另一个维度，我们可以设计为一个接口，并通过适配器模式来处理具体的解码器。

interface AudioFormat {
    void decode(String fileName);
}

class MP3Format implements AudioFormat {
    private MP3Decoder decoder;

    public MP3Format(MP3Decoder decoder) {
        this.decoder = decoder;
    }

    public void decode(String fileName) {
        decoder.decodeMP3(fileName);
    }
}

class WAVFormat implements AudioFormat {
    private WAVDecoder decoder;

    public WAVFormat(WAVDecoder decoder) {
        this.decoder = decoder;
    }

    public void decode(String fileName) {
        decoder.decodeWAV(fileName);
    }
}

// 2. 使用适配器模式适配现有的解码器

假设我们有现成的解码器类，但它们的接口与我们设计的系统不兼容，因此需要使用适配器模式来适配它们。

class MP3Decoder {
    public void decodeMP3(String fileName) {
        System.out.println("Decoding MP3 file: " + fileName);
    }
}

class WAVDecoder {
    public void decodeWAV(String fileName) {
        System.out.println("Decoding WAV file: " + fileName);
    }
}

// 3. 具体播放器类

最后，我们创建具体的音频播放器类，通过组合设备和音频格式两个维度实现音频播放功能。

class MusicPlayer extends AudioPlayer {
    public MusicPlayer(Device device, AudioFormat format) {
        super(device, format);
    }

    public void play() {
        String fileName = "musicfile";
        format.decode(fileName);
        device.playAudio(format.getClass().getSimpleName());
    }
}

// 4. 使用桥接模式和适配器模式的联合设计

我们可以通过组合设备和音频格式，创建各种不同的播放器。

public class AdapterBridgeExample {
    public static void main(String[] args) {
        // 使用MP3格式并在电脑上播放
        MP3Decoder mp3Decoder = new MP3Decoder();
        AudioFormat mp3Format = new MP3Format(mp3Decoder);
        Device computer = new Computer();
        AudioPlayer player1 = new MusicPlayer(computer, mp3Format);
        player1.play();  // Decoding MP3 file: musicfile | Playing MP3Format on computer

        // 使用WAV格式并在智能手机上播放
        WAVDecoder wavDecoder = new WAVDecoder();
        AudioFormat wavFormat = new WAVFormat(wavDecoder);
        Device smartphone = new Smartphone();
        AudioPlayer player2 = new MusicPlayer(smartphone, wavFormat);
        player2.play();  // Decoding WAV file: musicfile | Playing WAVFormat on smartphone
    }
}

在这个实例中，桥接模式 用于处理音频格式和设备两个独立变化的维度，使系统能够灵活地应对不同格式和设备的组合。而 适配器模式 则用于将不兼容的解码器类适配到我们的音频播放系统中。这两个模式的联合使用，使得系统既灵活又具有很强的扩展性，可以轻松添加新的音频格式、设备或解码器，而无需修改现有代码。

桥接模式总结

桥接模式是设计Java虚拟机和实现JDBC等驱动程序的核心模式之一，应用较为广泛。在软件开发中，如果一个类或一个系统有多个变化维度时，都可以尝试使用桥接模式对其进行设计。桥接模式为具有多维度变化的系统提供了一套完整的解决方案，并且降低了系统的复杂度。

优点

桥接模式的主要优点如下：

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

缺点

桥接模式的主要缺点如下：

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

使用场景

在以下情况下可以考虑使用桥接模式：

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

案例

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

为了设计一个支持多种文件格式和多种数据库的数据转换工具，可以使用桥接模式将“数据库”和“文件格式”这两个独立的变化维度分离开来。下面是设计思路：

// 1. 抽象部分：数据转换器（DataConverter）类

首先，定义一个抽象的 DataConverter 类，用于表示数据转换器。
它将数据库和文件格式这两个维度分离，并作为抽象部分的一部分。

abstract class DataConverter {
    protected Database database;
    protected FileFormat fileFormat;

    public DataConverter(Database database, FileFormat fileFormat) {
        this.database = database;
        this.fileFormat = fileFormat;
    }

    public abstract void convertData();
}

// 2. 实现部分一：数据库（Database）类

数据库是一个变化的维度，我们可以将其设计为一个接口，并创建不同数据库的具体实现。

interface Database {
    String fetchData();
}

class MySQLDatabase implements Database {
    public String fetchData() {
        // 模拟从MySQL数据库获取数据
        return "Data from MySQL";
    }
}

class PostgreSQLDatabase implements Database {
    public String fetchData() {
        // 模拟从PostgreSQL数据库获取数据
        return "Data from PostgreSQL";
    }
}

class OracleDatabase implements Database {
    public String fetchData() {
        // 模拟从Oracle数据库获取数据
        return "Data from Oracle";
    }
}

// 3. 实现部分二：文件格式（FileFormat）类

文件格式是另一个变化的维度，我们可以将其设计为一个接口，并创建不同文件格式的具体实现。

interface FileFormat {
    void writeData(String data);
}

class TxtFormat implements FileFormat {
    public void writeData(String data) {
        System.out.println("Writing data to TXT file: " + data);
    }
}

class XmlFormat implements FileFormat {
    public void writeData(String data) {
        System.out.println("Writing data to XML file: " + data);
    }
}

class PdfFormat implements FileFormat {
    public void writeData(String data) {
        System.out.println("Writing data to PDF file: " + data);
    }
}

// 4. 具体转换器类

创建具体的转换器类，继承自 DataConverter 抽象类。
通过组合不同的数据库和文件格式实现数据的转换功能。

class DatabaseToFileConverter extends DataConverter {
    public DatabaseToFileConverter(Database database, FileFormat fileFormat) {
        super(database, fileFormat);
    }

    public void convertData() {
        String data = database.fetchData();
        fileFormat.writeData(data);
    }
}

// 5. 使用桥接模式设计的数据转换工具

通过桥接模式设计的数据转换工具，可以灵活地组合不同的数据库和文件格式进行数据转换。

public class BridgePatternExample {
    public static void main(String[] args) {
        // 将MySQL数据库中的数据转换为TXT文件
        Database mysqlDatabase = new MySQLDatabase();
        FileFormat txtFormat = new TxtFormat();
        DataConverter converter1 = new DatabaseToFileConverter(mysqlDatabase, txtFormat);
        converter1.convertData();  // Writing data to TXT file: Data from MySQL

        // 将PostgreSQL数据库中的数据转换为XML文件
        Database postgresDatabase = new PostgreSQLDatabase();
        FileFormat xmlFormat = new XmlFormat();
        DataConverter converter2 = new DatabaseToFileConverter(postgresDatabase, xmlFormat);
        converter2.convertData();  // Writing data to XML file: Data from PostgreSQL

        // 将Oracle数据库中的数据转换为PDF文件
        Database oracleDatabase = new OracleDatabase();
        FileFormat pdfFormat = new PdfFormat();
        DataConverter converter3 = new DatabaseToFileConverter(oracleDatabase, pdfFormat);
        converter3.convertData();  // Writing data to PDF file: Data from Oracle
    }
}

在这个设计中，桥接模式成功地将数据库和文件格式这两个独立变化的维度分离开来。通过这种设计，Sunny软件公司可以灵活地组合各种数据库和文件格式，轻松实现不同数据库数据到各种文件格式的转换。如果需要增加新的数据库支持或文件格式，只需扩展相应的类，而无需修改现有的代码，极大地提高了系统的扩展性和维护性。