设计模式19：Chain Of Responsibility 职责链模式（行为型模式）

Chain Of Responsibility 职责链模式（行为型模式）

请求的发送者与接受者

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

动机（Motivation）

在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，如果显示指定，将必不可少地带来请求发送者与接受者的紧耦合。

如何使请求的发送者不需要指定具体的接受者？让请求的接受者自己在运行时决定来处理请求，从而使两者解耦。

意图（Intent）

使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。——《设计模式》GoF

示例代码

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

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

        public override bool CanHandleRequest(Request request)
        {
            //...
        }
    }

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

        public override bool CanHandleRequest(Request request)
        {
            //...
        }
    }

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

        public override bool CanHandleRequest(Request request)
        {
            //...
        }
    }

    public class Request
    {
        //...
    }

    public class Sender
    {
        public void Process()
        {
            Request request=new Request();
            //...
            List<BaseHandler> handlerList=new List<BaseHandler>();
            handlerList.Add(new AHandler());
            handlerList.Add(new BHandler());
            handlerList.Add(new CHandler());

            foreach (var handler in handlerList)
            {
                if (handler.CanHandleRequest(request))
                {
                    handler.HandleRequest(request);
                }
            }
        }
    }

如果我们不希望Sender中有这么多的Handler的调用，可以通过指责链模式修改：

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

        public BaseHandler Next { get; set; }

        protected abstract bool CanHandleRequest(Request request);

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

    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 bool CanHandleRequest(Request request)
        {
            //...
        }
    }

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

        public override void HandleRequest(Request request)
        {
            //...
        }

        protected override bool CanHandleRequest(Request request)
        {
            //...
        }
    }

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

        public override void HandleRequest(Request request)
        {
            //...
        }

        protected override bool CanHandleRequest(Request request)
        {
            //...
        }
    }

    public class Request
    {
        //...
    }

    public class Sender
    {
        public void Process(BaseHandler handler)
        {
            Request request = new Request();
            //...
            handler.HandleRequest(request);
        }
    }

客户端调用：

        static void Main(string[] args)
        {
            Sender sender=new Sender();

            BaseHandler handler1 = new AHandler(null);
            BaseHandler handler2 = new BHandler(handler1);
            BaseHandler handler3 = new CHandler(handler2);

            sender.Process(handler3);

            Console.ReadKey();
        }

结构（Structure）

一个典型的对象结构可能如下图所示：

Handler——定义一个处理请求的接口。（可选）实现后继链。
ConcreteHandler——处理它所负责的请求。可访问它的后继者。如果可处理该请求，就处理之；否则将该请求转发给它的后继者。
Client——向链上的具体处理者(ConcreteHandler)对象提交请求。

Chain Of Responsibility 模式的几个要点

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

转载请注明出处：

作者：JesseLZJ
出处：http://jesselzj.cnblogs.com