状态机demo的演示

读图很重要，给到的需求就是一张图

1. 看图说话，抽象图片的能力一定要有，这张图分析出的类有：

    1.  State: 未发起、领导审批中等等
    2.  Event事件： 提交、同意、拒绝
    3、 State结果： 领导审批、HR审批中等等
    4、 Handler： event事件发生后，审批人的动作

2. demo

/**
 * 状态枚举
 */
public enum State {

    REJECT,

    FINISH,

    UN_SUBMIT,

    LEADER_CHECK,

    HR_CHECK;

}

/**
 * @Description 事件枚举
 * @Author roy.ding
 * @Date 2022/9/3 00:20:46
 */
public enum Event {

    SUBMIT,

    PASS,

    REJECT;
}



/**
 * @Description 抽象的状态机
 * @Author roy.ding
 * @Date 2022/9/3 00:20:01
 */
public abstract class AbstractStateMachine {

    private HashBasedTable<State, Event, ApprovalExecutor> hashBasedTable = HashBasedTable.create();

    {
        List<ApprovalProcess> approvalProcesses = init();

        approvalProcesses.forEach(item -> {
            ApprovalExecutor approvalExecutor = new ApprovalExecutor();
            approvalExecutor.setNextState(item.getTo());
            approvalExecutor.setStateHandle(item.getStateHandle());
            hashBasedTable.put(item.getFrom(), item.getEvent(), approvalExecutor);
        });
    }

    abstract List<ApprovalProcess> init();

    public State getNext(State state, Event event) {
        ApprovalExecutor result = hashBasedTable.get(state, event);
        if (result == null) {
            throw new IllegalArgumentException("未找到状态");
        }
        return result.getNextState();
    }

    public IStateHandle getHandle(State state, Event event) {
        ApprovalExecutor result = hashBasedTable.get(state, event);
        if (result == null) {
            throw new IllegalArgumentException("未找到状态");
        }
        return result.getStateHandle();
    }
}

/**
 * @Description 状态机
 * @Author roy.ding
 * @Date 2022/9/3 00:23:14
 */
public class NewStateMachine extends AbstractStateMachine {


    @Override
    List<ApprovalProcess> init() {
        return Arrays.asList(
                ApprovalProcessBuilder.getInstance()
                        .from(State.UN_SUBMIT)
                        .event(Event.SUBMIT)
                        .to(State.LEADER_CHECK)
                        .build(),
                ApprovalProcessBuilder.getInstance()
                        .from(State.LEADER_CHECK)
                        .event(Event.PASS)
                        .handle(new LeaderPassHandle())
                        .to(State.HR_CHECK)
                        .build()
        );
    }

    public static void main(String[] args) {
        NewStateMachine newStateMachine = new NewStateMachine();
        State state = newStateMachine.getNext(State.LEADER_CHECK, Event.PASS);
        System.out.println(state);
        IStateHandle<String, String> stateHandle = newStateMachine.getHandle(State.LEADER_CHECK, Event.PASS);
        String result = stateHandle.handle("入参内容");
        System.out.println(result);
    }
}

/**
 * @Description 审批执行器
 * @Author roy.ding
 * @Date 2022/9/3 09:14:48
 */
@Data
public class ApprovalExecutor {
    private State nextState;
    private IStateHandle stateHandle;
}


/**
 * @Description 考验你的抽象能力，表示从哪个状态来，经历什么事件，到达某个状态
 * @Author roy.ding
 * @Date 2022/9/3 00:23:45
 */
@Data
class ApprovalProcess {

    private State from;
    private State to;
    private Event event;
    private IStateHandle stateHandle;
}


/**
 * @Description TODO
 * @Author roy.ding
 * @Date 2022/9/3 00:22:11
 */
public class ApprovalProcessBuilder {

    private ApprovalProcess approvalProcess;

    public ApprovalProcess getApprovalProcess() {
        return approvalProcess;
    }

    public void setApprovalProcess(ApprovalProcess approvalProcess) {
        this.approvalProcess = approvalProcess;
    }

    public static ApprovalProcessBuilder getInstance() {
        ApprovalProcessBuilder builder = new ApprovalProcessBuilder();
        builder.setApprovalProcess(new ApprovalProcess());
        return builder;
    }

    public ApprovalProcessBuilder from(State state) {
        approvalProcess.setFrom(state);
        return this;
    }

    public ApprovalProcessBuilder handle(IStateHandle stateHandle) {
        approvalProcess.setStateHandle(stateHandle);
        return this;
    }

    public ApprovalProcessBuilder to(State state) {
        approvalProcess.setTo(state);
        return this;
    }

    public ApprovalProcessBuilder event(Event state) {
        approvalProcess.setEvent(state);
        return this;
    }

    public ApprovalProcess build() {
        return approvalProcess;
    }
}


/**
 * @Description 审批动作
 * @Author roy.ding
 * @Date 2022/9/3 00:19:07
 */
interface IStateHandle<T, R> {
    R handle(T t);
}


/**
 * @Description leader具体审批动作
 * @Author roy.ding
 * @Date 2022/9/3 00:22:41
 */
public class LeaderPassHandle implements IStateHandle<String, String> {

    @Override
    public String handle(String s) {
        System.out.println(String.format("收到了%s", s));
        return "业务处理完了";
    }
}