Comparing ModelMapper and MapStruct in Java: The Power of Automatic Mappers

In Java applications, data mapping is a common task that involves converting objects from one type to another. This process can become complex and tedious, especially when dealing with large and nested classes. To simplify this task, developers often turn to automatic mapping frameworks. Two popular choices for automatic mapping in Java are ModelMapper and MapStruct. In this article, we will compare these frameworks and explore why using an automatic mapper is beneficial over manual mapping.

The Need for Automatic Mappers

Before delving into the comparison, let’s understand why automatic mappers are preferred over manual mapping. Here are some key reasons:

1. Productivity: Manual mapping requires writing boilerplate code to transfer data between classes. It can be time-consuming and error-prone, especially in applications with many classes. Automatic mappers generate the mapping code for you, saving valuable development time.
2. Maintainability: As applications evolve, classes might change, leading to frequent updates in mapping logic. Automatic mappers handle these changes automatically, reducing the risk of introducing bugs during updates.
3. Reduced human errors: Manual mapping involves writing repetitive code, which increases the likelihood of human errors. Automatic mappers ensure consistent and accurate mapping between classes.
4. Readability: Automatic mappers provide a cleaner and more concise mapping code, making it easier for developers to understand the data flow.
5. Flexibility: Automatic mappers often allow customizations and configurations to handle complex mapping scenarios.

ModelMapper vs. MapStruct

ModelMapper and MapStruct are robust and widely used mapping frameworks in the Java ecosystem. Let’s compare them based on various factors:

1. Ease of use: ModelMapper is known for its simplicity and ease of use. It automatically maps fields with the same names and data types. On the other hand, MapStruct requires developers to write explicit mapping interfaces, which can lead to more initial setup but offers more control over the mapping process.
2. Performance: MapStruct performs better than ModelMapper due to its compile-time code generation approach. ModelMapper relies on reflection, which can have a slight performance overhead.
3. Configuration: ModelMapper provides a rich set of configuration options and supports complex mapping scenarios. MapStruct, being a compile-time mapper, requires explicit mapping interfaces, which can be both an advantage (statically typed) and a disadvantage (more initial setup).
4. Customization: Both frameworks allow custom converters to handle specific mapping cases. However, ModelMapper offers more built-in conversions and requires fewer custom converters in many scenarios.

Both ModelMapper and MapStruct are excellent choices for automatic mapping in Java, and the decision to use one over the other primarily depends on the specific requirements and preferences of the project.

Beyond DTO: Various Use Cases of Automatic Mappers

Automatic mappers can be used in several ways beyond simple DTO mapping. Let’s explore some of the additional use cases:

1. Conversion between layers: Automatic mappers can convert domain objects to DTOs, presentation models, or any other data conversion between application layers.
2. Adapter and conversion in legacy code: When dealing with legacy codebases, automatic mappers can act as adapters to bridge the gap between old and new class structures. They make it easier to introduce modern data models while still supporting the existing codebase.
3. API versioning: As applications evolve and introduce new API versions, automatic mappers can convert data models between different versions, ensuring backward compatibility and smooth migration.

The table compares the Java ecosystem's prominent automatic mapping frameworks: ModelMapper and MapStruct. These frameworks offer efficient solutions for converting objects between different types, eliminating the need for manual mapping and boosting developer productivity.

ModelMapper stands out with its user-friendly approach, requiring minimal setup and configuration. Its straightforward usage allows developers to get started with data mapping tasks quickly. The framework’s rich configuration options provide great flexibility, making it capable of handling complex mapping scenarios effortlessly. Additionally, ModelMapper supports custom converters, making it convenient to take specific mapping requirements.

On the other hand, MapStruct follows a compile-time code generation approach, resulting in superior performance compared to ModelMapper. It requires the definition of explicit mapping interfaces, which might involve a bit more setup effort. However, this approach offers greater control over the mapping process, giving developers a fine-grained level of customization.

ModelMapper and MapStruct integrate seamlessly with popular Java frameworks like Spring and CDI, allowing developers to incorporate automatic mapping into their projects with dependency injection support. This seamless integration enables developers to take full advantage of these frameworks’ capabilities while benefiting from the powerful mapping functionalities of ModelMapper or MapStruct.

