桥接模式Bridge.docx

桥接模式Bridge.docx

《桥接模式Bridge.docx》由会员分享，可在线阅读，更多相关《桥接模式Bridge.docx（57页珍藏版）》请在冰豆网上搜索。

桥接模式Bridge

桥接模式（Bridge）

1 场景问题

1.1 发送提示消息

       考虑这样一个实际的业务功能：

发送提示消息。

基本上所有带业务流程处理的系统都会有这样的功能，比如某人有新的工作了，需要发送一条消息提示他。

       从业务上看，消息又分成普通消息、加急消息和特急消息多种，不同的消息类型，业务功能处理是不一样的，比如加急消息是在消息上添加加急，而特急消息除了添加特急外，还会做一条催促的记录，多久不完成会继续催促。

从发送消息的手段上看，又有系统内短消息、手机短消息、邮件等等。

       现在要实现这样的发送提示消息的功能，该如何实现呢？

1.2 不用模式的解决方案

1：

实现简化版本

       先考虑实现一个简单点的版本，比如：

消息先只是实现发送普通消息，发送的方式呢，先实现系统内短消息和邮件。

其它的功能，等这个版本完成过后，再继续添加，这样先把问题简单化，实现起来会容易一点。

（1）由于发送普通消息会有两种不同的实现方式，为了让外部能统一操作，因此，把消息设计成接口，然后由两个不同的实现类，分别实现系统内短消息方式和邮件发送消息的方式。

此时系统结构如图1所示：

 图1 简化版本的系统结构示意图

下面看看大致的实现示意。

（2）先来看看消息的统一接口，示例代码如下：

Java代码

1./** 

2. * 消息的统一接口 

3. */  

4.public interface Message {  

5.    /** 

6.     * 发送消息 

7.     * @param message 要发送的消息内容 

8.     * @param toUser 消息发送的目的人员 

9.     */  

10.    public void send（String message,String toUser）;  

11.}  

/**

*消息的统一接口

*/

publicinterfaceMessage{

/**

*发送消息

*@parammessage要发送的消息内容

*@paramtoUser消息发送的目的人员

*/

publicvoidsend（Stringmessage,StringtoUser）;

}

 （3）再来分别看看两种实现方式，这里只是为了示意，并不会真的去发送Email和站内短消息，先看站内短消息的方式，示例代码如下：

Java代码

1./** 

2. * 以站内短消息的方式发送普通消息 

3. */  

4.public  class CommonMessageSMS implements Message{  

5.    public void send（String message, String toUser） {  

6.        System.out.println（"使用站内短消息的方式，发送消息'"  

7.+message+"'给"+toUser）;  

8.    }  

9.}  

/**

*以站内短消息的方式发送普通消息

*/

publicclassCommonMessageSMSimplementsMessage{

publicvoidsend（Stringmessage,StringtoUser）{

System.out.println（"使用站内短消息的方式，发送消息'"

+message+"'给"+toUser）;

}

}

同样的，实现以Email的方式发送普通消息，示例代码如下：

Java代码

1./** 

2. * 以Email的方式发送普通消息 

3. */  

4.public class CommonMessageEmail implements Message{  

5.    public void send（String message, String toUser） {  

6.        System.out.println（"使用Email的方式，发送消息'"  

7.+message+"'给"+toUser）;  

8.    }  

9.}  

/**

*以Email的方式发送普通消息

*/

publicclassCommonMessageEmailimplementsMessage{

publicvoidsend（Stringmessage,StringtoUser）{

System.out.println（"使用Email的方式，发送消息'"

+message+"'给"+toUser）;

}

}

2：

实现发送加急消息

       上面的实现，看起来很简单，对不对。

接下来，添加发送加急消息的功能，也有两种发送的方式，同样是站内短消息和Email的方式。

       加急消息的实现跟普通消息不同，加急消息会自动在消息上添加加急，然后再发送消息；另外加急消息会提供监控的方法，让客户端可以随时通过这个方法来了解对于加急消息处理的进度，比如：

相应的人员是否接收到这个信息，相应的工作是否已经开展等等。

因此加急消息需要扩展出一个新的接口，除了基本的发送消息的功能，还需要添加监控的功能，这个时候，系统的结构如图2所示：

                                     图2 加入发送加急消息后的系统结构示意图

（1）先看看扩展出来的加急消息的接口，示例代码如下：

Java代码

1./** 

2. * 加急消息的抽象接口 

3. */  

