摘要：目前為止，我們都是從狀態(tài)流程的開始階段創(chuàng)建一個狀態(tài)機(jī)，然后一路走下去。然后就可以愉快的在里面看怎么用了發(fā)送事件持久化恢復(fù)狀態(tài)機(jī)后的狀態(tài)為執(zhí)行完保存后，大家可以自己在客戶端查看以下，是不是有內(nèi)容保存進(jìn)去了。

目前為止，我們都是從狀態(tài)流程的開始階段創(chuàng)建一個狀態(tài)機(jī)，然后一路走下去。但在實(shí)際業(yè)務(wù)中，狀態(tài)機(jī)可能需要在某個環(huán)節(jié)停留，等待其他業(yè)務(wù)的觸發(fā)，然后再繼續(xù)下面的流程。比如訂單，可能在支付環(huán)節(jié)需要等待一個剁手的用戶隔天再下單，所以這里面涉及到一個創(chuàng)建的狀態(tài)機(jī)該何去何從的問題。在spring statemachine中，給出來的辦法就是保存起來，到需要的時候取出來用。

1、持久化到本地內(nèi)存
嚴(yán)格來說，你完全可以自己保存狀態(tài)機(jī)，比如我就自己用map保存下來了。

public class MachineMap {

public static Map> orderMap = new HashMap>();
public static Map> formMap = new HashMap>();

}
這個代碼一看就明白，我用唯一id作為key（order就是orderId，form就是formId），把狀態(tài)機(jī)保存到map表里面，在實(shí)際的業(yè)務(wù)中，自由存取

@RequestMapping("/sendEvent")

void sendEvent(String machineId,String events,String id) throws Exception{
    if(machineId.equals("form")) {
        StateMachine sm = MachineMap.formMap.get(id);
        Form form = new Form();
        form.setId(id);
        if(sm == null) {
            if(events.equals("WRITE")) {
                sm = formStateMachineBuilder.build(beanFactory);
                sm.start();
                MachineMap.formMap.put(id, sm);
            }else {
                System.out.println("該表單流程尚未開始，不能做"+events+"轉(zhuǎn)換");
                return;
            }
        }
        
        Message message = MessageBuilder.withPayload(FormEvents.valueOf(events)).setHeader("form", form).build();
        sm.sendEvent(message);
    }
    if(machineId.equals("order")) {
        StateMachine sm = MachineMap.orderMap.get(id);
        Order order = new Order();
        order.setId(id);
        if(sm == null) {
            if(events.equals("PAY")) {
                sm = orderStateMachineBuilder.build(beanFactory);
                sm.start();
                MachineMap.orderMap.put(id, sm);
            }else {
                System.out.println("該訂單流程尚未開始，不能做"+events+"轉(zhuǎn)換");
                return;
            }
            
        }
        Message message = MessageBuilder.withPayload(OrderEvents.valueOf(events)).setHeader("order", order).setHeader("test","test1").build();
        sm.sendEvent(message);
    }
}

在這段代碼里面，我根據(jù)不同種類的狀態(tài)機(jī)去map取和id對應(yīng)的狀態(tài)機(jī)，如果狀態(tài)機(jī)沒在map里面，就創(chuàng)建一個，然后塞進(jìn)map表。其實(shí)寫這個代碼，并沒有其他意思，只是為了告訴你，spring打算管理你的map表，所以出了一個接口來規(guī)范這件事：

import java.util.HashMap;
import java.util.Map;

import org.springframework.statemachine.StateMachineContext;
import org.springframework.statemachine.StateMachinePersist;
import org.springframework.stereotype.Component;

/**

在內(nèi)存中持久化狀態(tài)機(jī)

*/
@Component
public class InMemoryStateMachinePersist implements StateMachinePersist {

private Map> map = new HashMap>();

@Override
public void write(StateMachineContext context, String contextObj) throws Exception {
    map.put(contextObj, context);
}

@Override
public StateMachineContext read(String contextObj) throws Exception {
    return map.get(contextObj);
}

}
這個接口非常簡單，就是write和read，但他保存的對象是StateMachineContext，不是StateMachine，所以我們還不能直接用它，需要配置一下。

import org.springframework.statemachine.StateMachinePersist;
......
import org.springframework.statemachine.persist.StateMachinePersister;
@Configuration
public class PersistConfig {

@Autowired
private InMemoryStateMachinePersist inMemoryStateMachinePersist;

/**
 * 注入StateMachinePersister對象
 * 
 * @return
 */
@Bean(name="orderMemoryPersister")
public StateMachinePersister getPersister() {
    return new DefaultStateMachinePersister<>(inMemoryStateMachinePersist);
}

}
這里有個坑，InMemoryStateMachinePersist 實(shí)現(xiàn)的接口是

org.springframework.statemachine.StateMachinePersist
，但在PersistConfig 里面，getPersister()方法返回的值類型是StateMachinePersister類型，看著很像，但并不是上面的這個接口，而是org.springframework.statemachine.persist.StateMachinePersister接口，為了表示這個坑對我的傷害，我要強(qiáng)調(diào)一下兩個接口：

