1
public static void main(String[] args) {
2
  String orderState = "已创建";
3
  String event = "支付";
4
  if ("已创建".equals(orderState)) if ("支付".equals(event)) orderState = "待发货";
5
  if ("已创建".equals(orderState)) if ("取消".equals(event)) orderState = "已关闭";
6
  // ......
7
}

1
/**
2
 * 订单事件枚举
3
 *
4
 * @author mydlq
5
 */
6
public enum OrderEvent {
7
  // 支付
8
  PAY,
9
  // 发货
10
  SHIP,
11
  // 收货
12
  RECEIVE,
13
  // 取消
14
  CANCEL
15
}

1
/**
2
 * 订单状态枚举
3
 *
4
 * @author mydlq
5
 */
6
public enum OrderState {
7
  // --- 已创建 ---
8
  CREATED {
9
    @Override
10
    public OrderState next(OrderEvent event) {
11
      if (event == OrderEvent.PAY) { return PENDING_SHIPMENT; }
12
      if (event == OrderEvent.CANCEL) { return CLOSED; }
13
      return this;
14
    }
15
  },
16
  // --- 待发货 ---
17
  PENDING_SHIPMENT {
18
    @Override
19
    public OrderState next(OrderEvent event) {
20
      if (event == OrderEvent.SHIP) { return SHIPPED; }
21
      if (event == OrderEvent.CANCEL) { return CLOSED; }
22
      return this;
23
    }
24
  },
25
  // --- 已发货 ---
26
  SHIPPED {
27
    @Override
28
    public OrderState next(OrderEvent event) {
29
      if (event == OrderEvent.RECEIVE) { return RECEIVED; }
30
      if (event == OrderEvent.CANCEL) { return CLOSED; }
31
      return this;
32
    }
33
  },
34
  // --- 已收货 ---
35
  RECEIVED {
36
    @Override
37
    public OrderState next(OrderEvent event) { return this; }
38
  },
39
  // --- 已关闭 ---
40
  CLOSED {
41
    @Override
42
    public OrderState next(OrderEvent event) { return this; }
43
  };
44

45
  /**
46
   * 获取下一个状态的抽象方法
47
   * @param event 事件
48
   * @return 下一个状态
49
   */
50
  public abstract OrderState next(OrderEvent event);
51

52
}

1
/**
2
 * 订单状态机测试
3
 *
4
 * @author mydlq
5
 */
6
public class StateMachineTest {
7

8
  public static void main(String[] args) {
9
    // 定义记录原状态和目标状态的变量，便于控制台中输出状态转换
10
    OrderState sourceState;
11
    OrderState targetState;
12

13
    // 输出plantUML状态转换图的开始标志
14
    System.out.println("@startuml");
15

16
    // (1) 验证状态转换: 已创建 -> (支付) -> 待发货
17
    sourceState = OrderState.CREATED;
18
    targetState = sourceState.next(OrderEvent.PAY);
19
    System.out.println(sourceState + " --> " + targetState + " : " + OrderEvent.PAY);
20

21
    // (2) 验证状态转换: 待发货 -> (发货) -> 已发货
22
    sourceState = OrderState.PENDING_SHIPMENT;
23
    targetState = targetState.next(OrderEvent.SHIP);
24
    System.out.println(sourceState + " --> " + targetState + " : " + OrderEvent.SHIP);
25

26
    // (3) 验证状态转换: 已发货 -> (收货) -> 已收货
27
    sourceState = OrderState.SHIPPED;
28
    targetState = targetState.next(OrderEvent.RECEIVE);
29
    System.out.println(sourceState + " --> " + targetState + " : " + OrderEvent.RECEIVE);
30

31
    // (4) 验证状态转换: 已创建 -> (取消) -> 已关闭
32
    sourceState = OrderState.CREATED;
33
    targetState = sourceState.next(OrderEvent.CANCEL);
34
    System.out.println(sourceState + " --> " + targetState + " : " + OrderEvent.CANCEL);
35

36
    // (5) 验证状态转换: 待发货 -> (取消) -> 已关闭
37
    sourceState = OrderState.PENDING_SHIPMENT;
38
    targetState = targetState.next(OrderEvent.CANCEL);
39
    System.out.println(sourceState + " --> " + targetState + " : " + OrderEvent.CANCEL);
40

41
    // (6) 验证状态转换: 已发货 -> (取消) -> 已关闭
42
    sourceState = OrderState.SHIPPED;
43
    targetState = targetState.next(OrderEvent.CANCEL);
44
    System.out.println(sourceState + " --> " + targetState + " : " + OrderEvent.CANCEL);
45

46
    // 输出plantUML状态转换图的结束标志
47
    System.out.println("@enduml");
48
  }
49

50
}

1
<dependency>
2
  <groupId>com.alibaba.cola</groupId>
3
  <artifactId>cola-component-statemachine</artifactId>
4
  <version>5.0.0</version>
5
</dependency>

1
public enum States {
2
  // 状态1
3
  STATE_1,
4
  // 状态2
5
  STATE_2,
6
  // 状态3
7
  STATE_3,
8
  // 状态4
9
  STATE_4
10
}

1
public enum Events {
2
  // 事件1
3
  EVENT_1,
4
  // 事件2
5
  EVENT_2,
6
  // 事件3
7
  EVENT_3
8
}

1
@Data
2
public class Order {
3
  /** 订单ID */
4
  private Long orderId;
5
}

1
public class TransitionCondition implements Condition<Order> {
2

3
  @Override
4
  public boolean isSatisfied(Order context) {
5
    // 这里验证条件，订单ID不能为空
6
    return context.getOrderId() != null;
7
  }
8

9
}

1
public class TransitionAction implements Action<States, Events, Order> {
2

3
  @Override
4
  public void execute(States from, States to, Events event, Order context) {
5
    // 打印日志
6
    System.out.println("输出订单 ID=" + context.getOrderId() + " 的状态转换过程:" +
7
            " 原始状态:" + from + " 目标状态:" + to + " 事件:" + event);
8
    // 执行其它操作
9
    // ......
10
  }
11

12
}

1
public class MyStateMachine {
2

3
  public static void initStateMachine() {
4
    // 创建状态转换条件和动作
5
    Condition<Order> condition = new TransitionCondition();
6
    Action<States, Events, Order> action = new TransitionAction();
7

8
    // 创建状态机构建器
9
    StateMachineBuilder<States, Events, Order> builder = StateMachineBuilderFactory.create();
10
    // 配置状态转换规则(1) - 外部状态流转
11
    builder.externalTransition()
12
            .from(States.STATE_1)
13
            .to(States.STATE_2)
14
            .on(Events.EVENT_1)
15
            .when(condition)
16
            .perform(action);
17
    // 配置状态转换规则(2) - 内部状态流转
18
    builder.internalTransition()
19
            .within(States.STATE_2)
20
            .on(Events.EVENT_2)
21
            .when(condition)
22
            .perform(action);
23
    // 配置状态转换规则(3) - 外部状态流转，多个原始状态转换为单个目标状态
24
    builder.externalTransitions()
25
            .fromAmong(States.STATE_1, States.STATE_2)
26
            .to(States.STATE_3)
27
            .on(Events.EVENT_3)
28
            .when(condition)
29
            .perform(action);
30

31
    // 定义状态机ID，并构建状态机
32
    String stateMachineId = "my-state-machine-id";
33
    StateMachine<States, Events, Order> stateMachine = builder.build(stateMachineId);
34

35
    // 输出绘制planUML图的数据
36
    System.out.println(stateMachine.generatePlantUML());
37
  }
38

39
}

