Spring Boot使用Spring StateMachine框架实现状态机

一点睛

Spring StateMachine框架可能对于大部分使用Spring的开发者来说还比较生僻，它的主要功能是帮助开发者简化状态机的开发过程，让状态机结构更加层次化。它的第三个Release版本1.2.0，其中增加了对Spring Boot的自动化配置。

我们通过一个简单的示例来对Spring StateMachine有一个初步的认识。

假设我们需要实现一个订单的相关流程，其中包括订单创建、订单支付、订单收货三个动作。

二实战

1 新建pom

<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>1.2.0.RELEASE</version>
    </dependency>
</dependencies>

2 定义状态和事件枚举

/*
其中共有三个状态（待支付、待收货、结束）以及两个引起状态迁移的事件（支付、收货）。
支付事件PAY会触发状态从待支付UNPAID状态到待收货WAITING_FOR_RECEIVE状态的迁移，
收货事件RECEIVE会触发状态从待收货WAITING_FOR_RECEIVE状态到结束DONE状态的迁移。
*/
public enum States {
    UNPAID,                 // 待支付
    WAITING_FOR_RECEIVE,    // 待收货
    DONE                    // 结束
}

public enum Events {
    PAY,        // 支付
    RECEIVE     // 收货
}

3 创建状态机配置类

package com.didispace;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.transition.Transition;

import java.util.EnumSet;


@Configuration
//该注解用来启用Spring StateMachine状态机功能
@EnableStateMachine
public class StateMachineConfig extends EnumStateMachineConfigurerAdapter<States, Events> {

    private Logger logger = LoggerFactory.getLogger(getClass());

    /*
    configure用来初始化当前状态机拥有哪些状态。
    * */
    @Override
    public void configure(StateMachineStateConfigurer<States, Events> states)
            throws Exception {
        states
            .withStates()
                .initial(States.UNPAID)   //定义了初始状态为UNPAID
                .states(EnumSet.allOf(States.class));  //指定States中的所有状态作为该状态机的状态定义。
    }

    /*
    configure用来初始化当前状态机有哪些状态迁移动作
    从其中命名中我们很容易理解每一个迁移动作，都有来源状态source，目标状态target以及触发事件event。
    * */
    @Override
    public void configure(StateMachineTransitionConfigurer<States, Events> transitions)
            throws Exception {
        transitions
            .withExternal()
                .source(States.UNPAID).target(States.WAITING_FOR_RECEIVE)
                .event(Events.PAY)
                .and()
            .withExternal()
                .source(States.WAITING_FOR_RECEIVE).target(States.DONE)
                .event(Events.RECEIVE);
    }
    /*
    configure为当前的状态机指定了状态监听器，其中listener()则是调用了下一个函数创建的监听器实例，用来处理各个各个发生的状态迁移事件。
    这里注释是因为我们有其他更好的方法去替代
    * */
//    @Override
//    public void configure(StateMachineConfigurationConfigurer<States, Events> config)
//            throws Exception {
//        config
//            .withConfiguration()
//                .listener(listener());   // 指定状态机的处理监听器
//    }
    /*
    listener()方法用来创建StateMachineListener状态监听器的实例，
    在该实例中会定义具体的状态迁移处理逻辑，上面的实现中只是做了一些输出，
    实际业务场景会有更严密的逻辑，所以通常情况下，我们可以将该实例的定义放到独立的类定义中，并用注入的方式加载进来。
    这里注释是因为我们有其他更好的方法去替代
    * */
//    @Bean
//    public StateMachineListener<States, Events> listener() {
//        return new StateMachineListenerAdapter<States, Events>() {
//
//            @Override
//            public void transition(Transition<States, Events> transition) {
//                if(transition.getTarget().getId() == States.UNPAID) {
//                    logger.info("订单创建，待支付");
//                    return;
//                }
//
//                if(transition.getSource().getId() == States.UNPAID
//                        && transition.getTarget().getId() == States.WAITING_FOR_RECEIVE) {
//                    logger.info("用户完成支付，待收货");
//                    return;
//                }
//
//                if(transition.getSource().getId() == States.WAITING_FOR_RECEIVE
//                        && transition.getTarget().getId() == States.DONE) {
//                    logger.info("用户已收货，订单完成");
//                    return;
//                }
//            }
//
//        };
//    }

}

4 注解监听器

package com.didispace;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.statemachine.annotation.*;

/**
* 该配置实现了com.didispace.StateMachineConfig类中定义的状态机监听器实现。
*/
@WithStateMachine
public class EventConfig {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @OnTransition(target = "UNPAID")
    public void create() {
        logger.info("订单创建，待支付");
    }

    @OnTransition(source = "UNPAID", target = "WAITING_FOR_RECEIVE")
    public void pay() {
        logger.info("用户完成支付，待收货");
    }

    @OnTransitionStart(source = "UNPAID", target = "WAITING_FOR_RECEIVE")
    public void payStart() {
        logger.info("用户完成支付，待收货: start");
    }

    @OnTransitionEnd(source = "UNPAID", target = "WAITING_FOR_RECEIVE")
    public void payEnd() {
        logger.info("用户完成支付，待收货: end");
    }

    @OnTransition(source = "WAITING_FOR_RECEIVE", target = "DONE")
    public void receive() {
        logger.info("用户已收货，订单完成");
    }

}

5 创建应用主类来完成流程

package com.didispace;

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 Application implements CommandLineRunner {

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

    @Autowired
    private StateMachine<States, Events> stateMachine;

    //在run函数中，我们定义了整个流程的处理过程
    @Override
    public void run(String... args) throws Exception {
        stateMachine.start();    //start()就是创建这个订单流程，根据之前的定义，该订单会处于待支付状态，
        stateMachine.sendEvent(Events.PAY);    //通过调用sendEvent(Events.PAY)执行支付操作，
        stateMachine.sendEvent(Events.RECEIVE);  //通过调用用sendEvent(Events.RECEIVE)来完成收货操作
    }

}

三测试

四项目说明

1 我们可以对如何使用Spring StateMachine做如下小结：

定义状态和事件枚举
为状态机定义使用的所有状态以及初始状态
为状态机定义状态的迁移动作
为状态机指定监听处理器

2 状态监听器

通过上面的入门示例以及最后的小结，我们可以看到使用Spring StateMachine来实现状态机的时候，代码逻辑变得非常简单并且具有层次化。

整个状态的调度逻辑主要依靠配置方式的定义，而所有的业务逻辑操作都被定义在了状态监听器中。

其实状态监听器可以实现的功能远不止上面我们所述的内容，它还有更多的事件捕获，我们可以通过查看StateMachineListener接口来了解它所有的事件定义：

public interface StateMachineListener<S,E> {
    void stateChanged(State<S,E> from, State<S,E> to);
    void stateEntered(State<S,E> state);
    void stateExited(State<S,E> state);
    void eventNotAccepted(Message<E> event);
    void transition(Transition<S, E> transition);
    void transitionStarted(Transition<S, E> transition);
    void transitionEnded(Transition<S, E> transition);
    void stateMachineStarted(StateMachine<S, E> stateMachine);
    void stateMachineStopped(StateMachine<S, E> stateMachine);
    void stateMachineError(StateMachine<S, E> stateMachine, Exception exception);
    void extendedStateChanged(Object key, Object value);
    void stateContext(StateContext<S, E> stateContext);
}

五参考

http://blog.didispace.com/spring-statemachine/

Spring Boot使用Spring StateMachine框架实现状态机

猜你喜欢