桥接模式--2

2  解决方案

2.1  桥接模式来解决

        用来解决上述问题的一个合理的解决方案，就是使用桥接模式。那么什么是桥接模式呢？

（1）桥接模式定义
         将抽象部分与它的实现部分分离，使它们都可以独立地变化。

 

（2）应用桥接模式来解决的思路
        仔细分析上面的示例，根据示例的功能要求，示例的变化具有两个纬度，一个纬度是抽象的消息这边，包括普通消息、加急消息和特急消息，这几个抽象的消息本身就具有一定的关系，加急消息和特急消息会扩展普通消息；另一个纬度在具体的消息发送方式上，包括站内短消息、Email和手机短信息，这几个方式是平等的，可被切换的方式。这两个纬度一共可以组合出9种不同的可能性来，它们的关系如下图5所示：


                               图5  发送消息的可能性的组合示意图

        现在出现问题的根本原因，就在于消息的抽象和实现是混杂在一起的，这就导致了，一个纬度的变化，会引起另一个纬度进行相应的变化，从而使得程序扩展起来非常困难。
        要想解决这个问题，就必须把这两个纬度分开，也就是将抽象部分和实现部分分开，让它们相互独立，这样就可以实现独立的变化，使扩展变得简单。
        桥接模式通过引入实现的接口，把实现部分从系统中分离出去；那么，抽象这边如何使用具体的实现呢？肯定是面向实现的接口来编程了，为了让抽象这边能够很方便的与实现结合起来，把顶层的抽象接口改成抽象类，在里面持有一个具体的实现部分的实例。
        这样一来，对于需要发送消息的客户端而言，就只需要创建相应的消息对象，然后调用这个消息对象的方法就可以了，这个消息对象会调用持有的真正的消息发送方式来把消息发送出去。也就是说客户端只是想要发送消息而已，并不想关心具体如何发送。

2.2  模式结构和说明

        桥接模式的结构如图6所示：

 

                                    图6  桥接模式的结构示意图
Abstraction：
        抽象部分的接口。通常在这个对象里面，要维护一个实现部分的对象引用，在抽象对象里面的方法，需要调用实现部分的对象来完成。这个对象里面的方法，通常都是跟具体的业务相关的方法。
RefinedAbstraction：
        扩展抽象部分的接口，通常在这些对象里面，定义跟实际业务相关的方法，这些方法的实现通常会使用Abstraction中定义的方法，也可能需要调用实现部分的对象来完成。
Implementor：
        定义实现部分的接口，这个接口不用和Abstraction里面的方法一致，通常是由Implementor接口提供基本的操作，而Abstraction里面定义的是基于这些基本操作的业务方法，也就是说Abstraction定义了基于这些基本操作的较高层次的操作。
ConcreteImplementor：
        真正实现Implementor接口的对象。

2.3  桥接模式示例代码

（1）先看看Implementor接口的定义，示例代码如下：

?

1 2 3 4 5 6 7 8 9

/**   * 定义实现部分的接口，可以与抽象部分接口的方法不一样   */ public  interface  Implementor {      /**       * 示例方法，实现抽象部分需要的某些具体功能       */      public  void  operationImpl(); }

（2）再看看Abstraction接口的定义，注意一点，虽然说是接口定义，但其实是实现成为抽象类。示例代码如下：

  
  

   
   

    
    

     
     

      
      ?
     
     
     
     
 
         

           1 
         
 
         

           2 
         
 
         

           3 
         
 
         

           4 
         
 
         

           5 
         
 
         

           6 
         
 
         

           7 
         
 
         

           8 
         
 
         

           9 
         
 
         

           10 
         
 
         

           11 
         
 
         

           12 
         
 
         

           13 
         
 
         

           14 
         
 
         

           15 
         
 
         

           16 
         
 
         

           17 
         
 
         

           18 
         
 
         

           19 
         
 
         

           20 
         
 
         

           21 
         
 
         

           22 
         
 
         
 
          
 
           /** 
          
 
          
 
             
           * 定义抽象部分的接口 
          
 
          
 
             
           */ 
          
 
          
 
           public  
           abstract  
           class  
           Abstraction { 
          
 
          
 
                
           /** 
          
 
          
 
                 
           * 持有一个实现部分的对象 
          
 
          
 
                 
           */ 
          
 
          
 
                
           protected  
           Implementor impl; 
          
 
          
 
                
           /** 
          
 
          
 
                 
           * 构造方法，传入实现部分的对象  
          
 
          
 
                 
           * @param impl 实现部分的对象 
          
 
          
 
                 
           */ 
          
 
          
 
                
           public  
           Abstraction(Implementor impl){ 
          
 
          
 
                    
           this 
           .impl = impl; 
          
 
          
 
                
           } 
          
 
          
 
                
           /** 
          
 
          
 
                 
           * 示例操作，实现一定的功能，可能需要转调实现部分的具体实现方法 
          
 
          
 
                 
           */ 
          
 
          
 
                
           public  
           void  
           operation() { 
          
 
          
 
                    
           impl.operationImpl(); 
          
 
          
 
                
           } 
          
 
          
 
           } 
          
 
         
    
    
   
   

  
  

