转自 https://www.jianshu.com/p/8def04b34b3c
首先,了解状态机是什么,我们为什么需要状态机!
举个最简单例子,请假,作为一个最底层程序员,每次请假都要领导层层审批,而假有分为很多种,事假,病假,婚假,年休假等等,当然选择请的假不同,审批标准也不同,不同的假单需要走的审批链也不一样,比如年休假,可能只需要领导审批扣掉年休假即可,请病假需要领导审批,领导审批之后,先休假,等休完假回来提交病假的材料,由hr审批之后才能完成整个请假过程。更有甚者,如果你要修一个一个月的长假,就不仅仅是需要直线领导hr审批,可能还需要公司ceo审批 ,审批通过后,才能通过。如下图:
当然,实际来讲,请假的种类和链路比这个要复杂的多,我们一般会怎么实现,是否要使用if else了,对应不同的假单,走不同的分支,代码写出来就成了一个非常复杂的,多级嵌套的代码了,后面如何维护代码,多了几种假的种类,是不是又要if else了。如下代码:
public void requestLeavePermit(String type){
if(type.equals("事假")){
//领导审批->hr审批->ceo审批->完成
}else if(type.equals("病假")){
//领导审批->休假->补充病例->hr审批->完成
}else if(type.equals("年休假")){
//领导审批->hr审批->通过
}else if(type.equals("产假")){
//领导审批->hr审批->通过
}else if(type.equals("调休假")){
//领导审批->ceo审批->通过
}
}
或者写成这个样子:
public void requestLeavePermit(String type,String userName){
switch (type){
case "事假":
//领导审批->hr审批->ceo审批->完成
break;
case "病假":
//领导审批->休假->补充病例->hr审批->完成
break;
case "年休假":
//领导审批->hr审批->通过
break;
case "产假":
//领导审批->hr审批->通过
break;
case "调休假":
//领导审批->ceo审批->通过
default:
break;
}
}
if,else嵌套太深,然后每个if,else又是自己的处理流程,这样代码结构会原来越复杂,当审批链发生变更,这个时候会发现代码耦合性太强,导致修改起来很麻烦。
如何解决这个问题,我们不难看到,所有的请假都经过了这样几个阶段,从请假开始,提交假单,然后领导审批,hr审批,ceo审批,只是不同的是,有些审批流程多了审核人或者是少了审核人,每种假单审核材料有所不同而已。
我们如何使用状态机来如何解决代码耦合性的问题,提高代码可扩展性可读性。
如果我们把领导审批,hr审批,ceo审批,分别看做一个动作,每个相应都有几个状态,审批通过,不通过,拒绝,重新审核,会怎么样?
首先,我们将请假的类型定义成一个枚举:
public enum LeavePermitEnum {
ANNUAL_LEAVE("annual_leave","年休假 "),
CASUAL_LEAVE("casual_leave","事假"),
MEDICAL_LEAVE("medical_leave","病假"),
MARRIAGE_LEAVE("marriage_leave","婚假"),;
private String type;
private String memo;
//此处忽略构造方法和set/get方法
}
领导审批,hr审批,ceo审批,都有一个审批意见(通过,拒绝,或者是重修修改假单补充材料等),在这里,相当于一个事件Event,于是,整个状态扭转也可以用一个枚举类来表示,审批意见由一个枚举类Event来表示。
public enum Event {
AGREE("agree","同意"),
DISSAGREE("disagree","不同意"),
MODIFY("modify","修改"),
;
private String type;
private String memo;
}
因此,一个假单的状态就有很多种,用一个枚举代表整个假单的状态:
public enum Status {
//提交假单
PERMIT_SUBMIT("permitSubmit","提交假单"),
//领导审批
LEADER_PERMITING("leaderPermiting","领导审批中"),
LEADER_PERMIT_AGREE("leaderAgree","领导同意"),
LEADER_PERMIT_DISAGREE("leaderDisAgree","领导不同意"),
LEADER_PERMIT_MODIFY("leaderModify","领导觉得需要补充材料重修修改"),
//hr审批
HR_PERMITING("hrPermiting","hr审批中"),
HR_PERMIT_AGREE("hrAgree","hr同意"),
HR_PERMIT_DISAGREE("hrDisAgree","hr不同意"),
HR_PERMIT_MODIFY("hrModify","hr觉得需要补充材料重修修改"),
//ceo审批
CEO_PERMITING("ceoPermiting","领导审批中"),
CEO_PERMIT_AGREE("ceoAgree","ceo同意"),
CEO_PERMIT_DISAGREE("ceoDisAgree","ceo不同意"),
CEO_PERMIT_MODIFY("ceoModify","ceo觉得需要补充材料重修修改"),
//最终请假状态
PERMIT_SUCCESS("permitSuccess","请假成功"),
PERMIT_FAIL("permitFail","请假失败")
;
private String status;
private String memo;
private Status(String status,String memo){
this.status=status;
this.memo=memo;
}
}
状态定义清楚之后,需要考虑两个问题
- 从当前状态需要能够跳转到下一个状态,比如提交假单之后,要能够从提交假单状态跳转到领导审批状态。
- 不同的审批意见要能够跳转不同的状态,比如领导审批状态跳转审批通过,或者拒绝该审批需要能够按照Event状态跳转不同的状态。
这块功能可以交给状态机StatusMachine去解决,由当前状态+事件驱动(也就是当前请假的状态和审批意见)获取下一个状态。
我们知道,请假的种类不同,所走的流程也不同,相应的处理也不同,每种假单都有自己的审批链,也对应每种假单有不同的状态机,不难设计StatusMachine为接口或抽象类。状态机只做一件事情,根据event(审批意见),跳转下一个状态机。
public interface StatusMachine {
/**
*@params status 当前状态
*@params event 审批意见
*@return 下一个状态
**/
public Status getNextStatus(Status status,Event event);
}
这里举两个例子,一个病假,一个年休假的实现:
年休假的审批流程:
- 提交假单 PERMIT_SUBMIT
- 领导审批 LEADER_PERMITING
- 等待领导审批
- 领导审批通过/不通过/拒绝
- 领导审批通过 LEADER_PERMIT_AGREE
- ceo审批 CEO_PERMITING
- 等待ceo审批意见
- ceo审批通过/不通过/拒绝
- ceo审批通过 CEO_PERMIT_AGREE
- 请假完成 PERMIT_SUCCESS
因此事假的状态机StatusMachine实现如下:
public class AnnualLeaveStatusMachine implements StatusMachine{
public Status getNextStatus(Status status,Event event){
switch (status){
case PERMIT_SUBMIT:
//提交假单状态无需审批跳转领导审批中状态
return Status.LEADER_PERMITING;
case LEADER_PERMITING:
//领导审批需要审批意见 审批意见不用返回不同的状态
return getLeaderPermitStatus(event);
case LEADER_PERMIT_AGREE:
//领导同意请假,则跳转ceo审批
return Status.CEO_PERMITING;
case LEADER_PERMIT_DISAGREE:
//领导不同意该假单,则请假失败
return Status.PERMIT_FAIL;
case LEADER_PERMIT_MODIFY:
return getLeaderPermitStatus(event);
case CEO_PERMITING:
//ceo审批需要审批意见
return getCEOPermitStatus(event);
case CEO_PERMIT_AGREE:
// ceo审批同意 跳转审批通过 请假完成
return Status.PERMIT_SUCCESS;
case CEO_PERMIT_DISAGREE:
//ceo不同意审批 则跳转审批失败
return Status.PERMIT_FAIL;
case CEO_PERMIT_MODIFY:
return getCEOPermitStatus(event);
default:
throw new RuntimeException("没有该流程");
}
}
private Status getLeaderPermitStatus(Event event){
switch (event){
case AGREE:
//领导审批通过 返回同意该假单
return Status.LEADER_PERMIT_AGREE;
case DISSAGREE:
//领导不同意 则返回领导拒绝改假单状态
return Status.LEADER_PERMIT_DISAGREE;
case MODIFY:
return Status.LEADER_PERMIT_MODIFY;
default:
throw new RuntimeException("不支持该Event审批意见");
}
}
private Status getCEOPermitStatus(Event event){
switch (event){
case AGREE:
//ceo审批通过 则返回ceo同意该假单
return Status.CEO_PERMIT_AGREE;
case DISSAGREE:
// ceo审批不通过 则返回ceo不同意该假单状态
return Status.CEO_PERMIT_DISAGREE;
case MODIFY:
return Status.CEO_PERMIT_MODIFY;
default:
throw new RuntimeException("不支持该Event审批意见");
}
}
}
病假的审批流程:
- 提交假单 PERMIT_SUBMIT
- 领导审批 LEADER_PERMITING
- 等待领导审批
- 领导审批通过/不通过/拒绝
- 领导审批通过 LEADER_PERMIT_AGREE
- HR审批 HR_PERMITING
- 等待HR审批意见
- HR审批通过/不通过/拒绝
- HR审批通过 CEO_PERMIT_AGREE
- 请假完成 PERMIT_SUCCESS
根据该流程不难设计出该状态机
public class MedicalLeaveStatusMachine implements StatusMachine{
public Status getNextStatus(Status status,Event event){
switch (status){
case PERMIT_SUBMIT:
//提交假单状态直接跳转领导审批中状态
return Status.LEADER_PERMITING;
case LEADER_PERMITING:
//领导审批中状态需要审批意见再获取下一个状态
return getLeaderPermitStatus(event);
case LEADER_PERMIT_AGREE:
//领导同意审批该假单 跳转hr审批中状态
return Status.HR_PERMITING;
case LEADER_PERMIT_DISAGREE:
//领导不同意则返回请假失败
return Status.PERMIT_FAIL;
case LEADER_PERMIT_MODIFY:
return getLeaderPermitStatus(event);
case HR_PERMITING:
//hr审批根据审批意见跳转下一个状态
return getHrPermitStatus(event);
case HR_PERMIT_AGREE:
//hr审批通过跳转审批完成状态
return Status.PERMIT_SUCCESS;
case HR_PERMIT_DISAGREE:
// hr审批不同意 返回请假失败
return Status.PERMIT_FAIL;
case HR_PERMIT_MODIFY:
return getHrPermitStatus(event);
default:
throw new RuntimeException("没有该流程");
}
}
private Status getLeaderPermitStatus(Event event){
switch (event){
case AGREE:
//领导同意该假单,则返回领导审批通过
return Status.LEADER_PERMIT_AGREE;
case DISSAGREE:
//领导不同意该假单 则返回领导审批不通过
return Status.LEADER_PERMIT_DISAGREE;
case MODIFY:
return Status.LEADER_PERMIT_MODIFY;
default:
throw new RuntimeException("不支持该Event审批意见");
}
}
private Status getHrPermitStatus(Event event){
switch (event){
case AGREE:
//hr审批同意该假单,则返回hr同意状态
return Status.HR_PERMIT_AGREE;
case DISSAGREE:
//hr审批不同意该假单,则返回hr不同意状态
return Status.HR_PERMIT_DISAGREE;
case MODIFY:
return Status.HR_PERMIT_MODIFY;
default:
throw new RuntimeException("不支持该Event审批意见");
}
}
}
对于请假的员工来讲,只知道提交了一个假单,并不会关心到底该流程怎么走,所以在设计的时候,需要根据请假类型能够自动匹配状态机,这里可以用静态工厂去实现。
public class StatusMachineFactory {
private StatusMachineFactory(){
}
/**
* 根据状态获取状态机
* @param leavePermitType
* @return 对应请假类型的状态机
*/
public static StatusMachine getStatusMachine(LeavePermitType leavePermitType){
switch (leavePermitType){
case MEDICAL_LEAVE:
return new MedicalLeaveStatusMachine();
case ANNUAL_LEAVE:
return new AnnualLeaveStatusMachine();
default:
throw new RuntimeException("未知类型");
}
}
}
状态机设计好之后,每个状态都应该对应有该状态的处理类,且需要统一管理该状态和处理类的关系。
以年休假为例:提交假单->领导审批4个状态->ceo审批4个状态->请假完成/失败2个状态。
总计需要11个状态处理对象去处理该状态。
该状态处理类需要具备哪些能力:
- 处理该状态的业务
- 能够决定要不要扭转该状态机接着往下走(提交假单状态处理结束要能够自动运行到领导审批状态,领导审批状态不能接着扭转到下一个状态,需要等待领导的审批意见才可继续往下走)
不难设计,先抽象出一个StatusHandler接口或父类,每个状态的处理类去实现该接口或继承该父类,在statusHandler中,有三个方法,before,dohandler,after,after主要负责扭转状态机,获取下一个状态的处理类处理下一个状态的事件。如果状态到达某一个状态不需要往下继续执行,则重写after方法即可中断状态机,dohandler主要负责做业务处理。
public interface AbstractStatusHandler {
public void handle(LeavePermit leavePermit);
}
public abstract class StatusHandler implements AbstractStatusHandler{
protected void before(LeavePermit leavePermit){
}
public void handle(LeavePermit leavePermit){
before(leavePermit);
doHandler(leavePermit);
after(leavePermit);
}
protected abstract void doHandler(LeavePermit leavePermit);
protected void after(LeavePermit leavePermit){
//去下一个状态的处理对象处理
goNextStatusHandler(leavePermit);
}
protected void goNextStatusHandler(LeavePermit leavePermit){
//获取下一个状态
leavePermit.setStatus(StatusMachineFactory.getStatusMachine(leavePermit.getLeavePermitType()).getNextStatus(leavePermit.getStatus(),leavePermit.getEvent()));
//状态机引擎驱动假单处理
StatusMachineEngine.post(leavePermit);
}
在看一下具体的状态处理类实现,11个状态对应11个处理类,这里列举出部分
public class AnnualPermitSubmitStatusHandler extends StatusHandler{
protected void doHandler(LeavePermit leavePermit){
System.out.println(String.format("user:%s--提交年休假假单--leavePermit status:%s",leavePermit.getUser(),leavePermit.getStatus().getStatus()));
}
}
public class AnnualLeaderPermitingStatusHandler extends StatusHandler{
protected void doHandler(LeavePermit leavePermit){
System.out.println(String.format("user:%s--领导审批年休假中--leavePermit status:%s",leavePermit.getUser(),leavePermit.getStatus().getStatus()));
}
@Override
protected void after(LeavePermit leavePermit){
if(leavePermit.getEvent()==null){
//还未审批,状态机结束,等待审批意见
System.out.println(String.format("user:%s--等待领导审批--leavePermit status:%s",leavePermit.getUser(),leavePermit.getStatus().getStatus()));
return;
}
super.goNextStatusHandler(leavePermit);
}
}
public class AnnualLeaderAgreeStatusHandler extends StatusHandler{
protected void doHandler(LeavePermit leavePermit){
System.out.println(String.format("user:%s--直线领导同意请年休假--leavePermit status:%s",leavePermit.getUser(),leavePermit.getStatus().getStatus()));
}
}
public class AnnualLeaderAgreeStatusHandler extends StatusHandler{
protected void doHandler(LeavePermit leavePermit){
leavePermit.setEvent(null);
System.out.println(String.format("user:%s--直线领导同意请年休假--leavePermit status:%s",leavePermit.getUser(),leavePermit.getStatus().getStatus()));
}
}
public class AnnualCEOPermitingStatusHandler extends StatusHandler{
protected void doHandler(LeavePermit leavePermit){
System.out