设计模式-职责链模式

一个人在公司干满三个月了，马上要办转正手续，要求加薪。于是他向经理提了出来。

经理也觉得他的工作很认真，能力很强。但是加薪他做不了主，于是他找了人力资源总监。总监说他也做不了主，毕竟刚毕业的大学生加薪的先例没有。但总监说登总经理回来向总经理提一下。但是总经理却不同意加薪，说大学生这么多，随便都能找得到，三个月就想加薪，不合适。

我们把向经理申请，经理没权利，然后向总监上报，总监也没权限，向总经理上报的事，写成代码试试。

我们也许会用一个方法，内部是各种if else 判断是总经理、总监还是经理，然后再if else做处理。

这样写并不好，增加其他的管理类比都要修改这个类，违背了单一职责原则，开放封闭原则。

我们可以把管理者的类别做成管理者的子类，这样利用多态性来化解分支带来的僵化。

让它们之间有一定的关联，把用户的请求传递，直到可以解决这个请求为止。

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

.这里发出这个请求的客户端并不知道这当中的哪一个对象最终处理这个请求，这样系统的更改可以在不影响客户端的情况夏动态地重新组织和分配责任。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ChainOfResponsibility
{
    //申请
    class Request
    {
        //申请类别
        private string requestType;
        public string RequestType
        {
            get { return requestType; }
            set { requestType = value; }
        }
        //申请内容
        private string requestContent;
        public string RequestContent
        {
            get { return requestContent; }
            set { requestContent = value; }
        }
        //数量
        private int requestNumber;
        public int RequestNumber
        {
            get { return requestNumber; }
            set { requestNumber = value; }
        }
    }
    //管理者
    abstract class Manager
    {
        protected string name;
        //管理者的上级
        protected Manager superior;

        public Manager(string name)
        {
            this.name = name;
        }
        //设置管理者的上级
        public void SetSuperior(Manager superior)
        {
            this.superior = superior;
        }
        //申请请求
        abstract public void RequestApplication(Request request); 
    }
    //经理
    class CommonManager : Manager
    {
        public CommonManager(string name)
            : base(name)
        {
        }

        public override void RequestApplication(Request request)
        {
            //经理所能有的权限就是可准许下属两天内的假期
            if (request.RequestType == "请假" && request.RequestNumber <= 2)
            {
                Console.WriteLine("{0} : {1} 数量 {2} 被批准", name, request.RequestContent, request.RequestNumber);
            }
            else
            {
                //其余的申请都需转到上级
                if(superior != null)
                    superior.RequestApplication(request);
            }
        }
    }
    //总监
    class Majordomo : Manager
    {
        public Majordomo(string name)
            : base(name)
        {
        }

        public override void RequestApplication(Request request)
        {
            //总监所能有的权限就是可准许下属一周内的假期
            if (request.RequestType == "请假" && request.RequestNumber <= 5)
            {
                Console.WriteLine("{0} : {1} 数量 {2} 被批准", name, request.RequestContent, request.RequestNumber);
            }
            else
            {
                //其余的申请都需转到上级
                if (superior != null)
                    superior.RequestApplication(request);
            }
        }
    }
    //总经理
    class GeneralManager : Manager
    {
        public GeneralManager(string name)
            : base(name)
        {
        }

        public override void RequestApplication(Request request)
        {
            //总经理可准许下属任意天的假期
            if (request.RequestType == "请假")
            {
                Console.WriteLine("{0} : {1} 数量 {2} 被批准", name, request.RequestContent, request.RequestNumber);
            }
            else if (request.RequestType == "加薪" && request.RequestNumber <= 500)
            {
                //加薪在500以内，没有问题
                Console.WriteLine("{0} : {1} 数量 {2} 被批准", name, request.RequestContent, request.RequestNumber);
            }
            else if (request.RequestType == "加薪" && request.RequestNumber > 500)
            {
                //超过500，就要考虑一下了。
                Console.WriteLine("{0} : {1} 数量 {2} 再说吧", name, request.RequestContent, request.RequestNumber);
            }
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            CommonManager jinli = new CommonManager("金利");
            Majordomo zongjian = new Majordomo("宗剑");
            GeneralManager zhongjingli = new GeneralManager("种精励");
            //设置上级，完全可以根据实际需求来更改设置
            jinli.SetSuperior(zongjian);
            zongjian.SetSuperior(zhongjingli);

            Request request = new Request();
            request.RequestType = "请假";
            request.RequestContent = "小菜请假";
            request.RequestNumber = 1;
            jinli.RequestApplication(request);
            //客户端的申请都是由经理发起，但实际有谁来决策由具体管理类来处理，客户端不知道。
            Request request1 = new Request();
            request1.RequestType = "请假";
            request1.RequestContent = "小菜请假";
            request1.RequestNumber = 4;
            jinli.RequestApplication(request1);

            Request request2 = new Request();
            request2.RequestType = "加薪";
            request2.RequestContent = "小菜请求加薪";
            request2.RequestNumber = 500;
            jinli.RequestApplication(request2);

            Request request3 = new Request();
            request3.RequestType = "加薪";
            request3.RequestContent = "小菜请求加薪";
            request3.RequestNumber = 1000;
            jinli.RequestApplication(request3);

            Console.Read();
        }
    }
}

当客户提交一个请求时，请求是沿链传递直到有一个ConcreteHandler对象负责处理它。

接收者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构。结果是职责链可简化对象的相互链接，它们仅需保持一个指向其后继者的引用，而不需要保持它所有的候选接受者的引用。

随时的增加或修改处理一个请求的结构，增强了给对象指派职责的灵活性。

一个请求极有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理，这就很糟糕了，需要事先考虑全面。