设计模式之责任链模式

---

请假审批需求

请假业务：员工1天内的请假直接主管可以直接审批；3天内的请假需要部门经理的审批；30天内的请假需要总经理的审批；大于30天，正常不会批准。

先思考一下，如果是你会如何设计这个业务？

---

违背设计模式的设计

用if…else实现的伪代码如下：

 public  String approve (int day){
 	if(day==1){
 		return "直接主管:已经处理;流程结束。";
 	} else if (1<day<=3){
 		return "部门经理:已经处理;流程结束。";
 	} else if(3<day<=30){
 		return "总经理:已经处理;流程结束。";
 	}else{
 		return "拒绝审批;流程结束。";
 	}
 }

备注：模拟的是一个简单流程，正常业务流比这个复杂得多。

责任链模式

1.定义

为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

2.模式的结构

1. 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
2. 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
3. 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

结构相对比较简单。

3.模式的结构图

责任链模式

1.请假对象

/**
 *
 * 现实中，请假的OA申请，请假天数如果是半天到1天，可能直接主管批准即可；
 * 如果是1到3天的假期，需要部门经理批准；
 * 如果是3天到30天，则需要总经理审批；
 * 大于30天，正常不会批准。
 * @author winter
 */
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class LeaveRequest {
    /**
     * 天数
     *
     * */
    private int leaveDays;

    /**
     * 姓名
     * */
    private String name;
}

2.抽象处理者

/**
 *
 * 请假责任链抽象处理类
 * @author winter
 */
public class AbstractLeaveHandler {
    /**直接主管审批处理的请假天数*/
    protected int MIN = 1;
    /**部门经理处理的请假天数*/
    protected int MIDDLE = 3;
    /**总经理处理的请假天数*/
    protected int MAX = 30;

    /**领导名称*/
    protected String handlerName;

    /**下一个处理节点（即更高级别的领导）*/
    protected AbstractLeaveHandler nextHandler;

    /**
     * 设置下一个处理节点
     * @param handler
     */
    protected void setNextHandler(AbstractLeaveHandler handler){
        this.nextHandler = handler;
    }

    /**
     * 处理请假的请求，具体业务由子类实现
     * @param request
     */
    protected void handlerRequest(LeaveRequest request){

    }
}

主要定义了请求接口、下一个处理节点。

3.具体处理者

/**
 * 直接主管处理类
 * @author winter
 */
public class DirectLeaderLeaveHandler extends AbstractLeaveHandler {

    public DirectLeaderLeaveHandler(String name) {
        this.handlerName = name;
    }

    @Override
    protected void handlerRequest(LeaveRequest request) {
        //自己的权限内 直接主管可以直接审批 流程结束
        if(request.getLeaveDays() <= this.MIN){
            System.out.println("直接主管:" + handlerName + ",已经处理;流程结束。");
            return;
        }

        //超过自己权限的审批 判断是否还存在下一个处理人，如果存在则给下一个处理人处理
        if(null != this.nextHandler){
            this.nextHandler.handlerRequest(request);
        }else{
            System.out.println("审批拒绝！");
        }
    }
}

/**
 * 部门经理处理类
 * @author winter
 */
public class DeptManagerLeaveHandler extends AbstractLeaveHandler {

    public DeptManagerLeaveHandler(String name) {
        this.handlerName = name;
    }

    @Override
    protected void handlerRequest(LeaveRequest request) {
        //自己的权限内 可以直接审批 流程结束
        if(request.getLeaveDays() >this.MIN && request.getLeaveDays() <= this.MIDDLE){
            System.out.println("部门经理:" + handlerName + ",已经处理;流程结束。");
            return;
        }

        //超过自己权限的审批 判断是否还存在下一个处理人，如果存在则给下一个处理人处理
        if(null != this.nextHandler){
            this.nextHandler.handlerRequest(request);
        }else{
            System.out.println("审批拒绝！");
        }
    }
}

/**
 * 总经理处理类
 * @author winter
 */
public class GManagerLeaveHandler extends AbstractLeaveHandler {

    public GManagerLeaveHandler(String name) {
        this.handlerName = name;
    }

    @Override
    protected void handlerRequest(LeaveRequest request) {
        //自己的权限内 直接主管可以直接审批 流程结束
        if(request.getLeaveDays() > this.MIDDLE && request.getLeaveDays() <= this.MAX){
            System.out.println("总经理:" + handlerName + ",已经处理;流程结束。");
            return;
        }

        //超过自己权限的审批 判断是否还存在下一个处理人，如果存在则给下一个处理人处理
        if(null != this.nextHandler){
            this.nextHandler.handlerRequest(request);
        }else{
            System.out.println("审批拒绝！");
        }
    }
}

4.客户类角色

/**
 * 测试执行
 * @author winter
 */
public class Client {
    public static void main(String[] args) {
        LeaveRequest request = LeaveRequest.builder().leaveDays(1).name("小明").build();

        //处理人
        AbstractLeaveHandler directLeaderLeaveHandler = new DirectLeaderLeaveHandler("张组长");
        DeptManagerLeaveHandler deptManagerLeaveHandler = new DeptManagerLeaveHandler("李经理");
        GManagerLeaveHandler gManagerLeaveHandler = new GManagerLeaveHandler("王总");
        //处理人顺序
        directLeaderLeaveHandler.setNextHandler(deptManagerLeaveHandler);
        deptManagerLeaveHandler.setNextHandler(gManagerLeaveHandler);

        directLeaderLeaveHandler.handlerRequest(request);

    }
}

测试结果：直接主管:张组长,已经处理;流程结束。

/**
 * 测试执行
 * @author winter
 */
public class Client {
    public static void main(String[] args) {
        LeaveRequest request = LeaveRequest.builder().leaveDays(3).name("小明").build();

        //处理人
        AbstractLeaveHandler directLeaderLeaveHandler = new DirectLeaderLeaveHandler("张组长");
        DeptManagerLeaveHandler deptManagerLeaveHandler = new DeptManagerLeaveHandler("李经理");
        GManagerLeaveHandler gManagerLeaveHandler = new GManagerLeaveHandler("王总");
        //处理人顺序
        directLeaderLeaveHandler.setNextHandler(deptManagerLeaveHandler);
        deptManagerLeaveHandler.setNextHandler(gManagerLeaveHandler);

        directLeaderLeaveHandler.handlerRequest(request);

    }
}

测试结果：部门经理:李经理,已经处理;流程结束。

总结

优点：

1. 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。
2. 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
3. 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。
4. 责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。
5. 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

缺点：

1. 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
2. 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
3. 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。

应用场景：OA系统 请假审批流程、风控系统 审批流程 等等。

作者之后的博客会尽量减少不必要篇幅，以免影响大家的阅读。