Data Transfer Object (DTO) pattern – Praktyczny przewodnik dla programistów Java

Co to jest Data Transfer Object?

Data Transfer Object (DTO) to wzorzec projektowy, który służy do przenoszenia danych między różnymi warstwami aplikacji lub między różnymi systemami. DTO to prosta klasa zawierająca tylko pola danych i metody dostępowe (gettery/settery), bez żadnej logiki biznesowej.

Dlaczego DTO jest ważne?

W nowoczesnych aplikacjach Java często pracujemy z wielowarstwową architekturą – mamy warstwę prezentacji, logiki biznesowej i dostępu do danych. Przekazywanie obiektów encji bezpośrednio między tymi warstwami może prowadzić do problemów:

DTO rozwiązuje te problemy poprzez:
– **Izolację warstw** – zmiany w bazie danych nie wpływają na API
– **Kontrolę nad danymi** – pokazujemy tylko to, co potrzebne
– **Bezpieczeństwo** – ukrywamy wrażliwe informacje
– **Wydajność** – przesyłamy tylko niezbędne dane

Co się nauczysz?

Wymagania wstępne

Praktyczny przykład – Aplikacja e-commerce

Wyobraź sobie, że tworzysz aplikację sklepu internetowego. Masz encję User w bazie danych:

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String email;
    private String password;
    private String firstName;
    private String lastName;
    private String phoneNumber;
    private boolean isActive;
    private LocalDateTime createdAt;
    private LocalDateTime lastLoginAt;
    
    // konstruktory, gettery, settery
}

Problem: Przekazywanie encji bezpośrednio

@RestController
public class UserController {
    
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id); // BŁĄD! Zwracamy hasło!
    }
}

Rozwiązanie: Tworzenie DTO

Tworzymy klasę UserDTO zawierającą tylko potrzebne dane:

public class UserDTO {
    private Long id;
    private String email;
    private String firstName;
    private String lastName;
    private boolean isActive;
    
    // Konstruktor bezparametrowy
    public UserDTO() {}
    
    // Konstruktor z parametrami
    public UserDTO(Long id, String email, String firstName, 
                   String lastName, boolean isActive) {
        this.id = id;
        this.email = email;
        this.firstName = firstName;
        this.lastName = lastName;
        this.isActive = isActive;
    }
    
    // Gettery i settery
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    
    // pozostałe gettery i settery...
}

Mapowanie Entity na DTO

Teraz potrzebujemy sposobu na konwersję z User na UserDTO:

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    public UserDTO getUserById(Long id) {
        User user = userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException("User not found"));
        
        return convertToDTO(user);
    }
    
    private UserDTO convertToDTO(User user) {
        return new UserDTO(
            user.getId(),
            user.getEmail(),
            user.getFirstName(),
            user.getLastName(),
            user.isActive()
        );
    }
}

Używanie w kontrolerze

@RestController
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/users/{id}")
    public ResponseEntity getUser(@PathVariable Long id) {
        UserDTO userDTO = userService.getUserById(id);
        return ResponseEntity.ok(userDTO);
    }
}

Kiedy używać DTO?

Przykłady praktycznego użycia

Najlepsze praktyki DTO

1. Jasne nazewnictwo

// Dobrze - jasno określa przeznaczenie
public class UserResponseDTO { }
public class CreateUserRequestDTO { }

// Źle - niejasne przeznaczenie
public class UserData { }
public class UserInfo { }

2. Immutable DTO

public class UserDTO {
    private final Long id;
    private final String email;
    private final String fullName;
    
    public UserDTO(Long id, String email, String fullName) {
        this.id = id;
        this.email = email;
        this.fullName = fullName;
    }
    
    // Tylko gettery, bez setterów
    public Long getId() { return id; }
    public String getEmail() { return email; }
    public String getFullName() { return fullName; }
}

3. Walidacja w DTO

public class CreateUserRequestDTO {
    
    @NotBlank(message = "Email nie może być pusty")
    @Email(message = "Nieprawidłowy format email")
    private String email;
    
    @NotBlank(message = "Imię nie może być puste")
    @Size(min = 2, max = 50, message = "Imię musi mieć 2-50 znaków")
    private String firstName;
    
    // konstruktory, gettery, settery
}

Częste błędy początkujących

Błąd 1: Duplikowanie całej struktury Entity

// ŹLE - DTO identyczne z Entity
public class UserDTO {
    private Long id;
    private String password; // Po co hasło w DTO?
    private LocalDateTime createdAt; // Czy frontend tego potrzebuje?
    // ... wszystkie pola z Entity
}

// DOBRZE - tylko potrzebne dane
public class UserDTO {
    private Long id;
    private String email;  
    private String fullName;
}

Błąd 2: Logika biznesowa w DTO

Testowanie DTO

@Test
public void shouldCreateUserDTOCorrectly() {
    // Given
    String email = "jan@example.com";
    String firstName = "Jan";
    String lastName = "Kowalski";
    
    // When
    UserDTO dto = new UserDTO(1L, email, firstName, lastName, true);
    
    // Then
    assertThat(dto.getId()).isEqualTo(1L);
    assertThat(dto.getEmail()).isEqualTo(email);
    assertThat(dto.getFullName()).isEqualTo(firstName + " " + lastName);
}

Następne kroki

Przydatne zasoby

• Martin Fowler – Data Transfer Object
• Spring Boot 2.2 Documentation
• Bean Validation 2.0 Specification
• ModelMapper – biblioteka do mapowania obiektów

Masz pytania o wzorzec DTO? A może już używasz go w swoich projektach? Podziel się swoimi doświadczeniami w komentarzach!