java状态机实现订单状态转移

已于 2023-05-10 18:41:34 修改
阅读量1.3k 收藏 6
点赞数
文章标签： java 开发语言
于 2023-05-09 20:21:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bxp1321/article/details/130587651
版权

一、状态机

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

二、状态机要素

把状态机的要素分为4个要素，即：现态、条件、动作、次态。
“现态”和“条件”是因，“动作”和“次态”是果。

（1）现态：是指当前所处状态；
（2）条件：又称为“事件”。当条件被满足时，将会触发一个动作，或者执行一次状态的迁移。
（3）动作：条件满足后执行的动作。动作不是必须的，当条件满足后，也可以不执行任何动作，直接迁移到新状态。
（4）次态：条件满足后要迁移往的新状态。“次态”是相对于“现态”而言的，“次态”一旦被激活，就转变成新的“现态”了。

三、状态机状态举例

以电商平台的订单状态为例，订单状态的可能有待支付、待发货、待收货、已完成、取消等。每一种状态都和变化前的状态以及执行的操作有关。

状态机图为：

 四、代码步骤

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

1.添加依赖

        <dependency>
            <groupId>org.springframework.statemachine</groupId>
            <artifactId>spring-statemachine-core</artifactId>
            <version>2.0.2.RELEASE</version>
        </dependency>

2.创建订单实体类

package com.sky.statemachinedemo.entity;

import lombok.Data;

/**
 * 订单实体类
 */
@Data
public class Order {
    private Integer id;
    private Integer status;
}

3.创建订单状态枚举类

package com.sky.statemachinedemo.constants;

/**
 * 订单状态枚举
 */
public enum OrderStatusEnum {

    /**
     * 待付款
     */
    WAIT_PAYMENT(0),

    /**
     * 待发货
     */
    WAIT_DELIVER(1),

    /**
     * 待收货
     */
    WAIT_RECEIVE(2),

    /**
     * 已完成
     */
    FINISH(3),

    /**
     * 取消
     */
    CANCEL(4),
    ;
    /**
     * 订单状态
     */
    public final int value;

    OrderStatusEnum(int value) {
        this.value = value;
    }

    public static Object getByValue(Integer status) {
        for(OrderStatusEnum OrderStatusEnum:OrderStatusEnum.values()){
            if(OrderStatusEnum.value==status){
                return OrderStatusEnum;
            }
        }
        return null;
    }
}

4.创建状态转换枚举类（事件event）

package com.sky.statemachinedemo.constants;

/**
 * 状态转换枚举类（事件）
 */
public enum OrderStatusChangeEvent {
    // 支付，发货，确认收货
    PAYED, DELIVERY, RECEIVED,CANCEL;
}

5.添加状态流配置

package com.sky.statemachinedemo.config;

import com.sky.statemachinedemo.constants.OrderStatusChangeEvent;
import com.sky.statemachinedemo.constants.OrderStatusEnum;
import com.sky.statemachinedemo.entity.Order;
import lombok.extern.slf4j.Slf4j;
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.EnumStateMachineConfigurerAdapter;
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;

/**
 * 订单状态机配置
 */
@Slf4j
@Configuration
@EnableStateMachine(name = "OrderStateMachine")
public class OrderStateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderStatusEnum, OrderStatusChangeEvent> {
    /**
     * 配置状态
     *
     * @param states
     * @throws Exception
     */
    public void configure(StateMachineStateConfigurer<OrderStatusEnum, OrderStatusChangeEvent> states) throws Exception {
        states
                .withStates()
                .initial(OrderStatusEnum.WAIT_PAYMENT)
                .states(EnumSet.allOf(OrderStatusEnum.class));
    }

    /**
     * 配置状态转换事件关系
     *
     * @param transitions
     * @throws Exception
     */
    public void configure(StateMachineTransitionConfigurer<OrderStatusEnum, OrderStatusChangeEvent> transitions) throws Exception {
        transitions
                .withExternal().source(OrderStatusEnum.WAIT_PAYMENT).target(OrderStatusEnum.WAIT_DELIVER).event(OrderStatusChangeEvent.PAYED)
                .and()
                .withExternal().source(OrderStatusEnum.WAIT_PAYMENT).target(OrderStatusEnum.CANCEL).event(OrderStatusChangeEvent.CANCEL)
                .and()
                .withExternal().source(OrderStatusEnum.WAIT_DELIVER).target(OrderStatusEnum.WAIT_RECEIVE).event(OrderStatusChangeEvent.DELIVERY)
                .and()
                .withExternal().source(OrderStatusEnum.WAIT_RECEIVE).target(OrderStatusEnum.FINISH).event(OrderStatusChangeEvent.RECEIVED);
    }

