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.

# Änderungen in der DynamoDB-Zuordnung APIs zwischen Version 1 und Version 2 des SDK for Java
<a name="dynamodb-mapping-api-changes"></a>

## Erstellen Sie einen Client
<a name="dynamodb-mapping-api-changes-client"></a>


****  

| Anwendungsfall | V1 | V2 | 
| --- | --- | --- | 
|   Normale Instanziierung  |  <pre>AmazonDynamoDB standardClient = AmazonDynamoDBClientBuilder.standard()<br />    .withCredentials(credentialsProvider)<br />    .withRegion(Regions.US_EAST_1)<br />    .build();<br />DynamoDBMapper mapper = new DynamoDBMapper(standardClient);</pre>  |  <pre>DynamoDbClient standardClient = DynamoDbClient.builder()<br />    .credentialsProvider(ProfileCredentialsProvider.create())<br />    .region(Region.US_EAST_1)<br />    .build();<br />DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()<br />    .dynamoDbClient(standardClient)<br />    .build();</pre>  | 
|   Minimale Instanziierung  |  <pre>AmazonDynamoDB standardClient = AmazonDynamoDBClientBuilder.standard();<br />DynamoDBMapper mapper = new DynamoDBMapper(standardClient);</pre>  |  <pre>DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.create();</pre>  | 
|   Mit dem Attribut Transformator \$1  |  <pre>DynamoDBMapper mapper = new DynamoDBMapper(standardClient, <br />                        attributeTransformerInstance);</pre>  |  <pre>DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()<br />    .dynamoDbClient(standardClient)<br />    .extensions(extensionAInstance, extensionBInstance)<br />    .build();</pre>  | 

\$1 Erweiterungen in V2 entsprechen in etwa den Attributtransformatoren in V1. Der [Verwenden Sie Erweiterungen, um DynamoDB Enhanced Client-Operationen anzupassen](ddb-en-client-extensions.md) Abschnitt enthält weitere Informationen zu Erweiterungen in V2. 

## Zuordnung zur DynamoDB-Tabelle/zum DynamoDB-Index einrichten
<a name="dynamodb-mapping-api-changes-mapping"></a>

In V1 geben Sie einen DynamoDB-Tabellennamen über eine Bean-Annotation an. In V2 erzeugt eine Factory-Methode,`table()`, eine Instanz von, `DynamoDbTable` die die Remote-DynamoDB-Tabelle darstellt. Der erste Parameter der `table()` Methode ist der DynamoDB-Tabellenname.


****  