1
public class StateMachineTest {
2

3
  public static void main(String[] args) {
4
    // 够级自定义状态机(全局只需要初始化一次状态机即可)
5
    MyStateMachine.initStateMachine();
6

7
    // 根据状态机ID获取状态机
8
    String stateMachineId = "my-state-machine-id";
9
    StateMachine<States, Events, Order> stateMachine = StateMachineFactory.get(stateMachineId);
10

11
    // 定义订单上下文对象
12
    Order order = new Order(1001L);
13

14
    // 触发事件，然后获取转换后的目标状态，并判断目标状态是否符合预期
15
    System.out.println("------------- 状态机状态转换测试 -------------");
16
    // 测试状态转换(1): STATE_1 -> (EVENT_1) -> STATE_2
17
    States targetState1 = stateMachine.fireEvent(States.STATE_1, Events.EVENT_1, order);
18
    System.out.print("测试状态转换(1)结果: ");
19
    System.out.println(targetState1 == States.STATE_2 ? "状态符合预期" : "状态转换不符合预期");
20

21
    // 测试状态转换(2): STATE_2 -> (EVENT_2) -> STATE_2
22
    States targetState2 = stateMachine.fireEvent(States.STATE_2, Events.EVENT_2, order);
23
    System.out.print("测试状态转换(2)结果: ");
24
    System.out.println(targetState2 == States.STATE_2 ? "状态符合预期" : "状态转换不符合预期");
25

26
    // 测试状态转换(3): STATE_1 -> (EVENT_3) -> STATE_3 和 STATE_2 -> (EVENT_3) -> STATE_3
27
    States targetState3 = stateMachine.fireEvent(States.STATE_1, Events.EVENT_3, order);
28
    States targetState4 = stateMachine.fireEvent(States.STATE_2, Events.EVENT_3, order);
29
    System.out.print("测试状态转换(3)结果: ");
30
    System.out.println(targetState3 == States.STATE_3 && targetState4 == States.STATE_3 ?
31
            "状态符合预期" : "状态转换不符合预期");
32
  }
33

34
}

1
CREATE TABLE `order`
2
(
3
  `id`          bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
4
  `order_id`    bigint(20) NOT NULL COMMENT '订单ID',
5
  `order_state` enum('CREATED','PENDING_SHIPMENT','SHIPPED','RECEIVED','CANCELED','CLOSED') NOT NULL COMMENT '订单状态',
6
  `create_time` datetime   NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
7
  `update_time` datetime   NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
8
  PRIMARY KEY (`id`)
9
) ENGINE = InnoDB
10
  DEFAULT CHARSET = utf8 COMMENT ='订单表';

1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
4
  <modelVersion>4.0.0</modelVersion>
5

6
  <parent>
7
    <groupId>org.springframework.boot</groupId>
8
    <artifactId>spring-boot-starter-parent</artifactId>
9
    <version>3.3.2</version>
10
  </parent>
11

12
  <groupId>club.mydlq</groupId>
13
  <artifactId>spring-boot-cola-statemachine-example</artifactId>
14
  <version>0.0.1</version>
15
  <name>spring-boot-cola-statemachine-example</name>
16
  <description>statemachine example</description>
17

18
  <properties>
19
    <java.version>17</java.version>
20
  </properties>
21

22
  <dependencies>
23
    <!--spring-boot-->
24
    <dependency>
25
      <groupId>org.springframework.boot</groupId>
26
      <artifactId>spring-boot-starter-web</artifactId>
27
    </dependency>
28
    <!--cola-component-statemachine-->
29
    <dependency>
30
      <groupId>com.alibaba.cola</groupId>
31
      <artifactId>cola-component-statemachine</artifactId>
32
      <version>5.0.0</version>
33
    </dependency>
34
    <!--mybatis-->
35
    <dependency>
36
      <groupId>org.mybatis.spring.boot</groupId>
37
      <artifactId>mybatis-spring-boot-starter</artifactId>
38
      <version>3.0.3</version>
39
    </dependency>
40
    <!--mysql-->
41
    <dependency>
42
      <groupId>mysql</groupId>
43
      <artifactId>mysql-connector-java</artifactId>
44
      <version>8.0.33</version>
45
      <scope>runtime</scope>
46
    </dependency>
47
    <!--test-->
48
    <dependency>
49
      <groupId>org.springframework.boot</groupId>
50
      <artifactId>spring-boot-starter-test</artifactId>
51
      <scope>test</scope>
52
    </dependency>
53
    <!--lombok-->
54
    <dependency>
55
      <groupId>org.projectlombok</groupId>
56
      <artifactId>lombok</artifactId>
57
      <optional>true</optional>
58
    </dependency>
59
  </dependencies>
60

61
  <build>
62
    <plugins>
63
      <plugin>
64
        <groupId>org.springframework.boot</groupId>
