Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Reduzieren Sie Attribute aus anderen Klassen Wenn die Attribute für Ihre Tabelle entweder durch Vererbung oder Zusammensetzung auf mehrere verschiedene Java-Klassen verteilt sind, bietet die DynamoDB Enhanced Client-API Unterstützung, um die Attribute zu einer Klasse zusammenzufassen. ## Verwenden Sie Vererbung Wenn Ihre Klassen Vererbung verwenden, verwenden Sie die folgenden Methoden, um die Hierarchie zu vereinfachen. ### Verwenden Sie Beans mit Anmerkungen Für den Annotationsansatz müssen beide Klassen die `@DynamoDbBean` Annotation enthalten und eine Klasse muss eine oder mehrere Primärschlüssel-Annotationen enthalten. Im Folgenden werden Beispiele für Datenklassen gezeigt, die eine Vererbungsbeziehung haben. ------ #### [ 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 ] Die [`onMethod`Option](https://projectlombok.org/features/experimental/onX) von Lombok kopiert attributbasierte DynamoDB-Anmerkungen, wie z. B., in den generierten Code. `@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; } ``` ------ ### Verwenden Sie statische Schemas Verwenden Sie für den statischen Schemaansatz die `extend()` Methode des Builders, um die Attribute der übergeordneten Klasse auf die untergeordnete Klasse zu reduzieren. Dies wird im folgenden Beispiel nach Kommentarzeile 1 gezeigt. ``` 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(); ``` Das vorherige Beispiel für ein statisches Schema verwendet die folgenden Datenklassen. Da die Zuordnung beim Erstellen des statischen Tabellenschemas definiert wird, benötigen die Datenklassen keine Anmerkungen. #### Datenklassen ------ #### [ 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; } ``` ------ ## Verwenden Sie Zusammensetzung Wenn in Ihren Klassen Komposition verwendet wird, verwenden Sie die folgenden Methoden, um die Hierarchie zu vereinfachen. ### Verwenden Sie Beans mit Anmerkungen Die `@DynamoDbFlatten` Anmerkung reduziert die enthaltene Klasse. In den folgenden Beispielen für Datenklassen wird die `@DynamoDbFlatten` Anmerkung verwendet, um der Klasse effektiv alle Attribute der enthaltenen `GenericRecord` Klasse hinzuzufügen. `Customer` ------ #### [ 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; } ``` ------ Sie können die Annotation Flatten verwenden, um so viele verschiedene geeignete Klassen wie nötig zu reduzieren. Die folgenden Einschränkungen gelten: + Alle Attributnamen müssen eindeutig sein, nachdem sie reduziert wurden. + Es darf nie mehr als einen Partitionsschlüssel, Sortierschlüssel oder Tabellennamen geben. ### Verwenden Sie statische Schemas Wenn Sie ein statisches Tabellenschema erstellen, verwenden Sie die `flatten()` Methode des Builders. Sie stellen auch die Getter- und Setter-Methoden bereit, die die enthaltene Klasse identifizieren. ``` 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(); ``` Das vorherige Beispiel für ein statisches Schema verwendet die folgenden Datenklassen. #### Datenklassen ------ #### [ 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; } ``` ------ Sie können das Builder-Muster verwenden, um so viele verschiedene in Frage kommende Klassen zu reduzieren, wie Sie möchten. ## Implikationen für anderen Code Wenn Sie das `@DynamoDbFlatten` Attribut (oder die `flatten()` Builder-Methode) verwenden, enthält das Element in DynamoDB ein Attribut für jedes Attribut des erstellten Objekts. Es enthält auch die Attribute des zusammengesetzten Objekts. Wenn Sie dagegen eine Datenklasse mit einer zusammengesetzten Klasse annotieren und diese nicht verwenden`@DynamoDbFlatten`, wird das Element zusammen mit dem zusammengesetzten Objekt als einzelnes Attribut gespeichert. Vergleichen Sie beispielsweise die im [Beispiel „Reduzieren mit Komposition“ gezeigte `Customer` Klasse mit](#ddb-en-client-adv-features-flatmap-comp-anno) und ohne Reduzierung des Attributs. `record` Sie können den Unterschied mit JSON visualisieren, wie in der folgenden Tabelle dargestellt. **** | Mit Abflachen | Ohne Abflachen | | --- | --- | | 3 Attribute | 2 Attribute | | 
{
  "id": "1",
  "createdDate": "today",
  "name": "my name"
}
| 
{
  "id": "1",
  "record": {
      "createdDate": "today",
      "name": "my name"
  }
}
| Der Unterschied wird wichtig, wenn Sie anderen Code haben, der auf die DynamoDB-Tabelle zugreift und erwartet, bestimmte Attribute zu finden.