Better way to map Kotlin data objects to data obje

问题:

I want to convert/map some "data" class objects to similar "data" class objects. For example, classes for web form to classes for database records.

data class PersonForm(
    val firstName: String,
    val lastName: String,
    val age: Int,
    // maybe many fields exist here like address, card number, etc.
    val tel: String
)
// maps to ...
data class PersonRecord(
    val name: String, // "${firstName} ${lastName}"
    val age: Int, // copy of age
    // maybe many fields exist here like address, card number, etc.
    val tel: String // copy of tel
)

I use ModelMapper for such works in Java, but it can't be used because data classes are final (ModelMapper creates CGLib proxies to read mapping definitions). We can use ModelMapper when we make these classes/fields open, but we must implement features of "data" class manually. (cf. ModelMapper examples: https://github.com/jhalterman/modelmapper/blob/master/examples/src/main/java/org/modelmapper/gettingstarted/GettingStartedExample.java)

How to map such "data" objects in Kotlin?

Update: ModelMapper automatically maps fields that have same name (like tel -> tel) without mapping declarations. I want to do it with data class of Kotlin.

Update: The purpose of each classes depends on what kind of application, but these are probably placed in the different layer of an application.

For example:

• data from database (Database Entity) to data for HTML form (Model/View Model)
• REST API result to data for database

These classes are similar, but are not the same.

I want to avoid normal function calls for these reasons:

• It depends on the order of arguments. A function for a class with many fields that have same type (like String) will be broken easily.
• Many declarations are nesessary though most mappings can be resolved with naming convention.

Of course, a library that has similar feature is intended, but information of the Kotlin feature is also welcome (like spreading in ECMAScript).

回答1:

1. Simplest (best?):

   fun PersonForm.toPersonRecord() = PersonRecord(
           name = "$firstName $lastName",
           age = age,
           tel = tel
   )
   

2. Reflection (not great performance):

   fun PersonForm.toPersonRecord() = with(PersonRecord::class.primaryConstructor!!) {
       val propertiesByName = PersonForm::class.memberProperties.associateBy { it.name }
       callBy(args = parameters.associate { parameter ->
           parameter to when (parameter.name) {
               "name" -> "$firstName $lastName"
               else -> propertiesByName[parameter.name]?.get(this@toPersonRecord)
           }
       })
   }
   

3. Cached reflection (okay performance but not as fast as #1):

   open class Transformer<in T : Any, out R : Any>
   protected constructor(inClass: KClass<T>, outClass: KClass<R>) {
       private val outConstructor = outClass.primaryConstructor!!
       private val inPropertiesByName by lazy {
           inClass.memberProperties.associateBy { it.name }
       }
   
       fun transform(data: T): R = with(outConstructor) {
           callBy(parameters.associate { parameter ->
               parameter to argFor(parameter, data)
           })
       }
   
       open fun argFor(parameter: KParameter, data: T): Any? {
           return inPropertiesByName[parameter.name]?.get(data)
       }
   }
   
   val personFormToPersonRecordTransformer = object
   : Transformer<PersonForm, PersonRecord>(PersonForm::class, PersonRecord::class) {
       override fun argFor(parameter: KParameter, data: PersonForm): Any? {
           return when (parameter.name) {
               "name" -> with(data) { "$firstName $lastName" }
               else -> super.argFor(parameter, data)
           }
       }
   }
   
   fun PersonForm.toPersonRecord() = personFormToPersonRecordTransformer.transform(this)
   

4. Storing Properties in a Map

   data class PersonForm(val map: Map<String, Any?>) {
       val firstName: String   by map
       val lastName: String    by map
       val age: Int            by map
       // maybe many fields exist here like address, card number, etc.
       val tel: String         by map
   }
   
   // maps to ...
   data class PersonRecord(val map: Map<String, Any?>) {
       val name: String    by map // "${firstName} ${lastName}"
       val age: Int        by map // copy of age
       // maybe many fields exist here like address, card number, etc.
       val tel: String     by map // copy of tel
   }
   
   fun PersonForm.toPersonRecord() = PersonRecord(HashMap(map).apply {
       this["name"] = "${remove("firstName")} ${remove("lastName")}"
   })
   

回答2:

Is this are you looking for?

data class PersonRecord(val name: String, val age: Int, val tel: String){       
    object ModelMapper {
        fun from(form: PersonForm) = 
            PersonRecord(form.firstName + form.lastName, form.age, form.tel)           
    }
}

and then:

val personRecord = PersonRecord.ModelMapper.from(personForm)

回答3:

Use MapStruct:

@Mapper
interface PersonConverter {

    @Mapping(source = "phoneNumber", target = "phone")
    fun convertToDto(person: Person) : PersonDto

    @InheritInverseConfiguration
    fun convertToModel(personDto: PersonDto) : Person

}

Use:

val converter = Mappers.getMapper(PersonConverter::class.java) // or PersonConverterImpl()

val person = Person("Samuel", "Jackson", "0123 334466", LocalDate.of(1948, 12, 21))

val personDto = converter.convertToDto(person)
println(personDto)

val personModel = converter.convertToModel(personDto)
println(personModel)

https://github.com/mapstruct/mapstruct-examples/tree/master/mapstruct-kotlin

回答4:

Do you really want a separate class for that? You can add properties to the original data class:

data class PersonForm(
    val firstName: String,
    val lastName: String,
    val age: Int,
    val tel: String
) {
    val name = "${firstName} ${lastName}"
}

回答5:

This works using Gson:

inline fun <reified T : Any> Any.mapTo(): T =
    GsonBuilder().create().run {
        toJson(this@mapTo).let { fromJson(it, T::class.java) }
    }

fun PersonForm.toRecord(): PersonRecord =
    mapTo<PersonRecord>().copy(
        name = "$firstName $lastName"
    )

fun PersonRecord.toForm(): PersonForm =
    mapTo<PersonForm>().copy(
        firstName = name.split(" ").first(),
        lastName = name.split(" ").last()
    )

with not nullable values allowed to be null because Gson uses sun.misc.Unsafe..

回答6:

You can use ModelMapper to map to a Kotlin data class. The keys are:

• Use @JvmOverloads (generates a constructor with no arguments)
• Default values for data class member

• Mutable member, var instead of val

  data class AppSyncEvent @JvmOverloads constructor(
      var field: String = "",
      var arguments: Map<String, *> = mapOf<String, Any>(),
      var source: Map<String, *> = mapOf<String, Any>()
  )
  
  val event = ModelMapper().map(request, AppSyncEvent::class.java)