徹底搞懂Spring狀態機原理，實現訂單與物流解耦

Tom彈架構發表於2021-11-16

本文節選自《設計模式就該這樣學》

1　狀態模式的UML類圖

狀態模式的UML類圖如下圖所示。

file

2　使用狀態模式實現登入狀態自由切換

當我們在社群閱讀文章時，如果覺得文章寫得很好，我們就會評論、收藏兩連發。如果處於登入情況下，則可以直接做評論、收藏這些行為。否則，跳轉到登入介面，登入後再繼續執行先前的動作。這裡涉及的狀態有兩種：登入與未登入；行為有兩種：評論和收藏。下面使用狀態模式來實現這個邏輯，程式碼如下。
首先建立抽象狀態角色UserState類。


public abstract class UserState {
    protected AppContext context;

    public void setContext(AppContext context) {
        this.context = context;
    }

    public abstract void favorite();

    public abstract void comment(String comment);
}

然後建立登入狀態LogInState類。


public class LoginInState extends UserState {
    @Override
    public void favorite() {
        System.out.println("收藏成功！");
    }

    @Override
    public void comment(String comment) {
        System.out.println(comment);
    }
}

建立未登入狀態UnloginState類。


public class UnLoginState extends UserState {
    @Override
    public void favorite() {
        this.switch2Login();
        this.context.getState().favorite();
    }

    @Override
    public void comment(String comment) {
        this.switch2Login();
        this.context.getState().comment(comment);
    }

    private void switch2Login() {
        System.out.println("跳轉到登入頁面!");
        this.context.setState(this.context.STATE_LOGIN);
    }
}

建立上下文角色AppContext類。


public class AppContext {
    public static final UserState STATE_LOGIN = new LoginInState();
    public static final UserState STATE_UNLOGIN = new UnLoginState();
    private UserState currentState = STATE_UNLOGIN;
    {
        STATE_LOGIN.setContext(this);
        STATE_UNLOGIN.setContext(this);
    }

    public void setState(UserState state) {
        this.currentState = state;
        this.currentState.setContext(this);
    }

    public UserState getState() {
        return this.currentState;
    }

    public void favorite() {
        this.currentState.favorite();
    }

    public void comment(String comment) {
        this.currentState.comment(comment);
    }
}

最後編寫客戶端測試程式碼。


public static void main(String[] args) {
        AppContext context = new AppContext();
        context.favorite();
        context.comment("評論: 好文章，360個贊!");
}

執行結果如下圖所示。

file

3　使用狀態機實現訂單狀態流轉控制

狀態機是狀態模式的一種應用，相當於上下文角色的一個升級版。在工作流或遊戲等各種系統中有大量使用，如各種工作流引擎，它幾乎是狀態機的子集和實現，封裝狀態的變化規則。Spring也提供了一個很好的解決方案。Spring中的元件名稱就叫作狀態機（StateMachine）。狀態機幫助開發者簡化狀態控制的開發過程，讓狀態機結構更加層次化。下面用Spring狀態機模擬一個訂單狀態流轉的過程。

3.1 新增依賴。


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

3.2 建立訂單實體Order類。


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.3 建立訂單狀態列舉類和狀態轉換列舉類。


/**
 * 訂單狀態
 */
public enum OrderStatus {
    //待支付，待發貨，待收貨，訂單結束
    WAIT_PAYMENT, WAIT_DELIVER, WAIT_RECEIVE, FINISH;
}

/**
 * 訂單狀態改變事件
 */
public enum OrderStatusChangeEvent {
    //支付，發貨，確認收貨
    PAYED, DELIVERY, RECEIVED;
}

3.4 新增狀態流轉配置。


/**
 * 訂單狀態機配置
 */
@Configuration
@EnableStateMachine(name = "orderStateMachine")
public class OrderStateMachineConfig extends StateMachineConfigurerAdapter<OrderStatus, OrderStatusChangeEvent> {
 
    /**
     * 配置狀態
     * @param states
     * @throws Exception
     */
    public void configure(StateMachineStateConfigurer<OrderStatus, OrderStatusChangeEvent> 	states) throws Exception {
        states
                .withStates()
                .initial(OrderStatus.WAIT_PAYMENT)
                .states(EnumSet.allOf(OrderStatus.class));
    }
 
    /**
     * 配置狀態轉換事件關係
     * @param transitions
     * @throws Exception
     */
    public void configure(StateMachineTransitionConfigurer<OrderStatus, OrderStatusChangeEvent> 	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<Object, Object, 			Order>() {
            @Override
            public void write(StateMachineContext<Object, Object> context, Order order) throws 			Exception {
                //此處並沒有進行持久化操作
            }
 
            @Override
            public StateMachineContext<Object, Object> read(Order order) throws Exception {
                //此處直接獲取Order中的狀態，其實並沒有進行持久化讀取操作
                return new DefaultStateMachineContext(order.getStatus(), null, null, null);
            }
        });
    }
}

3.5 新增訂單狀態監聽器。


@Component("orderStateListener")
@WithStateMachine(name = "orderStateMachine")
public class OrderStateListenerImpl{
 