    /**
     * 持久化配置
     * 实际使用中，可以配合redis等，进行持久化操作
     *
     * @return
     */
    @Bean
    public DefaultStateMachinePersister persister() {
        return new DefaultStateMachinePersister<>(new StateMachinePersist<OrderStatusEnum, OrderStatusChangeEvent, Order>() {
            @Override
            public void write(StateMachineContext<OrderStatusEnum, OrderStatusChangeEvent> context, Order Order) throws Exception {
                //此处并没有进行持久化操作
                //此处可调用更新状态流转接口(如：更新时间）状态不需要在此进行调用
            }

            @Override
            public StateMachineContext<OrderStatusEnum, OrderStatusChangeEvent> read(Order Order) throws Exception {
                //此处直接获取Order中的状态，其实并没有进行持久化读取操作
                //实际生产中我们会查询出订单信息，根据订单状态获取状态机状态
                return new DefaultStateMachineContext(OrderStatusEnum.getByValue(Order.getStatus()), null, null, null);
            }
        });
    }
}

6.添加订单状态监听器 

package com.sky.statemachinedemo.listener;

import com.sky.statemachinedemo.constants.OrderStatusChangeEvent;
import com.sky.statemachinedemo.constants.OrderStatusEnum;
import com.sky.statemachinedemo.entity.Order;
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 OrderStateListener {

    @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER")
    public boolean payTransition(Message<OrderStatusChangeEvent> message) {
        Order Order = (Order) message.getHeaders().get("order");
        Order.setStatus(OrderStatusEnum.WAIT_DELIVER.value);
        System.out.println("支付，状态机反馈信息：" + message.getHeaders().toString());
        return true;
    }
    @OnTransition(source = "WAIT_PAYMENT", target = "CANCEL")
    public boolean cancelTransition(Message<OrderStatusChangeEvent> message) {
        Order Order = (Order) message.getHeaders().get("order");
        Order.setStatus(OrderStatusEnum.CANCEL.value);
        System.out.println("支付，状态机反馈信息：" + message.getHeaders().toString());
        return true;
    }
    @OnTransition(source = "WAIT_DELIVER", target = "WAIT_RECEIVE")
    public boolean deliverTransition(Message<OrderStatusChangeEvent> message) {
        Order Order = (Order) message.getHeaders().get("order");
        Order.setStatus(OrderStatusEnum.WAIT_RECEIVE.value);
        System.out.println("发货，状态机反馈信息：" + message.getHeaders().toString());
        return true;
    }

    @OnTransition(source = "WAIT_RECEIVE", target = "FINISH")
    public boolean receiveTransition(Message<OrderStatusChangeEvent> message) {
        Order Order = (Order) message.getHeaders().get("order");
        Order.setStatus(OrderStatusEnum.FINISH.value);
        System.out.println("收货，状态机反馈信息：" + message.getHeaders().toString());
        return true;
    }
}

此处也可以单独添加监听，比如：

package com.sky.statemachinedemo.listener;

import com.sky.statemachinedemo.constants.OrderStatusChangeEvent;
import com.sky.statemachinedemo.constants.OrderStatusEnum;
import com.sky.statemachinedemo.entity.Order;
import lombok.extern.slf4j.Slf4j;
import org.springframework.statemachine.StateContext;
import org.springframework.statemachine.action.Action;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class FinishListener implements Action<OrderStatusEnum, OrderStatusChangeEvent> {
    @Override
    public void execute(StateContext<OrderStatusEnum, OrderStatusChangeEvent> stateContext) {
        Order order = (Order) stateContext.getMessage().getHeaders().get("order");
        order .setStatus(OrderStatusEnum.FINISH.value);
        System.out.println("收货，状态机反馈信息：" + stateContext.getMessage().getHeaders().toString());
//可以设置返回值
context.getStateMachine().getExtendedState().getVariables().put("order", order );
    }
}

config修改：

    /**
     * 配置状态转换事件关系
     *
     * @param transitions
     * @throws Exception
     */
    public void configure(StateMachineTransitionConfigurer<OrderStatusEnum, OrderStatusChangeEvent> transitions) throws Exception {
        transitions
                .withExternal().source(OrderStatusEnum.WAIT_PAYMENT).target(OrderStatusEnum.WAIT_DELIVER).event(OrderStatusChangeEvent.PAYED)
                .and()
                .withExternal().source(OrderStatusEnum.WAIT_PAYMENT).target(OrderStatusEnum.CANCEL).event(OrderStatusChangeEvent.CANCEL)
                .and()
                .withExternal().source(OrderStatusEnum.WAIT_DELIVER).target(OrderStatusEnum.WAIT_RECEIVE).event(OrderStatusChangeEvent.DELIVERY)
                .and()
                .withExternal().source(OrderStatusEnum.WAIT_RECEIVE).target(OrderStatusEnum.FINISH).event(OrderStatusChangeEvent.RECEIVED).action(finishListener,transitionExceptionListener);
    }

