Java责任链模式

现实中，我们会遇到很多需要有流程的事，比如请假审批，请假一天找组长，请假两天找经理，请假三天找老板，如果我们把业务耦合起来，我们会写很多分支语句，这样看起来代码就很冗长，如果使用了责任链模式，那就避免了写很多的if else，审批流程也会解耦。

接下来我们就以请假来作为示例，实现责任链模式：

首先我们要限定职位和等级：

public enum Position {

    Staff(0,"员工"),
    TEAM_LEADER(1,"组长"),
    GENERAL_MANAGER(2,"总经理"),
    BOSS(3,"老板");

    private Integer positionLevel;// 职级

    private String positionName; // 职位名称

    Position(Integer positionLevel,String positionName){
        this.positionLevel = positionLevel;
        this.positionName = positionName;
    }

    public Integer getPositionLevel() {
        return positionLevel;
    }

    public void setPositionLevel(Integer positionLevel) {
        this.positionLevel = positionLevel;
    }

    public String getPositionName() {
        return positionName;
    }

    public void setPositionName(String positionName) {
        this.positionName = positionName;
    }
}

然后是一个抽象处理请假的角色：

public abstract class AbstractProcessor {

    private AbstractProcessor superior;

    private Position position;

    /**
     * 创建 具体处理角色的时候要指定上级和职位
     * @param superior 上级 可以为空
     * @param position 职位
     */
    AbstractProcessor(AbstractProcessor superior,Position position){
         this.superior = superior;
         this.position = position;
    }

    public Position getPosition() {
        return position;
    }

    public AbstractProcessor getSuperior() {
        return superior;
    }

    /**
     * 处理请假抽象方法
     * @param leaveDays 请假天数
     */
    public abstract void leaveHandle(int leaveDays);

    /**
     * 传递给下一级
     * @param leaveDays 请假天数
     */
    public void transferToSuperior(int leaveDays){
        if (superior != null){
            superior.leaveHandle(leaveDays);
        } else {
            System.out.println("我" + position.getPositionName() + "已经没有上级了，不能审批了");
        }
    }
}

接下来是四个不同职位等级的具体实现类：

/**
 * 老板BOSS
 */
public class Boss extends AbstractProcessor {

    Boss(AbstractProcessor superior, Position position) {
        super(superior, position);
    }

    @Override
    public void leaveHandle(int leaveDays) {
        if (leaveDays > 2){
            System.out.println("我 " + this.getPosition().getPositionName() +" 有权审批， 允许请假");
        } else {
            System.out.println("我 " + this.getPosition().getPositionName() +" 没有权限审批，已经递交给上一级 " + this.getSuperior().getPosition().getPositionName());
            this.transferToSuperior(leaveDays);
        }
    }
}

/**
 * 总经理
 */
public class GeneralManager extends AbstractProcessor {


    GeneralManager(AbstractProcessor superior, Position position) {
        super(superior, position);
    }

    @Override
    public void leaveHandle(int leaveDays) {
        if (leaveDays > 1 && leaveDays <= 2){
            System.out.println("我 " + this.getPosition().getPositionName() +" 有权审批， 允许请假");
        }else {
            System.out.println("我 " + this.getPosition().getPositionName() +" 没有权限审批，已经递交给上一级 " + this.getSuperior().getPosition().getPositionName());
            this.transferToSuperior(leaveDays);
        }
    }
}

/**
 * 组长
 */
public class TeamLeader extends AbstractProcessor {


    TeamLeader(AbstractProcessor superior, Position position) {
        super(superior, position);
    }

    @Override
    public void leaveHandle(int leaveDays) {
        if (leaveDays <= 1 && leaveDays > 0){
            System.out.println("我 " + this.getPosition().getPositionName() +" 有权审批， 允许请假");
        } else {
            System.out.println("我 " + this.getPosition().getPositionName() +" 没有权限审批，已经递交给上一级 " + this.getSuperior().getPosition().getPositionName());
            this.transferToSuperior(leaveDays);
        }
    }
}

/**
 * 底层员工
 */
public class Staff extends AbstractProcessor {

    Staff(AbstractProcessor superior, Position position) {
        super(superior, position);
    }

    @Override
    public void leaveHandle(int leaveDays) {
        System.out.println("我 " + this.getPosition().getPositionName() +" 不能擅自缺席，请假申请已经递交给上一级 " + this.getSuperior().getPosition().getPositionName());
        this.transferToSuperior(leaveDays);
    }
}

接下来就是测试代码了

public class ChainOfResponsibilityTest {


    public static void main(String[] args) {
        //创建boss
        AbstractProcessor boss = new Boss(null,Position.BOSS);
        //创建GeneralManager 总经理
        AbstractProcessor generalManager = new GeneralManager(boss,Position.GENERAL_MANAGER);
        //创建TeamLeader 组长
        AbstractProcessor teamLeader = new TeamLeader(generalManager,Position.TEAM_LEADER);
        // 创建Staff 员工
        AbstractProcessor staff = new Staff(teamLeader,Position.Staff);

        staff.leaveHandle(3);
    }
}

测试结果：

我 员工 不能擅自缺席，请假申请已经递交给上一级 组长
我 组长 没有权限审批，已经递交给上一级 总经理
我 总经理 没有权限审批，已经递交给上一级 老板
我 老板 有权审批， 允许请假

以上就是责任链以请假示例的实现

代码中每一个实现类方法中只有对天数判断的if else，代码看起来很简洁

实际上责任链的优点就是这样，解耦。

下面说一说责任链具体有哪些优点：

责任链模式中的优点
1. 责任链模式将请求和处理分开，请求者不知道是谁处理，处理者可以不用知道请求者全貌。
2. 提高系统的灵活性
责任链模式中的缺点
1.降低程序的性能。每个请求都是从链头遍历到链尾，当遇到链比较长的时候，性能就会大幅下降。
2.不易于调试，由于该模式采用了类似递归的方式，调试的时候逻辑比较复杂。

该模式的适用场景：

1.一个请求需要一系列的处理工作。
2.业务流的处理，例如文件审批。
3.对系统进行扩展。