Mapstruct With Kotlin’s Data Classes

By Syed Wahaj

Mapstruct is a powerful code generation library that simplifies mapping between Java beans by generating mapping code at compile time. While Mapstruct is primarily designed for Java, it can also be used with Kotlin, a modern and concise programming language for the Java Virtual Machine (JVM). In this article, we will explore how to use Mapstruct with Kotlin’s data classes to streamline object mapping in Kotlin projects.

1. Introduction to Mapstruct

Mapstruct is an annotation-based code generation library that eliminates the boilerplate code needed for converting one object type to another. It analyzes the mappings defined in interfaces and generates efficient mapping code during the compilation process.

2. Setting Up a Kotlin Project

Before we dive into using Mapstruct, let’s set up a Kotlin project using Gradle:

Step 1: Create a Kotlin Project

Use your preferred IDE or the command line to create a new Kotlin project. For this example, we’ll use Gradle to manage dependencies.

Step 2: Build Configuration

In your build.gradle file, ensure that you have the following dependencies:

plugins {
    id 'org.jetbrains.kotlin.jvm' version '1.5.10'
    id 'org.jetbrains.kotlin.plugin.spring' version '1.5.10'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
}

dependencies {
    implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
    implementation 'org.springframework.boot:spring-boot-starter'
    implementation 'org.mapstruct:mapstruct:1.4.2.Final'
    annotationProcessor 'org.mapstruct:mapstruct-processor:1.4.2.Final'
}

3. Configuring Mapstruct for Kotlin

Mapstruct requires additional configuration to work with Kotlin. Create a kapt block in your build.gradle to specify the location where Mapstruct should generate the mapping code:

kapt {
    arguments {
        arg("mapstruct.defaultComponentModel", "spring")
    }
}

This configuration sets the default component model to “spring,” allowing Mapstruct to integrate smoothly with Spring.

4. Creating Data Classes

In Kotlin, data classes are concise and automatically generate useful methods like equals(), hashCode(), and toString(). Let’s create two data classes: Person and PersonDto, representing the domain object and DTO (Data Transfer Object), respectively:

data class Person(
    val id: Long,
    val firstName: String,
    val lastName: String,
    val age: Int
)

data class PersonDto(
    val id: Long,
    val fullName: String,
    val age: Int
)

5. Defining Mapper Interface

To define the mapping between Person and PersonDto, create a Mapstruct mapper interface:

import org.mapstruct.Mapper
import org.mapstruct.Mapping

@Mapper
interface PersonMapper {

    @Mapping(target = "fullName", expression = "java(person.getFirstName() + ' ' + person.getLastName())")
    fun toDto(person: Person): PersonDto
}

In this interface, we use the @Mapper annotation to let Mapstruct know that this interface contains mapping definitions. The toDto() function maps a Person object to a PersonDto, using the expression attribute to concatenate the first and last names.

6. Generating Mapping Code

With the Mapper interface defined, the next step is to generate the mapping code. Run the following command in your project directory:

./gradlew build

This command triggers the code generation process, and Mapstruct will generate the implementation for the PersonMapper interface.

7. Using the Mapper

Now that the mapping code is generated, you can use the PersonMapper in your Kotlin code:

fun main() {
    val person = Person(1L, "John", "Doe", 30)
    val mapper = PersonMapperImpl() // Mapstruct generates the implementation with "Impl" suffix

    val personDto = mapper.toDto(person)

    println(personDto)
}

When you run the code above, it will output:

PersonDto(id=1, fullName=John Doe, age=30)

8. Conclusion

Mapstruct is a fantastic tool that simplifies object mapping in Java projects. By using it with Kotlin’s data classes, we can achieve the same benefits and eliminate the boilerplate code associated with mapping objects manually. By following the steps outlined in this article, you can easily set up Mapstruct in your Kotlin projects and enjoy the benefits of seamless object mapping.

Remember to keep your Kotlin data classes and DTOs concise and ensure that your mapping logic remains clear and readable. This will help you maintain a clean and organized codebase, making it easier to manage complex projects.

Happy coding with Mapstruct and Kotlin!