设计模式学习笔记二十（Chain of Responsibility职责链模式）

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

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

基本Code：

public class Request

{

    //...

}

 

public abstract class BaseHandler

{

    public abstract void HandleRequest(Request request);

    public abstract bool CanHandleRequest();

 

}

public class AHandler:BaseHandler

{

    public override  void HandleRequest(Request request)

    {

    }

    public override bool CanHandleRequest()

    {      

    }

}

public class BHandler:BaseHandler

{

    public override void HandleRequest(Request request)

    {

    }

    public override bool CanHandleRequest()

    {

    }

}

public class CHandler:BaseHandler

{

    public override void HandleRequest(Request request)

    {

    }

    public override bool CanHandleRequest()

    {

    }

}

 

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);

            }

        }

 

    }

}

public class App

{

    public static void Main()

    {

        Sender sender = new Sender();

        sender.Process();

    }

}

 

用Chain of Responsibility模式改进后的Code如下：

public class Request

{

    //...

}

 

public abstract class BaseHandler

{

    protected abstract bool CanHandleRequest();

    public virtual void HandleRequest(Request request)

    {

        if (this.next != null)

        {

            this.next.HandleRequest(request);

        }

    }

 

    public BaseHandler(BaseHandler next)

    {

        this.next = next;

    }   

 

    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  void HandleRequest(Request request)

    {

        if (this.CanHandleRequest())

        {

            //如果自己能处理就自己处理，否则传给基类处理

        }

        else

        {

            base.HandleRequest(request);

        }

    }

    protected override bool CanHandleRequest()

    {      

    }

}

public class BHandler:BaseHandler

{

    public BHandler(BaseHandler next)

        : base(next)

    {

    }

    public override  void HandleRequest(Request request)

    {

        if (this.CanHandleRequest())

        {

            //如果自己能处理就自己处理，否则传给基类处理

        }

        else

        {

            base.HandleRequest(request);

        }

    }

    protected override bool CanHandleRequest()

    {

    }

}

public class CHandler:BaseHandler

{

     public CHandler(BaseHandler next)

        : base(next)

    {

    }

    public override  void HandleRequest(Request request)

    {

        if (this.CanHandleRequest())

        {

            //如果自己能处理就自己处理，否则传给基类处理

        }

        else

        {

            base.HandleRequest(request);

        }

    }

    protected override bool CanHandleRequest()

    {

       

    }

}

 

public class Sender

{

    //解耦的地方

    public void Process(BaseHandler handler)

    {

        Request request = new Request();

        //...    

        handler.HandleRequest(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);

        sender.Process(handler3);

        //handler3-->handler2-->handler1，这里可以动态地改变链接顺序，动态地增加/修改节点

    }

}

Chain of Responsibility模式结构图：

 

Chain Of Responsibility模式要点：

1、  Chain Of Responsibility模式的应用场合在于“一个请求可能有多个接受者，但是最后真正的接受者只有一个”，只有这时候请求发送者与接受者的耦合才有可能出现“变化脆弱”的症状，职责链的目的就是将二者解耦，从而更好地应对变化。

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

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