The choice between ModelMapper and MapStruct depends on project requirements and preferences. ModelMapper shines with its simplicity and feature-rich configuration, while MapStruct excels in performance and provides more control over mappings. Developers can confidently select the most suitable framework based on their specific needs, enhancing the overall development experience and streamlining data mapping tasks in Java applications.

Hands-On Session: Mapping Delivery to DeliveryDTO

Let's dive into a hands-on session where we'll use ModelMapper and MapStruct to map the Delivery class to the DeliveryDTO class.

First, let's define the Delivery class and the DeliveryDTO class:

public class Delivery {

    private UUID trackId;

    private LocalDate when;

    private String city;

    private String country;

}



public record DeliveryDTO(String id, String when, String city, String country) {

}

Using MapStruct:

1. Add the MapStruct dependency to your project. For Maven:

<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct</artifactId>
    <version>${org.mapstruct.version}</version>
</dependency>

2. Create a mapping interface:

@Mapper

public interface DeliveryMapper {



    @Mapping(target = "trackId", source = "id")

    Delivery toEntity(DeliveryDTO dto);



    @Mapping(target = "id", source = "trackId")

    DeliveryDTO toDTO(Delivery entity);

}

3. Perform the mapping:

DeliveryMapper mapper = Mappers.getMapper(DeliveryMapper.class);
Delivery delivery = new Delivery(UUID.randomUUID(), LocalDate.now(), "Salvador", "Brazil");
DeliveryDTO dto = this.mapper.toDTO(delivery);
Delivery entity = this.mapper.toEntity(dto);

Using ModelMapper:

1. Add the ModelMapper dependency to your project. For Maven:

<dependency>
    <groupId>org.modelmapper</groupId>
    <artifactId>modelmapper</artifactId>
    <version>${org.modelmapper.version}</version>
</dependency>

2. Create a new ModelMapper instance:

ModelMapper modelMapper = new ModelMapper();

3. Setting configuration and converters: Unfortunately, the ModelMapper does not work with the records. Thus, we must convert it to a class as the first step and create and define a converter to UUID and LocalDate type as the code below shows.

ModelMapper mapper = new ModelMapper();

mapper.getConfiguration()
        .setFieldMatchingEnabled(true)
        .setFieldAccessLevel(Configuration.AccessLevel.PRIVATE);


Converter<String, UUID> uuidConverter = new AbstractConverter<>() {
    @Override
    protected UUID convert(String source) {
        return UUID.fromString(source);
    }

};


Converter<String, LocalDate> localDateConverter = new AbstractConverter<>() {
    @Override
    protected LocalDate convert(String source) {
       return LocalDate.parse(source);
    }
};


mapper.addConverter(uuidConverter);
mapper.addConverter(localDateConverter);

TypeMap<DeliveryDTO, Delivery> typeMap = this.mapper.createTypeMap(DeliveryDTO.class, Delivery.class);
typeMap.addMappings(mapping -> mapping.using(uuidConverter).map(DeliveryDTO::id, Delivery::setTrackId));

4. Perform the mapping:

Delivery delivery = new Delivery(UUID.randomUUID(), LocalDate.now(), "New York", "USA");
DeliveryDTO deliveryDTO = modelMapper.map(delivery, DeliveryDTO.class);

In this hands-on session, we saw how to use ModelMapper and MapStruct to map the Delivery class to the DeliveryDTO class. Both frameworks make this mapping effortless and allow developers to focus on building the application's core logic rather than spending time on manual mapping.

Conclusion

Automatic mappers like ModelMapper and MapStruct offer significant advantages over manual mapping, improving productivity, maintainability, and reducing errors in data mapping. Choosing the proper mapper depends on the specific needs of your project. Still, ModelMapper and MapStruct are potent tools that simplify complex mapping scenarios and help developers deliver more efficient and maintainable Java applications.

References

• Source ModelMapper
• Source MapStruct
• ModelMapper
• MapStruct