一直以来，总觉得ssm不够灵活，主要原因是没找到为状态机指定状态的方式，也就意味着状态机引擎实例必须要跟对应的业务数据一起持久化，虽然ssm提供了多重持久化的方式，依然觉得有点不爽。
最近又回过头去啃了下文档和源码，无意中在AbstractStateMachine类中看到了setCurrentState方法，如下：

void setCurrentState(State<S, E> state, Message<E> message, Transition<S, E> transition, boolean exit, StateMachine<S, E> stateMachine) {
    this.setCurrentState(state, message, transition, exit, stateMachine, (Collection)null, (Collection)null);
}

void setCurrentState(State<S, E> state, Message<E> message, Transition<S, E> transition, boolean exit, StateMachine<S, E> stateMachine, Collection<State<S, E>> sources, Collection<State<S, E>> targets) {
    this.setCurrentStateInternal(state, message, transition, exit, stateMachine, sources, targets);
}

private void setCurrentStateInternal(State<S, E> state, Message<E> message, Transition<S, E> transition, boolean exit, StateMachine<S, E> stateMachine, Collection<State<S, E>> sources, Collection<State<S, E>> targets) {
  ...
}

emmm，貌似有门儿，于是做了以下尝试。

搭个项目框架

为了简单，用springboot基于maven搭了个简单的项目(http://start.spring.io)

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-statemachine.version>2.1.3.RELEASE</spring-statemachine.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.statemachine</groupId>
            <artifactId>spring-statemachine-core</artifactId>
            <version>${spring-statemachine.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

可以看到，只需要引入spring-statemachine-core就可以了，当然夹带点私货，顺手扔上去了lombok。

States & Events

package com.example.demo;

public enum States {
    SI, S1, S2, S3;
}

package com.example.demo;

public enum Events {
    E1, E2, E3;
}

spring statemachine config

定义了一些configure & listener

package com.example.demo;

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.Message;
import org.springframework.statemachine.config.EnableStateMachine;
import org.springframework.statemachine.config.EnumStateMachineConfigurerAdapter;
import org.springframework.statemachine.config.builders.StateMachineConfigurationConfigurer;
import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
import org.springframework.statemachine.listener.StateMachineListener;
import org.springframework.statemachine.listener.StateMachineListenerAdapter;
import org.springframework.statemachine.state.State;
import org.springframework.statemachine.transition.Transition;

import java.util.EnumSet;
import java.util.Optional;

@Configuration
@EnableStateMachine
public class StateMachineConfig
        extends EnumStateMachineConfigurerAdapter<States, Events> {

    @Override
    public void configure(StateMachineConfigurationConfigurer<States, Events> config)
            throws Exception {
        config
                .withConfiguration()
                .autoStartup(true)
                .listener(listener());
    }

    @Override
    public void configure(StateMachineStateConfigurer<States, Events> states)
            throws Exception {
        states
                .withStates()
                .initial(States.SI)
                .states(EnumSet.allOf(States.class));
    }

    @Override
    public void configure(StateMachineTransitionConfigurer<States, Events> transitions)
            throws Exception {
        transitions
                .withExternal()
                .source(States.SI).target(States.S1).event(Events.E1)
                .and()
                .withExternal()
                .source(States.S1).target(States.S2).event(Events.E2)
                .and()
                .withExternal()
                .source(States.S2).target(States.S3).event(Events.E3);
    }


    private StateMachineListener<States, Events> listener() {
        return new StateMachineListenerAdapter<States, Events>() {
            @Override
            public void transition(Transition<States, Events> transition) {
                System.out.println("move from:{" + ofNullableState(transition.getSource()) + "} " +
                        "to:{" + ofNullableState(transition.getTarget()) + "}");
            }

            @Override
            public void stateChanged(State<States, Events> from, State<States, Events> to) {

                if (null != from) {
                    System.out.println("State change from " + from.getId() + " to " + to.getId());
                } else {
                    System.out.println("State change to " + to.getId());
                }

            }

            @Override
            public void eventNotAccepted(Message<Events> event) {
                System.err.println("event not accepted: {" + event + "}");
            }

            private Object ofNullableState(State s) {
                return Optional.ofNullable(s)
                        .map(State::getId)
                        .orElse(null);
            }
        };
    }

/*    @Bean
    public StateMachineListener<States, Events> listener() {
        return new StateMachineListenerAdapter<States, Events>() {
            @Override
            public void stateChanged(State<States, Events> from, State<States, Events> to) {
                System.out.println("State change to " + to.getId());
            }
        };
    }*/

}

Stringboot Application

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.statemachine.StateMachine;

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Autowired
    private StateMachine<States, Events> stateMachine;

    @Override
    public void run(String... args) throws Exception {

        stateMachine.sendEvent(Events.E1);
        stateMachine.sendEvent(Events.E2);
    }


}

执行结果

mvn clean install

Java -jar *.jar

move from:{null} to:{SI}
State change to SI
2019-09-17 23:10:14.374  INFO 71833 --- [           main] o.s.s.support.LifecycleObjectSupport     : started S3 SI S2 S1  / SI / uuid=eb612bb8-d97f-4505-b8af-4106320b3073 / id=null
move from:{SI} to:{S1}
State change from SI to S1
move from:{S1} to:{S2}
State change from S1 to S2

可以看到，可以通过sendEvent来触发状态机引擎的状态流转

setCurrentState

上面只是一个常规的demo，那么怎么直接设置当前状态呢？

还是回到上面的AbstractStateMachine类中setCurrentState方法定义：

void setCurrentState(State<S, E> state, Message<E> message, Transition<S, E> transition, boolean exit, StateMachine<S, E> stateMachine) 

State<S, E> state：需要设置的状态

Message<E> message：需要携带的message，这里先不用

Transition<S, E> transition：对应节点，可以先不用，毕竟还需要构造

boolean exit：？是否可以exit，默认走false

StateMachine<S, E> stateMachine：具体的状态机引擎实例

应该是需要提供写一个工具类，屏蔽掉上游调用的复杂度。而SpringStateMachine中本身就提供了一个工具类StateMachineUtils，直接基于它扩展吧，毕竟很多上下文的东西构造起来还是挺麻烦。

StateMachineUtils工具类

package org.springframework.statemachine.support;

import org.springframework.statemachine.StateMachine;
import org.springframework.statemachine.state.State;

public abstract class MyStateMachineUtils extends StateMachineUtils {

    public static <S, E> void setCurrentState(StateMachine<S, E> stateMachine, S state) {
        if (stateMachine instanceof AbstractStateMachine) {
            setCurrentState((AbstractStateMachine<S, E>) stateMachine, state);

            System.out.println("StateMachine Current:" + stateMachine);
        } else {
            throw new IllegalArgumentException("Provided StateMachine is not a valid type");
        }
    }

    public static <S, E> void setCurrentState(AbstractStateMachine<S, E> stateMachine, S state) {
        stateMachine.setCurrentState(findState(stateMachine, state), null, null, false, stateMachine);
    }

    private static <S, E> State<S, E> findState(AbstractStateMachine<S, E> stateMachine, S stateId) {
        for (State<S, E> state : stateMachine.getStates()) {
            if (state.getId() == stateId) {
                return state;
            }
        }

        throw new IllegalArgumentException("Specified State ID is not valid");
    }
}

注意：

1、这里的包名是org.springframework.statemachine.support，因为setCurrentState是default的scope，不放在同一个包里无法直接操作

2、这里findState是从stateMachine实例中获取目标state

修改DemoApplication

        @Override
    public void run(String... args) throws Exception {

        //        stateMachine.sendEvent(Events.E1);

        MyStateMachineUtils.setCurrentState(stateMachine,States.S1);

        stateMachine.sendEvent(Events.E2);

    }

执行下看结果：

move from:{null} to:{SI}
State change to SI
2019-09-17 23:21:14.788  INFO 72337 --- [           main] o.s.s.support.LifecycleObjectSupport     : started S1 S3 SI S2  / SI / uuid=801118a8-0115-48e1-95e7-a8ba67e5d30f / id=null
State change from SI to S1
StateMachine Current:S1 S3 SI S2  / S1 / uuid=801118a8-0115-48e1-95e7-a8ba67e5d30f / id=null
move from:{S1} to:{S2}
State change from S1 to S2

可以看到，直接把stateMachine的状态从SI迁移到了S1，done！

注意：这里如果spring-statemachine.version=2.1.3.RELEASE是正常的，但是如果是使用3.0.0.M1版本，则状态一直未生效，应该是新版本还有缺陷。