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.
# Erste Schritte mit der DynamoDB Enhanced Client API
Das folgende Tutorial führt Sie in die Grundlagen ein, die Sie für die Arbeit mit der DynamoDB Enhanced Client API benötigen.
## Fügen Sie Abhängigkeiten hinzu
Um mit der Arbeit mit der DynamoDB Enhanced Client API in Ihrem Projekt zu beginnen, fügen Sie eine Abhängigkeit vom `dynamodb-enhanced` Maven-Artefakt hinzu. Dies wird in den folgenden Beispielen veranschaulicht.
------
#### [ Maven ]
```
software.amazon.awssdk
bom
pom
import
software.amazon.awssdk
dynamodb-enhanced
...
```
Suchen Sie im zentralen Maven-Repository nach der [neuesten Version](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) und ** ersetzen Sie sie durch diesen Wert.
------
#### [ Gradle ]
```
repositories {
mavenCentral()
}
dependencies {
implementation(platform("software.amazon.awssdk:bom:"))
implementation("software.amazon.awssdk:dynamodb-enhanced")
...
}
```
Suchen Sie im zentralen Maven-Repository nach der [neuesten Version](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) und ** ersetzen Sie sie durch diesen Wert.
------
# Generieren Sie `TableSchema` aus einer Datenklasse eine
A `[TableSchema](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/TableSchema.html)` ermöglicht es dem erweiterten Client, DynamoDB-Attributwerte Ihren clientseitigen Klassen zuzuordnen. In diesem Tutorial erfahren Sie mehr über `TableSchema` s, die von einer statischen Datenklasse abgeleitet und mithilfe eines Builders aus Code generiert wurden.
## Verwenden Sie eine Datenklasse mit Anmerkungen
Das SDK for Java 2.x enthält eine [Reihe von Anmerkungen](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.html), die Sie mit einer Datenklasse verwenden können, um schnell eine `TableSchema` für die Zuordnung Ihrer Klassen zu Tabellen zu generieren.
[Erstellen Sie zunächst eine Datenklasse, die der Spezifikation entspricht. JavaBean ](https://download.oracle.com/otn-pub/jcp/7224-javabeans-1.01-fr-spec-oth-JSpec/beans.101.pdf) Die Spezifikation erfordert, dass eine Klasse einen öffentlichen Konstruktor ohne Argumente und Getter und Setter für jedes Attribut in der Klasse hat. Fügen Sie eine Anmerkung auf Klassenebene hinzu, um anzugeben, dass es sich bei der Datenklasse um eine handelt. `DynamoDbBean` Fügen Sie außerdem mindestens eine `DynamoDbPartitionKey` Anmerkung zum Getter- oder Setter-Wert für das Primärschlüsselattribut hinzu.
Sie können [Anmerkungen auf Attributebene auf](ddb-en-client-anno-index.md) Getter oder Setter anwenden, aber nicht auf beide.
**Anmerkung**
Der Begriff `property` wird normalerweise für einen Wert verwendet, der in a gekapselt ist. JavaBean In diesem Handbuch wird der Begriff jedoch `attribute` stattdessen verwendet, um mit der von DynamoDB verwendeten Terminologie konsistent zu sein.
Die folgende `Customer` Klasse zeigt Anmerkungen, die die Klassendefinition mit einer DynamoDB-Tabelle verknüpfen.
### `Customer`-Klasse
```
package org.example.tests.model;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey;
import java.time.Instant;
@DynamoDbBean
public class Customer {
private String id;
private String name;
private String email;
private Instant regDate;
@DynamoDbPartitionKey
public String getId() { return this.id; }
public void setId(String id) { this.id = id; }
public String getCustName() { return this.name; }
public void setCustName(String name) { this.name = name; }
@DynamoDbSortKey
public String getEmail() { return this.email; }
public void setEmail(String email) { this.email = email; }
public Instant getRegistrationDate() { return this.regDate; }
public void setRegistrationDate(Instant registrationDate) { this.regDate = registrationDate; }
@Override
public String toString() {
return "Customer [id=" + id + ", name=" + name + ", email=" + email
+ ", regDate=" + regDate + "]";
}
}
```
Nachdem Sie eine annotierte Datenklasse erstellt haben, verwenden Sie sie, um die zu erstellen`TableSchema`, wie im folgenden Codeausschnitt gezeigt.
```
static final TableSchema customerTableSchema = TableSchema.fromBean(Customer.class);
```
A `TableSchema` ist so konzipiert, dass es statisch und unveränderlich ist. Sie können es normalerweise beim Laden der Klasse instanziieren.
Die statische `TableSchema.fromBean()` Factory-Methode untersucht die Bean, um die Zuordnung von Datenklassenattributen (Eigenschaften) zu und von DynamoDB-Attributen zu generieren.
Ein Beispiel für die Arbeit mit einem Datenmodell, das aus mehreren Datenklassen besteht, finden Sie in der `Person` Klasse im Abschnitt. [Arbeiten Sie mit Attributen wie Beans, Maps, Listen und Sets](ddb-en-client-adv-features-nested.md)
## Verwenden Sie einen Builder
Sie können die Kosten für die Bean-Introspektion überspringen, wenn Sie das Tabellenschema im Code definieren. Wenn Sie das Schema codieren, muss Ihre Klasse weder den JavaBean Benennungsstandards entsprechen noch muss sie mit Anmerkungen versehen werden. Das folgende Beispiel verwendet einen Builder und entspricht dem `Customer` Klassenbeispiel, das Anmerkungen verwendet.
```
static final TableSchema customerTableSchema =
TableSchema.builder(Customer.class)
.newItemSupplier(Customer::new)
.addAttribute(String.class, a -> a.name("id")
.getter(Customer::getId)
.setter(Customer::setId)
.tags(StaticAttributeTags.primaryPartitionKey()))
.addAttribute(String.class, a -> a.name("email")
.getter(Customer::getEmail)
.setter(Customer::setEmail)
.tags(StaticAttributeTags.primarySortKey()))
.addAttribute(String.class, a -> a.name("name")
.getter(Customer::getCustName)
.setter(Customer::setCustName))
.addAttribute(Instant.class, a -> a.name("registrationDate")
.getter(Customer::getRegistrationDate)
.setter(Customer::setRegistrationDate))
.build();
```
# Erstellen Sie einen erweiterten Client und `DynamoDbTable`
## Erstellen Sie einen erweiterten Client
Die [DynamoDbEnhancedClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbEnhancedClient.html)Klasse oder ihr asynchrones Gegenstück, [DynamoDbEnhancedAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbEnhancedAsyncClient.html), ist der Einstiegspunkt für die Arbeit mit der DynamoDB Enhanced Client API.
Der erweiterte Client benötigt einen Standard, um die Arbeit ausführen `[DynamoDbClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/dynamodb/DynamoDbClient.html)` zu können. Die API bietet zwei Möglichkeiten, eine `DynamoDbEnhancedClient` Instanz zu erstellen. Die erste Option, die im folgenden Ausschnitt gezeigt wird, erstellt einen Standard `DynamoDbClient` mit Standardeinstellungen, die aus den Konfigurationseinstellungen übernommen wurden.
```
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.create();
```
Wenn Sie den zugrunde liegenden Standardclient konfigurieren möchten, können Sie ihn der Builder-Methode des erweiterten Clients zur Verfügung stellen, wie im folgenden Codeausschnitt gezeigt.
```
// Configure an instance of the standard DynamoDbClient.
DynamoDbClient standardClient = DynamoDbClient.builder()
.region(Region.US_EAST_1)
.credentialsProvider(ProfileCredentialsProvider.create())
.build();
// Use the configured standard client with the enhanced client.
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(standardClient)
.build();
```
## Erstellen einer `DynamoDbTable`-Instance
Stellen Sie sich a [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbTable.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbTable.html)als die clientseitige Darstellung einer DynamoDB-Tabelle vor, die die von a bereitgestellte Zuordnungsfunktion verwendet. `TableSchema` Die `DynamoDbTable` Klasse stellt Methoden für CRUD-Operationen bereit, mit denen Sie mit einer einzelnen DynamoDB-Tabelle interagieren können.
`DynamoDbTable`ist eine generische Klasse, die ein einzelnes Typargument akzeptiert, unabhängig davon, ob es sich um eine benutzerdefinierte Klasse handelt oder um eine, `EnhancedDocument` wenn mit dokumentartigen Elementen gearbeitet wird. Dieser Argumenttyp stellt die Beziehung zwischen der Klasse, die Sie verwenden, und der einzelnen DynamoDB-Tabelle her.
Verwenden Sie die `table()` Factory-Methode von`DynamoDbEnhancedClient`, um eine `DynamoDbTable` Instanz zu erstellen, wie im folgenden Codeausschnitt gezeigt.
```
static final DynamoDbTable customerTable =
enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
```
`DynamoDbTable`Instanzen sind Kandidaten für Singletons, da sie unveränderlich sind und in Ihrer gesamten Anwendung verwendet werden können.
Ihr Code hat jetzt eine speicherinterne Darstellung einer DynamoDB-Tabelle, die mit Instanzen arbeiten kann. `Customer` Die tatsächliche DynamoDB-Tabelle ist möglicherweise vorhanden oder nicht. Wenn die angegebene Tabelle `Customer` bereits existiert, können Sie damit beginnen, CRUD-Operationen an ihr durchzuführen. Wenn sie nicht existiert, verwenden Sie die `DynamoDbTable` Instanz, um die Tabelle zu erstellen, wie im nächsten Abschnitt beschrieben.
# Erstellen Sie bei Bedarf eine DynamoDB-Tabelle
Nachdem Sie eine `DynamoDbTable` Instanz erstellt haben, verwenden Sie sie, um eine *einmalige* Erstellung einer Tabelle in DynamoDB durchzuführen.
## Beispielcode für Tabelle erstellen
Im folgenden Beispiel wird eine DynamoDB-Tabelle erstellt, die auf der `Customer` Datenklasse basiert.
In diesem Beispiel wird eine DynamoDB-Tabelle mit dem Namen erstellt, der mit dem Klassennamen `Customer` identisch ist, aber der Tabellenname kann auch ein anderer sein. Wie auch immer Sie die Tabelle benennen, Sie müssen diesen Namen in weiteren Anwendungen verwenden, um mit der Tabelle arbeiten zu können. Geben Sie der `table()` Methode diesen Namen jedes Mal, wenn Sie ein anderes `DynamoDbTable` Objekt erstellen, um mit der zugrunde liegenden DynamoDB-Tabelle zu arbeiten.
Mit dem an die `createTable` Methode übergebenen Java-Lambda-Parameter können Sie die Tabelle [anpassen](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/CreateTableEnhancedRequest.Builder.html). `builder` In diesem Beispiel wird der [bereitgestellte Durchsatz konfiguriert](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.ProvisionedThroughput.Manual). Wenn Sie beim Erstellen einer Tabelle die Standardeinstellungen verwenden möchten, überspringen Sie den Builder, wie im folgenden Codeausschnitt gezeigt.
```
customerTable.createTable();
```
Wenn Standardeinstellungen verwendet werden, werden keine Werte für den bereitgestellten Durchsatz festgelegt. Stattdessen ist der Abrechnungsmodus für die Tabelle auf [On-Demand-Modus](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.OnDemand) eingestellt.
In dem Beispiel wird auch ein verwendet, `[DynamoDbWaiter](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/dynamodb/waiters/DynamoDbWaiter.html)` bevor versucht wird, den in der Antwort erhaltenen Tabellennamen auszudrucken. Die Erstellung einer Tabelle dauert einige Zeit. Wenn Sie also einen Kellner verwenden, müssen Sie keine Logik schreiben, die den DynamoDB-Dienst abfragt, um festzustellen, ob die Tabelle existiert, bevor Sie die Tabelle verwenden.
### Importe
```
import com.example.dynamodb.Customer;
import software.amazon.awssdk.core.internal.waiters.ResponseOrException;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
import software.amazon.awssdk.enhanced.dynamodb.model.CreateTableEnhancedRequest;
import software.amazon.awssdk.services.dynamodb.model.DescribeTableResponse;
import software.amazon.awssdk.services.dynamodb.waiters.DynamoDbWaiter;
```
### Code
```
public static void createCustomerTable(DynamoDbTable customerTable, DynamoDbClient standardClient) {
// Create the DynamoDB table using the 'customerTable' DynamoDbTable instance.
customerTable.createTable(builder -> builder
.provisionedThroughput(b -> b
.readCapacityUnits(10L)
.writeCapacityUnits(10L)
.build())
);
// The DynamoDbClient instance (named 'standardClient') passed to the builder for the DynamoDbWaiter is the same instance
// that was passed to the builder of the DynamoDbEnhancedClient instance that we created previously.
// By using the same instance, it ensures that the same Region that was configured on the standard DynamoDbClient
// instance is used for other service clients that accept a DynamoDbClient during construction.
try (DynamoDbWaiter waiter = DynamoDbWaiter.builder().client(standardClient).build()) { // DynamoDbWaiter is Autocloseable
ResponseOrException response = waiter
.waitUntilTableExists(builder -> builder.tableName("Customer").build())
.matched();
DescribeTableResponse tableDescription = response.response().orElseThrow(
() -> new RuntimeException("Customer table was not created."));
// The actual error can be inspected in response.exception()
logger.info("Customer table was created.");
}
}
```
**Anmerkung**
Die Attributnamen einer DynamoDB-Tabelle beginnen mit einem Kleinbuchstaben, wenn die Tabelle aus einer Datenklasse generiert wird. Wenn der Attributname der Tabelle mit einem Großbuchstaben beginnen soll, verwenden Sie die [`@DynamoDbAttribute(NAME)`Anmerkung](ddb-en-client-adv-features-inex-attr.md) und geben Sie den gewünschten Namen als Parameter an.
# Führen Sie Operationen aus
Nachdem die Tabelle erstellt wurde, verwenden Sie die `DynamoDbTable` Instanz, um Operationen mit der DynamoDB-Tabelle durchzuführen.
Im folgenden Beispiel `DynamoDbTable` wird ein Singleton als Parameter zusammen mit einer [`Customer`Datenklasseninstanz](ddb-en-client-gs-tableschema.md#ddb-en-client-gs-tableschema-anno-bean-cust) übergeben, um der Tabelle ein neues Element hinzuzufügen.
```
public static void putItemExample(DynamoDbTable customerTable, Customer customer){
logger.info(customer.toString());
customerTable.putItem(customer);
}
```
## `Customer`-Objekt
```
Customer customer = new Customer();
customer.setId("1");
customer.setCustName("Customer Name");
customer.setEmail("customer@example.com");
customer.setRegistrationDate(Instant.parse("2023-07-03T10:15:30.00Z"));
```
Bevor Sie das `customer` Objekt an den DynamoDB-Dienst senden, protokollieren Sie die Ausgabe der `toString()` Methode des Objekts, um sie mit dem zu vergleichen, was der erweiterte Client sendet.
```
Customer [id=1, name=Customer Name, email=customer@example.com, regDate=2023-07-03T10:15:30Z]
```
Die Protokollierung auf Wireebene zeigt die Nutzlast der generierten Anfrage. Der erweiterte Client generierte die Low-Level-Darstellung anhand der Datenklasse. Das `regDate` Attribut, ein `Instant` Typ in Java, wird als DynamoDB-Zeichenfolge dargestellt.
```
{
"TableName": "Customer",
"Item": {
"registrationDate": {
"S": "2023-07-03T10:15:30Z"
},
"id": {
"S": "1"
},
"custName": {
"S": "Customer Name"
},
"email": {
"S": "customer@example.com"
}
}
}
```
# Arbeiten Sie mit einer vorhandenen Tabelle
Im vorherigen Abschnitt wurde gezeigt, wie eine DynamoDB-Tabelle erstellt wird, die mit einer Java-Datenklasse beginnt. Wenn Sie bereits über eine bestehende Tabelle verfügen und die Funktionen des erweiterten Clients nutzen möchten, können Sie eine Java-Datenklasse erstellen, die mit der Tabelle arbeitet. Sie müssen die DynamoDB-Tabelle untersuchen und der Datenklasse die erforderlichen Anmerkungen hinzufügen.
Rufen Sie die Methode auf, bevor Sie mit einer vorhandenen Tabelle arbeiten. `DynamoDbEnhanced.table()` Dies wurde im vorherigen Beispiel mit der folgenden Anweisung durchgeführt.
```
DynamoDbTable customerTable = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
```
Nachdem die `DynamoDbTable` Instanz zurückgegeben wurde, können Sie sofort mit der Arbeit an der zugrunde liegenden Tabelle beginnen. Sie müssen die Tabelle nicht neu erstellen, indem Sie die `DynamoDbTable.createTable()` Methode aufrufen.
Das folgende Beispiel veranschaulicht dies, indem sofort eine `Customer` Instanz aus der DynamoDB-Tabelle abgerufen wird.
```
DynamoDbTable customerTable = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
// The Customer table exists already and has an item with a primary key value of "1" and a sort key value of "customer@example.com".
customerTable.getItem(
Key.builder().
partitionValue("1").
sortValue("customer@example.com").build());
```
**Wichtig**
Der in der `table()` Methode verwendete Tabellenname muss mit dem vorhandenen DynamoDB-Tabellennamen übereinstimmen.