编程模式之十四----行为型----职责链模式

 

 

 定义

 　　避免把一个请求的发送者和接收者耦合在一起，使多个对象都有机会处理请求。将这个请求的多个接收着连接成一条链，并让请求沿着这个链传递下去，只到有一个结点能处理请求。

　　职责链模式中，链形成后，不一定非要有一个结点能够处理请求，也就是说，所有结点都可以处理一下再往下传，也可以都不处理，这样说来就比较灵活了。

 组成

 　　抽象处理者：AbstractHandler。维护一个对自身类型对象的引用，这个引用作为下一个具体的处理者。声明所有处理者都用到的方法，这个方法的作用是设置本处理者后面的一个处理者。另外声明一个处理请求的方法。

　　具体处理者：Handler。实现设置下一个处理者的方法。实现处理请求的方法，也就是业务方法。

 一个例子

 　　以我们公司的请假过程为例子，我们公司的请假审批过程是这样的：请不多于1天，只用主管（Supervisor）审批就可以了；请不多于3天，而大于1天，就需要部门经理（DepartmentManager）审批；请假超过3天，就需要总经理（GeneralManager）审批了。

　　抽象处理者设计为Manager，包含主管，经理和总经理。具体处理者就是上面三位：主管，经理，总经理。这里的请求就是请假这个事。　　

　　代码如下：

    /// <summary>
    /// 抽象管理者类
    /// </summary>
    abstract class Manager
    {
        //维护下一个管理者的引用
        public Manager manager = null;
        /// <summary>
        /// 设置下一个管理者的方法，也是下一个处理者
        /// </summary>
        /// <param name="manager"></param>
        public abstract void SetNextHandler(Manager manager);
        /// <summary>
        /// 业务方法，怎么处理请假这件事
        /// </summary>
        public abstract void HandlerLeave(int days);
    }
    /// <summary>
    /// 主管处理者
    /// </summary>
    class Supervisor : Manager
    {
        public override void SetNextHandler(Manager manager)
        {
            this.manager = manager;
        }
        public override void HandlerLeave(int days)
        {
            if (days <= 1)
            {
                Console.WriteLine("主管处理了请假：允许");
            }
            else
            {
                Console.WriteLine("主管没有权力，交给部门经理处理");
                this.manager.HandlerLeave(days);
            }
        }
    }
    /// <summary>
    /// 部门经理处理者
    /// </summary>
    class DepartmentManager : Manager
    {
        public override void SetNextHandler(Manager manager)
        {
            this.manager = manager;
        }
        public override void HandlerLeave(int days)
        {
            if (days <= 3)
            {
                Console.WriteLine("部门经理处理了请假：允许");
            }
            else
            {
                Console.WriteLine("部门经理没有权力，交给总经理处理");
                this.manager.HandlerLeave(days);
            }
        }
    }
    /// <summary>
    /// 总经理处理者
    /// </summary>
    class GeneralManager : Manager
    {
        public override void SetNextHandler(Manager manager)
        {
            this.manager = manager;
        }
        public override void HandlerLeave(int days)
        {
            if (days <= 10)
            {
                Console.WriteLine("总经理处理了请假：允许");
            }
            else
            {
                Console.WriteLine("总经理处理了请假：时间太长，不允许");
            }
        }
    }

 　　客户端代码如下：

       static void Main(string[] args)
        {
            Manager supervisor = new Supervisor();
            Manager departManager = new DepartmentManager();
            Manager generalManager = new GeneralManager();
            //设置主管的下一个处理者：部门经理
            supervisor.SetNextHandler(departManager);
            //设置总店经理的下一个处理者：总经理
            departManager.SetNextHandler(generalManager);
            //职责链形成，开始处理

            int days1 = 1;
            int days2 = 2;
            int days3 = 3;
            int days4 = 4;
            int days5 = 11;

            supervisor.HandlerLeave(days5);//使用11天测试
            Console.Read();
        }

　　使用11天测试，结果如下：

主管没有权力，交给部门经理处理
部门经理没有权力，交给总经理处理
总经理处理了请假：时间太长，不允许

　　注意：链的创建是由客户端来完成的，客户端有能力改变处理者的处理次序。

 一些扩展

 　　其实，在上面的例子中，主管和部门经理都做了处理，无论处理的结果是怎么样的，总之是做了处理。这种有叫做不纯的职责链模式。

如果主管和部门经理一看时间，只接不批示的话，也就是说不做处理的话，只让大boss处理，又叫做纯的职责链模式。

　　在实际做程序时，异常处理时，有时会用到以下过程：

           try
            {
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                throw new Exception(ex.Message + "某某处理错误");
            }

 　　在第一次捕获异常并显示异常后，又把异常交给下一任"捕捉--处理"过程来二次处理，这种算是不纯的职责链模式。

 使用环境

 　　不明确请求处理者是具体的哪一个对象，只知道对象是在一个对象群中时，可以使用此模式。

　　当有多个对象都有可能处理请求时。

 PS

 　　做这个笔记的目的是让自己的印象更深一些。写的有些仓促，万望提出宝贵意见，不论是表达方面，还是技能方面或者是文章组织方面。你的意见，对我很重要，谢谢~