| Anwendungsfall | V1 | V2 | 
| --- | --- | --- | 
|   Ordnen Sie die Java-POJO-Klasse der DynamoDB-Tabelle zu  |  <pre>@DynamoDBTable(tableName ="Customer")<br />public class Customer {<br />  ...<br />}</pre>  |  <pre>DynamoDbTable<Customer> customerTable = enhancedClient.table("Customer",<br />    TableSchema.fromBean(Customer.class));</pre>  | 
|   Einem DynamoDB-Sekundärindex zuordnen  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) Der Abschnitt im DynamoDB Developer Guide, in [dem die `query` V1-Methode](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html#DynamoDBMapper.Methods.query) beschrieben wird, enthält ein vollständiges Beispiel.  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) Der [Verwenden Sie sekundäre Indizes](ddb-en-client-use-secindex.md) Abschnitt in diesem Handbuch enthält weitere Informationen.  | 

## Tabellenoperationen
<a name="dynamodb-mapping-api-changes-tobleops"></a>

In diesem Abschnitt werden Operationen beschrieben APIs , die sich in den meisten Standardanwendungsfällen zwischen V1 und V2 unterscheiden. 

In V2 werden alle Operationen, die eine einzelne Tabelle betreffen, auf der `DynamoDbTable` Instanz aufgerufen, nicht auf dem erweiterten Client. Der erweiterte Client enthält Methoden, die auf mehrere Tabellen abzielen können. 

In der folgenden *Tabelle mit dem Namen Tabellenoperationen* wird eine POJO-Instanz als `item` oder als ein bestimmter Typ bezeichnet, z. B. `customer1` In den V2-Beispielen sind die genannten Instanzen `table` das Ergebnis eines vorherigen Aufrufs`enhancedClient.table()`, der einen Verweis auf die `DynamoDbTable` Instanz zurückgibt.

Beachten Sie, dass die meisten V2-Operationen mit einem fließenden Benutzermuster aufgerufen werden können, auch wenn sie nicht angezeigt werden. Zum Beispiel 

```
Customer customer = table.getItem(r → r.key(key));
  or
Customer customer = table.getItem(r → r.key(k -> k.partitionValue("id").sortValue("email")))
```

Für V1-Operationen enthalten *Tabellenoperationen* (unten) einige der häufig verwendeten Formulare und nicht alle überladenen Formulare. Die `load()` Methode weist beispielsweise die folgenden Überladungen auf:

```
mapper.load(Customer.class, hashKey)
mapper.load(Customer.class, hashKey, rangeKey)
mapper.load(Customer.class, hashKey, config)
mapper.load(Customer.class, hashKey, rangeKey, config)
mapper.load(item)
mapper.load(item, config)
```

Die *Tabellenoperationen* (unten) zeigen die am häufigsten verwendeten Formen:

```
mapper.load(item)
mapper.load(item, config)
```


**Tabellenoperationen**  

| Anwendungsfall | V1 | V2 | 
| --- | --- | --- | 
|  Schreiben Sie ein Java-POJO in eine DynamoDB-Tabelle **DynamoDB-Betrieb**:, `PutItem` `UpdateItem`  |  <pre>mapper.save(item)<br />mapper.save(item, config)<br />mapper.save(item, saveExpression, config)</pre> In V1 bestimmen `DynamoDBMapperConfig.SaveBehavior` Annotationen, welche Low-Level-DynamoDB-Methode aufgerufen wird. Wird im Allgemeinen aufgerufen, außer wenn und verwendet `UpdateItem` wird. `SaveBehavior.CLOBBER` `SaveBehavior.PUT` Automatisch generierte Schlüssel sind ein besonderer Anwendungsfall, und gelegentlich `UpdateItem` werden beide `PutItem` verwendet.  |  <pre>table.putItem(putItemRequest)<br />table.putItem(item)<br />table.putItemWithResponse(item) //Returns metadata.<br /><br />updateItem(updateItemRequest)<br />table.updateItem(item)<br />table.updateItemWithResponse(item) //Returns metadata.</pre>  | 
|  Ein Element aus einer DynamoDB-Tabelle in ein Java-POJO lesen **DynamoDB-Betrieb:** `GetItem`  |  <pre>mapper.load(item)<br />mapper.load(item, config)</pre>  |  <pre>table.getItem(getItemRequest)<br />table.getItem(item)<br />table.getItem(key)<br />table.getItemWithResponse(key) //Returns POJO with metadata.</pre>  | 
|  Löschen Sie ein Element aus einer DynamoDB-Tabelle **DynamoDB-Betrieb:** `DeleteItem`  |  <pre>mapper.delete(item, deleteExpression, config)</pre>  |  <pre>table.deleteItem(deleteItemRequest)<br />table.deleteItem(item)<br />table.deleteItem(key)</pre>  | 
|  Fragen Sie eine DynamoDB-Tabelle oder einen sekundären Index ab und geben Sie eine paginierte Liste zurück **DynamoDB-Betrieb:** `Query`  |  <pre>mapper.query(Customer.class, queryExpression)<br />mapper.query(Customer.class, queryExpression, <br />                             mapperConfig)</pre>  |  <pre>table.query(queryRequest)<br />table.query(queryConditional)</pre> Verwenden Sie die zurückgegebenen Daten `PageIterable.stream()` (verzögertes Laden) für Synchronisationsantworten und `PagePublisher.subscribe()` für asynchrone Antworten  | 
|  Eine DynamoDB-Tabelle oder einen sekundären Index abfragen und eine Liste zurückgeben **DynamoDB-Betrieb:** `Query`  |  <pre>mapper.queryPage(Customer.class, queryExpression)<br />mapper.queryPage(Customer.class, queryExpression, <br />                                 mapperConfig)</pre>  |  <pre>table.query(queryRequest)<br />table.query(queryConditional)</pre> Verwenden Sie die zurückgegebenen Daten `PageIterable.items()` (verzögertes Laden) für Synchronisationsantworten und `PagePublisher.items.subscribe()` für asynchrone Antworten  | 
|  Scannen Sie eine DynamoDB-Tabelle oder einen sekundären Index und geben Sie eine paginierte Liste zurück **DynamoDB-Betrieb:** `Scan`  |  <pre>mapper.scan(Customer.class, scanExpression)<br />mapper.scan(Customer.class, scanExpression, <br />                            mapperConfig)</pre>  |  <pre>table.scan()<br />table.scan(scanRequest)</pre> Verwenden Sie die zurückgegebenen Daten `PageIterable.stream()` (verzögertes Laden) für Synchronisationsantworten und `PagePublisher.subscribe()` für asynchrone Antworten  | 
|  Eine DynamoDB-Tabelle oder einen sekundären Index scannen und eine Liste zurückgeben **DynamoDB-Betrieb:** `Scan`  |  <pre>mapper.scanPage(Customer.class, scanExpression)<br />mapper.scanPage(Customer.class, scanExpression, <br />                                mapperConfig)</pre>  |  <pre>table.scan()<br />table.scan(scanRequest)</pre> Verwenden Sie die zurückgegebenen Daten `PageIterable.items()` (verzögertes Laden) für Synchronisationsantworten und `PagePublisher.items.subscribe()` für asynchrone Antworten  | 
|  Lesen Sie mehrere Elemente aus mehreren Tabellen in einem Stapel **DynamoDB-Betrieb:** `BatchGetItem`  |  <pre>mapper.batchLoad(Arrays.asList(customer1, <br />                               customer2, <br />                               book1))<br />mapper.batchLoad(itemsToGet) <br />           // itemsToGet: Map<Class<?>, List<KeyPair>></pre>  |  <pre>enhancedClient.batchGetItem(batchGetItemRequest)<br /><br />enhancedClient.batchGetItem(r -> r.readBatches(<br />    ReadBatch.builder(Record1.class)<br />             .mappedTableResource(mappedTable1)<br />             .addGetItem(i -> i.key(k -> k.partitionValue(0)))<br />             .build(),<br />    ReadBatch.builder(Record2.class)<br />             .mappedTableResource(mappedTable2)<br />             .addGetItem(i -> i.key(k -> k.partitionValue(0)))<br />             .build()))<br /><br />// Iterate over pages with lazy loading or over all items <br />   from the same table.</pre>  | 
|  Schreiben Sie mehrere Elemente in einem Stapel in mehrere Tabellen **DynamoDB-Betrieb:** `BatchWriteItem`  |  <pre>mapper.batchSave(Arrays.asList(customer1, <br />                               customer2, <br />                               book1)) </pre>  |  <pre>enhancedClient.batchWriteItem(batchWriteItemRequest)<br /><br />enhancedClient.batchWriteItem(r -> r.writeBatches(<br />    WriteBatch.builder(Record1.class)<br />             .mappedTableResource(mappedTable1)<br />             .addPutItem(item1)<br />             .build(),<br />    WriteBatch.builder(Record2.class)<br />             .mappedTableResource(mappedTable2)<br />             .addPutItem(item2)<br />             .build()))</pre>  | 
|  Löschen Sie mehrere Elemente aus mehreren Tabellen in einem Stapel **DynamoDB-Betrieb:** `BatchWriteItem`  |  <pre>mapper.batchDelete(Arrays.asList(customer1, <br />                                 customer2, <br />                                 book1)) </pre>  |  <pre>enhancedClient.batchWriteItem(r -> r.writeBatches(<br />    WriteBatch.builder(Record1.class)<br />             .mappedTableResource(mappedTable1)<br />             .addDeleteItem(item1key)<br />             .build(),<br />    WriteBatch.builder(Record2.class)<br />             .mappedTableResource(mappedTable2)<br />             .addDeleteItem(item2key)<br />             .build()))</pre>  | 
|  Schreiben/löschen Sie mehrere Elemente in einem Stapel **DynamoDB-Betrieb:** `BatchWriteItem`  |  <pre>mapper.batchWrite(Arrays.asList(customer1, book1), <br />                  Arrays.asList(customer2)) </pre>  |  <pre>enhancedClient.batchWriteItem(r -> r.writeBatches(<br />    WriteBatch.builder(Record1.class)<br />             .mappedTableResource(mappedTable1)<br />             .addPutItem(item1)<br />             .build(),<br />    WriteBatch.builder(Record2.class)<br />             .mappedTableResource(mappedTable2)<br />             .addDeleteItem(item2key)<br />             .build()))</pre>  | 
|  Führen Sie einen transaktionalen Schreibvorgang durch **DynamoDB-Betrieb:** `TransactWriteItems`  |  <pre>mapper.transactionWrite(transactionWriteRequest)</pre>  |  <pre>enhancedClient.transactWriteItems(transasctWriteItemsRequest)</pre>  | 
|  Führen Sie einen transaktionalen Lesevorgang durch **DynamoDB-Betrieb:** `TransactGetItems`  |  <pre>mapper.transactionLoad(transactionLoadRequest)</pre>  |  <pre>enhancedClient.transactGetItems(transactGetItemsRequest) </pre>  | 
|  Ruft die Anzahl der übereinstimmenden Elemente einer Abfrage ab **DynamoDB-Betrieb**: mit `Query` `Select.COUNT`  |  <pre>mapper.count(Customer.class, queryExpression)</pre>  |  <pre>// Get the count from query results.<br />PageIterable<Customer> pageIterable =<br />    customerTable.query(QueryEnhancedRequest.builder()<br />        .queryConditional(queryConditional)<br />        .select(Select.COUNT)<br />        .build());<br />Iterator<Page<Customer>> iterator = pageIterable.iterator();<br />Page<Customer> page = iterator.next();<br />int count = page.count();<br /><br />// For a more concise approach, you can chain the method calls:<br />int count = customerTable.query(QueryEnhancedRequest.builder()<br />                .queryConditional(queryConditional)<br />                .select(Select.COUNT)<br />                .build())<br />            .iterator().next().count();</pre>  | 
|  Ermittelt die Anzahl der übereinstimmenden Elemente eines Scans **DynamoDB-Betrieb**: mit `Scan` `Select.COUNT`  |  <pre>mapper.count(Customer.class, scanExpression)</pre>  |  <pre>// Get the count from scan results.<br />PageIterable<Customer> pageIterable =<br />    customerTable.scan(ScanEnhancedRequest.builder()<br />        .filterExpression(filterExpression)<br />        .select(Select.COUNT)<br />        .build());<br />Iterator<Page<Customer>> iterator = pageIterable.iterator();<br />Page<Customer> page = iterator.next();<br />int count = page.count();<br /><br />// For a more concise approach, you can chain the method calls:<br />int count = customerTable.scan(ScanEnhancedRequest.builder()<br />                .filterExpression(filterExpression)<br />                .select(Select.COUNT)<br />                .build())<br />            .iterator().next().count();</pre>  | 
|  Erstellen Sie eine Tabelle in DynamoDB, die der POJO-Klasse entspricht **DynamoDB-Betrieb:** `CreateTable`  |  <pre>mapper.generateCreateTableRequest(Customer.class)</pre> Die vorherige Anweisung generiert eine Low-Level-Anforderung zur Tabellenerstellung; Benutzer müssen den DynamoDB-Client aufrufen`createTable`.  |  <pre>table.createTable(createTableRequest)<br /><br />table.createTable(r -> r.provisionedThroughput(defaultThroughput())<br />    .globalSecondaryIndices(<br />        EnhancedGlobalSecondaryIndex.builder()<br />            .indexName("gsi_1")<br />            .projection(p -> p.projectionType(ProjectionType.ALL))<br />            .provisionedThroughput(defaultThroughput())<br />            .build()));</pre>  | 
|  Führen Sie einen parallel Scan in DynamoDB durch **DynamoDB-Operation:** `Scan` mit `Segment` und Parametern `TotalSegments`  |  <pre>mapper.parallelScan(Customer.class, <br />                    scanExpression, <br />                    numTotalSegments)</pre>  |  Benutzer müssen die Worker-Threads verwalten und jedes Segment aufrufen`scan`: <pre>table.scan(r -> r.segment(0).totalSegments(5))</pre>  | 
|  Integrieren Sie Amazon S3 mit DynamoDB, um intelligente S3-Links zu speichern  |  <pre>mapper.createS3Link(bucket, key)<br />mapper.getS3ClientCache()</pre>  |  Wird nicht unterstützt, da es Amazon S3 und DynamoDB verbindet.  | 

## Ordnen Sie Klassen und Eigenschaften zu
<a name="dynamodb-mapping-schemas"></a>

Sowohl in V1 als auch in V2 ordnen Sie Klassen Tabellen mithilfe von Anmerkungen im Bean-Stil zu. V2 bietet auch [andere Möglichkeiten, Schemas für bestimmte Anwendungsfälle zu definieren](ddb-en-client-adv-features.md#ddb-en-client-adv-features-schm-overview), z. B. die Arbeit mit unveränderlichen Klassen.

### Bean-Anmerkungen
<a name="dynamodb-mapping-schemas-annos"></a>

Die folgende Tabelle zeigt die entsprechenden Bean-Annotationen für einen bestimmten Anwendungsfall, die in V1 und V2 verwendet werden. Ein `Customer` Klassenszenario wird verwendet, um Parameter zu veranschaulichen.

Anmerkungen — ebenso wie Klassen und Aufzählungen — in V2 folgen der Camel-Case-Konvention und verwenden '', nicht 'DynamoDB'. DynamoDb


| Anwendungsfall | V1 | V2 | 
| --- | --- | --- | 
| Klasse der Tabelle zuordnen |  <pre>@DynamoDBTable (tableName ="CustomerTable")</pre>  | <pre>@DynamoDbBean<br />@DynamoDbBean(converterProviders = {...})</pre>Der Tabellenname wird beim Aufrufen der DynamoDbEnhancedClient\$1table() Methode definiert. | 
| Benennen Sie ein Klassenmitglied als Tabellenattribut  |  <pre>@DynamoDBAttribute(attributeName = "customerName")</pre>  |  <pre>@DynamoDbAttribute("customerName") </pre>  | 
| Die Benennung eines Klassenmitglieds ist ein Schlüssel hash/partition  |  <pre>@DynamoDBHashKey </pre>  |  <pre>@DynamoDbPartitionKey</pre>  | 
| Die Benennung eines Klassenmitglieds ist ein Schlüssel range/sort  |  <pre>@DynamoDBRangeKey </pre>  |  <pre>@DynamoDbSortKey </pre>  | 
| Ein Klassenmitglied als sekundären Index-Hash-/Partitionsschlüssel bezeichnen |  <pre>@DynamoDBIndexHashKey </pre>  |  <pre>@DynamoDbSecondaryPartitionKey </pre>  | 
| Ein Klassenmitglied als sekundären Indexbereich/Sortierschlüssel bezeichnen |  <pre>@DynamoDBIndexRangeKey </pre>  |  <pre>@DynamoDbSecondarySortKey </pre>  | 
| Ignorieren Sie dieses Klassenmitglied bei der Zuordnung zu einer Tabelle |  <pre>@DynamoDBIgnore </pre>  |  <pre>@DynamoDbIgnore</pre>  | 
| Benennen Sie ein Klassenmitglied als automatisch generiertes UUID-Schlüsselattribut |  <pre>@DynamoDBAutoGeneratedKey</pre>  |  <pre>@DynamoDbAutoGeneratedUuid </pre> Die Erweiterung, die dies bereitstellt, wird standardmäßig nicht geladen. Sie müssen die Erweiterung zu Client Builder hinzufügen.  | 
| Kennzeichnen Sie ein Klassenmitglied als automatisch generiertes Zeitstempelattribut |  <pre>@DynamoDBAutoGeneratedTimestamp</pre>  |  <pre>@DynamoDbAutoGeneratedTimestampAttribute</pre> Die Erweiterung, die dies bereitstellt, wird standardmäßig nicht geladen. Sie müssen die Erweiterung zu Client Builder hinzufügen.  | 
| Kennzeichnen Sie ein Klassenmitglied als automatisch inkrementiertes Versionsattribut |  <pre>@DynamoDBVersionAttribute</pre>  |  <pre>@DynamoDbVersionAttribute</pre> Die Erweiterung, die dies bereitstellt, wird automatisch geladen.  | 
| Weisen Sie einem Klassenmitglied zu, für das eine benutzerdefinierte Konvertierung erforderlich ist |  <pre>@DynamoDBTypeConverted</pre>  |  <pre>@DynamoDbConvertedBy</pre>  | 
| Legen Sie ein Klassenmitglied fest, das mit einem anderen Attributtyp gespeichert werden soll |  <pre>@DynamoDBTyped(<DynamoDBAttributeType>)</pre>  |  Verwenden Sie eine `AttributeConverter` Implementierung. V2 bietet viele integrierte Konverter für gängige Java-Typen. Sie können auch Ihr eigenes benutzerdefiniertes `AttributeConverter` oder implementieren`AttributeConverterProvider`. Siehe [Steuern Sie die Attributkonvertierung](ddb-en-client-adv-features-conversion.md) in diesem Handbuch.  | 
| Bestimmen Sie eine Klasse, die in ein DynamoDB-Dokument (Dokument im JSON-Stil) oder Unterdokument serialisiert werden kann  |  <pre>@DynamoDBDocument</pre>  | Verwenden Sie die erweiterte Dokument-API. Weitere Informationen finden Sie in den folgenden Ressourcen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) | 

### V2 zusätzliche Anmerkungen
<a name="dynamodb-mapping-schemas-annos-v2-addnl"></a>


| Anwendungsfall | V1 | V2 | 
| --- | --- | --- | 
| Bestimmen Sie ein Klassenmitglied, das nicht als NULL-Attribut gespeichert werden soll, wenn der Java-Wert Null ist | – |  <pre>@DynamoDbIgnoreNulls</pre>  | 
| Bestimmen Sie ein Klassenmitglied als leeres Objekt, wenn alle Attribute Null sind | – |  <pre>@DynamoDbPreserveEmptyObject</pre>  | 
| Legen Sie eine spezielle Aktualisierungsaktion für ein Klassenmitglied fest | – |  <pre>@DynamoDbUpdateBehavior</pre>  | 
| Bestimmen Sie eine unveränderliche Klasse | – |  <pre>@DynamoDbImmutable</pre>  | 
| Kennzeichnen Sie ein Klassenmitglied als automatisch inkrementiertes Zählerattribut | – |  <pre>@DynamoDbAtomicCounter</pre> Die Erweiterung, die diese Funktionalität bereitstellt, wird automatisch geladen.  | 

## Konfiguration
<a name="dynamodb-mapping-configuration"></a>

In V1 steuern Sie im Allgemeinen bestimmte Verhaltensweisen, indem Sie eine Instanz von `DynamoDBMapperConfig` verwenden. Sie können das Konfigurationsobjekt entweder angeben, wenn Sie den Mapper erstellen oder wenn Sie eine Anfrage stellen. In V2 ist die Konfiguration spezifisch für das Anforderungsobjekt für den Vorgang.


| Anwendungsfall | V1 | Standard in V1 | V2 | 
| --- | --- | --- | --- | 
|  |  <pre>DynamoDBMapperConfig.builder()</pre>  |  |  | 
| Strategie zur load/write Wiederholung von Batch |  <pre>  .withBatchLoadRetryStrategy(loadRetryStrategy)</pre> <pre>  .withBatchWriteRetryStrategy(writeRetryStrategy)</pre>  | Fehlgeschlagene Artikel erneut versuchen | Konfigurieren Sie die Wiederholungsstrategie für das Basisprodukt. DynamoDBClient Weitere Informationen finden Sie [Konfigurieren Sie das Wiederholungsverhalten in der AWS SDK for Java 2.x](retry-strategy.md) in diesem Handbuch. | 
| Konsistente Lesevorgänge |  <pre>  .withConsistentReads(CONSISTENT)</pre>  | EVENTUAL | Standardmäßig ist der Wert für konsistente Lesevorgänge für Lesevorgänge falsch. Überschreiben .consistentRead(true) Sie mit im Anforderungsobjekt. | 
| Konvertierungsschema mit Gruppen von Marshallern/Unmarshallern |  <pre>  .withConversionSchema(conversionSchema)</pre> Statische Implementierungen bieten Abwärtskompatibilität mit älteren Versionen.  | V2\$1COMPATIBLE | Nicht zutreffend. Dies ist ein veraltetes Feature, das sich darauf bezieht, wie die frühesten Versionen von DynamoDB (V1) Datentypen gespeichert haben. Dieses Verhalten wird im erweiterten Client nicht beibehalten. Ein Beispiel für ein Verhalten in DynamoDB V1 ist das Speichern von Booleschen Werten als Zahl statt als Boolean. | 
| Tabellennamen |  <pre>  .withObjectTableNameResolver()<br />  .withTableNameOverride() <br />  .withTableNameResolver()</pre> Statische Implementierungen bieten Abwärtskompatibilität mit älteren Versionen  | verwende Anmerkungen oder Vermutungen aus der Klasse |  Der Tabellenname wird beim Aufrufen der `DynamoDbEnhancedClient#table()` Methode definiert.  | 
| Strategie beim Laden der Seitennummerierung |  <pre>  .withPaginationLoadingStrategy(strategy)</pre>  Die Optionen sind: LAZY\$1`LOADING`, oder `EAGER_LOADING` `ITERATION_ONLY`  | LAZY\$1LOADING |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html)  | 
| Erfassung von Metriken anfordern |  <pre>  .withRequestMetricCollector(collector)</pre>  | null | Verwenden Sie metricPublisher() inClientOverrideConfiguration, wenn Sie den standardmäßigen DynamoDB-Client erstellen.  | 
| Verhalten speichern |  <pre>  .withSaveBehavior(SaveBehavior.CLOBBER) </pre> Die Optionen sind `UPDATE``CLOBBER`,`PUT`,`APPEND_SET`, oder`UPDATE_SKIP_NULL_ATTRIBUTES`.  | UPDATE |  In V2 rufen Sie `putItem()` oder `updateItem()` explizit auf. `CLOBBER or PUT`: Die entsprechende Aktion in Version 2 ist das Aufrufen`putItem()`. Es gibt keine spezifische `CLOBBER` Konfiguration. `UPDATE`: Entspricht `updateItem()` `UPDATE_SKIP_NULL_ATTRIBUTES`: Entspricht`updateItem()`. Steuern Sie das Aktualisierungsverhalten mit der Anforderungseinstellung `ignoreNulls` und der Annotation/dem Tag`DynamoDbUpdateBehavior`. `APPEND_SET`: Nicht unterstützt  | 
| Geben Sie Converter Factory ein |  <pre>  .withTypeConverterFactory(typeConverterFactory) </pre>  | Wandler vom Typ Standard |  Auf die Bohne legen, indem Sie <pre>@DynamoDbBean(converterProviders = {ConverterProvider.class, <br />        DefaultAttributeConverterProvider.class})</pre>  | 

