设计模式之职责链模式（Chain of Responsibility Pattern）

1.概念

 职责链模式（Chain of Responsibility Pattern）：避免将请求发送者与接收者耦合在一起，让多个对象都有机会接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。职责链模式是一种对象行为型模式。

2.结构

职责链模式结构的核心在于引入了一个抽象处理者

从图中可以看出，在职责链模式结构图中包含以下两个角色：
 （1）Handler（抽象处理者）：它定义了一个处理请求的接口，一般设计为抽象类。由于不同的具体处理者处理请求的方式不同，因此在其中定义了抽象请求处理方法。因为每个处理者的下家还是一个处理者，因此在抽象处理者中定义一个抽象处理者类型的对象（结构图中的successor），作为其对下家的引用。通过该引用，处理者可以连成一条链。
 （2）ConcreteHandler（具体处理者）：它是抽象处理者的子类，可以处理用户请求。在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，可以访问链中下一个对象，达到请求转发的效果。
 在职责链模式里，每个对象对其下家的引用连接起来形成一条链。请求在这个链上传递，直到链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织链和分配职责。

3.典型代码

职责链模式的核心在于抽象处理者类的设计，抽象处理者类的典型代码如下：

abstract class Handler {
    //维持对下家的引用
    protected Handler successor;
    
    public void setSuccessor(Handler successor) {
        this.successor = successor;    
    }
    
    public abstract void handleRequest(String request);
}
1
2
3
4
5
6
7
8
9
10

在上述代码中，抽象处理者定义了对下家的引用对象，以便将请求转发给下家。该对象的访问符可设为 protected，在其子类中可以使用。

具体处理者是抽象处理者的子类，它有两大作用：

• 处理请求，不同的具体处理者以不同的形式实现抽象请求处理方法 handleRequest()；
• 转发请求，如果该请求超出了当前处理者的处理范围，可以将该请求转发给下家。

具体处理者类的典型代码如下：

class ConcreteHandler extends Handler {
    public void handleRequest(String request) {
        if (请求满足条件) {
            //处理请求        
        } 
        else {
            this.successor.handleRequest(request);  //转发请求
        }
    }
}
1
2
3
4
5
6
7
8
9
10

4.案例分析一：采购单审批系统

某一采购单审批系统是分级进行的，即根据采购金额的不同由不同层次的主管人员来审批。

主任可以审批5万元以下的采购单，副董事长可以审批 [5, 10) 万元的采购单，董事长可以审批 [10, 50) 万元的采购单，50万元及以上的采购单就需要开董事会讨论决定。

由于每个职位的审批者都有下家（除了董事会），且他们的行为是有共通性的，都涉及将审批转发给后继。因此设计一个审批者类作为抽象处理者：

//审批者类: 抽象处理者
abstract class Approver {
    protected Approver successor;  //定义后继对象
    protected String name;  //审批者姓名

    public Approver(String name) {
        this.name = name;
    }

    //设置后继者
    public void setSuccessor(Approver successor) {
        this.successor = successor;
    }

    public abstract void processRequest(PurchaseRequest request);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

然后各个职位的作为具体处理者，要实现抽象处理者：

//主任: 具体处理者
class Director extends Approver{
    public Director(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() < 50000) {
            System.out.println(
                    MessageFormat.format("主任 {0} 审批采购单:{1}, 金额:{2}元, 采购目的:{3}。",
                            this.name, request.getNumber(), request.getAmount(), request.getPurpose())
            );
        } else {
            this.successor.processRequest(request);  //转发请求
        }
    }
}

//副董事长：具体处理类
class VicePresident extends Approver{
    public VicePresident(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() < 100000) {
            System.out.println(
                    MessageFormat.format("副董事长 {0} 审批采购单:{1}, 金额:{2}元, 采购目的:{3}。",
                            this.name, request.getNumber(), request.getAmount(), request.getPurpose())
            );
        } else {
            this.successor.processRequest(request);
        }
    }
}

//董事长类：具体处理者
class President extends Approver{
    public President(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() < 500000) {
            System.out.println(
                    MessageFormat.format("董事长 {0} 审批采购单:{1}, 金额:{2}元, 采购目的:{3}。",
                            this.name, request.getNumber(), request.getAmount(), request.getPurpose())
            );
        } else {
            this.successor.processRequest(request);
        }
    }
}

//董事会类：具体处理者
class Congress extends Approver{
    public Congress(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        System.out.println(
                MessageFormat.format("召开董事会 审批采购单:{0}, 金额:{1}元, 采购目的:{2}。",
                        request.getNumber(), request.getAmount(), request.getPurpose())
        );
    }
}
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

再定义一个采购单类，作为需要被审批的目标：

//采购单: 请求类
class PurchaseRequest {
    private double amount;  //采购金额
    private int number;  //采购单编号
    private String purpose;  //采购目的

    public PurchaseRequest(double amount, int number, String purpose) {
        this.amount = amount;
        this.number = number;
        this.purpose = purpose;
    }

    public double getAmount() {
        return amount;
    }