7.创建OrderService接口

package com.sky.statemachinedemo.service;

import com.sky.statemachinedemo.entity.Order;

import java.util.Map;

public interface OrderService {
    //创建订单
    Order create();

    //发起支付
    Order pay(Integer id);
    //发起支付
    Order cancel(Integer id);

    //订单发货
    Order deliver(Integer id);

    //订单收货
    Order receive(Integer id);

    //获取所有订单信息
    //模拟数据存储的订单信息，生产中用数据库存储
    Map<Integer, Order> getOrders();
}

8.在 Service 业务逻辑中应用

package com.sky.statemachinedemo.service;

import com.sky.statemachinedemo.constants.OrderStatusChangeEvent;
import com.sky.statemachinedemo.constants.OrderStatusEnum;
import com.sky.statemachinedemo.entity.Order;
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
public class OrderServiceImpl implements OrderService{
    @Autowired
    private StateMachine<OrderStatusEnum, OrderStatusChangeEvent> orderStateMachine;

    @Autowired
    private StateMachinePersister<OrderStatusEnum, OrderStatusChangeEvent, Order> persister;
    private int id = 1;
    private Map<Integer, Order> orders = new HashMap<>();

    @Override
    public Order create() {
        Order order = new Order();
        order.setStatus(OrderStatusEnum.WAIT_PAYMENT.value);
        order.setId(id++);
        orders.put(order.getId(), order);
        return order;
    }

    @Override
    public Order pay(Integer 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);
    }

    @Override
    public Order cancel(Integer id) {
        Order order = orders.get(id);
        System.out.println("线程名称：" + Thread.currentThread().getName() + " 尝试取消，订单号：" + id);
        Message message = MessageBuilder.withPayload(OrderStatusChangeEvent.CANCEL).setHeader("order", order).build();
        if (!sendEvent(message, order)) {
            System.out.println("线程名称：" + Thread.currentThread().getName() + " 取消失败, 状态异常，订单号：" + id);
        }
        return orders.get(id);
    }

    @Override
    public Order deliver(Integer 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);
    }

    @Override
    public Order receive(Integer 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);
        }
//可以获取返回值
orderStateMachine.getExtendedState().get("order", Order.class);
        return orders.get(id);
    }

    @Override
    public Map<Integer, Order> getOrders() {
        return orders;
    }

    /**
     * 发送订单状态转换事件 这里不要使用synchronized锁方法，效率比较低，分布式系统优先采用分布式锁，下单锁userId，订单状态流转锁orderId根据业务考虑使用什么。
     *
     * @param message
     * @param order
     * @return
     */
    private synchronized boolean sendEvent(Message<OrderStatusChangeEvent> 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;
    }
}

9.编写单元测试代码

package com.sky.statemachinedemo.service;

import com.sky.statemachinedemo.StateMachineDemoApplication;
import junit.framework.TestCase;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = StateMachineDemoApplication.class,
        webEnvironment = SpringBootTest.WebEnvironment.NONE)
public class OrderServiceTest extends TestCase {
    @Autowired
    OrderService orderService;
    @Test
    public void stateTest(){
        orderService.create();
        orderService.pay(1);
        orderService.deliver(1);
        orderService.receive(1);
        orderService.cancel(1);

    }
}

10.也可以用controller测试，更方便

package com.sky.statemachinedemo.controller;

import com.sky.statemachinedemo.entity.Order;
import com.sky.statemachinedemo.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/order")
public class OrderController {
    @Autowired
    OrderService orderService;
    @RequestMapping("/create")
    public Order create(){
        return orderService.create();
    }

    @RequestMapping("/cancel")
    public Order cancel(Integer orderId){
        return orderService.cancel(orderId);
    }
    @RequestMapping("/pay")
    public Order pay(Integer orderId){
        return orderService.pay(orderId);
    }
    @RequestMapping("/deliver")
    public Order deliver(Integer orderId){
        return orderService.deliver(orderId);
    }
    @RequestMapping("/receive")
    public Order receive(Integer orderId){
        return orderService.receive(orderId);
    }
}

bxp1321
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值