职责链模式(Chain of Responsibility)

什么是职责链

先看个场景：

某公司请假制度为：
请假1天，需小组长批准
请假超过1天小于等于3天，需项目经理批准
请假超过3天小于等于7天，需人事部门批准

普通做法的伪代码为:

if(请假天数 <= 1){
    askForLeave(小组长);
}ele if(请假天数 <= 3  &&  请假天数 > 1){
    askForLeave(项目经理);
}else if(请假天数 <= 7  &&  请假天数 > 3){
    askForLeave(人事部门);
}else {
    otherOp();
}

但是假如多几种操作，比如请假5天需要向老王请假，那就得重新整理代码顺序。
使用职责链可以有效的解决这个问题，先看看职责链处理这个问题的代码 -- AskForLevel。
定义一个Client基类：

public class Client {
    private String leaveName;
    private int leaveDays;

    public Client(String leaveName, int leaveDays) {
        this.leaveName = leaveName;
        this.leaveDays = leaveDays;
    }

    getter/setter method(){
        ... ...
    }
}

所有“领导”继承基类：

public class GroupLeader extends Handler {
    public GroupLeader(String name) {
        super(name);
    }

    public void handleRequest(Client request) {
        if (request.getLeaveDays() <= 1) {
            System.out.println("组长" + name + "审批员工" + request.getLeaveName()
                    + "的请假条，请假天数为" + request.getLeaveDays() + "天。");
        } else {
            if (this.successor != null) {
                this.successor.handleRequest(request);
            }
        }
    }
}

再定义一个Handler类：

public abstract class Handler {
    protected String name;

    protected Handler successor;

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

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

    public abstract void handleRequest(Client request);
}

最后看看主函数：

public class Main {
    public static void main(String args[]) {
        Handler groupLeader, manager, hr;

        groupLeader = new GroupLeader("王明");
        manager = new Manager("赵强");
        hr = new HRDepartment("李波");

        groupLeader.setSuccessor(manager); // 排传递顺序
        manager.setSuccessor(hr);

        Client lr1 = new Client("张三", 1);
        groupLeader.handleRequest(lr1);

        Client lr2 = new Client("李四", 2);
        groupLeader.handleRequest(lr2);

        Client lr3 = new Client("王五", 5);
        groupLeader.handleRequest(lr3);

        Client lr4 = new Client("赵六", 10);
        groupLeader.handleRequest(lr4);
    }
}

使用职责链模式，请假5天需要向老王请假，只需在排传递顺序的地方添加新后继就可以。
职责链的UML模型图如下：

职责链UML

职责链模式说明

避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

1. 客户端发送一个请求，有多个对象都有机会来处理这个请求，但客户端不知道究竟谁来处理。
2. 客户端只知道他提交请求的第一个对象，从第一个对象开始处理，整个职责链中的对象要么处理请求，要么转发给下一个接受者。
3. 在标准的职责链模式中，只要有对象处理了请求，这个请求就到此为止，不再被传递和处理了。
4. 在职责链模式中，请求不一定会被处理，因为可能没有合适的处理者。请求在职责链中从头到尾，每个处理对象都判断不属于自己处理，最后请求就没有对象来处理。

在实际开发中，经常会遇到把职责链稍稍变形的用法。一个请求在职责链中传递，每个对象处理完后不是停止，而是继续向下传递请求，当请求通过所有对象处理后，功能也就处理完成了，这样的职责链称为功能链。

将上面的那个场景转换一下：

某公司请假制度为：
1. 先经过小组长批准
2. 再经过项目经理批准
3. 最后人事部门批准
4. 成功请假

这种情况我们将只需将“领导”的handleRequest方法修改下即可，还以GroupLeader 类举例：

public class GroupLeader extends Handler {
    public GroupLeader(String name) {
        super(name);
    }

    public void handleRequest(Client request) {
        if (request.getTeam() == 1 || request.getTeam() == 2) {
            System.out.println("组长" + name + "允许第" + request.getTeam() + "组员工"
                    + request.getLeaveName() + "的请假");

            if (this.successor != null) {
                this.successor.handleRequest(request);
            }
        } else {
            System.out.println("组长" + name + "认为第" + request.getTeam() + "组员工"
                    + request.getLeaveName() + "项目进展慢，不允许请假");
        }
    }
}

具体参阅代码 -- AskForLevel2。
职责链模式优缺点
--

1. 请求者和接收者松耦合
   在职责链模式中，请求者并不知道接收者是谁，也不知道具体如何处理，请求者只是负责向职责链发送请求就可以了。而每个职责对象也不用管请求者或者是其他的职责对象，只负责处理自己的部分，其他的就交给其他的职责对象去处理。也就是说，请求者和接受者是完全解耦的。

2. 动态组合职责
   职责链模式会把功能处理分散到单独的职责对象中，然后再使用的时候，可以动态组合职责形成职责链，从而可以灵活地给对象分配职责，也可以灵活地实现和改变对象的职责。

3. 产生很多细粒度对象
   职责链模式会把功能处理分散到单独的职责对象中，也就是每个职责对象只处理一个方面的功能，要把整个业务处理完，需要很多职责对象的组合，这样会产生大量的细粒度职责对象。

4. 不一定能被处理
   职责链模式的每个职责对象只负责自己处理的那一部分，因此可能会出现某个请求把整个链传递完了都没有职责对象处理它。这就需要使用职责链模式的时候，需要提供默认的处理，并且注意构造的链的有效性。