Simplifying Object Mapping in Java with ModelMapper

Introduction

Object mapping is a common task in applications and API development. As your application evolves, you may find yourself dealing with different data structures, such as entities from a database, DTOs for communication, and view models for presentation. Manually writing code to map objects from one type to another can be tedious, error-prone, and time-consuming.

This is where ModelMapper comes into play. It automates the process of object mapping, allowing developers to focus on business logic rather than writing repetitive mapping code.

ModelMapper

ModelMapper is a powerful Java library designed to simplify the process of mapping objects from one type to another. It provides a flexible and convention-based approach to object mapping, reducing the boilerplate code typically associated with data transfer between different models.

How to Use ModelMapper?

To use ModelMapper in your Java project, you must include the library as a dependency. If you are using Maven, add the following to your pom.xml:

<dependency>
<groupId>org.modelmapper</groupId>
<artifactId>modelmapper</artifactId>
<version>3.1.1</version>
</dependency>

Related read: React Virtual Dom vs Real Dom

For Gradle, Add the Following to Your Build. gradle:

Implementation ‘org.modelmapper:modelmapper:3.1.1’:

Here’s a Simple Example Demonstrating the Usage of ModelMapper:

public class UserDTO {
private String name;
private String email;
private String phone;
private String dateOfBirth;

//constructor,getters and setters

}

public class UserEntity {
private String name;
private String emailId;
private String phone;
private LocalDate dateOfBirth;

//constructor,getters and setters
}

ModelMapper modelMapper = new ModelMapper();

UserEntity userEntity = new UserEntity("Brock","brock@example.com","1234567890",LocalDate.of(1998, 04, 24));

UserDTO userDTO = modelMapper.map(userEntity, UserDTO.class);

System.out.println("Name :: "+userDTO.getName());
System.out.println("Email :: "+userDTO.getEmail());
System.out.println("Phone :: "+userDTO.getPhone());
System.out.println("Date Of birth:"+userDTO.getDateOfBirth());

In this example, ModelMapper automatically maps properties with matching names and types from UserEntity to UserDTO i.e. email, name, phone, and date of birth.

CustomMapper

Most of the time model mapper handles the conversion but sometimes you may need to handle more complex conversions between types. This is where ModelMapper’s custom converters come into play.

ModelMapper allows the creation of custom converters to handle more complex mappings. You can implement the Converter interface and register it with ModelMapper.

For example:

ModelMapper modelMapper = new ModelMapper();

Converter<Date, String> dateToStringConverter = new Converter<>()
{
@Override
public String convert(MappingContext<Date, String> context)
{
SimpleDateFormat dateFormat = newSimpleDateFormat("yyyy-MM-dd");
return dateFormat.format(context.getSource());
}

// Register the custom converter

modelMapper.addConverter(dateToStringConverter);

UserEntity userEntity = new UserEntity(new Date());
UserDTO userDTO = modelMapper.map(userEntity, UserDTO.class);
System.out.println(userDTO.getDateOfBirth());

In this example, we are formatting the date of birth to the date format we want.

Property Mapping

Property binding refers to the association of properties between source and destination objects during the mapping process. ModelMapper provides a flexible way to handle property binding, allowing developers to configure mappings based on property names or custom expressions.

modelMapper.createTypeMap(UserEntity.class, UserDTO.class)

.addMapping(src -> src.getEmailId(), UserDTO::setEmailAddress);

In this example, we create a custom type mapping and explicitly define the property bindings. We specify that the email ID property in the source object should be bound to the emailAddress property in the destination object.

Conditional Mapping

ModelMapper allows for conditional mapping, where certain mappings are applied based on conditions. This is useful when you want to apply different mappings depending on the state of the source object.

modelMapper.createTypeMap(UserEntity.class, UserDTO.class)
.addMappings(mapping -> mapping.using(ctx -> {
LocalDate dateOfBirth = ((Date)ctx.getSource()).toInstant().atZone(ZoneId.systemDefault()).toLocalDate();

return
String.valueOf(Period.between(dateOfBirth,LocalDate.now()).getYears());
}).map(UserEntity::getDateOfBirth, UserDTO::setAge));

In this example we have calculated age from date of birth and set the value of age in UserDTO object.

Transform Data Easily with ModelMapper! Hire Us for Seamless Java Object Mapping

Ignore Mapping

Sometimes, you may want to ignore certain properties during the mapping process. ModelMapper provides mechanisms to achieve this.

modelMapper.createTypeMap(UserEntity.class, UserDTO.class)
.addMappings(mapping -> mapping.skip(UserDTO::setDateOfBirth));

In this example, we use the skip method to instruct ModelMapper to ignore the dateOfBirth property during mapping.

Collection Mapping

Collection mapping in the context of ModelMapper refers to the process of mapping collections of objects from one type to another. It involves mapping each element within a source collection to its corresponding element in a destination collection.

List<UserEntity> users = Arrays.asList(new UserEntity("Brock","brock@example.com","1234567890",new Date()));

List<UserDTO> userDTOs = modelMapper.map(users, new TypeToken<List<UserDTO>>() {}.getType());

In this example, the ModelMapper will handle each mapping from UserEntity to UserDTO.

coma

Conclusion

ModelMapper significantly simplifies object mapping in Java applications. Whether you are dealing with basic one-to-one mappings or complex hierarchies with nested collections, ModelMapper provides the tools to handle the job efficiently.

By mastering ModelMapper, you can enhance the maintainability and readability of your code, making it easier to adapt to changes in your data model. This guide has covered the basics and advanced features of ModelMapper.

Keep Reading

Keep Reading

Mindbowser is excited to meet healthcare industry leaders and experts from across the globe. Join us from Feb 25th to 28th, 2024, at ViVE 2024 Los Angeles.

Learn More

Let's create something together!