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.
# Überblick über die AWS SDK-Unterstützung für DynamoDB
Das folgende Diagramm bietet einen allgemeinen Überblick über die Amazon DynamoDB DynamoDB-Anwendungsprogrammierung mit dem. AWS SDKs
![\[Programmiermodell für die Verwendung von DynamoDB mit. AWS SDKs\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/SDKSupport.png)
1. Sie schreiben eine Anwendung mit einem AWS SDK für Ihre Programmiersprache.
1. Jedes AWS SDK bietet eine oder mehrere programmatische Schnittstellen für die Arbeit mit DynamoDB. Welche spezifischen Schnittstellen verfügbar sind, hängt davon ab, welche Programmiersprache und welches AWS SDK Sie verwenden. Zu den Optionen gehören:
+ [Low-Level-Schnittstellen, die mit DynamoDB funktionieren](Programming.SDKs.Interfaces.md#Programming.SDKs.Interfaces.LowLevel)
+ [Dokumentschnittstellen, die mit DynamoDB funktionieren](Programming.SDKs.Interfaces.md#Programming.SDKs.Interfaces.Document)
+ [Schnittstellen für Objektpersistenz, die mit DynamoDB funktionieren](Programming.SDKs.Interfaces.md#Programming.SDKs.Interfaces.Mapper)
+ [High-Level-Schnittstellen](HigherLevelInterfaces.md)
1. Das AWS SDK erstellt HTTP (S) -Anfragen zur Verwendung mit der Low-Level-DynamoDB-API.
1. Das AWS SDK sendet die Anfrage an den DynamoDB-Endpunkt.
1. DynamoDB führt die Anforderung aus. Wenn die Anforderung erfolgreich ist, gibt DynamoDB einen HTTP-200-Antwortcode zurück (OK). Wenn die Anforderung fehlschlägt, gibt DynamoDB einen HTTP-Fehlercode und eine Fehlermeldung zurück.
1. Das AWS SDK verarbeitet die Antwort und leitet sie zurück an Ihre Anwendung.
Jedes von ihnen AWS SDKs stellt wichtige Dienste für Ihre Anwendung bereit, darunter die folgenden:
+ Formatieren von HTTP(S)-Anforderungen und Serialisieren von Anforderungsparametern
+ Erstellen einer kryptografischen Signatur für jede Anforderung
+ Weiterleiten von Anforderungen an einen DynamoDB-Endpunkt und Empfangen von Antworten von DynamoDB.
+ Extrahieren der Ergebnisse dieser Antworten
+ Implementieren einer grundlegenden Retry-Logik im Falle von Fehlern
Sie müssen für keine dieser Aufgaben einen Code schreiben.
**Anmerkung**
Weitere Informationen AWS SDKs, einschließlich Installationsanweisungen und Dokumentation, finden Sie unter [Tools for Amazon Web Services](https://aws.amazon.com/tools).
## SDK-Unterstützung für AWS kontobasierte Endgeräte
AWS führt die SDK-Unterstützung für AWS-account-basierte Endpunkte für DynamoDB ein, beginnend mit dem AWS SDK for Java V1 am 4. September 2024. Diese neuen Endpunkte tragen dazu bei AWS , eine hohe Leistung und Skalierbarkeit sicherzustellen. Die aktualisierte SDKs Version verwendet automatisch die neuen Endpunkte, die das Format haben. `https://(account-id).ddb.(region).amazonaws.com`
Wenn Sie eine einzelne Instance eines SDK-Clients verwenden, um Anfragen an mehrere Konten zu stellen, hat Ihre Anwendung weniger Möglichkeiten, Verbindungen wiederzuverwenden. AWS empfiehlt, Ihre Anwendung so anzupassen, dass pro SDK-Client-Instance weniger Konten angesprochen werden. Eine Alternative besteht darin, Ihren SDK-Client mithilfe dieser `ACCOUNT_ID_ENDPOINT_MODE` Einstellung so einzurichten, dass er weiterhin regionale Endpunkte verwendet, wie im Referenzhandbuch [https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html) dokumentiert.
# Programmierschnittstellen, die mit DynamoDB funktionieren
Jedes [AWS SDK ](https://aws.amazon.com/tools) bietet eine oder mehrere programmgesteuerte Schnittstellen für die Arbeit mit Amazon DynamoDB. Diese Schnittstellen reichen von einfachen Low-Level-DynamoDB-Wrapper zu objektorientierten Persistenzschichten. Die verfügbaren Schnittstellen variieren je nach AWS SDK und verwendeter Programmiersprache.
![\[Programmatische Schnittstellen sind in verschiedenen Ausführungen AWS SDKs für die Arbeit mit DynamoDB verfügbar.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/SDKSupport.SDKInterfaces.png)
Der folgende Abschnitt hebt einige der verfügbaren Schnittstellen hervor und verwendet AWS SDK für Java als Beispiel. (Nicht alle Schnittstellen sind in allen verfügbar.) AWS SDKs
**Topics**
+ [
## Low-Level-Schnittstellen, die mit DynamoDB funktionieren
](#Programming.SDKs.Interfaces.LowLevel)
+ [
## Dokumentschnittstellen, die mit DynamoDB funktionieren
](#Programming.SDKs.Interfaces.Document)
+ [
## Schnittstellen für Objektpersistenz, die mit DynamoDB funktionieren
](#Programming.SDKs.Interfaces.Mapper)
## Low-Level-Schnittstellen, die mit DynamoDB funktionieren
Jedes sprachspezifische AWS SDK bietet eine Low-Level-Schnittstelle für Amazon DynamoDB mit Methoden, die DynamoDB-API-Anfragen auf niedriger Ebene sehr ähnlich sind.
In einigen Fällen müssen Sie die Datentypen der Attribute mithilfe von [Datentypbeschreibungen](Programming.LowLevelAPI.md#Programming.LowLevelAPI.DataTypeDescriptors) identifizieren, so wie `S` für Zeichenfolge und `N` für Zahl.
**Anmerkung**
Ein Low-Level-Schnittstelle ist in jeder sprachspezifischen AWS -SDK verfügbar.
Das folgende Java-Programm verwendet die Low-Level-Schnittstelle des AWS SDK für Java.
### Beispiel einer Low-Level-Schnittstelle
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* To get an item from an Amazon DynamoDB table using the AWS SDK for Java V2,
* its better practice to use the
* Enhanced Client, see the EnhancedGetItem example.
*/
public class GetItem {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table from which an item is retrieved (for example, Music3).\s
key - The key used in the Amazon DynamoDB table (for example, Artist).\s
keyval - The key value that represents the item to get (for example, Famous Band).
""";
if (args.length != 3) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
String keyVal = args[2];
System.out.format("Retrieving item \"%s\" from \"%s\"\n", keyVal, tableName);
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
getDynamoDBItem(ddb, tableName, key, keyVal);
ddb.close();
}
public static void getDynamoDBItem(DynamoDbClient ddb, String tableName, String key, String keyVal) {
HashMap keyToGet = new HashMap<>();
keyToGet.put(key, AttributeValue.builder()
.s(keyVal)
.build());
GetItemRequest request = GetItemRequest.builder()
.key(keyToGet)
.tableName(tableName)
.build();
try {
// If there is no matching item, GetItem does not return any data.
Map returnedItem = ddb.getItem(request).item();
if (returnedItem.isEmpty())
System.out.format("No item found with the key %s!\n", key);
else {
Set keys = returnedItem.keySet();
System.out.println("Amazon DynamoDB table attributes: \n");
for (String key1 : keys) {
System.out.format("%s: %s\n", key1, returnedItem.get(key1).toString());
}
}
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
```
## Dokumentschnittstellen, die mit DynamoDB funktionieren
Viele AWS SDKs bieten eine Dokumentschnittstelle, über die Sie Operationen auf Datenebene (Erstellen, Lesen, Aktualisieren, Löschen) für Tabellen und Indizes ausführen können. Mit einer Dokumentschnittstelle müssen Sie [Datentypbeschreibungen](Programming.LowLevelAPI.md#Programming.LowLevelAPI.DataTypeDescriptors) nicht angeben. Die Datentypen werden durch die Semantiken der Daten selber bereitgestellt. Diese bieten AWS SDKs auch Methoden zur einfachen Konvertierung von JSON-Dokumenten in und aus nativen Amazon DynamoDB DynamoDB-Datentypen.
**Anmerkung**
[Dokumentschnittstellen sind im AWS SDKs für [Java](https://aws.amazon.com/sdk-for-java), [.NET](https://aws.amazon.com/sdk-for-net), [Node.js](https://aws.amazon.com/sdk-for-node-js) und JavaScript SDK verfügbar.](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/)
Das folgende Java-Programm verwendet die Dokumentschnittstelle des AWS SDK für Java. Das Programm erstellt ein `Table`-Objekt, das die `Music`-Tabelle repräsentiert und fordert dieses Objekt auf, `GetItem` zu verwenden, um einen Song abzurufen. Das Programm gibt dann das Jahr aus, in dem der Song veröffentlicht wurde.
Die `software.amazon.dynamodb.document.DynamoDB`-Klasse implementiert die DynamoDB-Dokumentschnittstelle. Beachten Sie, wie `DynamoDB` als Wrapper um den Low-Level-Client agiert (`AmazonDynamoDB`).
### Beispiel für eine Dokumentschnittstelle
```
package com.amazonaws.codesamples.gsg;
import software.amazon.dynamodb.AmazonDynamoDB;
import software.amazon.dynamodb.AmazonDynamoDBClientBuilder;
import software.amazon.dynamodb.document.DynamoDB;
import software.amazon.dynamodb.document.GetItemOutcome;
import software.amazon.dynamodb.document.Table;
public class MusicDocumentDemo {
public static void main(String[] args) {
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB docClient = new DynamoDB(client);
Table table = docClient.getTable("Music");
GetItemOutcome outcome = table.getItemOutcome(
"Artist", "No One You Know",
"SongTitle", "Call Me Today");
int year = outcome.getItem().getInt("Year");
System.out.println("The song was released in " + year);
}
}
```
## Schnittstellen für Objektpersistenz, die mit DynamoDB funktionieren
Einige AWS SDKs bieten eine Schnittstelle zur Objektpersistenz, über die Sie keine direkten Operationen auf der Datenebene ausführen können. Stattdessen erstellen Sie Objekte, die Elemente in Amazon-DynamoDB-Tabellen und Indexe repräsentieren, und interagieren ausschließlich mit diesen Objekten. Auf diese Weise können Sie objektorientierte Codes statt datenbankorientierter Codes schreiben.
**Anmerkung**
Schnittstellen AWS SDKs für Objektpersistenz sind in Java und .NET verfügbar. Weitere Informationen finden Sie unter [Higher-Level-Programmierschnittstellen für DynamoDB](HigherLevelInterfaces.md) für DynamoDB.
### Beispiel einer Objektpersistenzschnittstelle
```
import com.example.dynamodb.Customer;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
import software.amazon.awssdk.enhanced.dynamodb.model.GetItemEnhancedRequest;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
```
```
import com.example.dynamodb.Customer;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
import software.amazon.awssdk.enhanced.dynamodb.model.GetItemEnhancedRequest;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
/*
* Before running this code example, create an Amazon DynamoDB table named Customer with these columns:
* - id - the id of the record that is the key. Be sure one of the id values is `id101`
* - custName - the customer name
* - email - the email value
* - registrationDate - an instant value when the item was added to the table. These values
* need to be in the form of `YYYY-MM-DDTHH:mm:ssZ`, such as 2022-07-11T00:00:00Z
*
* Also, ensure that you have set up your development environment, including your credentials.
*
* For information, see this documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class EnhancedGetItem {
public static void main(String[] args) {
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
getItem(enhancedClient);
ddb.close();
}
public static String getItem(DynamoDbEnhancedClient enhancedClient) {
Customer result = null;
try {
DynamoDbTable table = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
Key key = Key.builder()
.partitionValue("id101").sortValue("tred@noserver.com")
.build();
// Get the item by using the key.
result = table.getItem(
(GetItemEnhancedRequest.Builder requestBuilder) -> requestBuilder.key(key));
System.out.println("******* The description value is " + result.getCustName());
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
return result.getCustName();
}
}
```
# Higher-Level-Programmierschnittstellen für DynamoDB
AWS SDKs Sie bieten Anwendungen mit Low-Level-Schnittstellen für die Arbeit mit Amazon DynamoDB. Diese clientseitigen Klassen und Methoden entsprechen direkt der Low-Level-API von DynamoDB API. Doch viele Entwickler stellen *Impedanzfehlanpassungen* fest, wenn sie Elementen in einer Datenbanktabelle komplexe Datentypen zuordnen müssen. Mit einer Low-Level-Datenbankschnittstelle müssen Entwickler Methoden zum Lesen oder Schreiben von Objektdaten in Datenbanktabellen und umgekehrt entwickeln. Die Menge des zusätzlich erforderlichen Codes für jede Kombination aus Objekttyp und Datenbanktabelle kann überwältigend erscheinen.
Um die Entwicklung zu vereinfachen, bieten die AWS SDKs für Java und .NET zusätzliche Schnittstellen mit höheren Abstraktionsebenen. Mit den High-Level-Schnittstellen für DynamoDB-Objekte können Sie die Beziehungen zwischen Objekten in Ihrem Programm und den Datenbanktabellen definieren, die die Daten dieser Objekte speichern. Nachdem Sie diese Mappings definiert haben, rufen Sie einfache Objektmethoden wie `save`, `load` oder `delete` auf. Die zugrunde liegenden DynamoDB-Low-Level-Operationen werden dann in Ihrem Namen automatisch aufgerufen. Auf diese Weise können Sie objektorientierte Codes statt datenbankorientierter Codes schreiben.
Die übergeordneten Programmierschnittstellen für DynamoDB sind in den Versionen AWS SDKs für Java und .NET verfügbar.
**Java**
+ [Java 1.x: Dynamo DBMapper](DynamoDBMapper.md)
+ [Java 2.x: Erweiterter DynamoDB-Client](DynamoDBEnhanced.md)
**.NET**
+ [Arbeiten dem .NET-Dokumentmodell in DynamoDB](DotNetSDKMidLevel.md)
+ [Arbeiten mit dem Object Persistence-Modell von .NET und DynamoDB](DotNetSDKHighLevel.md)
# Java 1.x: Dynamo DBMapper
**Anmerkung**
Das SDK für Java ist in zwei Versionen verfügbar: 1.x und 2.x. Die Version end-of-support für 1.x wurde [am 12. Januar 2024 angekündigt](https://aws.amazon.com/blogs/developer/announcing-end-of-support-for-aws-sdk-for-java-v1-x-on-december-31-2025/). Es wird und end-of-support ist am 31. Dezember 2025 fällig. Für Neuentwicklungen wird die Verwendung von Version 2.x empfohlen.
Die AWS SDK für Java stellt eine `DynamoDBMapper` Klasse bereit, mit der Sie Ihre clientseitigen Klassen Amazon DynamoDB-Tabellen zuordnen können. Um `DynamoDBMapper` zu verwenden, definieren Sie die Beziehung zwischen Elementen in einer DynamoDB-Tabelle und ihren entsprechenden Objekt-Instances im Code. Die `DynamoDBMapper`-Klasse ermöglicht Ihnen auch die Ausführung verschiedener Create-, Read-, Update-, und Delete-Operationen (CRUD) für Elemente sowie das Ausführen von Abfragen und Scans für Tabellen.
**Topics**
+ [
# Dynamo-Klasse DBMapper
](DynamoDBMapper.Methods.md)
+ [
# Unterstützte Datentypen für Dynamo DBMapper für Java
](DynamoDBMapper.DataTypes.md)
+ [
# Java-Anmerkungen für DynamoDB
](DynamoDBMapper.Annotations.md)
+ [
# Optionale Konfigurationseinstellungen für Dynamo DBMapper
](DynamoDBMapper.OptionalConfig.md)
+ [
# DynamoDB und optimistische Sperren mit Versionsnummer
](DynamoDBMapper.OptimisticLocking.md)
+ [
# Zuordnen willkürlicher Daten in DynamoDB
](DynamoDBMapper.ArbitraryDataMapping.md)
+ [
# Beispiele für DynamoDBMapper
](DynamoDBMapper.Examples.md)
**Anmerkung**
Die `DynamoDBMapper`-Klasse erlaubt kein Erstellen, Aktualisieren oder Löschen von Tabellen. Zum Ausführen dieser Aufgaben verwenden Sie stattdessen die Low-Level-SDK-für-Java-Schnittstelle.
Das SDK für Java stellt eine Reihe von Anmerkungstypen bereit, damit Sie Ihre Klassen zu Tabellen zuweisen können. Betrachten Sie beispielsweise eine `ProductCatalog`-Tabelle, die `Id` als Partitionsschlüssel verwendet.
```
ProductCatalog(Id, ...)
```
Sie können der `ProductCatalog`-Tabelle eine Klasse in Ihrer Client-Anwendung zuweisen wie im folgenden Java-Code gezeigt. Diese Code definiert ein Plain Old Java Object (POJO) mit dem Namen `CatalogItem`, das Anmerkungen verwendet, um Objektfelder zu DynamoDB-Attributnamen zuzuweisen:
**Example**
```
package com.amazonaws.codesamples;
import java.util.Set;
import software.amazon.dynamodb.datamodeling.DynamoDBAttribute;
import software.amazon.dynamodb.datamodeling.DynamoDBHashKey;
import software.amazon.dynamodb.datamodeling.DynamoDBIgnore;
import software.amazon.dynamodb.datamodeling.DynamoDBTable;
@DynamoDBTable(tableName="ProductCatalog")
public class CatalogItem {
private Integer id;
private String title;
private String ISBN;
private Set bookAuthors;
private String someProp;
@DynamoDBHashKey(attributeName="Id")
public Integer getId() { return id; }
public void setId(Integer id) {this.id = id; }
@DynamoDBAttribute(attributeName="Title")
public String getTitle() {return title; }
public void setTitle(String title) { this.title = title; }
@DynamoDBAttribute(attributeName="ISBN")
public String getISBN() { return ISBN; }
public void setISBN(String ISBN) { this.ISBN = ISBN; }
@DynamoDBAttribute(attributeName="Authors")
public Set getBookAuthors() { return bookAuthors; }
public void setBookAuthors(Set bookAuthors) { this.bookAuthors = bookAuthors; }
@DynamoDBIgnore
public String getSomeProp() { return someProp; }
public void setSomeProp(String someProp) { this.someProp = someProp; }
}
```
Im vorherigen Code weist die Anmerkung `@DynamoDBTable` die Klasse `CatalogItem` der Tabelle `ProductCatalog` zu. Sie können einzelne Klassen-Instances als Elemente in der Tabelle speichern. Die Anmerkung `@DynamoDBHashKey` weist die Eigenschaft `Id` dem Primärschlüssel zu.
Standardmäßig sind die Klasseneigenschaften denselben Attributnamen in der Tabelle zugeordnet. Die Eigenschaften `Title` und `ISBN` sind den gleichen Attributnamen in der Tabelle zugeordnet.
Die `@DynamoDBAttribute`-Anmerkung ist optional, wenn der Name des DynamoDB-Attributs dem Namen der in der Klasse angegebenen Eigenschaft entspricht. Wenn sich die Namen unterscheiden, verwenden Sie diese Anmerkung mit dem Parameter `attributeName`, um anzugeben, mit welchem DynamoDB-Attribut diese Eigenschaft übereinstimmt.
Im vorangegangenen Beispiel wird jeder Eigenschaft die Annotation `@DynamoDBAttribute` hinzugefügt, um sicherzustellen, dass Eigenschaftsnamen genau den Tabellen entsprechen, die in einem vorherigen Schritt erstellt wurden und um die Attributnamen, die in anderen Codebeispielen in diesem Handbuch verwendet werden, einzuhalten.
Ihre Klassendefinition kann Eigenschaften besitzen, die keinen Attributen in der Tabelle zugeordnet sind. Sie erkennen diese Eigenschaften, indem Sie die `@DynamoDBIgnore`-Anmerkung hinzufügen. Im vorangegangenen Beispiel ist die `SomeProp`-Eigenschaft mit der `@DynamoDBIgnore`-Anmerkung gekennzeichnet. Wenn Sie eine `CatalogItem`-Instance in die Tabelle hochladen, enthält Ihre `DynamoDBMapper`-Instance die Eigenschaft `SomeProp` nicht. Darüber hinaus gibt der Mapper dieses Attribut nicht zurück, wenn Sie ein Element aus der Tabelle abrufen.
Nachdem Sie die Mappingklasse definierthaben, können Sie `DynamoDBMapper`-Methoden verwenden, um eine Instance dieser Klasse zu einem entsprechenden Element in der Tabelle `Catalog` zu schreiben. Das folgende Codebeispiel zeigt diese Technik.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDBMapper mapper = new DynamoDBMapper(client);
CatalogItem item = new CatalogItem();
item.setId(102);
item.setTitle("Book 102 Title");
item.setISBN("222-2222222222");
item.setBookAuthors(new HashSet(Arrays.asList("Author 1", "Author 2")));
item.setSomeProp("Test");
mapper.save(item);
```
Im folgenden Codebeispiel wird gezeigt, wie Sie das Element abrufen und auf einige seiner Attribute zugreifen.
```
CatalogItem partitionKey = new CatalogItem();
partitionKey.setId(102);
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withHashKeyValues(partitionKey);
List itemList = mapper.query(CatalogItem.class, queryExpression);
for (int i = 0; i < itemList.size(); i++) {
System.out.println(itemList.get(i).getTitle());
System.out.println(itemList.get(i).getBookAuthors());
}
```
`DynamoDBMapper` ermöglicht ein intuitives und natürliches Arbeiten mit DynamoDB-Daten in Java. Er bietet auch verschiedene integrierte Funktionen wie optimistische Sperre, ACID-Transaktionen, automatisch generierte Partitions- und Sortierschlüsselwerte sowie Objektversionierung.
# Dynamo-Klasse DBMapper
Die Klasse A`DynamoDBMapper` ist der Eintrittspunkt für Amazon DynamoDB. Sie stellt Zugriff auf einen DynamoDB-Endpunkt bereit und ermöglicht Ihnen, auf Ihre Daten in verschiedenen Tabellen zuzugreifen. Sie ermöglicht Ihnen auch die Ausführung verschiedener Create-, Read-, Update-, und Delete-Operationen (CRUD) für Elemente sowie das Ausführen von Abfragen und Scans auf Tabellen. Diese Klasse bietet die folgenden Methoden für die Arbeit mit DynamoDB.
*Die entsprechende Javadoc-Dokumentation finden Sie unter [Dynamo DBMapper](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) in der API-Referenz.AWS SDK für Java *
**Topics**
+ [
## save
](#DynamoDBMapper.Methods.save)
+ [
## load
](#DynamoDBMapper.Methods.load)
+ [
## delete
](#DynamoDBMapper.Methods.delete)
+ [
## query
](#DynamoDBMapper.Methods.query)
+ [
## queryPage
](#DynamoDBMapper.Methods.queryPage)
+ [
## scan
](#DynamoDBMapper.Methods.scan)
+ [
## scanPage
](#DynamoDBMapper.Methods.scanPage)
+ [
## parallelScan
](#DynamoDBMapper.Methods.parallelScan)
+ [
## batchSave
](#DynamoDBMapper.Methods.batchSave)
+ [
## batchLoad
](#DynamoDBMapper.Methods.batchLoad)
+ [
## batchDelete
](#DynamoDBMapper.Methods.batchDelete)
+ [
## batchWrite
](#DynamoDBMapper.Methods.batchWrite)
+ [
## transactionWrite
](#DynamoDBMapper.Methods.transactionWrite)
+ [
## transactionLoad
](#DynamoDBMapper.Methods.transactionLoad)
+ [
## count
](#DynamoDBMapper.Methods.count)
+ [
## generateCreateTableAnfrage
](#DynamoDBMapper.Methods.generateCreateTableRequest)
+ [
## createS3Link
](#DynamoDBMapper.Methods.createS3Link)
+ [
## GetS3 ClientCache
](#DynamoDBMapper.Methods.getS3ClientCache)
## save
Speichert das angegebene Objekt in der Tabelle. Das Objekt, das Sie speichern möchten, ist der einzige erforderliche Parameter für diese Methode. Sie können optionale Konfigurationsparameter mithilfe des `DynamoDBMapperConfig`-Objekts bereitstellen.
Wenn ein Element mit demselben Primärschlüssel nicht vorhanden ist, erstellt diese Methode ein neues Element in der Tabelle. Wenn ein Element mit demselben Primärschlüssel vorhanden ist, aktualisiert sie das vorhandene Element. Wenn der Partitions- und Sortierschlüssel den Typ String haben und mit `@DynamoDBAutoGeneratedKey` angemerkt sind, erhalten sie einen Random Universally Unique Identifier (UUID), wenn sie nicht initialisiert werden. Versionsfelder, die mit `@DynamoDBVersionAttribute` angemerkt sind, werden um eins erhöht. Wenn ein Versionsfeld aktualisiert oder ein Schlüssel generiert wird, wird das übergebene Objekt als Folge der Operation aktualisiert.
Standardmäßig werden nur Attribute aktualisiert, die Eigenschaften der zugewiesenen Klasse entsprechen. Zusätzlich für ein Element vorhandene Attribute sind nicht betroffen. Wenn Sie jedoch `SaveBehavior.CLOBBER` angeben, können Sie die vollständige Überschreibung des Elements erzwingen.
```
DynamoDBMapperConfig config = DynamoDBMapperConfig.builder()
.withSaveBehavior(DynamoDBMapperConfig.SaveBehavior.CLOBBER).build();
mapper.save(item, config);
```
Wenn Versioning aktiviert ist, müssen die client- und serverseitigen Elementversionen übereinstimmen. Jedoch muss die Version nicht übereinstimmen, wenn die Option `SaveBehavior.CLOBBER` verwendet wird. Weitere Informationen über das Versioning finden Sie unter [DynamoDB und optimistische Sperren mit Versionsnummer](DynamoDBMapper.OptimisticLocking.md).
## load
Ruft ein Element aus einer Tabelle ab. Sie müssen den Primärschlüssel des Elements bereitstellen, das Sie abrufen möchten. Sie können optionale Konfigurationsparameter mithilfe des `DynamoDBMapperConfig`-Objekts bereitstellen. Beispielsweise können Sie optional Strongly Consistent-Lesevorgänge anfordern, um sicherzustellen, dass diese Methode ausschließlich die neuesten Elementwerte, wie in der folgenden Java-Anweisung dargestellt, bereitstellt.
```
DynamoDBMapperConfig config = DynamoDBMapperConfig.builder()
.withConsistentReads(DynamoDBMapperConfig.ConsistentReads.CONSISTENT).build();
CatalogItem item = mapper.load(CatalogItem.class, item.getId(), config);
```
Standardmäßig gibt DynamoDB das Element zurück, das über Eventually-Consistent-Werte verfügt. Weitere Informationen über das Eventual-Consistency-Modell von DynamoDB finden Sie unter [DynamoDB-Lesekonsistenz](HowItWorks.ReadConsistency.md).
## delete
Löscht ein Element aus der Tabelle. Sie müssen eine Objekt-Instance aus der zugeordneten Klasse übergeben.
Wenn Versioning aktiviert ist, müssen die client- und serverseitigen Elementversionen übereinstimmen. Jedoch muss die Version nicht übereinstimmen, wenn die Option `SaveBehavior.CLOBBER` verwendet wird. Weitere Informationen zum Versioning finden Sie unter [DynamoDB und optimistische Sperren mit Versionsnummer](DynamoDBMapper.OptimisticLocking.md).
## query
Fragt eine Tabelle oder einen sekundären Index ab.
Angenommen, Sie verfügen über die Tabelle `Reply`, die Antworten für Forum-Threads speichert. Jedes Thread-Thema kann null oder mehr Antworten enthalten. Der Primärschlüssel der Tabelle `Reply` besteht aus den Feldern `Id` und `ReplyDateTime`, wobei `Id` der Partitionsschlüssel und `ReplyDateTime` der Sortierschlüssel des Primärschlüssels ist.
```
Reply ( Id, ReplyDateTime, ... )
```
Angenommen, Sie haben eine Mapping zwischen der Klasse `Reply` und der entsprechenden Tabelle `Reply` in DynamoDB erstellt. Der folgende Java-Code verwendet `DynamoDBMapper`, um alle Antworten der letzten zwei Wochen zu einem bestimmten Thread-Thema zu finden.
**Example**
```
String forumName = "&DDB;";
String forumSubject = "&DDB; Thread 1";
String partitionKey = forumName + "#" + forumSubject;
long twoWeeksAgoMilli = (new Date()).getTime() - (14L*24L*60L*60L*1000L);
Date twoWeeksAgo = new Date();
twoWeeksAgo.setTime(twoWeeksAgoMilli);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
String twoWeeksAgoStr = df.format(twoWeeksAgo);
Map eav = new HashMap();
eav.put(":v1", new AttributeValue().withS(partitionKey));
eav.put(":v2",new AttributeValue().withS(twoWeeksAgoStr.toString()));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withKeyConditionExpression("Id = :v1 and ReplyDateTime > :v2")
.withExpressionAttributeValues(eav);
List latestReplies = mapper.query(Reply.class, queryExpression);
```
Die Abfrage gibt eine Sammlung von `Reply`-Objekten zurück.
Die `query`-Methode gibt standardmäßig eine "lazy-loaded"-Sammlung zurück. Sie gibt anfänglich ausschließlich eine Ergebnisseite zurück und führt dann bei Bedarf einen Dienstaufruf für die nächste Seite durch. Um alle übereinstimmenden Elemente zu erhalten, müssen Sie die Sammlung `latestReplies` durchlaufen.
Beachten Sie, dass beim Aufrufen der `size()`-Methode für die Sammlung jedes Ergebnis geladen wird, um eine genaue Zählung zu liefern. Dies kann dazu führen, dass viel bereitgestellter Durchsatz verbraucht wird, und bei einer sehr großen Tabelle könnte sogar der gesamte Speicher in Ihrer JVM ausgeschöpft werden.
Für eine Indexabfrage müssen Sie zuerst den Index als eine Mapper-Klasse modellieren. *Angenommen, die `Reply` Tabelle hat einen globalen sekundären Index namens -Message-Index. PostedBy* Der Partitionsschlüssel für diesen Index ist `PostedBy` und der Sortierschlüssel ist `Message`. Die Klassendefinition für ein Element im Index würde wie folgt aussehen.
```
@DynamoDBTable(tableName="Reply")
public class PostedByMessage {
private String postedBy;
private String message;
@DynamoDBIndexHashKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "PostedBy")
public String getPostedBy() { return postedBy; }
public void setPostedBy(String postedBy) { this.postedBy = postedBy; }
@DynamoDBIndexRangeKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "Message")
public String getMessage() { return message; }
public void setMessage(String message) { this.message = message; }
// Additional properties go here.
}
```
Die Anmerkung `@DynamoDBTable` gibt an, dass dieser Index mit der Tabelle `Reply` verknüpft ist. Die `@DynamoDBIndexHashKey` Anmerkung bezeichnet den Partitionsschlüssel (*PostedBy*) des Indexes und `@DynamoDBIndexRangeKey` den Sortierschlüssel (*Message*) des Indexes.
Sie können jetzt `DynamoDBMapper` nutzen, um den Index abzufragen, der eine Teilmenge der Nachrichten, die von einem bestimmten Benutzer gepostet wurden, abruft. Sie müssen den Indexnamen nicht angeben, wenn Sie keine widersprüchlichen Zuordnungen zwischen Tabellen und Indizes haben und die Zuordnungen bereits im Mapper vorgenommen wurden. Der Mapper leitet anhand des Primärschlüssels und des Sortierschlüssels ab. Der folgende Code fragt den globalen sekundären Index ab. Da globale sekundäre Indizes Eventually Consistent-Lesevorgänge, jedoch keine Strongly Consistent-Lesevorgänge unterstützen, müssen Sie `withConsistentRead(false)` angeben.
```
HashMap eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("User A"));
eav.put(":v2", new AttributeValue().withS("DynamoDB"));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false)
.withKeyConditionExpression("PostedBy = :v1 and begins_with(Message, :v2)")
.withExpressionAttributeValues(eav);
List iList = mapper.query(PostedByMessage.class, queryExpression);
```
Die Abfrage gibt eine Sammlung von `PostedByMessage`-Objekten zurück.
## queryPage
Fragt eine Tabelle oder einen sekundären Index ab und gibt eine einzelne Seite der übereinstimmenden Ergebnisse zurück. Ebenso wie bei der `query`-Methode, müssen Sie einen Partitions-Schlüsselwert und einen Abfragefilter angeben, der auf das Sortierschlüsselattribut angewendet wird. `queryPage` gibt jedoch ausschließlich die erste „Seite“ der Daten zurück, d. h. Menge von Daten, die in 1 MB passt.
## scan
Scannt eine gesamte Tabelle oder einen sekundären Index. Sie können optional einen `FilterExpression` angeben, um den Ergebnissatz zu filtern.
Angenommen, Sie verfügen über die Tabelle `Reply`, die Antworten für Forum-Threads speichert. Jedes Thread-Thema kann null oder mehr Antworten enthalten. Der Primärschlüssel der Tabelle `Reply` besteht aus den Feldern `Id` und `ReplyDateTime`, wobei `Id` der Partitionsschlüssel und `ReplyDateTime` der Sortierschlüssel des Primärschlüssels ist.
```
Reply ( Id, ReplyDateTime, ... )
```
Wenn Sie der Tabelle `Reply` eine Java-Klasse zugewiesen haben, können Sie `DynamoDBMapper` verwenden, um die Tabelle zu scannen. Der folgende Java-Code scannt beispielsweise die gesamte Tabelle `Reply` und gibt nur die Antworten für ein bestimmtes Jahr zurück.
**Example**
```
HashMap eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("2015"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("begins_with(ReplyDateTime,:v1)")
.withExpressionAttributeValues(eav);
List replies = mapper.scan(Reply.class, scanExpression);
```
Die `scan`-Methode gibt standardmäßig eine "lazy-loaded"-Sammlung zurück. Sie gibt anfänglich ausschließlich eine Ergebnisseite zurück und führt dann bei Bedarf einen Dienstaufruf für die nächste Seite durch. Um alle übereinstimmenden Elemente zu erhalten, müssen Sie die Sammlung `replies` durchlaufen.
Beachten Sie, dass beim Aufrufen der `size()`-Methode für die Sammlung jedes Ergebnis geladen wird, um eine genaue Zählung zu liefern. Dies kann dazu führen, dass viel bereitgestellter Durchsatz verbraucht wird, und bei einer sehr großen Tabelle könnte sogar der gesamte Speicher in Ihrer JVM ausgeschöpft werden.
Um einen Index zu scannen, müssen Sie zuerst den Index als eine Mapper-Klasse modellieren. Angenommen, die `Reply`-Tabelle hat einen globalen sekundären Index namens `PostedBy-Message-Index`. Der Partitionsschlüssel für diesen Index ist `PostedBy` und der Sortierschlüssel ist `Message`. Im Abschnitt [query](#DynamoDBMapper.Methods.query) wird eine Mapper-Klasse für diesen Index gezeigt. Sie verwendet die Anmerkungen `@DynamoDBIndexHashKey` und `@DynamoDBIndexRangeKey`, um den Partitions- und Sortierschlüssel des Index anzugeben.
Im folgenden Codebeispiel wird `PostedBy-Message-Index` gescannt. Er verwendet keinen Scan-Filter, sodass alle Elemente im Index an Sie zurückgegeben werden.
```
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false);
List iList = mapper.scan(PostedByMessage.class, scanExpression);
Iterator indexItems = iList.iterator();
```
## scanPage
Scannt eine Tabelle oder einen sekundären Index und gibt eine einzelne Seite der übereinstimmenden Ergebnisse zurück. Ebenso wie bei der `scan`-Methode, können Sie optional einen `FilterExpression` festlegen, um den Ergebnissatz zu filtern. `scanPage` gibt jedoch nur die erste „Seite“ der Daten zurück, d. h. Menge von Daten, die in 1 MB passt.
## parallelScan
Führt einen parallelen Scan einer gesamten Tabelle oder einem sekundären Index durch. Sie geben eine Reihe von logischen Segmente für die Tabelle zusammen mit einem Scan-Ausdruck an, um Ergebnisse zu filtern. Der `parallelScan` teilt die Scan-Aufgabe unter mehreren Benutzern auf, einer für jedes logische Segment; die Benutzer verarbeiten die Daten parallel und geben die Ergebnisse zurück.
Im folgenden Java-Codebeispiel wird ein paralleler Scan der Tabelle `Product` ausgeführt.
```
int numberOfThreads = 4;
Map eav = new HashMap();
eav.put(":n", new AttributeValue().withN("100"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("Price <= :n")
.withExpressionAttributeValues(eav);
List scanResult = mapper.parallelScan(Product.class, scanExpression, numberOfThreads);
```
## batchSave
Speichert Objekte in eine oder mehrere Tabellen mithilfe eines Aufrufs oder mehrerer Aufrufe der Methode `AmazonDynamoDB.batchWriteItem`. Diese Methode bietet keine Transaktionsgarantien.
Der folgende Java-Code speichert zwei Elemente (Bücher) in der Tabelle `ProductCatalog`.
```
Book book1 = new Book();
book1.setId(901);
book1.setProductCategory("Book");
book1.setTitle("Book 901 Title");
Book book2 = new Book();
book2.setId(902);
book2.setProductCategory("Book");
book2.setTitle("Book 902 Title");
mapper.batchSave(Arrays.asList(book1, book2));
```
## batchLoad
Ruft mehrere Elemente aus einer oder mehreren Tabellen anhand ihrer Primärschlüssel ab.
Der folgende Java-Code ruft zwei Elemente aus zwei verschiedenen Tabellen ab.
```
ArrayList