你需要了解的行为型设计模式之责任链模式

初识责任链模式

介绍

可以想像一下，击鼓传花，每个人都有机会接触这个花，但是花到了你那，时间到了（处理级别相同，或者是其他的限制条件），你需要唱一首歌（处理这个请求）和责任链模式很像了，唯一不同的是责任链模式中，消息处理了就不往下传递了，新的消息走新的循环。

对于链式结构，每个节点都可以拆开再链接，因此，链式结构有很强的灵活性

可以将每一个节点看做一个对象，每一个对象有不同的处理逻辑，将一个请求从链式顶端出发，沿着链的路径依次传递给每一个对象节点，直到有对象处理这个请求位置

定义

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

应用场景

1. 多个对象处理同一请求，但是具体由哪个对象处理则在运行时动态的决定
2. 字请求处理者不明确的时候向多个对象中的一个提交请求
3. 需要动态的指定一组对象的处理请求

okhttp请求的拦截器就是责任链模式，多个拦截器对象形成链处理请求

UML类图

责任链模式

案例

角色介绍

• AbstractHandler：抽象处理者角色，声明一个处理请求流程的方法，并保持对下一个处理节点Handler对象的引用

• Handler：具体处理者角色，继承父类，实现处理级别和具体处理的抽象方法

• AbstractRequest: 抽象的请求者，声明子类需要实现方法，保存消息对象。

• Request: 具体的请求者，继承父类，实现抽象方法，存储数据，获取数据，设置请求级别。

角色实现

消息处理者父类

public abstract class AbstractHandler {

    protected AbstractHandler nextHandler;

    /**
     * 处理请求方法
     *
     * @param request
     */
    protected void handleRequest(AbstractRequest request) {
        //判断请求级别和处理级别是否一致
        if (request.getRequestLevel() == getHandleLevel()) {
            //一致就由该对象处理
            handle(request);
        } else {
            //否则将请求分发给下一个对象
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                //所有对象不为空时处理
                System.out.println("ALL HANDLER CAN NOT HANDLE THE REQUEST!");
            }
        }

    }

    /**
     * 处理级别
     * @return level
     */
    protected abstract int getHandleLevel();

    /**
     * 具体处理方式
     * @param request 请求对象
     *
     */
    protected abstract void handle(AbstractRequest request);
}

消息请求者父类

public abstract class AbstractRequest {
    //请求内容
    protected Object object;

    //内容赋值
    public AbstractRequest(Object object) {
        this.object = object;
    }

    //获取请求级别
    protected abstract int getRequestLevel();

    /**
     * 获取请求内容
     * @return
     */
    protected Object getRequestContent() {
        return object;
    }
}

创建三个请求者对象

public class Request1 extends AbstractRequest {
    public Request1(Object object) {
        super(object);
    }

    @Override
    protected int getRequestLevel() {
        return 1;
    }
}

后两个略，只是优先级改成2和3

创建三个处理者对象

public class Handler1 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 1;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println(request.getRequestContent()+" request level:"+request.getRequestLevel()+" has been handled by"+" handle level:"+getHandleLevel());
    }
}

后两个略，只是优先级改成2和3

测试

public class test {

    public static void main(String args[]) {
        //实例化处理者对象
        Handler1 handler1 = new Handler1();
        Handler2 handler2 = new Handler2();
        Handler3 handler3 = new Handler3();

        //连接下一个节点
        handler1.nextHandler = handler2;
        handler2.nextHandler = handler3;

        //实例化请求者对象
        Request1 request1 = new Request1("request1");
        Request2 request2 = new Request2("request2");
        Request3 request3 = new Request3("request3");

        //处理请求对象
        handler1.handleRequest(request1);
        handler1.handleRequest(request2);
        handler1.handleRequest(request3);
    }
}

输出结果

request1 request level:1 has been handled by handle level:1
request2 request level:2 has been handled by handle level:2
request3 request level:3 has been handled by handle level:3