### Konfiguration pro Vorgang
<a name="dynamodb-mapping-configuration-per-op"></a>

In Version 1 sind einige Operationen, wie z. B.`query()`, über ein Ausdrucksobjekt, das der Operation übergeben wird, in hohem Maße konfigurierbar. Beispiel:

```
DynamoDBQueryExpression<Customer> emailBwQueryExpr = new DynamoDBQueryExpression<Customer>()
    .withRangeKeyCondition("Email",
        new Condition()
            .withComparisonOperator(ComparisonOperator.BEGINS_WITH)
            .withAttributeValueList(
                new AttributeValue().withS("my")));

mapper.query(Customer.class, emailBwQueryExpr);
```

In V2 verwenden Sie kein Konfigurationsobjekt, sondern legen Parameter für das Anforderungsobjekt mithilfe eines Builders fest. Beispiel:

```
QueryEnhancedRequest emailBw = QueryEnhancedRequest.builder()
    .queryConditional(QueryConditional
        .sortBeginsWith(kb -> kb
            .sortValue("my"))).build();

customerTable.query(emailBw);
```

## Bedingungen
<a name="dynamodb-mapping-conditionals"></a>

In V2 werden Bedingungs- und Filterausdrücke mithilfe eines `Expression` Objekts ausgedrückt, das die Bedingung und die Zuordnung von Namen und Filtern kapselt. 