    @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER")
    public boolean payTransition(Message<OrderStatusChangeEvent> 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<OrderStatusChangeEvent> 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<OrderStatusChangeEvent> message){
        Order order = (Order) message.getHeaders().get("order");
        order.setStatus(OrderStatus.FINISH);
        System.out.println("收貨，狀態機反饋資訊：" + message.getHeaders().toString());
        return true;
    }
}

3.6 建立IOrderService介面。


public interface IOrderService {
    //建立新訂單
    Order create();
    //發起支付
    Order pay(int id);
    //訂單發貨
    Order deliver(int id);
    //訂單收貨
    Order receive(int id);
    //獲取所有訂單資訊
    Map<Integer, Order> getOrders();
}

3.7 在Service業務邏輯中應用。


@Service("orderService")
public class OrderServiceImpl implements IOrderService {

    @Autowired
    private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine;
 
    @Autowired
    private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, Order> persister;
 
    private int id = 1;
    private Map<Integer, Order> 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<Integer, Order> getOrders() {
        return orders;
    }
 
 
    /**
     * 傳送訂單狀態轉換事件
     *
     * @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;
    }
}

3.8 編寫客戶端測試程式碼。



@SpringBootApplication
public class Test {
    public static void main(String[] args) {

        Thread.currentThread().setName("主執行緒");

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

        IOrderService orderService = (IOrderService)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());

    }
}

通過這個真實的業務案例，相信小夥伴們已經對狀態模式有了一個非常深刻的理解。
關注微信公眾號『 Tom彈架構』回覆“設計模式”可獲取完整原始碼。

【推薦】Tom彈架構：30個設計模式真實案例（附原始碼），挑戰年薪60W不是夢

本文為“Tom彈架構”原創，轉載請註明出處。技術在於分享，我分享我快樂！
如果本文對您有幫助，歡迎關注和點贊；如果您有任何建議也可留言評論或私信，您的支援是我堅持創作的動力。關注微信公眾號『 Tom彈架構』可獲取更多技術乾貨！

徹底搞懂 Channel 實現原理
2023-01-17
徹底搞懂https原理
2020-08-21
HTTP
從原理到實戰，徹底搞懂Nginx
2020-01-09
Nginx
看完讓你徹底搞懂Websocket原理
2021-09-09
Web
PC微信機器人介面api之徹底搞懂hook原理及手動實現
2021-06-25
機器人APIHook
一篇文章徹底搞懂java動態代理的實現
2017-12-22
Java
從原理到實戰，徹底搞懂Nginx（高階篇）
2020-01-13
Nginx
徹底搞懂徹底搞懂事件驅動模型 - Reactor
2021-06-18
事件模型React
徹底搞懂 RxJava
2016-05-05
RxJava
Spring狀態機（FSM），讓訂單狀態流轉如絲般順滑
2024-03-12
Spring
徹底理解閉包實現原理
2022-10-26
兩張圖徹底搞懂MyBatis的Mapper原理！
2019-03-08
MyBatisAPP
徹底搞懂Composer自動載入原理
2021-11-01
用es5實現es6的promise，徹底搞懂promise的原理
2018-05-20
Promise
徹底搞懂HTTPS的加密機制
2018-09-05
HTTP加密
一張圖徹底搞懂Spring迴圈依賴
2021-10-29
Spring
深入詳解Java反射機制與底層實現原理?
2023-01-04
Java反射
徹底搞懂JavaScript作用域
2019-02-07
JavaScript
徹底搞懂Bean載入
2019-01-08
Bean
徹底搞懂 Git-Rebase
2018-12-24
Git
徹底搞懂同步非同步與阻塞非阻塞
2023-02-15
非同步
使用有限狀態機原理實現英文分詞
2017-12-10
分詞
徹底搞懂Python 中的 import 與 from import
2020-12-24
PythonImport
深入JavaScript系列（四）：徹底搞懂this
2018-12-13
JavaScript
徹底搞懂 RxJava — 基礎篇
2017-05-17
RxJava
徹底搞懂 RxJava — 中級篇
2017-05-17
RxJava
徹底搞懂 RxJava — 高階篇
2017-05-17
RxJava
徹底搞懂訪問者模式的靜態、動態和偽動態分派
2021-11-24
模式
資料庫訂單狀態
2015-05-29
資料庫
SpringBoot+MongoDB實現物流訂單系統
2020-10-17
Spring BootMongoDB
幫你徹底搞懂JS中的prototype、__proto__與constructor（圖解）
2019-04-11
JSStruct圖解
實踐這一次,徹底搞懂瀏覽器快取機制
2019-01-21
瀏覽器快取
徹底搞懂JavaScript中的繼承
2019-08-06
JavaScript繼承
徹底搞懂Python中的類
2021-09-11
Python
兩萬字長文，徹底搞懂Kafka！
2021-08-13
Kafka
[原始碼解讀]一文徹底搞懂Events模組
2019-09-23
原始碼
[python]有限狀態機（FSM）簡單實現
2007-02-15
Python
SAP-PP-CO 生產訂單狀態詳解
2022-05-16