（3）该来看看具体的实现了，示例代码如下：

  
  

   
   

    
    

     
     

      
      ?
     
     
     
     
 
         

           1 
         
 
         

           2 
         
 
         

           3 
         
 
         

           4 
         
 
         

           5 
         
 
         

           6 
         
 
         

           7 
         
 
         

           8 
         
 
         
 
          
 
           /** 
          
 
          
 
             
           * 真正的具体实现对象 
          
 
          
 
             
           */ 
          
 
          
 
           public  
           class  
           ConcreteImplementorA implements Implementor { 
          
 
          
 
                
           public  
           void  
           operationImpl() {  
          
 
          
 
                    
           //真正的实现 
          
 
          
 
                
           } 
          
 
          
 
           } 
          
 
         
    
    
   
   

  
  

另外一个实现，示例代码如下：

  
  

   
   

    
    

     
     

      
      ?
     
     
     
     
 
         

           1 
         
 
         

           2 
         
 
         

           3 
         
 
         

           4 
         
 
         

           5 
         
 
         

           6 
         
 
         

           7 
         
 
         

           8 
         
 
         
 
          
 
           /** 
          
 
          
 
             
           * 真正的具体实现对象 
          
 
          
 
             
           */ 
          
 
          
 
           public  
           class  
           ConcreteImplementorB implements Implementor { 
          
 
          
 
                
           public  
           void  
           operationImpl() {  
          
 
          
 
                    
           //真正的实现 
          
 
          
 
                
           } 
          
 
          
 
           } 
          
 
         
    
    
   
   

  
  

（4）最后来看看扩展Abstraction接口的对象实现，示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