| Anwendungsfall | Operationen | V1 | V2 | 
| --- | --- | --- | --- | 
| Erwartete Attributbedingungen | speichern (), löschen (), abfragen (), scannen () |  <pre>new DynamoDBSaveExpression()<br />  .withExpected(Collections.singletonMap(<br />      "otherAttribute", new ExpectedAttributeValue(false)))<br />  .withConditionalOperator(ConditionalOperator.AND);</pre>  | Veraltet; stattdessen verwendenConditionExpression. | 
| Bedingungsausdruck | löschen () |  <pre>deleteExpression.setConditionExpression("zipcode = :zipcode")<br />deleteExpression.setExpressionAttributeValues(...)<br /></pre>  |  <pre>Expression conditionExpression =<br />    Expression.builder()<br />        .expression("#key = :value OR #key1 = :value1")<br />        .putExpressionName("#key", "attribute")<br />        .putExpressionName("#key1", "attribute3")<br />        .putExpressionValue(":value", AttributeValues.stringValue("wrong"))<br />        .putExpressionValue(":value1", AttributeValues.stringValue("three"))<br />        .build();<br /><br />DeleteItemEnhancedRequest request = DeleteItemEnhancedRequest.builder()<br />         .conditionExpression(conditionExpression).build();</pre>  | 
| Filterausdruck | abfragen (), scannen () |  <pre>scanExpression<br />  .withFilterExpression("#statename = :state")<br />  .withExpressionAttributeValues(attributeValueMapBuilder.build())<br />  .withExpressionAttributeNames(attributeNameMapBuilder.build())<br /></pre>  |  <pre>Map<String, AttributeValue> values = singletonMap(":key", stringValue("value"));<br />Expression filterExpression =<br />    Expression.builder()<br />        .expression("name = :key")<br />        .expressionValues(values)<br />        .build();<br />QueryEnhancedRequest request = QueryEnhancedRequest.builder()<br />    .filterExpression(filterExpression).build();<br /></pre>  | 
| Bedingungsausdruck für die Abfrage | abfrage () |  <pre>queryExpression.withKeyConditionExpression()</pre>  |  <pre>QueryConditional keyEqual = QueryConditional.keyEqualTo(b -> b<br />                .partitionValue("movie01"));<br /><br />QueryEnhancedRequest tableQuery = QueryEnhancedRequest.builder()<br />                .queryConditional(keyEqual)<br />                .build();</pre>  | 

