Merge pull request #128 from ProjectMapK/develop

For release 2.15.2-beta2

Author: k163377

.github/workflows/test-main.yml

@@ -36,7 +36,7 @@ jobs:
         # LTS versions, latest version (if exists)
         java-version: [ '8', '11', '17', '19' ]
         # Minimum version, latest release version, latest pre-release version (if exists)
-        kotlin-version: [ '1.7.21', '1.8.22', '1.9.0-Beta' ]
+        kotlin-version: [ '1.7.21', '1.8.22', '1.9.0' ]
     env:
       KOTLIN_VERSION: ${{ matrix.kotlin-version }}
     name: test-main

README.md

@@ -9,6 +9,9 @@ This project has the following features compared to `jackson-module-kotlin`.
   - Smaller memory consumption
 - More `Kotlin` friendly behavior
 
+Especially when it comes to deserialization throughput, it is several times higher than `jackson-module-kotlin`.
+![](https://docs.google.com/spreadsheets/d/e/2PACX-1vTZB9ByuRV9XS_eug0vM_IEx_Em_ObiuZMoClXAt7zVZQZ9EnhKCXmbTsRQpoLiBbje6H_R9Hf7v0RI/pubchart?oid=754117157&format=image)
+
 This project is experimental, but passes all the tests implemented in `jackson-module-kotlin` except for the intentional incompatibility.
 
 # Features of `jackson-module-kogera`

src/main/java/io/github/projectmapk/jackson/module/kogera/deser/value_instantiator/ReflectProperties.java

@@ -0,0 +1,71 @@
+package io.github.projectmapk.jackson.module.kogera.deser.value_instantiator;
+
+import kotlin.jvm.functions.Function0;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.ref.SoftReference;
+
+// ported from kotlin.reflect.jvm.internal.ReflectProperties 887dc to use LazySoft
+class ReflectProperties {
+    static abstract class Val<T> {
+        private static final Object NULL_VALUE = new Object() {
+        };
+
+        @SuppressWarnings({"UnusedParameters", "unused"})
+        final T getValue(Object instance, Object metadata) {
+            return invoke();
+        }
+
+        abstract T invoke();
+
+        protected Object escape(T value) {
+            return value == null ? NULL_VALUE : value;
+        }
+
+        @SuppressWarnings("unchecked")
+        protected T unescape(Object value) {
+            return value == NULL_VALUE ? null : (T) value;
+        }
+    }
+
+    // A delegate for a lazy property on a soft reference, whose initializer may be invoked multiple times
+    // including simultaneously from different threads
+    static class LazySoftVal<T> extends Val<T> implements Function0<T> {
+        private final Function0<T> initializer;
+        private volatile SoftReference<Object> value = null;
+
+        LazySoftVal(@Nullable T initialValue, @NotNull Function0<T> initializer) {
+            this.initializer = initializer;
+            if (initialValue != null) {
+                this.value = new SoftReference<Object>(escape(initialValue));
+            }
+        }
+
+        @Override
+        public T invoke() {
+            SoftReference<Object> cached = value;
+            if (cached != null) {
+                Object result = cached.get();
+                if (result != null) {
+                    return unescape(result);
+                }
+            }
+
+            T result = initializer.invoke();
+            value = new SoftReference<Object>(escape(result));
+
+            return result;
+        }
+    }
+
+    @NotNull
+    static <T> LazySoftVal<T> lazySoft(@Nullable T initialValue, @NotNull Function0<T> initializer) {
+        return new LazySoftVal<T>(initialValue, initializer);
+    }
+
+    @NotNull
+    static <T> LazySoftVal<T> lazySoft(@NotNull Function0<T> initializer) {
+        return lazySoft(null, initializer);
+    }
+}

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

@@ -2,17 +2,22 @@ package io.github.projectmapk.jackson.module.kogera
 
 import com.fasterxml.jackson.annotation.JsonCreator
 import kotlinx.metadata.Flag
+import kotlinx.metadata.KmClass
 import kotlinx.metadata.KmClassifier
 import kotlinx.metadata.KmType
 import kotlinx.metadata.KmValueParameter
 import kotlinx.metadata.jvm.JvmFieldSignature
 import kotlinx.metadata.jvm.JvmMethodSignature
+import kotlinx.metadata.jvm.KotlinClassMetadata
 import java.lang.reflect.AnnotatedElement
 import java.lang.reflect.Constructor
 import java.lang.reflect.Field
 import java.lang.reflect.Method
 
-internal fun Class<*>.isUnboxableValueClass() = annotations.any { it is JvmInline }
+internal fun Class<*>.isUnboxableValueClass() = this.getAnnotation(JvmInline::class.java) != null
+
+internal fun Class<*>.toKmClass(): KmClass? = this.getAnnotation(Metadata::class.java)
+    ?.let { (KotlinClassMetadata.read(it) as KotlinClassMetadata.Class).toKmClass() }
 
 private val primitiveClassToDesc by lazy {
     mapOf(
@@ -96,5 +101,6 @@ internal fun KmType.reconstructClassOrNull(): Class<*>? = (classifier as? KmClas
 
 internal fun KmType.isNullable(): Boolean = Flag.Type.IS_NULLABLE(this.flags)
 
-internal fun AnnotatedElement.hasCreatorAnnotation(): Boolean =
-    annotations.any { it is JsonCreator && it.mode != JsonCreator.Mode.DISABLED }
+internal fun AnnotatedElement.hasCreatorAnnotation(): Boolean = getAnnotation(JsonCreator::class.java)
+    ?.let { it.mode != JsonCreator.Mode.DISABLED }
+    ?: false

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

@@ -6,28 +6,41 @@ import kotlinx.metadata.KmClass
 import kotlinx.metadata.KmConstructor
 import kotlinx.metadata.KmFunction
 import kotlinx.metadata.KmProperty
-import kotlinx.metadata.jvm.KotlinClassMetadata
+import kotlinx.metadata.jvm.fieldSignature
 import kotlinx.metadata.jvm.getterSignature
 import kotlinx.metadata.jvm.signature
 import java.lang.reflect.Constructor
 import java.lang.reflect.Field
 import java.lang.reflect.Method
 
-private fun Class<*>.toKmClass(): KmClass? = annotations
-    .filterIsInstance<Metadata>()
-    .firstOrNull()
-    ?.let { KotlinClassMetadata.read(it) as KotlinClassMetadata.Class }
-    ?.toKmClass()
-
 // Jackson Metadata Class
 internal class JmClass(
     private val clazz: Class<*>,
-    kmClass: KmClass
+    kmClass: KmClass,
+    superJmClass: JmClass?,
+    interfaceJmClasses: List<JmClass>
 ) {
+    private val allPropsMap: Map<String, KmProperty> = mutableMapOf<String, KmProperty>().apply {
+        kmClass.properties.forEach {
+            this[it.name] = it
+        }
+
+        // Add properties of inherited classes and interfaces
+        // If an `interface` is implicitly implemented by an abstract class,
+        // it is necessary to obtain a more specific type, so always add it from the abstract class first.
+        superJmClass?.allPropsMap?.forEach {
+            this.putIfAbsent(it.key, it.value)
+        }
+        interfaceJmClasses.forEach { i ->
+            i.allPropsMap.forEach {
+                this.putIfAbsent(it.key, it.value)
+            }
+        }
+    }
+
     val flags: Flags = kmClass.flags
     val constructors: List<KmConstructor> = kmClass.constructors
-    val properties: List<KmProperty> = kmClass.properties
-    private val functions: List<KmFunction> = kmClass.functions
+    val properties: List<KmProperty> = allPropsMap.values.toList()
     val sealedSubclasses: List<ClassName> = kmClass.sealedSubclasses
     private val companionPropName: String? = kmClass.companionObject
     val companion: CompanionObject? by lazy { companionPropName?.let { CompanionObject(clazz, it) } }
@@ -52,16 +65,15 @@ internal class JmClass(
         }
     }
 
+    // Field name always matches property name
+    fun findPropertyByField(field: Field): KmProperty? = allPropsMap[field.name]
+        ?.takeIf { it.fieldSignature == field.toSignature() }
+
     fun findPropertyByGetter(getter: Method): KmProperty? {
         val signature = getter.toSignature()
         return properties.find { it.getterSignature == signature }
     }
 
-    fun findFunctionByMethod(method: Method): KmFunction? {
-        val signature = method.toSignature()
-        return functions.find { it.signature == signature }
-    }
-
     internal class CompanionObject(
         declaringClass: Class<*>,
         companionObject: String
@@ -81,8 +93,4 @@ internal class JmClass(
             return kmClass.functions.find { it.signature == signature }
         }
     }
-
-    companion object {
-        fun createOrNull(clazz: Class<*>): JmClass? = clazz.toKmClass()?.let { JmClass(clazz, it) }
-    }
 }

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

@@ -2,26 +2,19 @@ package io.github.projectmapk.jackson.module.kogera
 
 import com.fasterxml.jackson.databind.introspect.AnnotatedMethod
 import com.fasterxml.jackson.databind.util.LRUMap
-import io.github.projectmapk.jackson.module.kogera.deser.value_instantiator.creator.ConstructorValueCreator
-import io.github.projectmapk.jackson.module.kogera.deser.value_instantiator.creator.MethodValueCreator
-import io.github.projectmapk.jackson.module.kogera.deser.value_instantiator.creator.ValueCreator
 import io.github.projectmapk.jackson.module.kogera.ser.ValueClassBoxConverter
 import java.io.Serializable
-import java.lang.reflect.Constructor
-import java.lang.reflect.Executable
-import java.lang.reflect.Method
 import java.util.Optional
 
 internal class ReflectionCache(reflectionCacheSize: Int) : Serializable {
     companion object {
         // Increment is required when properties that use LRUMap are changed.
         @Suppress("ConstPropertyName")
-        private const val serialVersionUID = 1L
+        private const val serialVersionUID = 2L
     }
 
     // This cache is used for both serialization and deserialization, so reserve a larger size from the start.
-    private val classCache = LRUMap<Class<*>, Optional<JmClass>>(reflectionCacheSize, reflectionCacheSize)
-    private val creatorCache: LRUMap<Executable, ValueCreator<*>>
+    private val classCache = LRUMap<Class<*>, JmClass>(reflectionCacheSize, reflectionCacheSize)
 
     // Initial size is 0 because the value class is not always used
     private val valueClassReturnTypeCache: LRUMap<AnnotatedMethod, Optional<Class<*>>> =
@@ -32,60 +25,24 @@ internal class ReflectionCache(reflectionCacheSize: Int) : Serializable {
     private val valueClassBoxConverterCache: LRUMap<Class<*>, ValueClassBoxConverter<*, *>> =
         LRUMap(0, reflectionCacheSize)
 
-    init {
-        // The current default value of reflectionCacheSize is 512.
-        // If less than 512 is specified, initialEntries shall be half of the reflectionCacheSize,
-        // since it is assumed that the situation does not require a large amount of space from the beginning.
-        // Conversely, if reflectionCacheSize is increased,
-        // the amount of cache is considered to be a performance bottleneck,
-        // and therefore reflectionCacheSize is used as is for initialEntries.
-        val initialEntries = if (reflectionCacheSize <= KotlinModule.Builder.reflectionCacheSizeDefault) {
-            reflectionCacheSize / 2
-        } else {
-            reflectionCacheSize
-        }
-        creatorCache = LRUMap(initialEntries, reflectionCacheSize)
-    }
-
     fun getJmClass(clazz: Class<*>): JmClass? {
-        val optional = classCache.get(clazz)
-
-        return if (optional != null) {
-            optional
-        } else {
-            val value = Optional.ofNullable(JmClass.createOrNull(clazz))
+        return classCache[clazz] ?: run {
+            val kmClass = clazz.toKmClass() ?: return null
+
+            // Do not parse super class for interfaces.
+            val superJmClass = if (!clazz.isInterface) {
+                clazz.superclass
+                    ?.takeIf { it != Any::class.java } // Stop parsing when `Object` is reached
+                    ?.let { getJmClass(it) }
+            } else {
+                null
+            }
+            val interfaceJmClasses = clazz.interfaces.mapNotNull { getJmClass(it) }
+
+            val value = JmClass(clazz, kmClass, superJmClass, interfaceJmClasses)
             (classCache.putIfAbsent(clazz, value) ?: value)
-        }.orElse(null)
-    }
-
-    /**
-     * return null if declaringClass is not kotlin class
-     */
-    fun valueCreatorFromJava(creator: Executable): ValueCreator<*>? = when (creator) {
-        is Constructor<*> -> {
-            creatorCache.get(creator)
-                ?: run {
-                    getJmClass(creator.declaringClass)?.let {
-                        val value = ConstructorValueCreator(creator, it)
-                        creatorCache.putIfAbsent(creator, value) ?: value
-                    }
-                }
         }
-
-        is Method -> {
-            creatorCache.get(creator)
-                ?: run {
-                    getJmClass(creator.declaringClass)?.let {
-                        val value = MethodValueCreator<Any?>(creator, it)
-                        creatorCache.putIfAbsent(creator, value) ?: value
-                    }
-                }
-        }
-
-        else -> throw IllegalStateException(
-            "Expected a constructor or method to create a Kotlin object, instead found ${creator.javaClass.name}"
-        )
-    } // we cannot reflect this method so do the default Java-ish behavior
+    }
 
     private fun AnnotatedMethod.getValueClassReturnType(): Class<*>? {
         val getter = this.member.apply {