Merge pull request #137 from ProjectMapK/develop

For release 2.15.2-beta3

Author: k163377

README.md

@@ -10,7 +10,7 @@ This project has the following features compared to `jackson-module-kotlin`.
 - 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)
+![](https://docs.google.com/spreadsheets/d/e/2PACX-1vSDpaOENd0a-qO_zK7C5_UkSxEKk7BxLjmyg8XVnPP0jj6J5rgoA8cCnm_lj7lflx6NDjvC1yMUPrce/pubchart?oid=1594997844&format=image)
 
 This project is experimental, but passes all the tests implemented in `jackson-module-kotlin` except for the intentional incompatibility.
 

build.gradle.kts

@@ -14,7 +14,7 @@ val jacksonVersion = "2.15.2"
 val generatedSrcPath = "$buildDir/generated/kotlin"
 
 group = groupStr
-version = "${jacksonVersion}-beta0"
+version = "${jacksonVersion}-beta3"
 
 repositories {
     mavenCentral()
@@ -33,6 +33,7 @@ dependencies {
     testImplementation("io.mockk:mockk:1.13.3")
 
     testImplementation("com.fasterxml.jackson.dataformat:jackson-dataformat-xml")
+    testImplementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310")
 }
 
 kotlin {

docs/KogeraSpecificImplementations.md

@@ -2,15 +2,6 @@ In `jackson-module-kogera`, there are several intentional design changes that ar
 This page summarizes them.
 
 # Common
-## Set `Kotlin Property` as positive and ignore functions.
-In `jackson-module-kotlin`, functions with getterLike or setterLike names are handled in the same way as `Kotlin Property`.  
-On the other hand, this implementation causes discrepancies between the `Kotlin` description and the processing results by `Jackson`.
-
-Therefore, `kogera` processes only `Kotlin Property` and excludes other functions from processing.  
-In addition, `kogera` uses the content defined in `Kotlin` as its name.
-
-These changes make it impossible to manipulate the results using `JvmName`.
-
 ## Change of `hasRequiredMarker` specification
 The `KotlinAnnotationIntrospector::hasRequiredMarker` function in `jackson-module-kotlin` has several problems.
 In `kogera`, the specification has been revised as follows.

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

@@ -0,0 +1,41 @@
+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
+
+/**
+ * A converter that only performs box processing for the value class.
+ * Note that constructor-impl is not called.
+ * @param S is nullable because value corresponds to a nullable value class.
+ *   see [io.github.projectmapk.jackson.module.kogera.annotation_introspector.KotlinFallbackAnnotationIntrospector.findNullSerializer]
+ */
+internal class ValueClassBoxConverter<S : Any?, D : Any>(
+    unboxedClass: Class<S>,
+    val valueClass: Class<D>
+) : StdConverter<S, D>() {
+    private val boxMethod = valueClass.getDeclaredMethod("box-impl", unboxedClass).apply {
+        if (!this.isAccessible) this.isAccessible = true
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    override fun convert(value: S): D = boxMethod.invoke(null, value) as D
+
+    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) }
+}

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

@@ -6,14 +6,16 @@ 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 typealias JavaDuration = java.time.Duration
+internal typealias KotlinDuration = kotlin.time.Duration
+
 internal fun Class<*>.isUnboxableValueClass() = this.getAnnotation(JvmInline::class.java) != null
 
 internal fun Class<*>.toKmClass(): KmClass? = this.getAnnotation(Metadata::class.java)
@@ -67,8 +69,7 @@ private val Class<*>.descriptor: String
         else -> "L${this.descName()};"
     }
 
-internal fun Field.toSignature(): JvmFieldSignature =
-    JvmFieldSignature(this.name, this.type.descriptor)
+internal fun Field.desc(): String = this.type.descriptor
 
 internal fun List<KmValueParameter>.hasVarargParam(): Boolean =
     lastOrNull()?.let { it.varargElementType != null } ?: false

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

@@ -15,7 +15,7 @@ import java.lang.reflect.Method
 
 // Jackson Metadata Class
 internal class JmClass(
-    private val clazz: Class<*>,
+    clazz: Class<*>,
     kmClass: KmClass,
     superJmClass: JmClass?,
     interfaceJmClasses: List<JmClass>
@@ -47,15 +47,15 @@ internal class JmClass(
 
     fun findKmConstructor(constructor: Constructor<*>): KmConstructor? {
         val descHead = constructor.parameterTypes.toDescBuilder()
-        val desc = CharArray(descHead.length + 1).apply {
-            descHead.getChars(0, descHead.length, this, 0)
-            this[this.lastIndex] = 'V'
+        val len = descHead.length
+        val desc = CharArray(len + 1).apply {
+            descHead.getChars(0, len, this, 0)
+            this[len] = 'V'
         }.let { String(it) }
 
         // Only constructors that take a value class as an argument have a DefaultConstructorMarker on the Signature.
         val valueDesc = descHead
-            .deleteCharAt(descHead.length - 1)
-            .append("Lkotlin/jvm/internal/DefaultConstructorMarker;)V")
+            .replace(len - 1, len, "Lkotlin/jvm/internal/DefaultConstructorMarker;)V")
             .toString()
 
         // Constructors always have the same name, so only desc is compared
@@ -67,7 +67,7 @@ internal class JmClass(
 
     // Field name always matches property name
     fun findPropertyByField(field: Field): KmProperty? = allPropsMap[field.name]
-        ?.takeIf { it.fieldSignature == field.toSignature() }
+        ?.takeIf { it.fieldSignature?.desc == field.desc() }
 
     fun findPropertyByGetter(getter: Method): KmProperty? {
         val signature = getter.toSignature()
@@ -81,7 +81,7 @@ internal class JmClass(
         private val companionField: Field = declaringClass.getDeclaredField(companionObject)
         val type: Class<*> = companionField.type
         val isAccessible: Boolean = companionField.isAccessible
-        private val kmClass: KmClass by lazy { type.toKmClass()!! }
+        private val functions by lazy { type.toKmClass()!!.functions }
         val instance: Any by lazy {
             // To prevent the call from failing, save the initial value and then rewrite the flag.
             if (!companionField.isAccessible) companionField.isAccessible = true
@@ -90,7 +90,7 @@ internal class JmClass(
 
         fun findFunctionByMethod(method: Method): KmFunction? {
             val signature = method.toSignature()
-            return kmClass.functions.find { it.signature == signature }
+            return functions.find { it.signature == signature }
         }
     }
 }

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

@@ -73,7 +73,16 @@ public enum class KotlinFeature(internal val enabledByDefault: Boolean) {
      *
      * @see KotlinClassIntrospector
      */
-    CopySyntheticConstructorParameterAnnotations(enabledByDefault = false);
+    CopySyntheticConstructorParameterAnnotations(enabledByDefault = false),
+
+    /**
+     * This feature represents whether to handle [kotlin.time.Duration] using [java.time.Duration] as conversion bridge.
+     *
+     * This allows use Kotlin Duration type with [com.fasterxml.jackson.datatype.jsr310.JavaTimeModule].
+     * `@JsonFormat` annotations need to be declared either on getter using `@get:JsonFormat` or field using `@field:JsonFormat`.
+     * See [jackson-module-kotlin#651] for details.
+     */
+    UseJavaDurationConversion(enabledByDefault = false);
 
     internal val bitSet: BitSet = (1 shl ordinal).toBitSet()
 

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

@@ -8,6 +8,7 @@ import io.github.projectmapk.jackson.module.kogera.KotlinFeature.NullToEmptyColl
 import io.github.projectmapk.jackson.module.kogera.KotlinFeature.NullToEmptyMap
 import io.github.projectmapk.jackson.module.kogera.KotlinFeature.SingletonSupport
 import io.github.projectmapk.jackson.module.kogera.KotlinFeature.StrictNullChecks
+import io.github.projectmapk.jackson.module.kogera.KotlinFeature.UseJavaDurationConversion
 import io.github.projectmapk.jackson.module.kogera.annotation_introspector.KotlinFallbackAnnotationIntrospector
 import io.github.projectmapk.jackson.module.kogera.annotation_introspector.KotlinPrimaryAnnotationIntrospector
 import io.github.projectmapk.jackson.module.kogera.deser.deserializers.KotlinDeserializers
@@ -32,6 +33,8 @@ import java.util.*
  *                                      the default, collections which are typed to disallow null members
  *                                      (e.g. List<String>) may contain null values after deserialization.  Enabling it
  *                                      protects against this but has significant performance impact.
+ * @param useJavaDurationConversion Default: false.  Whether to use [java.time.Duration] as a bridge for [kotlin.time.Duration].
+ *                                      This allows use Kotlin Duration type with [com.fasterxml.jackson.datatype.jsr310.JavaTimeModule].
  */
 // Do not delete default arguments,
 // as this will cause an error during initialization by Spring's Jackson2ObjectMapperBuilder.
@@ -43,7 +46,8 @@ public class KotlinModule private constructor(
     public val singletonSupport: Boolean = SingletonSupport.enabledByDefault,
     public val strictNullChecks: Boolean = StrictNullChecks.enabledByDefault,
     public val copySyntheticConstructorParameterAnnotations: Boolean =
-        CopySyntheticConstructorParameterAnnotations.enabledByDefault
+        CopySyntheticConstructorParameterAnnotations.enabledByDefault,
+    public val useJavaDurationConversion: Boolean = UseJavaDurationConversion.enabledByDefault
 ) : SimpleModule(KotlinModule::class.java.name, kogeraVersion) { // kogeraVersion is generated by building.
     private constructor(builder: Builder) : this(
         builder.reflectionCacheSize,
@@ -52,7 +56,8 @@ public class KotlinModule private constructor(
         builder.isEnabled(NullIsSameAsDefault),
         builder.isEnabled(SingletonSupport),
         builder.isEnabled(StrictNullChecks),
-        builder.isEnabled(CopySyntheticConstructorParameterAnnotations)
+        builder.isEnabled(CopySyntheticConstructorParameterAnnotations),
+        builder.isEnabled(UseJavaDurationConversion)
     )
 
     @Deprecated(
@@ -87,16 +92,18 @@ public class KotlinModule private constructor(
         context.insertAnnotationIntrospector(
             KotlinPrimaryAnnotationIntrospector(nullToEmptyCollection, nullToEmptyMap, cache)
         )
-        context.appendAnnotationIntrospector(KotlinFallbackAnnotationIntrospector(strictNullChecks, cache))
+        context.appendAnnotationIntrospector(
+            KotlinFallbackAnnotationIntrospector(strictNullChecks, useJavaDurationConversion, cache)
+        )
 
         if (copySyntheticConstructorParameterAnnotations) {
             context.setClassIntrospector(KotlinClassIntrospector)
         }
 
-        context.addDeserializers(KotlinDeserializers(cache))
+        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)

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

@@ -2,15 +2,14 @@ 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.ser.ValueClassBoxConverter
 import java.io.Serializable
 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 = 2L
+        private const val serialVersionUID = 3L
     }
 
     // This cache is used for both serialization and deserialization, so reserve a larger size from the start.
@@ -24,16 +23,19 @@ 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 {
             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) }
+                clazz.superclass?.let {
+                    // Stop parsing when `Object` is reached
+                    if (it != Any::class.java) getJmClass(it) else null
+                }
             } else {
                 null
             }
@@ -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)
+        }
 }