Framework per la conversione di oggetti java

Question

Sto lavorando su un progetto che converte entità di database in oggetti DTO. Per farlo viene utilizzata una classe di conversione speciale per ogni conversione.

---

Sto fornendo un esempio semplificato delle cose che stiamo facendo. Ho intenzionalmente perso setter/getter e alcune altre cose per la chiarezza del codice.

Così qui sono entità persistenti:

class Car { 
    String number; 
    Driver driver; 
} 

class Driver { 
    String name; 
    License license; 
} 

class License { 
    String serial; 
    Date expired; 
} 

---

e supponendo che abbiamo bisogno di seguenti oggetti DTO:

class DriverDTO { 
    String name; 
    String carNumber; 
    String licenseSerial; 
} 

Creiamo seguenti classe convertitore:

class DriverDTOConverter { 
    DriverDTO convert(Car car) { 
     DriverDTO driverDto = new DriverDTO(); 
     driverDto.carNumber = car.number; 
     driverDto.name = car.driver.name; 
     driverDto.licenseSerial = car.driver.license.serial; 
     return driverDto; 
    } 
} 

---

e un po 'più complessa esempio:

class CarDTO { 
    String number; 
    String driverName; 
    LicenseDTO driverLicense; 
} 

class LicenseDTO { 
    String serial; 
} 

class CarDTOConverter { 
    CarDTO convert(Car car) { 
     CarDTO carDto = new CarDTO(); 
     carDto.number = car.number; 
     carDto.driverName = car.driver.name; 
     LicenseDtoConverter c = new LicenseDtoConverter(); 
     carDto.driverLicense = c.convert(car.driver.license); 
     return carDto; 
    } 
} 

class LicenseDtoConverter { 
    LicenseDTO convert(License license) { 
     LicenseDTO licenseDto = new LicenseDTO(); 
     licenseDto.serial = license.serial; 
     return licenseDto; 
    } 
} 

---

ci vuole un sacco di tempo, quindi mi chiedo se c'è qualche quadro che può prendere il responsbility per quel lavoro. E ho solo bisogno di configurarlo con file di proprietà o annotazioni.

Smth così

Se fatta da file di proprietà:

DriverDto <--> Car { 
carNumber = number; 
name = driver.name;    
licenseSerial = driver.license.serial; 
} 

CarDTO <--> Car { 
number = number; 
driverName = driver.name; 
driverLicense = driver.license; 
} 

LicenseDTO <--> License { 
license = license; 
} 

O esempio di possibili entità annotato

@Converted(Car.class) 
class DriverDTO { 
    @Associated("driver.name") 
    String name; 
    @Associated("number") 
    String carNumber; 
    @Associated("driver.license.serial") 
    String licenseSerial; 
} 

Il requisito importante è che non dovrebbe usare alcuna riflessione. Tutte le annotazioni o file di proprietà devono essere compilati in fase di compilazione o precompilazione e devono essere generati bytecode o codice sorgente.

Sarò molto contento se qualcuno può indicarmi un tale quadro. Parteciperò volentieri alla sua creazione anche se è ancora in fase di sviluppo.

Answer 1

Da verificare Dozer - Mapper Java to bean. Facile da usare, facile da estendere.

Answer 2

Si potrebbe verificare ModelMapper.

Si differenzia da Dozer e altri in quanto riduce al minimo la quantità di configurazione necessaria mediante il mapping intelligente dei modelli di oggetti. Dove è necessaria la configurazione, ModelMapper offre un'API sicura di refactoring che utilizza il codice effettivo per mappare proprietà e valori piuttosto che utilizzare riferimenti a stringhe o XML.

controllare il sito ModelMapper per maggiori informazioni:

http://modelmapper.org

Answer 3

Un'alternativa a Bulldozer, che si possono trovare interessanti è jDTO Binder, è davvero semplice da usare e fornisce l'integrazione con il backend più popolare contenitori.

jDTO Binder

Answer 4

Potreste essere interessati a MapStruct che è un generatore di codice in fase di compilazione proprio per questo caso d'uso (disclaimer: sto lavorando su questo progetto).

Poiché MapStruct è uno strumento di generazione, non utilizza la riflessione né richiede alcune dipendenze di runtime. È necessario dichiarare un'interfaccia simile a questo:

@Mapper 
public interface CarMapper { 

    CarMapper INSTANCE = Mappers.getMapper (CarMapper.class); 

    @Mapping(source="number", target="carNumber") 
    @Mapping(source="driver.name", target="name") 
    @Mapping(source="driver.license.serial", target="licenseSerial") 
    CarDto carToCarDto(Car car); 

    DriverDto driverToDriverDto(Driver driver); 
} 

durante la costruzione (per esempio tramite Maven o nel vostro IDE), MapStruct genererà un'implementazione di tale interfaccia che appare fondamentalmente come il tuo codice originale scritto a mano.

Se sei interessato, puoi scoprire di più su reference guide.