Fixed to not get unbox-impl each time

Author: k163377

src/main/kotlin/io/github/projectmapk/jackson/module/kogera/Converters.kt

@@ -25,7 +25,7 @@ internal class ValueClassBoxConverter<S : Any?, D : Any>(
     val delegatingSerializer: StdDelegatingSerializer by lazy { StdDelegatingSerializer(this) }
 }
 
-internal class ValueClassUnboxConverter<T : Any>(private val valueClass: Class<T>) : StdConverter<T, Any?>() {
+internal class ValueClassUnboxConverter<T : Any>(val valueClass: Class<T>) : StdConverter<T, Any?>() {
     private val unboxMethod = valueClass.getDeclaredMethod("unbox-impl").apply {
         if (!this.isAccessible) this.isAccessible = true
     }
@@ -34,4 +34,6 @@ internal class ValueClassUnboxConverter<T : Any>(private val valueClass: Class<T
     override fun convert(value: T): Any? = unboxMethod.invoke(value)
 
     override fun getInputType(typeFactory: TypeFactory): JavaType = typeFactory.constructType(valueClass)
+    override fun getOutputType(typeFactory: TypeFactory): JavaType =
+        typeFactory.constructType(unboxMethod.genericReturnType)
 }

src/main/kotlin/io/github/projectmapk/jackson/module/kogera/KotlinModule.kt

@@ -103,7 +103,7 @@ public class KotlinModule private constructor(
         context.addDeserializers(KotlinDeserializers(cache, useJavaDurationConversion))
         context.addKeyDeserializers(KotlinKeyDeserializers)
         context.addSerializers(KotlinSerializers())
-        context.addKeySerializers(KotlinKeySerializers())
+        context.addKeySerializers(KotlinKeySerializers(cache))
 
         // ranges
         context.setMixInAnnotations(ClosedRange::class.java, ClosedRangeMixin::class.java)

src/main/kotlin/io/github/projectmapk/jackson/module/kogera/ser/serializers/KotlinKeySerializers.kt

@@ -9,17 +9,20 @@ import com.fasterxml.jackson.databind.SerializationConfig
 import com.fasterxml.jackson.databind.SerializerProvider
 import com.fasterxml.jackson.databind.ser.Serializers
 import com.fasterxml.jackson.databind.ser.std.StdSerializer
+import io.github.projectmapk.jackson.module.kogera.ReflectionCache
+import io.github.projectmapk.jackson.module.kogera.ValueClassUnboxConverter
 import io.github.projectmapk.jackson.module.kogera.isUnboxableValueClass
 import java.lang.reflect.Method
 import java.lang.reflect.Modifier
 
-internal object ValueClassUnboxKeySerializer : StdSerializer<Any>(Any::class.java) {
-    override fun serialize(value: Any, gen: JsonGenerator, provider: SerializerProvider) {
-        val method = value::class.java.getMethod("unbox-impl")
-        val unboxed = method.invoke(value)
+internal class ValueClassUnboxKeySerializer<T : Any>(
+    private val converter: ValueClassUnboxConverter<T>
+) : StdSerializer<T>(converter.valueClass) {
+    override fun serialize(value: T, gen: JsonGenerator, provider: SerializerProvider) {
+        val unboxed = converter.convert(value)
 
         if (unboxed == null) {
-            val javaType = provider.typeFactory.constructType(method.genericReturnType)
+            val javaType = converter.getOutputType(provider.typeFactory)
             provider.findNullKeySerializer(javaType, null).serialize(null, gen, provider)
             return
         }
@@ -33,15 +36,14 @@ private fun Class<*>.getStaticJsonKeyGetter(): Method? = this.declaredMethods.fi
     Modifier.isStatic(method.modifiers) && method.annotations.any { it is JsonKey && it.value }
 }
 
-internal class ValueClassStaticJsonKeySerializer<T>(
-    t: Class<T>,
+internal class ValueClassStaticJsonKeySerializer<T : Any>(
+    private val converter: ValueClassUnboxConverter<T>,
     private val staticJsonKeyGetter: Method
-) : StdSerializer<T>(t) {
+) : StdSerializer<T>(converter.valueClass) {
     private val keyType: Class<*> = staticJsonKeyGetter.returnType
-    private val unboxMethod: Method = t.getMethod("unbox-impl")
 
     override fun serialize(value: T, gen: JsonGenerator, provider: SerializerProvider) {
-        val unboxed = unboxMethod.invoke(value)
+        val unboxed = converter.convert(value)
         // As shown in the processing of the factory function, jsonValueGetter is always a static method.
         val jsonKey: Any? = staticJsonKeyGetter.invoke(null, unboxed)
 
@@ -57,19 +59,26 @@ internal class ValueClassStaticJsonKeySerializer<T>(
         // If create a function with a JsonValue in the value class,
         // it will be compiled as a static method (= cannot be processed properly by Jackson),
         // so use a ValueClassSerializer.StaticJsonValue to handle this.
-        fun createOrNull(t: Class<*>): StdSerializer<*>? =
-            t.getStaticJsonKeyGetter()?.let { ValueClassStaticJsonKeySerializer(t, it) }
+        fun <T : Any> createOrNull(converter: ValueClassUnboxConverter<T>): StdSerializer<T>? =
+            converter.valueClass.getStaticJsonKeyGetter()?.let { ValueClassStaticJsonKeySerializer(converter, it) }
     }
 }
 
-internal class KotlinKeySerializers : Serializers.Base() {
+internal class KotlinKeySerializers(private val cache: ReflectionCache) : Serializers.Base() {
     override fun findSerializer(
         config: SerializationConfig,
         type: JavaType,
         beanDesc: BeanDescription
-    ): JsonSerializer<*>? = when {
-        type.rawClass.isUnboxableValueClass() -> ValueClassStaticJsonKeySerializer.createOrNull(type.rawClass)
-            ?: ValueClassUnboxKeySerializer
-        else -> null
+    ): JsonSerializer<*>? {
+        val rawClass = type.rawClass
+
+        return when {
+            rawClass.isUnboxableValueClass() -> {
+                val unboxConverter = cache.getValueClassUnboxConverter(rawClass)
+                ValueClassStaticJsonKeySerializer.createOrNull(unboxConverter)
+                    ?: ValueClassUnboxKeySerializer(unboxConverter)
+            }
+            else -> null
+        }
     }
 }