研磨设计模式之 桥接模式

2010-09-20 作者：云飞龙行 来源：云飞龙行的blog

 

来写一个大家既陌生又熟悉的设计模式，也是非常实用的一个设计模式，那就是桥接模式。

说陌生是很多朋友并不熟悉这个设计模式，说熟悉是很多人经常见到或者是下意识的用到这个设计模式，只是不知道罢了。桥接模式是非常实用的一个模式，下面就来写写它。

桥接模式（Bridge）

1  场景问题

1.1  发送提示消息

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

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

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

1.2  不用模式的解决方案

1：实现简化版本

先考虑实现一个简单点的版本，比如：消息先只是实现发送普通消息，发送的方式呢，先实现系统内短消息和邮件。其它的功能，等这个版本完成过后，再继续添加，这样先把问题简单化，实现起来会容易一点。

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

 

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

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

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

01 /**
02  * 消息的统一接口
03  */
04 public interface Message {
05     /**
06      * 发送消息
07      * @param message 要发送的消息内容
08      * @param toUser 消息发送的目的人员
09      */
10     public void send(String message,String toUser);
11 }

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

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 }

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

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 }

2：实现发送加急消息

上面的实现，看起来很简单，对不对。接下来，添加发送加急消息的功能，也有两种发送的方式，同样是站内短消息和Email的方式。

加急消息的实现跟普通消息不同，加急消息会自动在消息上添加加急，然后再发送消息；另外加急消息会提供监控的方法，让客户端可以随时通过这个方法来了解对于加急消息处理的进度，比如：相应的人员是否接收到这个信息，相应的工作是否已经开展等等。因此加急消息需要扩展出一个新的接口，除了基本的发送消息的功能，还需要添加监控的功能，这个时候，系统的结构如图2所示：

 
 

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

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

01 /**
02  * 加急消息的抽象接口
03  */
04 public interface UrgencyMessage extends Message{
05     /**
06      * 监控某消息的处理过程
07      * @param messageId 被监控的消息的编号
08      * @return 包含监控到的数据对象，这里示意一下，所以用了Object
09      */
10     public Object watch(String messageId);
11 }

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

01 public class UrgencyMessageSMS implements UrgencyMessage{
02     public void send(String message, String toUser) {
03         message = "加急："+message;
04         System.out.println("使用站内短消息的方式，发送消息'"
05 +message+"'给"+toUser);
06     }
07   
08     public Object watch(String messageId) {
09         //获取相应的数据，组织成监控的数据对象，然后返回       
10         return null;
11     }   
12 }

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

01 public class UrgencyMessageEmail implements UrgencyMessage{
02     public void send(String message, String toUser) {
03         message = "加急："+message;
04         System.out.println("使用Email的方式，发送消息'"
05 +message+"'给"+toUser);
06     }
07     public Object watch(String messageId) {
08         //获取相应的数据，组织成监控的数据对象，然后返回       
09         return null;
10     }   
11 }

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

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

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

