# dcy-state-machine

**Repository Path**: dcy421/dcy-state-machine

## Basic Information

- **Project Name**: dcy-state-machine
- **Description**: 状态机（spring-statemachine）状态机封装
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 2
- **Created**: 2021-11-15
- **Last Updated**: 2023-02-03

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# dcy-state-machine

## 介绍
学习状态机（spring-statemachine）  
主页：[spring-statemachine](https://spring.io/projects/spring-statemachine#overview)  
## 如何使用
### 1. 定义业务状态
```java
public enum OrderStatus implements MachineState {

    // 待支付
    WAIT_PAYMENT,

    // 待发货
    WAIT_DELIVER,

    // 待收货
    WAIT_RECEIVE,

    // 订单结束
    FINISH;

}
```
### 2. 定义业务事件
```java
public enum OrderEvent implements MachineEvent {

    // 支付
    PAYED,

    // 发货
    DELIVERY,

    // 确认收货
    RECEIVED;

}
```
### 3. 定义业务对象
```java
@Data
public class NewOrder implements MatchineObj<OrderStatus> {

    private String id;

    private String orderNo;

    private String name;

    /**
     * 状态
     */
    private String status;

    @Override
    public String matchineId() {
        return OrderStateMachineConfig.ORDER_STATE_MACHINE_ID;
    }

    @Override
    public String factoryName() {
        return OrderStateMachineConfig.ORDER_STATE_MACHINE_FACTORY_NAME;
    }

    @Override
    public String stateName() {
        return status;
    }

    @Override
    public Class<OrderStatus> machineStateEnum() {
        return OrderStatus.class;
    }
}
```
### 4. 定义业务状态机
```java
@Slf4j
@Configuration
@EnableStateMachineFactory(name = OrderStateMachineConfig.ORDER_STATE_MACHINE_FACTORY_NAME)
public class OrderStateMachineConfig extends StateMachineConfigurerAdapter<OrderStatus, OrderEvent> {

    /**
     * 订单状态机ID
     */
    public static final String ORDER_STATE_MACHINE_ID = "orderStateMachineId";
    /**
     * 订单状态机工厂名称
     */
    public static final String ORDER_STATE_MACHINE_FACTORY_NAME = "orderStateMachineFactory";

    /**
     * 状态监听器
     *
     * @param config
     * @throws Exception
     */
    @Override
    public void configure(StateMachineConfigurationConfigurer<OrderStatus, OrderEvent> config) throws Exception {
        config
                .withConfiguration()
                .machineId(ORDER_STATE_MACHINE_ID)
                .transitionConflictPolicy(TransitionConflictPolicy.CHILD)
                .regionExecutionPolicy(RegionExecutionPolicy.PARALLEL)
                .listener(listener());
    }

    private StateMachineListener<OrderStatus, OrderEvent> listener() {
        return new StateMachineListenerAdapter<OrderStatus, OrderEvent>() {
            @Override
            public void stateChanged(State<OrderStatus, OrderEvent> from, State<OrderStatus, OrderEvent> to) {
                log.info("State 改变 form {} to {}", from != null ? from.getId() : null, to.getId());
            }
        };
    }

    /**
     * 配置状态
     *
     * @param states
     * @throws Exception
     */
    @Override
    public void configure(StateMachineStateConfigurer<OrderStatus, OrderEvent> states) throws Exception {
        states
                .withStates()
                .initial(OrderStatus.WAIT_PAYMENT) //定义了初始状态
                .end(OrderStatus.FINISH) // 定义结束状态
                .states(EnumSet.allOf(OrderStatus.class)); //指定了使用上一步中定义的所有状态作为该状态机的状态定义
    }

    /**
     * 配置状态转换事件关系
     * 命名中我们很容易理解每一个迁移动作，都有来源状态source，目标状态target以及触发事件event
     *
     * @param transitions
     * @throws Exception
     */
    @Override
    public void configure(StateMachineTransitionConfigurer<OrderStatus, OrderEvent> transitions) throws Exception {
        transitions
                // 待支付 到 待发货 的事件 支付
                .withExternal().source(OrderStatus.WAIT_PAYMENT).target(OrderStatus.WAIT_DELIVER).event(OrderEvent.PAYED)
                .and()
                // 待发货 到 待收货 的事件 发货
                .withExternal().source(OrderStatus.WAIT_DELIVER).target(OrderStatus.WAIT_RECEIVE).event(OrderEvent.DELIVERY)
                .and()
                // 待收货 到 订单结束 的事件 确认收货
                .withExternal().source(OrderStatus.WAIT_RECEIVE).target(OrderStatus.FINISH).event(OrderEvent.RECEIVED);
    }
}

```
> 注意：    
> 1.状态机ID 唯一  
> 2.状态机工厂名称 唯一

### 5. 如果使用  
#### 5.1 初始化
```java
// 初始化状态
final NewOrder newOrder = new NewOrder();
newOrder.setId("222");
newOrder.setName("测试订单");
newOrder.setStatus(OrderStatus.WAIT_PAYMENT.name());
// 保存数据库操作
```
#### 5.2 业务状态流转
```java
// 正常业务逻辑
// 1.查询业务数据 知道当前是什么状态
// 2.执行什么事件
// 3.执行成功后操作哪些
final NewOrder newOrder = new NewOrder();
newOrder.setId("222");
newOrder.setName("测试订单");
newOrder.setStatus(OrderStatus.WAIT_PAYMENT.name());
stateMachineService.next(newOrder, OrderEvent.PAYED, orderStatusMatchineObj -> {
    log.info("修改状态成功");
});
```