Création et remplissage de propriétés d'un objet de classe T ou étendues à partir de T sans code en double

Question

J'ai développé une application Java EE offrant des services REST. J'ai décidé de ne jamais exposer des entités sous-jacentes, en utilisant des POJO pour envoyer des données. Lorsque l'utilisateur demande une liste, l'application envoie une liste de POJO avec un minimum d'informations, mais si l'utilisateur demande une ressource spécifique, il obtiendra un POJO plus détaillé. Par exemple, imaginez que j'ai une entité Car, je peux avoir ceci:

public class BaseCar { 
    private String model; 
    private int year; 
    // [...getters and setters...] 
} 

et ceci:

public class FullCar extends BaseCar { 
    private String color; 
    private int maxSpeed; 
    private List<String> comments; 
    // [...getters and setters...] 
} 

Donc, si l'utilisateur appelle/voitures il va obtenir une liste des BaseCar s, mais s'il appelle/cars/10 il obtient un FullCar. En fait, j'ai deux méthodes pour créer BaseCar et FullCar:

public BaseCar toBaseCar(Car car) { 
    BaseCar baseCar = new BaseCar(); 
    baseCar.setModel(car.getModel()); 
    baseCar.setYear(car.getYear()); 
} 

public FullCar toFullCar(Car car) { 
    FullCar fullCar = new FullCar(); 
    fullCar.setModel(car.getModel()); 
    fullCar.setYear(car.getYear()); 
    fullCar.setColor(car.getColor()); 
    fullCar.setMaxSpeed(car.getMaxSpeed()); 
    fullCar.setComments(new ArrayList<String>()); 
    for (Comment comment : car.getCommentsCollection()) { 
     fullCar.getComments().add(comment.getText()); 
    } 
} 

Comme vous pouvez le voir, il y a un code répété (dans cet exemple que setModel() et setYear(), mais le plus souvent il est plus). Je sais ce que je peux faire pour éviter ces répétitions:

BaseCar baseCar = (baseCar) toFullCar(car); 

Mais je ne veux pas le faire, parce que je ne veux pas utiliser plus de collections de mémoire ou de charge si je ne vais pas les utiliser . En fait, ce que je souhaite est quelque chose comme ceci:

public FullCar toFullCar(Car car) { 
    FullCar fullCar = toBaseCar(car); 
    fullCar.setColor(car.getColor()); 
    fullCar.setMaxSpeed(car.getMaxSpeed()); 
    fullCar.setComments(new ArrayList<String>()); 
    for (Comment comment : car.getCommentsCollection()) { 
     fullCar.getComments().add(comment.getText()); 
    } 
} 

Mais la coulée BaseCar-FullCar est impossible. Est-il possible d'éviter de répéter le même bloc de code (parfois assez grand)?

Answer 1

Ajouter un constructeur à l'BaseCar et FullCar qui prennent un paramètre Car:

interface Car { 
    String getModel(); 

    int getYear(); 

    String getColor(); 

    int getMaxSpeed(); 

    List<String> getComments(); 

} 

public class BaseCar { 
    private String model; 
    private int year; 

    public BaseCar(Car c) { 
     this.model = c.getModel(); 
     this.year = c.getYear(); 
    } 

    public String getModel() { 
     return model; 
    } 

    public void setModel(String model) { 
     this.model = model; 
    } 

    public int getYear() { 
     return year; 
    } 

    public void setYear(int year) { 
     this.year = year; 
    } 

} 

public class FullCar extends BaseCar { 
    private String color; 
    private int maxSpeed; 
    private List<String> comments; 

    public FullCar(Car c) { 
     super(c); // Set up base car. 
     this.maxSpeed = c.getMaxSpeed(); 
     this.color = c.getColor(); 
     this.comments = new ArrayList<>(c.getComments()); 
    } 

} 

public BaseCar toBaseCar(Car car) { 
     return new BaseCar(car); 
} 

public FullCar toFullCar(Car car) { 
    return new FullCar(car); 
}