01 /**
02  * 定义抽象部分的接口
03  */
04 public abstract class Abstraction {
05     /**
06      * 持有一个实现部分的对象
07      */
08     protected Implementor impl;
09     /**
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 }

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

1 /**
2  * 真正的具体实现对象
3  */
4 public class ConcreteImplementorA implements Implementor {
5     public void operationImpl() { 
6         //真正的实现
7     }
8 }

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

1 /**
2  * 真正的具体实现对象
3  */
4 public class ConcreteImplementorB implements Implementor {
5     public void operationImpl() { 
6         //真正的实现
7     }
8 }

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

01 /**
02  * 扩充由Abstraction定义的接口功能
03  */
04 public class RefinedAbstraction extends Abstraction {
05     public RefinedAbstraction(Implementor impl) {
06         super(impl);
07     }
08     /**
09      * 示例操作，实现一定的功能
10      */
11     public void otherOperation(){
12         //实现一定的功能，可能会使用具体实现部分的实现方法，
13         //但是本方法更大的可能是使用Abstraction中定义的方法，
14         //通过组合使用Abstraction中定义的方法来完成更多的功能
15     }
16 }

2.4  使用桥接模式重写示例

学习了桥接模式的基础知识过后，该来使用桥接模式重写前面的示例了。通过示例，来看看使用桥接模式来实现同样的功能，是否能解决“既能方便的实现功能，又能有很好的扩展性”的问题。

要使用桥接模式来重新实现前面的示例，首要任务就是要把抽象部分和实现部分分离出来，分析要实现的功能，抽象部分就是各个消息的类型所对应的功能，而实现部分就是各种发送消息的方式。

其次要按照桥接模式的结构，给抽象部分和实现部分分别定义接口，然后分别实现它们就可以了。

1：从简单功能开始

从相对简单的功能开始，先实现普通消息和加急消息的功能，发送方式先实现站内短消息和Email这两种。 

使用桥接模式来实现这些功能的程序结构如图7所示

图7  使用桥接模式来实现简单功能示例的程序结构示意图

还是看看代码实现，会更清楚一些。

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

01 /**
02  * 实现发送消息的统一接口
03  */
04 public interface MessageImplementor {
05     /**
06      * 发送消息
07      * @param message 要发送的消息内容
08      * @param toUser 消息发送的目的人员
09      */
10     public void send(String message,String toUser);
11 }

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

01 /**
02  * 抽象的消息对象
03  */
04 public abstract class AbstractMessage {
05     /**
06      * 持有一个实现部分的对象
07      */
08     protected MessageImplementor impl;
09     /**
10      * 构造方法，传入实现部分的对象 
11      * @param impl 实现部分的对象
12      */
13     public AbstractMessage(MessageImplementor impl){
14         this.impl = impl;
15     }
16     /**
17      * 发送消息，转调实现部分的方法
18      * @param message 要发送的消息内容
19      * @param toUser 消息发送的目的人员
20      */
21     public void sendMessage(String message,String toUser){
22         this.impl.send(message, toUser);
23     }   
24 }

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

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

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

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

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

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

再看看加急消息的

01 public class UrgencyMessage extends AbstractMessage{

实现，示例代码如下：

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

2：添加功能

看了上面的实现，发现使用桥接模式来实现也不是很困难啊，关键得看是否能解决前面提出的问题，那就来添加还未实现的功能看看，添加对特急消息的处理，同时添加一个使用手机发送消息的方式。该怎么实现呢？

很简单，只需要在抽象部分再添加一个特急消息的类，扩展抽象消息就可以把特急消息的处理功能加入到系统中了；对于添加手机发送消息的方式也很简单，在实现部分新增加一个实现类，实现用手机发送消息的方式，也就可以了。

这么简单？好像看起来完全没有了前面所提到的问题。的确如此，采用桥接模式来实现过后，抽象部分和实现部分分离开了，可以相互独立的变化，而不会相互影响。因此在抽象部分添加新的消息处理，对发送消息的实现部分是没有影响的；反过来增加发送消息的方式，对消息处理部分也是没有影响的。

（1）接着看看代码实现，先看看新的特急消息的处理类，示例代码如下：

01 public class SpecialUrgencyMessage extends AbstractMessage{
02     public SpecialUrgencyMessage(MessageImplementor impl) {
03         super(impl);
04     }
05     public void hurry(String messageId) {
06         //执行催促的业务，发出催促的信息
07     }
08     public void sendMessage(String message, String toUser) {
09         message = "特急："+message;
10         super.sendMessage(message, toUser);
11         //还需要增加一条待催促的信息
12     }
13 }

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

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

3：测试一下功能

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

01 public class Client {
02     public static void main(String[] args) {
03         //创建具体的实现对象
04         MessageImplementor impl = new MessageSMS();
05         //创建一个普通消息对象
06         AbstractMessage m = new CommonMessage(impl);
07         m.sendMessage("请喝一杯茶", "小李");       
08         //创建一个紧急消息对象
09         m = new UrgencyMessage(impl);
10         m.sendMessage("请喝一杯茶", "小李");       
11         //创建一个特急消息对象
12         m = new SpecialUrgencyMessage(impl);
13         m.sendMessage("请喝一杯茶", "小李");
14           
15         //把实现方式切换成手机短消息，然后再实现一遍
16         impl = new MessageMobile();
17         m = new CommonMessage(impl);
18         m.sendMessage("请喝一杯茶", "小李");
19         m = new UrgencyMessage(impl);
20         m.sendMessage("请喝一杯茶", "小李");
21         m = new SpecialUrgencyMessage(impl);
22         m.sendMessage("请喝一杯茶", "小李");
23     }
24 }

运行结果如下：

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

前面三条是使用的站内短消息，后面三条是使用的手机短消息，正确的实现了预期的功能。看来前面的实现应该是正确的，能够完成功能，且能灵活扩展。 

3  模式讲解

3.1  认识桥接模式

（1）什么是桥接

在桥接模式里面，不太好理解的就是桥接的概念，什么是桥接？为何需要桥接？如何桥接？把这些问题搞清楚了，也就基本明白桥接的含义了。

一个一个来，先看什么是桥接？所谓桥接，通俗点说就是在不同的东西之间搭一个桥，让他们能够连接起来，可以相互通讯和使用。那么在桥接模式中到底是给什么东西来搭桥呢？就是为被分离了的抽象部分和实现部分来搭桥，比如前面示例中抽象的消息和具体消息发送之间搭个桥。

但是这里要注意一个问题：在桥接模式中的桥接是单向的，也就是只能是抽象部分的对象去使用具体实现部分的对象，而不能反过来，也就是个单向桥。

（2）为何需要桥接

为了达到让抽象部分和实现部分都可以独立变化的目的，在桥接模式中，是把抽象部分和实现部分分离开来的，虽然从程序结构上是分开了，但是在抽象部分实现的时候，还是需要使用具体的实现的，这可怎么办呢？抽象部分如何才能调用到具体实现部分的功能呢？很简单，搭个桥不就可以了，搭个桥，让抽象部分通过这个桥就可以调用到实现部分的功能了，因此需要桥接。

（3）如何桥接

这个理解上也很简单，只要让抽象部分拥有实现部分的接口对象，这就桥接上了，在抽象部分就可以通过这个接口来调用具体实现部分的功能。也就是说，桥接在程序上就体现成了在抽象部分拥有实现部分的接口对象，维护桥接就是维护这个关系。

（4）独立变化

桥接模式的意图：使得抽象和实现可以独立变化，都可以分别扩充。也就是说抽象部分和实现部分是一种非常松散的关系，从某个角度来讲，抽象部分和实现部分是可以完全分开的，独立的，抽象部分不过是一个使用实现部分对外接口的程序罢了。

如果这么看桥接模式的话，就类似于策略模式了，抽象部分需要根据某个策略，来选择真实的实现，也就是说桥接模式的抽象部分相当于策略模式的上下文。更原始的就直接类似于面向接口编程，通过接口分离的两个部分而已。但是别忘了，桥接模式的抽象部分，是可以继续扩展和变化的，而策略模式只有上下文，是不存在所谓抽象部分的。

那抽象和实现为何还要组合在一起呢？原因是在抽象部分和实现部分还是存在内部联系的，抽象部分的实现通常是需要调用实现部分的功能来实现的。

（5）动态变换功能

由于桥接模式中的抽象部分和实现部分是完全分离的，因此可以在运行时动态组合具体的真实实现，从而达到动态变换功能的目的。

从另外一个角度看，抽象部分和实现部分没有固定的绑定关系了，因此同一个真实实现可以被不同的抽象对象使用，反过来，同一个抽象也可以有多个不同的实现。就像前面示例的那样，比如：站内短消息的实现功能，可以被普通消息、加急消息或是特急消息等不同的消息对象使用；反过来，某个消息具体的发送方式，可以是站内短消息，或者是Email，也可以是手机短消息等具体的发送方式。

（6）退化的桥接模式

如果Implementor仅有一个实现，那么就没有必要创建 Implementor接口了，这是一种桥接模式退化的情况。这个时候Abstraction和Implementor是一对一的关系，虽然如此，也还是要保持它们的分离状态，这样的话，它们才不会相互影响，才可以分别扩展。

也就是说，就算不要Implementor接口了，也要保持Abstraction和Implementor是分离的，模式的分离机制仍然是非常有用的。

（7）桥接模式和继承

继承是扩展对象功能的一种常见手段，通常情况下，继承扩展的功能变化纬度都是一纬的，也就是变化的因素只有一类。

对于出现变化因素有两类的，也就是有两个变化纬度的情况，继承实现就会比较痛苦。比如上面的示例，就有两个变化纬度，一个是消息的类别，不同的消息类别处理不同；另外一个是消息的发送方式。

从理论上来说，如果用继承的方式来实现这种有两个变化纬度的情况，最后实际的实现类应该是两个纬度上可变数量的乘积那么多个。比如上面的示例，在消息类别的纬度上，目前的可变数量是3个，普通消息、加急消息和特急消息；在消息发送方式的纬度上，目前的可变数量也是3个，站内短消息、Email和手机短消息。这种情况下，如果要实现全的话，那么需要的实现类应该是：3 X 3 = 9个。

如果要在任何一个纬度上进行扩展，都需要实现另外一个纬度上的可变数量那么多个实现类，这也是为何会感到扩展起来很困难。而且随着程序规模的加大，会越来越难以扩展和维护。

而桥接模式就是用来解决这种有两个变化纬度的情况下，如何灵活的扩展功能的一个很好的方案。其实，桥接模式主要是把继承改成了使用对象组合，从而把两个纬度分开，让每一个纬度单独去变化，最后通过对象组合的方式，把两个纬度组合起来，每一种组合的方式就相当于原来继承中的一种实现，这样就有效的减少了实际实现的类的个数。

从理论上来说，如果用桥接模式的方式来实现这种有两个变化纬度的情况，最后实际的实现类应该是两个纬度上可变数量的和那么多个。同样是上面那个示例，使用桥接模式来实现，实现全的话，最后需要的实现类的数目应该是：3 + 3 = 6个。

这也从侧面体现了，使用对象组合的方式比继承要来得更灵活。

（8）桥接模式的调用顺序示意图

桥接模式的调用顺序如图8所示：

图8  桥接模式的调用顺序示意图

3.2  谁来桥接

所谓谁来桥接，就是谁来负责创建抽象部分和实现部分的关系，说得更直白点，就是谁来负责创建Implementor的对象，并把它设置到抽象部分的对象里面去，这点对于使用桥接模式来说，是十分重要的一点。

大致有如下几种实现方式：

  • 由客户端负责创建Implementor的对象，并在创建抽象部分的对象的时候，把它设置到抽象部分的对象里面去，前面的示例采用的就是这个方式
  • 可以在抽象部分的对象构建的时候，由抽象部分的对象自己来创建相应的Implementor的对象，当然可以给它传递一些参数，它可以根据参数来选择并创建具体的Implementor的对象
  • 可以在Abstraction中选择并创建一个缺省的Implementor的对象，然后子类可以根据需要改变这个实现
  • 也可以使用抽象工厂或者简单工厂来选择并创建具体的Implementor的对象，抽象部分的类可以通过调用工厂的方法来获取Implementor的对象
  • 如果使用IoC/DI容器的话，还可以通过IoC/DI容器来创建具体的Implementor的对象，并注入回到Abstraction中

下面分别给出后面几种实现方式的示例。

1：由抽象部分的对象自己来创建相应的Implementor的对象

对于这种情况的实现，又分成两种，一种是需要外部传入参数，一种是不需要外部传入参数。

（1）从外面传递参数比较简单，比如前面的示例，如果用一个type来标识具体采用哪种发送消息的方案，然后在Abstraction的构造方法中，根据type进行创建就好了。

还是代码示例一下，主要修改Abstraction的构造方法，示例代码如下：

01 /**
02  * 抽象的消息对象
03  */
04 public abstract class AbstractMessage {
05     /**
06      * 持有一个实现部分的对象
07      */
08     protected MessageImplementor impl;
09     /**
10      * 构造方法，传入选择实现部分的类型 
11      * @param type 传入选择实现部分的类型
12      */
13     public AbstractMessage(int type){
14         if(type==1){
15             this.impl = new MessageSMS();
16         }else if(type==2){
17             this.impl = new MessageEmail();
18         }else if(type==3){
19             this.impl = new MessageMobile();
20         }
21     }   
22     /**
23      * 发送消息，转调实现部分的方法
24      * @param message 要发送的消息内容
25      * @param toUser 把消息发送的目的人员
26      */
27     public void sendMessage(String message,String toUser){
28         this.impl.send(message, toUser);
29     }   
30 }

（2）对于不需要外部传入参数的情况，那就说明是在Abstraction的实现中，根据具体的参数数据来选择相应的Implementor对象。有可能在Abstraction的构造方法中选，也有可能在具体的方法中选。
        比如前面的示例，如果发送的消息长度在100以内采用手机短消息，长度在100-1000采用站内短消息，长度在1000以上采用Email，那么就可以在内部方法中自己判断实现了。
        实现中，大致有如下改变：

  • 原来protected的MessageImplementor类型的属性，不需要了，去掉
  • 提供一个protected的方法来获取要使用的实现部分的对象，在这个方法里面，根据消息的长度来选择合适的实现对象
  • 构造方法什么都不用做了，也不需要传入参数
  • 在原来使用impl属性的地方，要修改成通过上面那个方法来获取合适的实现对象了，不能直接使用impl属性，否则会没有值

示例代码如下：

01 public abstract class AbstractMessage {
02     /**
03      * 构造方法
04      */
05     public AbstractMessage(){
06         //现在什么都不做了
07     }
08     /**
09      * 发送消息，转调实现部分的方法
10      * @param message 要发送的消息内容
11      * @param toUser 把消息发送的目的人员
12      */
13     public void sendMessage(String message,String toUser){      
14         this.getImpl(message).send(message, toUser);
15     }
16 /**
17      * 根据消息的长度来选择合适的实现
18      * @param message 要发送的消息
19      * @return 合适的实现对象
20      */
21     protected MessageImplementor getImpl(String message) {
22         MessageImplementor impl = null;
23         if(message == null){
24             //如果没有消息，默认使用站内短消息
25             impl = new MessageSMS();
26         }else if(message.length()< 100){
27             //如果消息长度在100以内，使用手机短消息
28             impl = new MessageMobile();
29         }else if(message.length()<1000){
30             //如果消息长度在100-1000以内，使用站内短消息
31             impl = new MessageSMS();
32         }else{
33             //如果消息长度在1000以上
34             impl = new MessageEmail();
35         }
36         return impl;
37     }
38 }

（3）小结一下

对于由抽象部分的对象自己来创建相应的Implementor的对象的这种情况，不管是否需要外部传入参数，优点是客户使用简单，而且集中控制 Implementor对象的创建和切换逻辑；缺点是要求Abstraction知道所有的具体的Implementor实现，并知道如何选择和创建它们，如果今后要扩展Implementor的实现，就要求同时修改Abstraction的实现，这会很不灵活，使扩展不方便。

2：在Abstraction中创建缺省的Implementor对象

对于这种方式，实现比较简单，直接在Abstraction的构造方法中，创建一个缺省的Implementor对象，然后子类根据需要，看是直接使用还是覆盖掉。示例代码如下：

01 public abstract class AbstractMessage {
02     protected MessageImplementor impl;
03     /**
04      * 构造方法
05      */
06     public AbstractMessage(){
07         //创建一个默认的实现
08         this.impl = new MessageSMS();
09     }
10     public void sendMessage(String message,String toUser){
11         this.impl.send(message, toUser);
12     }
13 }
 

这种方式其实还可以使用工厂方法，把创建工作延迟到子类。

3：使用抽象工厂或者是简单工厂

对于这种方式，根据具体的需要来选择，如果是想要创建一系列实现对象，那就使用抽象工厂，如果是创建单个的实现对象，那就使用简单工厂就可以了。

直接在原来创建Implementor对象的地方，直接调用相应的抽象工厂或者是简单工厂，来获取相应的Implementor对象，很简单，这个就不去示例了。

这种方法的优点是Abstraction类不用和任何一个Implementor类直接耦合。

4：使用IoC/DI的方式

对于这种方式，Abstraction的实现就更简单了，只需要实现注入Implementor对象的方法就可以了，其它的Abstraction就不管了。

IoC/DI容器会负责创建Implementor对象，并设置回到Abstraction对象中，使用IoC/DI的方式，并不会改变 Abstraction和Implementor的关系，Abstraction同样需要持有相应的Implementor对象，同样会把功能委托给 Implementor对象去实现。

3.3  典型例子-JDBC

在Java应用中，对于桥接模式有一个非常典型的例子，就是：应用程序使用JDBC驱动程序进行开发的方式。所谓驱动程序，指的是按照预先约定好的接口来操作计算机系统或者是外围设备的程序。

先简单的回忆一下使用JDBC进行开发的过程，简单的片断代码示例如下：

01 String sql = "具体要操作的sql语句";
02         // 1：装载驱动
03         Class.forName("驱动的名字");
04         // 2：创建连接
05         Connection conn = DriverManager.getConnection(
06 "连接数据库服务的URL", "用户名","密码");
07   
08         // 3：创建statement或者是preparedStatement
09         PreparedStatement pstmt = conn.prepareStatement(sql);
10         // 4：执行sql，如果是查询，再获取ResultSet
11         ResultSet rs = pstmt.executeQuery(sql);
12   
13         // 5：循环从ResultSet中把值取出来，封装到数据对象中去
14         while (rs.next()) {
15             // 取值示意，按名称取值
16             String uuid = rs.getString("uuid");
17             // 取值示意，按索引取值
18             int age = rs.getInt(2);
19         }
20         //6：关闭
21         rs.close();
22         pstmt.close();
23         conn.close();

从上面的示例可以看出，我们写的应用程序，是面向JDBC的API在开发，这些接口就相当于桥接模式中的抽象部分的接口。那么怎样得到这些API的呢？是通过DriverManager来得到的。此时的系统结构如图9所示：

 图9  基于JDBC开发的应用程序结构示意图

那么这些JDBC的API，谁去实现呢？光有接口，没有实现也不行啊。

该驱动程序登场了，JDBC的驱动程序实现了JDBC的API，驱动程序就相当于桥接模式中的具体实现部分。而且不同的数据库，由于数据库实现不一样，可执行的Sql也不完全一样，因此对于JDBC驱动的实现也是不一样的，也就是不同的数据库会有不同的驱动实现。此时驱动程序这边的程序结构如图10所示：

图10  驱动程序实现结构示意图

有了抽象部分——JDBC的API，有了具体实现部分——驱动程序，那么它们如何连接起来呢？就是如何桥接呢？

就是前面提到的DriverManager来把它们桥接起来，从某个侧面来看，DriverManager在这里起到了类似于简单工厂的功能，基于JDBC的应用程序需要使用JDBC的API，如何得到呢？就通过DriverManager来获取相应的对象。

那么此时系统的整体结构如图11所示：

图11  JDBC的结构示意图

通过上图可以看出，基于JDBC的应用程序，使用JDBC的 API，相当于是对数据库操作的抽象的扩展，算作桥接模式的抽象部分；而具体的接口实现是由驱动来完成的，驱动这边自然就相当于桥接模式的实现部分了。而桥接的方式，不再是让抽象部分持有实现部分，而是采用了类似于工厂的做法，通过DriverManager来把抽象部分和实现部分对接起来，从而实现抽象部分和实现部分解耦。 

JDBC的这种架构，把抽象和具体分离开来，从而使得抽象和具体部分都可以独立扩展。对于应用程序而言，只要选用不同的驱动，就可以让程序操作不同的数据库，而无需更改应用程序，从而实现在不同的数据库上移植；对于驱动程序而言，为数据库实现不同的驱动程序，并不会影响应用程序。而且，JDBC的这种架构，还合理的划分了应用程序开发人员和驱动程序开发人员的边界。

对于有些朋友会认为，从局部来看，体现了策略模式，比如在上面的结构中去掉“JDBC的API和基于JDBC的应用程序”这边，那么剩下的部分，看起来就是一个策略模式的体现。此时的DriverManager就相当于上下文，而各个具体驱动的实现就相当于是具体的策略实现，这个理解也不算错，但是在这里看来，这么理解是比较片面的。

对于这个问题，再次强调一点：对于设计模式，要从整体结构上、从本质目标上、从思想体现上来把握，而不要从局部、从表现、从特例实现上来把握。
posted @ 2011-11-28 16:50  Flying Dreams  阅读(188)  评论(0)  编辑  收藏  举报