设计模式学习笔记十四——Chain of Responsibility模式

动机：使多个对象有机会处理请求，实现请求发送者和接收者之间的解耦。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。


结构

代码实现

/**/ /*
 * 请求者
*/
namespace  DesignPattern.ChainOfResponsibility
{
    public class Request
    {
    }
}

/**/ /*
 * 职责链
*/
namespace  DesignPattern.ChainOfResponsibility
{
    abstract class Handler
    {
        // 后继对象
        private Handler next;
        public Handler Next
        {
            get
            {
                return this.next;
            }
            set
            {
                this.next = value;
            }
        }

        public Handler(Handler next)
        {
            this.next = next;
        }

        public abstract void CanHandlerRequest(Request request);

        // 默认由后继节点处理请求
        public virtual void HanlderRequest(Request request)
        {
            if (next != null)
            {
                next.HanlderRequest();
            }
        }
    }

    public class Handler1 : Handler
    {
        public Handler1(Handler next)
            : base(next)
        {
        }

        public override void CanHandlerRequest(Request request)
        {
            // 
        }

        public override void HanlderRequest(Request request)
        {
            if (CanHandlerRequest(request))
            {
                // 处理请求
            }
            else
            {
                base.HanlderRequest(request);
            }
        }
    }

    public class Handler2 : Handler
    {
        public Handler2(Handler next)
            : base(next)
        {
        }

        public override void CanHandlerRequest(Request request)
        {
            // 
        }

        public override void HanlderRequest(Request request)
        {
            if (CanHandlerRequest(request))
            {
                // 处理请求
            }
            else
            {
                base.HanlderRequest(request);
            }
        }
    }

    public class Handler3 : Handler
    {
        public Handler3(Handler next)
            : base(next)
        {
        }

        public override void CanHandlerRequest(Request request)
        {
            // 
        }

        public override void HanlderRequest(Request request)
        {
            if (CanHandlerRequest(request))
            {
                // 处理请求
            }
            else
            {
                base.HanlderRequest(request);
            }
        }
    }
}

/**/ /*
 * 请求发送者
*/
namespace  DesignPattern.ChainOfResponsibility
{
    public class Sender
    {
        public void Process(Handler handler)
        {
            handler.HanlderRequest();
        }
    }
}

/**/ /*
 * 客户程序
*/
namespace  DesignPattern.ChainOfResponsibility
{
    public class Client
    {
        public void Process()
        {
            Sender sender = new Sender();

            Request request = new Request();

            Handler handler1 = new Handler1(null);
            Handler handler2 = new Handler2(handler1);

            Handler handler3 = new Handler3(handler1);
            handler3.Next = handler2;

            sender.Process(handler3);
        }
    }
}

要点：
      1、本模式的应用场合在“一个请求可能有多个接受者，但是最后真正接受者只有一个”，本模式将二者解耦，更好地应对变化。
      2、应用本模式后，对象的职责分派将更灵活，可以在运行时动态添加、修改请求的处理职责。
      3、如果请求传递到职责链的末尾仍然得不到处理，应该有一个合理的缺省机制进行处理，由请求接受者实现。