## Typkonvertierung
<a name="dynamodb-mapping-type-conv"></a>

### Standardkonverter
<a name="dynamodb-mapping-type-conv-defaults"></a>

In V2 bietet das SDK eine Reihe von Standardkonvertern für alle gängigen Typen. Sie können Typkonverter sowohl auf der Gesamtanbieterebene als auch für ein einzelnes Attribut ändern. Eine Liste der verfügbaren Konverter finden Sie in der [AttributeConverter](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverter.html)API-Referenz.

### Legen Sie einen benutzerdefinierten Konverter für ein Attribut fest
<a name="dynamodb-mapping-type-conv-anno"></a>

In V1 können Sie eine Getter-Methode mit annotieren, `@DynamoDBTypeConverted` um die Klasse anzugeben, die zwischen dem Java-Attributtyp und einem DynamoDB-Attributtyp konvertiert. Beispielsweise kann eine, `CurrencyFormatConverter` die zwischen einem `Currency` Java-Typ und einem DynamoDB-String konvertiert, angewendet werden, wie im folgenden Codeausschnitt gezeigt.

```
@DynamoDBTypeConverted(converter = CurrencyFormatConverter.class)
public Currency getCurrency() { return currency; }
```

Das V2-Äquivalent des vorherigen Snippets ist unten dargestellt.

