java mapstruct dto mapping

MapStruct for object mapping

David Kumar Jan 2026

3 tabs

package com.example.demo.mapper;

import com.example.demo.dto.UserDTO;
import com.example.demo.model.User;
import org.mapstruct.*;

import java.util.List;

@Mapper(componentModel = "spring")
public interface UserMapper {

    @Mapping(source = "email", target = "emailAddress")
    @Mapping(target = "fullName", expression = "java(user.getFirstName() + " " + user.getLastName())")
    UserDTO toDto(User user);

    @Mapping(source = "emailAddress", target = "email")
    @Mapping(target = "createdAt", ignore = true)
    User toEntity(UserDTO dto);

    List<UserDTO> toDtoList(List<User> users);

    @BeanMapping(nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.IGNORE)
    void updateUserFromDto(UserDTO dto, @MappingTarget User user);
}

package com.example.demo.dto;

import lombok.Data;

@Data
public class UserDTO {
    private Long id;
    private String fullName;
    private String emailAddress;
    private boolean active;
}

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;
    private final UserMapper userMapper;

    public UserController(UserService userService, UserMapper userMapper) {
        this.userService = userService;
        this.userMapper = userMapper;
    }

    @GetMapping
    public ResponseEntity<List<UserDTO>> getAllUsers() {
        List<User> users = userService.findAll();
        List<UserDTO> dtos = userMapper.toDtoList(users);
        return ResponseEntity.ok(dtos);
    }

    @PostMapping
    public ResponseEntity<UserDTO> createUser(@RequestBody UserDTO dto) {
        User user = userMapper.toEntity(dto);
        User saved = userService.save(user);
        return ResponseEntity.status(HttpStatus.CREATED)
            .body(userMapper.toDto(saved));
    }

    @PatchMapping("/{id}")
    public ResponseEntity<UserDTO> partialUpdate(
        @PathVariable Long id,
        @RequestBody UserDTO dto
    ) {
        return userService.findById(id)
            .map(existing -> {
                userMapper.updateUserFromDto(dto, existing);
                User updated = userService.save(existing);
                return ResponseEntity.ok(userMapper.toDto(updated));
            })
            .orElse(ResponseEntity.notFound().build());
    }
}

3 files · java Explain with highlit

MapStruct generates type-safe bean mappers at compile-time, eliminating manual mapping code. I define mapper interfaces with @Mapper annotation—MapStruct generates implementations. @Mapping annotations handle different property names or custom conversions. The approach is faster than reflection-based mappers like ModelMapper because code generation happens at compile-time. Mappers convert between entities and DTOs, preventing exposure of domain models in APIs. Spring integration uses componentModel = "spring" for dependency injection. Collection mappings work automatically. Custom mapping methods handle complex transformations. MapStruct validates mappings at compile-time, catching errors early. The tool reduces boilerplate while maintaining type safety and performance—essential for clean architecture separating layers.