4.public interface UrgencyMessage extends Message{  

5.    /** 

6.     * 监控某消息的处理过程 

7.     * @param messageId 被监控的消息的编号 

8.     * @return 包含监控到的数据对象，这里示意一下，所以用了Object 

9.     */  

10.    public Object watch（String messageId）;  

11.}  

/**

*加急消息的抽象接口

*/

publicinterfaceUrgencyMessageextendsMessage{

/**

*监控某消息的处理过程

*@parammessageId被监控的消息的编号

*@return包含监控到的数据对象，这里示意一下，所以用了Object

*/

publicObjectwatch（StringmessageId）;

}

（2）相应的实现方式还是发送站内短消息和Email两种，同样需要两个实现类来分别实现这两种方式，先看站内短消息的方式，示例代码如下：

Java代码

1.public class UrgencyMessageSMS implements UrgencyMessage{  

2.    public void send（String message, String toUser） {  

3.        message = "加急：

"+message;  

4.        System.out.println（"使用站内短消息的方式，发送消息'"  

5.+message+"'给"+toUser）;  

6.    }  

7.  

8.    public Object watch（String messageId） {  

9.        //获取相应的数据，组织成监控的数据对象，然后返回         

10.        return null;  

11.    }     

12.}  

publicclassUrgencyMessageSMSimplementsUrgencyMessage{

publicvoidsend（Stringmessage,StringtoUser）{

message="加急：

"+message;

System.out.println（"使用站内短消息的方式，发送消息'"

+message+"'给"+toUser）;

}

publicObjectwatch（StringmessageId）{

//获取相应的数据，组织成监控的数据对象，然后返回

returnnull;

}

}

 再看看Emai的方式，示例代码如下：

Java代码

1.public class UrgencyMessageEmail implements UrgencyMessage{  

2.    public void send（String message, String toUser） {  

3.        message = "加急：

"+message;  

4.        System.out.println（"使用Email的方式，发送消息'"  

5.+message+"'给"+toUser）;  

6.    }  

7.    public Object watch（String messageId） {  

8.        //获取相应的数据，组织成监控的数据对象，然后返回         

9.        return null;  

10.    }     

11.}  

publicclassUrgencyMessageEmailimplementsUrgencyMessage{

publicvoidsend（Stringmessage,StringtoUser）{

message="加急：

"+message;

System.out.println（"使用Email的方式，发送消息'"

+message+"'给"+toUser）;

}

publicObjectwatch（StringmessageId）{

//获取相应的数据，组织成监控的数据对象，然后返回

returnnull;

}

}

 （3）事实上，在实现加急消息发送的功能上，可能会使用前面发送不同消息的功能，也就是让实现加急消息处理的对象继承普通消息的相应实现，这里为了让结构简单一点，清晰一点，所以没有这样做。

1.3 有何问题

       上面这样实现，好像也能满足基本的功能要求，可是这么实现好不好呢？

有没有什么问题呢？

       咱们继续向下来添加功能实现，为了简洁，就不再去进行代码示意了，通过实现的结构示意图就可以看出实现上的问题。

1：

继续添加特急消息的处理

       特急消息不需要查看处理进程，只要没有完成，就直接催促，也就是说，对于特急消息，在普通消息的处理基础上，需要添加催促的功能。

而特急消息、还有催促的发送方式，相应的实现方式还是发送站内短消息和Email两种，此时系统的结构如图3所示：

                                    图3 加入发送特急消息后的系统结构示意图

       仔细观察上面的系统结构示意图，会发现一个很明显的问题，那就是：

通过这种继承的方式来扩展消息处理，会非常不方便。

       你看，实现加急消息处理的时候，必须实现站内短消息和Email两种处理方式，因为业务处理可能不同；在实现特急消息处理的时候，又必须实现站内短消息和Email这两种处理方式。

       这意味着，以后每次扩展一下消息处理，都必须要实现这两种处理方式，是不是很痛苦，这还不算完，如果要添加新的实现方式呢？

继续向下看吧。

2：

继续添加发送手机消息的处理方式

       如果看到上面的实现，你还感觉问题不是很大的话，继续完成功能，添加发送手机消息的处理方式。

       仔细观察现在的实现，如果要添加一种新的发送消息的方式，是需要在每一种抽象的具体实现里面，都要添加发送手机消息的处理的。

也就是说：

发送普通消息、加急消息和特急消息的处理，都可以通过手机来发送。

这就意味着，需要添加三个实现。

此时系统结构如图4所示：

                               图4 加入发送手机消息后的系统结构示意图

      这下能体会到这种实现方式的大问题了吧。

