Merge pull request #4 from k163377/feature

Add class deserializer support.

Author: k163377

.idea/KMapper.iml

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = "com.mapk"
-version = "0.2"
+version = "0.3"
 
 java {
     sourceCompatibility = JavaVersion.VERSION_1_8
@@ -30,8 +30,8 @@ repositories {
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
     implementation(kotlin("reflect"))
-    // 使うのはRowMapperのみなため、他はexclude
-    implementation(group = "org.springframework", name = "spring-jdbc", version = "5.2.4.RELEASE") {
+    // 使うのはRowMapperのみなため他はexclude、またバージョンそのものは使う相手に合わせるためcompileOnly
+    compileOnly(group = "org.springframework", name = "spring-jdbc", version = "5.2.4.RELEASE") {
         exclude(module = "spring-beans")
         exclude(module = "spring-jcl")
         exclude(module = "spring-tx")
@@ -47,6 +47,8 @@ dependencies {
     // 現状プロパティ名の変換はテストでしか使っていないのでtestImplementation
     // https://mvnrepository.com/artifact/com.google.guava/guava
     testImplementation(group = "com.google.guava", name = "guava", version = "28.2-jre")
+    // テスト時には無いと困るため、別口でimplementation
+    testImplementation(group = "org.springframework", name = "spring-jdbc", version = "5.2.4.RELEASE")
 }
 
 tasks {

.idea/modules/KMapper.main.iml

@@ -0,0 +1,6 @@
+package com.mapk.annotations
+
+@Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION)
+@Retention(AnnotationRetention.RUNTIME)
+@MustBeDocumented
+annotation class KColumnDeserializer

.idea/modules/KMapper.test.iml

@@ -1,6 +1,5 @@
 package com.mapk.krowmapper
 
-import com.mapk.core.EnumMapper
 import com.mapk.core.KFunctionForCall
 import com.mapk.core.isUseDefaultArgument
 import com.mapk.core.toKConstructor
@@ -22,24 +21,17 @@ class KRowMapper<T : Any> private constructor(
         clazz.toKConstructor(), propertyNameConverter
     )
 
-    private val parameters: List<ParameterForMap<*>> = function.parameters
+    private val parameters: List<ParameterForMap> = function.parameters
         .filter { it.kind != KParameter.Kind.INSTANCE && !it.isUseDefaultArgument() }
         .map { ParameterForMap.newInstance(it, propertyNameConverter) }
 
     override fun mapRow(rs: ResultSet, rowNum: Int): T {
         val argumentBucket = function.getArgumentBucket()
 
         parameters.forEach { param ->
-            argumentBucket.putIfAbsent(param.param, when {
-                param.clazz.isEnum -> EnumMapper.getEnum(param.clazz, rs.getObject(param.name, stringClazz))
-                else -> rs.getObject(param.name, param.clazz)
-            })
+            argumentBucket.putIfAbsent(param.param, param.getObject(rs))
         }
 
         return function.call(argumentBucket)
     }
-
-    companion object {
-        private val stringClazz = String::class.java
-    }
 }

build.gradle.kts

@@ -1,21 +1,87 @@
 package com.mapk.krowmapper
 
+import com.mapk.annotations.KColumnDeserializer
+import com.mapk.core.EnumMapper
+import com.mapk.core.KFunctionWithInstance
 import com.mapk.core.getAliasOrName
+import java.lang.IllegalArgumentException
+import java.sql.ResultSet
 import kotlin.reflect.KClass
+import kotlin.reflect.KFunction
 import kotlin.reflect.KParameter
+import kotlin.reflect.full.companionObjectInstance
+import kotlin.reflect.full.functions
+import kotlin.reflect.full.staticFunctions
+import kotlin.reflect.jvm.isAccessible
+import kotlin.reflect.jvm.jvmName
 
-class ParameterForMap<D : Any> private constructor(
-    val name: String,
+class ParameterForMap private constructor(
     val param: KParameter,
-    val clazz: Class<D>
+    private val name: String,
+    kClazz: KClass<*>
 ) {
+    private val javaClazz: Class<*> = kClazz.java
+    private val deserializer: KFunction<*>?
+
+    init {
+        val deserializers = deserializerFromConstructors(kClazz) +
+                deserializerFromStaticMethods(kClazz) +
+                deserializerFromCompanionObject(kClazz)
+
+        deserializer = when {
+            deserializers.isEmpty() -> null
+            deserializers.size == 1 -> deserializers.single()
+            else -> throw IllegalArgumentException("Find multiple deserializer from ${kClazz.jvmName}")
+        }
+    }
+
+    fun getObject(rs: ResultSet): Any? = when {
+        javaClazz.isEnum -> EnumMapper.getEnum(javaClazz, rs.getString(name))
+        else -> {
+            val value: Any? = rs.getObject(name, javaClazz)
+            deserializer?.call(value) ?: value
+        }
+    }
+
     companion object {
-        fun newInstance(param: KParameter, propertyNameConverter: (String) -> String = { it }): ParameterForMap<*> {
+        fun newInstance(param: KParameter, propertyNameConverter: (String) -> String = { it }): ParameterForMap {
             return ParameterForMap(
-                propertyNameConverter(param.getAliasOrName()!!),
                 param,
-                (param.type.classifier as KClass<*>).java
+                propertyNameConverter(param.getAliasOrName()!!),
+                param.type.classifier as KClass<*>
             )
         }
     }
 }
+
+private fun <T> Collection<KFunction<T>>.getDeserializerFromFunctions(): Collection<KFunction<T>> {
+    return filter { it.annotations.any { annotation -> annotation is KColumnDeserializer } }
+        .map { func ->
+            func.isAccessible = true
+            func
+        }
+}
+
+private fun <T : Any> deserializerFromConstructors(clazz: KClass<T>): Collection<KFunction<T>> {
+    return clazz.constructors.getDeserializerFromFunctions()
+}
+
+@Suppress("UNCHECKED_CAST")
+private fun <T : Any> deserializerFromStaticMethods(clazz: KClass<T>): Collection<KFunction<T>> {
+    val staticFunctions: Collection<KFunction<T>> = clazz.staticFunctions as Collection<KFunction<T>>
+    return staticFunctions.getDeserializerFromFunctions()
+}
+
+@Suppress("UNCHECKED_CAST")
+private fun <T : Any> deserializerFromCompanionObject(clazz: KClass<T>): Collection<KFunction<T>> {
+    return clazz.companionObjectInstance?.let { companionObject ->
+        companionObject::class.functions
+            .filter { it.annotations.any { annotation -> annotation is KColumnDeserializer } }
+            .map { function ->
+                KFunctionWithInstance(
+                    function,
+                    companionObject
+                ) as KFunction<T>
+            }.toSet()
+    } ?: emptySet()
+}

src/main/kotlin/com/mapk/annotations/KColumnDeserializer.kt

@@ -0,0 +1,20 @@
+package com.mapk.krowmapper;
+
+import com.mapk.annotations.KColumnDeserializer;
+
+public class ByStaticMethod {
+    private final String bazString;
+
+    public ByStaticMethod(String bazString) {
+        this.bazString = bazString;
+    }
+
+    public String getBazString() {
+        return bazString;
+    }
+
+    @KColumnDeserializer
+    public static ByStaticMethod factory(Integer bazArg) {
+        return new ByStaticMethod(bazArg.toString());
+    }
+}

src/main/kotlin/com/mapk/krowmapper/KRowMapper.kt

@@ -0,0 +1,40 @@
+package com.mapk.krowmapper
+
+import com.mapk.annotations.KColumnDeserializer
+import io.mockk.every
+import io.mockk.mockk
+import java.sql.ResultSet
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+
+class DeserializeByMethodTest {
+    data class ByConstructor @KColumnDeserializer constructor(val fooString: String)
+    data class ByCompanionObject(val barInt: Int) {
+        companion object {
+            @KColumnDeserializer
+            fun factory(bar: String) = ByCompanionObject(bar.toInt())
+        }
+    }
+
+    data class Dst(
+        val foo: ByConstructor,
+        val bar: ByCompanionObject,
+        val baz: ByStaticMethod
+    )
+
+    @Test
+    @DisplayName("マッピングテスト")
+    fun test() {
+        val resultSet = mockk<ResultSet>()
+        every { resultSet.getObject("foo", any<Class<*>>()) } returns "foo"
+        every { resultSet.getObject("bar", any<Class<*>>()) } returns "123"
+        every { resultSet.getObject("baz", any<Class<*>>()) } returns 321
+
+        val result = KRowMapper(::Dst).mapRow(resultSet, 0)
+
+        Assertions.assertEquals("foo", result.foo.fooString)
+        Assertions.assertEquals(123, result.bar.barInt)
+        Assertions.assertEquals("321", result.baz.bazString)
+    }
+}