65
        <artifactId>spring-boot-maven-plugin</artifactId>
66
      </plugin>
67
    </plugins>
68
  </build>
69

70
</project>

1
spring:
2
  application:
3
    name: spring-boot-cola-statemachine-example
4
  ## 数据库配置
5
  datasource:
6
    type: com.zaxxer.hikari.HikariDataSource
7
    driverClassName: com.mysql.cj.jdbc.Driver
8
    url: jdbc:mysql://127.0.0.1:3306/example
9
    hikari:
10
      pool-name: DatebookHikariCP
11
      minimum-idle: 5
12
      maximum-pool-size: 15
13
      max-lifetime: 1800000
14
      connection-timeout: 30000
15
      username: root
16
      password: 123456
17

18
## MyBatis配置，指定扫描的 Mapper 文件位置
19
mybatis:
20
  mapper-locations: classpath:mapper/*.xml

1
import lombok.AllArgsConstructor;
2
import lombok.Getter;
3

4
/**
5
 * 订单状态枚举
6
 *
7
 * @author mydlq
8
 */
9
@Getter
10
@AllArgsConstructor
11
public enum OrderState {
12
  // 已创建
13
  CREATED("已创建"),
14
  // 待发货
15
  PENDING_SHIPMENT("待发货"),
16
  // 已发货
17
  SHIPPED("已发货"),
18
  // 已收货
19
  RECEIVED("已收货"),
20
  // 已关闭
21
  CLOSED("已关闭"),
22
  ;
23

24
  private final String desc;
25

26
  @Override
27
  public String toString() {
28
    return this.name() + "_" + desc;
29
  }
30
}

1
import lombok.AllArgsConstructor;
2
import lombok.Getter;
3

4
/**
5
 * 订单事件枚举
6
 *
7
 * @author mydlq
8
 */
9
@Getter
10
@AllArgsConstructor
11
public enum OrderEvent {
12
  // 支付
13
  PAY("支付" ),
14
  // 发货
15
  SHIP("发货" ),
16
  // 收货
17
  RECEIVE("收货" ),
18
  // 取消
19
  CANCEL("取消" ),
20
  ;
21

22
  private final String desc;
23

24
  @Override
25
  public String toString() {
26
    return this.name() + "_" + desc;
27
  }
28
}

1
import club.mydlq.example.enums.OrderState;
2
import lombok.AllArgsConstructor;
3
import lombok.Data;
4

5
/**
6
 * 订单信息实体类
7
 *
8
 * @author mydlq
9
 */
10
@Data
11
@AllArgsConstructor
12
public class Order {
13
  /**
14
   * 订单ID
15
   */
16
  private Long orderId;
17
  /**
18
   * 订单状态
19
   */
20
  private OrderState orderState;
21
}

1
import club.mydlq.example.enums.OrderState;
2
import club.mydlq.example.model.Order;
3
import com.alibaba.cola.statemachine.Condition;
4
import org.springframework.stereotype.Component;
5

6
/**
7
 * 待发货状态转换条件
8
 * (1) CREATED(已创建) --> PENDING_SHIPMENT(待发货)
9
 *
10
 * @author mydlq
11
 */
12
@Component
13
public class PendingShipmentCondition implements Condition<Order> {
14

15
    @Override
16
    public boolean isSatisfied(Order context) {
17
        return context != null
18
                && context.getOrderId() != null
19
                && context.getOrderState() == OrderState.CREATED;
20
    }
21

22
}

1
import club.mydlq.example.enums.OrderState;
2
import club.mydlq.example.model.Order;
3
import com.alibaba.cola.statemachine.Condition;
4
import org.springframework.stereotype.Component;
5

6
/**
7
 * 已发货状态转换条件
8
 * (1) PENDING_SHIPMENT(待发货) --> SHIPPED(已发货)
9
 *
10
 * @author mydlq
11
 */
12
@Component
13
public class ShippedCondition implements Condition<Order> {
14

15
    @Override
16
    public boolean isSatisfied(Order context) {
17
        return context != null
18
                && context.getOrderId() != null
19
                && context.getOrderState() == OrderState.PENDING_SHIPMENT;
20
    }
21

22
}

