Add kotlin.serialization implementation of Serializer

kotlin/src/main/kotlin/org/axonframework/extensions/kotlin/serialization/KotlinSerializer.kt

@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2010-2021. Axon Framework
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.axonframework.extensions.kotlin.serialization
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import org.axonframework.common.ObjectUtils
+import org.axonframework.serialization.AnnotationRevisionResolver
+import org.axonframework.serialization.ChainingConverter
+import org.axonframework.serialization.Converter
+import org.axonframework.serialization.RevisionResolver
+import org.axonframework.serialization.SerializedObject
+import org.axonframework.serialization.SerializedType
+import org.axonframework.serialization.Serializer
+import org.axonframework.serialization.SimpleSerializedObject
+import org.axonframework.serialization.SimpleSerializedType
+import org.axonframework.serialization.UnknownSerializedType
+import kotlin.reflect.full.companionObject
+import kotlin.reflect.full.companionObjectInstance
+
+/**
+ * Implementation of Axon Serializer that uses a kotlinx.serialization implementation.
+ * The serialized format is JSON.
+ *
+ * The DSL function kotlinSerializer can be used to easily configure the parameters
+ * for this serializer.
+ *
+ * @see kotlinx.serialization.Serializer
+ * @see org.axonframework.serialization.Serializer
+ * @see kotlinSerializer
+ */
+class KotlinSerializer(
+    private val revisionResolver: RevisionResolver,
+    private val converter: Converter,
+    private val json: Json
+) : Serializer {
+
+    private val serializerCache: MutableMap<Class<*>, KSerializer<*>> = mutableMapOf()
+
+    override fun <T> serialize(value: Any?, expectedRepresentation: Class<T>): SerializedObject<T> {
+        try {
+            val type = ObjectUtils.nullSafeTypeOf(value)
+            return when {
+                expectedRepresentation.isAssignableFrom(String::class.java) ->
+                    SimpleSerializedObject(
+                        (if (value == null) "null" else json.encodeToString(type.serializer(), value)) as T,
+                        expectedRepresentation,
+                        typeForClass(type)
+                    )
+
+                expectedRepresentation.isAssignableFrom(JsonElement::class.java) ->
+                    SimpleSerializedObject(
+                        (if (value == null) JsonNull else json.encodeToJsonElement(type.serializer(), value)) as T,
+                        expectedRepresentation,
+                        typeForClass(type)
+                    )
+
+                else ->
+                    throw org.axonframework.serialization.SerializationException("Cannot serialize type $type to representation $expectedRepresentation. String and JsonElement are supported.")
+            }
+        } catch (ex: SerializationException) {
+            throw org.axonframework.serialization.SerializationException("Cannot serialize type ${value?.javaClass?.name} to representation $expectedRepresentation.", ex)
+        }
+    }
+
+    override fun <T> canSerializeTo(expectedRepresentation: Class<T>): Boolean =
+        expectedRepresentation == String::class.java ||
+                expectedRepresentation == JsonElement::class.java
+
+    override fun <S, T> deserialize(serializedObject: SerializedObject<S>?): T? {
+        try {
+            if (serializedObject == null) {
+                return null
+            }
+
+            if (serializedObject.type == SerializedType.emptyType()) {
+                return null
+            }
+
+            val serializer: KSerializer<T> = serializedObject.serializer()
+            return when {
+                serializedObject.contentType.isAssignableFrom(String::class.java) ->
+                    json.decodeFromString(serializer, serializedObject.data as String)
+
+                serializedObject.contentType.isAssignableFrom(JsonElement::class.java) ->
+                    json.decodeFromJsonElement(serializer, serializedObject.data as JsonElement)
+
+                else ->
+                    throw org.axonframework.serialization.SerializationException("Cannot deserialize from content type ${serializedObject.contentType} to type ${serializedObject.type}. String and JsonElement are supported.")
+            }
+        } catch (ex: SerializationException) {
+            throw org.axonframework.serialization.SerializationException(
+                "Could not deserialize from content type ${serializedObject?.contentType} to type ${serializedObject?.type}",
+                ex
+            )
+        }
+    }
+
+    private fun <S, T> SerializedObject<S>.serializer(): KSerializer<T> =
+        classForType(type).serializer() as KSerializer<T>
+
+    /**
+     * When a type is compiled by the Kotlin compiler extension, a companion object
+     * is created which contains a method `serializer()`. This method should be called
+     * to get the serializer of the class.
+     *
+     * In a 'normal' serialization environment, you would call the MyClass.serializer()
+     * method directly. Here we are in a generic setting, and need reflection to call
+     * the method.
+     *
+     * This method caches the reflection mapping from class to serializer for efficiency.
+     */
+    private fun <T> Class<T>.serializer(): KSerializer<T> =
+        serializerCache.computeIfAbsent(this) {
+            // Class<T>: T must be non-null
+            val kClass = (this as Class<Any>).kotlin
+
+            val companion = kClass.companionObject
+                ?: throw SerializationException("Class $this has no companion object. Did you mark it as @Serializable?")
+
+            val serializerMethod = companion.java.getMethod("serializer")
+                ?: throw SerializationException("Class $this has no serializer() method. Did you mark it as @Serializable?")
+
+            serializerMethod.invoke(kClass.companionObjectInstance) as KSerializer<*>
+        } as KSerializer<T>
+
+    override fun classForType(type: SerializedType): Class<*> =
+        if (SerializedType.emptyType() == type) {
+            Void.TYPE
+        } else {
+            try {
+                Class.forName(type.name)
+            } catch (e: ClassNotFoundException) {
+                UnknownSerializedType::class.java
+            }
+        }
+
+    override fun typeForClass(type: Class<*>?): SerializedType =
+        if (type == null || Void.TYPE == type || Void::class.java == type) {
+            SimpleSerializedType.emptyType()
+        } else {
+            SimpleSerializedType(type.name, revisionResolver.revisionOf(type))
+        }
+
+    private fun revisionOf(type: Class<*>): String? =
+        revisionResolver.revisionOf(type)
+
+    override fun getConverter(): Converter =
+        converter
+
+}
+
+/**
+ * Configuration which will be used to construct a KotlinSerializer.
+ * This class is used in the kotlinSerializer DSL function.
+ *
+ * @see KotlinSerializer
+ * @see kotlinSerializer
+ */
+class KotlinSerializerConfiguration {
+    var revisionResolver: RevisionResolver = AnnotationRevisionResolver()
+    var converter: Converter = ChainingConverter()
+    var json: Json = Json
+}
+
+/**
+ * DSL function to configure a new KotlinSerializer.
+ *
+ * Usage example:
+ * <code>
+ *     val serializer: KotlinSerializer = kotlinSerializer {
+ *          json = Json
+ *          converter = ChainingConverter()
+ *          revisionResolver = AnnotationRevisionResolver()
+ *     }
+ * </code>
+ *
+ * @see KotlinSerializer
+ */
+fun kotlinSerializer(init: KotlinSerializerConfiguration.() -> Unit = {}): KotlinSerializer {
+    val configuration = KotlinSerializerConfiguration()
+    configuration.init()
+    return KotlinSerializer(
+        configuration.revisionResolver,
+        configuration.converter,
+        configuration.json,
+    )
+}

