第9章 结构型模式—桥接模式

1. 桥接模式（Bridge Pattern）的定义

（1）将抽象部分与它的实现部分分离，使它们都可以独立地变化

　　①一般的“抽象”与“实现”是指父子类的继承关系。但这里，GoF所谓的“抽象”是如果引起一个类变化是多维度的因素（设为2维），就将其他变化因素抽象成一个接口，在“Abstraction类”中只留这个接口，然后通过对象组合（而不是继承）的方式去依赖这个接口。而“实现”是指在让另一个“Implementor类”的子类去实现接口（第2维度的变化）。

　　② “Abstraction类”和“Implementor类”分别代表了引起类变化的两个维度（前者是个抽象类、后者是接口），正因为这种分离，所以他们都可以独立的变化。

　　③简单的理解就是，在类中抽离“方法”形成另一个“类”。如动物狗，在设计时，把狗设计成一个类，里面的“行走”方法从狗中分离出来，形成“行走”接口，并在“狗”类中使用这个“行走”对象。这样“狗”和“行走”类都可以独立变化。

（2）桥接模式的结构和说明

 

　　①Abstraction：抽象部分的接口。通常在这个对象中，要维护一个实现部分的对象的引用，抽象对象里面的方法，需要调用实现部分的对象来完成。这个对象中的方法，通常都是和具体的业务相关的方法。

　　②RefinedAbstraction：扩展抽象部分的接口。通常在这些对象中，定义跟实际业务相关的方法，这些方法的实现通常会使用Abstraction中定义的方法，也可能需要调用实现部分的对象来完成。如上图中的operation方法中，一般调用impl->operationImpl();

　　③Implementor：定义实现部分的接口。这个接口不用和Abstraction中的方法一致。

　　④ConcreteImplementor：真正实现Implementor接口的对象。

（3）不使用桥接模式的案例

　　①蜡笔和毛笔：这两者的关键区别在于笔和颜色是否能够分离。

 

　　②跨平台的图像浏览系统

 

　　A、使用多层继承结构，导致系统中类的个数急剧增加（共17个）。

　　B、系统扩展麻烦，由于每个具体类（*Image）既包含图像文件格式信息，又包含操作系统信息。因此无论是增加新的图像文件格式还是增加新的操作系统，都需要增加大量的具体类。（如增加TIF，则需要增加3个具体类以便在3种不同的操作系统中显示。如果增加一个新的操作系统，则需要在每个*Image下增加具体的类。

　　C、从图中可以看出，该系统存在两个独立变化的维度：图像文件格式和操作系统。

 

（4）思考Bridge模式

　　①Bridge模式的本质：分离抽象和实现。它是解决多继承的一套方案，把使用继承改成使用对象组合，解耦了抽象和实现之间固有的绑定关系，从而使“抽象”和“实现”可以沿着各自的纬度独立的变化。

　　②Bridge模式的动机：Bridge模式就是为了处理类的多维度变化，其目的是解耦。

　　③由于抽象部分和实现部分是完全分离的。所以可以在运行时动态组合具体的真实实现，从而动态变换功能。此外，同一个真实实现可以被不同抽象对象使用；反过来，同一个抽象也不能有多个不同的实现。

　　④桥接模式是一种很实用的结构型设计模式，如果某个类存在多个独立变化的维度，通过该模式可以将这多个维度分离出来，使它们可以独立扩展。让系统更符合“单一职责原则”。

【编程实验】发送提示消息

  

//结构型模式：桥接模式
//场景：发送提示消息
//消息：普通消息、加急消息和特急消息
//发送方式：站内消息、手机短信、E-mail
#include <iostream>
#include <string>

using namespace std;

//实现发送消息的统一接口
class MessageImplementor
{
public:
    //发送消息：
    //@param message 要发送的消息内容
    //@param toUser  消息发送的目的人员
    virtual void send(string message,string toUser) = 0; 
};

//抽象的消息对象
class AbstractMessage
{
private:
    //持有一个实现部分的对象
    MessageImplementor& impl;
public:
    //构造函数，传入实现部分的对象
    AbstractMessage(MessageImplementor& mi):impl(mi){}
    
    //发送消息，转调实现部分的方法
    virtual void sendMessage(string message,string toUser)
    {
        impl.send(message, toUser);
    }
};
//************************具体的消息发送方式*******************
//站内消息的实现
class MessageSMS : public MessageImplementor
{
public:
    void send(string message, string toUser)
    {
        cout <<"SMS:""<< message << "" to:" << toUser << endl;
    }    
};