1
import club.mydlq.example.enums.OrderState;
2
import club.mydlq.example.model.Order;
3
import com.alibaba.cola.statemachine.Condition;
4
import org.springframework.stereotype.Component;
5

6
/**
7
 * 已收货状态转换条件
8
 * (1) SHIPPED(已发货) --> RECEIVED(已收货)
9
 *
10
 * @author mydlq
11
 */
12
@Component
13
public class ReceivedCondition implements Condition<Order> {
14

15
    @Override
16
    public boolean isSatisfied(Order context) {
17
        return context != null
18
                && context.getOrderId() != null
19
                && context.getOrderState() == OrderState.SHIPPED;
20
    }
21

22
}

1
import club.mydlq.example.enums.OrderState;
2
import club.mydlq.example.model.Order;
3
import com.alibaba.cola.statemachine.Condition;
4
import org.springframework.stereotype.Component;
5

6
/**
7
 * 已关闭状态转换条件
8
 * (1) CREATED(已创建)          --> CLOSED(已关闭)
9
 * (2) PENDING_SHIPMENT(待发货) --> CLOSED(已关闭)
10
 * (3) SHIPPED(已发货)          --> CLOSED(已关闭)
11
 *
12
 * @author mydlq
13
 */
14
@Component
15
public class ClosedCondition implements Condition<Order> {
16

17
    @Override
18
    public boolean isSatisfied(Order context) {
19
        return context != null
20
                && context.getOrderId() != null
21
                && (context.getOrderState() == OrderState.CREATED
22
                        || context.getOrderState() == OrderState.PENDING_SHIPMENT
23
                        || context.getOrderState() == OrderState.SHIPPED);
24
    }
25

26
}

1
import club.mydlq.example.enums.OrderEvent;
2
import club.mydlq.example.enums.OrderState;
3
import club.mydlq.example.mapper.OrderMapper;
4
import club.mydlq.example.model.Order;
5
import com.alibaba.cola.statemachine.Action;
6
import jakarta.annotation.Resource;
7
import lombok.extern.slf4j.Slf4j;
8
import org.springframework.stereotype.Component;
9

10
/**
11
 * 订单状态转换动作
12
 *
13
 * @author mydlq
14
 */
15
@Slf4j
16
@Component
17
public class OrderAction implements Action<OrderState, OrderEvent, Order> {
18

19
    @Resource
20
    private OrderMapper orderMapper;
21

22
    @Override
23
    public void execute(OrderState from, OrderState to, OrderEvent event, Order context) {
24
        // 打印日志
25
        System.out.printf("订单ID:%s: %s -> (%s) -> %s %n", context.getOrderId(), from, event, to);
26
        // 更新订单状态
27
        context.setOrderState(to);
28
        orderMapper.update(context);
29
    }
30

31
}

1
import club.mydlq.example.config.action.*;
2
import club.mydlq.example.config.condition.ClosedCondition;
3
import club.mydlq.example.config.condition.PendingShipmentCondition;
4
import club.mydlq.example.config.condition.ReceivedCondition;
5
import club.mydlq.example.config.condition.ShippedCondition;
6
import club.mydlq.example.enums.OrderEvent;
7
import club.mydlq.example.enums.OrderState;
8
import club.mydlq.example.model.Order;
9
import com.alibaba.cola.statemachine.StateMachine;
10
import com.alibaba.cola.statemachine.builder.StateMachineBuilder;
11
import com.alibaba.cola.statemachine.builder.StateMachineBuilderFactory;
12
import jakarta.annotation.Resource;
13
import org.springframework.context.annotation.Bean;
14
import org.springframework.context.annotation.Configuration;
15

16
/**
17
 * 订单状态机配置
18
 *
19
 * @author mydlq
20
 */
