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.
# Arbeiten Sie mit Attributen wie Beans, Maps, Listen und Sets
Eine Bean-Definition, wie die unten gezeigte `Person` Klasse, könnte Eigenschaften (oder Attribute) definieren, die sich auf Typen mit zusätzlichen Attributen beziehen. In der `Person` Klasse `mainAddress` handelt es sich beispielsweise um eine Eigenschaft, die sich auf ein `Address` Bean bezieht, das zusätzliche Wertattribute definiert. `addresses`bezieht sich auf eine Java-Map, deren Elemente sich auf `Address` Beans beziehen. Diese komplexen Typen können als Container mit einfachen Attributen betrachtet werden, die Sie für ihren Datenwert im Kontext von DynamoDB verwenden.
*DynamoDB bezeichnet die Werteigenschaften verschachtelter Elemente wie Maps, Listen oder Beans als verschachtelte Attribute.* Im [Amazon DynamoDB Developer Guide](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes) wird die gespeicherte Form einer Java-Map, -Liste oder -Bean als *Dokumenttyp* bezeichnet. Einfache Attribute, die Sie in Java für ihren Datenwert verwenden, werden in DynamoDB als *skalare Typen* bezeichnet. *Mengen, die mehrere skalare Elemente desselben Typs enthalten und als Mengentypen bezeichnet werden.*
Es ist wichtig zu wissen, dass die DynamoDB Enhanced Client-API eine Eigenschaft, die Bean ist, beim Speichern in einen DynamoDB-Kartendokumenttyp konvertiert.
## `Person`-Klasse
```
@DynamoDbBean
public class Person {
private Integer id;
private String firstName;
private String lastName;
private Integer age;
private Address mainAddress;
private Map addresses;
private List phoneNumbers;
private Set hobbies;
@DynamoDbPartitionKey
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Address getMainAddress() {
return mainAddress;
}
public void setMainAddress(Address mainAddress) {
this.mainAddress = mainAddress;
}
public Map getAddresses() {
return addresses;
}
public void setAddresses(Map addresses) {
this.addresses = addresses;
}
public List getPhoneNumbers() {
return phoneNumbers;
}
public void setPhoneNumbers(List phoneNumbers) {
this.phoneNumbers = phoneNumbers;
}
public Set getHobbies() {
return hobbies;
}
public void setHobbies(Set hobbies) {
this.hobbies = hobbies;
}
@Override
public String toString() {
return "Person{" +
"addresses=" + addresses +
", id=" + id +
", firstName='" + firstName + '\'' +
", lastName='" + lastName + '\'' +
", age=" + age +
", mainAddress=" + mainAddress +
", phoneNumbers=" + phoneNumbers +
", hobbies=" + hobbies +
'}';
}
}
```
## `Address`-Klasse
```
@DynamoDbBean
public class Address {
private String street;
private String city;
private String state;
private String zipCode;
public Address() {
}
public String getStreet() {
return this.street;
}
public String getCity() {
return this.city;
}
public String getState() {
return this.state;
}
public String getZipCode() {
return this.zipCode;
}
public void setStreet(String street) {
this.street = street;
}
public void setCity(String city) {
this.city = city;
}
public void setState(String state) {
this.state = state;
}
public void setZipCode(String zipCode) {
this.zipCode = zipCode;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Address address = (Address) o;
return Objects.equals(street, address.street) && Objects.equals(city, address.city) && Objects.equals(state, address.state) && Objects.equals(zipCode, address.zipCode);
}
@Override
public int hashCode() {
return Objects.hash(street, city, state, zipCode);
}
@Override
public String toString() {
return "Address{" +
"street='" + street + '\'' +
", city='" + city + '\'' +
", state='" + state + '\'' +
", zipCode='" + zipCode + '\'' +
'}';
}
}
```
## `PhoneNumber`-Klasse
```
@DynamoDbBean
public class PhoneNumber {
String type;
String number;
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
@Override
public String toString() {
return "PhoneNumber{" +
"type='" + type + '\'' +
", number='" + number + '\'' +
'}';
}
}
```
## Speichern Sie komplexe Typen
### Verwenden Sie annotierte Datenklassen
Sie speichern verschachtelte Attribute für benutzerdefinierte Klassen, indem Sie sie einfach mit Anmerkungen versehen. Die `Address` Klasse und die `PhoneNumber` Klasse, die zuvor gezeigt wurden, sind nur mit der Anmerkung annotiert. `@DynamoDbBean` Wenn die DynamoDB Enhanced Client-API das Tabellenschema für die `Person` Klasse mit dem folgenden Codeausschnitt erstellt, erkennt die API die Verwendung der `PhoneNumber` Klassen `Address` und und erstellt die entsprechenden Mappings für die Arbeit mit DynamoDB.
```
TableSchema personTableSchema = TableSchema.fromBean(Person.class);
```
### Verwenden Sie abstrakte Schemas mit Buildern
Der alternative Ansatz besteht darin, Schema-Builder für statische Tabellen für jede verschachtelte Bean-Klasse zu verwenden, wie im folgenden Code gezeigt.
Die Tabellenschemas für die `PhoneNumber` Klassen `Address` und sind abstrakt in dem Sinne, dass sie nicht mit einer DynamoDB-Tabelle verwendet werden können. Das liegt daran, dass ihnen Definitionen für den Primärschlüssel fehlen. Sie werden jedoch als verschachtelte Schemas im Tabellenschema für die `Person` Klasse verwendet.
Nach den Kommentarzeilen 1 und 2 in der Definition von sehen Sie den Code`PERSON_TABLE_SCHEMA`, der die abstrakten Tabellenschemas verwendet. Die Verwendung von `documentOf` in der `EnhanceType.documentOf(...)` Methode bedeutet nicht, dass die Methode einen `EnhancedDocument` Typ der Enhanced Document API zurückgibt. Die `documentOf(...)` Methode gibt in diesem Kontext ein Objekt zurück, das weiß, wie es sein Klassenargument mithilfe des Tabellenschema-Arguments DynamoDB-Tabellenattributen zuordnen kann.
#### Statischer Schemacode
```
// Abstract table schema that cannot be used to work with a DynamoDB table,
// but can be used as a nested schema.
public static final TableSchema TABLE_SCHEMA_ADDRESS = TableSchema.builder(Address.class)
.newItemSupplier(Address::new)
.addAttribute(String.class, a -> a.name("street")
.getter(Address::getStreet)
.setter(Address::setStreet))
.addAttribute(String.class, a -> a.name("city")
.getter(Address::getCity)
.setter(Address::setCity))
.addAttribute(String.class, a -> a.name("zipcode")
.getter(Address::getZipCode)
.setter(Address::setZipCode))
.addAttribute(String.class, a -> a.name("state")
.getter(Address::getState)
.setter(Address::setState))
.build();
// Abstract table schema that cannot be used to work with a DynamoDB table,
// but can be used as a nested schema.
public static final TableSchema TABLE_SCHEMA_PHONENUMBER = TableSchema.builder(PhoneNumber.class)
.newItemSupplier(PhoneNumber::new)
.addAttribute(String.class, a -> a.name("type")
.getter(PhoneNumber::getType)
.setter(PhoneNumber::setType))
.addAttribute(String.class, a -> a.name("number")
.getter(PhoneNumber::getNumber)
.setter(PhoneNumber::setNumber))
.build();
// A static table schema that can be used with a DynamoDB table.
// The table schema contains two nested schemas that are used to perform mapping to/from DynamoDB.
public static final TableSchema PERSON_TABLE_SCHEMA =
TableSchema.builder(Person.class)
.newItemSupplier(Person::new)
.addAttribute(Integer.class, a -> a.name("id")
.getter(Person::getId)
.setter(Person::setId)
.addTag(StaticAttributeTags.primaryPartitionKey()))
.addAttribute(String.class, a -> a.name("firstName")
.getter(Person::getFirstName)
.setter(Person::setFirstName))
.addAttribute(String.class, a -> a.name("lastName")
.getter(Person::getLastName)
.setter(Person::setLastName))
.addAttribute(Integer.class, a -> a.name("age")
.getter(Person::getAge)
.setter(Person::setAge))
.addAttribute(EnhancedType.documentOf(Address.class, TABLE_SCHEMA_ADDRESS), a -> a.name("mainAddress")
.getter(Person::getMainAddress)
.setter(Person::setMainAddress))
.addAttribute(EnhancedType.listOf(String.class), a -> a.name("hobbies")
.getter(Person::getHobbies)
.setter(Person::setHobbies))
.addAttribute(EnhancedType.mapOf(
EnhancedType.of(String.class),
// 1. Use mapping functionality of the Address table schema.
EnhancedType.documentOf(Address.class, TABLE_SCHEMA_ADDRESS)), a -> a.name("addresses")
.getter(Person::getAddresses)
.setter(Person::setAddresses))
.addAttribute(EnhancedType.listOf(
// 2. Use mapping functionality of the PhoneNumber table schema.
EnhancedType.documentOf(PhoneNumber.class, TABLE_SCHEMA_PHONENUMBER)), a -> a.name("phoneNumbers")
.getter(Person::getPhoneNumbers)
.setter(Person::setPhoneNumbers))
.build();
```
## Projektattribute komplexer Typen
Für `query()` und `scan()` Methoden können Sie mithilfe von Methodenaufrufen wie `addNestedAttributeToProject()` und angeben, welche Attribute in den Ergebnissen zurückgegeben werden sollen`attributesToProject()`. Die DynamoDB Enhanced Client API konvertiert die Parameter des Java-Methodenaufrufs in [Projektionsausdrücke](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ProjectionExpressions.html), bevor die Anforderung gesendet wird.
Das folgende Beispiel füllt die `Person` Tabelle mit zwei Elementen und führt dann drei Scanvorgänge durch.
Beim ersten Scan werden alle Elemente in der Tabelle abgerufen, um die Ergebnisse mit den anderen Scanvorgängen zu vergleichen.
Der zweite Scan verwendet die [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/ScanEnhancedRequest.Builder.html#addNestedAttributeToProject(software.amazon.awssdk.enhanced.dynamodb.NestedAttributeName)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/ScanEnhancedRequest.Builder.html#addNestedAttributeToProject(software.amazon.awssdk.enhanced.dynamodb.NestedAttributeName))Builder-Methode, um nur den `street` Attributwert zurückzugeben.
Der dritte Scanvorgang verwendet die [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/ScanEnhancedRequest.Builder.html#attributesToProject(java.lang.String...)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/ScanEnhancedRequest.Builder.html#attributesToProject(java.lang.String...))Builder-Methode, um die Daten für das Attribut der ersten Ebene zurückzugeben,`hobbies`. Der Attributtyp von `hobbies` ist eine Liste. Um auf einzelne Listenelemente zuzugreifen, führen Sie einen `get()` Vorgang in der Liste aus.
```
personDynamoDbTable = getDynamoDbEnhancedClient().table("Person", PERSON_TABLE_SCHEMA);
PersonUtils.createPersonTable(personDynamoDbTable, getDynamoDbClient());
// Use a utility class to add items to the Person table.
List personList = PersonUtils.getItemsForCount(2);
// This utility method performs a put against DynamoDB to save the instances in the list argument.
PersonUtils.putCollection(getDynamoDbEnhancedClient(), personList, personDynamoDbTable);
// The first scan logs all items in the table to compare to the results of the subsequent scans.
final PageIterable allItems = personDynamoDbTable.scan();
allItems.items().forEach(p ->
// 1. Log what is in the table.
logger.info(p.toString()));
// Scan for nested attributes.
PageIterable streetScanResult = personDynamoDbTable.scan(b -> b
// Use the 'addNestedAttributeToProject()' or 'addNestedAttributesToProject()' to access data nested in maps in DynamoDB.
.addNestedAttributeToProject(
NestedAttributeName.create("addresses", "work", "street")
));
streetScanResult.items().forEach(p ->
//2. Log the results of requesting nested attributes.
logger.info(p.toString()));
// Scan for a top-level list attribute.
PageIterable hobbiesScanResult = personDynamoDbTable.scan(b -> b
// Use the 'attributesToProject()' method to access first-level attributes.
.attributesToProject("hobbies"));
hobbiesScanResult.items().forEach((p) -> {
// 3. Log the results of the request for the 'hobbies' attribute.
logger.info(p.toString());
// To access an item in a list, first get the parent attribute, 'hobbies', then access items in the list.
String hobby = p.getHobbies().get(1);
// 4. Log an item in the list.
logger.info(hobby);
});
```
```
// Logged results from comment line 1.
Person{id=2, firstName='first name 2', lastName='last name 2', age=11, addresses={work=Address{street='street 21', city='city 21', state='state 21', zipCode='33333'}, home=Address{street='street 2', city='city 2', state='state 2', zipCode='22222'}}, phoneNumbers=[PhoneNumber{type='home', number='222-222-2222'}, PhoneNumber{type='work', number='333-333-3333'}], hobbies=[hobby 2, hobby 21]}
Person{id=1, firstName='first name 1', lastName='last name 1', age=11, addresses={work=Address{street='street 11', city='city 11', state='state 11', zipCode='22222'}, home=Address{street='street 1', city='city 1', state='state 1', zipCode='11111'}}, phoneNumbers=[PhoneNumber{type='home', number='111-111-1111'}, PhoneNumber{type='work', number='222-222-2222'}], hobbies=[hobby 1, hobby 11]}
// Logged results from comment line 2.
Person{id=null, firstName='null', lastName='null', age=null, addresses={work=Address{street='street 21', city='null', state='null', zipCode='null'}}, phoneNumbers=null, hobbies=null}
Person{id=null, firstName='null', lastName='null', age=null, addresses={work=Address{street='street 11', city='null', state='null', zipCode='null'}}, phoneNumbers=null, hobbies=null}
// Logged results from comment lines 3 and 4.
Person{id=null, firstName='null', lastName='null', age=null, addresses=null, phoneNumbers=null, hobbies=[hobby 2, hobby 21]}
hobby 21
Person{id=null, firstName='null', lastName='null', age=null, addresses=null, phoneNumbers=null, hobbies=[hobby 1, hobby 11]}
hobby 11
```
**Anmerkung**
Wenn die `attributesToProject()` Methode einer anderen Builder-Methode folgt, die Attribute hinzufügt, die Sie projizieren möchten, `attributesToProject()` ersetzt die mitgelieferte Liste der Attributnamen alle anderen Attributnamen.
Ein Scan, der mit der `ScanEnhancedRequest` Instanz im folgenden Codeausschnitt durchgeführt wird, gibt nur Hobbydaten zurück.
```
ScanEnhancedRequest lastOverwrites = ScanEnhancedRequest.builder()
.addNestedAttributeToProject(
NestedAttributeName.create("addresses", "work", "street"))
.addAttributeToProject("firstName")
// If the 'attributesToProject()' method follows other builder methods that add attributes for projection,
// its list of attributes replace all previous attributes.
.attributesToProject("hobbies")
.build();
PageIterable hobbiesOnlyResult = personDynamoDbTable.scan(lastOverwrites);
hobbiesOnlyResult.items().forEach(p ->
logger.info(p.toString()));
// Logged results.
Person{id=null, firstName='null', lastName='null', age=null, addresses=null, phoneNumbers=null, hobbies=[hobby 2, hobby 21]}
Person{id=null, firstName='null', lastName='null', age=null, addresses=null, phoneNumbers=null, hobbies=[hobby 1, hobby 11]}
```
Der folgende Codeausschnitt verwendet die Methode zuerst. `attributesToProject()` Bei dieser Reihenfolge werden alle anderen angeforderten Attribute beibehalten.
```
ScanEnhancedRequest attributesPreserved = ScanEnhancedRequest.builder()
// Use 'attributesToProject()' first so that the method call does not replace all other attributes
// that you want to project.
.attributesToProject("firstName")
.addNestedAttributeToProject(
NestedAttributeName.create("addresses", "work", "street"))
.addAttributeToProject("hobbies")
.build();
PageIterable allAttributesResult = personDynamoDbTable.scan(attributesPreserved);
allAttributesResult.items().forEach(p ->
logger.info(p.toString()));
// Logged results.
Person{id=null, firstName='first name 2', lastName='null', age=null, addresses={work=Address{street='street 21', city='null', state='null', zipCode='null'}}, phoneNumbers=null, hobbies=[hobby 2, hobby 21]}
Person{id=null, firstName='first name 1', lastName='null', age=null, addresses={work=Address{street='street 11', city='null', state='null', zipCode='null'}}, phoneNumbers=null, hobbies=[hobby 1, hobby 11]}
```
## Verwenden Sie komplexe Typen in Ausdrücken
Sie können komplexe Typen in Ausdrücken wie Filterausdrücken und Bedingungsausdrücken verwenden, indem Sie Dereferenzierungsoperatoren verwenden, um in der Struktur des komplexen Typs zu navigieren. Verwenden Sie für Objekte und Maps das `. (dot)` und für Listenelemente use `[n]` (eckige Klammern um die Sequenznummer des Elements). Sie können nicht auf einzelne Elemente einer Menge verweisen, aber Sie können die [`contains`Funktion](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) verwenden.
Das folgende Beispiel zeigt zwei Filterausdrücke, die bei Scanvorgängen verwendet werden. Die Filterausdrücke geben die Übereinstimmungsbedingungen für Elemente an, die Sie in den Ergebnissen haben möchten. In dem Beispiel werden `Person` die zuvor gezeigten `PhoneNumber` Klassen`Address`, und verwendet.
```
public void scanUsingFilterOfNestedAttr() {
// The following is a filter expression for an attribute that is a map of Address objects.
// By using this filter expression, the SDK returns Person objects that have an address
// with 'mailing' as a key and 'MS2' for a state value.
Expression addressFilter = Expression.builder()
.expression("addresses.#type.#field = :value")
.putExpressionName("#type", "mailing")
.putExpressionName("#field", "state")
.putExpressionValue(":value", AttributeValue.builder().s("MS2").build())
.build();
PageIterable addressFilterResults = personDynamoDbTable.scan(rb -> rb.
filterExpression(addressFilter));
addressFilterResults.items().stream().forEach(p -> logger.info("Person: {}", p));
assert addressFilterResults.items().stream().count() == 1;
// The following is a filter expression for an attribute that is a list of phone numbers.
// By using this filter expression, the SDK returns Person objects whose second phone number
// in the list has a type equal to 'cell'.
Expression phoneFilter = Expression.builder()
.expression("phoneNumbers[1].#type = :type")
.putExpressionName("#type", "type")
.putExpressionValue(":type", AttributeValue.builder().s("cell").build())
.build();
PageIterable phoneFilterResults = personDynamoDbTable.scan(rb -> rb
.filterExpression(phoneFilter)
.attributesToProject("id", "firstName", "lastName", "phoneNumbers")
);
phoneFilterResults.items().stream().forEach(p -> logger.info("Person: {}", p));
assert phoneFilterResults.items().stream().count() == 1;
assert phoneFilterResults.items().stream().findFirst().get().getPhoneNumbers().get(1).getType().equals("cell");
}
```
### Hilfsmethode, die die Tabelle auffüllt
```
public static void populateDatabase() {
Person person1 = new Person();
person1.setId(1);
person1.setFirstName("FirstName1");
person1.setLastName("LastName1");
Address billingAddr1 = new Address();
billingAddr1.setState("BS1");
billingAddr1.setCity("BillingTown1");
Address mailing1 = new Address();
mailing1.setState("MS1");
mailing1.setCity("MailingTown1");
person1.setAddresses(Map.of("billing", billingAddr1, "mailing", mailing1));
PhoneNumber pn1_1 = new PhoneNumber();
pn1_1.setType("work");
pn1_1.setNumber("111-111-1111");
PhoneNumber pn1_2 = new PhoneNumber();
pn1_2.setType("home");
pn1_2.setNumber("222-222-2222");
List phoneNumbers1 = List.of(pn1_1, pn1_2);
person1.setPhoneNumbers(phoneNumbers1);
personDynamoDbTable.putItem(person1);
Person person2 = person1;
person2.setId(2);
person2.setFirstName("FirstName2");
person2.setLastName("LastName2");
Address billingAddress2 = billingAddr1;
billingAddress2.setCity("BillingTown2");
billingAddress2.setState("BS2");
Address mailing2 = mailing1;
mailing2.setCity("MailingTown2");
mailing2.setState("MS2");
person2.setAddresses(Map.of("billing", billingAddress2, "mailing", mailing2));
PhoneNumber pn2_1 = new PhoneNumber();
pn2_1.setType("work");
pn2_1.setNumber("333-333-3333");
PhoneNumber pn2_2 = new PhoneNumber();
pn2_2.setType("cell");
pn2_2.setNumber("444-444-4444");
List phoneNumbers2 = List.of(pn2_1, pn2_2);
person2.setPhoneNumbers(phoneNumbers2);
personDynamoDbTable.putItem(person2);
}
```
### JSON-Darstellung von Elementen in der Datenbank
```
{
"id": 1,
"addresses": {
"billing": {
"city": "BillingTown1",
"state": "BS1",
"street": null,
"zipCode": null
},
"mailing": {
"city": "MailingTown1",
"state": "MS1",
"street": null,
"zipCode": null
}
},
"firstName": "FirstName1",
"lastName": "LastName1",
"phoneNumbers": [
{
"number": "111-111-1111",
"type": "work"
},
{
"number": "222-222-2222",
"type": "home"
}
]
}
{
"id": 2,
"addresses": {
"billing": {
"city": "BillingTown2",
"state": "BS2",
"street": null,
"zipCode": null
},
"mailing": {
"city": "MailingTown2",
"state": "MS2",
"street": null,
"zipCode": null
}
},
"firstName": "FirstName2",
"lastName": "LastName2",
"phoneNumbers": [
{
"number": "333-333-3333",
"type": "work"
},
{
"number": "444-444-4444",
"type": "cell"
}
]
}
```
## Aktualisieren Sie Elemente, die komplexe Typen enthalten
Um ein Element zu aktualisieren, das komplexe Typen enthält, haben Sie zwei grundlegende Methoden:
+ Ansatz 1: Rufen Sie zuerst das Element ab (mithilfe von`getItem`), aktualisieren Sie das Objekt und rufen Sie es dann auf`DynamoDbTable#updateItem`.
+ Ansatz 2: Rufen Sie das Element nicht ab, sondern erstellen Sie eine neue Instanz, legen Sie die Eigenschaften fest, die Sie aktualisieren möchten, und leiten Sie die Instanz weiter, `DynamoDbTable#updateItem` indem Sie den entsprechenden Wert von festlegen [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/IgnoreNullsMode.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/IgnoreNullsMode.html). Bei diesem Ansatz müssen Sie das Element nicht abrufen, bevor Sie es aktualisieren.
Die in diesem Abschnitt gezeigten Beispiele verwenden die zuvor aufgeführten `PhoneNumber` Klassen `Person``Address`, und.
### Aktualisierungsansatz 1: Abrufen, dann aktualisieren
Mit diesem Ansatz stellen Sie sicher, dass beim Update keine Daten verloren gehen. Die DynamoDB Enhanced Client API erstellt die Bean mit den Attributen des in DynamoDB gespeicherten Elements neu, einschließlich Werten komplexer Typen. Anschließend müssen Sie die Getter und Setter verwenden, um die Bean zu aktualisieren. Der Nachteil dieses Ansatzes sind die Kosten, die Ihnen entstehen, wenn Sie den Artikel zuerst abrufen.
Das folgende Beispiel zeigt, dass keine Daten verloren gehen, wenn Sie das Element zuerst abrufen, bevor Sie es aktualisieren.
```
public void retrieveThenUpdateExample() {
// Assume that we ran this code yesterday.
Person person = new Person();
person.setId(1);
person.setFirstName("FirstName");
person.setLastName("LastName");
Address mainAddress = new Address();
mainAddress.setStreet("123 MyStreet");
mainAddress.setCity("MyCity");
mainAddress.setState("MyState");
mainAddress.setZipCode("MyZipCode");
person.setMainAddress(mainAddress);
PhoneNumber homePhone = new PhoneNumber();
homePhone.setNumber("1111111");
homePhone.setType("HOME");
person.setPhoneNumbers(List.of(homePhone));
personDynamoDbTable.putItem(person);
// Assume that we are running this code now.
// First, retrieve the item
Person retrievedPerson = personDynamoDbTable.getItem(Key.builder().partitionValue(1).build());
// Make any updates.
retrievedPerson.getMainAddress().setCity("YourCity");
// Save the updated bean. 'updateItem' returns the bean as it appears after the update.
Person updatedPerson = personDynamoDbTable.updateItem(retrievedPerson);
// Verify for this example.
Address updatedMainAddress = updatedPerson.getMainAddress();
assert updatedMainAddress.getCity().equals("YourCity");
assert updatedMainAddress.getState().equals("MyState"); // Unchanged.
// The list of phone numbers remains; it was not set to null;
assert updatedPerson.getPhoneNumbers().size() == 1;
}
```
### Aktualisierungsansatz 2: Verwenden Sie eine `IgnoreNullsMode` Aufzählung, ohne das Element zuerst abzurufen
Um ein Element in DynamoDB zu aktualisieren, können Sie ein neues Objekt angeben, das nur die Eigenschaften hat, die Sie aktualisieren möchten, und die anderen Werte auf Null belassen. Bei diesem Ansatz müssen Sie wissen, wie Nullwerte im Objekt vom SDK behandelt werden und wie Sie das Verhalten steuern können.
Um anzugeben, welche Eigenschaften mit Nullwerten das SDK ignorieren soll, geben Sie beim Erstellen des eine `IgnoreNullsMode` Aufzählung an. [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/UpdateItemEnhancedRequest.Builder.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/UpdateItemEnhancedRequest.Builder.html) Als Beispiel für die Verwendung eines der Aufzählungswerte verwendet der folgende Codeausschnitt den Modus. `IgnoreNullsMode.SCALAR_ONLY`
```
// Create a new Person object to update the existing item in DynamoDB.
Person personForUpdate = new Person();
personForUpdate.setId(1);
personForUpdate.setFirstName("updatedFirstName"); // 'firstName' is a top scalar property.
Address addressForUpdate = new Address();
addressForUpdate.setCity("updatedCity");
personForUpdate.setMainAddress(addressForUpdate);
personDynamoDbTable.updateItem(r -> r
.item(personForUpdate)
.ignoreNullsMode(IgnoreNullsMode.SCALAR_ONLY));
/* With IgnoreNullsMode.SCALAR_ONLY provided, The SDK ignores all null properties. The SDK adds or replaces
the 'firstName' property with the provided value, "updatedFirstName". The SDK updates the 'city' value of
'mainAddress', as long as the 'mainAddress' attribute already exists in DynamoDB.
In the background, the SDK generates an update expression that it sends in the request to DynamoDB.
The following JSON object is a simplified version of what it sends. Notice that the SDK includes the paths
to 'mainAddress.city' and 'firstName' in the SET clause of the update expression. No null values in
'personForUpdate' are included.
{
"TableName": "PersonTable",
"Key": {
"id": {
"N": "1"
}
},
"ReturnValues": "ALL_NEW",
"UpdateExpression": "SET #mainAddress.#city = :mainAddress_city, #firstName = :firstName",
"ExpressionAttributeNames": {
"#city": "city",
"#firstName": "firstName",
"#mainAddress": "mainAddress"
},
"ExpressionAttributeValues": {
":firstName": {
"S": "updatedFirstName"
},
":mainAddress_city": {
"S": "updatedCity"
}
}
}
Had we chosen 'IgnoreNullsMode.DEFAULT' instead of 'IgnoreNullsMode.SCALAR_ONLY', the SDK would have included
null values in the "ExpressionAttributeValues" section of the request as shown in the following snippet.
"ExpressionAttributeValues": {
":mainAddress": {
"M": {
"zipCode": {
"NULL": true
},
"city": {
"S": "updatedCity"
},
"street": {
"NULL": true
},
"state": {
"NULL": true
}
}
},
":firstName": {
"S": "updatedFirstName"
}
}
*/
```
Das Amazon DynamoDB DynamoDB-Entwicklerhandbuch enthält weitere Informationen zu [Aktualisierungsausdrücken](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html).
#### Beschreibungen der Optionen `IgnoreNullsMode`
+ `IgnoreNullsMode.SCALAR_ONLY`- Verwenden Sie diese Einstellung, um skalare Attribute auf jeder Ebene zu aktualisieren. Das SDK erstellt eine Aktualisierungsanweisung, die nur skalare Attribute ungleich Null an DynamoDB sendet. Das SDK ignoriert nullwertige, skalare Attribute einer Bean oder Map und behält den gespeicherten Wert in DynamoDB bei.
Wenn Sie ein skalares Attribut von map oder bean aktualisieren, muss die Map bereits in DynamoDB vorhanden sein. Wenn Sie dem Objekt eine Map oder eine Bean hinzufügen, die noch nicht für das Objekt in DynamoDB vorhanden ist, erhalten Sie eine `DynamoDbException` mit der Meldung *Der im Aktualisierungsausdruck angegebene Dokumentpfad ist für die Aktualisierung ungültig*. Sie müssen `MAPS_ONLY` den Modus verwenden, um DynamoDB ein Bean oder eine Map hinzuzufügen, bevor Sie eines ihrer Attribute aktualisieren.
+ `IgnoreNullsMode.MAPS_ONLY`- Verwenden Sie diese Einstellung, um Eigenschaften hinzuzufügen oder zu ersetzen, bei denen es sich um eine Bean oder Map handelt. Das SDK ersetzt oder fügt alle im Objekt bereitgestellten Maps oder Beans hinzu. Alle Beans oder Maps, die im Objekt Null sind, werden ignoriert, wobei die in DynamoDB vorhandene Map beibehalten wird.
+ `IgnoreNullsMode.DEFAULT`— Mit dieser Einstellung ignoriert das SDK niemals Nullwerte. Skalare Attribute auf jeder Ebene, die Null sind, werden auf Null aktualisiert. Das SDK aktualisiert alle Bean-, Map-, List- oder Set-Eigenschaften mit Nullwert im Objekt in DynamoDB auf Null. Wenn Sie diesen Modus verwenden — oder keinen Modus angeben, da es der Standardmodus ist — sollten Sie das Element zuerst abrufen, damit Werte in DynamoDB nicht auf Null gesetzt werden, die im Objekt zur Aktualisierung bereitgestellt werden, es sei denn, Sie beabsichtigen, die Werte auf Null zu setzen.
Wenn Sie in allen Modi ein Objekt mit einer Liste oder einem Satz angeben`updateItem`, der nicht Null ist, wird die Liste oder der Satz in DynamoDB gespeichert.
#### Warum die Modi?
Wenn Sie ein Objekt mit einem Bean oder einer Map für die `updateItem` Methode bereitstellen, kann das SDK nicht sagen, ob es die Eigenschaftswerte in der Bean (oder die Eintragswerte in der Map) verwenden soll, um das Element zu aktualisieren, oder ob das Ganze das ersetzen bean/map soll, was in DynamoDB gespeichert wurde.
Ausgehend von unserem vorherigen Beispiel, das zuerst den Abruf des Elements zeigt, versuchen wir, das `city` Attribut von `mainAddress` ohne den Abruf zu aktualisieren.
```
/* The retrieval example saved the Person object with a 'mainAddress' property whose 'city' property value is "MyCity".
/* Note that we create a new Person with only the necessary information to update the city value
of the mainAddress. */
Person personForUpdate = new Person();
personForUpdate.setId(1);
// The update we want to make changes the city.
Address mainAddressForUpdate = new Address();
mainAddressForUpdate.setCity("YourCity");
personForUpdate.setMainAddress(mainAddressForUpdate);
// Lets' try the following:
Person updatedPerson = personDynamoDbTable.updateItem(personForUpdate);
/*
Since we haven't retrieved the item, we don't know if the 'mainAddress' property
already exists, so what update expression should the SDK generate?
A) Should it replace or add the 'mainAddress' with the provided object (setting all attributes to null other than city)
as shown in the following simplified JSON?
{
"TableName": "PersonTable",
"Key": {
"id": {
"N": "1"
}
},
"ReturnValues": "ALL_NEW",
"UpdateExpression": "SET #mainAddress = :mainAddress",
"ExpressionAttributeNames": {
"#mainAddress": "mainAddress"
},
"ExpressionAttributeValues": {
":mainAddress": {
"M": {
"zipCode": {
"NULL": true
},
"city": {
"S": "YourCity"
},
"street": {
"NULL": true
},
"state": {
"NULL": true
}
}
}
}
}
B) Or should it update only the 'city' attribute of an existing 'mainAddress' as shown in the following simplified JSON?
{
"TableName": "PersonTable",
"Key": {
"id": {
"N": "1"
}
},
"ReturnValues": "ALL_NEW",
"UpdateExpression": "SET #mainAddress.#city = :mainAddress_city",
"ExpressionAttributeNames": {
"#city": "city",
"#mainAddress": "mainAddress"
},
"ExpressionAttributeValues": {
":mainAddress_city": {
"S": "YourCity"
}
}
}
However, assume that we don't know if the 'mainAddress' already exists. If it doesn't exist, the SDK would try to update
an attribute of a non-existent map, which results in an exception.
In this particular case, we would likely select option B (SCALAR_ONLY) to retain the other values of the 'mainAddress'.
*/
```
Die folgenden beiden Beispiele zeigen die Verwendung der Werte `MAPS_ONLY` und der `SCALAR_ONLY` Aufzählungswerte. `MAPS_ONLY`fügt eine Map hinzu und `SCALAR_ONLY` aktualisiert eine Map.
##### `IgnoreNullsMode.MAPS_ONLY`Beispiel für
```
public void mapsOnlyModeExample() {
// Assume that we ran this code yesterday.
Person person = new Person();
person.setId(1);
person.setFirstName("FirstName");
personDynamoDbTable.putItem(person);
// Assume that we are running this code now.
/* Note that we create a new Person with only the necessary information to update the city value
of the mainAddress. */
Person personForUpdate = new Person();
personForUpdate.setId(1);
// The update we want to make changes the city.
Address mainAddressForUpdate = new Address();
mainAddressForUpdate.setCity("YourCity");
personForUpdate.setMainAddress(mainAddressForUpdate);
Person updatedPerson = personDynamoDbTable.updateItem(r -> r
.item(personForUpdate)
.ignoreNullsMode(IgnoreNullsMode.MAPS_ONLY)); // Since the mainAddress property does not exist, use MAPS_ONLY mode.
assert updatedPerson.getMainAddress().getCity().equals("YourCity");
assert updatedPerson.getMainAddress().getState() == null;
}
```
##### `IgnoreNullsMode.SCALAR_ONLY example`
```
public void scalarOnlyExample() {
// Assume that we ran this code yesterday.
Person person = new Person();
person.setId(1);
Address mainAddress = new Address();
mainAddress.setCity("MyCity");
mainAddress.setState("MyState");
person.setMainAddress(mainAddress);
personDynamoDbTable.putItem(person);
// Assume that we are running this code now.
/* Note that we create a new Person with only the necessary information to update the city value
of the mainAddress. */
Person personForUpdate = new Person();
personForUpdate.setId(1);
// The update we want to make changes the city.
Address mainAddressForUpdate = new Address();
mainAddressForUpdate.setCity("YourCity");
personForUpdate.setMainAddress(mainAddressForUpdate);
Person updatedPerson = personDynamoDbTable.updateItem(r -> r
.item(personForUpdate)
.ignoreNullsMode(IgnoreNullsMode.SCALAR_ONLY)); // SCALAR_ONLY mode ignores null properties in the in mainAddress.
assert updatedPerson.getMainAddress().getCity().equals("YourCity");
assert updatedPerson.getMainAddress().getState().equals("MyState"); // The state property remains the same.
}
```
In der folgenden Tabelle können Sie nachlesen, welche Nullwerte für jeden Modus ignoriert werden. Sie können oft mit beiden `SCALAR_ONLY` arbeiten, `MAPS_ONLY` außer wenn Sie mit Beans oder Maps arbeiten.
**Welche Eigenschaften mit Nullwert in dem Objekt, an das gesendet wurde, ignoriert `updateItem` das SDK für jeden Modus?**
| Art der Eigenschaft | im Modus SCALAR\$1ONLY | im MAPS\$1ONLY-Modus | im DEFAULT-Modus |
| --- | --- | --- | --- |
| Oberster Skalar | Ja | Ja | Nein |
| Bean oder Karte | Ja | Ja | Nein |
| Skalarwert eines Bean- oder Map-Eintrags | Ja1 | Nr.2 | Nein |
| Liste oder Satz | Ja | Ja | Nein |
1 Dies setzt voraus, dass die Map bereits in DynamoDB vorhanden ist. Jeder Skalarwert — Null oder nicht Null — der Bean oder Map, die Sie im Objekt für die Aktualisierung angeben, erfordert, dass ein Pfad zu dem Wert in DynamoDB existiert. Das SDK erstellt mithilfe des Dereferenzierungsoperators einen Pfad zu dem Attribut, bevor es die Anforderung sendet. `. (dot)`
2 Da Sie den `MAPS_ONLY` Modus verwenden, um eine Bean oder Map vollständig zu ersetzen oder hinzuzufügen, werden alle Nullwerte in der Bean oder Map in der in DynamoDB gespeicherten Map beibehalten.
# Leere Objekte konservieren mit `@DynamoDbPreserveEmptyObject`
Wenn Sie eine Bean mit leeren Objekten in Amazon DynamoDB speichern und möchten, dass das SDK die leeren Objekte beim Abrufen neu erstellt, kommentieren Sie den Getter der inneren Bean mit. `@DynamoDbPreserveEmptyObject`
Um zu veranschaulichen, wie die Anmerkung funktioniert, verwendet das Codebeispiel die folgenden beiden Beans.
## Beispiel Bohnen
Die folgende Datenklasse enthält zwei `InnerBean` Felder. Die Getter-Methode,`getInnerBeanWithoutAnno()`, ist nicht mit annotiert. `@DynamoDbPreserveEmptyObject` Die `getInnerBeanWithAnno()` Methode ist mit Anmerkungen versehen.
```
@DynamoDbBean
public class MyBean {
private String id;
private String name;
private InnerBean innerBeanWithoutAnno;
private InnerBean innerBeanWithAnno;
@DynamoDbPartitionKey
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public InnerBean getInnerBeanWithoutAnno() { return innerBeanWithoutAnno; }
public void setInnerBeanWithoutAnno(InnerBean innerBeanWithoutAnno) { this.innerBeanWithoutAnno = innerBeanWithoutAnno; }
@DynamoDbPreserveEmptyObject
public InnerBean getInnerBeanWithAnno() { return innerBeanWithAnno; }
public void setInnerBeanWithAnno(InnerBean innerBeanWithAnno) { this.innerBeanWithAnno = innerBeanWithAnno; }
@Override
public String toString() {
return new StringJoiner(", ", MyBean.class.getSimpleName() + "[", "]")
.add("innerBeanWithoutAnno=" + innerBeanWithoutAnno)
.add("innerBeanWithAnno=" + innerBeanWithAnno)
.add("id='" + id + "'")
.add("name='" + name + "'")
.toString();
}
}
```
Instanzen der folgenden `InnerBean` Klasse sind Felder von `MyBean` und werden im Beispielcode als leere Objekte initialisiert.
```
@DynamoDbBean
public class InnerBean {
private String innerBeanField;
public String getInnerBeanField() {
return innerBeanField;
}
public void setInnerBeanField(String innerBeanField) {
this.innerBeanField = innerBeanField;
}
@Override
public String toString() {
return "InnerBean{" +
"innerBeanField='" + innerBeanField + '\'' +
'}';
}
}
```
Das folgende Codebeispiel speichert ein `MyBean` Objekt mit initialisierten inneren Beans in DynamoDB und ruft dann das Element ab. Die protokollierte Ausgabe zeigt, dass das `innerBeanWithoutAnno` nicht initialisiert wurde, sondern erstellt wurde. `innerBeanWithAnno`
```
public MyBean preserveEmptyObjectAnnoUsingGetItemExample(DynamoDbTable myBeanTable) {
// Save an item to DynamoDB.
MyBean bean = new MyBean();
bean.setId("1");
bean.setInnerBeanWithoutAnno(new InnerBean()); // Instantiate the inner bean.
bean.setInnerBeanWithAnno(new InnerBean()); // Instantiate the inner bean.
myBeanTable.putItem(bean);
GetItemEnhancedRequest request = GetItemEnhancedRequest.builder()
.key(Key.builder().partitionValue("1").build())
.build();
MyBean myBean = myBeanTable.getItem(request);
logger.info(myBean.toString());
// Output 'MyBean[innerBeanWithoutAnno=null, innerBeanWithAnno=InnerBean{innerBeanField='null'}, id='1', name='null']'.
return myBean;
}
```
## Alternatives statisches Schema
Sie können die folgende `StaticTableSchema` Version der Tabellenschemas anstelle der Anmerkungen auf den Beans verwenden.
```
public static TableSchema buildStaticSchemas() {
StaticTableSchema innerBeanStaticTableSchema =
StaticTableSchema.builder(InnerBean.class)
.newItemSupplier(InnerBean::new)
.addAttribute(String.class, a -> a.name("innerBeanField")
.getter(InnerBean::getInnerBeanField)
.setter(InnerBean::setInnerBeanField))
.build();
return StaticTableSchema.builder(MyBean.class)
.newItemSupplier(MyBean::new)
.addAttribute(String.class, a -> a.name("id")
.getter(MyBean::getId)
.setter(MyBean::setId)
.addTag(primaryPartitionKey()))
.addAttribute(String.class, a -> a.name("name")
.getter(MyBean::getName)
.setter(MyBean::setName))
.addAttribute(EnhancedType.documentOf(InnerBean.class,
innerBeanStaticTableSchema),
a -> a.name("innerBean1")
.getter(MyBean::getInnerBeanWithoutAnno)
.setter(MyBean::setInnerBeanWithoutAnno))
.addAttribute(EnhancedType.documentOf(InnerBean.class,
innerBeanStaticTableSchema,
b -> b.preserveEmptyObject(true)),
a -> a.name("innerBean2")
.getter(MyBean::getInnerBeanWithAnno)
.setter(MyBean::setInnerBeanWithAnno))
.build();
}
```
# Vermeiden Sie das Speichern von Null-Attributen verschachtelter Objekte
Sie können Null-Attribute verschachtelter Objekte überspringen, wenn Sie ein Datenklassenobjekt in DynamoDB speichern, indem Sie die Anmerkung anwenden. `@DynamoDbIgnoreNulls` Im Gegensatz dazu werden Attribute der obersten Ebene mit Nullwerten niemals in der Datenbank gespeichert.
Um zu veranschaulichen, wie die Anmerkung funktioniert, verwendet das Codebeispiel die folgenden beiden Beans.
## Beispiel Bohnen
Die folgende Datenklasse enthält zwei `InnerBean` Felder. Die Getter-Methode,`getInnerBeanWithoutAnno()`, ist nicht annotiert. Die `getInnerBeanWithIgnoreNullsAnno()` Methode ist mit annotiert. `@DynamoDbIgnoreNulls`
```
@DynamoDbBean
public class MyBean {
private String id;
private String name;
private InnerBean innerBeanWithoutAnno;
private InnerBean innerBeanWithIgnoreNullsAnno;
@DynamoDbPartitionKey
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public InnerBean getInnerBeanWithoutAnno() { return innerBeanWithoutAnno; }
public void setInnerBeanWithoutAnno(InnerBean innerBeanWithoutAnno) { this.innerBeanWithoutAnno = innerBeanWithoutAnno; }
@DynamoDbIgnoreNulls
public InnerBean getInnerBeanWithIgnoreNullsAnno() { return innerBeanWithIgnoreNullsAnno; }
public void setInnerBeanWithIgnoreNullsAnno(InnerBean innerBeanWithAnno) { this.innerBeanWithIgnoreNullsAnno = innerBeanWithAnno; }
@Override
public String toString() {
return new StringJoiner(", ", MyBean.class.getSimpleName() + "[", "]")
.add("innerBeanWithoutAnno=" + innerBeanWithoutAnno)
.add("innerBeanWithIgnoreNullsAnno=" + innerBeanWithIgnoreNullsAnno)
.add("id='" + id + "'")
.add("name='" + name + "'")
.toString();
}
}
```
Instanzen der folgenden `InnerBean` Klasse sind Felder von `MyBean` und werden im folgenden Beispielcode verwendet.
```
@DynamoDbBean
public class InnerBean {
private String innerBeanFieldString;
private Integer innerBeanFieldInteger;
public String getInnerBeanFieldString() { return innerBeanFieldString; }
public void setInnerBeanFieldString(String innerBeanFieldString) { this.innerBeanFieldString = innerBeanFieldString; }
public Integer getInnerBeanFieldInteger() { return innerBeanFieldInteger; }
public void setInnerBeanFieldInteger(Integer innerBeanFieldInteger) { this.innerBeanFieldInteger = innerBeanFieldInteger; }
@Override
public String toString() {
return new StringJoiner(", ", InnerBean.class.getSimpleName() + "[", "]")
.add("innerBeanFieldString='" + innerBeanFieldString + "'")
.add("innerBeanFieldInteger=" + innerBeanFieldInteger)
.toString();
}
}
```
Im folgenden Codebeispiel wird ein `InnerBean` Objekt erstellt und nur einem seiner beiden Attribute ein Wert zugewiesen.
```
public void ignoreNullsAnnoUsingPutItemExample(DynamoDbTable myBeanTable) {
// Create an InnerBean object and give only one attribute a value.
InnerBean innerBeanOneAttributeSet = new InnerBean();
innerBeanOneAttributeSet.setInnerBeanFieldInteger(200);
// Create a MyBean instance and use the same InnerBean instance both for attributes.
MyBean bean = new MyBean();
bean.setId("1");
bean.setInnerBeanWithoutAnno(innerBeanOneAttributeSet);
bean.setInnerBeanWithIgnoreNullsAnno(innerBeanOneAttributeSet);
Map itemMap = myBeanTable.tableSchema().itemToMap(bean, true);
logger.info(itemMap.toString());
// Log the map that is sent to the database.
// {innerBeanWithIgnoreNullsAnno=AttributeValue(M={innerBeanFieldInteger=AttributeValue(N=200)}), id=AttributeValue(S=1), innerBeanWithoutAnno=AttributeValue(M={innerBeanFieldInteger=AttributeValue(N=200), innerBeanFieldString=AttributeValue(NUL=true)})}
// Save the MyBean object to the table.
myBeanTable.putItem(bean);
}
```
Um die Low-Level-Daten zu visualisieren, die an DynamoDB gesendet werden, protokolliert der Code die Attributzuordnung, bevor das Objekt gespeichert wird. `MyBean`
Die protokollierte Ausgabe zeigt, dass ein Attribut `innerBeanWithIgnoreNullsAnno` ausgegeben wird,
```
innerBeanWithIgnoreNullsAnno=AttributeValue(M={innerBeanFieldInteger=AttributeValue(N=200)})
```
Die `innerBeanWithoutAnno` Instanz gibt zwei Attribute aus. Ein Attribut hat einen Wert von 200 und das andere ist ein Nullwertattribut.
```
innerBeanWithoutAnno=AttributeValue(M={innerBeanFieldInteger=AttributeValue(N=200), innerBeanFieldString=AttributeValue(NUL=true)})
```
## JSON-Darstellung der Attributzuordnung
Die folgende JSON-Darstellung macht es einfacher, die in DynamoDB gespeicherten Daten zu sehen.
```
{
"id": {
"S": "1"
},
"innerBeanWithIgnoreNullsAnno": {
"M": {
"innerBeanFieldInteger": {
"N": "200"
}
}
},
"innerBeanWithoutAnno": {
"M": {
"innerBeanFieldInteger": {
"N": "200"
},
"innerBeanFieldString": {
"NULL": true
}
}
}
}
```
## Alternatives statisches Schema
Sie können die folgende `StaticTableSchema` Version der Tabellenschemas anstelle von Datenklassenanmerkungen verwenden.
```
public static TableSchema buildStaticSchemas() {
StaticTableSchema innerBeanStaticTableSchema =
StaticTableSchema.builder(InnerBean.class)
.newItemSupplier(InnerBean::new)
.addAttribute(String.class, a -> a.name("innerBeanFieldString")
.getter(InnerBean::getInnerBeanFieldString)
.setter(InnerBean::setInnerBeanFieldString))
.addAttribute(Integer.class, a -> a.name("innerBeanFieldInteger")
.getter(InnerBean::getInnerBeanFieldInteger)
.setter(InnerBean::setInnerBeanFieldInteger))
.build();
return StaticTableSchema.builder(MyBean.class)
.newItemSupplier(MyBean::new)
.addAttribute(String.class, a -> a.name("id")
.getter(MyBean::getId)
.setter(MyBean::setId)
.addTag(primaryPartitionKey()))
.addAttribute(String.class, a -> a.name("name")
.getter(MyBean::getName)
.setter(MyBean::setName))
.addAttribute(EnhancedType.documentOf(InnerBean.class,
innerBeanStaticTableSchema),
a -> a.name("innerBeanWithoutAnno")
.getter(MyBean::getInnerBeanWithoutAnno)
.setter(MyBean::setInnerBeanWithoutAnno))
.addAttribute(EnhancedType.documentOf(InnerBean.class,
innerBeanStaticTableSchema,
b -> b.ignoreNulls(true)),
a -> a.name("innerBeanWithIgnoreNullsAnno")
.getter(MyBean::getInnerBeanWithIgnoreNullsAnno)
.setter(MyBean::setInnerBeanWithIgnoreNullsAnno))
.build();
}
```
# Arbeiten Sie mit JSON-Dokumenten mit der Enhanced Document API für DynamoDB
Die [Enhanced Document API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/package-summary.html) für AWS SDK for Java 2.x ist für die Arbeit mit dokumentenorientierten Daten konzipiert, die kein festes Schema haben. Sie können damit jedoch auch benutzerdefinierte Klassen verwenden, um einzelne Attribute zuzuordnen.
Die Enhanced Document API ist der Nachfolger der [Document API](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/DynamoDB.html) der AWS SDK für Java Version v1.x.
**Contents**
+ [Beginnen Sie mit der Verwendung der Enhanced Document API](ddb-en-client-doc-api-steps.md)
+ [Erstellen Sie ein und ein `DocumentTableSchema` `DynamoDbTable`](ddb-en-client-doc-api-steps.md#ddb-en-client-doc-api-steps-createschema)
+ [Erstellen Sie erweiterte Dokumente](ddb-en-client-doc-api-steps-create-ed.md)
+ [Aus einer JSON-Zeichenfolge erstellen](ddb-en-client-doc-api-steps-create-ed.md#ddb-en-client-doc-api-steps-create-ed-fromJson)
+ [Aus einzelnen Elementen zusammensetzen](ddb-en-client-doc-api-steps-create-ed.md#ddb-en-client-doc-api-steps-create-ed-fromparts)
+ [Führen Sie CRUD-Operationen durch](ddb-en-client-doc-api-steps-use.md)
+ [Greifen Sie als benutzerdefinierte Objekte auf erweiterte Dokumentattribute zu](ddb-en-client-doc-api-convert.md)
+ [Verwenden Sie eine `EnhancedDocument` ohne DynamoDB](ddb-en-client-doc-api-standalone.md)
# Beginnen Sie mit der Verwendung der Enhanced Document API
Die Enhanced Document API erfordert dieselben [Abhängigkeiten](ddb-en-client-getting-started.md#ddb-en-client-gs-dep) wie die DynamoDB Enhanced Client API. Außerdem ist eine [`DynamoDbEnhancedClient`Instanz](ddb-en-client-getting-started-dynamodbTable.md#ddb-en-client-getting-started-dynamodbTable-eclient) erforderlich, wie am Anfang dieses Themas beschrieben.
Da die Enhanced Document API mit Version 2.20.3 von veröffentlicht wurde AWS SDK for Java 2.x, benötigen Sie diese Version oder eine höhere Version.
## Erstellen Sie ein und ein `DocumentTableSchema` `DynamoDbTable`
[Um mithilfe der Enhanced Document API Befehle für eine DynamoDB-Tabelle aufzurufen, verknüpfen Sie die Tabelle mit einem clientseitigen DynamoDbTable < > -Ressourcenobjekt. EnhancedDocument](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbTable.html)
Die `table()` Methode des erweiterten Clients erstellt eine `DynamoDbTable` Instanz und benötigt Parameter für den DynamoDB-Tabellennamen und a. `DocumentTableSchema`
Der Builder für a [DocumentTableSchema](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/DocumentTableSchema.html)erfordert einen primären Indexschlüssel und einen oder mehrere Attributkonverter-Anbieter. Die `AttributeConverterProvider.defaultProvider()` Methode stellt Konverter für [Standardtypen](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/internal/converter/attribute/package-summary.html) bereit. Sie sollte auch dann angegeben werden, wenn Sie einen benutzerdefinierten Attributkonverter-Anbieter angeben. Sie können dem Builder einen optionalen sekundären Indexschlüssel hinzufügen.
Der folgende Codeausschnitt zeigt den Code, der die clientseitige Darstellung einer DynamoDB-Tabelle generiert, in der schemalose Objekte gespeichert `person` werden. `EnhancedDocument`
```
DynamoDbTable documentDynamoDbTable =
enhancedClient.table("person",
TableSchema.documentSchemaBuilder()
// Specify the primary key attributes.
.addIndexPartitionKey(TableMetadata.primaryIndexName(),"id", AttributeValueType.S)
.addIndexSortKey(TableMetadata.primaryIndexName(), "lastName", AttributeValueType.S)
// Specify attribute converter providers. Minimally add the default one.
.attributeConverterProviders(AttributeConverterProvider.defaultProvider())
.build());
// Call documentTable.createTable() if "person" does not exist in DynamoDB.
// createTable() should be called only one time.
```
Im Folgenden wird die JSON-Darstellung eines Objekts gezeigt, die in diesem Abschnitt verwendet wird`person`.
### `person`JSON-Objekt
```
{
"id": 1,
"firstName": "Richard",
"lastName": "Roe",
"age": 25,
"addresses":
{
"home": {
"zipCode": "00000",
"city": "Any Town",
"state": "FL",
"street": "123 Any Street"
},
"work": {
"zipCode": "00001",
"city": "Anywhere",
"state": "FL",
"street": "100 Main Street"
}
},
"hobbies": [
"Hobby 1",
"Hobby 2"
],
"phoneNumbers": [
{
"type": "Home",
"number": "555-0100"
},
{
"type": "Work",
"number": "555-0119"
}
]
}
```
# Erstellen Sie erweiterte Dokumente
An `[EnhancedDocument](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html)` steht für ein Objekt vom Typ Dokument mit einer komplexen Struktur mit verschachtelten Attributen. An `EnhancedDocument` erfordert Attribute der obersten Ebene, die den für den angegebenen Primärschlüsselattributen entsprechen. `DocumentTableSchema` Der restliche Inhalt ist willkürlich und kann aus Attributen der obersten Ebene und auch tief verschachtelten Attributen bestehen.
Sie erstellen eine `EnhancedDocument` Instanz mithilfe eines Builders, der mehrere Möglichkeiten zum Hinzufügen von Elementen bietet.
## Aus einer JSON-Zeichenfolge erstellen
Mit einer JSON-Zeichenfolge können Sie einen Methodenaufruf `EnhancedDocument` in einem Schritt erstellen. Das folgende Snippet erstellt `EnhancedDocument` aus einer JSON-Zeichenfolge, die von der `jsonPerson()` Hilfsmethode zurückgegeben wird. Die `jsonPerson()` Methode gibt die JSON-String-Version des zuvor gezeigten [Personenobjekts](ddb-en-client-doc-api-steps.md#ddb-en-client-doc-api-steps-createschema-obj) zurück.
```
EnhancedDocument document =
EnhancedDocument.builder()
.json( jsonPerson() )
.build());
```
## Aus einzelnen Elementen zusammensetzen
Alternativ können Sie mit den typsicheren Methoden des Builders eine `EnhancedDocument` Instanz aus einzelnen Komponenten erstellen.
Im folgenden Beispiel wird ein `person` erweitertes Dokument erstellt, das dem erweiterten Dokument ähnelt, das aus der JSON-Zeichenfolge im vorherigen Beispiel erstellt wurde.
```
/* Define the shape of an address map whose JSON representation looks like the following.
Use 'addressMapEnhancedType' in the following EnhancedDocument.builder() to simplify the code.
"home": {
"zipCode": "00000",
"city": "Any Town",
"state": "FL",
"street": "123 Any Street"
}*/
EnhancedType> addressMapEnhancedType =
EnhancedType.mapOf(EnhancedType.of(String.class), EnhancedType.of(String.class));
// Use the builder's typesafe methods to add elements to the enhanced document.
EnhancedDocument personDocument = EnhancedDocument.builder()
.putNumber("id", 50)
.putString("firstName", "Shirley")
.putString("lastName", "Rodriguez")
.putNumber("age", 53)
.putNull("nullAttribute")
.putJson("phoneNumbers", phoneNumbersJSONString())
/* Add the map of addresses whose JSON representation looks like the following.
{
"home": {
"zipCode": "00000",
"city": "Any Town",
"state": "FL",
"street": "123 Any Street"
}
} */
.putMap("addresses", getAddresses(), EnhancedType.of(String.class), addressMapEnhancedType)
.putList("hobbies", List.of("Theater", "Golf"), EnhancedType.of(String.class))
.build();
```
### Hilfsmethoden
```
private static String phoneNumbersJSONString() {
return " [" +
" {" +
" \"type\": \"Home\"," +
" \"number\": \"555-0140\"" +
" }," +
" {" +
" \"type\": \"Work\"," +
" \"number\": \"555-0155\"" +
" }" +
" ]";
}
private static Map> getAddresses() {
return Map.of(
"home", Map.of(
"zipCode", "00002",
"city", "Any Town",
"state", "ME",
"street", "123 Any Street"));
}
```
# Führen Sie CRUD-Operationen durch
Nachdem Sie eine `EnhancedDocument` Instanz definiert haben, können Sie sie in einer DynamoDB-Tabelle speichern. Der folgende Codeausschnitt verwendet das [PersonDocument, das aus einzelnen Elementen](ddb-en-client-doc-api-steps-create-ed.md#ddb-en-client-doc-api-steps-create-ed-fromparts) erstellt wurde.
```
documentDynamoDbTable.putItem(personDocument);
```
Nachdem Sie eine erweiterte Dokumentinstanz aus DynamoDB gelesen haben, können Sie die einzelnen Attributwerte mithilfe von Getter extrahieren, wie im folgenden Codeausschnitt gezeigt, die auf die Daten zugreifen, die aus dem gespeichert wurden. `personDocument` Alternativ können Sie den gesamten Inhalt in eine JSON-Zeichenfolge extrahieren, wie im letzten Teil des Beispielcodes gezeigt.
```
// Read the item.
EnhancedDocument personDocFromDb = documentDynamoDbTable.getItem(Key.builder().partitionValue(50).build());
// Access top-level attributes.
logger.info("Name: {} {}", personDocFromDb.getString("firstName"), personDocFromDb.getString("lastName"));
// Name: Shirley Rodriguez
// Typesafe access of a deeply nested attribute. The addressMapEnhancedType shown previously defines the shape of an addresses map.
Map> addresses = personDocFromDb.getMap("addresses", EnhancedType.of(String.class), addressMapEnhancedType);
addresses.keySet().forEach(k -> logger.info(addresses.get(k).toString()));
// {zipCode=00002, city=Any Town, street=123 Any Street, state=ME}
// Alternatively, work with AttributeValue types checking along the way for deeply nested attributes.
Map addressesMap = personDocFromDb.getMapOfUnknownType("addresses");
addressesMap.keySet().forEach((String k) -> {
logger.info("Looking at data for [{}] address", k);
// Looking at data for [home] address
AttributeValue value = addressesMap.get(k);
AttributeValue cityValue = value.m().get("city");
if (cityValue != null) {
logger.info(cityValue.s());
// Any Town
}
});
List phoneNumbers = personDocFromDb.getListOfUnknownType("phoneNumbers");
phoneNumbers.forEach((AttributeValue av) -> {
if (av.hasM()) {
AttributeValue type = av.m().get("type");
if (type.s() != null) {
logger.info("Type of phone: {}", type.s());
// Type of phone: Home
// Type of phone: Work
}
}
});
String jsonPerson = personDocFromDb.toJson();
logger.info(jsonPerson);
// {"firstName":"Shirley","lastName":"Rodriguez","addresses":{"home":{"zipCode":"00002","city":"Any Town","street":"123 Any Street","state":"ME"}},"hobbies":["Theater","Golf"],
// "id":50,"nullAttribute":null,"age":53,"phoneNumbers":[{"number":"555-0140","type":"Home"},{"number":"555-0155","type":"Work"}]}
```
`EnhancedDocument`Instanzen können mit jeder Methode von `[DynamoDbTable](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbTable.html)` oder [DynamoDbEnhancedClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbEnhancedClient.html)anstelle von zugewiesenen Datenklassen verwendet werden.
# Greifen Sie als benutzerdefinierte Objekte auf erweiterte Dokumentattribute zu
Die Enhanced Document API bietet nicht nur eine API zum Lesen und Schreiben von Attributen mit schemalosen Strukturen, sondern ermöglicht auch die Konvertierung von Attributen in und aus Instanzen benutzerdefinierter Klassen.
Die Enhanced Document API verwendet `AttributeConverterProvider` s und `AttributeConverter` s, die im Abschnitt zur [Konvertierung von Steuerattributen](ddb-en-client-adv-features-conversion.md) als Teil der DynamoDB Enhanced Client API angezeigt wurden.
Im folgenden Beispiel verwenden wir a `CustomAttributeConverterProvider` mit seiner verschachtelten `AddressConverter` Klasse, um Objekte zu konvertieren. `Address`
Dieses Beispiel zeigt, dass Sie Daten aus Klassen und auch Daten aus Strukturen kombinieren können, die nach Bedarf erstellt werden. Dieses Beispiel zeigt auch, dass benutzerdefinierte Klassen auf jeder Ebene einer verschachtelten Struktur verwendet werden können. Die `Address` Objekte in diesem Beispiel sind Werte, die in einer Map verwendet werden.
```
public static void attributeToAddressClassMappingExample(DynamoDbEnhancedClient enhancedClient, DynamoDbClient standardClient) {
String tableName = "customer";
// Define the DynamoDbTable for an enhanced document.
// The schema builder provides methods for attribute converter providers and keys.
DynamoDbTable documentDynamoDbTable = enhancedClient.table(tableName,
DocumentTableSchema.builder()
// Add the CustomAttributeConverterProvider along with the default when you build the table schema.
.attributeConverterProviders(
List.of(
new CustomAttributeConverterProvider(),
AttributeConverterProvider.defaultProvider()))
.addIndexPartitionKey(TableMetadata.primaryIndexName(), "id", AttributeValueType.N)
.addIndexSortKey(TableMetadata.primaryIndexName(), "lastName", AttributeValueType.S)
.build());
// Create the DynamoDB table if needed.
documentDynamoDbTable.createTable();
waitForTableCreation(tableName, standardClient);
// The getAddressesForCustomMappingExample() helper method that provides 'addresses' shows the use of a custom Address class
// rather than using a Map to hold the address data.
Map addresses = getAddressesForCustomMappingExample();
// Build an EnhancedDocument instance to save an item with a mix of structures defined as needed and static classes.
EnhancedDocument personDocument = EnhancedDocument.builder()
.putNumber("id", 50)
.putString("firstName", "Shirley")
.putString("lastName", "Rodriguez")
.putNumber("age", 53)
.putNull("nullAttribute")
.putJson("phoneNumbers", phoneNumbersJSONString())
// Note the use of 'EnhancedType.of(Address.class)' instead of the more generic
// 'EnhancedType.mapOf(EnhancedType.of(String.class), EnhancedType.of(String.class))' that was used in a previous example.
.putMap("addresses", addresses, EnhancedType.of(String.class), EnhancedType.of(Address.class))
.putList("hobbies", List.of("Hobby 1", "Hobby 2"), EnhancedType.of(String.class))
.build();
// Save the item to DynamoDB.
documentDynamoDbTable.putItem(personDocument);
// Retrieve the item just saved.
EnhancedDocument srPerson = documentDynamoDbTable.getItem(Key.builder().partitionValue(50).sortValue("Rodriguez").build());
// Access the addresses attribute.
Map srAddresses = srPerson.get("addresses",
EnhancedType.mapOf(EnhancedType.of(String.class), EnhancedType.of(Address.class)));
srAddresses.keySet().forEach(k -> logger.info(addresses.get(k).toString()));
documentDynamoDbTable.deleteTable();
// The content logged to the console shows that the saved maps were converted to Address instances.
Address{street='123 Main Street', city='Any Town', state='NC', zipCode='00000'}
Address{street='100 Any Street', city='Any Town', state='NC', zipCode='00000'}
```
## `CustomAttributeConverterProvider`-Code
```
public class CustomAttributeConverterProvider implements AttributeConverterProvider {
private final Map, AttributeConverter> converterCache = ImmutableMap.of(
// 1. Add AddressConverter to the internal cache.
EnhancedType.of(Address.class), new AddressConverter());
public static CustomAttributeConverterProvider create() {
return new CustomAttributeConverterProvider();
}
// 2. The enhanced client queries the provider for attribute converters if it
// encounters a type that it does not know how to convert.
@SuppressWarnings("unchecked")
@Override
public AttributeConverter converterFor(EnhancedType enhancedType) {
return (AttributeConverter) converterCache.get(enhancedType);
}
// 3. Custom attribute converter
private class AddressConverter implements AttributeConverter {
// 4. Transform an Address object into a DynamoDB map.
@Override
public AttributeValue transformFrom(Address address) {
Map attributeValueMap = Map.of(
"street", AttributeValue.fromS(address.getStreet()),
"city", AttributeValue.fromS(address.getCity()),
"state", AttributeValue.fromS(address.getState()),
"zipCode", AttributeValue.fromS(address.getZipCode()));
return AttributeValue.fromM(attributeValueMap);
}
// 5. Transform the DynamoDB map attribute to an Address oject.
@Override
public Address transformTo(AttributeValue attributeValue) {
Map m = attributeValue.m();
Address address = new Address();
address.setStreet(m.get("street").s());
address.setCity(m.get("city").s());
address.setState(m.get("state").s());
address.setZipCode(m.get("zipCode").s());
return address;
}
@Override
public EnhancedType type() {
return EnhancedType.of(Address.class);
}
@Override
public AttributeValueType attributeValueType() {
return AttributeValueType.M;
}
}
}
```
## `Address`-Klasse
```
public class Address {
private String street;
private String city;
private String state;
private String zipCode;
public Address() {
}
public String getStreet() {
return this.street;
}
public String getCity() {
return this.city;
}
public String getState() {
return this.state;
}
public String getZipCode() {
return this.zipCode;
}
public void setStreet(String street) {
this.street = street;
}
public void setCity(String city) {
this.city = city;
}
public void setState(String state) {
this.state = state;
}
public void setZipCode(String zipCode) {
this.zipCode = zipCode;
}
}
```
## Hilfsmethode, die Adressen bereitstellt
Die folgende Hilfsmethode stellt die Map bereit, die benutzerdefinierte `Address` Instanzen für Werte anstelle von generischen `Map` Instanzen für Werte verwendet.
```
private static Map getAddressesForCustomMappingExample() {
Address homeAddress = new Address();
homeAddress.setStreet("100 Any Street");
homeAddress.setCity("Any Town");
homeAddress.setState("NC");
homeAddress.setZipCode("00000");
Address workAddress = new Address();
workAddress.setStreet("123 Main Street");
workAddress.setCity("Any Town");
workAddress.setState("NC");
workAddress.setZipCode("00000");
return Map.of("home", homeAddress,
"work", workAddress);
}
```
# Verwenden Sie eine `EnhancedDocument` ohne DynamoDB
Normalerweise verwenden Sie eine Instanz von an, `EnhancedDocument` um DynamoDB-Elemente vom Typ Dokument zu lesen und zu schreiben, sie kann jedoch auch unabhängig von DynamoDB verwendet werden.
Sie können ihre Fähigkeit verwenden`EnhancedDocuments`, zwischen JSON-Zeichenfolgen oder benutzerdefinierten Objekten in Low-Level-Maps von `AttributeValues` zu konvertieren, wie im folgenden Beispiel gezeigt.
```
public static void conversionWithoutDynamoDbExample() {
Address address = new Address();
address.setCity("my city");
address.setState("my state");
address.setStreet("my street");
address.setZipCode("00000");
// Build an EnhancedDocument instance for its conversion functionality alone.
EnhancedDocument addressEnhancedDoc = EnhancedDocument.builder()
// Important: You must specify attribute converter providers when you build an EnhancedDocument instance not used with a DynamoDB table.
.attributeConverterProviders(new CustomAttributeConverterProvider(), DefaultAttributeConverterProvider.create())
.put("addressDoc", address, Address.class)
.build();
// Convert address to a low-level item representation.
final Map addressAsAttributeMap = addressEnhancedDoc.getMapOfUnknownType("addressDoc");
logger.info("addressAsAttributeMap: {}", addressAsAttributeMap.toString());
// Convert address to a JSON string.
String addressAsJsonString = addressEnhancedDoc.getJson("addressDoc");
logger.info("addressAsJsonString: {}", addressAsJsonString);
// Convert addressEnhancedDoc back to an Address instance.
Address addressConverted = addressEnhancedDoc.get("addressDoc", Address.class);
logger.info("addressConverted: {}", addressConverted.toString());
}
/* Console output:
addressAsAttributeMap: {zipCode=AttributeValue(S=00000), state=AttributeValue(S=my state), street=AttributeValue(S=my street), city=AttributeValue(S=my city)}
addressAsJsonString: {"zipCode":"00000","state":"my state","street":"my street","city":"my city"}
addressConverted: Address{street='my street', city='my city', state='my state', zipCode='00000'}
*/
```
**Anmerkung**
Wenn Sie ein erweitertes Dokument verwenden, das unabhängig von einer DynamoDB-Tabelle ist, stellen Sie sicher, dass Sie im Builder explizit Attributkonverter-Anbieter festlegen.
Im Gegensatz dazu stellt das Dokumenttabellenschema die Konverteranbieter bereit, wenn ein erweitertes Dokument mit einer DynamoDB-Tabelle verwendet wird.
# Verwenden Sie Erweiterungen, um DynamoDB Enhanced Client-Operationen anzupassen
Die DynamoDB Enhanced Client API unterstützt Plugin-Erweiterungen, die Funktionen bieten, die über Mapping-Operationen hinausgehen. Erweiterungen verwenden zwei Hook-Methoden, um Daten während Lese- und Schreibvorgängen zu ändern:
+ `beforeWrite()`- Ändert einen Schreibvorgang, bevor er stattfindet
+ `afterRead()`- Ändert die Ergebnisse eines Lesevorgangs, nachdem er ausgeführt wurde
Bei einigen Operationen (wie Artikelaktualisierungen) wird sowohl ein Schreib- als auch ein Lesevorgang ausgeführt, sodass beide Hook-Methoden aufgerufen werden.
## Wie werden Erweiterungen geladen
Erweiterungen werden in der Reihenfolge geladen, die Sie im erweiterten Client Builder angegeben haben. Die Ladereihenfolge kann wichtig sein, da eine Erweiterung auf Werte reagieren kann, die durch eine vorherige Erweiterung transformiert wurden.
Standardmäßig lädt der erweiterte Client zwei Erweiterungen:
+ `[VersionedRecordExtension](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/extensions/VersionedRecordExtension.html)`- Sorgt für optimistisches Sperren
+ `[AtomicCounterExtension](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/extensions/AtomicCounterExtension.html)`- Inkrementiert automatisch die Zählerattribute
Sie können das Standardverhalten mit dem erweiterten Client Builder überschreiben und jede Erweiterung laden. Sie können auch keine angeben, wenn Sie die Standarderweiterungen nicht verwenden möchten.
**Wichtig**
Wenn Sie Ihre eigenen Erweiterungen laden, lädt der erweiterte Client keine Standarderweiterungen. Wenn Sie das Verhalten einer der Standarderweiterungen verwenden möchten, müssen Sie sie explizit zur Liste der Erweiterungen hinzufügen.
Das folgende Beispiel zeigt, wie eine benutzerdefinierte Erweiterung geladen wird, die `verifyChecksumExtension` nach dem benannt ist`VersionedRecordExtension`. Die `AtomicCounterExtension` ist in diesem Beispiel nicht geladen.
```
DynamoDbEnhancedClientExtension versionedRecordExtension = VersionedRecordExtension.builder().build();
DynamoDbEnhancedClient enhancedClient =
DynamoDbEnhancedClient.builder()
.dynamoDbClient(dynamoDbClient)
.extensions(versionedRecordExtension, verifyChecksumExtension)
.build();
```
## Verfügbare Erweiterungsdetails und Konfiguration
Die folgenden Abschnitte enthalten detaillierte Informationen zu jeder verfügbaren Erweiterung im SDK.
### Implementieren Sie optimistisches Sperren mit dem `VersionedRecordExtension`
Die `VersionedRecordExtension` Erweiterung ermöglicht optimistisches Sperren, indem die Versionsnummer eines Elements beim Schreiben von Elementen in die Datenbank erhöht und nachverfolgt wird. Jedem Schreibvorgang wird eine Bedingung hinzugefügt, die dazu führt, dass der Schreibvorgang fehlschlägt, wenn die Versionsnummer des tatsächlich persistenten Elements nicht dem Wert entspricht, den die Anwendung zuletzt gelesen hat.
#### Konfiguration
Um anzugeben, welches Attribut verwendet werden soll, um die Versionsnummer des Elements nachzuverfolgen, kennzeichnen Sie ein numerisches Attribut im Tabellenschema.
Der folgende Codeausschnitt gibt an, dass das `version` Attribut die Versionsnummer des Artikels enthalten soll.
```
@DynamoDbVersionAttribute
public Integer getVersion() {...};
public void setVersion(Integer version) {...};
```
Der entsprechende Ansatz für ein statisches Tabellenschema wird im folgenden Codeausschnitt dargestellt.
```
.addAttribute(Integer.class, a -> a.name("version")
.getter(Customer::getVersion)
.setter(Customer::setVersion)
// Apply the 'version' tag to the attribute.
.tags(VersionedRecordExtension.AttributeTags.versionAttribute())
```
#### Funktionsweise
Das optimistische Sperren mit dem `VersionedRecordExtension` hat folgende Auswirkungen auf diese `DynamoDbEnhancedClient` und `DynamoDbTable` Methoden:
**`putItem`**
Neuen Elementen wird der ursprüngliche Versionswert 0 zugewiesen. Dies kann mit konfiguriert werden`@DynamoDbVersionAttribute(startAt = X)`.
**`updateItem`**
Wenn Sie ein Element abrufen, eine oder mehrere seiner Eigenschaften aktualisieren und versuchen, die Änderungen zu speichern, ist der Vorgang nur erfolgreich, wenn die Versionsnummer auf der Client- und der Serverseite übereinstimmen.
Bei Erfolg wird die Versionsnummer automatisch um 1 erhöht. Dies kann mit `@DynamoDbVersionAttribute(incrementBy = X)` konfiguriert werden.
**`deleteItem`**
Die `DynamoDbVersionAttribute` Anmerkung hat keine Auswirkung. Sie müssen beim Löschen eines Elements manuell Bedingungsausdrücke hinzufügen.
Im folgenden Beispiel wird ein bedingter Ausdruck hinzugefügt, um sicherzustellen, dass es sich bei dem gelöschten Element auch um das gelesene Element handelt. Im folgenden Beispiel `recordVersion` ist das Attribut der Bean mit `@DynamoDbVersionAttribute` annotiert.
```
// 1. Read the item and get its current version.
Customer item = customerTable.getItem(Key.builder().partitionValue("someId").build());
// `recordVersion` is the bean's attribute that is annotated with `@DynamoDbVersionAttribute`.
AttributeValue currentVersion = item.getRecordVersion();
// 2. Create conditional delete with the `currentVersion` value.
DeleteItemEnhancedRequest deleteItemRequest =
DeleteItemEnhancedRequest.builder()
.key(KEY)
.conditionExpression(Expression.builder()
.expression("recordVersion = :current_version_value")
.putExpressionValue(":current_version_value", currentVersion)
.build()).build();
customerTable.deleteItem(deleteItemRequest);
```
**`transactWriteItems`**
+ `addPutItem`: Diese Methode hat das gleiche Verhalten wie`putItem`.
+ `addUpdateItem`: Diese Methode hat das gleiche Verhalten wie`updateItem`.
+ `addDeleteItem`: Diese Methode hat das gleiche Verhalten wie`deleteItem`.
**`batchWriteItem`**
+ `addPutItem`: Diese Methode hat das gleiche Verhalten wie`putItem`.
+ `addDeleteItem`: Diese Methode hat das gleiche Verhalten wie`deleteItem`.
**Anmerkung**
Globale DynamoDB-Tabellen verwenden einen [Abgleich zwischen gleichzeitigen Aktualisierungen, bei dem DynamoDB sich nach besten Kräften bemüht, den letzten Writer](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2globaltables_HowItWorks.html#V2globaltables_HowItWorks.consistency-modes) zu ermitteln. Wenn Sie globale Tabellen verwenden, bedeutet diese „Last Writer gewinnt“ -Richtlinie, dass Sperrstrategien möglicherweise nicht wie erwartet funktionieren, da alle Replikate letztendlich auf der Grundlage des von DynamoDB bestimmten letzten Schreibvorgangs konvergieren.
#### Wie deaktiviere ich
Verwenden Sie die `@DynamoDbVersionAttribute` Anmerkung nicht, um das optimistische Sperren zu deaktivieren.
### Implementieren Sie Zähler mit dem `AtomicCounterExtension`
Die `AtomicCounterExtension` Erweiterung erhöht jedes Mal, wenn ein Datensatz in die Datenbank geschrieben wird, ein mit Tags versehenes numerisches Attribut. Sie können Start- und Inkrementwerte angeben. Wenn keine Werte angegeben sind, wird der Startwert auf 0 gesetzt und der Wert des Attributs wird um 1 erhöht.
#### Konfiguration
Um anzugeben, welches Attribut ein Zähler ist, kennzeichnen Sie ein Attribut vom Typ `Long` im Tabellenschema.
Der folgende Ausschnitt zeigt die Verwendung der standardmäßigen Start- und Inkrementwerte für das Attribut. `counter`
```
@DynamoDbAtomicCounter
public Long getCounter() {...};
public void setCounter(Long counter) {...};
```
Der Ansatz eines statischen Tabellenschemas wird im folgenden Codeausschnitt dargestellt. Die Atomic Counter Extension verwendet einen Startwert von 10 und erhöht den Wert jedes Mal, wenn der Datensatz geschrieben wird, um 5.
```
.addAttribute(Integer.class, a -> a.name("counter")
.getter(Customer::getCounter)
.setter(Customer::setCounter)
// Apply the 'atomicCounter' tag to the attribute with start and increment values.
.tags(StaticAttributeTags.atomicCounter(10L, 5L))
```
### Fügen Sie Zeitstempel hinzu mit `AutoGeneratedTimestampRecordExtension`
Die `AutoGeneratedTimestampRecordExtension` Erweiterung aktualisiert jedes Mal, wenn das Element erfolgreich in die Datenbank geschrieben wurde, automatisch markierte Attribute des Typs `[Instant](https://docs.oracle.com/javase/8/docs/api/java/time/Instant.html)` mit einem aktuellen Zeitstempel. Diese Erweiterung ist standardmäßig nicht geladen.
#### Konfiguration
Um anzugeben, welches Attribut mit dem aktuellen Zeitstempel aktualisiert werden soll, kennzeichnen Sie das `Instant` Attribut im Tabellenschema.
Das `lastUpdate` Attribut ist das Ziel des Verhaltens der Erweiterung im folgenden Codeausschnitt. Beachten Sie die Anforderung, dass das Attribut ein `Instant` Typ sein muss.
```
@DynamoDbAutoGeneratedTimestampAttribute
public Instant getLastUpdate() {...}
public void setLastUpdate(Instant lastUpdate) {...}
```
Der entsprechende Ansatz für ein statisches Tabellenschema wird im folgenden Codeausschnitt dargestellt.
```
.addAttribute(Instant.class, a -> a.name("lastUpdate")
.getter(Customer::getLastUpdate)
.setter(Customer::setLastUpdate)
// Applying the 'autoGeneratedTimestamp' tag to the attribute.
.tags(AutoGeneratedTimestampRecordExtension.AttributeTags.autoGeneratedTimestampAttribute())
```
### Generieren Sie eine UUID mit dem AutoGeneratedUuidExtension
Die `AutoGeneratedUuidExtension` Erweiterung generiert eine eindeutige UUID (Universally Unique Identifier) für ein Attribut, wenn ein neuer Datensatz in die Datenbank geschrieben wird. Verwendet die Java-JDK-Methode [UUID.randomUUID () und gilt für Typattribute](https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--). `java.lang.String` Diese Erweiterung wird standardmäßig nicht geladen.
#### Konfiguration
Das `uniqueId` Attribut ist das Ziel des Verhaltens der Erweiterung im folgenden Codeausschnitt.
```
@AutoGeneratedUuidExtension
public String getUniqueId() {...}
public void setUniqueId(String uniqueId) {...}
```
Der entsprechende Ansatz für ein statisches Tabellenschema wird im folgenden Codeausschnitt dargestellt.
```
.addAttribute(String.class, a -> a.name("uniqueId")
.getter(Customer::getUniqueId)
.setter(Customer::setUniqueId)
// Applying the 'autoGeneratedUuid' tag to the attribute.
.tags(AutoGeneratedUuidExtension.AttributeTags.autoGeneratedUuidAttribute())
```
Wenn Sie möchten, dass die Erweiterung die UUID nur für `putItem` Methoden und nicht für Methoden auffüllt, fügen Sie die Anmerkung zum `updateItem` [Aktualisierungsverhalten](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/UpdateBehavior.html) hinzu, wie im folgenden Codeausschnitt gezeigt.
```
@AutoGeneratedUuidExtension
@DynamoDbUpdateBehavior(UpdateBehavior.WRITE_IF_NOT_EXISTS)
public String getUniqueId() {...}
public void setUniqueId(String uniqueId) {...}
```
Wenn Sie den Ansatz eines statischen Tabellenschemas verwenden, verwenden Sie den folgenden äquivalenten Code.
```
.addAttribute(String.class, a -> a.name("uniqueId")
.getter(Customer::getUniqueId)
.setter(Customer::setUniqueId)
// Applying the 'autoGeneratedUuid' tag to the attribute.
.tags(AutoGeneratedUuidExtension.AttributeTags.autoGeneratedUuidAttribute(),
StaticAttributeTags.updateBehavior(UpdateBehavior.WRITE_IF_NOT_EXISTS))
```
# Beispiel für eine benutzerdefinierte Erweiterung
Sie können benutzerdefinierte Erweiterungen erstellen, indem Sie die `DynamoDbEnhancedClientExtension` Schnittstelle implementieren. Die folgende benutzerdefinierte Erweiterungsklasse zeigt eine `beforeWrite()` Methode, die einen Aktualisierungsausdruck verwendet, um ein `registrationDate` Attribut festzulegen, falls das Element in der Datenbank noch keines hat.
```
public final class CustomExtension implements DynamoDbEnhancedClientExtension {
// 1. In a custom extension, use an UpdateExpression to define what action to take before
// an item is updated.
@Override
public WriteModification beforeWrite(DynamoDbExtensionContext.BeforeWrite context) {
if ( context.operationContext().tableName().equals("Customer")
&& context.operationName().equals(OperationName.UPDATE_ITEM)) {
return WriteModification.builder()
.updateExpression(createUpdateExpression())
.build();
}
return WriteModification.builder().build(); // Return an "empty" WriteModification instance if the extension should not be applied.
// In this case, if the code is not updating an item on the Customer table.
}
private static UpdateExpression createUpdateExpression() {
// 2. Use a SetAction, a subclass of UpdateAction, to provide the values in the update.
SetAction setAction =
SetAction.builder()
.path("registrationDate")
.value("if_not_exists(registrationDate, :regValue)")
.putExpressionValue(":regValue", AttributeValue.fromS(Instant.now().toString()))
.build();
// 3. Build the UpdateExpression with one or more UpdateAction.
return UpdateExpression.builder()
.addAction(setAction)
.build();
}
}
```
# Verwenden Sie die DynamoDB Enhanced Client API asynchron
Wenn Ihre Anwendung nicht blockierende, asynchrone Aufrufe von DynamoDB erfordert, können Sie den verwenden. [DynamoDbEnhancedAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbEnhancedAsyncClient.html) Sie ähnelt der synchronen Implementierung, weist jedoch die folgenden wesentlichen Unterschiede auf:
1. Wenn Sie den erstellen`DynamoDbEnhancedAsyncClient`, müssen Sie die asynchrone Version des Standardclients bereitstellen`DynamoDbAsyncClient`, wie im folgenden Codeausschnitt dargestellt.
```
DynamoDbEnhancedAsyncClient enhancedClient =
DynamoDbEnhancedAsyncClient.builder()
.dynamoDbClient(dynamoDbAsyncClient)
.build();
```
1. Methoden, die ein einzelnes Datenobjekt zurückgeben, geben nicht nur das Ergebnis zurück. `CompletableFuture` Ihre Anwendung kann dann andere Aufgaben ausführen, ohne das Ergebnis blockieren zu müssen. Der folgende Ausschnitt zeigt die asynchrone `getItem()` Methode.
```
CompletableFuture result = customerDynamoDbTable.getItem(customer);
// Perform other work here.
return result.join(); // Now block and wait for the result.
```
1. Methoden, die paginierte Ergebnislisten zurückgeben, geben [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/SdkPublisher.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/SdkPublisher.html)statt eines zurück [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/pagination/sync/SdkIterable.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/pagination/sync/SdkIterable.html), das die synchrone Methode für dieselben Methoden `DynamoDbEnhanceClient` zurückgibt. Ihre Anwendung kann dann einen Handler für diesen Herausgeber abonnieren, um die Ergebnisse asynchron zu verarbeiten, ohne sie blockieren zu müssen.
```
PagePublisher results = customerDynamoDbTable.query(r -> r.queryConditional(keyEqualTo(k -> k.partitionValue("Smith"))));
results.subscribe(myCustomerResultsProcessor);
// Perform other work and let the processor handle the results asynchronously.
```
Ein vollständigeres Beispiel für die Arbeit mit dem `SdkPublisher API` finden Sie in [dem Beispiel](ddb-en-client-use-multirecord.md#ddb-en-client-use-multirecord-scan-async) in dem Abschnitt, in dem die asynchrone `scan()` Methode beschrieben wird.
# Anmerkungen zu Datenklassen
In der folgenden Tabelle sind die Anmerkungen aufgeführt, die für Datenklassen verwendet werden können, und sie enthält Links zu Informationen und Beispielen in diesem Handbuch. Die Tabelle ist in aufsteigender alphabetischer Reihenfolge nach dem Namen der Anmerkung sortiert.
**Anmerkungen zur Datenklasse, die in diesem Handbuch verwendet werden**
| Name der Anmerkung | Anmerkung bezieht sich auf 1 | Was macht es | Wo es in diesem Handbuch gezeigt wird |
| --- | --- | --- | --- |
| DynamoDbAtomicCounter | Attribut 2 | Inkrementiert ein mit Tags versehenes numerisches Attribut jedes Mal, wenn ein Datensatz in die Datenbank geschrieben wird. | [Einführung und Diskussion.](ddb-en-client-extensions.md#ddb-en-client-extensions-ACE) |
| DynamoDbAttribute | Attribut | Definiert oder benennt eine Bean-Eigenschaft um, die einem DynamoDB-Tabellenattribut zugeordnet ist. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/ddb-en-client-anno-index.html) |
| DynamoDbAutoGeneratedTimestampAttribute | Attribut | Aktualisiert jedes Mal, wenn das Element erfolgreich in die Datenbank geschrieben wurde, ein mit einem Tag versehenes Attribut mit einem aktuellen Zeitstempel | [Einführung und Diskussion](ddb-en-client-extensions.md#ddb-en-client-extensions-AGTE). |
| DynamoDbAutoGeneratedUuid | Attribut | Generieren Sie eine eindeutige UUID (Universally Unique Identifier) für ein Attribut, wenn ein neuer Datensatz in die Datenbank geschrieben wird. | [Einführung und Diskussion.](ddb-en-client-extensions.md#ddb-en-client-extensions-AGUE) |
| DynamoDbBean | class | Markiert eine Datenklasse als einem Tabellenschema zuordbar. | Erste Anwendung in der [Kundenklasse](ddb-en-client-gs-tableschema.md#ddb-en-client-gs-tableschema-anno-bean-cust) im Abschnitt Erste Schritte. Im gesamten Handbuch werden verschiedene Verwendungen verwendet. |
| DynamoDbConvertedBy | Attribut | Ordnet dem annotierten AttributeConverter Attribut einen benutzerdefinierten Wert zu. | [Erste Diskussion und Beispiel.](ddb-en-client-adv-features-conversion.md#ddb-en-client-adv-features-conversion-single) |
| DynamoDbFlatten | Attribut | Reduziert alle Attribute einer separaten DynamoDB-Datenklasse und fügt sie dem Datensatz, der in die Datenbank gelesen und geschrieben wird, als Attribute der obersten Ebene hinzu. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/ddb-en-client-anno-index.html) |
| DynamoDbIgnore | Attribut | Führt dazu, dass das Attribut nicht zugeordnet wird. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/ddb-en-client-anno-index.html) |
| DynamoDbIgnoreNulls | Attribut | Verhindert das Speichern von Null-Attributen verschachtelter DynamoDb Objekte. | [Diskussion und Beispiele.](ddb-en-client-adv-features-ignore-null.md) |
| DynamoDbImmutable | class | Markiert eine unveränderliche Datenklasse als einem Tabellenschema zuordbar. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/ddb-en-client-anno-index.html) |
| DynamoDbPartitionKey | Attribut | Markiert ein Attribut als primären Partitionsschlüssel (Hash-Schlüssel) der DynamoDb Tabelle. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/ddb-en-client-anno-index.html) |
| DynamoDbPreserveEmptyObject | Attribut | Gibt an, dass das Objekt mit allen Nullfeldern initialisiert werden soll, wenn keine Daten für das Objekt vorhanden sind, das dem annotierten Attribut zugeordnet ist. | [Diskussion und Beispiele.](ddb-en-client-adv-features-empty.md) |
| DynamoDbSecondaryPartitionKey | Attribut | Markiert ein Attribut als Partitionsschlüssel für einen globalen sekundären Index. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/ddb-en-client-anno-index.html) |
| DynamoDbSecondarySortKey | Attribut | Markiert ein Attribut als optionalen Sortierschlüssel für einen globalen oder lokalen Sekundärindex. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/ddb-en-client-anno-index.html) |
| DynamoDbSortKey | Attribut | Markiert ein Attribut als optionalen primären Sortierschlüssel (Bereichsschlüssel). | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/ddb-en-client-anno-index.html) |
| DynamoDbUpdateBehavior | Attribut | Gibt das Verhalten an, wenn dieses Attribut im Rahmen eines Aktualisierungsvorgangs aktualisiert wird, UpdateItem z. | [Einführung und Beispiel.](ddb-en-client-adv-features-upd-behavior.md) |
| DynamoDbVersionAttribute | Attribut | Erhöht die Versionsnummer eines Artikels. | [Einführung und Diskussion.](ddb-en-client-extensions.md#ddb-en-client-extensions-VRE) |
1 Sie können Anmerkungen auf Attributebene auf Getter oder Setter anwenden, aber nicht auf beide. Diese Anleitung zeigt Anmerkungen zu Getter.
2 Der Begriff `property` wird normalerweise für einen Wert verwendet, der in einer Datenklasse gekapselt ist. JavaBean In diesem Handbuch wird der Begriff jedoch `attribute` stattdessen verwendet, um mit der von DynamoDB verwendeten Terminologie konsistent zu sein.