设计模式之结构型模式中的桥接模式（Bridge Pattern）

一、基本介绍

    桥接模式（Bridge Pattern）是一种结构型设计模式，基于类的最小设计原则，通过使用封装、聚合及继承等方式让不同的类承担不同的职责，从而把抽象(Abstraction)和实现(Implementation)分离开放在不同的层次中，使得各部分保持独立更加利于扩展。一句话来说，就是在抽象与实现之间提供一个桥梁，降低二者耦合度，达到二者可以独立变化而不互相影响的目的。

二、从“类爆炸”说起

     🌰 假如，现在有这样一个业务场景，需要对不同颜色不同品牌的手机实现相应的功能，如打电话、发短信、上网等。
    如果使用传统的方式，可能是这样的，类图如下：

    从以上的类图中，可以看出存在的问题，首先，这种方式会带来扩展性的问题，随着功能和手机品牌的增加，需要维护的类的数量也会增加,扩展性极差😖，产生“类爆炸”；其次，从类的最小设计原则考虑，当需要手机的颜色时，同时还需增加所有品牌的手机，这种设计违反了单一职责原则。

三、桥接模式

    那么，基于以上两点的考虑，借鉴单一职责原则的核心思想，尝试将对象解耦，将类的功能职责粒度分解细化,通过使用封装、聚合及继承等行为让不同的类承担不同的职责。

3.1 采用桥接模式解决问题

• 定义手机品牌接口

  /**
   * 手机品牌接口
   *
   * @author sunys
   */
  public interface PhoneBrand {
      /**
       * Call.
       * 打电话
       */
      void call();
  
      /**
       * Send message.
       * 发短信
       */
      void sendMessage();
  
      /**
       * Go online.
       * 上网
       */
      void goOnline();
  }

• 不同品牌手机接口的接口实现

  /**
   * @author sunys
   * HuaWei品牌接口实现
   */
  public class HuaWeiPhoneBrandImpl implements PhoneBrand {
      @Override
      public void call() {
          System.out.println("Call use HuaWei phone.");
      }
  
      @Override
      public void sendMessage() {
          System.out.println("SendMessage use HuaWei phone.");
      }
  
      @Override
      public void goOnline() {
          System.out.println("GoOnline use HuaWei phone.");
      }
  }

  /**
   * @author sunys
   * Apple品牌接口实现
   */
  public class ApplePhoneBrandImpl implements PhoneBrand {
      @Override
      public void call() {
          System.out.println("Call use Apple phone.");
      }
  
      @Override
      public void sendMessage() {
          System.out.println("SendMessage use Apple phone.");
      }
  
      @Override
      public void goOnline() {
          System.out.println("GoOnline use Apple phone.");
      }
  }

  /**
   * @author sunys
   * XiaoMi品牌接口实现
   */
  public class XiaoMiPhoneBrandImpl implements PhoneBrand {
      @Override
      public void call() {
          System.out.println("Call use XiaoMi phone.");
      }
  
      @Override
      public void sendMessage() {
          System.out.println("SendMessage use XiaoMi phone.");
      }
  
      @Override
      public void goOnline() {
          System.out.println("GoOnline use XiaoMi phone.");
      }
  }

• 创建手机这个抽象类，即“桥”

  /**
   * @author sunys
   * 手机抽象类 相当于“桥”
   */
  public abstract class Phone {
  
      /**
       * PhoneBrand 类聚合
       */
      private PhoneBrand phoneBrand;
  
      public Phone(PhoneBrand phoneBrand) {
          super();
          this.phoneBrand = phoneBrand;
      }
  
      protected void call() {
          this.phoneBrand.call();
      }
  
  
      protected void sendMessage() {
          this.phoneBrand.sendMessage();
      }
  
      protected void goOnline() {
          this.phoneBrand.goOnline();
      }
  }

