Design Patterns(二十二) Chain of Responsibility

backend

Chain of responsibility pattern is used to achieve loose coupling in software design where a request from the client is passed to a chain of objects to process them. Later, the object in the chain will decide themselves who will be processing the request and whether the request is required to be sent to the next object in the chain or not.

前言

    责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

责任链模式

基本介绍：

1) 职责链模式（Chain of Responsibility Pattern）,又叫 责任链模式，为请求创建了一个 接收者对象的 链( 简单示意图) 。这种模式对请求的发送者和接收者进行解耦；
2) 职责链模式通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推；
3) 这种类型的设计模式属于行为型模式

角色介绍：

1) Handler : 抽象的处理者, 定义了一个处理请求的接口, 同时含义另外Handler；
2) ConcreteHandlerA , B 是具体的处理者, 处理它自己负责的请求， 可以访问它的后继者(即下一处
理者), 如果可以处理当前请求，则处理，否则就将该请求交个 后继者去处理，从而形成一个职责链；
3) Request ， 含义很多属性，表示一个请求。

责任链模式-UML图：





责任链模式-实例图：


代码：

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
/**
 * @Auther: Arsenal
 * @Date: 2020-03-21 18:47
 * @Description: 责任链模式
 */
public class Chainofresponsibility {
    public static void main(String[] args) {
        /*
         * 先来一个程序猿 这里给他一个三万以内的随机值表示需要申请的差旅费
         */
        ProgramApe ape = new ProgramApe((int) (Math.random() * 30000));

        /*
         * 再来四个老大
         */
        GroupLeader leader = new GroupLeader();
        Director director = new Director();
        Manager manager = new Manager();
        Boss boss = new Boss();

        /*
         * 处理申请
         */
        if (ape.getExpenses() <= 1000) {
            leader.handleRequest(ape);
        } else if (ape.getExpenses() <= 5000) {
            director.handleRequest(ape);
        } else if (ape.getExpenses() <= 10000) {
            manager.handleRequest(ape);
        } else {
            boss.handleRequest(ape);
        }
    }
}


class SimpleResponsibility {
    public static void main(String[] args) {
        int request = (int) (Math.random() * 3);
        switch (request) {
            case 0:
                System.out.println("SMBother handle it: " + request);
                break;
            case 1:
                System.out.println("Aige handle it: " + request);
                break;
            case 2:
                System.out.println("7Bother handle it: " + request);
                break;
            default:
                break;
        }
    }
}

/**
 * 程序猿类
 */
class ProgramApe {
    private int expenses;// 声明整型成员变量表示出差费用
    private String apply = "爹要点钱出差";// 声明字符串型成员变量表示差旅申请

    /*
     * 含参构造方法
     */
    public ProgramApe(int expenses) {
        this.expenses = expenses;
    }

    /*
     * 获取程序员具体的差旅费用
     */
    public int getExpenses() {
        return expenses;
    }

    /*
     * 获取差旅费申请
     */
    public String getApply() {
        return apply;
    }
}

/**
 * 小组长类
 */
class GroupLeader {

    /**
     * 处理请求
     * @param ape 具体的猿
     */
    public void handleRequest(ProgramApe ape) {
        System.out.println(ape.getApply());
        System.out.println("GroupLeader: Of course Yes!");
    }
}

/**
 * 项目主管类
 */
class Director {
    /**
     * 处理请求
     * @param ape 具体的猿
     */
    public void handleRequest(ProgramApe ape) {
        System.out.println(ape.getApply());
        System.out.println("Director: Of course Yes!");
    }
}

/**
 * 部门经理类
 */
class Manager {
    /**
     * 处理请求
     * @param ape 具体的猿
     */
    public void handleRequest(ProgramApe ape) {
        System.out.println(ape.getApply());
        System.out.println("Manager: Of course Yes!");
    }
}

/**
 * 老总类
 */
class Boss {
    /**
     * 处理请求
     * @param ape 具体的猿
     */
    public void handleRequest(ProgramApe ape) {
        System.out.println(ape.getApply());
        System.out.println("Boss: Of course Yes!");
    }
}

总结

责任链模式的注意事项和细节:

1) 将请求和处理分开，实现解耦，提高系统的灵活性；
2) 简化了对象，使对象不需要知道链的结构；
3) 性能会受到影响，特别是在链比较长的时候，因此需控制链中最大节点数量，一般通过在Handler中设置一个最大节点数量，在setNext()方法中判断是否已经超过阀值，超过则不允许该链建立，避免出现超长链无意识地破坏系统性能；
4) 调试不方便。采用了类似递归的方式，调试时逻辑可能比较复杂
5) 最佳应用场景：有多个对象可以处理同一个请求时，比如：多级请求、请假/加薪等审批流程、Java Web中Tomcat对Encoding的处理、拦截器。

延伸

    责任链模式-菜鸟教程
    Java设计模式 - 责任链模式
    行为型设计模式-责任链模式
    Chain of Responsibility Design Pattern
    尚硅谷Java设计模式，韩顺平图解java设计模式

Article Title:Design Patterns(二十二) Chain of Responsibility

Article Author:Funing Ma

Release Time:2020-03-21 19:18:18

Last Update:2020-03-30 10:01:13

Original Link:https://mafuning.github.io/2020/03/21/2020-03-21-Design-Patterns%E3%80%90%E4%BA%8C%E5%8D%81%E4%BA%8C%E3%80%91-Chain-of-Responsibility/

License Agreement: "CC-BY-SA-4.0"

Content
  1. 1. 前言
  2. 2. 责任链模式
  3. 3. 总结
  4. 4. 延伸