Entity to DTO mapping in Spring Boot

Introduction

Entity to DTO mapping helps separate how data is stored from how it is sent or shown. It keeps your app clean and safe.

When you want to send only some data from your database to the user.

When you want to hide sensitive information like passwords from being sent out.

When you want to change the data format before sending it to the user.

When you want to reduce the amount of data sent over the network.

When you want to keep your database structure separate from your app's public interface.

Syntax

Spring Boot

public class Entity {
    private Long id;
    private String name;
    private String secret;
    // getters and setters
}

public class EntityDTO {
    private Long id;
    private String name;
    // getters and setters
}

// Mapping method example
public EntityDTO toDTO(Entity entity) {
    EntityDTO dto = new EntityDTO();
    dto.setId(entity.getId());
    dto.setName(entity.getName());
    return dto;
}

DTO stands for Data Transfer Object, a simple object to carry data.

Mapping means copying data from Entity to DTO manually or using tools.

Examples

Simple manual mapping copying only needed fields.

Spring Boot

public EntityDTO toDTO(Entity entity) {
    EntityDTO dto = new EntityDTO();
    dto.setId(entity.getId());
    dto.setName(entity.getName());
    return dto;
}

Using MapStruct library to generate mapping code automatically.

Spring Boot

@Mapper
public interface EntityMapper {
    EntityDTO toDTO(Entity entity);
}

Using ModelMapper library to map Entity to DTO in one line.

Spring Boot

EntityDTO dto = modelMapper.map(entity, EntityDTO.class);

Sample Program

This Spring Boot app has a UserEntity with sensitive password. The controller sends UserDTO without password to keep data safe.

Spring Boot

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

class UserEntity {
    private Long id;
    private String username;
    private String password; // sensitive

    public UserEntity(Long id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public Long getId() { return id; }
    public String getUsername() { return username; }
    public String getPassword() { return password; }
}

class UserDTO {
    private Long id;
    private String username;

    public UserDTO(Long id, String username) {
        this.id = id;
        this.username = username;
    }

    public Long getId() { return id; }
    public String getUsername() { return username; }
}

@RestController
class UserController {

    @GetMapping("/user")
    public UserDTO getUser() {
        UserEntity userEntity = new UserEntity(1L, "alice", "secret123");
        return toDTO(userEntity);
    }

    private UserDTO toDTO(UserEntity entity) {
        return new UserDTO(entity.getId(), entity.getUsername());
    }
}

Important Notes

Always exclude sensitive or unnecessary fields in DTOs.

Manual mapping is simple but can be repetitive; libraries help automate it.

Keep DTOs simple and focused on what the client needs.

Summary

Entity to DTO mapping separates database data from what you send outside.

It helps protect sensitive info and control data format.

You can map manually or use libraries like MapStruct or ModelMapper.

Practice

1. What is the main purpose of mapping an Entity to a DTO in Spring Boot?

easy

A. To speed up database queries

B. To separate database structure from data sent to clients

C. To store data in a different database

D. To automatically generate database tables

Solution

1. Step 1: Understand Entity and DTO roles

   Entity represents database data, DTO is for data transfer outside the app.

2. Step 2: Identify the purpose of mapping

   Mapping hides database details and controls what data is sent to clients.

3. Final Answer:

   To separate database structure from data sent to clients -> Option B

4. Quick Check:

   Entity to DTO mapping = data separation [OK]

Hint: Think: Entity is internal, DTO is external data format [OK]

Common Mistakes:

• Confusing DTO with database storage
• Thinking mapping speeds up queries
• Assuming DTO changes database schema

2. Which of the following is the correct way to manually map an Entity field name to a DTO field fullName in Java?

easy

A. entity.getName(dto.setFullName());

B. entity.setName(dto.getFullName());

C. dto.getFullName(entity.setName());

D. dto.setFullName(entity.getName());

Solution

1. Step 1: Identify source and target objects

   Entity is source, DTO is target for mapping.

2. Step 2: Use getter on entity and setter on DTO

   Correct syntax is calling entity.getName() and passing to dto.setFullName().

3. Final Answer:

   dto.setFullName(entity.getName()); -> Option D

4. Quick Check:

   Getter from entity, setter on DTO [OK]

Hint: Getter from entity, setter on DTO for mapping [OK]

Common Mistakes:

• Reversing source and target in mapping
• Using setter as getter or vice versa
• Calling methods with wrong parameters

3. Given the following code snippet, what will be the output of dto.getAge() after mapping?

public class UserEntity {
  private int age = 30;
  public int getAge() { return age; }
}

public class UserDTO {
  private int age;
  public void setAge(int age) { this.age = age; }
  public int getAge() { return age; }
}

UserEntity entity = new UserEntity();
UserDTO dto = new UserDTO();
dto.setAge(entity.getAge());
System.out.println(dto.getAge());

medium

A. 30

B. 0

C. null

D. Compilation error

Solution

1. Step 1: Check initial value in Entity

   Entity's age is set to 30 by default.

2. Step 2: Map Entity age to DTO and print

   DTO's age is set to entity.getAge(), so dto.getAge() returns 30.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   Entity age 30 mapped to DTO age 30 [OK]

Hint: Mapping copies values exactly unless changed [OK]

Common Mistakes:

• Assuming default int is null
• Confusing getter/setter roles
• Expecting compilation error without syntax issues

4. Identify the error in this manual mapping method:

public UserDTO mapToDTO(UserEntity entity) {
  UserDTO dto = new UserDTO();
  dto.setName(entity.getFullName());
  dto.setEmail(entity.getEmail());
  return dto;
}

Assuming UserEntity has a getName() method but no getFullName() method.

medium

A. Setter methods used incorrectly

B. Missing return statement

C. Calling non-existent method getFullName() on entity

D. DTO object not created

Solution

1. Step 1: Check entity methods used

   Code calls entity.getFullName(), but entity only has getName().

2. Step 2: Identify cause of error

   Calling a method that does not exist causes a compile-time error.

3. Final Answer:

   Calling non-existent method getFullName() on entity -> Option C

4. Quick Check:

   Method must exist on entity for mapping [OK]

Hint: Verify entity methods before calling in mapping [OK]

Common Mistakes:

• Assuming method names match automatically
• Ignoring compile errors from wrong method calls
• Confusing getter names between classes

5. You want to map a list of UserEntity objects to a list of UserDTO objects using Java streams in Spring Boot. Which code snippet correctly performs this mapping assuming a method mapToDTO(UserEntity entity) exists?

hard

A. List<UserDTO> dtos = entities.stream().map(this::mapToDTO).collect(Collectors.toList());

B. List<UserDTO> dtos = entities.map(entity -> mapToDTO(entity));

C. List<UserDTO> dtos = entities.forEach(entity -> mapToDTO(entity));

D. List<UserDTO> dtos = entities.stream().forEach(this::mapToDTO);

Solution

1. Step 1: Use stream() to process list

   entities.stream() creates a stream to transform elements.

2. Step 2: Use map() to convert each entity to DTO

   map(this::mapToDTO) applies the mapping method to each element.

3. Step 3: Collect results into a list

   collect(Collectors.toList()) gathers mapped DTOs into a list.

4. Final Answer:

   List<UserDTO> dtos = entities.stream().map(this::mapToDTO).collect(Collectors.toList()); -> Option A

5. Quick Check:

   Stream map + collect to list = correct mapping [OK]

Hint: Use stream().map(...).collect(toList()) for list mapping [OK]

Common Mistakes:

• Using forEach instead of map for transformation
• Calling map on list directly without stream()
• Not collecting results after mapping