桥接模式

时间 2020-05-27 标签桥接模式

1.1桥接模式

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

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

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

1.2 模式结构和说明

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

Abstraction:
抽象部分的接口。一般在这个对象里面，要维护一个实现部分的对象引用，在抽象对象里面的方法，须要调用实现部分的对象来完成。这个对象里面的方法，一般都是跟具体的业务相关的方法。
RefinedAbstraction:
设计模式

扩展抽象部分的接口，一般在这些对象里面，定义跟实际业务相关的方法，这些方法的实现一般会使用Abstraction中定义的方法，也可能须要调用实现部分的对象来完成。
Implementor:
ide

定义实现部分的接口，这个接口不用和Abstraction里面的方法一致，一般是由Implementor接口提供基本的操做，而Abstraction里面定义的是基于这些基本操做的业务方法，也就是说Abstraction定义了基于这些基本操做的较高层次的操做。
ConcreteImplementor:
学习

真正实现Implementor接口的对象。测试

1.3 桥接模式示例代码

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

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

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

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

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

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

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

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

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

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

1.4 使用桥接模式重写示例

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

（1）先看看实现部分定义的接口，示例代码以下：

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

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

/** 
 * 抽象的消息对象 
 */  
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）看看如何具体的实现发送消息，先看站内短消息的实现吧，示例代码以下：

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

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

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

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

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

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

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）接着看看代码实现，先看看新的特急消息的处理类，示例代码以下：

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）再看看使用手机短消息的方式发送消息的实现，示例代码以下：

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

3：测试一下功能

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

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.5 桥接模式的优缺点