2. 程式人生 > 程式設計 >Spring StateMachine 狀態機引擎在專案中的應用(二)--持久化

Spring StateMachine 狀態機引擎在專案中的應用(二)--持久化

阿新 • • 發佈：2019-12-31

背景

每次用到的時候新建立一個狀態機，太奢侈了，官方檔案裡面也提到過這點。

而且創建出來的例項，其狀態也跟當前訂單的不符；spring statemachine暫時不支援每次建立時指定當前狀態，所以對狀態機引擎例項的持久化，就成了必須要考慮的問題。（不過在後續版本有直接指定狀態的方式，這個後面會寫）

擴充套件一下

這裡擴充套件說明一下，狀態機引擎的持久化一直是比較容易引起討論的，因為很多場景並不希望再多儲存一些中間非業務資料，之前在淘寶工作時，淘寶的訂單系統tradeplatform自己實現了一套workflowEngine，其實說白了也就是一套狀態機引擎，所有的配置都放在xml中，每次每個環節的請求過來，都會重新建立一個狀態機引擎例項，並根據當前的訂單狀態來設定引擎例項的狀態。

workflowEngine沒有做持久化，私下裡猜測下這樣實現的原因：1、淘係資料量太大，一天幾千萬筆訂單，額外的資訊儲存就要耗費很多儲存資源；2、完全自主開發的狀態機引擎，可定製化比較強，根據自己的業務需要可以按自己的需要處理。

而反過來，spring statemachine並不支援隨意指定初始狀態，每次建立都是固定的初始化狀態，其實也只是有好處的，標準版流程，而且可以保證安全，每個節點都是按照事先定義好的流程跑下來，而不是隨意指定。所以，狀態機引擎例項的持久化，我們這次的主題，那就繼續聊下去吧。

持久化

spring statemachine 本身支援了記憶體、redis及db的持久化，記憶體持久化就不說了，看原始碼實現就是放在了hashmap裡，平時也沒誰專案中可以這麼奢侈，啥啥都放在記憶體中，而且一旦重啟…..?。下面詳細說下利用redis進行的持久化操作。

依賴引入

spring statemachine 本身是提供了一個redis儲存的元件的，在1.2.10.RELEASE版本中，這個元件需要通過依賴引入，同時需要引入的還有序列化的元件kyro、data-common：

gradle引入依賴 (build.gradle 或者 libraries.gradle，由自己專案的gradle組織方式來定)：

compile 'org.springframework.statemachine:spring-statemachine-core:1.2.10.RELEASE'
compile 'org.springframework.statemachine:spring-statemachine-data-common:1.2.10.RELEASE'
compile 'org.springframework.statemachine:spring-statemachine-kyro:1.2.10.RELEASE'
compile 'org.springframework.statemachine:spring-statemachine-redis:1.2.10.RELEASE'複製程式碼

當然如果是maven的話，一樣的，pom.xml如下：

<dependencies>
    <dependency>
        <groupId>org.springframework.statemachine</groupId>
        <artifactId>spring-statemachine-core</artifactId>
        <version>1.2.10.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.statemachine</groupId>
        <artifactId>spring-statemachine-data-common</artifactId>
        <version>1.2.10.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.statemachine</groupId>
        <artifactId>spring-statemachine-kyro</artifactId>
        <version>1.2.10.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.statemachine</groupId>
        <artifactId>spring-statemachine-redis</artifactId>
        <version>1.2.10.RELEASE</version>
    </dependency>
</dependencies>複製程式碼

先把持久化的呼叫軌跡說明下

spring-statemachine-持久化.png

說明：

spring statemachine持久化時，採用了三層結構設計，persister —>persist —>repository。

  • 其中persister中封裝了write和restore兩個方法，分別用於持久化寫及反序列化讀出。
  • persist只是一層皮，主要還是呼叫repository中的實際實現；但是在這裡，由於redis儲存不保證百分百資料安全，所以我實現了一個自定義的persist，其中封裝了資料寫入db、從db中讀取的邏輯。
  • repository中做了兩件事兒
    • 序列化/反序列化資料，將引擎例項與二進位制陣列互相轉換
    • 讀、寫redis
詳細的實現

Persister

import org.springframework.beans.factory.annotation.Autowire;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.statemachine.StateMachinePersist;
import org.springframework.statemachine.persist.StateMachinePersister;
import org.springframework.statemachine.redis.RedisStateMachinePersister;

@Configuration
public class BizOrderRedisStateMachinePersisterConfig {

    @Autowired
    private StateMachinePersist bizOrderRedisStateMachineContextPersist;

    @Bean(name = "bizOrderRedisStateMachinePersister",autowire = Autowire.BY_TYPE)
    public StateMachinePersister<BizOrderStatusEnum,BizOrderStatusChangeEventEnum,String> bizOrderRedisStateMachinePersister() {
        return new RedisStateMachinePersister<>(bizOrderRedisStateMachineContextPersist);
    }

}複製程式碼

