相比Spring statemachine状态机等的复杂，功能多；我们更需要常用的功能，简单使用，所以这类就显得不简洁；再看cola-statemachine相比就是小巧、无状态、简单、轻量、性能极高的状态机DSL实现，解决业务中的状态流转问题。
github:
https://github.com/alibaba/COLA/tree/master/cola-components/cola-component-statemachine
概念：
State：状态
Event：事件，状态由事件触发，引起变化
Transition：流转，表示从一个状态到另一个状态
External Transition：外部流转，两个不同状态之间的流转
Internal Transition：内部流转，同一个状态之间的流转
Condition：条件，表示是否允许到达某个状态
Action：动作，到达某个状态之后，可以做什么
StateMachine：状态机
外部过程描述：起始状态STATE1，结束状态STATE2，当发生EVENT1时执行状态转移，当满足checkCondition()时，执行doAction，执行成功则返回状态STATE2，否则返回STATE1。
public class StateMachineTest {
static String MACHINE_ID = "TestStateMachine";
static enum States {
STATE1, STATE2, STATE3, STATE4
}
static enum Events {
EVENT1, EVENT2, EVENT3, EVENT4, INTERNAL_EVENT
}
static class Context{
String operator = "frank";
String entityId = "123465";
}
@Test
public void testExternalNormal(){
// 第一步：生成一个状态机builder
StateMachineBuilder<States, Events, Context> builder = StateMachineBuilderFactory.create();
// 第二步：设置一个外部状态转移类型的builder，并设置from\to\on\when\perform
builder.externalTransition()
.from(States.STATE1)
.to(States.STATE2)
.on(Events.EVENT1)
.when(checkCondition())
.perform(doAction()); //这个action 我们可以按自己所需修改，比如这种Action<R,T> service的方法Service::method
// 第三步：设置状态机的id和ready，并在StateMachineFactory中的stateMachineMap进行注册
StateMachine<States, Events, Context> stateMachine = builder.build(MACHINE_ID);
// 第四步：触发状态机
States target = stateMachine.fireEvent(States.STATE1, Events.EVENT1, new Context());
Assert.assertEquals(States.STATE2, target);
}
}
源码分析：这里只是简单介绍，整个流转的链路，因为具体的代码还是要根据自己的知识储备理解；
第一步：生成一个状态机builder
new com.alibaba.cola.statemachine.builder.StateMachineBuilderImpl
/**
* StateMap is the same with stateMachine, as the core of state machine is holding reference to states.
*/
private final Map<S, State< S, E, C>> stateMap = new ConcurrentHashMap<>();
private final StateMachineImpl<S, E, C> stateMachine = new StateMachineImpl<>(stateMap);
第二步：设置一个外部状态转移类型的builder，并设置from\to\on\when\perform
@Override
public ExternalTransitionBuilder<S, E, C> externalTransition() {
return new TransitionBuilderImpl<>(stateMap, TransitionType.EXTERNAL);
}
TransitionBuilderImpl为多实现接口实现类，这个设计加上不同接口的唯一方法实现，可以让from to ，按DSL方式运行
class TransitionBuilderImpl<S,E,C> implements ExternalTransitionBuilder<S,E,C>, InternalTransitionBuilder<S,E,C>, From<S,E,C>, On<S,E,C>, To<S,E,C> {
image.png
上述构建就是一个状态流转的过程
class TransitionBuilderImpl<S,E,C> implements ExternalTransitionBuilder<S,E,C>, InternalTransitionBuilder<S,E,C>, From<S,E,C>, On<S,E,C>, To<S,E,C> {
//状态机
final Map<S, State<S, E, C>> stateMap;
//原状态
private State<S, E, C> source;
//目标状态
protected State<S, E, C> target;
//该具体做事流转
private Transition<S, E, C> transition;
//流转类型
final TransitionType transitionType;
...
// 此时只是把from的state新增到stateMap中，返回结果赋给本地变量source
@Override
public From<S, E, C> from(S stateId) {
source = StateHelper.getState(stateMap, stateId);
return this;
}
// 此时只是把to的state新增到stateMap中，返回结果赋给本地变量target
@Override
public To<S, E, C> to(S stateId) {
target = StateHelper.getState(stateMap, stateId);
return this;
}
//所以ON是在Form和to后面执行，因为它用本流程中的source，向来源state中加入Transition
//Transition是一个具体做事的流转，其中包含事件，目标状态和流转类型
//看下面源码就是一个事件对应Transition
@Override
public On<S, E, C> on(E event) {
transition = source.addTransition(event, target, transitionType);
return this;
}
//该执行流转的条件
@Override
public When<S, E, C> when(Condition<C> condition) {
transition.setCondition(condition);
return this;
}
//设置transition的action
@Override
public void perform(Action<S, E, C> action) {
transition.setAction(action);
}
...
}
第三步：
builder.build(MACHINE_ID) 此步就是状态机已构建完成，一般直接@Bean注入，使用时直接调用
public class StateMachineBuilderImpl<S, E, C> implements StateMachineBuilder<S, E, C> {
...
private final StateMachineImpl<S, E, C> stateMachine = new StateMachineImpl<>(stateMap);
...
// 设置状态机的id和ready，并在StateMachineFactory中的stateMachineMap进行注册
@Override
public StateMachine<S, E, C> build(String machineId) {
stateMachine.setMachineId(machineId);
stateMachine.setReady(true);
StateMachineFactory.register(stateMachine);
return stateMachine;
}
}
第四步：States target = stateMachine.fireEvent(States.STATE1, Events.EVENT1, new Context()); 业务具体使用时，这个方法入参是原状态和事件和action的入参，这个就按上面配置的状态机进行流转；from to on when perform
public class StateMachineImpl<S,E,C> implements StateMachine<S, E, C> {
private String machineId;
private final Map<S, State<S,E,C>> stateMap;
private boolean ready;
public StateMachineImpl(Map<S, State< S, E, C>> stateMap){
this.stateMap = stateMap;
}
public S fireEvent(S sourceStateId, E event, C ctx){
isReady();
State sourceState = getState(sourceStateId);
return doTransition(sourceState, event, ctx).getId();
}
private State<S, E, C> doTransition(State sourceState, E event, C ctx) {
//根据原状态和事件获取流转transition
Optional<Transition<S,E,C>> transition = sourceState.getTransition(event);
if(transition.isPresent()){
//ctx为执行入参
return transition.get().transit(ctx);
}
Debugger.debug("There is no Transition for " + event);
return sourceState;
Transition是具体做事的流转
/**
* TransitionImpl。
*
* This should be designed to be immutable, so that there is no thread-safe risk
*
* @author Frank Zhang
* @date 2020-02-07 10:32 PM
*/
public class TransitionImpl<S,E,C> implements Transition<S,E,C> {
private State<S, E, C> source;
private State<S, E, C> target;
private E event;
private Condition<C> condition;
private Action<S,E,C> action;
private TransitionType type = TransitionType.EXTERNAL;
...
@Override
public State<S, E, C> transit(C ctx) {
Debugger.debug("Do transition: "+this);
this.verify();
if(condition == null || condition.isSatisfied(ctx)){
if(action != null){
action.execute(source.getId(), target.getId(), event, ctx);
}
return target;
}
Debugger.debug("Condition is not satisfied, stay at the "+source+" state ");
return source;
}
...
@Override
public final String toString() {
return source + "-[" + event.toString() +", "+type+"]->" + target;
}
@Override
public boolean equals(Object anObject){
if(anObject instanceof Transition){
Transition other = (Transition)anObject;
if(this.event.equals(other.getEvent())
&& this.source.equals(other.getSource())
&& this.target.equals(other.getTarget())){
return true;
}
}
return false;
}
@Override
public void verify() {
if(type== TransitionType.INTERNAL && source != target) {
throw new StateMachineException(String.format("Internal transition source state '%s' " +
"and target state '%s' must be same.", source, target));
}
}
State是整个流转中状态类
public interface State<S,E,C> extends Visitable{
/**
* Gets the state identifier.
*
* @return the state identifiers
*/
S getId();
/**
* Add transition to the state
* @param event the event of the Transition
* @param target the target of the transition
* @return
*/
Transition<S,E,C> addTransition(E event, State<S, E, C> target, TransitionType transitionType);
Optional<Transition<S,E,C>> getTransition(E event);
Collection<Transition<S,E,C>> getTransitions();
}
public class StateImpl<S,E,C> implements State<S,E,C> {
protected final S stateId;
private HashMap<E, Transition<S, E,C>> transitions = new HashMap<>();
StateImpl(S stateId){
this.stateId = stateId;
}
@Override
public Transition<S, E, C> addTransition(E event, State<S,E,C> target, TransitionType transitionType) {
Transition<S, E, C> newTransition = new TransitionImpl<>();
newTransition.setSource(this);
newTransition.setTarget(target);
newTransition.setEvent(event);
newTransition.setType(transitionType);
Debugger.debug("Begin to add new transition: "+ newTransition);
verify(event, newTransition);
transitions.put(event, newTransition);
return newTransition;
}
/**
* @param event
* @param newTransition
*/
private void verify(E event, Transition<S,E,C> newTransition) {
Transition existingTransition = transitions.get(event);
if(existingTransition != null){
if(existingTransition.equals(newTransition)){
throw new StateMachineException(existingTransition+" already Exist, you can not add another one");
}
}
}
最后用层级展示下源码的设计：存储下来类似树形分支
第一维度：状态
第二维度：原状态 对应 事件
第三维度：事件对应具体流转
image.png
