springboot【28】状态机的实现-Spring StateMachine框架

         Spring StateMachine框架的第三个Release版本1.2.0增加了对Spring Boot的自动化配置。

快速入门

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

• 创建一个Spring Boot的基础工程，并在pom.xml中加入spring-statemachine-core的依赖，具体如下：

  <parent>
  	<groupId>org.springframework.boot</groupId>
  	<artifactId>spring-boot-starter-parent</artifactId>
  	<version>1.3.7.RELEASE</version>
  	<relativePath/> 
  </parent>
  <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>

• 根据上面所述的订单需求场景定义状态和事件枚举，具体如下：

  public enum States {
      UNPAID,                 // 待支付
      WAITING_FOR_RECEIVE,    // 待收货
      DONE                    // 结束
  }
  public enum Events {
      PAY,        // 支付
      RECEIVE     // 收货
  }

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

• 创建状态机配置类StateMachineConfig.java：

  package com.lyd;
  
  @Configuration
  @EnableStateMachine
  public class StateMachineConfig extends EnumStateMachineConfigurerAdapter<States, Events> {
  
  	private Logger logger = LoggerFactory.getLogger(getClass());
  	
  	@Override
  	public void configure(StateMachineStateConfigurer<States, Events> states) throws Exception{
  		//定义状态机中的状态
  		states
  			.withStates()
  				.initial(States.UNPAID) //初始状态
  				.states(EnumSet.allOf(States.class));
  	}
  	
  	@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);
  	}
  	
  	@Override
  	public void configure(StateMachineConfigurationConfigurer<States, Events> config) throws Exception{
  		config
  			.withConfiguration()
  				.listener(listener());  //指定状态机的处理监听器
  	}
  	
  	@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("用户已收货，订单完成");
  				}
  			}
  		};
  	}
  }
  

  在该类中定义了较多配置内容，下面对这些内容一一说明：

  • @EnableStateMachine注解用来启用Spring StateMachine状态机功能

  • configure(StateMachineStateConfigurer<States, Events> states)方法用来初始化当前状态机拥有哪些状态，其中initial(States.UNPAID)定义了初始状态为UNPAID，states(EnumSet.allOf(States.class))则指定了使用上一步中定义的所有状态作为该状态机的状态定义。

  • configure(StateMachineTransitionConfigurer<States, Events> transitions)方法用来初始化当前状态机有哪些状态迁移动作，其中命名中我们很容易理解每一个迁移动作，都有来源状态source，目标状态target以及触发事件event。

  • configure(StateMachineConfigurationConfigurer<States, Events> config)方法为当前的状态机指定了状态监听器，其中listener()则是调用了下一个内容创建的监听器实例，用来处理各个各个发生的状态迁移事件。

  • StateMachineListener<States, Events> listener()方法用来创建StateMachineListener状态监听器的实例，在该实例中会定义具体的状态迁移处理逻辑，上面的实现中只是做了一些输出，实际业务场景会会有更负责的逻辑，所以通常情况下，我们可以将该实例的定义放到独立的类定义中，并用注入的方式加载进来。

• 创建应用主类来完成整个流程：

  package com.lyd;
  
  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;
  	
  	@Override
  	public void run(String... args){
  		stateMachine.start();
  		stateMachine.sendEvent(Events.PAY);
  		stateMachine.sendEvent(Events.RECEIVE);
  	}
  }
  

  在run函数中，我们定义了整个流程的处理过程，其中start()就是创建这个订单流程，根据之前的定义，该订单会处于待支付状态，然后通过调用sendEvent(Events.PAY)执行支付操作，最后通过掉用sendEvent(Events.RECEIVE)来完成收货操作。在运行了上述程序之后，我们可以在控制台中获得类似下面的输出内容，其中包括了状态监听器中对各个状态迁移做出的处理：

  
  

  
  

通过上面的例子，我们可以对如何使用Spring StateMachine做如下小结：

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

状态监听器

         可以看到使用Spring StateMachine来实现状态机的时候，代码逻辑变得非常简单并且具有层次化。整个状态的调度逻辑主要依靠配置方式的定义，而所有的业务逻辑操作都被定义在了状态监听器中，其实状态监听器可以实现的功能远不止上面我们所述的内容，它还有更多的事件捕获，我们可以通过查看StateMachineListener接口来了解它所有的事件定义：

注解监听器

对于状态监听器，Spring StateMachine还提供了优雅的注解配置实现方式，所有StateMachineListener接口中定义的事件都能通过注解的方式来进行配置实现。比如，我们可以将之前实现的状态监听器用注解配置来做进一步的简化。下面代码实现了与快速入门中定义的listener()方法创建的监听器相同的功能，但是由于通过注解的方式配置，省去了原来事件监听器中各种if的判断，使得代码显得更为简洁，拥有了更好的可读性：

package com.lyd;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.statemachine.annotation.OnTransition;
import org.springframework.statemachine.annotation.OnTransitionEnd;
import org.springframework.statemachine.annotation.OnTransitionStart;
import org.springframework.statemachine.annotation.WithStateMachine;

/**
 * 该配置实现了com.lyd.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("用户已收货，订单完成");
    }
}

注释掉StateMachineConfig.java中监听器配置代码，即可运行：

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

	private Logger logger = LoggerFactory.getLogger(getClass());
	
	@Override
	public void configure(StateMachineStateConfigurer<States, Events> states) throws Exception{
		//定义状态机中的状态
		states
			.withStates()
				.initial(States.UNPAID) //初始状态
				.states(EnumSet.allOf(States.class));
	}
	
	@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);
	}



     /*@Override
	public void configure(StateMachineConfigurationConfigurer<States, Events> config) throws Exception{
		config
			.withConfiguration()
				.listener(listener());  //指定状态机的处理监听器
	}
	
	@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("用户已收货，订单完成");
				}
			}
		};
	}*/
}

结果：

下面是完整项目结构：