這裡採用官方samples中初始化的方式，通過@Bean註解來建立一個RedisStateMachinePersister例項，注意其中傳遞進去的Persist為自定義的bizOrderRedisStateMachineContextPersist

Persist

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.messaging.MessageHeaders;
import org.springframework.statemachine.StateMachineContext;
import org.springframework.statemachine.StateMachinePersist;
import org.springframework.statemachine.kryo.MessageHeadersSerializer;
import org.springframework.statemachine.kryo.StateMachineContextSerializer;
import org.springframework.statemachine.kryo.UUIDSerializer;
import org.springframework.statemachine.redis.RedisStateMachineContextRepository;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
import java.util.Base64;
import java.util.UUID;

@Component("bizOrderRedisStateMachineContextPersist")
public class BizOrderRedisStateMachineContextPersist implements StateMachinePersist<BizOrderStatusEnum,String> {

    @Autowired
    @Qualifier("redisStateMachineContextRepository")
    private RedisStateMachineContextRepository<BizOrderStatusEnum,BizOrderStatusChangeEventEnum> redisStateMachineContextRepository;

    @Autowired
    private BizOrderStateMachineContextRepository bizOrderStateMachineContextRepository;

    //  加入儲存到DB的資料repository,biz_order_state_machine_context表結構：
    //  bizOrderId
    //  contextStr
    //  curStatus
    //  updateTime

    /**
     * Write a {@link StateMachineContext} into a persistent store
     * with a context object {@code T}.
     *
     * @param context    the context
     * @param contextObj the context ojb
     * @throws Exception the exception
     */
    @Override
    @Transactional
    public void write(StateMachineContext<BizOrderStatusEnum,BizOrderStatusChangeEventEnum> context,String contextObj) throws Exception {

        redisStateMachineContextRepository.save(context,contextObj);
        //  save to db
        BizOrderStateMachineContext queryResult = bizOrderStateMachineContextRepository.selectByOrderId(contextObj);

        if (null == queryResult) {
            BizOrderStateMachineContext bosmContext = new BizOrderStateMachineContext(contextObj,context.getState().getStatus(),serialize(context));
            bizOrderStateMachineContextRepository.insertSelective(bosmContext);
        } else {
            queryResult.setCurOrderStatus(context.getState().getStatus());
            queryResult.setContext(serialize(context));
            bizOrderStateMachineContextRepository.updateByPrimaryKeySelective(queryResult);
        }
    }

    /**
     * Read a {@link StateMachineContext} from a persistent store
     * with a context object {@code T}.
     *
     * @param contextObj the context ojb
     * @return the state machine context
     * @throws Exception the exception
     */
    @Override
    public StateMachineContext<BizOrderStatusEnum,BizOrderStatusChangeEventEnum> read(String contextObj) throws Exception {

        StateMachineContext<BizOrderStatusEnum,BizOrderStatusChangeEventEnum> context = redisStateMachineContextRepository.getContext(contextObj);
        //redis 訪快取擊穿
        if (null != context && BizOrderConstants.STATE_MACHINE_CONTEXT_ISNULL.equalsIgnoreCase(context.getId())) {
            return null;
        }
        //redis 為空走db
        if (null == context) {
            BizOrderStateMachineContext boSMContext = bizOrderStateMachineContextRepository.selectByOrderId(contextObj);
            if (null != boSMContext) {
                context = deserialize(boSMContext.getContext());
                redisStateMachineContextRepository.save(context,contextObj);
            } else {
                context = new StateMachineContextIsNull();
                redisStateMachineContextRepository.save(context,contextObj);
            }
        }
        return context;
    }

    private String serialize(StateMachineContext<BizOrderStatusEnum,BizOrderStatusChangeEventEnum> context) throws UnsupportedEncodingException {
        Kryo kryo = kryoThreadLocal.get();
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        Output output = new Output(out);
        kryo.writeObject(output,context);
        output.close();
        return Base64.getEncoder().encodeToString(out.toByteArray());
    }

    @SuppressWarnings("unchecked")
    private StateMachineContext<BizOrderStatusEnum,BizOrderStatusChangeEventEnum> deserialize(String data) throws UnsupportedEncodingException {
        if (StringUtils.isEmpty(data)) {
            return null;
        }
        Kryo kryo = kryoThreadLocal.get();
        ByteArrayInputStream in = new ByteArrayInputStream(Base64.getDecoder().decode(data));
        Input input = new Input(in);
        return kryo.readObject(input,StateMachineContext.class);
    }

