Deserialization（冒頭）

ついでに古い内容は削除

Author: k163377

README.md

@@ -220,184 +220,13 @@ val mapper: KRowMapper<Dst> = KRowMapper(::Dst, parameterNameConverter)
 By using the contents described so far, you can perform more flexible and safe mapping compared to `BeanPropertyRowMapper`.
 In addition, by making full use of the abundant functions provided by `KRowMapper`, further labor saving is possible.
 
-### Deserialize column
-`KRowMapper` provides a deserialization function for the acquisition results of three patterns.
+### Deserialization
+Since `KRowMapper` gets the value from `java.sql.ResultSet`, by default it is not possible to get the type which is not supported by this implementation.
+To deal with this problem, `KRowMapper` provides the following three types of deserialization methods in addition to the default conversion function.
 
-- Deserialize at initialization using the `factory method` or deserialize on initialize.
-- Define a deserializer for the `class`.
-- Define custom deserializer `annotation`.
-
-#### Deserialize at initialization using the factory method or deserialize on initialize
-Deserialization within a `factory method` or initialization is the simplest method.  
-Also, deserialization from multiple columns to one argument or from one column to multiple arguments cannot be realized other than this method.
-
-```kotlin
-// example of deserialize on factory method
-data class Dst(
-    foo: Foo,
-    bar: Bar,
-    baz: Baz?,
-    ...
-) {
-    companion object {
-        fun factory(
-            foo: String,
-            bar: String,
-            baz: Int?,
-            ...
-        ): Dst {
-            return Dst(
-                Foo(foo),
-                Bar.fromString(bar),
-                baz?.let { Baz(it) },
-                ...
-            )
-        }
-    }
-}
-
-val dst: Dst = jdbcTemplate.query(query, KRowMapper((Dst)::factory))
-```
-
-#### Define a deserializer for the class
-By assigning the `KColumnDeserializer` `annotation` to the `constructor` or `factory method`, deserialization by the `KFunction` can be performed.  
-The `method` that assigns this `annotation` must have one argument.
-
-When the deserializer is defined in this way, the destination will be as follows.
-
-```kotlin
-data class Dst(
-    val foo: ByConstructor,
-    val bar: BySecondaryConstructor,
-    val baz: ByCompanionObject,
-    val qux: ByStaticMethod
-)
-```
-
-##### constructor
-```kotlin
-data class ByConstructor @KColumnDeserializer constructor(val fooString: String)
-```
-
-##### secondary constructor
-```kotlin
-data class BySecondaryConstructor(val barShort: Short) {
-    @KColumnDeserializer
-    constructor(bar: String) : this(bar.toShort())
-}
-``` 
-
-##### factory method
-```kotlin
-data class ByCompanionObject(val bazInt: Int) {
-    companion object {
-        @KColumnDeserializer
-        fun factory(baz: String) = ByCompanionObject(baz.toInt())
-    }
-}
-```
-
-##### (static method)
-`Java` `static method` is also supported.
-
-```java
-public class ByStaticMethod {
-    private final String quxString;
-
-    public ByStaticMethod(String quxString) {
-        this.quxString = quxString;
-    }
-
-    public String getQuxString() {
-        return quxString;
-    }
-
-    @KColumnDeserializer
-    public static ByStaticMethod factory(Integer quxArg) {
-        return new ByStaticMethod(quxArg.toString());
-    }
-}
-```
-
-#### Define custom deserializer annotation
-`KRowMapper` supports complex deserialization by defining custom deserializer `annotations`.  
-As an example, a custom deserializer `annotation` that performs deserialization from a `String` to `LocalDateTime` is shown.
-
-```kotlin
-// annotation
-@Target(AnnotationTarget.VALUE_PARAMETER)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
-@KColumnDeserializeBy(LocalDateTimeDeserializerImpl::class)
-annotation class LocalDateTimeDeserializer(val pattern: String = "yyyy-MM-dd'T'HH:mm:ss")
-
-// deserializer
-class LocalDateTimeDeserializerImpl(
-    annotation: LocalDateTimeDeserializer
-) : AbstractKColumnDeserializer<LocalDateTimeDeserializer, String, LocalDateTime>(annotation) {
-    private val formatter: DateTimeFormatter = DateTimeFormatter.ofPattern(annotation.pattern)
-
-    override val srcClass: Class<String> = String::class.javaObjectType
-
-    override fun deserialize(source: String?): LocalDateTime? {
-        return source?.let {
-            LocalDateTime.parse(it, formatter)
-        }
-    }
-}
-```
-
-```kotlin
-// usage
-data class Dst(@LocalDateTimeDeserializer val dateTime: LocalDateTime)
-```
-
-##### annotation
-For the `annotation class`, specify the deserializer `class` with the `KColumnDeserializeBy` `annotation`.  
-Also, the fields prepared for this `annotation class` can be used from the deserializer.
-
-```kotlin
-@Target(AnnotationTarget.VALUE_PARAMETER)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
-// LocalDateTimeDeserializerImpl is deserializer class
-@KColumnDeserializeBy(LocalDateTimeDeserializerImpl::class)
-annotation class LocalDateTimeDeserializer(val pattern: String = "yyyy-MM-dd'T'HH:mm:ss")
-```
-
-##### deserializer
-Deserializer is created by inheriting `AbstractKColumnDeserializer`.  
-The meaning of each type parameter is as follows.
-
-- `A`: `Annotation class` (`LocalDateTimeDeserializer` in this example)
-- `S`: `Java class` of argument required at deserialization
-- `D`: `Class` returned after deserialization
-
-```kotlin
-abstract class AbstractKColumnDeserializer<A : Annotation, S : Any, D : Any>(protected val annotation: A) {
-    abstract val srcClass: Class<S>
-    abstract fun deserialize(source: S?): D?
-}
-```
-
-In the example, deserialization from a `String` to `LocalDateTime` is performed based on the `pattern` obtained from the
- `LocalDateTimeDeserializer`.
-
-```kotlin
-class LocalDateTimeDeserializerImpl(
-    annotation: LocalDateTimeDeserializer
-) : AbstractKColumnDeserializer<LocalDateTimeDeserializer, String, LocalDateTime>(annotation) {
-    private val formatter: DateTimeFormatter = DateTimeFormatter.ofPattern(annotation.pattern)
-
-    override val srcClass: Class<String> = String::class.javaObjectType
-
-    override fun deserialize(source: String?): LocalDateTime? {
-        return source?.let {
-            LocalDateTime.parse(it, formatter)
-        }
-    }
-}
-```
+1. Deserialization by using the `KColumnDeserializer` annotation.
+2. Deserialization by creating your own custom deserialization annotations.
+3. Deserialization from multiple arguments.
 
 ### Use default arguments
 `KRowMapper` supports `default arguments`.