//E-mail方式的发送消息
class MessageEmail : public MessageImplementor
{
public:
    void send(string message, string toUser)
    {
        cout <<"Email:""<< message << "" to:" << toUser << endl;
    }    
};

//Mobile方式的发送消息
class MessageMobile : public MessageImplementor
{
public:
    void send(string message, string toUser)
    {
        cout <<"Mobile:""<< message << "" to:" << toUser << endl;
    }    
};

//*********************具体的消息类型************************
//普通消息
class CommonMessage : public AbstractMessage
{
public:
    CommonMessage(MessageImplementor& im):AbstractMessage(im){} 
};

//加急消息
class UrgencyMessage : public AbstractMessage
{
public:
    UrgencyMessage(MessageImplementor& im):AbstractMessage(im){} 
    void sendMessage(string message,string toUser)
    {
        message ="Urgency:" + message;
        AbstractMessage::sendMessage(message, toUser);
    }
};

//特急消息
class SpecialUrgencyMessage : public AbstractMessage
{
public:
    SpecialUrgencyMessage(MessageImplementor& im):AbstractMessage(im){} 
    void sendMessage(string message,string toUser)
    {
        message ="SpecialUrgency:" + message;
        AbstractMessage::sendMessage(message, toUser);
        //还需要加一条待催促的信息
        hurry(100);
    }
    
    void hurry(int messageId)
    {
        //执行摧促的业务，发出催足的信息，这里简单示意一下
        cout << "hurry: messageId=" << messageId << endl; 
    }
};

int main()
{ 
    //1、使用站内短息发送消息（普通、加急、特急等）
    //创建具体的实现对象
    MessageImplementor* impl = new MessageSMS();//选择站内短息的方式来发送
    
    //创建一个普通消息对象
    AbstractMessage* m = new CommonMessage(*impl);    //发送普通消息
    m->sendMessage("Cup of Tee please","SantaClaus");
    delete m;
    
    //创建一个加急消息对象
    m = new UrgencyMessage(*impl);  //发送加急消息
    m->sendMessage("Cup of Tee please","SantaClaus");
    delete m;  
    
    //创建一个特急消息对象    
    m = new SpecialUrgencyMessage(*impl); //发送特急消息
    m->sendMessage("Cup of Tee please","SantaClaus");
    delete m; 

    delete impl;
    cout <<endl;
    
    //2、把实现切换成手机短信，然后再实现一遍    
     //创建具体的实现对象
    impl = new MessageMobile();
    
    //创建一个普通消息对象
    m = new CommonMessage(*impl);
    m->sendMessage("Cup of Tee please","SantaClaus");
    delete m;
    
    //创建一个加急消息对象
    m = new UrgencyMessage(*impl);
    m->sendMessage("Cup of Tee please","SantaClaus");
    delete m;  
    
    //创建一个特急消息对象    
    m = new SpecialUrgencyMessage(*impl);
    m->sendMessage("Cup of Tee please","SantaClaus");
    delete m; 
       
    return 0;
}

2. 谁来桥接：谁也创建Implementor对象？

（1）方式1：由客户端创建Implementor对象，并设置到抽象部分的对象中去。

（2）方式2：可以在抽象部分对象构建的时候，由抽象部分的对象自己来创建。当然也可以给这个抽象部分的对象传递一些参数，让它可以根据参数来创建具体的Implementor对象。

（3）方式3：可以在Abstraction中选择并创建一个默认的Implementor对象，然后子类可以根据需要改变这个实现。

（4）方式4：可以使用抽象工厂或简单工厂来选择并创建具体的Implementor对象。抽象部分的类可以通过调用工厂的方法来获取Implementor对象。

3. 桥接模式的优点

（1）分离抽象和实现部分。让抽象和实现部分可以独立变化。对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以，将依赖实现改为依赖接口编程。

（2）更好的扩展性：抽象和实现部分可以别分独立的扩展，而不会互相影响

（3）可以动态切换实现：因为一个实现不再是固定绑定到一个抽象接口上，所以可以实现在运行期间动态地切换。

（4）可减少子类的个数：如果采用继承的实现方式，大约需要两个纬度上可变化数量的乘积的子类个数；而采用桥接模式只需要两个纬度可变化数量的子类的和个子类。

4. 桥接模式的使用场景

（1）需要跨越多个平台的图形和窗口中系统上。

（2）一个类存在两个独立变化维度，且两个维度都需要扩展。