21
@Configuration
22
public class OrderStateMachineConfig {
23

24
  /**
25
   * 条件
26
   */
27
  @Resource(name = "pendingShipmentCondition")
28
  private PendingShipmentCondition pendingShipmentCondition;
29
  @Resource(name = "shippedCondition")
30
  private ShippedCondition shippedCondition;
31
  @Resource(name = "receivedCondition")
32
  private ReceivedCondition receivedCondition;
33
  @Resource(name = "closedCondition")
34
  private ClosedCondition closedCondition;
35
  /**
36
   * 动作
37
   */
38
  @Resource(name = "orderAction")
39
  private OrderAction orderAction;
40

41
  /**
42
   * 状态机ID
43
   */
44
  private static final String STATE_MACHINE_ID = "orderStateMachine";
45

46
  @Bean("orderStateMachine")
47
  public StateMachine<OrderState, OrderEvent, Order> orderStateMachine() {
48
    // (1) 生成一个状态机builder
49
    StateMachineBuilder<OrderState, OrderEvent, Order> builder = StateMachineBuilderFactory.create();
50

51
    // (2) 通过使用builder配置外部状态转换
52
    // - ①状态转换规则1: CREATED(已创建) -> PAY(支付) -> PENDING_SHIPMENT(待发货)
53
    builder.externalTransition()
54
            .from(OrderState.CREATED).to(OrderState.PENDING_SHIPMENT).on(OrderEvent.PAY)
55
            .when(pendingShipmentCondition)
56
            .perform(orderAction);
57
    // - ②状态转换规则2: PENDING_SHIPMENT(待发货) -> SHIP(发货) -> SHIPPED(已发货)
58
    builder.externalTransition()
59
            .from(OrderState.PENDING_SHIPMENT).to(OrderState.SHIPPED).on(OrderEvent.SHIP)
60
            .when(shippedCondition)
61
            .perform(orderAction);
62
    // - ③状态转换规则3: SHIPPED(已发货) -> RECEIVE(收货) -> RECEIVED(已收货)
63
    builder.externalTransition()
64
            .from(OrderState.SHIPPED).to(OrderState.RECEIVED).on(OrderEvent.RECEIVE)
65
            .when(receivedCondition)
66
            .perform(orderAction);
67
    // - ④状态转换规则4:
68
    //     CREATED(已创建)          -> CANCEL(取消) -> CLOSED(已关闭)
69
    //     PENDING_SHIPMENT(待发货) -> CANCEL(取消) -> CLOSED(已关闭)
70
    //     SHIPPED(已发货)          -> CANCEL(取消) -> CLOSED(已关闭)
71
    builder.externalTransitions()
72
            .fromAmong(OrderState.CREATED,
73
                    OrderState.PENDING_SHIPMENT,
74
                    OrderState.SHIPPED)
75
            .to(OrderState.CLOSED)
76
            .on(OrderEvent.CANCEL)
77
            .when(closedCondition)
78
            .perform(orderAction);
79

80
    // (3) 构建状态机
81
    StateMachine<OrderState, OrderEvent, Order> orderStateMachine = builder.build(STATE_MACHINE_ID);
82

83
    // (4) 输出状态机转换流程plantUML
84
    System.out.println(orderStateMachine.generatePlantUML());
85

86
    return orderStateMachine;
87
  }
88

89
}

1
import club.mydlq.example.model.Order;
2
import org.apache.ibatis.annotations.Mapper;
3

4
/**
5
 * 订单 Mapper
6
 *
7
 * @author mydlq
8
 */
9
@Mapper
10
public interface OrderMapper {
11
  /**
12
   * 根据ID查询订单信息
13
   *
14
   * @param orderId 订单ID
15
   * @return 执行结果
16
   */
17
  Order selectByOrderId(Long orderId);
18

19
  /**
20
   * 保存订单信息
21
   *
22
   * @param order 订单信息
23
   * @return 执行结果
24
   */
25
  int save(Order order);
26

27
  /**
28
   * 更新订单信息
29
   *
30
   * @param order 订单信息
31
   * @return 执行结果
32
   */
33
  int update(Order order);
34
}

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
4
<mapper namespace="club.mydlq.example.mapper.OrderMapper">
5

6
    <resultMap id="BaseResultMap" type="club.mydlq.example.model.Order">
7
        <result property="orderId" column="order_id"/>
8
        <result property="orderState" column="order_state"/>
9
    </resultMap>
10

11
    <!--根据ID查询订单信息-->
12
    <select id="selectByOrderId" parameterType="java.lang.Long" resultMap="BaseResultMap">
13
        SELECT order_id, order_state
