Änderungen im DynamoDB-Mapping/Dokument APIs von Version 1 zu Version 2

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.amazonaws</groupId>
      <artifactId>aws-java-sdk-bom</artifactId>
      <version>1.X.X</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement> 

<dependencies>
  <dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>aws-java-sdk-dynamodb</artifactId>
  </dependency>
</dependencies>

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>bom</artifactId>
      <version>2.X.X*</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement> 

<dependencies>
  <dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>dynamodb-enhanced</artifactId>
  </dependency>
</dependencies>

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();

Ordnen Sie die POJO Java-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

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

Der Verwenden Sie sekundäre Indizes Abschnitt in diesem Handbuch enthält weitere Informationen.

Schreiben Sie ein Java POJO in eine DynamoDB-Tabelle

mapper.save(item)
mapper.save(item, config)
mapper.save(item, saveExpression, config)

In Version 1 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.

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

table.getItem(getItemRequest)
table.getItem(item)
table.getItem(key)
table.getItemWithResponse(key) //Returns POJO with metadata.

mapper.delete(item, deleteExpression, config)

table.deleteItem(deleteItemRequest)
table.deleteItem(item)
table.deleteItem(key)

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 synchrone Antworten und für asynchrone PagePublisher.subscribe() Antworten

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 synchrone Antworten und PagePublisher.items.subscribe() für asynchrone Antworten

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 synchrone Antworten und für asynchrone PagePublisher.subscribe() Antworten

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 synchrone Antworten und PagePublisher.items.subscribe() für asynchrone Antworten

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.

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()))

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()))

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()))

mapper.transactionWrite(transactionWriteRequest)

enhancedClient.transactWriteItems(transasctWriteItemsRequest)

mapper.transactionLoad(transactionLoadRequest)

enhancedClient.transactGetItems(transactGetItemsRequest) 

mapper.count(Customer.class, queryExpression)
mapper.count(Customer.class, scanExpression)

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(getDefaultProvisionedThroughput())
        .globalSecondaryIndices(
                EnhancedGlobalSecondaryIndex.builder()
                        .indexName("gsi_1")
                        .projection(p -> p.projectionType(ProjectionType.ALL))
                        .provisionedThroughput(getDefaultProvisionedThroughput())
                        .build()));

mapper.parallelScan(Customer.class, scanExpression, numTotalSegments)

Benutzer müssen die Worker-Threads verwalten und scan für jedes Segment aufrufen:

table.scan(r -> r.segment(0).totalSegments(5))

mapper.createS3Link(bucket, key)
mapper.getS3ClientCache()

Wird nicht unterstützt, da es Amazon S3 und DynamoDB verbindet.

@DynamoDBTable (tableName ="CustomerTable")

@DynamoDbBean
@DynamoDbBean(converterProviders = {...})

@DynamoDBAttribute(attributeName = "customerName")

@DynamoDbAttribute("customerName") 

@DynamoDBHashKey 

@DynamoDbPartitionKey

@DynamoDBHashKey 

@DynamoDbSortKey 

@DynamoDBIndexHashKey 

@DynamoDbSecondaryPartitionKey 

@DynamoDBIndexRangeKey 

@DynamoDbSecondarySortKey 

@DynamoDBIgnore 

@DynamoDbIgnore

@DynamoDBAutoGeneratedKey

@DynamoDbAutoGeneratedUuid 

Die Erweiterung, die dies bereitstellt, wird standardmäßig nicht geladen. Sie müssen die Erweiterung zu Client Builder hinzufügen.

@DynamoDBAutoGeneratedTimestamp

@DynamoDbAutoGeneratedTimestampAttribute

Die Erweiterung, die dies bereitstellt, wird standardmäßig nicht geladen. Sie müssen die Erweiterung zu Client Builder hinzufügen.

@DynamoDBVersionAttribute

@DynamoDbVersionAttribute

Die Erweiterung, die dies bereitstellt, wird automatisch geladen.

@DynamoDBTypeConverted

@DynamoDbConvertedBy

@DynamoDBTyped(<DynamoDBAttributeType>)

@DynamoDBDocument

@DynamoDbIgnoreNulls

@DynamoDbPreserveEmptyObject

@DynamoDbUpdateBehavior

@DynamoDbImmutable

@DynamoDbAtomicCounter

Die Erweiterung, die diese Funktionalität bereitstellt, wird automatisch geladen.

DynamoDBMapperConfig.builder()

  .withBatchLoadRetryStrategy(batchLoadRetryStrategy)

  .withBatchWriteRetryStrategy(batchWriteRetryStrategy)

  .withConsistentReads(CONSISTENT)

  .withConversionSchema(conversionSchema)

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

  .withObjectTableNameResolver()
  .withTableNameOverride() 
  .withTableNameResolver()

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

Der Tabellenname wird beim Aufrufen der DynamoDbEDnhancedClient#table() Methode definiert.

  .withPaginationLoadingStrategy(strategy)

Die Optionen sind: LAZY _ LOADINGEAGER_LOADING, oder ITERATION_ONLY

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

  .withRequestMetricCollector(collector)

  .withSaveBehavior(SaveBehavior.CLOBBER) 

Die Optionen sind UPDATECLOBBER,PUT,APPEND_SET, oderUPDATE_SKIP_NULL_ATTRIBUTES.

In Version 2 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

  .withTypeConverterFactory(typeConverterFactory) 

Auf die Bohne legen, indem Sie

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

new DynamoDBSaveExpression()
  .withExpected(Collections.singletonMap(
      "otherAttribute", new ExpectedAttributeValue(false)))
  .withConditionalOperator(ConditionalOperator.AND);

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();

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();

queryExpression.withKeyConditionExpression()

QueryConditional keyEqual = QueryConditional.keyEqualTo(b -> b
                .partitionValue("movie01"));

QueryEnhancedRequest tableQuery = QueryEnhancedRequest.builder()
                .queryConditional(keyEqual)
                .build();

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.

Table documentTable = docClient.documentClient("Person");

DynamoDbTable<EnhancedDocument> documentTable = enhancedClient.table("Person",  
        TableSchema.documentSchemaBuilder()
              .addIndexPartitionKey(TableMetadata.primaryIndexName(),"id", AttributeValueType.S)
              .attributeConverterProviders(AttributeConverterProvider.defaultProvider())
              .build());

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);

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");

// 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());

documentTable.putItem(item)

documentTable.putItem(document);

GetItemOutcome outcome = //Get item.
String jsonPerson = outcome.getItem().toJSON();

String jsonPerson = documentTable.getItem(Key.builder()
        .partitionValue(50).build())
        .fromJson();