某些对象请求的接受者可能多种多样,变化无常
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). 如果请求传递到职责的末尾仍到不处理,应该有一个合理的缺省机制。这也是每个缺省对象的责任,而不是发出请求对象的责任。