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 bei der Arbeit mit DynamoDB von Version 1 zu Version 2 von AWS SDK für Java **Topics** + [ # Unterschiede der DynamoDB-Mapping-API zwischen Version 1 und Version 2 von AWS SDK für Java ](ddb-mapping.md) + [ # Dokumentieren Sie die API-Unterschiede zwischen Version 1 und Version 2 von AWS SDK für Java ](dynamodb-mapping-document-api.md) + [ # Migration der Verschlüsselungsbibliothek ](ddb-encryption-lib-migrate.md) # Unterschiede der DynamoDB-Mapping-API zwischen Version 1 und Version 2 von AWS SDK für Java Die DynamoDB-Zuordnung APIs hat sich zwischen Version 1 und Version 2 von erheblich geändert. AWS SDK für Java In Version 1 verwenden Sie den, um mit `DynamoDBMapper` Java zu arbeiten. POJOs In Version 2 verwenden Sie die `DynamoDbEnhancedClient` mit aktualisierten Methodennamen, erweiterten Schemadefinitionsoptionen und verbesserter Typsicherheit. Zu den wichtigsten Unterschieden gehören: + Neue Methodennamen (z. B. `getItem` statt von`load`) + Explizite Erstellung eines Tabellenschemas + Integrierte Unterstützung für synchrone und asynchrone Operationen + Änderungen in der Art und Weise, wie leere Zeichenketten und Konfigurationen behandelt werden In diesem Abschnitt werden die Änderungen der Mapping-API, Unterschiede in den Anmerkungen, Konfigurationsupdates und Migrationsanleitungen behandelt, die Ihnen beim Übergang von Version 1 `DynamoDBMapper` zu Version 2 helfen sollen`DynamoDbEnhancedClient`. **Contents** + [ # Änderungen auf hoher Ebene in den Mapping-Bibliotheken von Version 1 zu Version 2 des SDK for Java ](dynamodb-mapping-high-level.md) + [ ## Unterschiede zwischen Importabhängigkeiten ](dynamodb-mapping-high-level.md#dynamodb-mapping-deps) + [ # Änderungen in der DynamoDB-Zuordnung APIs zwischen Version 1 und Version 2 des SDK for Java ](dynamodb-mapping-api-changes.md) + [ ## Erstellen Sie einen Client ](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-client) + [ ## Zuordnung zur DynamoDB-Tabelle/zum DynamoDB-Index einrichten ](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-mapping) + [ ## Tabellenoperationen ](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-tobleops) + [ ## Ordnen Sie Klassen und Eigenschaften zu ](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas) + [ ### Bean-Anmerkungen ](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas-annos) + [ ### V2 zusätzliche Anmerkungen ](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas-annos-v2-addnl) + [ ## Konfiguration ](dynamodb-mapping-api-changes.md#dynamodb-mapping-configuration) + [ ### Konfiguration pro Vorgang ](dynamodb-mapping-api-changes.md#dynamodb-mapping-configuration-per-op) + [ ## Bedingungen ](dynamodb-mapping-api-changes.md#dynamodb-mapping-conditionals) + [ ## Typkonvertierung ](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv) + [ ### Standardkonverter ](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-defaults) + [ ### Legen Sie einen benutzerdefinierten Konverter für ein Attribut fest ](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-anno) + [ ### Fügen Sie einen Typkonverter, eine Fabrik oder einen Anbieter hinzu ](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-factory) + [ # Unterschiede im Umgang mit Zeichenketten zwischen Version 1 und Version 2 des SDK for Java ](dynamodb-migration-string-handling.md) + [ # Optimistische Sperrunterschiede zwischen Version 1 und Version 2 des SDK for Java ](dynamodb-migrate-optimstic-locking.md) + [ # Fluent Setter: Unterschiede zwischen Version 1 und Version 2 des SDK for Java ](dynamodb-migrate-fluent-setters.md) # Änderungen auf hoher Ebene in den Mapping-Bibliotheken von Version 1 zu Version 2 des SDK for Java Die Namen der Mapping-Clients in den einzelnen Bibliotheken unterscheiden sich in V1 und V2: + V1 — Dynamo DBMapper + V2 — Erweiterter DynamoDB-Client Sie interagieren mit den beiden Bibliotheken auf die gleiche Weise: Sie instanziieren ein mapper/client und stellen dann ein Java-POJO bereit APIs , das diese Elemente liest und in DynamoDB-Tabellen schreibt. Beide Bibliotheken bieten auch Anmerkungen für die Klasse des POJO, um zu steuern, wie der Client mit dem POJO umgeht. Zu den bemerkenswerten Unterschieden beim Umstieg auf V2 gehören: + V2 und V1 verwenden unterschiedliche Methodennamen für die DynamoDB-Operationen auf niedriger Ebene. Beispiel: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/dynamodb-mapping-high-level.html) + V2 bietet mehrere Möglichkeiten, Tabellenschemas zu definieren und Tabellen POJOs zuzuordnen. Sie können zwischen der Verwendung von Anmerkungen oder einem Schema wählen, das mithilfe eines Builders aus Code generiert wurde. V2 bietet auch veränderbare und unveränderliche Versionen von Schemas. + Bei V2 erstellen Sie als einen der ersten Schritte speziell das Tabellenschema, wohingegen in V1 das Tabellenschema nach Bedarf aus der annotierten Klasse abgeleitet wird. + V2 beinhaltet den [Document API-Client](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html) in der erweiterten Client-API, wohingegen V1 eine [separate](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/DynamoDB.html) API verwendet. + Alle APIs sind in Version V2 in synchronen und asynchronen Versionen verfügbar. Ausführlichere Informationen zum erweiterten V2-Client finden Sie im [Abschnitt DynamoDB-Mapping](dynamodb-enhanced-client.md) in diesem Handbuch. ## Unterschiede zwischen Importabhängigkeiten | V1 | V2 | | --- | --- | | 

  
    
      com.amazonaws
      aws-java-sdk-bom
      1.X.X
      pom
      import
    
  
 


  
    com.amazonaws
    aws-java-sdk-dynamodb
| 

  
    
      software.amazon.awssdk
      bom
      2.X.X*
      pom
      import
    
  
 


  
    software.amazon.awssdk
    dynamodb-enhanced
| \$1 [Letzte Version](https://central.sonatype.com/artifact/software.amazon.awssdk/bom). In Version 1 umfasst eine einzelne Abhängigkeit sowohl die DynamoDB-API auf niedriger Ebene als auch die mapping/document API, wohingegen Sie in V2 die `dynamodb-enhanced` Artefaktabhängigkeit verwenden, um auf die API zuzugreifen. mapping/document Das `dynamodb-enhanced` Modul enthält eine transitive Abhängigkeit vom Low-Level-Modul. `dynamodb` # Änderungen in der DynamoDB-Zuordnung APIs zwischen Version 1 und Version 2 des SDK for Java ## Erstellen Sie einen Client **** | Anwendungsfall | V1 | V2 | | --- | --- | --- | | Normale Instanziierung | 
AmazonDynamoDB standardClient = AmazonDynamoDBClientBuilder.standard()
    .withCredentials(credentialsProvider)
    .withRegion(Regions.US_EAST_1)
    .build();
DynamoDBMapper mapper = new DynamoDBMapper(standardClient);
| 
DynamoDbClient standardClient = DynamoDbClient.builder()
    .credentialsProvider(ProfileCredentialsProvider.create())
    .region(Region.US_EAST_1)
    .build();
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
    .dynamoDbClient(standardClient)
    .build();
| | Minimale Instanziierung | 
AmazonDynamoDB standardClient = AmazonDynamoDBClientBuilder.standard();
DynamoDBMapper mapper = new DynamoDBMapper(standardClient);
| 
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.create();
| | Mit dem Attribut Transformator \$1 | 
DynamoDBMapper mapper = new DynamoDBMapper(standardClient, 
                        attributeTransformerInstance);
| 
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
    .dynamoDbClient(standardClient)
    .extensions(extensionAInstance, extensionBInstance)
    .build();
| \$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 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 | 
@DynamoDBTable(tableName ="Customer")
public class Customer {
  ...
}
| 
DynamoDbTable customerTable = enhancedClient.table("Customer",
    TableSchema.fromBean(Customer.class));
| | 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 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` | 
mapper.save(item)
mapper.save(item, config)
mapper.save(item, saveExpression, config)
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. | 
table.putItem(putItemRequest)
table.putItem(item)
table.putItemWithResponse(item) //Returns metadata.

updateItem(updateItemRequest)
table.updateItem(item)
table.updateItemWithResponse(item) //Returns metadata.
| | Ein Element aus einer DynamoDB-Tabelle in ein Java-POJO lesen **DynamoDB-Betrieb:** `GetItem` | 
mapper.load(item)
mapper.load(item, config)
| 
table.getItem(getItemRequest)
table.getItem(item)
table.getItem(key)
table.getItemWithResponse(key) //Returns POJO with metadata.
| | Löschen Sie ein Element aus einer DynamoDB-Tabelle **DynamoDB-Betrieb:** `DeleteItem` | 
mapper.delete(item, deleteExpression, config)
| 
table.deleteItem(deleteItemRequest)
table.deleteItem(item)
table.deleteItem(key)
| | Fragen Sie eine DynamoDB-Tabelle oder einen sekundären Index ab und geben Sie eine paginierte Liste zurück **DynamoDB-Betrieb:** `Query` | 
mapper.query(Customer.class, queryExpression)
mapper.query(Customer.class, queryExpression, 
                             mapperConfig)
| 
table.query(queryRequest)
table.query(queryConditional)
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` | 
mapper.queryPage(Customer.class, queryExpression)
mapper.queryPage(Customer.class, queryExpression, 
                                 mapperConfig)
| 
table.query(queryRequest)
table.query(queryConditional)
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` | 
mapper.scan(Customer.class, scanExpression)
mapper.scan(Customer.class, scanExpression, 
                            mapperConfig)
| 
table.scan()
table.scan(scanRequest)
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` | 
mapper.scanPage(Customer.class, scanExpression)
mapper.scanPage(Customer.class, scanExpression, 
                                mapperConfig)
| 
table.scan()
table.scan(scanRequest)
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` | 
mapper.batchLoad(Arrays.asList(customer1, 
                               customer2, 
                               book1))
mapper.batchLoad(itemsToGet) 
           // itemsToGet: Map, List>
| 
enhancedClient.batchGetItem(batchGetItemRequest)

enhancedClient.batchGetItem(r -> r.readBatches(
    ReadBatch.builder(Record1.class)
             .mappedTableResource(mappedTable1)
             .addGetItem(i -> i.key(k -> k.partitionValue(0)))
             .build(),
    ReadBatch.builder(Record2.class)
             .mappedTableResource(mappedTable2)
             .addGetItem(i -> i.key(k -> k.partitionValue(0)))
             .build()))

// Iterate over pages with lazy loading or over all items 
   from the same table.
| | Schreiben Sie mehrere Elemente in einem Stapel in mehrere Tabellen **DynamoDB-Betrieb:** `BatchWriteItem` | 
mapper.batchSave(Arrays.asList(customer1, 
                               customer2, 
                               book1))
| 
enhancedClient.batchWriteItem(batchWriteItemRequest)

enhancedClient.batchWriteItem(r -> r.writeBatches(
    WriteBatch.builder(Record1.class)
             .mappedTableResource(mappedTable1)
             .addPutItem(item1)
             .build(),
    WriteBatch.builder(Record2.class)
             .mappedTableResource(mappedTable2)
             .addPutItem(item2)
             .build()))
| | Löschen Sie mehrere Elemente aus mehreren Tabellen in einem Stapel **DynamoDB-Betrieb:** `BatchWriteItem` | 
mapper.batchDelete(Arrays.asList(customer1, 
                                 customer2, 
                                 book1))
| 
enhancedClient.batchWriteItem(r -> r.writeBatches(
    WriteBatch.builder(Record1.class)
             .mappedTableResource(mappedTable1)
             .addDeleteItem(item1key)
             .build(),
    WriteBatch.builder(Record2.class)
             .mappedTableResource(mappedTable2)
             .addDeleteItem(item2key)
             .build()))
| | Schreiben/löschen Sie mehrere Elemente in einem Stapel **DynamoDB-Betrieb:** `BatchWriteItem` | 
mapper.batchWrite(Arrays.asList(customer1, book1), 
                  Arrays.asList(customer2))
| 
enhancedClient.batchWriteItem(r -> r.writeBatches(
    WriteBatch.builder(Record1.class)
             .mappedTableResource(mappedTable1)
             .addPutItem(item1)
             .build(),
    WriteBatch.builder(Record2.class)
             .mappedTableResource(mappedTable2)
             .addDeleteItem(item2key)
             .build()))
| | Führen Sie einen transaktionalen Schreibvorgang durch **DynamoDB-Betrieb:** `TransactWriteItems` | 
mapper.transactionWrite(transactionWriteRequest)
| 
enhancedClient.transactWriteItems(transasctWriteItemsRequest)
| | Führen Sie einen transaktionalen Lesevorgang durch **DynamoDB-Betrieb:** `TransactGetItems` | 
mapper.transactionLoad(transactionLoadRequest)
| 
enhancedClient.transactGetItems(transactGetItemsRequest)
| | Ruft die Anzahl der übereinstimmenden Elemente einer Abfrage ab **DynamoDB-Betrieb**: mit `Query` `Select.COUNT` | 
mapper.count(Customer.class, queryExpression)
| 
// Get the count from query results.
PageIterable pageIterable =
    customerTable.query(QueryEnhancedRequest.builder()
        .queryConditional(queryConditional)
        .select(Select.COUNT)
        .build());
Iterator> iterator = pageIterable.iterator();
Page page = iterator.next();
int count = page.count();

// For a more concise approach, you can chain the method calls:
int count = customerTable.query(QueryEnhancedRequest.builder()
                .queryConditional(queryConditional)
                .select(Select.COUNT)
                .build())
            .iterator().next().count();
| | Ermittelt die Anzahl der übereinstimmenden Elemente eines Scans **DynamoDB-Betrieb**: mit `Scan` `Select.COUNT` | 
mapper.count(Customer.class, scanExpression)
| 
// Get the count from scan results.
PageIterable pageIterable =
    customerTable.scan(ScanEnhancedRequest.builder()
        .filterExpression(filterExpression)
        .select(Select.COUNT)
        .build());
Iterator> iterator = pageIterable.iterator();
Page page = iterator.next();
int count = page.count();

// For a more concise approach, you can chain the method calls:
int count = customerTable.scan(ScanEnhancedRequest.builder()
                .filterExpression(filterExpression)
                .select(Select.COUNT)
                .build())
            .iterator().next().count();
| | Erstellen Sie eine Tabelle in DynamoDB, die der POJO-Klasse entspricht **DynamoDB-Betrieb:** `CreateTable` | 
mapper.generateCreateTableRequest(Customer.class)
Die vorherige Anweisung generiert eine Low-Level-Anforderung zur Tabellenerstellung; Benutzer müssen den DynamoDB-Client aufrufen`createTable`. | 
table.createTable(createTableRequest)

table.createTable(r -> r.provisionedThroughput(defaultThroughput())
    .globalSecondaryIndices(
        EnhancedGlobalSecondaryIndex.builder()
            .indexName("gsi_1")
            .projection(p -> p.projectionType(ProjectionType.ALL))
            .provisionedThroughput(defaultThroughput())
            .build()));
| | Führen Sie einen parallel Scan in DynamoDB durch **DynamoDB-Operation:** `Scan` mit `Segment` und Parametern `TotalSegments` | 
mapper.parallelScan(Customer.class, 
                    scanExpression, 
                    numTotalSegments)
| Benutzer müssen die Worker-Threads verwalten und jedes Segment aufrufen`scan`: 
table.scan(r -> r.segment(0).totalSegments(5))
| | Integrieren Sie Amazon S3 mit DynamoDB, um intelligente S3-Links zu speichern | 
mapper.createS3Link(bucket, key)
mapper.getS3ClientCache()
| Wird nicht unterstützt, da es Amazon S3 und DynamoDB verbindet. | ## Ordnen Sie Klassen und Eigenschaften zu 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 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 | 
@DynamoDBTable (tableName ="CustomerTable")
| 
@DynamoDbBean
@DynamoDbBean(converterProviders = {...})
Der Tabellenname wird beim Aufrufen der DynamoDbEnhancedClient\$1table() Methode definiert. | | Benennen Sie ein Klassenmitglied als Tabellenattribut | 
@DynamoDBAttribute(attributeName = "customerName")
| 
@DynamoDbAttribute("customerName")
| | Die Benennung eines Klassenmitglieds ist ein Schlüssel hash/partition | 
@DynamoDBHashKey
| 
@DynamoDbPartitionKey
| | Die Benennung eines Klassenmitglieds ist ein Schlüssel range/sort | 
@DynamoDBRangeKey
| 
@DynamoDbSortKey
| | Ein Klassenmitglied als sekundären Index-Hash-/Partitionsschlüssel bezeichnen | 
@DynamoDBIndexHashKey
| 
@DynamoDbSecondaryPartitionKey
| | Ein Klassenmitglied als sekundären Indexbereich/Sortierschlüssel bezeichnen | 
@DynamoDBIndexRangeKey
| 
@DynamoDbSecondarySortKey
| | Ignorieren Sie dieses Klassenmitglied bei der Zuordnung zu einer Tabelle | 
@DynamoDBIgnore
| 
@DynamoDbIgnore
| | Benennen Sie ein Klassenmitglied als automatisch generiertes UUID-Schlüsselattribut | 
@DynamoDBAutoGeneratedKey
| 
@DynamoDbAutoGeneratedUuid
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 | 
@DynamoDBAutoGeneratedTimestamp
| 
@DynamoDbAutoGeneratedTimestampAttribute
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 | 
@DynamoDBVersionAttribute
| 
@DynamoDbVersionAttribute
Die Erweiterung, die dies bereitstellt, wird automatisch geladen. | | Weisen Sie einem Klassenmitglied zu, für das eine benutzerdefinierte Konvertierung erforderlich ist | 
@DynamoDBTypeConverted
| 
@DynamoDbConvertedBy
| | Legen Sie ein Klassenmitglied fest, das mit einem anderen Attributtyp gespeichert werden soll | 
@DynamoDBTyped()
| 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 | 
@DynamoDBDocument
| 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 | Anwendungsfall | V1 | V2 | | --- | --- | --- | | Bestimmen Sie ein Klassenmitglied, das nicht als NULL-Attribut gespeichert werden soll, wenn der Java-Wert Null ist | – | 
@DynamoDbIgnoreNulls
| | Bestimmen Sie ein Klassenmitglied als leeres Objekt, wenn alle Attribute Null sind | – | 
@DynamoDbPreserveEmptyObject
| | Legen Sie eine spezielle Aktualisierungsaktion für ein Klassenmitglied fest | – | 
@DynamoDbUpdateBehavior
| | Bestimmen Sie eine unveränderliche Klasse | – | 
@DynamoDbImmutable
| | Kennzeichnen Sie ein Klassenmitglied als automatisch inkrementiertes Zählerattribut | – | 
@DynamoDbAtomicCounter
Die Erweiterung, die diese Funktionalität bereitstellt, wird automatisch geladen. | ## Konfiguration 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 | | --- | --- | --- | --- | | | 
DynamoDBMapperConfig.builder()
| | | | Strategie zur load/write Wiederholung von Batch | 
  .withBatchLoadRetryStrategy(loadRetryStrategy)
  .withBatchWriteRetryStrategy(writeRetryStrategy)
| 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 | 
  .withConsistentReads(CONSISTENT)
| 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 | 
  .withConversionSchema(conversionSchema)
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 | 
  .withObjectTableNameResolver()
  .withTableNameOverride() 
  .withTableNameResolver()
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 | 
  .withPaginationLoadingStrategy(strategy)
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 | 
  .withRequestMetricCollector(collector)
| null | Verwenden Sie metricPublisher() inClientOverrideConfiguration, wenn Sie den standardmäßigen DynamoDB-Client erstellen. | | Verhalten speichern | 
  .withSaveBehavior(SaveBehavior.CLOBBER)
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 | 
  .withTypeConverterFactory(typeConverterFactory)
| Wandler vom Typ Standard | Auf die Bohne legen, indem Sie 
@DynamoDbBean(converterProviders = {ConverterProvider.class, 
        DefaultAttributeConverterProvider.class})
| ### Konfiguration pro Vorgang 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 emailBwQueryExpr = new DynamoDBQueryExpression() .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 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 () | 
new DynamoDBSaveExpression()
  .withExpected(Collections.singletonMap(
      "otherAttribute", new ExpectedAttributeValue(false)))
  .withConditionalOperator(ConditionalOperator.AND);
| Veraltet; stattdessen verwendenConditionExpression. | | Bedingungsausdruck | löschen () | 
deleteExpression.setConditionExpression("zipcode = :zipcode")
deleteExpression.setExpressionAttributeValues(...)
| 
Expression conditionExpression =
    Expression.builder()
        .expression("#key = :value OR #key1 = :value1")
        .putExpressionName("#key", "attribute")
        .putExpressionName("#key1", "attribute3")
        .putExpressionValue(":value", AttributeValues.stringValue("wrong"))
        .putExpressionValue(":value1", AttributeValues.stringValue("three"))
        .build();

DeleteItemEnhancedRequest request = DeleteItemEnhancedRequest.builder()
         .conditionExpression(conditionExpression).build();
| | Filterausdruck | abfragen (), scannen () | 
scanExpression
  .withFilterExpression("#statename = :state")
  .withExpressionAttributeValues(attributeValueMapBuilder.build())
  .withExpressionAttributeNames(attributeNameMapBuilder.build())
| 
Map values = singletonMap(":key", stringValue("value"));
Expression filterExpression =
    Expression.builder()
        .expression("name = :key")
        .expressionValues(values)
        .build();
QueryEnhancedRequest request = QueryEnhancedRequest.builder()
    .filterExpression(filterExpression).build();
| | Bedingungsausdruck für die Abfrage | abfrage () | 
queryExpression.withKeyConditionExpression()
| 
QueryConditional keyEqual = QueryConditional.keyEqualTo(b -> b
                .partitionValue("movie01"));

QueryEnhancedRequest tableQuery = QueryEnhancedRequest.builder()
                .queryConditional(keyEqual)
                .build();
| ## Typkonvertierung ### Standardkonverter 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 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 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() { @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. # Unterschiede im Umgang mit Zeichenketten zwischen Version 1 und Version 2 des SDK for Java V1 und V2 behandeln leere Zeichenketten unterschiedlich, wenn Daten an DynamoDB gesendet werden: + **V1**: Konvertiert leere Zeichenketten vor dem Senden an DynamoDB in Nullwerte (was zu keinem Attribut führt) + **V2**: Sendet leere Zeichenketten als tatsächliche leere Zeichenkettenwerte an DynamoDB **Wichtig** Wenn Sie nach der Migration zu V2 keine leeren Zeichenketten in DynamoDB speichern möchten, müssen Sie benutzerdefinierte Konverter implementieren. Ohne benutzerdefinierte Konverter speichert V2 leere Zeichenfolgen als tatsächliche leere Zeichenkettenattribute in Ihren DynamoDB-Elementen, was sich von dem Verhalten von V1 unterscheidet, diese Attribute vollständig wegzulassen. **Example benutzerdefinierter Konverter für V2, der ein leeres Zeichenkettenattribut in Null umwandelt** ``` /** * Custom converter that maintains V1 behavior by converting empty strings to null values * when writing to DynamoDB, ensuring compatibility with existing data. No attribute will be saved to DynamoDB. */ public class NullifyEmptyStringConverter implements AttributeConverter { @Override public AttributeValue transformFrom(String value) { if (value == null || value.isEmpty()) { return AttributeValue.builder().nul(true).build(); } return AttributeValue.builder().s(value).build(); } @Override public String transformTo(AttributeValue attributeValue) { if (attributeValue.nul()) { return null; } return attributeValue.s(); } @Override public EnhancedType type() { return EnhancedType.of(String.class); } @Override public AttributeValueType attributeValueType() { return AttributeValueType.S; } } // V2 usage: @DynamoDbBean public class Customer { private String name; @DynamoDbConvertedBy(NullifyEmptyStringConverter.class) public String getName() { return name; } } ``` # Optimistische Sperrunterschiede zwischen Version 1 und Version 2 des SDK for Java Sowohl V1 als auch V2 implementieren optimistisches Sperren mit einer Attributanmerkung, die eine Eigenschaft in Ihrer Bean-Klasse markiert, um die Versionsnummer zu speichern. **Unterschiede im optimistischen Sperrverhalten** | | V1 | V2 | | --- | --- | --- | | Anmerkung zur Bean-Klasse | @DynamoDBVersionAttribute | @DynamoDbVersionAttribute(Beachten Sie, dass V2 ein kleingeschriebenes „b“ verwendet) | | Erstes Speichern | Das Versionsnummer-Attribut ist auf 1 gesetzt. | Der Startwert für das auf festgelegte Versionsattribut`@DynamoDbVersionAttribute(startAt = X)`. Der Standardwert ist 0. | | Aktualisierung | Das Versionsnummernattribut wird um 1 erhöht, wenn die bedingte Prüfung sicherstellt, dass die Versionsnummer des zu aktualisierenden Objekts mit der Nummer in der Datenbank übereinstimmt. | Das Versionsnummernattribut wird erhöht, wenn bei der bedingten Überprüfung überprüft wird, ob die Versionsnummer des zu aktualisierenden Objekts mit der Nummer in der Datenbank übereinstimmt. Das Versionsnummernattribut wird um die mit festgelegte `incrementBy` Option erhöht. `@DynamoDbVersionAttribute(incrementBy = X)` Der Standardwert ist 1. | | Delete | DynamoDBMapperfügt eine bedingte Überprüfung hinzu, ob die Versionsnummer des gelöschten Objekts mit der Versionsnummer in der Datenbank übereinstimmt. | V2 fügt nicht automatisch Bedingungen für die Löschvorgänge hinzu. Sie müssen Bedingungsausdrücke manuell hinzufügen, wenn Sie das Löschverhalten steuern möchten. Im folgenden Beispiel `recordVersion` ist das Versionsattribut der Bean dargestellt. 
// 1. Read the item and get its current version.
Customer item = customerTable.getItem(Key.builder().partitionValue("someId").build());
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);
| | Transaktionales Schreiben mit einer Zustandsprüfung | Sie können eine Bean-Klasse, die mit einer Anmerkung versehen ist, nicht @DynamoDBVersionAttribute in einer Methode verwenden. addConditionCheck | Sie können eine Bean-Klasse mit der @DynamoDbVersionAttribute Anmerkung in einer addConditionCheck Builder-Methode für eine transactWriteItems Anfrage verwenden. | | Deaktivieren | Deaktivieren Sie optimistisches Sperren, indem Sie den DynamoDBMapperConfig.SaveBehavior Aufzählungswert von UPDATE bis CLOBBER ändern. | Verwenden Sie die `@DynamoDbVersionAttribute` Anmerkung nicht. | # Fluent Setter: Unterschiede zwischen Version 1 und Version 2 des SDK for Java Sie können es POJOs mit Fluent-Settern in der DynamoDB-Mapping-API für V1 und mit V2 seit Version 2.30.29 verwenden. Das folgende POJO gibt beispielsweise eine Instanz aus der Methode zurück: `Customer` `setName` ``` // V1 @DynamoDBTable(tableName ="Customer") public class Customer{ private String name; // Other attributes and methods not shown. public Customer setName(String name){ this.name = name; return this; } } ``` Wenn Sie jedoch eine Version von V2 vor 2.30.29 verwenden, wird eine `Customer` Instanz mit dem Wert von `setName` zurückgegeben. `name` `null` ``` // V2 prior to version 2.30.29. @DynamoDbBean public class Customer{ private String name; // Other attributes and methods not shown. public Customer setName(String name){ this.name = name; return this; // Bug: returns this instance with a `name` value of `null`. } } ``` ``` // Available in V2 since version 2.30.29. @DynamoDbBean public class Customer{ private String name; // Other attributes and methods not shown. public Customer setName(String name){ this.name = name; return this; // Returns this instance for method chaining with the `name` value set. } } ``` # Dokumentieren Sie die API-Unterschiede zwischen Version 1 und Version 2 von AWS SDK für Java Die Dokument-API unterstützt die Arbeit mit Dokumenten im JSON-Stil als einzelne Elemente in einer DynamoDB-Tabelle. Die V1-Dokument-API hat eine entsprechende API in V2, aber anstatt wie in V1 einen separaten Client für die Dokument-API zu verwenden, integriert V2 Dokument-API-Funktionen in den erweiterten DynamoDB-Client. In V1 stellt die [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Item.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Item.html)Klasse einen unstrukturierten Datensatz aus einer DynamoDB-Tabelle dar. In V2 wird ein unstrukturierter Datensatz durch eine Instanz der Klasse dargestellt. [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html) Beachten Sie, dass Primärschlüssel im Tabellenschema für V2 und im Element selbst in V1 definiert sind. In der folgenden Tabelle werden die Unterschiede zwischen den Dokumenten APIs in V1 und V2 verglichen. | Anwendungsfall | V1 | V2 | | --- |--- |--- | | Erstellen Sie einen Dokumentenclient | 
AmazonDynamoDB client = ... //Create a client.
DynamoDB documentClient = new DynamoDB(client);
| 
// The V2 Document API uses the same DynamoDbEnhancedClient
// that is used for mapping POJOs.
DynamoDbClient standardClient = ... //Create a standard client.
DynamoDbEnhancedClient enhancedClient = ... // Create an enhanced client.
| | Verweisen Sie auf eine Tabelle | 
Table documentTable = docClient.documentClient("Person");
| 
DynamoDbTable documentTable = enhancedClient.table("Person",  
        TableSchema.documentSchemaBuilder()
              .addIndexPartitionKey(TableMetadata.primaryIndexName(),"id", AttributeValueType.S)
              .attributeConverterProviders(AttributeConverterProvider.defaultProvider())
              .build());
| | **Work with semi-structured data** | | --- | | Element einfügen | 
Item item = new Item()
      .withPrimaryKey("id", 50)
      .withString("firstName", "Shirley");
PutItemOutcome outcome = documentTable.putItem(item);
| 
EnhancedDocument personDocument = EnhancedDocument.builder()
        .putNumber("id", 50)
        .putString("firstName", "Shirley")
        .build();
documentTable.putItem(personDocument);
| | Element abrufen | 
GetItemOutcome outcome = documentTable.getItemOutcome( "id", 50);
Item personDocFromDb = outcome.getItem();
String firstName = personDocFromDb.getString("firstName");
| 
EnhancedDocument personDocFromDb = documentTable
        .getItem(Key.builder()
            .partitionValue(50)
            .build()); 
String firstName = personDocFromDb.getString("firstName");
| | **Work with JSON items** | | --- | | Konvertiert eine JSON-Struktur, um sie mit der Document API zu verwenden | 
// The 'jsonPerson' identifier is a JSON string. 
Item item = new Item().fromJSON(jsonPerson);
| 
// The 'jsonPerson' identifier is a JSON string.
EnhancedDocument document = EnhancedDocument.builder()
        .json(jsonPerson).build());
