ModelMapper vs MapStruct: which is better for Java?

ModelMapper is easier to start with due to its convention-based approach, reducing boilerplate quickly. MapStruct generates code at compile-time, offering better performance but requiring more configuration. Choose ModelMapper for rapid development and MapStruct for performance-critical apps.

How to map nested objects with ModelMapper?

Use the TypeMap API or configure property mappings to handle nested structures. For example, you can define custom mappings for sub-objects using modelMapper.createTypeMap(Source.class, Dest.class).addMappings(...), as detailed in the documentation.

Does ModelMapper support Java Records?

Yes, but it requires the ModelMapper Record module. After registering the module with modelMapper.registerModule(new RecordModule()), ModelMapper can automatically map to and from Java Records based on naming conventions.

What are common ModelMapper performance issues?

Performance issues often stem from reflection overhead in automatic mapping, especially with large object graphs or frequent mappings. Mitigate this by caching TypeMaps, using converters judiciously, or considering compile-time alternatives for high-load scenarios.

How to exclude properties in ModelMapper?

Use the skip() method in property mappings or configure a TypeMap to ignore specific properties. For instance, modelMapper.createTypeMap(Source.class, Dest.class).addMappings(mapper -> mapper.skip(Dest::setUnwantedField)) excludes that field from mapping.

Is ModelMapper good for Spring Boot apps?

Yes, ModelMapper integrates well with Spring Boot, and there's a community-supported starter project, modelmapper-spring-boot-starter, that simplifies auto-configuration and dependency injection for common use cases.

Open-Awesome

ModelMapper

Apache-2.0Java

An intelligent Java library that automatically maps objects to each other using a convention-based approach.

Visit Website GitHub

2.4k stars346 forks0 contributors

What is ModelMapper?

ModelMapper is a Java library that automatically maps data between objects, such as from domain models to DTOs or between different API layers. It uses intelligent conventions to match properties by name and type, eliminating the need for repetitive manual mapping code. The library solves the common problem of writing and maintaining boilerplate mapping logic in Java applications.

Target Audience

Java developers building applications with layered architectures, such as Spring Boot or Jakarta EE projects, where data needs to be transformed between entities, DTOs, and view models.

Value Proposition

Developers choose ModelMapper for its balance of automatic convention-based mapping and a refactoring-safe API for customizations, reducing development time while maintaining type safety and flexibility.

Overview

Intelligent object mapping

Use Cases

Best For

Mapping domain entities to DTOs in REST APIs
Reducing boilerplate code in Spring Boot applications
Transforming data between different object models in layered architectures
Integrating with Protocol Buffers or Java Records via modules
Ensuring type-safe object mappings that survive refactoring
Simplifying data conversion in microservices or enterprise Java apps

Not Ideal For

Performance-critical applications where reflection overhead is unacceptable
Projects requiring explicit, verbose mapping code for auditability or regulatory compliance
Scenarios with highly irregular property naming conventions that deviate significantly from ModelMapper's defaults

Pros & Cons

Pros

Automatic Convention Mapping

Maps properties with matching names and types automatically, eliminating boilerplate code for common cases as highlighted in the key features.

Type-Safe Customization

Provides a refactoring-safe API for custom mappings, ensuring type safety and resilience to code changes during development.

Flexible Configuration

Supports custom property mappings, converters, and conditionals, allowing developers to handle complex scenarios when conventions fall short.

Modular Extensibility

Offers optional modules for Java 8 features, Records, Protocol Buffers, and Vavr, enabling easy integration with modern Java libraries and technologies.

Cons

Reflection Performance Impact

Relies on reflection for automatic mapping, which can introduce performance overhead compared to compile-time alternatives like MapStruct, especially in high-throughput applications.

Setup Complexity for Modules

Advanced integrations, such as with Protocol Buffers or Records, require separate modules and additional registration steps, adding complexity to the initial setup.

Potential Hidden Mapping Errors

Convention-based mapping can lead to subtle bugs if property names or types are misaligned, necessitating thorough testing and validation to ensure correctness.

Frequently Asked Questions

Related Projects

MapStruct

An annotation processor for generating type-safe bean mappers

Stars7,688

Forks1,051

Last commit1 month ago

Orika

Simpler, better and faster Java bean mapping framework

Stars1,313

Forks271

Last commit1 year ago

JMapper

Elegance, high performance and robustness all in one java bean mapper

Stars246

Forks41

Last commit2 years ago

Selma

Selma Java bean mapping that compiles

Stars212

Forks38

Last commit6 years ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub