It is impossible to persist a StateMachine using normal java serialization as object graph is too rich and contains too much dependencies into other Spring context classes. StateMachineContext is a runtime representation of a state machine which can be used to restore an existing machine into a state represented by a particular StateMachineContext object.

Building a StateMachineContext and then restoring a state machine from it has always been a little bit of a black magic if done manually. Interface StateMachinePersister aims to ease these operations by providing persist and restore methods. Default implementation of this interface is DefaultStateMachinePersister

Usage of a StateMachinePersister is easy to demonstrate by following a snippets from tests. We start by creating to two similar configs for a state machine machine1 and machine2. We could build different machines for this demonstration using various other ways but this serves a purpose for this case.

@Configuration
@EnableStateMachine(name = "machine1")
static class Config1 extends Config {
}

@Configuration
@EnableStateMachine(name = "machine2")
static class Config2 extends Config {
}

static class Config extends StateMachineConfigurerAdapter<String, String> {

    @Override
    public void configure(StateMachineStateConfigurer<String, String> states) throws Exception {
        states
            .withStates()
                .initial("S1")
                .state("S1")
                .state("S2");
    }

    @Override
    public void configure(StateMachineTransitionConfigurer<String, String> transitions) throws Exception {
        transitions
            .withExternal()
                .source("S1")
                .target("S2")
                .event("E1");
    }
}

As we’re using a StateMachinePersist we simply create an in-memory implementation.

	Note
	In-memory sample is just for demonstration purposes, use a real persistent storage implementations.

static class InMemoryStateMachinePersist implements StateMachinePersist<String, String, String> {

    private final HashMap<String, StateMachineContext<String, String>> contexts = new HashMap<>();

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

    @Override
    public StateMachineContext<String, String> read(String contextObj) throws Exception {
        return contexts.get(contextObj);
    }
}

After we have instantiated two different machines we can transfer machine1 into state S2 via event E1, then persist it and restore machine2.

InMemoryStateMachinePersist stateMachinePersist = new InMemoryStateMachinePersist();
StateMachinePersister<String, String, String> persister = new DefaultStateMachinePersister<>(stateMachinePersist);

StateMachine<String, String> stateMachine1 = context.getBean("machine1", StateMachine.class);
StateMachine<String, String> stateMachine2 = context.getBean("machine2", StateMachine.class);
stateMachine1.start();

stateMachine1.sendEvent("E1");
assertThat(stateMachine1.getState().getIds(), contains("S2"));

persister.persist(stateMachine1, "myid");
persister.restore(stateMachine2, "myid");
assertThat(stateMachine2.getState().getIds(), contains("S2"));

Support for persisting State Machine into Redis is done via RepositoryStateMachinePersist which implements StateMachinePersist. Specific implementation is a RedisStateMachineContextRepository which uses kryo serialization to persist a StateMachineContext into Redis.

For StateMachinePersister we have a redis related RedisStateMachinePersister implementation which takes an instance of a StateMachinePersist and uses String as its context object.

	Tip
	Check sample Chapter 46, Event Service for detailed usage.

RedisStateMachineContextRepository will need a RedisConnectionFactory for it to work and we recommend a JedisConnectionFactory for it as seeing from above example.

StateMachineRuntimePersister is a simple extension to StateMachinePersist adding interface level method to get StateMachineInterceptor associated with it. This interceptor is then required to persist machine during state changes without needing to stop and start a machine.

Currently there are implementations for this interface for out-of-the-box supported Spring Data Repositories. These are JpaStateMachineRuntimePersister, RedisStateMachineRuntimePersister and MongoDbStateMachineRuntimePersister.

	Tip
	Check sample ??? for detailed usage.