现实中,我们会遇到很多需要有流程的事,比如请假审批,请假一天找组长,请假两天找经理,请假三天找老板,如果我们把业务耦合起来,我们会写很多分支语句,这样看起来代码就很冗长,如果使用了责任链模式,那就避免了写很多的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.对系统进行扩展。