Merge pull request #135 from ProjectMapK/value-class-unbox-cache

k163377 · web-flow · commit dc51a9ebccb3 · 2023-09-02T02:52:15.000+09:00
Fix to reuse ValueClassUnboxConverter
diff --git a/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/Converters.kt b/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/Converters.kt
@@ -1,6 +1,8 @@
 package io.github.projectmapk.jackson.module.kogera
 
+import com.fasterxml.jackson.databind.JavaType
 import com.fasterxml.jackson.databind.ser.std.StdDelegatingSerializer
+import com.fasterxml.jackson.databind.type.TypeFactory
 import com.fasterxml.jackson.databind.util.StdConverter
 
 /**
@@ -22,3 +24,18 @@ internal class ValueClassBoxConverter<S : Any?, D : Any>(
 
     val delegatingSerializer: StdDelegatingSerializer by lazy { StdDelegatingSerializer(this) }
 }
+
+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
+    }
+    val unboxedClass: Class<*> = unboxMethod.returnType
+
+    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)
+
+    val delegatingSerializer: StdDelegatingSerializer by lazy { StdDelegatingSerializer(this) }
+}
diff --git a/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/KotlinModule.kt b/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/KotlinModule.kt
@@ -102,8 +102,8 @@ public class KotlinModule private constructor(
 
         context.addDeserializers(KotlinDeserializers(cache, useJavaDurationConversion))
         context.addKeyDeserializers(KotlinKeyDeserializers)
-        context.addSerializers(KotlinSerializers())
-        context.addKeySerializers(KotlinKeySerializers())
+        context.addSerializers(KotlinSerializers(cache))
+        context.addKeySerializers(KotlinKeySerializers(cache))
 
         // ranges
         context.setMixInAnnotations(ClosedRange::class.java, ClosedRangeMixin::class.java)
diff --git a/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/ReflectionCache.kt b/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/ReflectionCache.kt
@@ -9,7 +9,7 @@ internal class ReflectionCache(reflectionCacheSize: Int) : Serializable {
     companion object {
         // Increment is required when properties that use LRUMap are changed.
         @Suppress("ConstPropertyName")
-        private const val serialVersionUID = 2L
+        private const val serialVersionUID = 3L
     }
 
     // This cache is used for both serialization and deserialization, so reserve a larger size from the start.
@@ -23,6 +23,8 @@ internal class ReflectionCache(reflectionCacheSize: Int) : Serializable {
     //       since the cache is used only twice locally at initialization per property.
     private val valueClassBoxConverterCache: LRUMap<Class<*>, ValueClassBoxConverter<*, *>> =
         LRUMap(0, reflectionCacheSize)
+    private val valueClassUnboxConverterCache: LRUMap<Class<*>, ValueClassUnboxConverter<*>> =
+        LRUMap(0, reflectionCacheSize)
 
     fun getJmClass(clazz: Class<*>): JmClass? {
         return classCache[clazz] ?: run {
@@ -75,4 +77,11 @@ internal class ReflectionCache(reflectionCacheSize: Int) : Serializable {
 
             (valueClassBoxConverterCache.putIfAbsent(valueClass, value) ?: value)
         }
+
+    fun getValueClassUnboxConverter(valueClass: Class<*>): ValueClassUnboxConverter<*> =
+        valueClassUnboxConverterCache.get(valueClass) ?: run {
+            val value = ValueClassUnboxConverter(valueClass)
+
+            (valueClassUnboxConverterCache.putIfAbsent(valueClass, value) ?: value)
+        }
 }
diff --git a/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/annotation_introspector/KotlinFallbackAnnotationIntrospector.kt b/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/annotation_introspector/KotlinFallbackAnnotationIntrospector.kt
@@ -13,9 +13,9 @@ import com.fasterxml.jackson.databind.type.TypeFactory
 import com.fasterxml.jackson.databind.util.Converter
 import io.github.projectmapk.jackson.module.kogera.KotlinDuration
 import io.github.projectmapk.jackson.module.kogera.ReflectionCache
+import io.github.projectmapk.jackson.module.kogera.ValueClassUnboxConverter
 import io.github.projectmapk.jackson.module.kogera.deser.CollectionValueStrictNullChecksConverter
 import io.github.projectmapk.jackson.module.kogera.deser.MapValueStrictNullChecksConverter
-import io.github.projectmapk.jackson.module.kogera.deser.ValueClassUnboxConverter
 import io.github.projectmapk.jackson.module.kogera.isNullable
 import io.github.projectmapk.jackson.module.kogera.isUnboxableValueClass
 import io.github.projectmapk.jackson.module.kogera.reconstructClassOrNull
diff --git a/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/deser/Converters.kt b/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/deser/Converters.kt
@@ -10,16 +10,6 @@ import io.github.projectmapk.jackson.module.kogera.JavaDuration
 import io.github.projectmapk.jackson.module.kogera.KotlinDuration
 import kotlin.time.toKotlinDuration
 
-internal class ValueClassUnboxConverter<T : Any>(private val valueClass: Class<T>) : StdConverter<T, Any?>() {
-    private val unboxMethod = valueClass.getDeclaredMethod("unbox-impl").apply {
-        if (!this.isAccessible) this.isAccessible = true
-    }
-
-    override fun convert(value: T): Any? = unboxMethod.invoke(value)
-
-    override fun getInputType(typeFactory: TypeFactory): JavaType = typeFactory.constructType(valueClass)
-}
-
 internal sealed class CollectionValueStrictNullChecksConverter<T : Any> : Converter<T, T> {
     protected abstract val type: JavaType
     protected abstract val paramName: String
diff --git a/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/deser/deserializers/KotlinDeserializers.kt b/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/deser/deserializers/KotlinDeserializers.kt
@@ -148,7 +148,7 @@ internal class KotlinDeserializers(
             rawClass == KotlinDuration::class.java ->
                 JavaToKotlinDurationConverter.takeIf { useJavaDurationConversion }?.delegatingDeserializer
             rawClass.isUnboxableValueClass() -> findValueCreator(type, rawClass, cache.getJmClass(rawClass)!!)?.let {
-                val unboxedClass = rawClass.getMethod("unbox-impl").returnType
+                val unboxedClass = cache.getValueClassUnboxConverter(rawClass).unboxedClass
                 val converter = cache.getValueClassBoxConverter(unboxedClass, rawClass)
                 ValueClassBoxDeserializer(it, converter)
             }
diff --git a/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/ser/serializers/KotlinKeySerializers.kt b/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
+        }
     }
 }
diff --git a/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/ser/serializers/KotlinSerializers.kt b/src/main/kotlin/io/github/projectmapk/jackson/module/kogera/ser/serializers/KotlinSerializers.kt
@@ -9,6 +9,8 @@ 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
@@ -39,28 +41,17 @@ internal object ULongSerializer : StdSerializer<ULong>(ULong::class.java) {
     }
 }
 
-// In accordance with kotlinx.serialization,
-// value classes are unboxed and serialized if they do not have a specified serializer.
-internal object ValueClassUnboxSerializer : StdSerializer<Any>(Any::class.java) {
-    override fun serialize(value: Any, gen: JsonGenerator, provider: SerializerProvider) {
-        val unboxed = value::class.java.getMethod("unbox-impl").invoke(value)
-        provider.defaultSerializeValue(unboxed, gen)
-    }
-}
-
 // Class must be UnboxableValueClass.
 private fun Class<*>.getStaticJsonValueGetter(): Method? = this.declaredMethods.find { method ->
     Modifier.isStatic(method.modifiers) && method.annotations.any { it is JsonValue && it.value }
 }
 
-internal class ValueClassStaticJsonValueSerializer<T>(
-    t: Class<T>,
+internal class ValueClassStaticJsonValueSerializer<T : Any>(
+    private val converter: ValueClassUnboxConverter<T>,
     private val staticJsonValueGetter: Method
-) : StdSerializer<T>(t) {
-    private val unboxMethod: Method = t.getMethod("unbox-impl")
-
+) : StdSerializer<T>(converter.valueClass) {
     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 jsonValue: Any? = staticJsonValueGetter.invoke(null, unboxed)
         provider.defaultSerializeValue(jsonValue, gen)
@@ -71,12 +62,12 @@ internal class ValueClassStaticJsonValueSerializer<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.getStaticJsonValueGetter()?.let { ValueClassStaticJsonValueSerializer(t, it) }
+        fun <T : Any> createOrNull(converter: ValueClassUnboxConverter<T>): StdSerializer<T>? =
+            converter.valueClass.getStaticJsonValueGetter()?.let { ValueClassStaticJsonValueSerializer(converter, it) }
     }
 }
 
-internal class KotlinSerializers : Serializers.Base() {
+internal class KotlinSerializers(private val cache: ReflectionCache) : Serializers.Base() {
     override fun findSerializer(
         config: SerializationConfig?,
         type: JavaType,
@@ -90,8 +81,10 @@ internal class KotlinSerializers : Serializers.Base() {
             UInt::class.java == rawClass -> UIntSerializer
             ULong::class.java == rawClass -> ULongSerializer
             // The priority of Unboxing needs to be lowered so as not to break the serialization of Unsigned Integers.
-            rawClass.isUnboxableValueClass() -> ValueClassStaticJsonValueSerializer.createOrNull(rawClass)
-                ?: ValueClassUnboxSerializer
+            rawClass.isUnboxableValueClass() -> {
+                val unboxConverter = cache.getValueClassUnboxConverter(rawClass)
+                ValueClassStaticJsonValueSerializer.createOrNull(unboxConverter) ?: unboxConverter.delegatingSerializer
+            }
             else -> null
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ internal class KotlinDeserializers(`
`148`	`148`	`rawClass == KotlinDuration::class.java ->`
`149`	`149`	`JavaToKotlinDurationConverter.takeIf { useJavaDurationConversion }?.delegatingDeserializer`
`150`	`150`	`rawClass.isUnboxableValueClass() -> findValueCreator(type, rawClass, cache.getJmClass(rawClass)!!)?.let {`
`151`		`- val unboxedClass = rawClass.getMethod("unbox-impl").returnType`
	`151`	`+ val unboxedClass = cache.getValueClassUnboxConverter(rawClass).unboxedClass`
`152`	`152`	`val converter = cache.getValueClassBoxConverter(unboxedClass, rawClass)`
`153`	`153`	`ValueClassBoxDeserializer(it, converter)`
`154`	`154`	`}`