行为型模式：Chain Of Responsibility 职责链模式

                                                  行为型模式：Chain Of Responsibility 职责链模式

１、请求的发送者与接受者
  １）某些对象请求的接受者可能多种多样，变化无常......
  ２）请求发送者→请求接受者1，请求接受者2，请求接受者3，......
 
２、动机（Motivation）
  １）在软件构建过程当中，一个请求可能被多个对象处理，可是每一个请求在运行时只能有一个接受者，若是显式指定，将必不可少地带来请求发送者与接受者的紧耦合。
  ２）如何使请求的发送者不须要指定具体的接受者？让请求的接受者本身在运行时决定来处理请求，从而使二者解耦。
 
３、意图（Intent）
      使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。
                          ——《设计模式》GoF
 
４、实例：
  １）多种状况的变化来处理一个对象，通常作法以下：
//请求接受者：抽象父类
public abstract class BaseHandler
{
  public abstract void HandleRequest(Request request);
  public abstract bool CanHandleRequest();
}

//请求接受者A
public class AHandler : BaseHandler
{
  public override void HandleRequest(Request request)
  {
  }
  public override bool CanHandleRequest()
  {
  }
}

//请求接受者B
public class BHandler : BaseHandler
{
  public override void HandleRequest(Request request)
  {
  }
  public override bool CanHandleRequest()
  {
  }
}

//请求接受者C
public class CHandler : BaseHandler
{
  public override void HandleRequest(Request request)
  {
  }
  public override bool CanHandleRequest()
  {
  }
}

//请求的发送者
public class Sender
{
  public void Process()
  {
    Request request = new Request();
   
    List<BaseHandler> list = new List<BaseHandler>();
    list.Add(new AHandler());
    list.Add(new BHandler());
    list.Add(new CHandler());
   
    foreach (BaseHandler handler in list)
    {
      //若是可以处理这个请求，那么就接受请求
      if (handler.CanHandleRequest())
      {
        handler.HandleRequest(request);
      }
    }
  }
}

public class Request
{
}

  ２）职责链模式作法以下：重构获得模式
//请求接受者：抽象父类
public abstract class BaseHandler
{
  private BaseHandler next;
 
  //构造器配合使用
  public BaseHandler(BaseHandler next)
  {
    this.next = next;
  }
 
  public BaseHandler Next
  {
    get
    {
      return this.next;
    }
    set
    {
      this.next = value;
    }
  }
 
  public virtual void HandleRequest(Request request)
  {
    if (this.next != null)
    {
      this.next.HandleRequest(request);
    }
  }
 
  protected abstract bool CanHandleRequest(Request request);
}

//请求接受者A
public class AHandler : BaseHandler
{
  public AHandler(BaseHandler next) : base(next)
  {
  }
 
  public override void HandleRequest(Request request)
  {
    if (this.CanHandleRequest(request))
    {
      //若是能处理本身处理
    }
    else
    {
      //不能处理交给基类
      base.HandleRequset(request);
    }
  }
 
  protected override bool CanHandleRequest(Request request)
  {
    if (.....)
    {
      return ture;
    }
    else
    {
      return false;
    }
  }
}

//请求接受者B
public class BHandler : BaseHandler
{
  public BHandler(BaseHandler next) : base(next)
  {
  }
 
  public override void HandleRequest(Request request)
  {
    if (this.CanHandleRequest(request))
    {
      //若是能处理本身处理
    }
    else
    {
      //不能处理交给基类
      base.HandleRequset(request);
    }
  }
 
  protected override bool CanHandleRequest(Request request)
  {
    if (.....)
    {
      return ture;
    }
    else
    {
      return false;
    }
  }
}

//请求接受者C
public class CHandler : BaseHandler
{
  public CHandler(BaseHandler next) : base(next)
  {
  }
 
  public override void HandleRequest(Request request)
  {
    if (this.CanHandleRequest(request))
    {
      //若是能处理本身处理
    }
    else
    {
      //不能处理交给基类
      base.HandleRequset(request);
    }
  }
 
  protected override bool CanHandleRequest(Request request)
  {
    if (.....)
    {
      return ture;
    }
    else
    {
      return false;
    }
  }
}

//请求的发送者
public class Sender
{
  //把请求交给一个对象就好了，无论谁来处理
  public void Process(BaseHandler handler)
  {
    Request request = new Request();
    hnadler.HandlerRequest(request);
  }
}

//客户
public class App
{
  public static void Main()
  {
    Sender sender = new Sender();
   
    BaseHandler handler1 = new Ahandler(null);
    BaseHandler handler2 = new Bhandler(handler1);
    BaseHandler handler3 = new Chandler(handler2);
   
    BaseHandler handler4 = new Dhandler(null);
    //运行时动态改变链表方向
    handler3.Next = handler4;
    handler4.Next = handler2;
   
    sender.Process(handler3);
    //方向：handler3-->handler4-->handler2-->handler1
   
    //程序扩展直接继承BaseHandler
    //BaseHandler handler4 = new Dhandler(handler3);
    //sender.Process(handler4);
    //......
  }
}

５、Chain Of Responsibility模式的几个要点   １）Chain Of Responsibility模式的应用场合在于“一个请求可能有多个接受者，可是最后真正的接受者只有一个”，只有这时候请求发送者与接受者的耦合才有可能出现“变化脆弱”的症状，职责链的目的就是将两者解耦，从而更好地应对变化。   ２）应用了Chain Of Responsibility模式后，对象的职责分派将更具灵活性。咱们能够在运行时动态添加/修改请求的处理职责。   ３）若是请求传递到职责链的末尾仍得不处处理，应该有一个合理的缺省机制。这也是每个接受对象的责任，而不是发出请求的对象的责任。