Java之责任链模式

一.前言

在公司一般的请假流程中,1天或者以下由组长批准,1-3天的由组长,经理审批,如果是3-7天的由组长,经理,部门领导审批，如果大于7天的则有上级批准。这种模式在设计模式里面的责任链模式可以得到很好的运用，下面用这个该模式实现体会一下责任链模式的好处。

二.定义

定义：将能够处理同一类请求的对象连成一条链，所提交的请求沿着链传递，链上的对象逐个判断是否有能力处理该请求，如果能处理则处理，如果不能则传递给链上的下一个对象。
思想：多个角色配合处理一个事件，每个角色都只负责自己的职责，链表示处理的事件是要有序的，什么阶段该做什么，由什么人做。
责任链模式在框架源码中运用非常广泛，比如Servlet的Filter、Dubbo的Filter、Mybatis的Plugin。

三.实例

1.这里采用了建造者模式构造请求Request对象，包含请假人名字,请假理由,请假天数,以及组长,经理,部门领导审批留言,代码如下：

public class Request {
    public String name;
    public String reason;
    public int day;
    public String groupleadMsg;//组长Msg
    public String managerMsg;//经理Msg
    public String leadMsg;//领导Msg
    public Request(Builder builder) {
        super();
        this.name = builder.name;
        this.reason = builder.reason;
        this.day = builder.day;
        this.groupleadMsg = builder.groupleadMsg;
        this.managerMsg = builder.managerMsg;
        this.leadMsg = builder.leadMsg;
    }

    public static class Builder {
        public String name;
        public String reason;
        public int day;
        public String groupleadMsg;
        public String managerMsg;
        public String leadMsg;
        public Builder setName(String name) {
            this.name = name;
            return this;
        }
        public Builder setReason(String reason) {
            this.reason = reason;
            return this;
        }
        public Builder setday(int day) {
            this.day = day;
            return this;
        }
        public Builder setgroupleadMsg(String groupleadMsg) {
            this.groupleadMsg = groupleadMsg;
            return this;
        }
        public Builder setmanagerMsg(String managerMsg) {
            this.managerMsg = managerMsg;
            return this;
        }
        public Builder setleadMsg(String leadMsg) {
            this.leadMsg = leadMsg;
            return this;
        }

        public Builder newRequest(Request request) {
            this.name = request.name;
            this.day = request.day;
            this.reason = request.reason;
            if (request.groupleadMsg != null && !request.groupleadMsg.equals("")) {
                this.groupleadMsg = request.groupleadMsg;
            }
            if (request.managerMsg != null && !request.managerMsg.equals("")) {
                this.managerMsg = request.managerMsg;
            }
            if (request.leadMsg != null && !request.leadMsg.equals("")) {
                this.leadMsg = request.leadMsg;
            }

            return this;
        }
        public Request build() {
            return new Request(this);
        }
    }

    @Override
    public String toString() {
        String msg="";
        String str="姓名:"+name+"\n"+"请假原因:"+reason+"\n"+"请假天数:"+day+"\n";
        msg=msg+str;
        if(groupleadMsg!=null){
            groupleadMsg="组长留言:"+groupleadMsg;
            msg=msg+groupleadMsg+"\n";
        }
        if(managerMsg!=null){
            managerMsg="经理留言:"+managerMsg;
            msg=msg+managerMsg+"\n";
        }
        if(leadMsg!=null){
            leadMsg="部门领导留言:"+leadMsg;
            msg=msg+leadMsg+"\n";
        }
        return msg;
    }
}

2.创建处理请假的结果类Result,用来返回请假处理的结果信息,代码如下:

public class Result {
    public boolean isAgree;
    public String reason;
    public Result() { }
    public Result(boolean isAgree, String reason) {
        this.isAgree = isAgree;
        this.reason = reason;
    }
    public boolean isAgree() {
        return isAgree;
    }
    public void setAgree(boolean agree) {
        isAgree = agree;
    }
    public String getReason() {
        return reason;
    }
    public void setReason(String reason) {
        this.reason = reason;
    }

    @Override
    public String toString() {
        String resutl="";
        if(isAgree){
            resutl="同意";
        }else {
            resutl="拒绝";
        }
        String msg=resutl+",理由:"+reason;
        return msg;
    }
}

3.创建一个LeaveHandler用来处理我请假流程,里面包括抽象方法-处理请假disposeLeave和处理请假的下级领导,如果当前领导没有权限处理,则分发到下一级领导去处理,代码如下:

public abstract  class LeaveHandle {

    protected LeaveHandle nextLeader;//下级领导
    public void setNextLeader(LeaveHandle handle){
        this.nextLeader=handle;
    }
    abstract Result disposeLeave(Request request);//处理请假
}

4.组长只能够处理一天的假期；如果超过了我们就要向他的上级传递请求,代码如下:

