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

前言

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

步骤

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

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

   /**
    * 抽象处理角色
    *
    * @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;
       }
   

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

   /**
    * @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("无助地说：我真可怜，没有保护伞！"));
       }
   }
   

3. 再来个大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("无助地说：我头大！"));
       }
   }
   

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

5. 现在就可以测试一下

   /**
    * @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("大江潜伏调查");
       }
   }
   

6. 如上，从抽象角色的核心处理逻辑我们可以知道，孙兴只处理包含一般关键字的问题；高明远处理包含麻烦关键字的问题。所以：

   1. 由孙兴处理的"杀了一般的小鸡"，会由孙兴自己处理
   2. 由孙兴处理的"杀了麦自立，惹了麻烦"，孙兴处理不了，会交给高明远解决
   3. 由孙兴处理的"大江潜伏调查"，孙兴处理不了，会交给高明远解决，高明远也解决不了，而且王政也没罩着他，所以他只能头大了

7. 如想要高明远有保护伞就可在在创建类型去继承AbstractHandler，再将该类塞到handler2.setUmbrella，给高明远设置保护伞。

总结

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

代码

博客代码路径