桥接（桥梁）模式

简介

桥接模式（Bridge Pattern）又叫作桥梁模式、接口（Interface）模式或柄体（Handle and Body）模式，指将抽象部分与具体实现部分分离，使它们都可以独立地变化，属于结构型设计模式。

常用用于替换继成

通用模板

1. 创建实现接口：确定实现维度的基本操作，提供给Abstraction使用。该类一般为接口或抽象类。

   // 抽象实现
   public interface IImplementor {
       void operationImp();
   }
   

2. 创建具体实现类：Implementor的具体实现。

   // 具体实现类A
   public class ConcreteImplementorA implements IImplementor{
       @Override
       public void operationImp() {
           System.out.println("I am ConcreteImplementorA");
       }
   }
   

   
   // 具体实现类B
   public class ConcreteImplementorB implements IImplementor {
       @Override
       public void operationImp() {
           System.out.println("I am ConcreteImplementorB");
       }
   }
   

3. 创建抽象类：该类持有一个对实现角色的引用，抽象角色中的方法需要实现角色来实现。抽象角色一般为抽象类（构造函数规定子类要传入一个实现对象）。

   // 抽象
   public abstract class Abstraction {
       private IImplementor iImplementor;
   
       public Abstraction(IImplementor iImplementor) {
           this.iImplementor = iImplementor;
       }
   
       public void operation() {
           iImplementor.operationImp();
       }
   }
   

4. 创建修正抽象类：Abstraction的具体实现，对Abstraction的方法进行完善和扩展。

   // 修正抽象类
   public class RefineAbstraction extends Abstraction {
       public RefineAbstraction(IImplementor iImplementor) {
           super(iImplementor);
       }
   
       @Override
       public void operation() {
           super.operation();
           System.out.println("refine operation");
       }
   }
   

5. 创建修正实现类：RefineAbstraction的具体实现

   // 修正抽象实现类
   public class ConcreteRefineAbstractionA extends RefineAbstraction {
       public ConcreteRefineAbstractionA(IImplementor iImplementor) {
           super(iImplementor);
       }
   
       @Override
       public void operation() {
           super.operation();
           System.out.println("ConcreteRefineAbstraction");
       }
   }
   

模板测试

1. 测试代码

   public class Client {
       public static void main(String[] args) {
           // 创建一个具体的角色
           ConcreteImplementorA imp = new ConcreteImplementorA();
           // 创建一个抽象的角色，聚合实现
           RefineAbstraction abs = new ConcreteRefineAbstractionA(imp);
           // 执行操作
           abs.operation();
       }
   }
   

2. 结果

   I am ConcreteImplementorA
   refine operation
   ConcreteRefineAbstraction
   

应用场景

在生活场景中，桥接模式随处可见，比如连接起两个空间维度的桥、连接虚拟网络与真实网络的链接。
当一个类内部具备两种或多种变化维度时，使用桥接模式可以解耦这些变化的维度，使高层代码架构稳定。
桥接模式适用于以下几种业务场景。
（1）在抽象和具体实现之间需要增加更多灵活性的场景。
（2）一个类存在两个（或多个）独立变化的维度，而这两个（或多个）维度都需要独立进行扩展。 （3）不希望使用继承，或因为多层继承导致系统类的个数剧增。

注：桥接模式的一个常见使用场景就是替换继承。我们知道，继承拥有很多优点，比如，抽象、封装、多态等，父类封装共性，子类实现特性。继承可以很好地实现代码复用（封装）的功能，但这也是继承的一大缺点。因为父类拥有的方法，子类也会继承得到，无论子类需不需要，这说明继承具备强侵入性（父类代码侵入子类），同时会导致子类臃肿。因此，在设计模式中，有一个原则为优先使用组合/聚合，而不是继承。 很多时候，我们分不清该使用继承还是组合/聚合或其他方式等，其实可以从现实语义进行思考。因为软件最终还是提供给现实生活中的人使用的，是服务于人类社会的，软件是具备现实场景的。当我们从纯代码角度无法看清问题时，现实角度可能会提供更加开阔的思路。

