Serialization - Restate

Restate sends data over the network for storing state, journaling actions, awakeables, etc. Therefore, Restate needs to serialize and deserialize the journal entries.

Default serialization

The SDK uses by default Jackson Databind for the Java API, and Kotlinx serialization for the Kotlin API. For example, for state keys:

// Primitive types
var myString = StateKey.of("myString", String.class);
// Generic types need TypeRef (similar to Jackson's TypeReference)
var myMap = StateKey.of("myMap", TypeTag.of(new TypeRef<Map<String, String>>() {}));

// These imports provide extension methods with reified generics
import dev.restate.sdk.kotlin.*

// Primitive types
val myString = stateKey<String>("my-string")
// Generic types
val myMap = stateKey<Map<String, String>>("my-map")
// Custom generic type
val myPerson = stateKey<Person<String>>("my-person")

The same applies to journaling actions, awakeables, etc.

Customizing serialization

There are different entrypoints in the SDK to customize (de)serialization, depending on your needs.

Custom Jackson `ObjectMapper`

You can customize the Jackson’s ObjectMapper by subclassing the JacksonSerdeFactory class:

class MyJacksonSerdeFactory extends JacksonSerdeFactory {
  public MyJacksonSerdeFactory() {
    super(new ObjectMapper().configure(SerializationFeature.INDENT_OUTPUT, true));
  }
}

And annotating your services with @CustomSerdeFactory:

@CustomSerdeFactory(MyJacksonSerdeFactory.class)
@Service
class ServiceWithCustomJacksonObjectMapper {
  @Handler
  public String greet(Context context) {
    return "Hello world";
  }
}

Custom Kotlinx Serialization `Json`

You can customize the Kotlinx Serialization Json by subclassing the KotlinSerializationSerdeFactory class:

class MyJsonSerdeFactory : KotlinSerializationSerdeFactory(json = Json { prettyPrint = true })

And annotating your services with @CustomSerdeFactory:

@CustomSerdeFactory(MyJsonSerdeFactory::class)
@Service
class ServiceWithCustomSerdeFactory {
  @Handler suspend fun greet(ctx: Context) = "Hello world!"
}

Use custom serializer for a specific operation

If you need for a specific operation (e.g. for Context.run or Context.Awakeable) a custom (de)serializer, you can implement one using the interface Serde:

class MyPersonSerde implements Serde<Person> {
  @Override
  public Slice serialize(Person person) {
    // convert value to a byte array, then wrap in a Slice
    return Slice.wrap(person.toBytes());
  }

  @Override
  public Person deserialize(Slice slice) {
    // convert value to Person
    return Person.fromBytes(slice.toByteArray());
  }
}

And then use it, for example, in combination with ctx.run:

ctx.run(new MyPersonSerde(), () -> new Person());

Use another serialization library

If you want to use a different serialization library throughout your service, we suggest implementing SerdeFactory and annotating the service class with @CustomSerdeFactory. Refer to the Javadocs for more details.

​Default serialization

​Customizing serialization

​Custom Jackson ObjectMapper

​Custom Kotlinx Serialization Json

​Use custom serializer for a specific operation

​Use another serialization library