1. 首页
  2. 设计模式

「补课」进行时:设计模式(9)——在请假中使用的责任链模式

「补课」进行时:设计模式(9)——在请假中使用的责任链模式

1. 前文汇总

「补课」进行时:设计模式系列

2. 请假

作为一位新时代的社畜,我们每天起得比鸡早,睡得比狗晚,还时不时的要受到上司的 PUA ,每天都生活在水深火热之中。

生活中总会有各种意外,比如生病了,需要去医院看病,那我们需要请假去医院,一般在公司中,请假的时长和审批领导息息相关,如果这个规则是这样的:

  • 请假 3 天内小组长可以审批
  • 请假 5 天内需要大组长神品
  • 请假 20 天内需要部门经理审批

如果按照顺序思维来写程序的话,那么我们需要做大量的 if…else 的判断,并且所有的类都要耦合在一起,这时,我们可以使用责任链模式,上面的审批流成如下:

「补课」进行时:设计模式(9)——在请假中使用的责任链模式

我们可以先定义一个员工类:

public interface IPerson {
    // 获取当前请假天数
    int getDays();
    // 获取审批结果
    String getResult();
}

public class Person implements IPerson {

    private int days;
    private String message;

    public Person(int days) {
        this.days = days;
        this.message = "领导,我想请 " + days + " 天假!!!";
    }

    @Override
    public int getDays() {
        return this.days;
    }

    @Override
    public String getResult() {
        return this.message;
    }
}

创建一个抽象 Handler 类:

public abstract class Handler {

    public final static int MIN = 3;
    public final static int MIDDLE = 5;
    public final static int MAX = 20;

    // 当前能处理的级别
    private int days;
    // 责任传递,定义下一个责任人
    private Handler nextHandler;
    // 所有的类都需要定义自己的能处理的请假天数
    public Handler(int days) {
        this.days = days;
    }

    public final void handleMessage(IPerson person) {
        if (this.days > person.getDays()) {
            this.response(person);
        } else {
            if (this.nextHandler != null) {
                this.nextHandler.handleMessage(person);
            } else {
                System.out.println("员工想要请假 " + this.days + " 天,超过可以审批的最大权限,那就不批了");
            }
        }
    }

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    protected abstract void response(IPerson person);
}

这个类中最核心的部分是定义了 nextHandler 下一个责任人,如果当前的员工请假的请求不属于自己的审批范畴,则会将这个请求转发至下一个审批人。

接下来是三位具体的审批人:

public class Leader1 extends Handler {
    // 小组长
    public Leader1() {
        super(Handler.MIN);
    }

    @Override
    protected void response(IPerson person) {
        System.out.println("-----------向小组长请示------------");
        System.out.println(person.getResult());
        System.out.println("-----------请示通过---------------");
    }
}

public class Leader2 extends Handler {
    // 大组长
    public Leader2() {
        super(Handler.MIDDLE);
    }

    @Override
    protected void response(IPerson person) {
        System.out.println("-----------向大组长请示------------");
        System.out.println(person.getResult());
        System.out.println("-----------请示通过---------------");
    }
}

public class Leader3 extends Handler {
    // 部门经理
    public Leader3() {
        super(Handler.MAX);
    }

    @Override
    protected void response(IPerson person) {
        System.out.println("-----------向部门经理请示--------------");
        System.out.println(person.getResult());
        System.out.println("-----------请示通过---------------");
    }
}

然后我们来写一个测试类:

public class Test {
    public static void main(String[] args) {

        Random random = new Random();

        ArrayList<IPerson> personList = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            personList.add(new Person(random.nextInt(30)));
        }

        Handler leader1 = new Leader1();
        Handler leader2 = new Leader2();
        Handler leader3 = new Leader3();

        leader1.setNextHandler(leader2);
        leader2.setNextHandler(leader3);

        for (IPerson person: personList) {
            leader1.handleMessage(person);
        }
    }
}

执行结果如下:

