Hello World Program with Map Struct

MapStruct is an open-source code generation library for Java that simplifies the mapping between Java Beans, DTOs, and other data transfer objects. It generates mapping code at compile time, which can help reduce the amount of boilerplate code needed to map between objects. MapStruct supports various data mapping scenarios, including:

1. Mapping between objects with the same or similar field names.
2. Mapping between objects with different field names.
3. Mapping between objects with distinct types.
4. Mapping between collections and arrays.

MapStruct uses a simple and intuitive annotation-based approach to define the mapping between objects. The annotations are used to specify the mapping between the source and target objects, as well as any conversion or custom mapping logic required. The generated mapping code is efficient and type-safe and can be customized to meet specific application requirements.

Some of the key benefits of using MapStruct include:

1. Improved code readability: MapStruct generates mapping code that is concise and easy to read, making it easier to understand and maintain code.
2. Reduced development time: MapStruct automates the process of mapping between objects, which can save developers time and effort.
3. Improved performance: MapStruct generates optimized mapping code that can improve application performance by reducing the overhead associated with mapping objects at runtime.
4. Reduced errors: MapStruct eliminates the need for manual mapping code, which can reduce the risk of errors and improve the overall quality of the code.

To use MapStruct in a Spring Boot project, you will need to follow the below steps:

Add the MapStruct dependency to your project:

<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct</artifactId>
    <version>1.4.2.Final</version>
</dependency>

Create your source and target DTOs or domain objects.

public class User {
    private Long id;
    private String firstName;
    private String lastName;
    private String email;
    
    // Constructors, getters, and setters
}

public class UserDto {
    private Long id;
    private String firstName;
    private String lastName;
    private String email;
    
    // Constructors, getters, and setters
}

In this example, the User class and UserDto class have the same fields, but they are separate classes with different purposes. The User class might represent a user in a database, while the UserDto class might represent a user’s information as it is displayed in a web application.

Create a mapper interface that defines the mapping methods.

@Mapper
public interface UserMapper {
    UserDTO userToUserDTO(User user);

    User userDTOToUser(UserDTO userDTO);
}

Annotate the mapper interface with the @Mapper annotation.

Use the mapper in your Spring Boot application. For example:

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;
    
    @Autowired
    private UserMapper userMapper;
    
    @GetMapping("/{id}")
    public UserDTO getUserById(@PathVariable("id") Long id) {
        User user = userService.getUserById(id);
        UserDTO userDTO = userMapper.userToUserDTO(user);
        return userDTO;
    }
    
    @PostMapping
    public void createUser(@RequestBody UserDTO userDTO) {
        User user = userMapper.userDTOToUser(userDTO);
        userService.createUser(user);
    }
}

Note: In the above example, we are injecting the UserMapper interface into the UserController class using Spring’s @Autowired annotation.

That’s it! MapStruct will automatically generate the mapping code during the build process and make it available to your Spring Boot application.

Also published on Medium.