Как связать новый DTO с DTO, закрытым для модификации

Как связать новый DTO с DTO, закрытым для модификации

Это задача о интеграции и наследовании DTO в системе, где часть кода не может быть изменена (например, библиотека, legacy код, external API).

---

Проблема

Представим ситуацию:

// В какой-то библиотеке (не можем менять)
public final class LegacyUserDTO {
  private String id;
  private String name;
  private String email;
  
  // getters only, no setters
  public String getId() { return id; }
  public String getName() { return name; }
  public String getEmail() { return email; }
}

// Наш новый код нужен больше полей
public class EnhancedUserDTO {
  private String id;
  private String name;
  private String email;
  private LocalDateTime createdAt;  // новое поле
  private List<String> roles;       // новое поле
}

Вопрос: как связать их между собой?

---

Способ 1: Композиция (рекомендуется)

Вместо наследования используем композицию — инкапсулируем старый DTO:

public class EnhancedUserDTO {
  
  // Старый DTO встроен как поле
  private final LegacyUserDTO legacy;
  
  // Новые поля
  private LocalDateTime createdAt;
  private List<String> roles;
  
  public EnhancedUserDTO(LegacyUserDTO legacy, LocalDateTime createdAt, List<String> roles) {
    this.legacy = legacy;
    this.createdAt = createdAt;
    this.roles = roles;
  }
  
  // Делегирование методов от legacy DTO
  public String getId() {
    return legacy.getId();
  }
  
  public String getName() {
    return legacy.getName();
  }
  
  public String getEmail() {
    return legacy.getEmail();
  }
  
  // Новые getter'ы
  public LocalDateTime getCreatedAt() {
    return createdAt;
  }
  
  public List<String> getRoles() {
    return roles;
  }
}

Использование:

LegacyUserDTO legacy = new LegacyUserDTO("1", "Alice", "alice@example.com");
EnhancedUserDTO enhanced = new EnhancedUserDTO(
  legacy,
  LocalDateTime.now(),
  Arrays.asList("ADMIN", "USER")
);

// Все методы работают
System.out.println(enhanced.getId());          // "1"
System.out.println(enhanced.getName());        // "Alice"
System.out.println(enhanced.getCreatedAt());   // 2024-01-01 10:30:00

Плюсы: ✅ Не нарушаем original DTO
✅ Полная гибкость
✅ Легко расширяется

Минусы: ❌ Много boilerplate (делегирование методов)
❌ Нельзя использовать как LegacyUserDTO

---

Способ 2: Наследование (если возможно)

Если LegacyUserDTO не final, можем наследоваться:

public class EnhancedUserDTO extends LegacyUserDTO {
  
  private LocalDateTime createdAt;
  private List<String> roles;
  
  public EnhancedUserDTO(String id, String name, String email,
                        LocalDateTime createdAt, List<String> roles) {
    super(id, name, email);  // инициализируем parent
    this.createdAt = createdAt;
    this.roles = roles;
  }
  
  public LocalDateTime getCreatedAt() {
    return createdAt;
  }
  
  public List<String> getRoles() {
    return roles;
  }
}

Но: если LegacyUserDTO final (как в примере) — этот способ не работает.

---

Способ 3: Adapter Pattern (переходной слой)

Создаём адаптер, который преобразует один DTO в другой:

// Адаптер для преобразования
public class UserDTOAdapter {
  
  // LegacyUserDTO → EnhancedUserDTO
  public static EnhancedUserDTO toLegacy(LegacyUserDTO legacy, 
                                         LocalDateTime createdAt,
                                         List<String> roles) {
    return new EnhancedUserDTO(legacy, createdAt, roles);
  }
  
  // LegacyUserDTO → обратно (если нужно)
  public static LegacyUserDTO toEnhanced(EnhancedUserDTO enhanced) {
    // Но LegacyUserDTO immutable, поэтому просто возвращаем те же данные
    return new SimpleLegacyUserDTO(
      enhanced.getId(),
      enhanced.getName(),
      enhanced.getEmail()
    );
  }
}

// Использование
LegacyUserDTO legacy = loadFromDatabase();
EnhancedUserDTO enhanced = UserDTOAdapter.toLegacy(
  legacy,
  LocalDateTime.now(),
  userService.getUserRoles(legacy.getId())
);

Плюсы: ✅ Логика преобразования в одном месте
✅ Легко тестировать
✅ Переиспользуемо

---

Способ 4: Mapper (с MapStruct или модном)

Используем MapStruct для автоматизированного маппинга:

// Интерфейс маппера
@Mapper(componentModel = "spring")
public interface UserMapper {
  
  @Mapping(target = "createdAt", expression = "java(java.time.LocalDateTime.now())")
  @Mapping(target = "roles", ignore = true)
  EnhancedUserDTO toLegacy(LegacyUserDTO legacy);
  