14
        FROM `order`
15
        WHERE order_id = #{orderId}
16
    </select>
17

18
    <!--保存订单信息-->
19
    <insert id="save" keyColumn="id" keyProperty="id" parameterType="club.mydlq.example.model.Order">
20
        INSERT INTO `order`(order_id, order_state)
21
        VALUES (#{orderId}, #{orderState})
22
    </insert>
23

24
    <!--更新订单信息-->
25
    <update id="update" parameterType="club.mydlq.example.model.Order">
26
        UPDATE `order`
27
        SET order_id    = #{orderId},
28
            order_state = #{orderState},
29
            update_time = NOW()
30
        WHERE order_id = #{orderId}
31
    </update>
32

33
</mapper>

1
import java.time.Instant;
2
import java.time.LocalDateTime;
3
import java.time.format.DateTimeFormatter;
4
import java.util.concurrent.atomic.AtomicInteger;
5

6
/**
7
 * 订单工具类
8
 *
9
 * @author mydlq
10
 */
11
public class OrderIdUtil {
12
    private OrderIdUtil() {
13
    }
14

15
    /**
16
     * 定义一个原子整型变量用于维护同一秒内的订单序列号
17
     */
18
    private static final AtomicInteger SEQUENCE = new AtomicInteger(1);
19
    /**
20
     * 定义一个格式化日期的工具
21
     */
22
    private static final DateTimeFormatter SDF = DateTimeFormatter.ofPattern("yyyyMMdd");
23

24
    /**
25
     * 生成订单ID
26
     *
27
     * @return 订单ID
28
     */
29
    public static Long generateOrderId() {
30
        /*
31
         * 订单ID组成: 【日期+时间戳+同一秒内的单号】
32
         * - 第1部分: 下单的日期+时间戳。比如 2024年8月13日，则表示 20240813
33
         * - 第2部分: 下单的时间戳。比如 01:20:30，转换为时间戳后则表示 04830
34
         * - 第3部分: 同一秒内下的第几单，并且认为不会超过10000单。比如在同一秒内第1001单，则表示第 1001 单
35
         */
36

37
        // 获取当前日期和时间
38
        LocalDateTime now = LocalDateTime.now();
39

40
        // 格式化年月日
41
        String dateStr = now.format(SDF);
42

43
        // 获取当前时间戳
44
        long timestamp = Instant.now().toEpochMilli();
45

46
        // 取时间戳的后五位
47
        int timestampPart = (int) (timestamp % 100000);
48

49
        // 同一秒内的序列号
50
        int sequenceNumber = SEQUENCE.getAndIncrement();
51

52
        // 认为每秒订单量不会超过10000，所以如果序列号超过9999，则说明已经到了下一秒，就需要重置序列号
53
        if (sequenceNumber >= 10000) {
54
            // 重置序列号
55
            SEQUENCE.set(0);
56
            sequenceNumber = SEQUENCE.getAndIncrement();
57
        }
58

59
        // 构造订单ID
60
        return Long.parseLong(dateStr +
61
                String.format("%05d", timestampPart) +
62
                String.format("%04d", sequenceNumber));
63
    }
64

65
}

1
/**
2
 * 订单 Service
3
 *
4
 * @author mydlq
5
 */
6
public interface OrderService {
7
  /**
8
   * 创建订单
9
   * @return 订单ID
10
   */
11
  Long create();
12

13
  /**
14
   * 支付
15
   * @param orderId 订单ID
16
   */
17
  void pay(Long orderId);
18

19
  /**
20
   * 发货
21
   * @param orderId 订单ID
22
   */
23
  void ship(Long orderId);
24

25
  /**
26
   * 确认收货
27
   * @param orderId 订单ID
28
   */
29
  void receive(Long orderId);
30

31
  /**
32
   * 取消订单
33
   * @param orderId 订单ID
34
   */
35
  void cancel(Long orderId);
36
}

1
import club.mydlq.example.enums.OrderEvent;
2
import club.mydlq.example.enums.OrderState;
3
import club.mydlq.example.mapper.OrderMapper;
4
import club.mydlq.example.model.Order;
5
import club.mydlq.example.service.OrderService;
6
import club.mydlq.example.utils.OrderIdUtil;
7
import com.alibaba.cola.statemachine.StateMachine;
8
import jakarta.annotation.Resource;
9
import org.springframework.stereotype.Service;
10
import org.springframework.transaction.annotation.Transactional;
11

12
/**
13
 * 订单 Service
14
 *
15
 * @author mydlq
16
 */
17
@Service
18
public class OrderServiceImpl implements OrderService {
19
    /**
20
     * 订单持久化 Mapper
21
     */
22
    @Resource
23
    private OrderMapper orderMapper;
24
    /**
25
     * 订单状态机
26
     */
27
    @Resource(name = "orderStateMachine")
28
    StateMachine<OrderState, OrderEvent, Order> orderOperaMachine;
29

30
    @Override
31
    @Transactional(rollbackFor = Exception.class)
32
    public Long create() {
33
        // 生成订单ID
34
        Long orderId = OrderIdUtil.generateOrderId();
35
        // 创建订单并设置订单初始状态
36
        Order order = new Order(orderId, OrderState.CREATED);
37
        // 执行订单创建的其它操作
38
        // ...
39
        // 保存订单信息
40
        orderMapper.save(order);
41
        return orderId;
42
    }
43

44
    @Override
45
    @Transactional(rollbackFor = Exception.class)
46
    public void pay(Long orderId) {
47
        // 查询订单信息
48
        Order order = this.queryOrder(orderId);
49
        // 触发状态机状态变更
50
        OrderState targetState = orderOperaMachine.fireEvent(order.getOrderState(), OrderEvent.PAY, order);
51
        // 验证目标状态
52
        if (targetState != OrderState.PENDING_SHIPMENT) {
53
            throw new RuntimeException("订单ID=" + orderId + "支付失败");
54
        }
55
        // 执行订单支付的其它操作
56
        // ......
57
    }
58

59
    @Override
60
    @Transactional(rollbackFor = Exception.class)
61
    public void ship(Long orderId) {
62
        // 查询订单信息
63
        Order order = this.queryOrder(orderId);
64
        // 触发状态机状态变更
65
        OrderState targetState = orderOperaMachine.fireEvent(order.getOrderState(), OrderEvent.SHIP, order);
66
        // 验证目标状态
67
        if (targetState != OrderState.SHIPPED) {
68
            throw new RuntimeException("订单ID " + orderId + " 发货失败");
69
        }
70
        // 执行订单发货的其它操作
71
        // ......
72
    }
73

74
    @Override
75
    @Transactional(rollbackFor = Exception.class)
76
    public void receive(Long orderId) {
77
        // 查询订单信息
78
        Order order = this.queryOrder(orderId);
79
        // 触发状态机状态变更
80
        OrderState targetState = orderOperaMachine.fireEvent(order.getOrderState(), OrderEvent.RECEIVE, order);
81
        // 验证目标状态
82
        if (targetState != OrderState.RECEIVED) {
83
            throw new RuntimeException("订单ID " + orderId + " 确认收货失败");
84
        }
85
        // 执行确认收货的其它操作
86
        // ......
87
    }
88

89
    @Override
90
    @Transactional(rollbackFor = Exception.class)
91
    public void cancel(Long orderId) {
92
        // 查询订单信息
93
        Order order = this.queryOrder(orderId);
94
        // 触发状态机状态变更
95
        OrderState targetState = orderOperaMachine.fireEvent(order.getOrderState(), OrderEvent.CANCEL, order);
96
        // 验证目标状态
97
        if (targetState != OrderState.CLOSED) {
98
            throw new RuntimeException("订单ID " + orderId + " 取消订单失败: ");
99
        }
100
        // 执行取消订单的其它操作
101
        // ......
102
    }
103

104
    /**
105
     * 查询订单信息
106
     *
107
     * @param orderId 订单ID
108
     * @return 订单信息
109
     */
110
    private Order queryOrder(Long orderId) {
111
        // 查询订单信息
112
        Order order = orderMapper.selectByOrderId(orderId);
113
        if (order == null) {
114
            throw new RuntimeException("订单ID " + orderId + " 的订单不存在");
115
        }
116
        return order;
117
    }
118

119
}