mysql集群怎么实现状态机_使用状态机(Spring Statemachine)实现订单状态流转控制…

在电商平台中,一个订单会有多种状态,临时单、已下单、待支付、已支付、待发货、待收货、已完成等等。每一种状态都和…

在电商平台中,一个订单会有多种状态,临时单、已下单、待支付、已支付、待发货、待收货、已完成等等。每一种状态都和变化前的状态以及执行的操作有关。

比如,用户将商品加入购物车后,后台会生成一个所谓的“临时单”。因为用户还没有点击下单,所以这个订单实际上还没有生成。只有当用户下单后,这个“临时单”才会转化为一个“待支付的订单”。

以上过程中只有将一个处于“临时单”状态的订单执行下单操作,才能得到一个状态为“待支付”的订单。 即一个前置状态+一个恰当的操作,才能流转订单的状态。在这个过程中如果使用硬编码,我们就需要一系列的 if-else 语句来检查订单的当前状态、可执行操作以及这两个组合得到的下一个应该被流转的状态值。如果订单的状态流转很复杂,代码逻辑就会很复杂,可读性低,后期维护困难。

处理以上问题,我们可以使用状态设计模式来处理。对应到实践,就是状态机。

状态机是状态模式的一种应用,相当于上下文角色的一个升级版。在工作流或游戏等各种系统中有大量使用,如各种工作流引擎,它几乎是状态机的子集和实现,封装状态的变化规则。状态机可以帮助开发者简化状态控制的开发过程,让状态机结构更加层次化。

Spring 提供了一个很好的解决方案,Spring Statemachine(状态机)是应用程序开发人员在 Spring 应用程序中使用状态机概念的框架。

下面用 Spring 状态机模拟订单状态流转的过程,步骤如下。

1)添加依赖

org.springframework.statemachine

spring-statemachine-core

2.0.1.RELEASE

2)创建订单实体类

package net.biancheng.c.entity;