-----------向部门经理请示--------------
领导,我想请 17 天假!!!
-----------请示通过---------------
员工想要请假 20 天,超过可以审批的最大权限,那就不批了
-----------向小组长请示------------
领导,我想请 0 天假!!!
-----------请示通过---------------
-----------向部门经理请示--------------
领导,我想请 11 天假!!!
-----------请示通过---------------
-----------向大组长请示------------
领导,我想请 4 天假!!!
-----------请示通过---------------

3. 责任链模式

责任链模式定义如下:

Avoid coupling the sender of a request to its receiver by giving more thanone object a chance to handle the request.Chain the receiving objects andpass the request along the chain until an object handles it.(使多个对象都有机会处理请求,从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它为止。)

责任链模式的重点是在 「链」 上,由一条链去处理相似的请求在链中决定谁来处理这个请求,并返回相应的结果,这个链类似于一个单向链表的数据结构,从开始一直向后迭代,知道找不到下一个为止,它的通用类图如下:

「补课」进行时:设计模式(9)——在请假中使用的责任链模式

通用代码如下:

3.1 抽象 Handler

public abstract class Handler {
    private Handler nextHandler;

    // 每个处理者都必须对请求作出处理
    public final Response handleMessage(Request request) {
        Response response = null;
        // 判断当前处理级别
        if (this.getHandlerLevel().equals(request.getLevel())) {
            response = this.echo(request);
        } else {
            // 判断是否有下一个处理者
            if (this.nextHandler != null) {
                response = this.nextHandler.handleMessage(request);
            } else {
                // 没有匹配的业务处理者,逻辑根据具体场景实现
            }
        }
        return response;
    }
    // 设置下一个处理者
    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    protected abstract Level getHandlerLevel();

    protected abstract Response echo(Request request);
}

抽象的处理者实现三个职责:

  • 定义一个请求的处理方法 handleMessage ,唯一对外开放的方法。
  • 定义一个链的编排方法 setNext ,设置下一个处理者。
  • 定义了具体的请求者必须实现的两个方法:定义自己能够处理的级别 getHandlerLevel 和具体的处理任务 echo 。

3.2 具体处理者

public class ConcreteHandler1 extends Handler {
    @Override
    protected Level getHandlerLevel() {
        // 设置自己的处理级别
        return null;
    }

    @Override
    protected Response echo(Request request) {
        // 设置处理的业务功能
        return null;
    }
}

public class ConcreteHandler2 extends Handler {
    @Override
    protected Level getHandlerLevel() {
        return null;
    }

    @Override
    protected Response echo(Request request) {
        return null;
    }
}

public class ConcreteHandler3 extends Handler {
    @Override
    protected Level getHandlerLevel() {
        return null;
    }

    @Override
    protected Response echo(Request request) {
        return null;
    }
}

定义三个具体的处理者,以便组成一个链。

3.3 其余相关代码

public class Level {
}

public class Request {
    public Level getLevel() {
        return null;
    }
}

public class Response {
}

3.4 测试类

最后是一个测试类:

public class Test {
    public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();

        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);

        Response response = handler1.handleMessage(new Request());
    }
}

在实际的使用过程中,最后都会有一个封装类对责任链模式进行封装,用来取代我们现在的这个测试类,直接返回链中的第一个处理者,具体链的设置不需要高层次模块关系,这样,更简化了高层次模块的调用,减少模块间的耦合,提高系统的灵活性。

4. 优点

任链模式非常显著的优点是将请求和处理分开。请求者可以不用知道是谁处理的,处理者可以不用知道请求的全貌(例如在 J2EE 项目开发中,可以剥离出无状态 Bean 由责任链处理),两者解耦,提高系统的灵活性。

5. 缺点

责任链有两个非常显著的缺点:

  • 性能问题,每个请求都是从链头遍历到链尾,特别是在链比较长的时候,性能是一个非常大的问题。
  • 调试不很方便,特别是链条比较长,环节比较多的时候,由于采用了类似递归的方式,调试的时候逻辑可能比较复杂。
转载声明:本博客由极客挖掘机创作,采用 CC BY 3.0 CN 许可协议。可自由转载、引用,但需署名作者且注明文章出处。如转载至微信公众号,请在文末添加作者公众号二维码。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

QR code