/**   * 扩充由Abstraction定义的接口功能   */ public  class  RefinedAbstraction extends Abstraction {      public  RefinedAbstraction(Implementor impl) {          super(impl);      }      /**       * 示例操作，实现一定的功能       */      public  void  otherOperation(){          //实现一定的功能，可能会使用具体实现部分的实现方法，          //但是本方法更大的可能是使用Abstraction中定义的方法，          //通过组合使用Abstraction中定义的方法来完成更多的功能      } }

 

2.4  使用桥接模式重写示例

        学习了桥接模式的基础知识过后，该来使用桥接模式重写前面的示例了。通过示例，来看看使用桥接模式来实现同样的功能，是否能解决“既能方便的实现功能，又能有很好的扩展性”的问题。
        要使用桥接模式来重新实现前面的示例，首要任务就是要把抽象部分和实现部分分离出来，分析要实现的功能，抽象部分就是各个消息的类型所对应的功能，而实现部分就是各种发送消息的方式。
        其次要按照桥接模式的结构，给抽象部分和实现部分分别定义接口，然后分别实现它们就可以了。
1：从简单功能开始
        从相对简单的功能开始，先实现普通消息和加急消息的功能，发送方式先实现站内短消息和Email这两种。 
        使用桥接模式来实现这些功能的程序结构如图7所示


                      图7  使用桥接模式来实现简单功能示例的程序结构示意图
 还是看看代码实现，会更清楚一些。
（1）先看看实现部分定义的接口，示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11

/**   * 实现发送消息的统一接口   */ public  interface  MessageImplementor {      /**       * 发送消息       * @param message 要发送的消息内容       * @param toUser 消息发送的目的人员       */      public  void  send(String message,String toUser); }

（2）再看看抽象部分定义的接口，示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

/**   * 抽象的消息对象   */ public  abstract  class  AbstractMessage {      /**       * 持有一个实现部分的对象       */      protected  MessageImplementor impl;      /**       * 构造方法，传入实现部分的对象       * @param impl 实现部分的对象       */      public  AbstractMessage(MessageImplementor impl){          this .impl = impl;      }      /**       * 发送消息，转调实现部分的方法       * @param message 要发送的消息内容       * @param toUser 消息发送的目的人员       */      public  void  sendMessage(String message,String toUser){          this .impl.send(message, toUser);      }   }

（3）看看如何具体的实现发送消息，先看站内短消息的实现吧，示例代码如下：

?

1 2 3 4 5 6 7 8 9

/**   * 以站内短消息的方式发送消息   */ public   class  MessageSMS implements MessageImplementor{      public  void  send(String message, String toUser) {          System. out .println( "使用站内短消息的方式，发送消息'" +message+ "'给" +toUser);      } }

再看看Email方式的实现，示例代码如下：

?

1 2 3 4 5 6 7 8 9

/**   * 以Email的方式发送消息   */ public  class  MessageEmail implements MessageImplementor{      public  void  send(String message, String toUser) {          System. out .println( "使用Email的方式，发送消息'"                                 +message+ "'给" +toUser);      } }

（4）接下来该看看如何扩展抽象的消息接口了，先看普通消息的实现，示例代码如下：

?

1 2 3 4 5 6 7 8 9

public  class  CommonMessage extends AbstractMessage{      public  CommonMessage(MessageImplementor impl) {          super(impl);      }      public  void  sendMessage(String message, String toUser) {          //对于普通消息，什么都不干，直接调父类的方法，把消息发送出去就可以了          super.sendMessage(message, toUser);      }   }

再看看加急消息的实现，示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public  class  UrgencyMessage extends AbstractMessage{      public  UrgencyMessage(MessageImplementor impl) {          super(impl);      }      public  void  sendMessage(String message, String toUser) {          message = "加急：" +message;          super.sendMessage(message, toUser);      }      /**       * 扩展自己的新功能：监控某消息的处理过程       * @param messageId 被监控的消息的编号       * @return 包含监控到的数据对象，这里示意一下，所以用了Object       */      public  Object watch(String messageId) {          //获取相应的数据，组织成监控的数据对象，然后返回                return  null ;      }   }

 

2：添加功能
        看了上面的实现，发现使用桥接模式来实现也不是很困难啊，关键得看是否能解决前面提出的问题，那就来添加还未实现的功能看看，添加对特急消息的处理，同时添加一个使用手机发送消息的方式。该怎么实现呢？
        很简单，只需要在抽象部分再添加一个特急消息的类，扩展抽象消息就可以把特急消息的处理功能加入到系统中了；对于添加手机发送消息的方式也很简单，在实现部分新增加一个实现类，实现用手机发送消息的方式，也就可以了。
        这么简单？好像看起来完全没有了前面所提到的问题。的确如此，采用桥接模式来实现过后，抽象部分和实现部分分离开了，可以相互独立的变化，而不会相互影响。因此在抽象部分添加新的消息处理，对发送消息的实现部分是没有影响的；反过来增加发送消息的方式，对消息处理部分也是没有影响的。
（1）接着看看代码实现，先看看新的特急消息的处理类，示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13

public  class  SpecialUrgencyMessage extends  AbstractMessage{      public  SpecialUrgencyMessage(MessageImplementor impl) {          super (impl);      }      public  void  hurry(String messageId) {          //执行催促的业务，发出催促的信息      }      public  void  sendMessage(String message, String toUser) {          message = "特急：" +message;          super .sendMessage(message, toUser);          //还需要增加一条待催促的信息      } }

（2）再看看使用手机短消息的方式发送消息的实现，示例代码如下：

?

1 2 3 4 5 6 7 8 9

/**   * 以手机短消息的方式发送消息   */ public   class  MessageMobile implements  MessageImplementor{      public  void  send(String message, String toUser) {          System.out.println( "使用手机短消息的方式，发送消息'" +message+ "'给" +toUser);      } }

 

3：测试一下功能

        看了上面的实现，可能会感觉得到，使用桥接模式来实现前面的示例过后，添加新的消息处理，或者是新的消息发送方式是如此简单，可是这样实现，好用吗？写个客户端来测试和体会一下，示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

public  class  Client {      public  static  void  main(String[] args) {          //创建具体的实现对象          MessageImplementor impl = new  MessageSMS();          //创建一个普通消息对象          AbstractMessage m = new  CommonMessage(impl);          m.sendMessage( "请喝一杯茶" , "小李" );                //创建一个紧急消息对象          m = new  UrgencyMessage(impl);          m.sendMessage( "请喝一杯茶" , "小李" );                //创建一个特急消息对象          m = new  SpecialUrgencyMessage(impl);          m.sendMessage( "请喝一杯茶" , "小李" );                    //把实现方式切换成手机短消息，然后再实现一遍          impl = new  MessageMobile();          m = new  CommonMessage(impl);          m.sendMessage( "请喝一杯茶" , "小李" );          m = new  UrgencyMessage(impl);          m.sendMessage( "请喝一杯茶" , "小李" );          m = new  SpecialUrgencyMessage(impl);          m.sendMessage( "请喝一杯茶" , "小李" );      } }

运行结果如下：

?

1 2 3 4 5 6

使用站内短消息的方式，发送消息 '请喝一杯茶' 给小李 使用站内短消息的方式，发送消息 '加急：请喝一杯茶' 给小李 使用站内短消息的方式，发送消息 '特急：请喝一杯茶' 给小李 使用手机短消息的方式，发送消息 '请喝一杯茶' 给小李 使用手机短消息的方式，发送消息 '加急：请喝一杯茶' 给小李 使用手机短消息的方式，发送消息 '特急：请喝一杯茶' 给小李

 

        前面三条是使用的站内短消息，后面三条是使用的手机短消息，正确的实现了预期的功能。看来前面的实现应该是正确的，能够完成功能，且能灵活扩展。 http://www.cnblogs.com/sjms/archive/2010/09/06/1818782.html 

 未完待续