3：

小结一下出现的问题

       采用通过继承来扩展的实现方式，有个明显的缺点：

扩展消息的种类不太容易，不同种类的消息具有不同的业务，也就是有不同的实现，在这种情况下，每个种类的消息，需要实现所有不同的消息发送方式。

       更可怕的是，如果要新加入一种消息的发送方式，那么会要求所有的消息种类，都要加入这种新的发送方式的实现。

要是考虑业务功能上再扩展一下呢？

比如：

要求实现群发消息，也就是一次可以发送多条消息，这就意味着很多地方都得修改，太恐怖了。

       那么究竟该如何实现才能既实现功能，又能灵活的扩展呢？

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接口的定义，示例代码如下：

Java代码

1./** 

2. * 定义实现部分的接口，可以与抽象部分接口的方法不一样 

3. */  

4.public interface Implementor {  

5.    /** 

6.     * 示例方法，实现抽象部分需要的某些具体功能 

7.     */  

8.    public void operationImpl（）;  

9.}  

/**

*定义实现部分的接口，可以与抽象部分接口的方法不一样

*/

publicinterfaceImplementor{

/**

*示例方法，实现抽象部分需要的某些具体功能

*/

publicvoidoperationImpl（）;

}

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

示例代码如下：

Java代码

1./** 

2. * 定义抽象部分的接口 

3. */  

4.public abstract class Abstraction {  

5.    /** 

6.     * 持有一个实现部分的对象 

7.     */  

8.    protected Implementor impl;  

9.    /** 

10.     * 构造方法，传入实现部分的对象  

11.     * @param impl 实现部分的对象 

12.     */  

13.    public Abstraction（Implementor impl）{  

14.        this.impl = impl;  

15.    }  

16.    /** 

17.     * 示例操作，实现一定的功能，可能需要转调实现部分的具体实现方法 

18.     */  

19.    public void operation（） {  

20.        impl.operationImpl（）;  

21.    }  

22.}  

/**

*定义抽象部分的接口

*/

publicabstractclassAbstraction{

/**

*持有一个实现部分的对象

*/

protectedImplementorimpl;

/**

*构造方法，传入实现部分的对象

*@paramimpl实现部分的对象

*/

publicAbstraction（Implementorimpl）{

this.impl=impl;

}

/**

*示例操作，实现一定的功能，可能需要转调实现部分的具体实现方法

*/

publicvoidoperation（）{

impl.operationImpl（）;

}

}

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

Java代码

1./** 

2. * 真正的具体实现对象 

3. */  

4.public class ConcreteImplementorA implements Implementor {  

5.    public void operationImpl（） {   

6.        //真正的实现  

7.    }  

8.}  

/**

*真正的具体实现对象

*/

publicclassConcreteImplementorAimplementsImplementor{

publicvoidoperationImpl（）{

//真正的实现

}

}

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

Java代码

1./** 

2. * 真正的具体实现对象 

3. */  

4.public class ConcreteImplementorB implements Implementor {  

5.    public void operationImpl（） {   

6.        //真正的实现  

7.    }  

8.}  

/**

*真正的具体实现对象

*/

publicclassConcreteImplementorBimplementsImplementor{

publicvoidoperationImpl（）{

//真正的实现

}

}

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

Java代码

1./** 

2. * 扩充由Abstraction定义的接口功能 

3. */  

4.public class RefinedAbstraction extends Abstraction {  

5.    public RefinedAbstraction（Implementor impl） {  

6.        super（impl）;  

7.    }  

8.    /** 

9.     * 示例操作，实现一定的功能 

10.     */  

11.    public void otherOperation（）{  

12.        //实现一定的功能，可能会使用具体实现部分的实现方法，  

13.        //但是本方法更大的可能是使用Abstraction中定义的方法，  

14.        //通过组合使用Abstraction中定义的方法来完成更多的功能  

15.    }  

16.}  

/**

*扩充由Abstraction定义的接口功能

*/

publicclassRefinedAbstractionextendsAbstraction{

publicRefinedAbstraction（Implementorimpl）{

super（impl）;

}

/**

*示例操作，实现一定的功能

*/

publicvoidotherOperation（）{

//实现一定的功能，可能会使用具体实现部分的实现方法，

//但是本方法更大的可能是使用Abstraction中定义的方法，

//通过组合使用Abstraction中定义的方法来完成更多的功能

}

}

2.4 使用桥接模式重写示例

       学习了桥接模式的基础知识过后，该来使用桥接模式重写前面的示例了。

通过示例，来看