影落离风

The shadow falls away from the wind

0%

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

前言

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

步骤

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

    1. 问题符合自己的等级,自己去处理,处理不了保护伞
    2. 有保护伞,交给保护伞(保护伞也是符合该机制的抽象角色)处理
    3. 没有保护伞只能说一些废话(坏人死于话多)
    4. 让所有符合该处理机制的角色去继承该类(如孙兴、高明远、王政)
    5. 是不是感觉还有点模板模式的味道,这些设计模式很多都不是单独存在,而在业务场景中可能含有其他模式的影子。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    /**
    * 抽象处理角色
    *
    * @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. 好,接下来符合该机制的不同的角色就可以去继承这个抽象角色了

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    /**
    * @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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    /**
    * @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. 现在就可以测试一下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    /**
    * @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. 维护性强,可以动态的修改流程;那个角色的处理逻辑变化,也不会影响其他角色

代码

博客代码路径