（3）三层架构中通过桥接模式将业务逻辑层（BLL）与数据操作层（DAL）解耦。

5. 三层架构及层间的解耦

（1）三层划分：用户界面层(UI)、业务逻辑层(BLL)和数据访问层(DAL)

 

（2）各层的作用

　　①用户界面层：只负责显示和采集用户操作。

　　②业务逻辑层：负责UI和DAL层之间的数据交换，是系统架构中体现核心价值的部分。它关注点主要集中在业务规则的制定、业务流程的实现和业务需求的有关系统设计。它与系统所对应的领域（Domain）有关。也可以做一些如用户权限合法性和数据据式是否正确等验证检查。

　　③数据访问层：与数据库直接打交道，如数据库进行增、删、改、查等操作。常用的技术如ADO+SQL语句。这里可能还会有DBUtility类（负责建立数据库连接）、与工厂方法模式相关的DALFactory抽象类（用于创建如OracleDAL、SQLServerDAL对象之类的工厂）、DataAccess产品类（真正操作数据库的类）

（3）各层的交互

　　①UI和BLL：UI层引用BLL和实体类(Entity)。

　　②BLL和DAL：桥接模式，在BLL中持有一个DAL接口的引用。

　　③DAL与数据库：工厂模式或抽象工厂模式。DAL与数据库间的解耦可参考《抽象工厂模式》部分的内容

【编程实验】利用桥接模式实现三层架构中的业务逻辑层(BLL)与数据访问层(DAL)的解耦。

 

//结构型模式：桥接模式
//场景：三层架构业务逻辑层（BLL）与数据操作层（DAL）的解耦

#include <iostream>
#include <string>
#include <list>
using namespace std;

//************************Implementor类******************
//三层架构中的数据访问层（DAL）
class IDataAccess
{
public:
    virtual void addRecord(string name) = 0;
    virtual void deleteRecord(string name) = 0;
    virtual void updateRecord(string name) = 0;
    virtual string getRecord(int index) = 0;
    virtual void queryAllRecords() = 0;   
};

//具体的DAL层
class CustomerDataAccess: public IDataAccess
{
private:
    list<string> customers;
public:
    CustomerDataAccess()
    {
        //实际工程中从数据库中读取数据再填充列表
        customers.push_back("learning Hard");
        customers.push_back("zhang san");
        customers.push_back("Li si");
        customers.push_back("Wang wu");
    }   
    
    void addRecord(string name)
    {
        customers.push_back(name);
    }
    void deleteRecord(string name)
    {
        customers.remove(name);
    }
    void updateRecord(string name)
    {
        //演示目的
         customers.front() = name;
    }
    string getRecord(int index)
    {
        list<string>::iterator iter = customers.begin();
        advance(iter,index);//取出索引号为index的元素
        
        return *iter;
    }
    void queryAllRecords()
    {
        for(list<string>::iterator iter=customers.begin();iter != customers.end();++iter)
        {
            cout << *iter << endl;
        }
    }    
};

//BLL层的接口
class AbstractBusiness
{
private:
    IDataAccess* dataAccess;
public:
    AbstractBusiness(IDataAccess* dataAccess)
    {
        this->dataAccess = dataAccess;
    }
    
    virtual void add(string name)
    {
        dataAccess->addRecord(name);   
    }
    
    virtual void del(string name)
    {
        dataAccess->deleteRecord(name);
    }
    
    virtual void update(string name)
    {
        dataAccess->updateRecord(name);
    }
    
    virtual string get(int index)
    {
        return dataAccess->getRecord(index);
    }
    
    virtual void showAll()
    {
       dataAccess->queryAllRecords();       
    }
};

//具体的业务逻辑类
class CustomersBusiness: public AbstractBusiness
{
public:
    CustomersBusiness(IDataAccess* dataAccess):AbstractBusiness(dataAccess){}
    
    void showAll()
    {
        cout <<"-----------------------"<<endl;
        AbstractBusiness::showAll();
        cout <<"-----------------------"<<endl;
    }    
};

int main()
{ 
    IDataAccess* dataAccess = new CustomerDataAccess();
    AbstractBusiness* customers = new CustomersBusiness(dataAccess);
    
    customers->add("SantaClaus");
    cout<<"add a member:"<<endl;
    customers->showAll();
    
    cout <<"delete a member:" << endl;
    customers->del("Wang wu");
    customers->showAll();
    
    cout << "update a member:" << endl; 
    customers->update("Learning Hard");
    customers->showAll();
   
    return 0;
}