设计模式学习笔记-职责链模式

概述：                                                                                                      

使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链。

并沿着这条链传递该请求，直到有一个对象处理它为止。

这一模式的想法是，给多个对象处理一个请求的机会，从而解耦发送者和接受者。

适用场合：                                                                                                

1.有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。

2.你想在不明确指定接受者的情况下，向多个对象中的一个提交请求。

3.处理一个请求的对象集合应被动态指定。

类图：                                                                                                      

代码示例：                                                                                                  

1.职责链的抽象接口

    /// <summary>
    /// 定义一个处理请示的接口
    /// </summary>
    abstract class Handler
    {
        protected Handler successor;
        /// <summary>
        /// 设置继任者
        /// </summary>
        /// <param name="successor"></param>
        public void SetSuccessor(Handler successor) 
        {
            this.successor = successor;
        }
        /// <summary>
        /// 处理请求的抽象方法
        /// </summary>
        /// <param name="request"></param>
        public abstract void HandleRequest(int request);
    }

2.实现职责链上的各个职责类

    /// <summary>
    /// 处理0-10的数
    /// </summary>
    class ConcreteHandler1:Handler
    {
        public override void HandleRequest(int request)
        {
            if(request>=0&&request<=10)
            {
                Console.WriteLine("{0}处理请求{1}",this.GetType().Name,request);
            }
            else if (successor != null) 
            {
                //转移到下一位
                successor.HandleRequest(request);
            }
        }
    }
    /// <summary>
    /// 处理10-20的数
    /// </summary>
    class ConcreteHandler2:Handler
    {
        public override void HandleRequest(int request)
        {
            if(request>=11&&request<=20)
            {
                Console.WriteLine("{0}处理请求{1}",this.GetType().Name,request);
            }
            else if (successor != null) 
            {
                //转移到下一位
                successor.HandleRequest(request);
            }
        }
    }
    /// <summary>
    /// 处理20-30的数
    /// </summary>
    class ConcreteHandler3:Handler
    {
        public override void HandleRequest(int request)
        {
            if(request>=21&&request<=30)
            {
                Console.WriteLine("{0}处理请求{1}",this.GetType().Name,request);
            }
            else if (successor != null) 
            {
                //转移到下一位
                successor.HandleRequest(request);
            }
        }
    }

3.客户端调用

        /// <summary>
        /// 测试职责链模式
        /// </summary>
        static void TestChainOfResponsibility() 
        {
            Handler h1 = new ConcreteHandler1();
            Handler h2 = new ConcreteHandler2();
            Handler h3 = new ConcreteHandler3();
            //设置职责链的上下游
            h1.SetSuccessor(h2);
            h2.SetSuccessor(h3);

            int[] requests = {2,2,5,4,6,4,8,10,25,13,14,15,25,68,14,35,17,30 };
            foreach(int request in requests)
            {
                h1.HandleRequest(request);
            }
            Console.Read();

        }

　小结：                                                                                                      

职责链的重要思想是定义这个链，而且这个链是有方向的，将请求里的变化隐藏处理，例子也很好理解，但是具体应用还是看具体的需求能用这个模式会极大的提高代码的可维护度和降低耦合度。