Layers 模式

分层模式是有助于将应用程序划分为多组子任务。每组子任务都有自己的抽象层。

最典型的应用是OSI的七层模型，每一层都有自己特定的任务。

#include <iostream>

class L1Provider{
public:
    virtual void L1Service() = 0;
};

class L2Provider{
public:
    virtual void L2Service() = 0;
    void setLowerLayer(L1Provider *l1){level1 = l1;}
protected:
    L1Provider *level1;
};

class L3Provider{
public:
    virtual void L3Service() = 0;
    void setLowerLayer(L2Provider *l2){level2 = l2;}
protected:
    L2Provider *level2;
};

class L2Parent{
public:
    virtual void L2PServ() = 0;
};

class L1Parent{
public:
    virtual void L1PServ() = 0;
    void setParentLayer(L2Parent *l2){lParent2 = l2;}
protected:
    L2Parent *lParent2;
};

class L1Peer{
public:
    virtual void L1PPeer() = 0;
    void setParentLayer(L1Parent *l1){lParent1 = l1;}
protected:
    L1Parent *lParent1;
};

class DataLink : public L1Provider, public L1Peer{
public:
    virtual void L1Service(){
        std::cout << "L1Service doing job" << std::endl;
    }
    void L1PPeer(){
        std::cout << "LpPPeer start" << std::endl;
        lParent1->L1PServ();
        std::cout << "LpPPeer end " << std::endl;
    }
};

class Transport : public L2Provider, public L1Parent{
public:
    void L1PServ(){
        std::cout << "Lp1 start" << std::endl;
        lParent2->L2PServ();
        std::cout << "Lp1 end" << std::endl;
    }
    virtual void L2Service(){ 
        std::cout << "L2Service starting job" << std::endl;
        level1->L1Service();
        std::cout << "L2Service finishing job" << std::endl;
    }
};
class Session : public L3Provider, public L2Parent{
public:
    void L2PServ(){
        std::cout << "doing L3server" << std::endl;
    }
    virtual void L3Service(){
        std::cout << "L3Service starting job" << std::endl;
        level2->L2Service();
        std::cout << "L3Service finishing job" << std::endl;
    }
};

int main()
{
    DataLink dataLink;
    Transport transport;
    Session session;

    transport.setLowerLayer(&dataLink);
    session.setLowerLayer(&transport);

    session.L3Service();

    std::cout << "
 =========== 
" ;
    transport.setParentLayer(&session);
    dataLink.setParentLayer(&transport);
    dataLink.L1PPeer();

    return 0;
}

这里写的是底下三层的一个策略。上层向底层请求服务。还有底层向上层请求服务的一个过程。

在进行分层的时候，需要制定的错误策略就是尽量少的将错误向上层传递。最好在当前层进行处理。否则效率会很低，并且上层也不知道你这层出现的这个错误到底是什么意思。

关于分层还有宽松的分层系统。 对于咱们比较熟悉的应该是API，在底层实现了一套API，然后一般在高层再封装一套易用的API，这样子，你既可以使用上层封装的API也可以使用底层比较晦涩难用的API。

但是分层还是有很多的缺点：行为变化引发的雪崩效应。效率较低（任务在各层中进行传递，而不是立即处理）。不必要的工作（假设读取底层的一组数据，多个上层对底层该数据进行读取，并且都是深度复制，那产生的效率就会低下）。难以确定正确的层次粒度（这个层次粒度要根据实际情况进行分析，并给出正确的取舍。关于串口通信发送命令时的组帧情况，是否通过多次组帧，还是直接一下子将帧组好直接发送过去）。

面向模式的软件架构 模式系统 中的Layers模式