Framework for converting java objects [closed]

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.

---

We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.

Closed 4 months ago.

Improve this question

I am working on project that converts database entities into DTO objects. To do it a special converter class is used for each convertion.

---

I am providing simplified example of the things we are doing. I intentionally missed setters/getters and some other things for code clarity.

So here are persistent entities:

class Car {
    String number;
    Driver driver;
}

class Driver {
    String name;
    License license;
}

class License {
    String serial;
    Date expired;
} 

---

And assuming that we need following DTO object:

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

We create following converter class:

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;
    }
}

---

And a little bit more complex example:

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(Licen开发者_开发技巧se license) {
        LicenseDTO licenseDto = new LicenseDTO();
        licenseDto.serial = license.serial;
        return licenseDto;
    }
}

---

It takes a lot of time, so I wonder if there is any framework which can take the responsbility for that work. And I will only need to configure it with property files or annotations.

Smth like that

If made by property file:

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;
}

Or example of possible annotated entity

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

The important requirement is that it should not use any reflection. All annotations or property files should be compiled on compile or precompile stage and bytecode or source code should be generated.

I will be very glad if anybody can point me to such a framework. I will also with pleasure participate in its creation if it is still on developent.

---

You should check out Dozer - Java bean to bean mapper. Easy to use, easy to extend.

---

You might check out my ModelMapper.

It differs from Dozer and others in that it minimizes the amount of configuration needed by intelligently mapping object models. Where configuration is needed, ModelMapper offers a refactoring safe API that uses actual code to map properties and values rather than using string references or XML.

Check out the ModelMapper site for more info:

http://modelmapper.org

---

One alternative to dozer, that you may find interesting is jDTO Binder, it is really simple to use and provides integration with the most popular backend containers.

jDTO Binder

---

You might be interested in MapStruct which is a compile-time code generator for exactly this use case (disclaimer: I'm working on this project).

As MapStruct is a build-time tool, it doesn't make use of reflection nor requires sort of runtime dependencies. You need to declare an interface like this:

@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);
}

During the build (e.g. via Maven or in your IDE), MapStruct will generate an implementation of that interface which basically looks like your original hand-written code.

If you're interested, you can find out more in the reference guide.