Chain of Responsibility Pattern

意图
使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系.将这些对象连成一条链,并沿着这条链传递请求,直到有一个对象处理它为止.

 

责任链模式相当于数据结构的链表一样,数据结构链表分为单项链表,双项链表,单项循环链表,双项循环链表.责任链模式就是这种行为的反映,它就是相当于将多个对象连成一条链,接着第一个对象收到一个请求该对象决定是否处理请求,如果该对象处理请求则处理请求,如果它不处理转到到二个对象,第二个重复第一个的过程,如果请求直接被它处理的话那么请求就结束了,以此类推.

 

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

 

2.你想在不明确指定接收者的情况下,向多个对象中的一个,提交一个请求.
比如说我有一个链表其中有10个对象,那么我想对第五个对象提出请求,我只需要对链表的第一个对象发出一个请求,前四个

对象可以忽略掉该请求,最后又第五个来处理,客户端不知道到底是哪个对象去真正的处理了请求.

 

3.可处理一个请求的对象集合应被动态指定.
处理的请求是在运行时被动态指定的,并不是在编译时就指定好的.

 

构成:
1.传递者接口(Handler):
(1).定义一个处理请求的接口
(2).定义一个后继者的引用或通过子类实现(可选)

 

2.具体传递者(ConcreteHandler):可以访问链中下一个对象,如果可以处理请求,就处理它,否则将请求转发给后继者
具体传递者有相应的引用,这个引用会传递给下一个处理者.

 

3.客户端(Client):向链中的对象发出请求

 

ClassDiagram:

 

SequenceDiagram:

 

class Client
    {
        static void Main(string[] args)
        {
            Handler handlerA = new ConcreteHandlerA();
            Handler handlerB = new ConcreteHanlderB();
            Handler handlerC = new ConcreteHanlderC();

            handlerA.SetHanlder(handlerB);
            handlerB.SetHanlder(handlerC);

            int[] requests = { 15, 3, 22, 20, 18, 15 };

            foreach (int request in requests)
            {
                handlerA.HandlerRequest(request);
            }

            Console.ReadKey();
        }
    }

    /// <summary>
    /// 抽象的传递者
    /// </summary>
    abstract class Handler
    {
        protected Handler handler;

        //定义后继者的引用
        public void SetHanlder(Handler handler)
        {
            this.handler = handler;
        }

        public abstract void HandlerRequest(int request);
    }

    /// <summary>
    /// 具体传递者A
    /// </summary>
    class ConcreteHandlerA : Handler
    {
        public override void HandlerRequest(int request)
        {
            if (request > 0 && request <= 10)
            {
                Console.WriteLine("{0} handlers {1}", this.GetType().Name, request);
            }
            else if (handler != null)
            {
                handler.HandlerRequest(request);
            }
        }
    }

    /// <summary>
    /// 具体传递者B
    /// </summary>
    class ConcreteHanlderB : Handler
    {
        public override void HandlerRequest(int request)
        {
            if (request > 10 && request <= 20)
            {
                Console.WriteLine("{0} handler {1}", this.GetType().Name, request);
            }
            else if (handler != null)
            {
                handler.HandlerRequest(request);
            }
        }
    }

    /// <summary>
    /// 具体传递者C
    /// </summary>
    class ConcreteHanlderC : Handler
    {
        public override void HandlerRequest(int request)
        {
            if (request > 20 && request <= 30)
            {
                Console.WriteLine("{0} handler {1}", this.GetType().Name, request);
            }
            else if (handler != null)
            {
                handler.HandlerRequest(request);
            }
        }
    }

 

总结:
其实责任链模式(职责链模式)就是构造一个链表,请求来了第一个对象处理不了转第二个,第二个处理不了转第三个,以此类推,直到转到处理该请求的对象.