职责链初步理解及应用小demo

什么是职责链

先看个需要用到职责的场景：

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

那么用职责链模式来实现场景功能:

先定义一个Handler类(将来每个角色的父类):

注意:这里的成员变量的权限修饰要控制protected,否则子类没办法继承的到,特别是针对Handler successor; 就是让这个以后有种"套娃"调用的感觉来实现呢! 看下去你会懂得5分钟就ok  ..5分钟你学不来吃亏5分钟你看不了上当!

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);

}

再创建Client基类:

public class Client {

    private String leaveName;
    private int leaveDays;

    public Client(String leaveName, int leaveDays) {
        this.leaveName = leaveName;
        this.leaveDays = leaveDays;
    }
  //getter 和 setter 省略要不看着眼花
}

再创建对应的角色类,并继承Handler及实现对象的抽象方法:

1.组长:

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);
            }else{//我干不了....但是后面没人了
                System.out.println("组长:" + name + "认为员工  "
                        + request.getLeaveName() + "  项目进展慢，不允许请假");
            }
        }
    }

2.经理:

public class Manager extends Handler {

    public Manager(String name) {
        super(name);
    }

    public void handleRequest(Client request) {
        if (request.getLeaveDays() <= 3) {
            System.out.println("经理:" + name + "  审批员工  " + request.getLeaveName()
                    + "  的请假条，请假天数为 " + request.getLeaveDays() + " 天。");
        } else {
            if (this.successor != null) {//我干不了,下一个人!走你!
                this.successor.handleRequest(request);
            }else{//我干不了....但是后面没人了
                System.out.println("经理:" + name + "认为员工  "
                        + request.getLeaveName() + "  项目进展慢，不允许请假");
            }
        }
    }

}

3.人事部门

public class HRDepartment extends Handler {

    public HRDepartment(String name) {
        super(name);
    }

    public void handleRequest(Client request) {
        if (request.getLeaveDays() <= 7) {
            System.out.println("HR:" + name + "  审批员工  " + request.getLeaveName()
                    + "  的请假条，请假天数为 " + request.getLeaveDays() + " 天。");
        } else {
            if (this.successor != null) {//我干不了,下一个人!走你!
                this.successor.handleRequest(request);
            }else{//我干不了....但是后面没人了
                System.out.println("HR:" + name + "认为员工  "
                        + request.getLeaveName() + "  项目进展慢，不允许请假");
            }
        }
    }
    
}

最后看看主函数：

public static void main(String args[])  {

        Handler groupLeader,hr,manager;

        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);


    }

结果:

    //组长:王明  审批员工  张三  的请假条，请假天数为 1 天。
    //经理:赵强  审批员工  李四  的请假条，请假天数为 2 天。
    //HR:李波  审批员工  王五  的请假条，请假天数为 5 天。
    //HR:李波认为员工  赵六  项目进展慢，不允许请假

慢慢品味你就会发现简单的技术大大的思维了;

如果你还没看见职责链的特点,那么我们试着注释点东西;

请忽略这个原谅绿的颜sai- -!

这两行注释掉会怎么样呢?

结果:

//组长:王明  审批员工  张三  的请假条，请假天数为 1 天。
//经理:赵强  审批员工  李四  的请假条，请假天数为 2 天。
//经理:赵强认为员工  王五  项目进展慢，不允许请假
//经理:赵强认为员工  赵六  项目进展慢，不允许请假

我们会发现职责链的尾巴变成了经理那么对应的天数上线变成了5天,从而职责链的运行起来也很是有的 (这也体现了职责链的耦合性很好,随时随节点添加修改,这只是简单的 out.print打印  如果是复杂的逻辑体现的就更大了)

咳咳!重点重点!

小山已经用白话点破了职责链,那么系统化的特点还是要指出的.

一.说明:

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

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

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

二.缺点:

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

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

3.产生很多细粒度对象
职责链模式会把功能处理分散到单独的职责对象中，也就是每个职责对象只处理一个方面的功能，要把整个业务处理完，需要很多职责对象的组合，这样会产生大量的细粒度职责对象。组长处理不掉的会传递给下层责任链经理那(如果有下层),那么本身组长的责任层已经创建,只是对应的判断没有进去,那么对于组长本身只是起到了传递信息的作用,但职责链模式却创建并占用了内存,可以变相的看成"无效"占用。

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

临时叫去评审先写到这