理解设计模式之：责任链模式

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

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

3. 模式角色分析：

• 抽象的处理者角色：声明一个处理请求的方法，并在其中持有一个对下一个处理节点的引用
• 具体的处理者角色：对请求进行处理，如果不能处理则将请求转发给下一个节点上的处理对象
• 客户端：动态构建责任链

4. 示例代码：

    /**
    * 抽象的处理者角色
    */
    public abstract class Handler {

        protected Handler successor;

        public void setSuccessor(Handler successor) {
            this.successor = successor;
        }

        /**
         * 处理请求，交由子类去实现自己的逻辑
         * @param request
         */
        public abstract void handleRequest(int request);
    }


    ----------------------------------------------------------------------

    /**
    * 具体的处理角色A
    */
    public class ConcreteHandlerA extends Handler {

        @Override
        public void handleRequest(int request) {

            System.out.print("ConcreteHandlerA handleRequest() -> ");

            if (request >= 0 && request < 10) {
                System.out.println("ConcreteHandlerA handled request");
                System.out.println("---------------------------------\n\n");
            }else {
                successor.handleRequest(request);
            }
        }

    }

    ----------------------------------------------------------------------

    /**
    * 具体的处理角色B
    */
    public class ConcreteHandlerB extends Handler {

        @Override
        public void handleRequest(int request) {

            System.out.print("ConcreteHandlerB handleRequest() -> ");

            if (request >= 10 && request < 20) {
                System.out.println("ConcreteHandlerB handled request");
                System.out.println("---------------------------------\n\n");
            }else {
                successor.handleRequest(request);
            }
        }
    }

    ----------------------------------------------------------------------

    /**
    * 具体的处理角色C
    */
    public class ConcreteHandlerC extends Handler {


        @Override
        public void handleRequest(int request) {

            System.out.print("ConcreteHandlerC handleRequest() -> ");

            if (request >= 20 && request < 30) {
                System.out.println("ConcreteHandlerC handled request");
                System.out.println("---------------------------------\n\n");
            } else {
                successor.handleRequest(request);
            }
        }
    }



    public class Client {

        public static void main(String[] args) {

            Handler h1 = new ConcreteHandlerA();
            Handler h2 = new ConcreteHandlerB();
            Handler h3 = new ConcreteHandlerC();

            h1.setSuccessor(h2);
            h2.setSuccessor(h3);

            int[] requests = {2, 14, 22};

            for (int request : requests) {
                h1.handleRequest(request);
            }

        }
    }

输出结果如下：

        ConcreteHandlerA handleRequest() -> ConcreteHandlerA handled request
        ---------------------------------


        ConcreteHandlerA handleRequest() -> ConcreteHandlerB handleRequest() -> ConcreteHandlerB handled request
        ---------------------------------


        ConcreteHandlerA handleRequest() -> ConcreteHandlerB handleRequest() -> ConcreteHandlerC handleRequest() -> ConcreteHandlerC handled request
        ---------------------------------

   通过上面的输出结果，我们可以看到整个请求的处理流程，也就能体会到责任链的链的含义。

     一开始觉得关于设计模式这类的文章，自己不想写，因为感觉算是读书笔记。后来想想，还是记录下来，并且一篇文章写完了不是说就算事的，后续还会根据项目中遇到的解耦性问题，可以通过什么样的模式来解决，或者是在阅读框架源码中遇到该设计模式，会再次更新文章。

相关内容参考自：《大话设计模式》、《Android源码设计模式与实战》