需求1 简单的审核流程

动作

prev next

状态

新建待审核审核通过退回修改

BO

@Data
public class BO {
    private long id;
    private String name;
    private StatusEnum status;
}

StatusEnum

@Data
public enum StatusEnum {
    INIT(1, "新建"),
    WAITING(2, "待审核"),
    PASSED(3, "审核通过"),
    REJECT(4, "驳回修改");
}

if/else实现

// 下一步操作
next() { 
    if(status = "新建"){ status = "带审核"; return; } 
    if(status = "待审核"){ status = "审核通过"; return; } 
    if(status = "审核通过"){ throw new Excption("当前状态没有下一步操作") }
    if(status = "退回修改"){ status = "退回"; return; } 
}
// 上一步操作
prev() { 
    if(status = "新建"){ throw new Excption("当前状态没有上一步操作") }
    if(status = "待审核"){ status = "退回修改"; return; }
    if(status = "审核通过"){ throw new Excption("当前状态没有上一步操作") }
    if(status = "退回修改"){ throw new Excption("当前状态没有上一步操作") }
}

优点：速度
缺点：不灵活

状态迁移表实现

state	Event	new state
新建	prev	none
新建	next	待审核
待审核	prev	退回修改
待审核	next	审核通过
审核通过	prev	none
审核通过	next	none
退回修改	prev	none
退回修改	next	待审核

优点：灵活，运行时改变状态机逻辑；多个迁移表实现多种状态机逻辑
缺点：读数据库

状态模式State

参与者

State接口
状态实现类
Context (StateMachine.java)

按动作设计API

public interface DemoService {
    // 下一步流程
    String next(DTO reqDTO) throws PendingException;

    // 上一步流程
    String prev(DTO reqDTO) throws PendingException;
}

State接口

public interface State {

    void actionToPrev() throws PendingException;

    void actionToNext() throws PendingException;
}

State实现类

InitState PassedState RejectState WaitingState

/**
* 应用状态：等待审核
*/
@Service("WAITING_STATE")
public class WaitingState implements State {

    @Setter
    @Autowired
    private StateMachine stateMachine;

    /**
    * 审核不通过
    */
    @Override
    public void actionToPrev() throws PendingException {
        // Context获取当前的BO
        BO bo = stateMachine.getBO();
        // 更新状态
        bo.setStatus("退回修改");
    }

    /**
    * 审核通过
    */
    @Override
    public void actionToNext() throws PendingException {
        // Context获取当前的BO
        BO bo = stateMachine.getBO();
        // 更新状态
        bo.setStatus("审核通过");
        
        // 如果有需要, 可以通过Context状态转换, 继续执行新State下的action
        stateMachine.setBO(bo);
    }
}

StateMachine

@Data
@Service
public class StateMachine implements State {
    @Autowired
    private InitState initState;
    @Autowired
    private WaitingState waitingState;
    @Autowired
    private RejectState rejectState;
    @Autowired
    private PassedState passedState;

    private State state;
    
    @Getter
    private BO bo;

    @Override
    public void actionToPrev() throws PendingException {
        state.actionToPrev();
    }

    @Override
    public void actionToNext() throws PendingException {
        state.actionToNext();
    }