  default EnhancedUserDTO toLegacyWithRoles(LegacyUserDTO legacy, List<String> roles) {
    EnhancedUserDTO dto = toLegacy(legacy);
    dto.setRoles(roles);
    return dto;
  }
}

// Использование
@Service
public class UserService {
  
  @Autowired
  private UserMapper userMapper;
  
  public EnhancedUserDTO getEnhancedUser(String userId) {
    LegacyUserDTO legacy = loadLegacy(userId);
    List<String> roles = loadRoles(userId);
    
    return userMapper.toLegacyWithRoles(legacy, roles);
  }
}

Плюсы: ✅ Минимум boilerplate
✅ Автоматизировано
✅ Легко поддерживать

---

Способ 5: Builder Pattern (для построения)

Для сложного конструирования:

public class EnhancedUserDTO {
  
  private String id;
  private String name;
  private String email;
  private LocalDateTime createdAt;
  private List<String> roles;
  
  private EnhancedUserDTO(Builder builder) {
    this.id = builder.id;
    this.name = builder.name;
    this.email = builder.email;
    this.createdAt = builder.createdAt;
    this.roles = builder.roles;
  }
  
  public static class Builder {
    private String id;
    private String name;
    private String email;
    private LocalDateTime createdAt = LocalDateTime.now();
    private List<String> roles = new ArrayList<>();
    
    // Builder из LegacyUserDTO
    public Builder fromLegacy(LegacyUserDTO legacy) {
      this.id = legacy.getId();
      this.name = legacy.getName();
      this.email = legacy.getEmail();
      return this;
    }
    
    public Builder createdAt(LocalDateTime createdAt) {
      this.createdAt = createdAt;
      return this;
    }
    
    public Builder roles(List<String> roles) {
      this.roles = roles;
      return this;
    }
    
    public EnhancedUserDTO build() {
      return new EnhancedUserDTO(this);
    }
  }
}

// Использование
LegacyUserDTO legacy = loadLegacy("123");
EnhancedUserDTO enhanced = new EnhancedUserDTO.Builder()
  .fromLegacy(legacy)
  .createdAt(LocalDateTime.now())
  .roles(Arrays.asList("ADMIN", "USER"))
  .build();

Плюсы: ✅ Читаемый код
✅ Гибкий
✅ Легко добавлять новые поля

---

Способ 6: Декоратор (для добавления функциональности)

Оборачиваем LegacyUserDTO дополнительной функциональностью:

// Декоратор
public class RoleAwareUserDTO {
  
  private final LegacyUserDTO user;
  private final List<String> roles;
  
  public RoleAwareUserDTO(LegacyUserDTO user, List<String> roles) {
    this.user = user;
    this.roles = roles;
  }
  
  // Делегирование
  public String getId() { return user.getId(); }
  public String getName() { return user.getName(); }
  public String getEmail() { return user.getEmail(); }
  
  // Новая функциональность
  public List<String> getRoles() { return roles; }
  
  public boolean hasRole(String role) {
    return roles.contains(role);
  }
  
  public boolean isAdmin() {
    return hasRole("ADMIN");
  }
}

// Использование
LegacyUserDTO legacy = loadLegacy("123");
RoleAwareUserDTO roleUser = new RoleAwareUserDTO(
  legacy,
  userService.getRoles(legacy.getId())
);

if (roleUser.isAdmin()) {
  // ...
}

---

Сравнение подходов

---

Практический пример: интеграция со внешним API

// Внешний API возвращает LegacyUserDTO
public class ExternalUserClient {
  public LegacyUserDTO getUser(String id) {
    // REST запрос и десериализация в LegacyUserDTO
    return restTemplate.getForObject("/api/users/" + id, LegacyUserDTO.class);
  }
}

// Наш сервис использует EnhancedUserDTO
@Service
public class UserEnrichmentService {
  
  @Autowired
  private ExternalUserClient externalClient;
  
  @Autowired
  private UserRepository userRepository;  // хранит доп. данные
  
  @Autowired
  private UserMapper userMapper;
  
  public EnhancedUserDTO getEnhancedUser(String userId) {
    // 1. Получаем базовый DTO от внешнего API
    LegacyUserDTO legacy = externalClient.getUser(userId);
    
    // 2. Загружаем дополнительные данные из нашей БД
    UserEntity entity = userRepository.findById(userId).orElse(null);
    
    // 3. Объединяем в EnhancedUserDTO
    return userMapper.toLegacyWithRoles(
      legacy,
      entity != null ? entity.getRoles() : new ArrayList<>()
    );
  }
}

---

Итог

Для связи нового DTO с закрытым для модификации:

1. Композиция — самый универсальный способ
2. Mapper (MapStruct) — для частых преобразований
3. Adapter — если много разных преобразований
4. Builder — для сложного конструирования
5. Декоратор — для добавления функциональности

Правило: никогда не наследуйся от external DTO. Вместо этого используй композицию или маппинг.