职责链(chain of responsibility)模式

某些对象请求的接受者可能多种多样，变化无常

 1、动机
在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，如果显式指定，将必不可少地带来请求发送者与接受者的紧耦合。
如何使请求的发送者不需要指定具体的接受者？让请求的接受者自己在运行时决定来处理请求，从而使两者解耦。

2、意图
使多个对象都有机会处理请求，从而避免请求的发送者和接受者之前的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

3、图

4、代码

abstract class BaseHandler
{
 public abstract void HandleRequest( Request request);
 public abstract bool CanHandleRequest();
}

public class AHandler : BaseHandler
{
 public override void HandleRequest( Request request)
 {
  
 }
}

public class BHandler : BaseHandler
{
 public override void HandleRequest( Request request)
 {
  
 }
}

public class CHandler : BaseHandler
{
 public override void HandleRequest( Request request)
 {
  
 }
}

public class Sender
{
 public void Process()
 {
  Request request = new Request();

  ArrayList list = new ArrayList();

  list.Add( new AHandler() );
  list.Add( new BHandler() );
  list.Add( new CHandler() );

  foreach(BaseHandler handler in list)
  {
   if( handler.CanHandleRequest( ) )
   {
    handler.HandleRequest( request );
   }
  }
  
  
 }
}

-------------------------------------------------------------------------

abstract class BaseHandler
{
 public BaseHandler(BaseHandler next)
 {
  this.nextHandler = next;
 }

 public virtual void HandleRequest( Request request)
 {
  if( this.nextHandler != null )
  {
   this.nextHandler.HandleRequest( request );
  }
 }

 protected abstract bool CanHandleRequest( Request request );

 private BaseHandler nextHandler;

 public BaseHandler NextHandler
 {
  get
  {
   return this.nextHandler;
  }
  set
  {
   this.nextHandler = value;
  }
 }
}

public class AHandler : BaseHandler
{
 public AHandler( BaseHandler next):base(next)
 {
 }

 public override void HandleRequest( Request request)
 {
  if( this.CanHandleRequest( request ) ) )
  {
   ...
  }
  else
  {
   base.HandleRequest( request );
  }
 }

 protected override void CanHandleRequest( Request request )
 {
  if( ... )
  {
   return true;
  }
  else
  {
   return false;
  }
 }
}

public class BHandler : BaseHandler
{
 public BHandler ( BaseHandler next):base(next)
 {
 }

 public override void HandleRequest( Request request)
 {
  if( this.CanHandleRequest( request  ) )
  {
   ...
  }
  else
  {
   base.HandleRequest( request );
  }
 }

 protected override void CanHandleRequest( Request request )
 {
  if( ... )
  {
   return true;
  }
  else
  {
   return false;
  }
 }
}

public class CHandler : BaseHandler
{
 public CHandler ( BaseHandler next):base(next)
 {
 }

 public override void HandleRequest( Request request)
 {
  if( this.CanHandleRequest( request ) )
  {
   ...
  }
  else
  {
   base.HandleRequest( request );
  }
 }

 protected override void CanHandleRequest( Request request )
 {
  if( ... )
  {
   return true;
  }
  else
  {
   return false;
  }
 }
}

//进行解耦
public class Sender
{
 public void Process(BaseHandler handler )
 {
  Request request = new Request();

  handler.HandleRequest( request );
  
  
 }
}

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 );
 
  sender.Process( handler3 );
 }
}

-----------------------------------------------------------

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 CHandler( null );

  handler3.NextHandler = handler4;
  handler4.NextHandler = handler2;
 
  sender.Process( handler3 );

  //handler3-->handler4-->handler2-->handler1
 }
}

--------------------------------------------------------------------------------------------------

abstract class Handler
{

 public abstract void HandleRequest( );

 private Handler nextHandler;

 public Handler NextHandler
 {
  get
  {
   return this.nextHandler;
  }
  set
  {
   this.nextHandler = value;
  }
 }
}

public class ConcreteHandler : Handler
{

 public void HandleRequest( )
 {
  if( NextHandler != null )
  {
   nextHandler.HandleRequest();
  }
 }

}

public class Client
{
 private Static Handler handler1,handler2;

 public static void main(string[] args)
 {
  handler1 = new ConcreteHandler();
  handler2 = new ConcreteHandler();
  handler1.NextHandler = handler2;
  handler1.HandleRequest();
 }
}

5、要点

(1). 职责链模式的应用场合在于“一个请求者可能有多个接受者，但是最后真正的接受者只有一个”，只有这时候请求发送者与接受者的耦合才有可能出现“变化脆弱”的症状，职责链的目的就是将二者解耦，从而更好地应对变化。
(2). 应用了职责链模式后，对象的职责分派将更具灵活性。我们可以在运行时动态添加/修改请求的处理职责。
(3). 如果请求传递到职责的末尾仍到不处理，应该有一个合理的缺省机制。这也是每个缺省对象的责任，而不是发出请求对象的责任。