应对软件需求变化-桥接模式的应用

一、动机

由于一个对象类型的固有逻辑，使得这个对象类型具有了两个（或多个）变化的维度。一个变化的维度为“。。。的变化”，一个变化的维度为“。。。的变化”。
如何应对这种“多维度的变化”？如何利用面向对象技术来使得这个对象类型可以轻松地沿着“。。。”和“。。。”两个方向变化，而不引入额外的复杂度？

二、需求变化过程

1、软件需求

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

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

2、需求1.0版

发送提示消息的第一个版本。最开始发送消息的需求，只需要实现发送普通消息，发送的方式只实现系统内短消息和邮件。

把消息设计成接口，然后由两个不同的实现类分别实现系统内短消息方式和邮件发送消息方式。

消息接口：

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

系统内短消息实现类：

/**
 * 以站内短消息的方式发送普通消息
 */
public  class CommonMessageSMS implements Message{

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

}

邮件发送消息实现类：

/**
 * 以Email的方式发送普通消息
 */
public class CommonMessageEmail implements Message{

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

}

客户端调用方：

public class Client {
    public static void main(String[] args) {
        Message m = new CommonMessageSMS();
        m.send("aa", "au");
        
        m = new CommonMessageEmail();
        m.send("aa", "au");
    }
}

3、需求2.0版-发送加急消息

现在来了个新需求，增加发送加急消息的功能。加急消息也有两种发送方式，站内短消息和邮件的方式。

加急消息的发送要先在消息上添加加急，然后再发送消息。另外加急消息会提供监控的方法，让客户端可以随时通过这个方法来了解对于加急消息处理的进度。因此加急消息需要扩展出一个新的接口，除了基本的发送消息的功能，还需要添加监控的功能。

加急消息的接口：

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

加急站内短消息实现类：

public class UrgencyMessageSMS implements UrgencyMessage{
    public void send(String message, String toUser) {
        message = "加急："+message;
        System.out.println("使用站内短消息的方式，发送消息'"+message+"'给"+toUser);
    }

    public Object watch(String messageId) {
        //获取相应的数据，组织成监控的数据对象，然后返回        
        return null;
    }    
}

加急Email实现类：

public class UrgencyMessageEmail implements UrgencyMessage{
    public void send(String message, String toUser) {
        message = "加急："+message;
        System.out.println("使用Email的方式，发送消息'"+message+"'给"+toUser);
    }

    public Object watch(String messageId) {
        //获取相应的数据，组织成监控的数据对象，然后返回        
        return null;
    }    
}

 4、需求3.0版-新增特急消息

特急消息只要没有完成，就直接催促。发送方式还是站内短消息和Email两种。

新增一个特急消息接口，增加两个发送方式实现类。这样有没有什么问题？

每次扩展消息处理，都必须要实现这两种处理方式。如果要添加新的处理方式呢？

5、需求4.0版-新增发送手机消息的处理方式

如果要添加一种新的发送消息的方式，就需要在每一种抽象的具体实现中，都要添加发送手机消息的处理。也就是说，需要添加三个实现。如果要再新加入一种类型的消息或者新的发送方式，新增类的速度又会进一步增加，以几何的速度增长。

那么如何才能既实现功能，有能随着需求的变化而灵活地扩展呢？

三、使用桥接模式来解决问题

1、需求1.0版

首先实现普通消息和加急消息这两种类型的功能，发送方式先实现站内短消息和Email两种。

首先看下实现部分的接口：

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

两个发送消息的实现类，第一个是发送站内短消息的实现类：

/**
 * 以站内短消息的方式发送消息
 */
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);
    }

}

然后看下抽象部分定义的抽象类：

/**
 * 抽象的消息对象
 */
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);
    }
    
}

先看看普通消息的实现类：

/**
 * 普通消息
 */
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、需求2.0版

添加对特急消息的处理，同时添加一个使用手机发送消息的方式，使用桥接模式，怎么实现呢？

只需要在抽象部分再添加一个特急消息的类，在实现部分新增一个实现类，实现用手机发送消息的方式。

首先看看特急消息的处理类：

/**
 * 特急消息
 */
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);
        //还需要增加一条待催促的信息
    }
}

发送方式手机短消息的实现类：

/**
 * 以手机短消息的方式发送消息
 */
public  class MessageMobile implements MessageImplementor{

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

客户端调用：

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("请喝一杯茶", "小李");
    }
}

四、总结

桥接模式的本质：将一个事物中多个维度的变化分离，使他们都可以独立地变化。桥接模式使用对象间的组合关系解耦了不同维度之间的绑定关系。

桥接模式体现了开闭原则和组合由于继承。避免了类层次爆炸的问题。

 当来一个新需求的时候，只需要扩展不同维度的变化，不需要修改原有代码。同时客户端代码松耦合，依赖于抽象，而非具体实现。