chain of responsibilit职责链模式-技术开发专区

chain of responsibilit职责链模式

作者：tony.zjb 编辑：阿雪 2007-05-15 22:39

【IT168技术文档】
动机：在软件构建过程中，一个请求可能被多个对象处理,但是每个请求在运行时只能有一个
接收者,如果显示指定,将必不可少地带来请求发送者和接收者的深耦合.

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

chain of responsibility 模式的应用场合在于“一个请求可能有多个接收者，但是最后真正
的接受者只有一个”，只有这时候请求发送者与接受者的偶合才有可能出现“变化脆弱”的症状，
职责链的母的旧式将二者解耦，从而更好的应对变化

应用了chain of responsibilit模式后，对象的职责分派将更具灵活性。我们可以在运行时动态添加
修改请求的处理职责。

如果请求传递到职责链的末尾依然得不到处理，应该有一个合理的缺省机制，这也是美一个接受对象
的责任，而不是发出请求的对象的责任。
first

abstract class BaseHandler
{
public abstract bool CanHandleRequest();
public abstract void HandleRequest(Request request);
private BaseHandler next;
public BaseHandler Next
{
get
{
return this.next;
}
set
{
this.next = value;
}
}
}
public class AHandler : BaseHandler
{
public override bool CanHandleReques()
{
}
public override void HandleRequest(Request request)
{
}
}
public class BHandler : BaseHandler
{
public override bool CanHandleReques()
{
}
public override void HandleRequest(Request request)
{
}
}
public class CHandler : BaseHandler
{
public override bool CanHandleReques()
{
}
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.next = next;
}
public abstract bool CanHandleRequest();
//public abstract void HandleRequest(Request request);

public virtual void HandleRequest(Request request)
{
if (this.next != null)
{
this.next.HandleRequest(request);
}
}
private BaseHandler next;
public BaseHandler Next
{
get
{
return this.next;
}
set
{
this.next = value;
}
}
}
public class AHandler : BaseHandler
{
public AHandler(BaseHandler next)
: base(next)
{
}
public override bool CanHandleReques()
{
}
public override void HandleRequest(Request request)
{
if (this.CanHandleRequest())
{
}
else
{
base.HandleRequest(request);
}
}
}
public class BHandler : BaseHandler
{
public BHandler(BaseHandler next)
: base(next)
{
}
public override bool CanHandleReques()
{
}
public override void HandleRequest(Request request)
{
}
}
public class CHandler : BaseHandler
{
public CHandler(BaseHandler next)
: base(next)
{
}
public override bool CanHandleReques()
{
if()
{
//
        }
else
{
//
        }
}
public override void HandleRequest(Request request)
{
}
}
public class Sender
{
public void Process()
{
//Request request = new Request();
        Sender sender = new Sender;
Handler handler1 = new AHandler(null);
Handler handler2 = new BHandler(handler1);
Handler handler3 = new CHandler(handler2);
handler3.HandlerRequest(request);
sender.Process(handler3);
}
}

关注我们