public class Order {

private int id;

private OrderStatus status;

public void setStatus(OrderStatus status) {

this.status = status;

public OrderStatus getStatus() {

return status;

public void setId(int id) {

this.id = id;

public int getId() {

return id;

@Override

public String toString() {

return “订单号:” + id + “, 订单状态:” + status;

3)创建订单状态枚举类和状态转换枚举类。

package net.biancheng.c.utils;

/**

* 订单状态

public enum OrderStatus {

// 待支付,待发货,待收货,已完成

WAIT_PAYMENT, WAIT_DELIVER, WAIT_RECEIVE, FINISH;

package net.biancheng.c.utils;

/**

* 订单状态改变事件

public enum OrderStatusChangeEvent {

// 支付,发货,确认收货

PAYED, DELIVERY, RECEIVED;

4)添加状态流配置

package net.biancheng.c.utils;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.statemachine.StateMachineContext;

import org.springframework.statemachine.StateMachinePersist;

import org.springframework.statemachine.config.EnableStateMachine;

import org.springframework.statemachine.config.StateMachineConfigurerAdapter;

import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;

import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;

import org.springframework.statemachine.persist.DefaultStateMachinePersister;

import org.springframework.statemachine.support.DefaultStateMachineContext;

import java.util.EnumSet;

/**

* 订单状态机配置

@Configuration

@EnableStateMachine(name = “orderStateMachine”)

public class OrderStateMachineConfig extends StateMachineConfigurerAdapter {

/**

* 配置状态

* @param states

* @throws Exception

public void configure(StateMachineStateConfigurer states) throws Exception {

states

.withStates()

.initial(OrderStatus.WAIT_PAYMENT)

.states(EnumSet.allOf(OrderStatus.class));

/**

* 配置状态转换事件关系

* @param transitions

* @throws Exception

public void configure(StateMachineTransitionConfigurer transitions) throws Exception {

transitions

.withExternal().source(OrderStatus.WAIT_PAYMENT).target(OrderStatus.WAIT_DELIVER).event(OrderStatusChangeEvent.PAYED)

.and()

.withExternal().source(OrderStatus.WAIT_DELIVER).target(OrderStatus.WAIT_RECEIVE).event(OrderStatusChangeEvent.DELIVERY)

.and()

.withExternal().source(OrderStatus.WAIT_RECEIVE).target(OrderStatus.FINISH).event(OrderStatusChangeEvent.RECEIVED);

/**

* 持久化配置

* 实际使用中,可以配合redis等,进行持久化操作

* @return

@Bean

public DefaultStateMachinePersister persister() {

return new DefaultStateMachinePersister<>(new StateMachinePersist() {

@Override

public void write(StateMachineContext context, Order order) throws Exception {

//此处并没有进行持久化操作

@Override

public StateMachineContext read(Order order) throws Exception {

//此处直接获取order中的状态,其实并没有进行持久化读取操作

return new DefaultStateMachineContext(order.getStatus(), null, null, null);

});

5)添加订单状态监听器

package net.biancheng.c.utils;

import org.springframework.messaging.Message;

import org.springframework.statemachine.annotation.OnTransition;

import org.springframework.statemachine.annotation.WithStateMachine;

import org.springframework.stereotype.Component;

@Component(“orderStateListener”)

@WithStateMachine(name = “orderStateMachine”)

public class OrderStateListenerImpl {

@OnTransition(source = “WAIT_PAYMENT”, target = “WAIT_DELIVER”)

public boolean payTransition(Message message) {

Order order = (Order) message.getHeaders().get(“order”);

order.setStatus(OrderStatus.WAIT_DELIVER);

System.out.println(“支付,状态机反馈信息:” + message.getHeaders().toString());

return true;

@OnTransition(source = “WAIT_DELIVER”, target = “WAIT_RECEIVE”)

public boolean deliverTransition(Message message) {

Order order = (Order) message.getHeaders().get(“order”);

order.setStatus(OrderStatus.WAIT_RECEIVE);

System.out.println(“发货,状态机反馈信息:” + message.getHeaders().toString());

return true;

@OnTransition(source = “WAIT_RECEIVE”, target = “FINISH”)

public boolean receiveTransition(Message message) {

Order order = (Order) message.getHeaders().get(“order”);

order.setStatus(OrderStatus.FINISH);

System.out.println(“收货,状态机反馈信息:” + message.getHeaders().toString());

return true;

6)创建 OrderService 接口。

package net.biancheng.c.service;

import net.biancheng.c.entity.Order;

import java.util.Map;

public interface OrderService {

//创建订单

Order create();

//发起支付

Order pay(int id);

//订单发货

Order deliver(int id);

//订单收货

Order receive(int id);

//获取所有订单信息

Map getOrders();

7)在 Service 业务逻辑中应用。

package net.biancheng.c.serviceImpl;

import net.biancheng.c.entity.Order;

import net.biancheng.c.service.OrderService;

import net.biancheng.c.utils.OrderStatus;

import net.biancheng.c.utils.OrderStatusChangeEvent;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.messaging.Message;

import org.springframework.messaging.support.MessageBuilder;

import org.springframework.statemachine.StateMachine;

import org.springframework.statemachine.persist.StateMachinePersister;

import org.springframework.stereotype.Service;

import java.util.HashMap;

import java.util.Map;

@Service(“orderService”)

public class OrderServiceImpl implements OrderService {

@Autowired

private StateMachine orderStateMachine;

@Autowired

private StateMachinePersister persister;

private int id = 1;

private Map orders = new HashMap<>();

public Order create() {

Order order = new Order();

order.setStatus(OrderStatus.WAIT_PAYMENT);

order.setId(id++);

orders.put(order.getId(), order);

return order;

public Order pay(int id) {

Order order = orders.get(id);

System.out.println(“线程名称:” + Thread.currentThread().getName() + ” 尝试支付,订单号:” + id);

Message message = MessageBuilder.withPayload(OrderStatusChangeEvent.PAYED).setHeader(“order”, order).build();

if (!sendEvent(message, order)) {

System.out.println(“线程名称:” + Thread.currentThread().getName() + ” 支付失败, 状态异常,订单号:” + id);

return orders.get(id);

public Order deliver(int id) {

Order order = orders.get(id);

System.out.println(“线程名称:” + Thread.currentThread().getName() + ” 尝试发货,订单号:” + id);

if (!sendEvent(MessageBuilder.withPayload(OrderStatusChangeEvent.DELIVERY).setHeader(“order”, order).build(), orders.get(id))) {

System.out.println(“线程名称:” + Thread.currentThread().getName() + ” 发货失败,状态异常,订单号:” + id);

return orders.get(id);

public Order receive(int id) {

Order order = orders.get(id);

System.out.println(“线程名称:” + Thread.currentThread().getName() + ” 尝试收货,订单号:” + id);

if (!sendEvent(MessageBuilder.withPayload(OrderStatusChangeEvent.RECEIVED).setHeader(“order”, order).build(), orders.get(id))) {

System.out.println(“线程名称:” + Thread.currentThread().getName() + ” 收货失败,状态异常,订单号:” + id);

return orders.get(id);

public Map getOrders() {

return orders;

/**

* 发送订单状态转换事件

* @param message

* @param order

* @return

private synchronized boolean sendEvent(Message message, Order order) {

boolean result = false;

try {

orderStateMachine.start();

//尝试恢复状态机状态

persister.restore(orderStateMachine, order);

//添加延迟用于线程安全测试

Thread.sleep(1000);

result = orderStateMachine.sendEvent(message);

//持久化状态机状态

persister.persist(orderStateMachine, order);

} catch (Exception e) {

e.printStackTrace();

} finally {

orderStateMachine.stop();

return result;

8)编写客户端测试代码。

import net.biancheng.c.service.OrderService;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication

public class Test {

public static void main(String[] args) {

Thread.currentThread().setName(“主线程”);

ConfigurableApplicationContext context = SpringApplication.run(Test.class, args);

OrderService orderService = (OrderService) context.getBean(“orderService”);

orderService.create();

orderService.create();

orderService.pay(1);

new Thread(“客户线程”) {

@Override

public void run() {

orderService.deliver(1);

orderService.receive(1);

}.start();

orderService.pay(2);

orderService.deliver(2);

orderService.receive(2);

System.out.println(“全部订单状态:” + orderService.getOrders());

运行结果如下。

线程名称:主线程 尝试支付,订单号:2

线程名称:客户线程 尝试发货,订单号:1

2020-11-10 09:42:59.528 INFO 10796 — [ 主线程] o.s.s.support.LifecycleObjectSupport : started org.springframework.statemachine.support.DefaultStateMachineExecutor@eb507b9

2020-11-10 09:42:59.528 INFO 10796 — [ 主线程] o.s.s.support.LifecycleObjectSupport : started FINISH WAIT_PAYMENT WAIT_RECEIVE WAIT_DELIVER / WAIT_PAYMENT / uuid=5aa411ad-212a-4f2a-8afd-fc1009def5d5 / id=null

2020-11-10 09:42:59.528 INFO 10796 — [ 主线程] o.s.s.support.LifecycleObjectSupport : stopped org.springframework.statemachine.support.DefaultStateMachineExecutor@eb507b9

2020-11-10 09:42:59.528 INFO 10796 — [ 主线程] o.s.s.support.LifecycleObjectSupport : stopped FINISH WAIT_PAYMENT WAIT_RECEIVE WAIT_DELIVER / / uuid=5aa411ad-212a-4f2a-8afd-fc1009def5d5 / id=null

2020-11-10 09:42:59.528 INFO 10796 — [ 主线程] o.s.s.support.LifecycleObjectSupport : started org.springframework.statemachine.support.DefaultStateMachineExecutor@eb507b9

2020-11-10 09:42:59.528 INFO 10796 — [ 主线程] o.s.s.support.LifecycleObjectSupport : started FINISH WAIT_PAYMENT WAIT_RECEIVE WAIT_DELIVER / WAIT_PAYMENT / uuid=5aa411ad-212a-4f2a-8afd-fc1009def5d5 / id=null

支付,状态机反馈信息:{order=订单号:2, 订单状态:WAIT_DELIVER, id=13bd1f00-21e1-cab4-3b2a-af8a4a82507a, timestamp=1604972579527}

由于运行结果篇幅过长,以上只贴出了部分运行结果。通过本节的真实业务案例,相信小伙伴们对状态模式已经有非常深刻的理解了。

本文来自网络,不代表软粉网立场,转载请注明出处:https://www.rfff.net/p/8038.html

作者: HUI

发表评论

您的电子邮箱地址不会被公开。

返回顶部