kotlin/src/test/kotlin/org/axonframework/extensions/kotlin/serialization/KotlinSerializerTest.kt

@@ -0,0 +1,95 @@
+package org.axonframework.extensions.kotlin.serialization
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import org.axonframework.serialization.AnnotationRevisionResolver
+import org.axonframework.serialization.ChainingConverter
+import org.axonframework.serialization.SerializedType
+import org.axonframework.serialization.SimpleSerializedObject
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+
+class KotlinSerializerTest {
+
+    /**
+     * This class will automatically become serializable through the Kotlin serialization compiler plugin.
+     */
+    @Serializable
+    data class TestData(
+        val name: String,
+        val value: Float?
+    )
+
+    @Test
+    fun canSerializeTo() {
+        val serializer = kotlinSerializer()
+
+        assertTrue(serializer.canSerializeTo(String::class.java))
+        assertTrue(serializer.canSerializeTo(JsonElement::class.java))
+    }
+
+    @Test
+    fun `configuration options`() {
+        val serializer = kotlinSerializer {
+            json = Json
+            converter = ChainingConverter()
+            revisionResolver = AnnotationRevisionResolver()
+        }
+        assertNotNull(serializer)
+    }
+
+    @Test
+    fun serialize() {
+        val serializer = kotlinSerializer()
+
+        val emptySerialized = serializer.serialize(TestData("", null), String::class.java)
+        assertEquals("SimpleSerializedType[org.axonframework.extensions.kotlin.serialization.KotlinSerializerTest\$TestData] (revision null)", emptySerialized.type.toString())
+        assertEquals("""{"name":"","value":null}""", emptySerialized.data)
+        assertEquals(String::class.java, emptySerialized.contentType)
+
+        val filledSerialized = serializer.serialize(TestData("name", 1.23f), String::class.java)
+        assertEquals("SimpleSerializedType[org.axonframework.extensions.kotlin.serialization.KotlinSerializerTest\$TestData] (revision null)", filledSerialized.type.toString())
+        assertEquals("""{"name":"name","value":1.23}""", filledSerialized.data)
+        assertEquals(String::class.java, filledSerialized.contentType)
+
+        val nullSerialized = serializer.serialize(null, String::class.java)
+        assertEquals("null", nullSerialized.data)
+        assertEquals(String::class.java, nullSerialized.contentType)
+    }
+
+    @Test
+    fun deserialize() {
+        val serializer = kotlinSerializer()
+
+        val nullDeserialized: Any? = serializer.deserialize(SimpleSerializedObject(
+            "",
+            String::class.java,
+            SerializedType.emptyType()
+        ))
+        assertNull(nullDeserialized)
+
+        val emptyDeserialized: Any? = serializer.deserialize(SimpleSerializedObject(
+            """{"name":"","value":null}""",
+            String::class.java,
+            TestData::class.java.name,
+            null
+        ))
+        assertNotNull(emptyDeserialized as TestData)
+        assertEquals(emptyDeserialized.name, "")
+        assertEquals(emptyDeserialized.value, null)
+
+        val filledDeserialized: Any? = serializer.deserialize(SimpleSerializedObject(
+            """{"name":"name","value":1.23}""",
+            String::class.java,
+            TestData::class.java.name,
+            null
+        ))
+        assertNotNull(filledDeserialized as TestData)
+        assertEquals(filledDeserialized.name, "name")
+        assertEquals(filledDeserialized.value, 1.23f)
+    }
+}

