设计模式之美：Chain of Responsibility（职责链）

索引

• 意图
• 结构
• 参与者
• 适用性
• 效果
• 相关模式
• 实现
  • 实现方式（一）：实现后继者链。

意图

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它位置。

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request.

Chain the receiving objects and pass the request along the chain until an object handles it.

结构

一个典型的对象结构可能如下图所示：

参与者

Handler

• 定义一个处理请求的接口。
• 实现后继链

ConcreteHandler

• 处理它所负责的请求。
• 可访问它的后继者。
• 如果可处理该请求，就处理；否则将该请求转发给它的后继者。

Client

• 向链上的具体处理者对象提交请求。

适用性

在以下情况下可以使用 Chain of Responsibility 模式：

• 有多个对象可以处理一个请求，哪个对象处理该请求运行时自动确定。
• 你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
• 可处理一个请求的对象集合应被动态指定。

效果

• 降低耦合度。对象无需知道哪个一个对象处理其请求，仅需知道对象被处理。
• 增强了给对象指派职责的灵活性。可以运行时对该链进行动态增加或修改。

相关模式

• Chain of Resposibility 常与 Composite 一起使用。一个构件的父构件可作为它的后继。

实现

实现方式（一）：实现后继者链。

 namespace ChainOfResponsibilityPattern.Implementation1
 {
   public enum RequestCategory
   {
     Category1,
     Category2,
   }

   public abstract class Request
   {
     public abstract RequestCategory Category { get; }
     public bool IsHandled { get; set; }
   }

   public class ConcreteRequest1 : Request
   {
     public override RequestCategory Category
     {
       get { return RequestCategory.Category1; }
     }
   }

   public class ConcreteRequest2 : Request
   {
     public override RequestCategory Category
     {
       get { return RequestCategory.Category2; }
     }
   }

   public abstract class Handler
   {
     private Handler _successor;

     public Handler()
     {
     }

     public Handler(Handler successor)
     {
       _successor = successor;
     }

     public void Handle(Request request)
     {
       OnHandle(request);

       if (!request.IsHandled)
       {
         if (_successor != null)
         {
           // pass request to successor
           _successor.Handle(request);
         }
       }
     }

     protected abstract void OnHandle(Request request);
   }

   public class ConcreteHandler1 : Handler
   {
     public ConcreteHandler1()
     {
     }

     public ConcreteHandler1(Handler successor)
       : base(successor)
     {
     }

     protected override void OnHandle(Request request)
     {
       if (request.Category == RequestCategory.Category1)
       {
         // handle the request which category is Category1
         request.IsHandled = true;
       }
     }
   }

   public class ConcreteHandler2 : Handler
   {
     public ConcreteHandler2()
     {
     }

     public ConcreteHandler2(Handler successor)
       : base(successor)
     {
     }

     protected override void OnHandle(Request request)
     {
       if (request.Category == RequestCategory.Category2)
       {
         // handle the request which category is Category2
         request.IsHandled = true;
       }
     }
   }

   public class Client
   {
     public void TestCase1()
     {
       Request request1 = new ConcreteRequest1();
       Request request2 = new ConcreteRequest2();

       Handler handler2 = new ConcreteHandler2();
       Handler handler1 = new ConcreteHandler1(handler2);

       handler1.Handle(request1);
       handler1.Handle(request2);
     }
   }
 }

《设计模式之美》为 Dennis Gao 发布于博客园的系列文章，任何未经作者本人同意的人为或爬虫转载均为耍流氓。