优点

（1）分离抽象部分及其具体实现部分。
（2）提高了系统的扩展性。
（3）符合开闭原则。
（4）符合合成复用原则。

缺点

（1）增加了系统的理解与设计难度。
（2）需要正确地识别系统中两个独立变化的维度。

“生搬硬套”实战

场景描述

桥接模式的定义非常玄乎，直接理解不太容易，所以我们还是举例子。

假设某个汽车厂商生产三种品牌的汽车：Big、Tiny和Boss，每种品牌又可以选择燃油、纯电和混合动力。如果用传统的继承来表示各个最终车型，一共有3个抽象类加9个最终子类：

如果要新增一个品牌，或者加一个新的引擎（比如核动力），那么子类的数量增长更快。

所以，桥接模式就是为了避免直接继承带来的子类爆炸。

我们来看看桥接模式如何解决上述问题。

在桥接模式中，首先把Car按品牌进行子类化，但是，每个品牌选择什么发动机，不再使用子类扩充，而是通过一个抽象的“修正”类，以组合的形式引入。我们来看看具体的实现。

代码开发

1. 创建实现（这里指引擎）接口

   // 实现接口
   public interface Engine {
       void start();
   }
   

2. 创建具体实现（这里指的是各种引擎）类

   // 混动引擎实现
   public class HybridEngine implements Engine {
       public void start() {
           System.out.println("Start Hybrid Engine...");
       }
   }
   

   // 油引擎实现
   public class FuelEngine implements Engine {
       public void start() {
           System.out.println("Start Fuel Engine...");
       }
   }
   

   // 纯电引擎实现
   public class PureEngine implements Engine {
       public void start() {
           System.out.println("Start Pure Engine...");
       }
   }
   

3. 创建抽象（这里指的是车）类

   // 抽象车类
   public abstract class Car {
       // 引用Engine:
       protected Engine engine;
   
       public Car(Engine engine) {
           this.engine = engine;
       }
   
       public abstract void drive();
   }
   

4. 创建修正抽象（这里指的是修正车类）类

   // 修正车抽象类
   public abstract class RefinedCar extends Car{
       public RefinedCar(Engine engine) {
           super(engine);
       }
   
       @Override
       public void drive() {
           this.engine.start();
           System.out.println("Drive " + getBrand() + " car...");
       }
   
       public abstract String getBrand();
   }
   

5. 创建修正实现（这里指具体不同品牌的车）类

   // Boss品牌车
   public class BossCar extends RefinedCar {
       public BossCar(Engine engine) {
           super(engine);
       }
   
       @Override
       public String getBrand() {
           return "Boss";
       }
   }
   

   // Big品牌车
   public class BigCar extends RefinedCar {
       public BigCar(Engine engine) {
           super(engine);
       }
   
       @Override
       public String getBrand() {
           return "Big";
       }
   }
   

   // Tiny品牌车
   public class TinyCar extends RefinedCar {
       public TinyCar(Engine engine) {
           super(engine);
       }
   
       @Override
       public String getBrand() {
           return "Tiny";
       }
   }
   

至此，我们就通过“生搬硬套”桥梁模式的模板设计出一套替换继成的桥接模式代码，接下来我们进行测试：

• 测试代码

  public class Test {
      public static void main(String[] args) {
          RefinedCar car = new BossCar(new HybridEngine());
          car.drive();
      }
  }
  

• 结果

  Start Hybrid Engine...
  Drive Boss car...
  

总结

使用桥接模式的好处在于，如果要增加一种引擎，只需要针对Engine派生一个新的子类，如果要增加一个品牌，只需要针对RefinedCar派生一个子类，任何RefinedCar的子类都可以和任何一种Engine自由组合，即一辆汽车的两个维度：品牌和引擎都可以独立地变化。

桥接模式实现比较复杂，实际应用也非常少，但它提供的设计思想值得借鉴，即不要过度使用继承，而是优先拆分某些部件，使用组合的方式来扩展功能。