public class GroupLeader extends LeaveHandle {
    @Override
    Result disposeLeave(Request request) {
        if(request.day<=1){
            return new Result(true, "组长：去吧");//这边处理请假,返回处理后的结果
        }else {
            Request newRequest = new Request.Builder().newRequest(request).setgroupleadMsg(request.name + "平时表现不错哦,哈哈").build();
            System.out.println("重新封装的请求者的信息:"+newRequest.toString());
            return nextLeader.disposeLeave(newRequest);
        }
    }
}

5.部门经理只能够处理3天的假期；如果超过了我们就要向他的上级传递请求,代码如下:

public class Manager extends LeaveHandle{
    @Override
    Result disposeLeave(Request request) {
        if(request.day<=3){
            return new Result(true, "部门经理：去吧");
        }else {
            Request newRequest = new Request.Builder().newRequest(request).setmanagerMsg(request.name + "平时表现不错哦,哈哈哈").build();
            System.out.println("重新封装的请求者的信息:"+newRequest.toString());
            return nextLeader.disposeLeave(newRequest);
        }
    }
}

6.部门领导只能够处理7天的假期；如果超过了我们就要向他的上级传递请求,代码如下:

public class DepLeader extends LeaveHandle{
    @Override
    Result disposeLeave(Request request) {
        if(request.day<=7){
            return new Result(true, "部门领导：去吧");
        }else {
            Request newRequest = new Request.Builder().newRequest(request).setleadMsg(request.name + "平时表现不错哦,哈哈哈哈").build();
            System.out.println("重新封装的请求者的信息:"+newRequest.toString());
            return nextLeader.disposeLeave(newRequest);
        }
    }
}

7.领导处理超过7天的请假,代码如下:

public class Leader extends LeaveHandle {
    @Override
    Result disposeLeave(Request request) {
        return new Result(false, "领导：想造反?");
    }
}

8.创建简单工厂方法,创建组长,部门经理,部门领导,领导实例,以及他们的上级,同时返回当前处理请假的职位,如下处理当前为组长,代码如下:

public class LeaveHandlerFactory {
    public static LeaveHandle createHandler(){
        LeaveHandle groupLeader=new GroupLeader();
        LeaveHandle manager=new Manager();
        DepLeader depLeader = new DepLeader();
        LeaveHandle leader=new Leader();
        groupLeader.setNextLeader(manager);
        manager.setNextLeader(depLeader);
        depLeader.setNextLeader(leader);
        return groupLeader;//返回当前请假处理人
    }
}

9.测试类

    public static void main(String[] args) {
        Request request = new Request.Builder().setName("张三").setday(1).setReason("事假").build();
        LeaveHandle leaveHandle = LeaveHandlerFactory.createHandler();
        Result result = leaveHandle.disposeLeave(request);
        System.out.println("审批结果：" + result.toString());
    }

10.测试结果

(1)如果是请假1天,则结果为

审批结果：同意,理由:组长：去吧

(2)如果是请假3天,则结果为:

重新封装的请求者的信息:姓名:张三
请假原因:事假
请假天数:3
组长留言:张三平时表现不错哦,哈哈

审批结果：同意,理由:部门经理：去吧

(3)如果是请假7天,则结果为:

重新封装的请求者的信息:姓名:张三
请假原因:事假
请假天数:7
组长留言:张三平时表现不错哦,哈哈

重新封装的请求者的信息:姓名:张三
请假原因:事假
请假天数:7
组长留言:组长留言:张三平时表现不错哦,哈哈
经理留言:张三平时表现不错哦,哈哈哈

审批结果：同意,理由:部门领导：去吧

(3)如果是请假大于7天,则结果为:

重新封装的请求者的信息:姓名:张三
请假原因:事假
请假天数:11
组长留言:张三平时表现不错哦,哈哈

重新封装的请求者的信息:姓名:张三
请假原因:事假
请假天数:11
组长留言:组长留言:张三平时表现不错哦,哈哈
经理留言:张三平时表现不错哦,哈哈哈

重新封装的请求者的信息:姓名:张三
请假原因:事假
请假天数:11
组长留言:组长留言:组长留言:张三平时表现不错哦,哈哈
经理留言:经理留言:张三平时表现不错哦,哈哈哈
部门领导留言:张三平时表现不错哦,哈哈哈哈

审批结果：拒绝,理由:领导：想造反?

ok,这几个用例符合我们的预期

四.总结

实现了解耦，符合开闭原则，在这里面调用者不需要知道具体的传递过程，他只需要知道最终的结果被处理了。而且这个链表的结构可以被灵活的更改重组。但是它的缺点也是很明显的，在性能上，一个是调用时间，如果链表在最开始被处理了还好，万一链表跑到了最后一个才被处理，那么他的调用时间肯定会比不适用责任链模式的效率要低一些；第二是内存的问题，我们会构造出很多的链表节点对象，但是有些对象在我们的应用场景中是不会用到的，这样就大大的消耗了我们的内存；所以不能为了模式而模式，如果有更好的模式可以代替，可以考虑其他模式。