| | Geben Sie JSON ein | 
documentTable.putItem(item)
| 
documentTable.putItem(document);
| | Lesen Sie JSON | 
GetItemOutcome outcome = //Get item.
String jsonPerson = outcome.getItem().toJSON();
| 
String jsonPerson = documentTable.getItem(Key.builder()
        .partitionValue(50).build())
        .fromJson();
| ## API-Referenz und Anleitungen für das Dokument APIs | | V1 | V2 | | --- | --- | --- | | API-Referenz | [API-Referenz](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/package-summary.html) | [API-Referenz](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/package-summary.html) | | Leitfaden zur Dokumentation | [Entwicklerhandbuch für Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/JavaDocumentAPIItemCRUD.html) | [Verbesserte Dokument-API](ddb-en-client-doc-api.md) (dieser Leitfaden) | # V1 Xpec API zur V2 Expressions API Die in Version 1 verfügbare Expression Specification (Xspec) -API, mit der Ausdrücke für dokumentorientierte Daten erstellt werden können, ist in Version 2 nicht verfügbar. V2 verwendet die Expression API, die sowohl mit dokumentenorientierten Daten als auch mit zugewiesenen Daten funktioniert. object-to-item **** | | V1 | V2 | | --- | --- | --- | | API-Name | API für Ausdrucksspezifikationen (Xspec) | Ausdrucks-API | | Funktioniert mit | [Methoden der [Document-API-Tabellenklasse](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Table.html) wie [updateItem und scan](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Table.html#updateItem-java.lang.String-java.lang.Object-com.amazonaws.services.dynamodbv2.xspec.UpdateItemExpressionSpec-)](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Table.html#scan-com.amazonaws.services.dynamodbv2.xspec.ScanExpressionSpec-) | Beide Versionen APIs von DynamoDB Enhanced Client: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/ddb-v1-xspec-migrate.html) Für beide Typen von APIs, nachdem Sie eine [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)Instanz erworben haben: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/ddb-v1-xspec-migrate.html) Sie verwenden Ausdrücke in `DynamoDbTable` Methoden, wenn Sie Anforderungsobjekte erstellen. Zum Beispiel in der `filterExpression` Methode der [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/QueryEnhancedRequest.Builder.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/QueryEnhancedRequest.Builder.html) | | Ressourcen | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/ddb-v1-xspec-migrate.html) | [Informationen zu Ausdrücken](ddb-en-client-expressions.md) in diesem Java-Entwicklerhandbuch | # Migration der Verschlüsselungsbibliothek Informationen zur Migration der Verschlüsselungsbibliothek für DynamoDB, damit sie mit Version 2 des Java SDK funktioniert, finden Sie im [Amazon DynamoDB](https://docs.aws.amazon.com/database-encryption-sdk/latest/devguide/ddb-java-migrate.html) Encryption Client Developer Guide.