面向对象设计之依赖倒置原理

依赖倒置原理是罗伯特.C.马丁提出来的，其中心思想如下：

高层模块不能依赖低层模块，两者都要依赖抽象。抽象不能依赖具体，具体要依赖抽象。

 

这个原理倒置了传统的高层模块依赖低层模块的观念，提出了高层或低层模块要依赖抽象，下面我们用一个三层协议栈的例设计子来详细说明下

该原理。

 

分以下三个步骤来说明：

• 初始设计
• 用依赖倒置原理来修改设计
• 依赖倒置的优点

 

初始设计

考察下面的无线电通信三层协议的代码，三层协议分别是：

• RLC物理层
• RLC数据链路层
• RLC网络层

 

每一层对应一个类， 代码骨架如下:

Layers 
class RLC_Physical_Layer
{
   RLC_Datalink_Layer *m_p_RLC_Datalink_Layer;

public:   
   void Device_Transmit(Datagram *p_Datagram)
   {
      Apply_Physical_Layer_Headers(p_Datagram);
      Write_Message_To_Device(p_Datagram);
   }

   void Handle_Device_Receive(Datagram *p_Datagram)
   {  
      Remove_Physical_Layer_Header(p_Datagram);
      m_p_RLC_Datalink_Layer->Handle_Physical_Layer_Receive(p_Datagram);
   }
};

class RLC_Datalink_Layer
{
   RLC_Physical_Layer *m_p_RLC_Physical_Layer;
   RLC_Network_Layer *m_p_RLC_Network_Layer;

public:   
   void Datalink_Transmit(Datagram *p_Datagram)
   {
      Process_Datalink_Transmit(p_Datagram);
      m_p_RLC_Physical_Layer->Device_Transmit(p_Datagram);
   }

   void Handle_Physical_Layer_Receive(Datagram *p_Datagram)
   {  
      Process_Datalink_Receive(p_Datagram);
      m_p_RLC_Network_Layer->Handle_Network_Layer_Receive(p_Datagram);
   }
};

class RLC_Network_Layer
{
   RLC_Datalink_Layer *m_p_RLC_Datalink_Layer;
   Application_Layer *m_p_Application_Layer;

public:   
   void Network_Transmit(Datagram *p_Datagram)
   {
      Process_Network_Layer_Transmit(p_Datagram);
      m_p_RLC_Datalink_Layer->Datalink_Transmit(p_Datagram);
   }

   void Handle_Datalink_Layer_Receive(Datagram *p_Datagram)
   {  
      Process_Network_Layer_Receive(p_Datagram);
      m_p_Application_Layer->Handle_Application_Receive(p_Datagram);
   }
};

 

这不是一个好的设计，因为有如下限制：

• 所有层都是相互依赖的，每个层的代码都需要包含其它层的头文件。
• 层之间的联系是固定的，要实现一个新的协议的话，必须重新改写层的联系。
• 一个层的被改变就会影响到其它层。

 

要解决以上问题， 就必须引入一个抽象层，让这些层都去依赖抽象层， 这就是依赖倒置原理的具体应用。

 

用依赖倒置原理来修改设计

先来设计一个抽象层， 该抽象层的要点如下：

• 构造函数有两个参数，一个是上层类抽象，一个是下层类抽象，这样保证了该层跟其它层的关系。
• 对上层发送过来的消息进行特定处理，处理完毕后调用底层传送接口发送给底层。
• 对低层接收到的信息做特定处理，处理完毕后就调用上层接收处理接口让上层进行处理。

下面的代码设计完全解耦合了三层的关系，所有层都只依赖于抽象层了。

Protocol_Layer Abstraction 
// Protocol_Layer abstraction has been defined to decouple the
// different protocol layers. Now the layers only depend upon
// this abstraction.

class Protocol_Layer
{
   // Each layer can associate with an upper and lower layer.
   // This association is also in terms of the Protocol_Layer
   // class. Thus there is no dependency on the actual types
   // of individual layers. The only requirement is that they
   // should inherit from Protocol_Layer.

   Protocol_Layer *m_p_Lower_Layer;
   Protocol_Layer *m_p_Upper_Layer;

   // Each inheriting layer must override the following methods.
   // These methods handle the actual protocol processing.
   virtual void Process_Transmit(Datagram *p_Datagram) = 0;
   virtual void Process_Receive(Datagram *p_Datagram) = 0;
public:

   // Create a protocol layer with the associated upper and
   // lower layers.
   Protocol_Layer(Protocol_Layer *p_Lower_Layer, 
                  Protocol_Layer *p_Upper_Layer)
   {
      m_p_Lower_Layer = p_Lower_Layer; 
      m_p_Upper_Layer = p_Upper_Layer;
   }

   // Process and transmit the datagram passed by higher layer.
   void Transmit(Datagram *p_Datagram)
   {
       Process_Transmit(p_Datagram);

       if (m_p_Lower_Layer)
       {
          m_p_Lower_Layer->Transmit(p_Datagram);
       }
   }

   // Receive handler for a datagram received from lower layer
   void Handle_Receive(Datagram *p_Datagram)
   {
       Process_Receive(p_Datagram);

       if (m_p_Upper_Layer)
       {
          m_p_Upper_Layer->Handle_Receive(p_Datagram);
       } 
   }
};

class RLC_Physical_Layer : public Protocol_Layer
{
   void Process_Transmit();
   void Process_Receive();
public:
   RLC_Physical_Layer(Layer *p_Lower_Layer, Layer *p_Upper_Layer)
   : Protocol_Layer(p_Lower_Layer, p_Upper_Layer)
   { }
};

class RLC_Datalink_Layer : public Protocol_Layer
{
   void Process_Transmit();
   void Process_Receive();
public:
   RLC_Datalink_Layer(Layer *p_Lower_Layer, Layer *p_Upper_Layer)
   : Protocol_Layer(p_Lower_Layer, p_Upper_Layer)
   { }
};

class RLC_Network_Layer : public Protocol_Layer
{
   void Process_Transmit();
   void Process_Receive();
public:
   RLC_Network_Layer(Layer *p_Lower_Layer, Layer *p_Upper_Layer)
   : Protocol_Layer(p_Lower_Layer, p_Upper_Layer)
   { }
};
 

依赖倒置的优点

• 解耦合。
• 灵活度高， 能随意匹配和融合各层。
• 可以在层与层之间任意插入一个新的功能层。