• 不同颜色的具体手机

  /**
   * The type Phone black.
   * @author sunys
   */
  public class PhoneBlack extends Phone{
      /**
       * Instantiates a new Phone black.
       *
       * @param phoneBrand the phone brand
       */
      public PhoneBlack(PhoneBrand phoneBrand) {
          super(phoneBrand);
      }
  
      @Override
      public void call() {
          super.call();
          System.out.println("The phone of call is Black.");
      }
  
      @Override
      public void sendMessage() {
          super.sendMessage();
          System.out.println("The phone of sendMessage is Black.");
      }
  
      @Override
      public void goOnline() {
          super.goOnline();
          System.out.println("The phone of goOnline is Black.");
      }
  }

  /**
   * The type Phone red.
   *
   * @author sunys
   */
  public class PhoneRed extends Phone{
      /**
       * Instantiates a new Phone red.
       *
       * @param phoneBrand the phone brand
       */
      public PhoneRed(PhoneBrand phoneBrand) {
          super(phoneBrand);
      }
  
      @Override
      public void call() {
          super.call();
          System.out.println("The phone of call is Red.");
      }
  
      @Override
      public void sendMessage() {
          super.sendMessage();
          System.out.println("The phone of sendMessage is Red.");
      }
  
      @Override
      public void goOnline() {
          super.goOnline();
          System.out.println("The phone of goOnline is Red.");
      }
  }

  /**
   * The type Phone white.
   *
   * @author sunys
   */
  public class PhoneWhite extends Phone{
      /**
       * Instantiates a new Phone white.
       *
       * @param phoneBrand the phone brand
       */
      public PhoneWhite(PhoneBrand phoneBrand) {
          super(phoneBrand);
      }
  
      @Override
      public void call() {
          super.call();
          System.out.println("The phone of call is White.");
      }
  
      @Override
      public void sendMessage() {
          super.sendMessage();
          System.out.println("The phone of sendMessage is White.");
      }
  
      @Override
      public void goOnline() {
          super.goOnline();
          System.out.println("The phone of goOnline is White.");
      }
  }

• 客户端调用

  /**
   * The type Client.
   *
   * @author sunys
   */
  public class Client {
      /**
       * Bridge test.
       */
      public static void bridgeTest() {
          PhoneRed phoneRed = new PhoneRed(new HuaWeiPhoneBrandImpl());
          phoneRed.call();
          phoneRed.sendMessage();
          phoneRed.goOnline();
          PhoneBlack phoneBlack = new PhoneBlack(new HuaWeiPhoneBrandImpl());
          phoneBlack.call();
          phoneBlack.sendMessage();
          phoneBlack.goOnline();
          PhoneWhite phoneWhite = new PhoneWhite(new XiaoMiPhoneBrandImpl());
          phoneWhite.call();
          phoneWhite.sendMessage();
          phoneWhite.goOnline();
      }
  }

      至此，解决问题的方案改进完毕，通过这种方式，如果要添加新品牌的手机，只需让其实现PhoneBrand类即可;如果需要增加手机的颜色，只需让其继承Phone类即可。看下类图，如下：
  
      在这个方案中，Phone这个抽象类是所有具体手机的父类，也是PhoneBrand类聚合的对象，起到了关键的“桥”的作用。基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同的类承担不同的职责，将抽象与实现分离开保证不同层次独立改变互不影响更，从而极大的提高了系统的灵活性，有利于扩展。

四、桥接模式在JDBC中的应用

• 首先，来看一段客户端调用JDBC连接数据库的过程

  /**
   * The type Client.
   *
   * @author sunys
   */
  public class Client {
  
      /**
       * Jdbc test.
       */
      public static void jdbcTest(){
          try {
              // 1. 注册驱动
              Class.forName("com.mysql.jdbc.Driver");
              //2. 创建一个连接对象
              Connection conn = DriverManager.getConnection("url","user","password");
              //3. 创建一个sql语句的发送命令对象
              Statement stmt = conn.createStatement();
              // 4. 执行sql,拿到查询的结果集对象
              ResultSet rs = stmt.executeQuery("s");
              //5. 输出结果集的数据
              while(rs.next()){
                  System.out.println(rs);
              }
              //6. 关闭连接，命令对象以及结果集。
              rs.close();
              stmt.close();
              conn.close();
          } catch (ClassNotFoundException e) {
              e.printStackTrace();
          } catch (SQLException throwables) {
              throwables.printStackTrace();
          }
      }
  }

• 然后，看下相关类的UML类图
  

    从UML类图可以看出，com.mysql.jdbc.Driver类是java.sql.Driver接口的实现类，注册驱动时，会执行com.mysql.jdbc.Driver类的静态块，该静态代码块中调用java.sql.DriverManager#registerDriver(java.sql.Driver)方法，将Driver对象注册到 DriverManager中，DriverManager就相当于是“桥”;调用java.sql.DriverManager#getConnection(java.lang.String, java.lang.String, java.lang.String)创建一个连接对象时，会根据驱动的类型调用不同类型数据库（mysql、oracle等）实现的 Driver 的 connect() 方法，最终获得连接对象。

附：本次演示的项目地址
https://github.com/syshlang/java-design-patterns