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?