    public void setAmount(double amount) {
        this.amount = amount;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public String getPurpose() {
        return purpose;
    }

    public void setPurpose(String purpose) {
        this.purpose = purpose;
    }
}
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

编写客户端测试代码：

class Client {
    public static void main(String[] args) {
        Approver kangXi, yongZheng, qianLong, hanLinYuan;
        kangXi = new Director("康熙");
        yongZheng = new VicePresident("雍正");
        qianLong = new VicePresident("乾隆");
        hanLinYuan = new Congress("翰林院");

        //创建职责链
        kangXi.setSuccessor(yongZheng);
        yongZheng.setSuccessor(qianLong);
        qianLong.setSuccessor(hanLinYuan);

        //创建采购单
        PurchaseRequest pr1 = new PurchaseRequest(45000, 10001, "购买刀");
        kangXi.processRequest(pr1);

        PurchaseRequest pr2 = new PurchaseRequest(60000, 10002, "购买枪");
        kangXi.processRequest(pr2);

        PurchaseRequest pr3 = new PurchaseRequest(160000, 10003, "购买火炮");
        kangXi.processRequest(pr3);

        PurchaseRequest pr4 = new PurchaseRequest(800000, 10004, "购买军舰");
        kangXi.processRequest(pr4);
    }
}
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

编译并运行程序，输出结果如下：

主任 康熙 审批采购单:10,001, 金额:45,000元, 采购目的:购买刀。
副董事长 雍正 审批采购单:10,002, 金额:60,000元, 采购目的:购买枪。
董事长 乾隆 审批采购单:10,003, 金额:160,000元, 采购目的:购买火炮。
召开董事会 审批采购单:10,004, 金额:800,000元, 采购目的:购买军舰。
1
2
3
4

5.案例分析二：班级任务处理

下面来设计一个和上面有些不同的案例，这样可以扩展我们对职责链模式的理解，以及它所能应用的场景。

• 第1点不同：处理者的请求方法带有返回值，可以反馈信息给上家；
• 第2点不同：《采购单审批系统》案例是先处理请求再转发请求，而该《班级任务处理》案例是先转发请求再处理请求

学校会派发一些任务给班级进行处理，这些类型包括 one, two, three, four 等等类型，班主任可以处理 one, two, three 这三种类型的任务，班长可以处理 one, two 这两种类型的任务，学习委员可以处理 one 这种类型的任务。班主任在收到任务时，会先将任务交给班长处理，如果下家处理不了，班主任再自己处理；班长在收到任务时，会先将任务交给学委处理，如果下家处理不了，班长再自己处理；学委收到任务时，如果能则自己处理。且他们处理不了时，都会向上反馈。

下面设计Handler类作为抽象处理者：
由于自己以及自己的下家并不一定能处理某些班级任务，存在向上反馈的情况，因此处理者的请求方法需要有boolean型返回值，用于告诉上家是否能处理该任务。

abstract class Handler {
    protected Handler successor;  //定义后继对象

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract boolean handleRequest(String taskName);
}
1
2
3
4
5
6
7
8
9

下面分别将班主任、班长、学习委员设计为具体处理者。
班主任默认先将任务给班长处理，班长默认先将任务给学习委员处理，学习委员只能处理 one 类型的任务，处理不了则向上返回 false；
班长如果收到的反馈为false，则自己处理，他只能处理 one, two 类型的任务，处理不了则向上返回 false；
班主任如果收到的反馈为false，则自己处理，他只能处理 one, two, three 类型的任务，处理不了则向上返回false。

//班主任
class HeadTeacher extends Handler{
    @Override
    public boolean handleRequest(String taskName) {
        boolean handled = successor.handleRequest(taskName);
        if (handled) {
            return true;
        }
        if (taskName.equals("one") || taskName.equals("two") || taskName.equals("three")) {
            System.out.println("班主任处理了该事务");
            return true;
        }

        return false;
    }
}

//班长
class Monitor extends Handler{
    @Override
    public boolean handleRequest(String taskName) {
        boolean handled = successor.handleRequest(taskName);
        if (handled) {
            return true;
        }
        if (taskName.equals("one") || taskName.equals("two")) {
            System.out.println("班长处理了该事务");
            return true;
        }

        return false;
    }
}

//学习委员
class StudyCommissary extends Handler{
    @Override
    public boolean handleRequest(String taskName) {
        boolean handled;
        if (successor == null) {  //注意学习委员可能没有下家，所以这里判一下是否为空
            handled = false;
        } else {
            handled = successor.handleRequest(taskName);
        }

        if (handled) {
            return true;
        }
        if (taskName.equals("one")) {
            System.out.println("学习委员处理了该事务");
            return true;
        }

        return false;
    }
}
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

编写客户端测试代码：
分别给每个职位设置下家，不过注意学习委员没有下家。
还有如果出现班主任也处理不了的任务，则打印一行日志进行说明

public class SchoolClient {
    public static void main(String[] args) {
        Handler headTeacher, monitor, studyCommissary;
        headTeacher = new HeadTeacher();
        monitor = new Monitor();
        studyCommissary = new StudyCommissary();

        headTeacher.setSuccessor(monitor);
        monitor.setSuccessor(studyCommissary);
        studyCommissary.setSuccessor(null);  //没有下一职责人

        startRequest(headTeacher, "one");
        startRequest(headTeacher, "two");
        startRequest(headTeacher, "three");
        startRequest(headTeacher, "four");
    }

    private static void startRequest(Handler headTeacher, String taskName) {
        if (! headTeacher.handleRequest(taskName)) {
            System.out.println("该班级处理不了此类任务！");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

编译并运行程序，输出结果如下：

学习委员处理了该事务
班长处理了该事务
班主任处理了该事务
该班级处理不了此类任务！
1
2
3
4

6.适用场景

在以下情况下可以考虑适用职责链模式：

• 有多个对象可以处理同一个请求，具体哪个对象处理该请求待运行时刻再确定。客户端只需将请求提交到链上，而无须关心请求的处理对象是谁以及它是如何处理的
• 在不明确指定接收者的情况下，向多个对象中的一个提交请求
• 可动态指定一组对象处理请求。客户端可以动态创建职责链来处理请求，还可以改变链中处理者之间的先后次序
  
  

---

参考书籍：
《设计模式的艺术》——刘伟