    // Context这里负责状态的转换: 当传入BO的时候,根据status选择State实现类
    public void setBO(BO bo) throws PendingException {
        this.bo = bo;
        StatusEnum status = this.bo.getStatus();
        if (status == "新建") {
            this.state = initState;
            return;
        }
        if (status == "审核通过") {
            this.state = passedState;
            return;
        }
        if ((status == "待审核") {
            this.state = waitingState;
            return;
        }
        if ((status == "退回修改") {
            this.state = rejectState;
            return;
        }
        throw new PendingException(MerCodeEnum.M1060);
    }

}

用法

public class Demo implements DemoService {
    @Autowired
    private BoDAO boDAO;
    @Autowired 
    private StateMachine stateMachine;

    @Override
    public void prev(PrevStateReqDTO reqDTO) throws PendingException {

       BO bo = boDAO.selectById(reqDTO.getId());

        // 状态的转换, 选择State实现类
       stateMachine.setBO(bo);
       
       // 执行动作
       stateMachine.actionToPrev();
       
        // 入库操作
        ......
    }

    @Override
    public void next(NextStateReqDTO reqDTO) throws PendingException {

       BO bo = boDAO.selectById(reqDTO.getId());
       
       // 状态的转换, 选择State实现类
       stateMachine.setBO(bo);
       
       // 执行动作
       stateMachine.actionToNext();
    }

}

谁定义状态的转换

1. 可以在Conetxt中定义转态转换, 即Conetxt需要注入所有State接口的实体类

见上面的示例中的StateMachine类的setBO()方法

2. 可以在State子类中指定后续转态转换，缺点：子类拥有其他子类的信息

State接口

public interface State {
    void updateStatus(BO bo) throws PendingException;
    
    void actionToPrev() throws PendingException;

    void actionToNext() throws PendingException;
}

StateMachine

@Data
@Service
public class StateMachine implements State {
    
    // 不需要注入所有的State实现类
    
    private State state;
    private BO bo;
    
    @Override
    public void updateStatus(BO bo) throws PendingException {
        // 状态转换
        state.updateStatus(bo);
    }
    
    @Override
    public void actionToPrev() throws PendingException {
        state.actionToPrev(bo);
    }

    @Override
    public void actionToNext(BO bo) throws PendingException {
        state.actionToNext(bo);
    }
}

WaitingState实现类

/**
* 应用状态：等待审核
*/
@Service("WAITING")
public class WaitingState implements State {

    @Setter
    @Autowired
    private StateMachine stateMachine;
    
    // 子类注入其他子类的信息
    @Autowired
    private RejectdState rejectdState;
    @Autowired
    private PassedState passedState;

    @Override
    public void updateStatus(BO bo) throws PendingException {
        // 状态转换
        bo.setState("等待审核");
    }
    
    /**
    * 审核不通过
    */
    @Override
    public void actionToPrev() throws PendingException {
        // 子类负责状态转换, 直接指定State的实现类
        stateMachine.setState(rejectdState);
        // 更新状态
        stateMachine.updateStatus();
    }

    /**
    * 审核通过
    */
    @Override
    public void actionToNext() throws PendingException {
        // 状态转换
        stateMachine.setState(passedState);
        // 更新状态
        stateMachine.updateStatus();
    }
}

状态模式优缺点

优点：效率高 + 灵活
缺点：类比较多
API设计风险点: 同一个人不小心多次调用prev接口, 会导致流程到达终态

优化代码v2 开闭原则

- 对修改关闭
不用修改已有代码
- 对扩展开放
只需新增一个状态类

StateMachine

@Data
@Service
public class StateMachine implements State {

    // @Autowired
    // private WaitingState waitingState;
    // @Autowired
    // private RejectState rejectState;
    // @Autowired
    // private PassedState passedState;
    
    @Autowired
    private Map<String, State> stateMap;
}

State实现类

@Service("...")用于指定stateMap中的key

@Service("WAITING_STATE")
public class WaitingState implements State {
    ......
}

@Service("PASSED_STATE")
public class PassedState implements State {
    ......
}

优化代码v3 并发场景

StateMachine原型模式

@Scope("prototype") 表示每次获得bean都会生成一个新的对象

@Data
@Service
@Scope("prototype")
public class StateMachine implements State {

    @Autowired
    private Map<String, State> stateMap;

    private State state;
    
    private BO bo;
    ......

}

StateMachine 单例模式

删除公共字段

@Data
@Service
public class StateMachine implements State {
    private final static String _SERVICE = "%s_STATE";
    
    @Autowired
    private Map<String, State> stateMap;

    @Override
    public void actionToPrev(BO bo) throws PendingException {
        // 当前状态
        StatusEnum status = bo.getStatus();
        stateMap.get(String.format(_SERVICE, status.name())).actionToPrev();
    }

    @Override
    public void actionToNext(BO bo) throws PendingException {
        // 当前状态
        StatusEnum status = bo.getStatus();
        stateMap.get(String.format(_SERVICE, status.name())).actionToNext();
    }

}

State接口

StateMachine是单例时, 由于没有缓存BO, 所以BO要作为参数传入State接口

public interface State {

    void actionToPrev(BO bo) throws PendingException;

    void actionToNext(BO bo) throws PendingException;
}

需求2 在审核通过后再加一个停用状态

ClosedState实现类

新增一个State实现类ClosedState

/**
* 应用状态：停用
*/
@Service("CLOSED")
public class ClosedState implements State {

    @Setter
    @Autowired
    private StateMachine stateMachine;

    /**
    * next
    */
    @Override
    public void actionToNext() throws PendingException {
         // Context获取当前的BO
        BO bo = stateMachine.getBO();
        // 更新状态
        bo.setStatus("待审核");
    }
}

修改StatusEnum

@Data
public enum StatusEnum {
    ......,
    CLOSED(5, "停用");
}

修改PassedState实现类

/**
* 应用状态：审核通过
*/
@Service("PASSED")
public class PassedState implements State {

    @Setter
    @Autowired
    private StateMachine stateMachine;

    /**
    * prev
    */
    @Override
    public void actionToPrev() throws PendingException {
        // Context获取当前的BO
        BO bo = stateMachine.getBO();
        // 更新状态
        bo.setStatus("停用");
    }
}

状态模式 VS 策略模式

状态模式
策略模式

需求3 一个动作下有多个状态

需求1是一个动作没有分支:prev -> success
需求2是一个动作存在分支:pay -> success | fail

按动作设计API

public interface DemoService {
    // 下单
    String build(DTO reqDTO) throws PendingException;

    // 支付
    // result: 成功 success 失败 fail
    String pay(DTO reqDTO, ResultEnum result) throws PendingException;
    
    // 担保
    // result: 成功 success 失败 fail
    String guarantee(DTO reqDTO, ResultEnum result) throws PendingException;
}

State接口

每个动作的大体的共同点是分为成功,失败

public interface State {
    // 成功
    String success() throws PendingException;
    // 失败
    String fail() throws PendingException;
    // 更新状态值
    String updateStatus() throws PendingException;
}

StateMachine

@Data
@Service
public class StateMachine implements State {
    private final static String _SERVICE = "%s_STATE";
    
    @Autowired
    private Map<String, State> stateMap;
    
    public void changeState(BO bo, ResultEnum result) throws PendingException {
        if (ResultEnum.SUCCESS.equals(result)) {
            this.success(bo);
            return;
        }
        if (ResultEnum.FAIL.equals(result)) {
            this.fail(bo);
            return;
        }
        throw new PendingException(TradeCode.T0010);
    }

    @Override
    public void updateStatus(BO bo) throws PendingException {
        // 状态转换
        stateMap.get(String.format(_SERVICE, bo.getStatus().name())).updateStatus(bo);
    }
    
    @Override
    public void success(BO bo) throws PendingException {
        stateMap.get(String.format(_SERVICE, bo.getStatus().name())).actionToPrev(bo);
    }

    @Override
    public void fail(BO bo) throws PendingException {
        stateMap.get(String.format(_SERVICE, bo.getStatus().name())).actionToNext(bo);
    }
}

用法

public class Demo impl DemoService {
    // 下单
    String build(DTO reqDTO) throws PendingException{
        stateMachine.sucess(bo);
    }

    // 支付
    // result: 成功 success 失败 fail
    String pay(DTO reqDTO, ResultEnum result) throws PendingException {
        // 根据result判断是执行success还是执行fail方法
        stateMachine.changeState(bo, result.name());
    }
}

需求4 双状态

降纬处理

API设计风险点: 同一个人不小心多次调用prev接口, 会导致流程到达终态