```
@DynamoDbConvertedBy(CurrencyFormatConverter.class)
public Currency getCurrency() { return currency; }
```

**Anmerkung**  
In V1 können Sie die Anmerkung auf das Attribut selbst, einen Typ oder eine benutzerdefinierte Anmerkung anwenden. V2 unterstützt das Anwenden der Anmerkung nur auf den Getter.

### Fügen Sie einen Typkonverter, eine Fabrik oder einen Anbieter hinzu
<a name="dynamodb-mapping-type-conv-factory"></a>

In V1 können Sie Ihren eigenen Satz von Typkonvertern bereitstellen oder die Typen, die Ihnen wichtig sind, überschreiben, indem Sie der Konfiguration eine Typkonverter-Factory hinzufügen. Die Typkonverter-Factory wird erweitert`DynamoDBTypeConverterFactory`, und Überschreibungen werden vorgenommen, indem ein Verweis auf den Standardsatz abgerufen und dieser erweitert wird. Der folgende Ausschnitt zeigt, wie das geht.

```
DynamoDBTypeConverterFactory typeConverterFactory =
    DynamoDBTypeConverterFactory.standard().override()
        .with(String.class, CustomBoolean.class, new DynamoDBTypeConverter<String, CustomBoolean>() {
            @Override
            public String convert(CustomBoolean bool) {
                return String.valueOf(bool.getValue());
            }
            @Override
            public CustomBoolean unconvert(String string) {
                return new CustomBoolean(Boolean.valueOf(string));
            }}).build();
DynamoDBMapperConfig config =
    DynamoDBMapperConfig.builder()
        .withTypeConverterFactory(typeConverterFactory)
        .build();
DynamoDBMapper mapperWithTypeConverterFactory = new DynamoDBMapper(dynamo, config);
```

V2 bietet durch die Anmerkung ähnliche Funktionen. `@DynamoDbBean` Sie können ein einzelnes `AttributeConverterProvider` oder eine Kette von bestellten `AttributeConverterProvider` s angeben. Beachten Sie, dass Sie, wenn Sie Ihre eigene Kette von Anbietern für Attributkonverter angeben, den Standardkonverter-Anbieter überschreiben und ihn in die Kette aufnehmen müssen, um die zugehörigen Attributkonverter verwenden zu können. 

```
@DynamoDbBean(converterProviders = {
   ConverterProvider1.class, 
   ConverterProvider2.class,
   DefaultAttributeConverterProvider.class})
public class Customer {
  ...
}
```

Der Abschnitt zur [Attributkonvertierung](ddb-en-client-adv-features-conversion.md#ddb-en-client-adv-features-conversion-example) in diesem Handbuch enthält ein vollständiges Beispiel für V2.