Comment construire un objet lorsque nous avons une relation d'héritage à l'aide de lombok builder?

Dans mon projet, je suis à l'aide de lombok pour éviter d'écrire des getters et setters pour une classe.
Aussi, je suis à l'aide de lombok.Builder pour créer un objet au lieu d'écrire de nouveaux Obeject() et ensuite le réglage de toutes les valeurs.

Mais quand nous avons une relation d'héritage et quand nous voulons construire l'enfant objet à l'aide de lombok builder, je n'obtiens pas de parent.

Par exemple:

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
@EqualsAndHashCode
public class Parent{
  private String nationality;
  .
  .
  //more columns
}

Et de la classe Enfant serait quelque chose comme ceci:

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class Child extends Parent{
   private String firstName;
   private String lastName;
   .
   .
}

Dans ma classe de test, où j'ai besoin de construire de l'enfant objet

public class Test{

 public void testMethod(){
   Child child = Child.builder()
            .firstName("Rakesh")
            .lastName("SS")
            .nationality("some text")//I am not able to set nationality               
            .build();
 }


}

S'il vous plaît laissez-moi savoir, est-il possible de gérer ce scénario à lombok.

Pas sûr, c'est pourquoi il a voté bas s'il vous Plaît laissez-moi savoir si tout ce que je peux améliorer

OriginalL'auteur Rakesh | 2015-10-07

@Builder n'a aucun moyen de déterminer quels sont les domaines d' Parent vous souhaitez exposer.

Quand @Builder est placé sur une classe, seuls les champs déclaré explicitement sur cette classe sont ajoutés à la *Builder.

Quand @Builder est placé sur une méthode statique ou à un constructeur de la résultante *Builder aura une méthode pour chaque argument.

Aussi, si vous êtes en utilisant @Builder alors il est sûr de supposer qu'au moins Child est destiné à être immuable?

Je l'approvisionnement de deux exemples, l'un où Parent est mutable et Child est immuable et celui où les deux Parent et Child sont immuables.

Immuable du Parent et de l'Enfant

import static org.junit.Assert.*;
import lombok.Builder;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import lombok.Value;
import lombok.experimental.NonFinal;
import org.junit.Test;
public class So32989562ValueTest {
@Value
@NonFinal
public static class Parent {
protected final String nationality;
}
@Value
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public static class Child extends Parent {
private final String firstName;
private final String lastName;
@Builder(toBuilder = true)
private Child(String nationality, String firstName, String lastName) {
super(nationality);
this.firstName = firstName;
this.lastName = lastName;
}
}
@Test
public void testChildBuilder() {
String expectedFirstName = "Jeff";
String expectedLastName = "Maxwell";
String expectedNationality = "USA";
Child result = Child.builder()
.firstName(expectedFirstName)
.lastName(expectedLastName)
.nationality(expectedNationality)
.build();
assertEquals(result.toString(), expectedFirstName, result.getFirstName());
assertEquals(result.toString(), expectedLastName, result.getLastName());
assertEquals(result.toString(), expectedNationality, result.getNationality());
}
}

Mutable Parent, Immuable Enfant:

import static org.junit.Assert.*;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import lombok.Value;
import org.junit.Test;
public class So32989562DataTest {
@Data
public static class Parent {
protected String nationality;
}
@Value
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public static class Child extends Parent {
private final String firstName;
private final String lastName;
@Builder(toBuilder = true)
private Child(String nationality, String firstName, String lastName) {
this.setNationality(nationality);
this.firstName = firstName;
this.lastName = lastName;
}
}
@Test
public void testChildBuilder() {
String expectedFirstName = "Jeff";
String expectedLastName = "Maxwell";
String expectedNationality = "USA";
Child result = Child.builder()
.firstName(expectedFirstName)
.lastName(expectedLastName)
.nationality(expectedNationality)
.build();
assertEquals(result.toString(), expectedFirstName, result.getFirstName());
assertEquals(result.toString(), expectedLastName, result.getLastName());
assertEquals(result.toString(), expectedNationality, result.getNationality());
}
}

OriginalL'auteur Jeff

6

Solution ci-dessus fonctionne, mais cela nécessite trop de solution de contournement. Et des modifications de l'enfant et de la classe parent exige un changement des arguments du constructeur de partout.

De Lombok a introduit des fonctionnalités expérimentales avec la version: 1.18.2 pour les questions de succession face avec le Constructeur d'annotation, et peut être résolu avec @SuperBuilder annotation comme ci-dessous.
```
@SuperBuilder
public class ParentClass {
private final String a;
private final String b;
}
@SuperBuilder
public class ChildClass extends ParentClass{
private final String c;
}
```
Maintenant, on peut utiliser le Constructeur de la classe comme ci-dessous (qui n'était pas possible avec @Générateur d'annotation)
```
ChildClass.builder().a("testA").b("testB").c("testC").build();
```
OriginalL'auteur Amit Kaneria

Vous devez vous connecter pour publier un commentaire.