Approcci alla scrittura di convertitori / traduttori di oggetti

0

Sto andando avanti e indietro su quale approccio adottare con il codice di conversione (ad esempio il codice che traduce un POJO in un DTO e viceversa). Attualmente sto lavorando in Java, ma suppongo che alcuni di questi si traducano in altre lingue.

Diversi approcci hanno diversi pro e contro, che cercherò di riassumere. Mi chiedo se:

  • Mi mancano alcuni importanti vantaggi / svantaggi che mi morderanno più tardi
  • Mi manca qualche approccio / modello migliore che risolva tutti i miei problemi

Per maggiore chiarezza, diciamo che sto traducendo avanti e indietro tra le seguenti due rappresentazioni:

class Jojo {
  // Jojo is a POJO
}

class Dodo {
  // Dodo is a DTO
}

Conversione statica / metodo di fabbrica in una classe di convertitore

class DodoJojoConverter {
  public static Jojo dodoToJojo(Dodo dodo) {...}
  public static Dodo jojoToDodo(Jojo jojo) {...}
}
...
Jojo jojo = DodoJojoConverter.dodoToJojo(dodo);
  • Pratico da usare, chiaro da leggere
  • Incapsula la traduzione a due vie
  • Incapsula la traduzione in un luogo esterno agli oggetti, quindi può essere più difficile trovare / ricordare / documentare / aggiornare
  • Nessuna dipendenza extra sulle entità (ad es., Jojo non ha bisogno di conoscere Pojo)
  • Il codice che utilizza il convertitore può essere difficile da testare (in Java almeno, non c'è modo di prendere in giro il convertitore ed è probabile che si rompa quando si tenta la conversione di un mock)

Metodo di fabbrica sull'oggetto

class Dodo {
  ...
  Jojo to() {...}
}
...
Jojo jo = dodo.toJojo();
Jojo jo = new Jojo.Builder().fromDodo(dodo).build();
  • Pratico da usare, chiaro da leggere
  • Crea un accoppiamento esplicito tra i due, forse a due vie
  • Rompe con la semplicità di un POJO dandogli più responsabilità
  • Classi facili da testare / simulare che utilizzano questo in alcuni casi, più difficile in altri.

Variazione: metodo di fabbrica statico sull'oggetto

class Dodo {
  ...
  static Jojo toJojo() {...}
}
...
Jojo jo = Dodo.toJojo(dodo);
  • Simile al precedente ma leggermente più difficile da testare e simulare classi che lo usano

Oggetto convertitore

class DodoJodoConverter() {
  Jojo dodoToJojo(Dodo dodo) {...}
  Dodo jojoToDodo(Jojo jojo) {...}
}
...
Jojo jojo = djConverter.dodoToJojo(dodo);
  • Il convertitore può essere configurato con le opzioni di conversione
  • L'oggetto convertitore può essere creato al volo (difficile da testare / mock)
  • Oppure può essere iniettato in fase di costruzione, più facile da deridere ma può portare a costruttori con un gran numero di argomenti
  • Molti convertitori semplici o alcuni più grandi
  • Nessun accoppiamento tra Dodo e Jojo e li mantiene semplici

Personalmente, mi piace di più l'ultima opzione. Principalmente perché iniettare il convertitore in fase di costruzione rende facile testare l'unità utilizzando la classe con i mock.

Qualche altro approccio mi manca? Qualunque aggiornamento / svantaggio di questi che ho omesso?

    
posta Marco 16.03.2018 - 22:11
fonte

0 risposte

Leggi altre domande sui tag