Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Aplatir les attributs des autres classes Si les attributs de votre table sont répartis dans plusieurs classes Java différentes, que ce soit par héritage ou par composition, l'API DynamoDB Enhanced Client permet de regrouper les attributs en une seule classe. ## Utiliser l'héritage Si vos classes utilisent l'héritage, appliquez les approches suivantes pour aplatir la hiérarchie. ### Utiliser des haricots annotés Pour l'approche d'annotation, les deux classes doivent porter l'`@DynamoDbBean`annotation et une classe doit porter une ou plusieurs annotations de clé primaire. Vous trouverez ci-dessous des exemples de classes de données dotées d'une relation d'héritage. ------ #### [ Standard data class ] ``` @DynamoDbBean public class Customer extends GenericRecord { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } } @DynamoDbBean public abstract class GenericRecord { private String id; private String createdDate; @DynamoDbPartitionKey public String getId() { return id; } public void setId(String id) { this.id = id; } public String getCreatedDate() { return createdDate; } public void setCreatedDate(String createdDate) { this.createdDate = createdDate; } } ``` ------ #### [ Lombok ] L'[`onMethod`option](https://projectlombok.org/features/experimental/onX) de Lombok copie les annotations DynamoDB basées sur les attributs, telles que, sur le code généré. `@DynamoDbPartitionKey` ``` @DynamoDbBean @Data @ToString(callSuper = true) public class Customer extends GenericRecord { private String name; } @Data @DynamoDbBean public abstract class GenericRecord { @Getter(onMethod_=@DynamoDbPartitionKey) private String id; private String createdDate; } ``` ------ ### Utiliser des schémas statiques Pour l'approche du schéma statique, utilisez la `extend()` méthode du générateur pour réduire les attributs de la classe parent sur ceux de la classe enfant. Ceci est affiché après la ligne de commentaire 1 dans l'exemple suivant. ``` StaticTableSchema GENERIC_RECORD_SCHEMA = StaticTableSchema.builder(org.example.tests.model.inheritance.stat.GenericRecord.class) // The partition key will be inherited by the top level mapper. .addAttribute(String.class, a -> a.name("id") .getter(org.example.tests.model.inheritance.stat.GenericRecord::getId) .setter(org.example.tests.model.inheritance.stat.GenericRecord::setId) .tags(primaryPartitionKey())) .addAttribute(String.class, a -> a.name("created_date") .getter(org.example.tests.model.inheritance.stat.GenericRecord::getCreatedDate) .setter(org.example.tests.model.inheritance.stat.GenericRecord::setCreatedDate)) .build(); StaticTableSchema CUSTOMER_SCHEMA = StaticTableSchema.builder(org.example.tests.model.inheritance.stat.Customer.class) .newItemSupplier(org.example.tests.model.inheritance.stat.Customer::new) .addAttribute(String.class, a -> a.name("name") .getter(org.example.tests.model.inheritance.stat.Customer::getName) .setter(org.example.tests.model.inheritance.stat.Customer::setName)) // 1. Use the extend() method to collapse the parent attributes onto the child class. .extend(GENERIC_RECORD_SCHEMA) // All the attributes of the GenericRecord schema are added to Customer. .build(); ``` L'exemple de schéma statique précédent utilise les classes de données suivantes. Comme le mappage est défini lorsque vous créez le schéma de table statique, les classes de données ne nécessitent pas d'annotations. #### Classes de données ------ #### [ Standard data class ] ``` public class Customer extends GenericRecord { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } } public abstract class GenericRecord { private String id; private String createdDate; public String getId() { return id; } public void setId(String id) { this.id = id; } public String getCreatedDate() { return createdDate; } public void setCreatedDate(String createdDate) { this.createdDate = createdDate; } ``` ------ #### [ Lombok ] ``` @Data @ToString(callSuper = true) public class Customer extends GenericRecord{ private String name; } @Data public abstract class GenericRecord { private String id; private String createdDate; } ``` ------ ## Utiliser la composition Si vos classes utilisent la composition, appliquez les approches suivantes pour aplatir la hiérarchie. ### Utiliser des haricots annotés L'`@DynamoDbFlatten`annotation aplatit la classe contenue. Les exemples de classes de données suivants utilisent l'`@DynamoDbFlatten`annotation pour ajouter efficacement tous les attributs de la `GenericRecord` classe contenue à la `Customer` classe. ------ #### [ Standard data class ] ``` @DynamoDbBean public class Customer { private String name; private GenericRecord record; public String getName() { return this.name; } public void setName(String name) { this.name = name; } @DynamoDbFlatten public GenericRecord getRecord() { return this.record; } public void setRecord(GenericRecord record) { this.record = record; } @DynamoDbBean public class GenericRecord { private String id; private String createdDate; @DynamoDbPartitionKey public String getId() { return this.id; } public void setId(String id) { this.id = id; } public String getCreatedDate() { return this.createdDate; } public void setCreatedDate(String createdDate) { this.createdDate = createdDate; } } ``` ------ #### [ Lombok ] ``` @Data @DynamoDbBean public class Customer { private String name; @Getter(onMethod_=@DynamoDbFlatten) private GenericRecord record; } @Data @DynamoDbBean public class GenericRecord { @Getter(onMethod_=@DynamoDbPartitionKey) private String id; private String createdDate; } ``` ------ Vous pouvez utiliser l'annotation aplatir pour aplatir autant de classes éligibles que nécessaire. Les contraintes suivantes s’appliquent : + Tous les noms d'attributs doivent être uniques une fois aplatis. + Il ne doit jamais y avoir plus d'une clé de partition, clé de tri ou nom de table. ### Utiliser des schémas statiques Lorsque vous créez un schéma de table statique, utilisez la `flatten()` méthode du générateur. Vous fournissez également les méthodes getter et setter qui identifient la classe contenue. ``` StaticTableSchema GENERIC_RECORD_SCHEMA = StaticTableSchema.builder(GenericRecord.class) .newItemSupplier(GenericRecord::new) .addAttribute(String.class, a -> a.name("id") .getter(GenericRecord::getId) .setter(GenericRecord::setId) .tags(primaryPartitionKey())) .addAttribute(String.class, a -> a.name("created_date") .getter(GenericRecord::getCreatedDate) .setter(GenericRecord::setCreatedDate)) .build(); StaticTableSchema CUSTOMER_SCHEMA = StaticTableSchema.builder(Customer.class) .newItemSupplier(Customer::new) .addAttribute(String.class, a -> a.name("name") .getter(Customer::getName) .setter(Customer::setName)) // Because we are flattening a component object, we supply a getter and setter so the // mapper knows how to access it. .flatten(GENERIC_RECORD_SCHEMA, Customer::getRecord, Customer::setRecord) .build(); ``` L'exemple de schéma statique précédent utilise les classes de données suivantes. #### Classes de données ------ #### [ Standard data class ] ``` public class Customer { private String name; private GenericRecord record; public String getName() { return this.name; } public void setName(String name) { this.name = name; } public GenericRecord getRecord() { return this.record; } public void setRecord(GenericRecord record) { this.record = record; } public class GenericRecord { private String id; private String createdDate; public String getId() { return this.id; } public void setId(String id) { this.id = id; } public String getCreatedDate() { return this.createdDate; } public void setCreatedDate(String createdDate) { this.createdDate = createdDate; } } ``` ------ #### [ Lombok ] ``` @Data public class Customer { private String name; private GenericRecord record; } @Data public class GenericRecord { private String id; private String createdDate; } ``` ------ Vous pouvez utiliser le modèle Builder pour aplatir autant de classes éligibles que nécessaire. ## Implications pour les autres codes Lorsque vous utilisez l'`@DynamoDbFlatten`attribut (ou la méthode du `flatten()` générateur), l'élément de DynamoDB contient un attribut pour chaque attribut de l'objet composé. Il inclut également les attributs de l'objet composant. En revanche, si vous annotez une classe de données avec une classe composée et que vous ne l'utilisez pas`@DynamoDbFlatten`, l'élément est enregistré avec l'objet composé en tant qu'attribut unique. Par exemple, comparez la `Customer` classe indiquée dans l'[exemple d'aplatissement avec la composition avec](#ddb-en-client-adv-features-flatmap-comp-anno) et sans aplatissement de l'attribut. `record` Vous pouvez visualiser la différence avec JSON, comme indiqué dans le tableau suivant. **** | Avec aplatissement | Sans aplatir | | --- | --- | | 3 attributs | 2 attributs | | 
{
  "id": "1",
  "createdDate": "today",
  "name": "my name"
}
| 
{
  "id": "1",
  "record": {
      "createdDate": "today",
      "name": "my name"
  }
}
| La différence devient importante si vous disposez d'un autre code accédant à la table DynamoDB qui devrait trouver certains attributs.