Create object of one type from object of another type with database lookups

Question

I have an application that gets a car entity from a third party database. I call the entity ThirdPartyCar. My application needs to create a Car entity by using data from a ThirdPartyCar. However, the Car entity must also derive some of its data from my application's database. For example, a status of a ThirdPartyCar might be _BOUGHT and through a database lookup my application must transform to Sold.

I currently have a Car constructor that has a ThirdPartyCar argument. But the Car constructor cannot populate the lookup data since it is an entity and entities should not have a reference to a repositories. So, I also have a service to populate the remaining data:

public class ThirdPartyCar {
    @Id
    private Long id;
    private String vin;
    private String status;
    // more props + default constructor
}

public class Car {
    @Id
    private Long id;
    private String vin;
    private CarStatus status;
    // more props (some different than ThirdPartyCar) + default constructor

    public Car(ThirdPartyCar thirdPartyCar) {
       this.vin = thirdPartyCar.getVin();
       // more props set based on thirdPartyCar
       // but props leveraging database not set here
    }

 public class CarStatus {
    @Id
    private Long id;
    private String status;
 }

 public class CarBuilderService {
     private final CarStatusMappingRepository repo;

     public Car buildFrom(ThirdPartyCar thirdPartyCar) {
        Car car = new Car(thirdPartyCar);
        CarStatus status = repo.findByThirdPartyCarStatus(thirdPartyCar.getStatus());
        car.setStatus(status);
        // set other props (including nested props) that depend on repos

     }
  }

The logical place to create a Car based on a ThirdPartyCar seems to be the constructor. But I have a disjointed approach b/c of the need of a repo. What pattern can I apply such that all data is created in the constructor but still not have the entity be aware of repositories?

Answer 1

You should avoid linking two POJO classes from different domains in constructor. These two classes should not know anything about each other. Maybe they represent the same concept in two different systems but they are not the same.

Good approach is creating Abstract Factory interface which will be used everywhere where Car should be created from ThirdPartyCar:

interface ThirdPartyCarFactory {

    Car createNewBasedOn(ThirdPartyCar source);
}

and one implementation could be your RepositoryThirdPartyCarFactory:

class RepositoryThirdPartyCarFactory implements ThirdPartyCarFactory {

    private CarStatusMappingRepository repo;
    private CarMapper carMapper;

    public Car createNewBasedOn(ThirdPartyCar thirdPartyCar) {
        Car car = new Car();
        carMapper.map(thirdPartyCar, car);

        CarStatus status = repo.findByThirdPartyCarStatus(thirdPartyCar.getStatus());
        car.setStatus(status);
        // set other props (including nested props) that depend on repos

        return car;
    }
}

In above implementation you can find CarMapper which knows how to map ThirdPartyCar to Car. To implement this mapper you can use Dozer, Orika, MapStruct or your custom implementation.

Other question is how you got ThirdPartyCar object. If you load it by ID from ThirdPartyRepository you can change your abstract factory to:

interface CarFactory {
    Car createNew(String id);
}

and given implementation loads by ID ThirdPartyCar and maps it to Car. Everything is hidden by factory which you can easily exchanged.

See also:

• Performance of Java Mapping Frameworks