Layers 模式

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

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

 1 #include <iostream>
 2 
 3 class L1Provider{
 4 public:
 5     virtual void L1Service() = 0;
 6 };
 7 
 8 class L2Provider{
 9 public:
10     virtual void L2Service() = 0;
11     void setLowerLayer(L1Provider *l1){level1 = l1;}
12 protected:
13     L1Provider *level1;
14 };
15 
16 class L3Provider{
17 public:
18     virtual void L3Service() = 0;
19     void setLowerLayer(L2Provider *l2){level2 = l2;}
20 protected:
21     L2Provider *level2;
22 };
23 
24 class L2Parent{
25 public:
26     virtual void L2PServ() = 0;
27 };
28 
29 class L1Parent{
30 public:
31     virtual void L1PServ() = 0;
32     void setParentLayer(L2Parent *l2){lParent2 = l2;}
33 protected:
34     L2Parent *lParent2;
35 };
36 
37 class L1Peer{
38 public:
39     virtual void L1PPeer() = 0;
40     void setParentLayer(L1Parent *l1){lParent1 = l1;}
41 protected:
42     L1Parent *lParent1;
43 };
44 
45 class DataLink : public L1Provider, public L1Peer{
46 public:
47     virtual void L1Service(){
48         std::cout << "L1Service doing job" << std::endl;
49     }
50     void L1PPeer(){
51         std::cout << "LpPPeer start" << std::endl;
52         lParent1->L1PServ();
53         std::cout << "LpPPeer end " << std::endl;
54     }
55 };
56 
57 class Transport : public L2Provider, public L1Parent{
58 public:
59     void L1PServ(){
60         std::cout << "Lp1 start" << std::endl;
61         lParent2->L2PServ();
62         std::cout << "Lp1 end" << std::endl;
63     }
64     virtual void L2Service(){ 
65         std::cout << "L2Service starting job" << std::endl;
66         level1->L1Service();
67         std::cout << "L2Service finishing job" << std::endl;
68     }
69 };
70 class Session : public L3Provider, public L2Parent{
71 public:
72     void L2PServ(){
73         std::cout << "doing L3server" << std::endl;
74     }
75     virtual void L3Service(){
76         std::cout << "L3Service starting job" << std::endl;
77         level2->L2Service();
78         std::cout << "L3Service finishing job" << std::endl;
79     }
80 };
81 
82 int main()
83 {
84     DataLink dataLink;
85     Transport transport;
86     Session session;
87 
88     transport.setLowerLayer(&dataLink);
89     session.setLowerLayer(&transport);
90 
91     session.L3Service();
92 
93     std::cout << "\r\n =========== \r\n" ;
94     transport.setParentLayer(&session);
95     dataLink.setParentLayer(&transport);
96     dataLink.L1PPeer();
97 
98     return 0;
99 }

View Code

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

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

 

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

 

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

 

 

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

转载于:https://www.cnblogs.com/cxiaoln/p/3737941.html