    private static final ThreadLocal<Kryo> kryoThreadLocal = new ThreadLocal<Kryo>() {

        @SuppressWarnings("rawtypes")
        @Override
        protected Kryo initialValue() {
            Kryo kryo = new Kryo();
            kryo.addDefaultSerializer(StateMachineContext.class,new StateMachineContextSerializer());
            kryo.addDefaultSerializer(MessageHeaders.class,new MessageHeadersSerializer());
            kryo.addDefaultSerializer(UUID.class,new UUIDSerializer());
            return kryo;
        }
    };
}複製程式碼

說明：

  1. 如果只是持久化到redis中，那麼BizOrderStateMachineContextRepository相關的所有內容均可刪除。不過由於redis無法承諾百分百的資料安全，所以我這裡做了兩層持久化，redis+db
  2. 存入redis中的資料預設採用kryo來序列化及反序列化，RedisStateMachineContextRepository中實現了對應程式碼。但是spring statemachine預設的db儲存比較複雜，需要建立多張表，參加下圖：

jpa-table.png

這裡需要額外建立5張表，分別儲存ActionGuardStateStateMachineTransition，比較複雜。

  1. 所以這裡建立了一張表bizorderstatemachinecontext，結構很簡單：bizOrderId,contextStr,curStatus,updateTime，其中關鍵是contextStr，用於儲存與redis中相同的內容
Repository

有兩個repository，一個是spring statemachine提供的redisRepo，另一個則是專案中基於mybatis的repo，先是db-repo：

   import org.apache.ibatis.annotations.Param;
   import org.springframework.data.domain.Pageable;
   import org.springframework.stereotype.Repository;
   
   import java.util.List;
   
   @Repository
   public interface BizOrderStateMachineContextRepository {
   
         int deleteByPrimaryKey(Long id);
       
       BizOrderStateMachineContext selectByOrderId(String bizOrderId);
       
       int updateByPrimaryKey(BizOrderStateMachineContext BizOrderStateMachineContext);
   
       int updateByPrimaryKeySelective(BizOrderStateMachineContext BizOrderStateMachineContext);
   
       int insertSelective(BizOrderStateMachineContext BizOrderStateMachineContext);
   
       int selectCount(BizOrderStateMachineContext BizOrderStateMachineContext);
   
       List<BizOrderStateMachineContext> selectPage(@Param("BizOrderStateMachineContext") BizOrderStateMachineContext BizOrderStateMachineContext,@Param("pageable") Pageable pageable);
       
   }複製程式碼

然後是redisRepo

   import org.springframework.beans.factory.annotation.Autowire;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.data.redis.connection.RedisConnectionFactory;
   import org.springframework.statemachine.redis.RedisStateMachineContextRepository;
   
   @Configuration
   public class BizOrderRedisStateMachineRepositoryConfig {
   
       /**
        * 接入asgard後，redis的connectionFactory可以通過serviceName + InnerConnectionFactory來注入
        */
       @Autowired
       private RedisConnectionFactory finOrderRedisInnerConnectionFactory;
   
       @Bean(name = "redisStateMachineContextRepository",autowire = Autowire.BY_TYPE)
       public RedisStateMachineContextRepository<BizOrderStatusEnum,BizOrderStatusChangeEventEnum> redisStateMachineContextRepository() {
   
           return new RedisStateMachineContextRepository<>(finOrderRedisInnerConnectionFactory);
       }
   }
   複製程式碼

使用方式

    @Autowired
    @Qualifier("bizOrderRedisStateMachinePersister")
    private StateMachinePersister<BizOrderStatusEnum,String> bizOrderRedisStateMachinePersister;
   
   ......
     bizOrderRedisStateMachinePersister.persist(stateMachine,request.getBizCode());
   ......
     StateMachine<BizOrderStatusEnum,BizOrderStatusChangeEventEnum> stateMachine
                   =      bizOrderRedisStateMachinePersister.restore(srcStateMachine,statusRequest.getBizCode());
   ......複製程式碼

支援，關於spring statemachine的持久化就交代完了，下面就是最關鍵的，怎麼利用狀態機來串聯業務，下一節將會詳細描述。

相關推薦

Spring StateMachine 狀態機引擎在專案中的應用(二)--持久化

背景 每次用到的時候新建立一個狀態機，太奢侈了，官方檔案裡面也提到過這點。

狀態機引擎在vivo營銷自動化中的深度實踐 | 引擎篇02

一、業務背景 營銷自動化平臺支援多種不同型別運營活動策略（比如：簡訊推送策略、微信圖文推送策略、App Push推送策略），每種活動型別都有各自不同的執行流程和活動狀態。比如簡訊活動的活動執行流程如下：

vue在實際專案中應用

技術棧 技術棧選擇 Vue 作為框架。 vue-router 和 vuex 都是必不可少的。 選擇 Ant Design Vue。

如何在Vue專案中應用TypeScript類

