使用状态机实现幂等性

柔情只为你懂 2024-04-22 07:15 38阅读 0赞

#### 文章目录 ####

*  背景
 *  幂等概念
 *  适用场景
 *  示例代码
 *  上述代码状态流转

## 背景 ##

在某些场景下，可以使用状态机来实现幂等性。将业务流程抽象为一个状态机，定义各个状态之间的转换规则。当收到一个请求时，根据当前状态和请求类型来判断是否允许执行操作，如果允许则执行操作并更新状态，否则拒绝操作。这样可以确保每个操作在合适的状态下执行，避免重复操作导致的问题。

## 幂等概念 ##

幂等（Idempotency）是指对于一个系统，一个具有幂等性质的操作，无论执行多少次，其结果始终保持一致。在分布式系统和网络编程中，幂等性是一种非常重要的概念。确保接口幂等性可以避免重复操作导致的数据不一致和其他潜在问题。

在计算机科学中，幂等性通常用于描述一种能够忽略重复调用的操作。例如，对于一个删除记录的操作，如果删除成功，无论执行多少次，记录都会保持被删除的状态。类似地，对于一个更新操作，如果更新成功，无论执行多少次，更新后的状态都保持不变。

## 适用场景 ##

1.  确定状态：根据业务场景，确定系统需要的状态。例如，在订单处理中，可能需要如下状态：待支付、已支付、已发货、已收货、已取消等。
2.  定义状态转换规则：针对每个状态，定义允许的操作以及操作后的新状态。例如，在待支付状态下，允许操作是支付，支付成功后状态转为已支付。
3.  操作条件判断：在执行操作之前，根据当前状态和请求类型判断是否允许执行操作。如果允许，则执行操作并更新状态；否则拒绝操作。
4.  存储状态：将状态持久化存储，例如存储在数据库中。这样，在处理请求时，可以获取当前状态，并根据状态执行相应的操作。
5.  幂等性处理：当接收到重复的请求时，可以根据当前状态判断请求是否有效。如果当前状态不允许执行请求的操作，则直接返回之前的响应结果，实现幂等性。

## 示例代码 ##

在这个示例中，创建了一个基于有限状态机的订单处理系统。我们首先定义了状态和操作的枚举类型，然后定义了一个状态转换接口。接着，我们创建了一个表示订单的类，并在主方法中初始化一个待支付的订单。

接下来，我们创建了一个状态机映射，用于存储状态转换规则。对于每个状态和操作，我们定义了一个状态转换接口的实现。在执行操作时，我们根据订单的当前状态和请求的操作来查找相应的状态转换。如果找到了合适的状态转换，就执行转换并更新订单状态。如果没有找到合适的状态转换，说明操作无效。

import java.util.HashMap;
    import java.util.Map;
    
    public class StateMachineExample {
        
    
        // 定义状态枚举
        public enum State {
        
            PENDING_PAYMENT,
            PAID,
            CANCELED
        }
    
        // 定义操作枚举
        public enum Operation {
        
            PAY,
            CANCEL
        }
    
        // 定义状态转换接口
        public interface StateTransition {
        
            State execute();
        }
    
        // 定义订单类
        public static class Order {
        
            private State state;
    
            public Order(State state) {
        
                this.state = state;
            }
    
            public State getState() {
        
                return state;
            }
    
            public void setState(State state) {
        
                this.state = state;
            }
        }
    
        public static void main(String[] args) {
        
            // 创建一个待支付的订单
            Order order = new Order(State.PENDING_PAYMENT);
    
            // 创建状态机映射
            Map<State, Map<Operation, StateTransition>> stateMachine = new HashMap<>();
    
            // *************定义状态转换规则*************//
            stateMachine.put(State.PENDING_PAYMENT, new HashMap<>());
            //待支付状态下业务规则
            stateMachine.get(State.PENDING_PAYMENT).put(Operation.PAY, () -> {
        
                System.out.println("支付成功");
                return State.PAID;
            });
            stateMachine.get(State.PENDING_PAYMENT).put(Operation.CANCEL, () -> {
        
                System.out.println("订单已取消");
                return State.CANCELED;
            });
    
            //支付状态下业务规则
            stateMachine.put(State.PAID, new HashMap<>());
            stateMachine.get(State.PAID).put(Operation.PAY, () -> {
        
                System.out.println("重复支付，忽略");
                return State.PAID;
            });
    
            //订单取消状态下业务规则
            stateMachine.put(State.CANCELED, new HashMap<>());
            stateMachine.get(State.CANCELED).put(Operation.PAY, () -> {
        
                System.out.println("订单已取消，无法支付");
                return State.CANCELED;
            });
            // *****************************************//
            
            
    
            // 执行操作
            executeOperation(order, stateMachine, Operation.PAY);
            executeOperation(order, stateMachine, Operation.PAY);
            executeOperation(order, stateMachine, Operation.CANCEL);
        }
    
        // 根据当前状态和操作执行状态转换
        private static void executeOperation(Order order, Map<State, Map<Operation, StateTransition>> stateMachine, Operation operation) {
        
            State currentState = order.getState();
            StateTransition transition = stateMachine.get(currentState).get(operation);
    
            if (transition != null) {
        
                State newState = transition.execute();
                order.setState(newState);
            } else {
        
                System.out.println("操作无效");
            }
        }
    }

**执行结果**  
![在这里插入图片描述][52dffc60daf54142bbc159dc60871b00.png]

## 上述代码状态流转 ##

1.  当订单处于 `PENDING_PAYMENT`（待支付）状态时，执行 `PAY` 操作会将订单状态变为 `PAID`（已支付）；执行 `CANCEL` 操作会将订单状态变为 `CANCELED`（已取消）。
2.  当订单处于 `PAID`（已支付）状态时，再次执行 `PAY` 操作会被忽略，订单状态保持为 `PAID`。
3.  当订单处于 `CANCELED`（已取消）状态时，不存在定义的状态转换。

**这样就保证在多次操作的时候只有一个结果，就保证了幂等性**  
![在这里插入图片描述][f61fbe3979c44532ba7828aa9d56e32a.png]

[52dffc60daf54142bbc159dc60871b00.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/6e5166f04f7140dfaf97321452bfd33e.png
[f61fbe3979c44532ba7828aa9d56e32a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/bb871d97db03467bb8cc58ec4913e7d8.png