责任链模式

定义：

将处理请求的多个对象连成一条链，链上的每个对象都有机会处理该请求，请求会沿着这条链进行传递，直到它被某个对象处理为止。

设计类图：

责任链模式的主要角色就是Handler处理者对象，通过类图可以发现它主要有两个特点，一个是可以处理请求的方法，还有就是可以设置下一个处理者对象。其中ConcreteHandler是具体的处理者，可以有多个。

示例代码：

public abstract class Handler {
    private Handler successor;
    private int handleLevel;

    public Handler(int handleLevel) {
        //每个处理者必须要知道自己能够处理的级别或者范围
        this.handleLevel = handleLevel;
    }

    /**
     * 处理请求对象
     */
    public Response handleRequest(Request request) {
        //如果请求是当前处理者能够处理的，就由当前处理者处理
        if (request.getLevel() == this.handleLevel) {
            return handleBusiness();
        } else {
            //否则，交由下一个处理者处理（如果有）
            if (successor != null) {
                return successor.handleRequest(request);
            }
        }
        return new Response("No Handler Found!");
    }

    /**
     * 设置下一个处理者对象
     */
    public  void setNextHandler(Handler handler) {
        successor = handler;
    }

    /**
     * 当前处理者真正处理业务逻辑的方法
     */
    public abstract Response handleBusiness();

}

public class ConcreteHandler1 extends Handler {

    public ConcreteHandler1(int handleLevel) {
        super(handleLevel);
    }

    @Override
    public Response handleBusiness() {
        System.out.println("ConcreteHandler1进行处理");
        return new Response("来自ConcreteHandler1的处理结果");
    }
}

public class ConcreteHandler2 extends Handler {

    public ConcreteHandler2(int handleLevel) {
        super(handleLevel);
    }

    @Override
    public Response handleBusiness() {
        System.out.println("ConcreteHandler2进行处理");
        return new Response("来自ConcreteHandler2的处理结果");
    }
}

public class ConcreteHandler3 extends Handler {

    public ConcreteHandler3(int handleLevel) {
        super(handleLevel);
    }

    @Override
    public Response handleBusiness() {
        System.out.println("ConcreteHandler3进行处理");
        return new Response("来自ConcreteHandler3的处理结果");
    }
}

public class Request {
    private int level;

    public Request(int level) {
        this.level = level;
    }

    public int getLevel() {
        return level;
    }
}

public class Response {
    String result;

    public Response(String result) {
        this.result = result;
    }

    public String getResult() {
        return result;
    }
}

public class Client {

    public static void main(String[] args) {

        Handler handler1 = new ConcreteHandler1(1);
        Handler handler2 = new ConcreteHandler2(2);
        Handler handler3 = new ConcreteHandler3(3);

        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);

        System.out.println("处理第一个请求 级别为1:");
        Request request = new Request(1);
        Response response = handler1.handleRequest(request);
        System.out.println("处理结果：");
        System.out.println(response.getResult());

        System.out.println("-------------------------------");

        System.out.println("处理第二个请求 级别为2:");
        request = new Request(2);
        response = handler1.handleRequest(request);
        System.out.println("处理结果：");
        System.out.println(response.getResult());

        System.out.println("-------------------------------");

        System.out.println("处理第三个请求 级别为3:");
        request = new Request(3);
        response = handler1.handleRequest(request);
        System.out.println("处理结果：");
        System.out.println(response.getResult());

    }
}

输出结果：

  通过输出结果可以看到。每一个级别的请求都得到了对应级别的处理者的正确的处理。在上面代码中设置了每个处理者当前能够处理的级别，当然这里只是示例，这里的级别可以是你的其它的约束判断条件。当请求被发出后，就不需要关心后面的事情，完全由Handler内部来判断该请求是否是由当前的Handler来处理还是交由下一个来处理。不同级别的请求在责任链中传递时满足条件的处理者自然会处理它。

  如图，责任链模式使得链条上面的每一个处理者都有机会对请求进行处理或者传递给下家，当某一个处理者处理了该请求并返回后，请求过程就结束了。责任链上的每一个处理者内部的逻辑是相互独立的，这样每个处理者能够专注于自己要干的事，职责上更加清晰明确。

责任链模式的优缺点

  优点就是将请求和处理过程进行了解耦，请求不需要知道处理的全过程，处理者也不用关心整个过程，只需要关心自己需要处理的部分。还有一个优点就是，你可以动态的改变责任链上处理者的次序或者是动态的新增删除一个处理者。缺点是链条比较长的时候，会产生性能问题，因为必须沿着链条一个一个的过才能知道最终被哪个处理，假如处理者正好处于链尾，就会耗时比较长。另外链条比较长的话，可能调试排错也会比较麻烦些。

  当然实际当中优点带来的影响能够盖过缺点带来的影响的话，还是可以尝试使用的，比如我有不同类型的注册用户，针对不同的请求不同类型的注册用户需要做出不同的响应，这时就很适合责任链模式来处理，它可以代替你的一大堆的if-else条件判断了。

参考：

• 《设计模式之禅》
• 《Head First设计模式》