pom.xml

@@ -36,6 +36,7 @@
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <kotlin.version>1.5.10</kotlin.version>
     <kotlin-logging.version>2.0.6</kotlin-logging.version>
+    <kotlin-serialization.version>1.2.1</kotlin-serialization.version>
     <jackson-kotlin.version>2.12.3</jackson-kotlin.version>
     <mockk.version>1.11.0</mockk.version>
     <junit.jupiter.version>5.7.2</junit.jupiter.version>
@@ -130,6 +131,14 @@
       <scope>test</scope>
     </dependency>
 
+    <!-- Serialization -->
+    <dependency>
+      <groupId>org.jetbrains.kotlinx</groupId>
+      <artifactId>kotlinx-serialization-json</artifactId>
+      <version>${kotlin-serialization.version}</version>
+      <optional>true</optional>
+    </dependency>
+
     <!-- Test dependencies -->
     <dependency>
       <groupId>org.junit.jupiter</groupId>
@@ -434,6 +443,7 @@
             <compilerPlugins>
               <plugin>no-arg</plugin>
               <plugin>all-open</plugin>
+              <plugin>kotlinx-serialization</plugin>
             </compilerPlugins>
             <pluginOptions>
               <!-- Axon specific classes -->
@@ -477,6 +487,12 @@
               <artifactId>kotlin-maven-noarg</artifactId>
               <version>${kotlin.version}</version>
             </dependency>
+            <dependency>
+              <groupId>org.jetbrains.kotlin</groupId>
+              <artifactId>kotlin-maven-serialization</artifactId>
+              <version>${kotlin.version}</version>
+              <optional>true</optional>
+            </dependency>
           </dependencies>
         </plugin>
       </plugins>