代码说孙兴高明远王政在扫黑风暴中的职责

前言

看过扫黑风暴，我们都知道孙兴是一家ktv的boss，高明远是绿藤的boss，王政是整个省的boss。因为他们的职责不同，所以解决的问题也不同。他们之间也存在一种链接关系，就是孙兴解决不了的问题会交给高明远，高明远解决不了就找王政。孙兴只需要记住高明远可以解决他解决不了的问题，至于高明远后续会把问题抛给谁，他是不用管的。所以要实现这样的机制，我们就要用到责任链模式

步骤

首先建一个抽象的角色，定义这个角色工作的流程：

问题符合自己的等级，自己去处理，处理不了保护伞
有保护伞，交给保护伞（保护伞也是符合该机制的抽象角色）处理
没有保护伞只能说一些废话（坏人死于话多）
让所有符合该处理机制的角色去继承该类（如孙兴、高明远、王政）
是不是感觉还有点模板模式的味道，这些设计模式很多都不是单独存在，而在业务场景中可能含有其他模式的影子。

/**
 * 抽象处理角色
 *
 * @author MinWeikai
 * @date 2021/8/26 16:23
 */
public abstract class AbstractHandler {

    /**
     * 保护伞
     */
    private AbstractHandler umbrella;

    /**
     * 保护伞名字
     */
    private String name;

    /**
     * 处理等级
     */
    private String handleLevel;

    /**
     * 需要处理的请求，该角色的的核心处理逻辑
     *
     * @param request
     */
    public void handleRequest(String request) {
        System.out.println(this.name.concat("接收：")
                .concat(request));
        // 该问题符合当前角色的处理等级
        if (request.contains(this.handleLevel)) {
            // 自己处理
            this.handleBySelf(request);
        } else {
            // 自己处理不了，看看有没有保护伞
            if (this.getUmbrella() != null) {
                // 将问题抛给保护伞
                this.handleByUmbrella();
                // 保护伞去处理
                this.getUmbrella().handleRequest(request);
            } else {
                // 没有保护伞就只能无助的说遗言了
                this.helplessSay(request);
            }
        }
    }

    /**
     * 自己处理，不同的职责有不同的实现
     *
     * @param request
     */
    public abstract void handleBySelf(String request);

    /**
     * 交给保护伞，各个职责动作一致
     */
    public void handleByUmbrella() {
        System.out.println(this.getName()
                .concat("处理不了这个请求")
                .concat("交给了保护伞")
                .concat(this.getUmbrella().getName())
                .concat("解决"));
    }

    /**
     * 不同职责，没有保护伞，无助时说的话也不一样
     *
     * @param request
     */
    public abstract void helplessSay(String request);

    public String getHandleLevel() {
        return handleLevel;
    }

    public void setHandleLevel(String handleLevel) {
        this.handleLevel = handleLevel;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public AbstractHandler getUmbrella() {
        return umbrella;
    }

    public void setUmbrella(AbstractHandler umbrella) {
        this.umbrella = umbrella;
    }

好，接下来符合该机制的不同的角色就可以去继承这个抽象角色了

/**
 * @author MinWeikai
 * @date 2021/8/26 16:29
 */
public class LittleBossHandler extends AbstractHandler {

    public LittleBossHandler(String name, String handleLevel) {
        this.setName(name);
        this.setHandleLevel(handleLevel);
    }

    @Override
    public void handleBySelf(String request) {
        System.out.println(this.getName()
                .concat("轻松处理：")
                .concat(request));
    }

    @Override
    public void helplessSay(String request) {
        System.out.println(this.getName()
                .concat("无助地说：我真可怜，没有保护伞！"));
    }
}

再来个大boss

/**
 * @author MinWeikai
 * @date 2021/8/26 16:29
 */
public class BigBossHandler extends AbstractHandler {

    public BigBossHandler(String name, String handleLevel) {
        this.setName(name);
        this.setHandleLevel(handleLevel);
    }

    @Override
    public void handleBySelf(String request) {
        System.out.println(this.getName()
                .concat("喝点茶处理：")
                .concat(request));
    }

    @Override
    public void helplessSay(String request) {
        System.out.println(this.getName()
                .concat("无助地说：我头大！"));
    }
}

他们都实现自己的处理逻辑

现在就可以测试一下

/**
 * @author MinWeikai
 * @date 2021/8/27 11:42
 */
public class AbstractHandlerTest {

    public static void main(String[] args) {
        AbstractHandler handler1 = new LittleBossHandler("孙兴", "一般");
        AbstractHandler handler2 = new BigBossHandler("高明远", "麻烦");
        handler1.setUmbrella(handler2);
        handler1.handleRequest("杀了一般的小鸡");
        System.out.println("------------------------------");
        handler1.handleRequest("杀了麦自立，惹了麻烦");
        System.out.println("------------------------------");
        handler1.handleRequest("大江潜伏调查");
    }
}

如上，从抽象角色的核心处理逻辑我们可以知道，孙兴只处理包含一般关键字的问题；高明远处理包含麻烦关键字的问题。所以：
1. 由孙兴处理的”杀了一般的小鸡”，会由孙兴自己处理
2. 由孙兴处理的”杀了麦自立，惹了麻烦”，孙兴处理不了，会交给高明远解决
3. 由孙兴处理的”大江潜伏调查”，孙兴处理不了，会交给高明远解决，高明远也解决不了，而且王政也没罩着他，所以他只能头大了
如想要高明远有保护伞就可在在创建类型去继承AbstractHandler，再将该类塞到handler2.setUmbrella，给高明远设置保护伞。

总结

由上可以看出多个角色去处理一个问题，在处理问题过程中，它们会自己找人处理。
所以一旦遇到问题不知道给谁处理，可以交给第一个人，他会自己向上传递
每个角色之关心自己处理问题的逻辑、处理不了要把问题传给谁
降低耦合度，问题的处理人和提交人没有关系，类似于卧底，只跟他的上一级联系
维护性强，可以动态的修改流程；那个角色的处理逻辑变化，也不会影响其他角色

代码

博客代码路径