责任链（Chain of Responsibility）

[TOC]

定义

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request.Chain the receiving objects and pass the request along the chain until an object handles it.（使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。）

​ 其实解释也已经非常明显了，就是遵循单一职责来作为责任链的处理接口，具体如何处理对象，什么时候处理，谁来处理，则交由外部或者父类去实现，优点就是系统不需要考虑handler是如何分发和处理的，只需要提交待处理的事件即可，不过缺点也是显而易见，链式传递会导致经由的路径非常长，每个责任链子类都会经过，所以可以在封装的时候考虑在合理的情况下对子链的数量进行制约

简单场景使用

还是老朋友LOL，在正常的比赛中，蓝色方和红色方都需要5位玩家进行游戏，而5位玩家中也有不同的职责，中单，上单，ADC和辅助以及打野爸爸，这里就用责任链的方式来实现玩家与玩家直接的对线辅助提示功能

coding

首先定义咱们的责任链接口

public interface IHandle {

    enum LineType {
        TOP,
        MIDDLE,
        ADC,
        ASSIST,
        DADDY,
        OTHER
    }

    /**
     * 能否处理此对线
     *
     * @param lineType 对线信息
     * @return
     */
    boolean canHandle(LineType lineType);

    /**
     * 下一任对线处理者
     *
     * @param handler
     */
    void setNextHandler(IHandle handler);

    /**
     * 处理对线
     *
     * @param lineType 对线信息
     * @return
     */
    String handle(LineType lineType);
}

接下来定义处理对线信息的基类，负责调度逻辑和约束子类存在

public abstract class BaseHandler implements IHandle {

    protected IHandle mNextHandler;

    @Override
    public final String handle(LineType lineType) {
        if (canHandle(lineType)) {
            return handleLine();
        } else {
            if (mNextHandler != null) {
                return mNextHandler.handle(lineType);
            }
        }
        return "处理不了该英雄的对象";
    }

    @Override
    public final void setNextHandler(IHandle handler) {
        mNextHandler = handler;
    }

    public abstract String handleLine();
}

最后就是实现咱们所有对线状况的handler对象

public class ADCHandler extends BaseHandler {

    @Override
    public String handleLine() {
        return "作为射手英雄，请您走下路~";
    }

    @Override
    public boolean canHandle(LineType lineType) {
        return lineType == LineType.ADC;
    }

}

public class AssistHandler extends BaseHandler {

    @Override
    public String handleLine() {
        return "作为辅助英雄，请您走下路~";
    }

    @Override
    public boolean canHandle(LineType lineType) {
        return lineType == LineType.ASSIST;
    }

}

public class DaddyHandler extends BaseHandler {

    @Override
    public String handleLine() {
        return "作为打野英雄，请您走野区，在合适的时机游走三路~";
    }

    @Override
    public boolean canHandle(LineType lineType) {
        return lineType == LineType.DADDY;
    }

}

public class MiddleHandler extends BaseHandler {
    @Override
    public String handleLine() {
        return "作为中单英雄，请您走中路~";
    }

    @Override
    public boolean canHandle(LineType lineType) {
        return lineType == LineType.MIDDLE;
    }
}

public class TopHandler extends BaseHandler {

    @Override
    public String handleLine() {
        return "作为上单英雄，请您走上路~";
    }

    @Override
    public boolean canHandle(LineType lineType) {
        return lineType == LineType.TOP;
    }

}

对外进行一个封装，用以解耦，注意，上文提到的对责任链的约束可以放到这里来写约束策略，作为行为型的设计模式，可以考虑复杂场景下利用创建型的设计模式来实例化咱们的 “责任链们”

public class ChainMatchSystem {

    private IHandle mHandler;

    public ChainMatchSystem() {
        mHandler = new TopHandler();
        IHandle middleHandle = new MiddleHandler();
        IHandle adcHandle = new ADCHandler();
        IHandle assistHandle = new AssistHandler();
        IHandle daddyHandle = new DaddyHandler();
        mHandler.setNextHandler(middleHandle);
        middleHandle.setNextHandler(adcHandle);
        adcHandle.setNextHandler(assistHandle);
        assistHandle.setNextHandler(daddyHandle);
    }

    public void startMatchGame(IHandle.LineType lineType) {
        System.out.println(mHandler.handle(lineType));
    }
}

最后则是测试main方法

    public static void main(String[] args) {
        ChainMatchSystem chainMatchSystem = new ChainMatchSystem();
        for (int i = 0; i < 5; i++) {
            IHandle.LineType lineType = IHandle.LineType.OTHER;
            if (i == 0) {
                lineType = IHandle.LineType.ASSIST;
            } else if (i == 1) {
                lineType = IHandle.LineType.ADC;
            } else if (i == 2) {
                lineType = IHandle.LineType.TOP;
            } else if (i == 3) {
                lineType = IHandle.LineType.MIDDLE;
            } else if (i == 4) {
                lineType = IHandle.LineType.DADDY;
            }
            chainMatchSystem.startMatchGame(lineType);
        }
    }


//作为辅助英雄，请您走下路~
//作为射手英雄，请您走下路~
//作为上单英雄，请您走上路~
//作为中单英雄，请您走中路~
//作为打野英雄，请您走野区，在合适的时机游走三路~

//修改一下，看看OTHER对线出现时会怎么办，只需要循环6次即可
    public static void main(String[] args) {
        ChainMatchSystem chainMatchSystem = new ChainMatchSystem();
        for (int i = 0; i < 6; i++) {
            IHandle.LineType lineType = IHandle.LineType.OTHER;
            if (i == 0) {
                lineType = IHandle.LineType.ASSIST;
            } else if (i == 1) {
                lineType = IHandle.LineType.ADC;
            } else if (i == 2) {
                lineType = IHandle.LineType.TOP;
            } else if (i == 3) {
                lineType = IHandle.LineType.MIDDLE;
            } else if (i == 4) {
                lineType = IHandle.LineType.DADDY;
            }
            chainMatchSystem.startMatchGame(lineType);
        }
    }

//作为辅助英雄，请您走下路~
//作为射手英雄，请您走下路~
//作为上单英雄，请您走上路~
//作为中单英雄，请您走中路~
//作为打野英雄，请您走野区，在合适的时机游走三路~
//处理不了该英雄的对象

实际场景使用

在咱们Android开发中，责任链的应用有一个非常出名的库，就是咱们的okhttp，感兴趣的同学可以对照着咱们的责任链看一下~