Exploring the MapStruct Library: Simplifying Object Mapping in Java

Whenever we have worked with Java applications, we have spent a fair amount of time mapping objects from one type to another. Whether it's converting between DTOs and entities, or transforming data for different layers of your application, object mapping is a everywhere and in any technology. While manual mapping is always an option, it can quickly become tedious, error-prone, and a maintenance headache.

What is MapStruct:

MapStruct is a code generator that greatly simplifies the implementation of mappings between Java bean types based on a convention over configuration approach.

The generated mapping code uses plain method invocations and thus is fast, type-safe and easy to understand.

MapStruct is an annotation-based Java library that generates type-safe, high-performance mapping code at compile time

It’s designed to reduce boilerplate code and improve maintainability by mapping fields between source and target objects automatically.

Why Use MapStruct?

• Compile-Time Safety: Errors are caught during compilation rather than at runtime.

• Performance:  Because the mapping logic is compiled directly into your application, there's no runtime overhead associated with reflection. This results in incredibly fast mappings, often on par with hand-written code.

• Clean Code: Eliminates repetitive mapping logic, keeping your codebase lean.

• Customization: Offers flexibility to handle complex mappings with custom methods.

• Integration: Works seamlessly with popular frameworks like Spring and Hibernate.

How to use MapStruct Library:

• Add Maven Dependency :

MapStruct requires an annotation processor to generate the mapper implementations

• Define an Entity:

Entity properties should match with Database columns. By default if table has a column with “_” we can define the property name as programStatus or vice versa.

• Define an DTO:

  DTO can have extra properties than Entity to deal with front end component.

• Define a mapper interface using MapStruct annotations:

  
  

Explanation:

• @Mapper: This annotation tells MapStruct to generate an implementation for this interface.

• ComponentModel=”spring” – This defines Spring to use IoC in our Mapper and it provides instance to use by auto wiring.

• @Mapping(source = "programName", target = "programName") – This annotation explicitly maps fields with different names. MapStruct handles identically named fields automatically.

• @Mapping(target = " programId ", expression = "java(...)"): For more complex mappings, you can use the expression attribute to provide a Java expression. MapStruct will embed this expression directly into the generated code.

• For OneToMany and ManyToMany relationships also we can define mapper methods as above.

• Using the Mapper:

  o   Declare Mapper with AutoWire property to get the instance of Mapper Class and then use Mapper’s methods to convert Entity <> DTO at the service Layer. Convert Entity to DTO before sending response back to the controller layer and same way convert DTO to Entity in service layer to do DB operations on object.

• TroubleShooting: When you compile your project, MapStruct will generate an implementation class (e.g., ProgramMapperImpl.java) in your target/generated-sources/annotations directory. You can inspect this file to see the optimized Java code that MapStruct generates. Or if the expected conversion is not correct we can check in the implementer class how two objects are mapped to each other.

• Advanced Features

  • Nested Mappings: MapStruct can handle nested objects with @Mapping(target = "nested.field", source = "source.field").

  • Custom Methods: Define custom mapping logic in the mapper interface.

  • Collections: Automatically map lists or sets between objects.

  • Spring Integration: Use @Mapper(componentModel = "spring") to integrate with Spring’s dependency injection.

MapStruct is a powerful tool for simplifying object mapping in Java applications. Its compile-time code generation ensures performance and safety, while its flexibility caters to both simple and complex mapping scenarios