Änderungen in der DynamoDB-Zuordnung APIs zwischen Version 1 und Version 2 des SDK for Java - AWS SDK for Java 2.x
Erstellen Sie einen ClientZuordnung zur DynamoDB-Tabelle/zum DynamoDB-Index einrichtenTabellenoperationenOrdnen Sie Klassen und Eigenschaften zuKonfigurationBedingungenTypkonvertierung

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

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 *

 
DynamoDBMapper mapper = new DynamoDBMapper(standardClient, 
                        attributeTransformerInstance);
 
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
    .dynamoDbClient(standardClient)
    .extensions(extensionAInstance, extensionBInstance)
    .build();

* Erweiterungen in V2 entsprechen in etwa den Attributtransformatoren in V1. Der Verwenden Sie Erweiterungen, um DynamoDB Enhanced Client-Operationen anzupassen 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<Customer> customerTable = enhancedClient.table("Customer",
    TableSchema.fromBean(Customer.class));

Einem DynamoDB-Sekundärindex zuordnen

  1. Definieren Sie eine POJO-Klasse, die den Index darstellt.

    • Kommentieren Sie die Klasse @DynamoDBTable mit dem Namen der Tabelle, die den Index enthält.

    • Kommentieren Sie Eigenschaften optional mit @DynamoDBIndexHashKey und. @DynamoDBIndexRangeKey

  2. Erstellen Sie einen Abfrageausdruck.

  3. Abfrage unter Verwendung eines Verweises auf die POJO-Klasse, die den Index darstellt. Beispiel

    mapper.query(IdEmailIndex.class, queryExpression)

    wo IdEmailIndex ist die Mapping-Klasse für den Index.

Der Abschnitt im DynamoDB Developer Guide, in dem die query V1-Methode beschrieben wird, enthält ein vollständiges Beispiel.

  1. Kommentieren Sie Attribute einer POJO-Klasse mit @DynamoDbSecondaryPartitionKey (für eine GSI) und @DynamoDbSecondarySortKey (für und GSI oder LSI). Zum Beispiel 

    @DynamoDbSecondarySortKey(indexNames = "IdEmailIndex")
public String getEmail() { return this.email; }

  2. Ruft einen Verweis auf den Index ab. Zum Beispiel 

    DynamoDbIndex<Customer> customerIndex = customerTable.index("IdEmailIndex");

  3. Fragen Sie den Index ab.

Der Verwenden Sie sekundäre Indizes 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 AufrufsenhancedClient.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. Gelegentlich UpdateItem werden PutItem sowohl als auch beide 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

Scannen Sie eine DynamoDB-Tabelle oder einen sekundären Index und geben Sie eine Liste zurück

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<Class<?>, List<KeyPair>>
 
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<Customer> pageIterable =
    customerTable.query(QueryEnhancedRequest.builder()
        .queryConditional(queryConditional)
        .select(Select.COUNT)
        .build());
Iterator<Page<Customer>> iterator = pageIterable.iterator();
Page<Customer> 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<Customer> pageIterable =
    customerTable.scan(ScanEnhancedRequest.builder()
        .filterExpression(filterExpression)
        .select(Select.COUNT)
        .build());
Iterator<Page<Customer>> iterator = pageIterable.iterator();
Page<Customer> 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 aufrufencreateTable.

 
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 aufrufenscan:

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, 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#table() 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(<DynamoDBAttributeType>)

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 implementierenAttributeConverterProvider. Siehe Steuern Sie die Attributkonvertierung 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:

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 N/A 
@DynamoDbIgnoreNulls
Bestimmen Sie ein Klassenmitglied als leeres Objekt, wenn alle Attribute Null sind N/A 
@DynamoDbPreserveEmptyObject
Legen Sie eine spezielle Aktualisierungsaktion für ein Klassenmitglied fest N/A 
@DynamoDbUpdateBehavior
Bestimmen Sie eine unveränderliche Klasse N/A 
@DynamoDbImmutable
Kennzeichnen Sie ein Klassenmitglied als automatisch inkrementiertes Zählerattribut N/A 
@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 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 Sätzen von Marshallern/Unmarshallern 
  .withConversionSchema(conversionSchema)

Statische Implementierungen bieten Abwärtskompatibilität mit älteren Versionen.

 V2_COMPATIBLE 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_LOADING, oder EAGER_LOADING ITERATION_ONLY

 LAZY_LOADING

  • Nur Iteration ist die Standardeinstellung. Die anderen V1-Optionen werden nicht unterstützt.

  • Sie können das Äquivalent von Eager Loading in V2 wie folgt implementieren: 

    List<Customer> allItems = 
    customerTable.scan().items().stream().collect(Collectors.toList());

  • Für verzögertes Laden müssen Sie Ihre eigene Caching-Logik für Objekte implementieren, auf die zugegriffen wird.
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 UPDATECLOBBER,PUT,APPEND_SET, oderUPDATE_SKIP_NULL_ATTRIBUTES.

 UPDATE

In V2 rufen Sie putItem() oder updateItem() explizit auf.

CLOBBER or PUT: Die entsprechende Aktion in Version 2 ist das AufrufenputItem(). Es gibt keine spezifische CLOBBER Konfiguration.

UPDATE: Entspricht updateItem()

UPDATE_SKIP_NULL_ATTRIBUTES: EntsprichtupdateItem(). Steuern Sie das Aktualisierungsverhalten mit der Anforderungseinstellung ignoreNulls und der Annotation/dem TagDynamoDbUpdateBehavior.

APPEND_SET: Wird nicht unterstützt
Geben Sie Converter Factory ein 
  .withTypeConverterFactory(typeConverterFactory)
Wandler vom Typ Standard

Auf die Bohne setzen mit

@DynamoDbBean(converterProviders = {ConverterProvider.class, 
        DefaultAttributeConverterProvider.class})

Konfiguration pro Vorgang

In Version 1 sind einige Operationen, wie z. B.query(), mithilfe eines „Ausdrucks“ -Objekts, das der Operation übergeben wird, in hohem Maße konfigurierbar. Zum 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. Zum 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.
Ausdruck der Bedingung 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<String, AttributeValue> 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 AttributeConverterAPI-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 erweitertDynamoDBTypeConverterFactory, 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 eine ähnliche Funktionalität. @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 in diesem Handbuch enthält ein vollständiges Beispiel für V2.