设计模式之禅——责任链模式

引：一个问题对应一个解决方法，你一般需要去找到对应的方法，现在有一种方法就是你不管遇到什么问题只要交给第一个解决方法就可以了，美滋滋，这就是责任链模式。

定义

使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。——行为类

责任链模式的重点在“链”上，由一条链去处理相似的请求在链中决定谁来处理这个请求，并返回相应的结果。其通用类图如下：

责任链模式的核心在链上，“链”是由多个处理者ConcreteHandle组成的，它的通用源码如下：

// 抽象处理者
public abstract class Handler {
    private Handler nextHandler;
    // 每个处理者都必须对请求做出处理
    public final Response handleMessage(Request request) { // final关键字参考模板模式的模板方法
        //  判断是否是自己的处理级别
        if (this.getHandlerLevel().equals(request.getRequestLevel())) {
            response = this.echo(request);
        } else { // 不属于自己的处理级别
            // 判断是否有下一个处理者
            if (this.nextHandler != null) {
                response = this.nextHandler.handleMessage(request);
            } else {
                // 没有适当处理者，业务自行处理
            }
        }
        return response;
    }
    // 设置下一个处理者
    public void setNext(Handler _handler) {
        this.nextHandler = _handler;
    }
    // 每个处理者都有一个处理级别
    protect abstract Level getHandlerLevel();
    //每个处理者都必须实现处理任务
    protect abstract Response echo(Request request);
}

// 具体处理者
public class Concretehandler1 extends Handler {
    // 定义自己的处理逻辑
    protected Response echo(Request request) {
        // 完成处理逻辑
        return null;
    }
    // 设置自己的处理级别
    protected Level getHandlerLevel() {
        // 设置自己的处理级别
        return null;
    }
}
public class Concretehandler2 extends Handler {
    // 定义自己的处理逻辑
    protected Response echo(Request request) {
        // 完成处理逻辑
        return null;
    }
    // 设置自己的处理级别
    protected Level getHandlerLevel() {
        // 设置自己的处理级别
        return null;
    }
}
public class Concretehandler3 extends Handler {
    // 定义自己的处理逻辑
    protected Response echo(Request request) {
        // 完成处理逻辑
        return null;
    }
    // 设置自己的处理级别
    protected Level getHandlerLevel() {
        // 设置自己的处理级别
        return null;
    }
}

// 模式中有关框架代码
public class Level {
    // 定义一个请求和处理等级
}
public class Request {
    // 请求的等级
    public Level getRequestLevel() {
        return null;
    }
}
publci class Request {
    // 处理者返回的数据
}

// 场景类
public class Client {
    public static void main(String[] args) {
        // 声明所有的处理节点
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();
        // 设置链中的阶段顺序1-->2-->3
        handler1.setNext(handler2);
        handler2.setNext(handler3);
        // 提交请求，返回结果
        Response response = handler1.handlerMessage(new Request());
    }
}

在实际应用中，一般会有一个封装类对责任模式进行封装，直接返回链中的第一个处理者，具体链的设置不需要高层模块关系，这样，简化了高层次模式的调用，减少模块间的耦合，提高系统的灵活性。

应用

优点

将请求和处理分开，请求者可以不用知道谁处理的，处理者可以不用知道请求的全貌，两者解耦。

缺点

1. 性能问题，每个请求都是从链头遍历到链尾，在链比较长的时候，性能就会出现问题。
2. 调试不方便，调试逻辑复制。

注意事项

链中节点数量需要控制，避免出现超长链的情况，一般做法是在Handler中设置一个最大节点数量，在setNext方法中判断是否已经超过其阈值，超过则不允许该链建立。

最佳实践

1. 融合模板方法模式，每个实现类只要实现两个方法：echo方法处理请求和getHandlerLevel获得处理级别，符合单一职责原则和迪米特法则。
2. 责任链模式的核心它屏蔽了请求的处理过程，只要你把请求抛给责任链的第一个处理者，最终会返回一个处理结果，作为请求者不用知道需要谁来处理。

参考

1. 《设计模式之禅》