目錄一、前言二、使用[email protected]、data、methods3.@props4.@watch5.@emit三 、總結

【架構設計】無狀態狀態機在程式碼中的實踐

無狀態狀態機 一：前言 ​ 在專案中經常有一些工單，申請之類需要對狀態進行流轉。這種需求一般都是滿足什麼條件然後就翻轉狀態。這些流程結構相似得邏輯，感覺可以抽象處理。用一個通用得結構處理，可以讓系統更加

Java開發之Struts框架專案中應用說明

Struts1最早的一種基於mvc模式的框架； Struts2 是在Struts1的基礎上，融合了xwork的功能;

專案中Axios二次封裝例項Demo

1.為什麼做封裝？ 方便程式碼整體呼叫、對請求做公共處理、個性化定製 2.別人已經封裝了很多，為什麼不直接修改使用？

Spring boot 專案中put提交Date資料時出現type=Bad Request, status=400狀態碼

1.問題原因 經過測試發現，當客戶端頁面提交日期為空時會出現以下異常，如果提交日期不為空則不會出現上述問題。出現這種錯誤的原因是沒有對程式碼中的Date型引數進行格式化，接收為null的日期型別引數時，出現了轉

狀態模式：遊戲、工作流引擎中常用的狀態機是如何實現的？

從今天起，我們開始學習狀態模式。在實際的軟體開發中，狀態模式並不是很常用，但是在能夠用到的場景裡，它可以發揮很大的作用。從這一點上來看，它有點像我們之前講到的組合模式。

Spring Boot專案中如何定製servlet-filters

本文首發於個人網站：Spring Boot專案中如何定製servlet-filters 在實際的web應用程式中，經常需要在請求（request）外面增加包裝用於：記錄呼叫日誌、排除有XSS威脅的字元、執行許可權驗證等等。除了上述提到的之

Spring Boot2 系列教程(三)理解 Spring Boot 專案中的 parent

前面和大夥聊了 Spring Boot 專案的三種建立方式，這三種建立方式，無論是哪一種，建立成功後，pom.xml 座標檔案中都有如下一段引用：

Spring Security 在前後端分離專案中的實踐（1）

1 概述 如今，前後端分離（開發）已經非常常見了。由於任務需要，要在基於 Spring Boot 的 Web 專案中整合 Spring Security 完成使用者模組的登入和認證等功能，但是在網上查閱的（中文）資料中，對前後端完全分離如

Spring Boot專案中如何定製PropertyEditors

本文首發於個人網站：Spring Boot專案中如何定製PropertyEditors 在Spring Boot: 定製HTTP訊息轉換器一文中我們學習瞭如何配置訊息轉換器用於HTTP請求和響應資料，實際上，在一次請求的完成過程中還發生了其他的轉

Spring Boot專案中如何定製攔截器

本文首發於個人網站：Spring Boot專案中如何定製攔截器 Servlet 過濾器屬於Servlet API，和Spring關係不大。除了使用過濾器包裝web請求，Spring MVC還提供HandlerInterceptor（攔截器）工具。根據檔案，HandlerI

在Spring Boot專案中使用Spock測試框架

本文首發於個人網站：在Spring Boot專案中使用Spock測試框架 Spock框架是基於Groovy語言的測試框架，Groovy與Java具備良好的互操作性，因此可以在Spring Boot專案中使用該框架寫優雅、高效以及DSL化的測試用例。

Spring Boot專案中使用Mockito

本文首發於個人網站：Spring Boot專案中使用Mockito Spring Boot可以和大部分流行的測試框架協同工作：通過Spring JUnit建立單元測試；生成測試資料初始化資料庫用於測試；Spring Boot可以跟BDD（Behavier Drive

Spring Boot專案中使用事件派發器模式

在專案開發中，會遇到如下情形：我們自己的服務訂閱、接收來自訊息佇列或者客戶端的事件和請求，基於不同的事件採取對應的行動，這種情況下適合應用派發器模式。

Spring Boot專案中定製PropertyEditors方法

在Spring Boot: 定製HTTP訊息轉換器一文中我們學習瞭如何配置訊息轉換器用於HTTP請求和響應資料，實際上，在一次請求的完成過程中還發生了其他的轉換，我們這次關注將引數轉換成多種型別的物件，如：字串轉換成Date物

Spring Boot專案中定製攔截器的方法詳解

這篇文章主要介紹了Spring Boot專案中定製攔截器的方法詳解,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

使用Spring CROS解決專案中的跨域問題詳解

CROS(Cross-Origin Resource Sharing) 用於解決瀏覽器中跨域請求的問題。簡單的Get請求可以使用JSONP來解決，而對於其它複雜的請求則需要後端應用的支援CROS。Spring在4.2版本之後提供了@CrossOrigin 註解來實現對Cr