package org.springframework.statemachine;
public interface StateMachinePersist {

void write(StateMachineContext context, T contextObj) throws Exception;
StateMachineContext read(T contextObj) throws Exception;

}
package org.springframework.statemachine.persist;
import org.springframework.statemachine.StateMachine;
public interface StateMachinePersister {

void persist(StateMachine stateMachine, T contextObj) throws Exception;
StateMachine restore(StateMachine stateMachine, T contextObj) throws Exception;

}
這兩個接口名字很類似，很容易搞混，但下面的是有er的，包名也不同的。StateMachinePersister是可以直接保存StateMachine對象的，所以我們需要先實(shí)現(xiàn)上面的StateMachinePersist，然后再一個Config類里面轉(zhuǎn)換成下面的StateMachinePersister，轉(zhuǎn)換的代碼就在上面的PersistConfig類里。

然后我們就能在controller里面使用了

@Resource(name="orderMemoryPersister")
private StateMachinePersister orderMemorypersister;

......

//保存狀態(tài)機(jī)
@RequestMapping("/testMemoryPersister")

public void tesMemorytPersister(String id) throws Exception {
    StateMachine stateMachine = orderStateMachineBuilder.build(beanFactory);
    stateMachine.start();
    
    //發(fā)送PAY事件
    stateMachine.sendEvent(OrderEvents.PAY);
    Order order = new Order();
    order.setId(id);
    
    //持久化stateMachine
    orderMemorypersister.persist(stateMachine, order.getId());

}

//取出狀態(tài)機(jī)
@RequestMapping("/testMemoryPersisterRestore")

public void testMemoryRestore(String id) throws Exception {
    StateMachine stateMachine = orderStateMachineBuilder.build(beanFactory);
    orderMemorypersister.restore(stateMachine, id);
    System.out.println("恢復(fù)狀態(tài)機(jī)后的狀態(tài)為：" + stateMachine.getState().getId());
}

2、持久化到redis
真正的業(yè)務(wù)中，一般都是多臺機(jī)分布式運(yùn)行，所以如果狀態(tài)機(jī)只能保存在本地內(nèi)容，就不能用在分布式應(yīng)用上了。spring提供了一個方便的辦法，使用redis解決這個問題。讓我們看看怎么弄。

pom文件引入spring-statemachine-redis

    
        org.springframework.statemachine
        spring-statemachine-redis
        1.2.9.RELEASE
    

在springboot配置文件里面加上redis參數(shù)，我這是application.properties

spring.redis.database=0

spring.redis.host=localhost

spring.redis.port=6379

spring.redis.password=

spring.redis.pool.max-active=8

spring.redis.pool.max-wait=-1

spring.redis.pool.max-idle=8

spring.redis.pool.min-idle=0

spring.redis.timeout=0
保證配置的redis開啟并能用，我們繼續(xù)?；氐轿覀兪煜さ腜ersistConfig

@Configuration
public class PersistConfig {

@Autowired
private RedisConnectionFactory redisConnectionFactory;


/**
 * 注入RedisStateMachinePersister對象
 * 
 * @return
 */
@Bean(name = "orderRedisPersister")
public RedisStateMachinePersister redisPersister() {
    return new RedisStateMachinePersister<>(redisPersist());
}

/**
 * 通過redisConnectionFactory創(chuàng)建StateMachinePersist
 * 
 * @return
 */
public StateMachinePersist redisPersist() {
    RedisStateMachineContextRepository repository = new RedisStateMachineContextRepository<>(redisConnectionFactory);
    return new RepositoryStateMachinePersist<>(repository);
}

}
這個套路和上面保存到本地內(nèi)存是一樣一樣的，先生成一個StateMachinePersist，這里是通過RedisConnectionFactory生成RepositoryStateMachinePersist，然后再包裝輸出StateMachinePersister，這里是RedisStateMachinePersister。然后就可以愉快的在controller里面看怎么用了

@Resource(name="orderRedisPersister")
private StateMachinePersister orderRedisPersister;

......

@RequestMapping("/testRedisPersister")

public void testRedisPersister(String id) throws Exception {
    StateMachine stateMachine = orderStateMachineBuilder.build(beanFactory);
    stateMachine.start();
    Order order = new Order();
    order.setId(id);
    //發(fā)送PAY事件
    Message message = MessageBuilder.withPayload(OrderEvents.PAY).setHeader("order", order).build();
    stateMachine.sendEvent(message);
    //持久化stateMachine
    orderRedisPersister.persist(stateMachine, order.getId());
}

@RequestMapping("/testRedisPersisterRestore")
public void testRestore(String id) throws Exception {
    StateMachine stateMachine = orderStateMachineBuilder.build(beanFactory);
    orderRedisPersister.restore(stateMachine, id);
    System.out.println("恢復(fù)狀態(tài)機(jī)后的狀態(tài)為：" + stateMachine.getState().getId());
}

執(zhí)行完redis保存statemachine后，大家可以自己在redis客戶端查看以下，是不是有內(nèi)容保存進(jìn)去了。

3、下期預(yù)告
無論是本地內(nèi)存還是分布式緩存，似乎都不是很可靠的持久化，但下一章會告訴大家，保不保存也就那么點(diǎn)大的事，沒保存我們就再創(chuàng)建一個就好了。但另外一個問題就浮出水面了，狀態(tài)機(jī)執(zhí)行到中間的時候創(chuàng)建狀態(tài)機(jī)，怎么在中間繼續(xù)執(zhí)行，之前的可都是從頭開始執(zhí)行的，這個問題，下一章解決。

碼云配套代碼地址