Modifications apportées au APIs mappage DynamoDB entre les versions 1 et 2 du SDK for Java - AWS SDK for Java 2.x
Création d'un clientÉtablir le mappage vers la table/l'index DynamoDBOpérations de tableClasses et propriétés de cartesConfigurationConditionnelsConversion de type

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Modifications apportées au APIs mappage DynamoDB entre les versions 1 et 2 du SDK for Java

Création d'un client

Cas d’utilisation V1 V2

Instanciation normale

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

Instanciation minimale

 
AmazonDynamoDB standardClient = AmazonDynamoDBClientBuilder.standard();
DynamoDBMapper mapper = new DynamoDBMapper(standardClient);
 
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.create();

Avec transformateur d'attributs *

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

* Les extensions de la V2 correspondent approximativement aux transformateurs d'attributs de la V1. La Utiliser des extensions pour personnaliser les opérations du client DynamoDB Enhanced section contient plus d'informations sur les extensions de la version 2.

Établir le mappage vers la table/l'index DynamoDB

Dans la version 1, vous spécifiez le nom d'une table DynamoDB par le biais d'une annotation de bean. Dans la version 2, une méthode d'usine produit une instance de DynamoDbTable qui représente la table DynamoDB distante. table() Le premier paramètre de la table() méthode est le nom de la table DynamoDB.

Cas d’utilisation V1 V2

Mappez la classe Java POJO à la table DynamoDB

 
@DynamoDBTable(tableName ="Customer")
public class Customer {
  ...
}
 
DynamoDbTable<Customer> customerTable = enhancedClient.table("Customer",
    TableSchema.fromBean(Customer.class));

Mapper vers un index secondaire DynamoDB

  1. Définissez une classe POJO qui représente l'index.

    • Annotez la classe @DynamoDBTable en fournissant le nom de la table contenant l'index.

    • Annotez les propriétés avec @DynamoDBIndexHashKey et éventuellement@DynamoDBIndexRangeKey.

  2. Créez une expression de requête.

  3. Requête utilisant une référence à la classe POJO qui représente l'index. Par exemple

    mapper.query(IdEmailIndex.class, queryExpression)

    où IdEmailIndex est la classe de mappage de l'index.

La section du Guide du développeur DynamoDB qui décrit la méthode query V1 présente un exemple complet.

  1. Annotez les attributs d'une classe POJO avec @DynamoDbSecondaryPartitionKey (pour un GSI) et @DynamoDbSecondarySortKey (pour et GSI ou LSI). Par exemple, 

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

  2. Récupérez une référence à l'index. Par exemple, 

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

  3. Interrogez l'index.

La Utiliser des indices secondaires section de ce guide fournit plus d'informations.

Opérations de table

Cette section décrit les opérations APIs qui diffèrent entre la V1 et la V2 pour la plupart des cas d'utilisation standard.

Dans la version 2, toutes les opérations impliquant une seule table sont appelées sur l'DynamoDbTableinstance, et non sur le client amélioré. Le client amélioré contient des méthodes qui peuvent cibler plusieurs tables.

Dans le tableau intitulé Opérations de table ci-dessous, une instance POJO est désignée sous le nom item ou en tant que type spécifique tel quecustomer1. Pour les exemples de la V2, les instances nommées table sont le résultat d'un appel précédent enhancedClient.table() qui renvoie une référence à l'DynamoDbTableinstance.

Notez que la plupart des opérations V2 peuvent être appelées avec un modèle de consommation fluide même lorsqu'elles ne sont pas affichées. Par exemple, 

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

Pour les opérations V1, les opérations de table (ci-dessous) contiennent certains des formulaires couramment utilisés, mais pas tous les formulaires surchargés. Par exemple, la load() méthode présente les surcharges suivantes :

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)

Le tableau des opérations (ci-dessous) montre les formulaires couramment utilisés :

mapper.load(item)
mapper.load(item, config)
Opérations de table
Cas d’utilisation V1 V2

Écrire un POJO Java dans une table DynamoDB

Opération DynamoDB :, PutItem UpdateItem

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

Dans la version 1, DynamoDBMapperConfig.SaveBehavior les annotations déterminent la méthode DynamoDB de bas niveau qui sera appelée. En général, UpdateItem est appelé sauf lors de l'utilisation de SaveBehavior.CLOBBER etSaveBehavior.PUT. Les clés générées automatiquement constituent un cas d'utilisation particulier, et parfois les deux PutItem UpdateItem sont utilisées.

 
table.putItem(putItemRequest)
table.putItem(item)
table.putItemWithResponse(item) //Returns metadata.

updateItem(updateItemRequest)
table.updateItem(item)
table.updateItemWithResponse(item) //Returns metadata.

Lire un élément d'une table DynamoDB dans un POJO Java

Fonctionnement DynamoDB : GetItem

 
mapper.load(item)
mapper.load(item, config)
 
table.getItem(getItemRequest)
table.getItem(item)
table.getItem(key)
table.getItemWithResponse(key) //Returns POJO with metadata.

Supprimer un élément d'une table DynamoDB

Fonctionnement DynamoDB : DeleteItem

 
mapper.delete(item, deleteExpression, config)
 
table.deleteItem(deleteItemRequest)
table.deleteItem(item)
table.deleteItem(key)

Interrogez une table DynamoDB ou un index secondaire et renvoyez une liste paginée

Fonctionnement DynamoDB : Query

 
mapper.query(Customer.class, queryExpression)
mapper.query(Customer.class, queryExpression, 
                             mapperConfig)
 
table.query(queryRequest)
table.query(queryConditional)

Utiliser le renvoi PageIterable.stream() (chargement différé) pour les réponses synchronisées et PagePublisher.subscribe() pour les réponses asynchrones

Interrogez une table DynamoDB ou un index secondaire et renvoyez une liste

Fonctionnement DynamoDB : Query

 
mapper.queryPage(Customer.class, queryExpression)
mapper.queryPage(Customer.class, queryExpression, 
                                 mapperConfig)
 
table.query(queryRequest)
table.query(queryConditional)

Utiliser le renvoi PageIterable.items() (chargement différé) pour les réponses synchronisées et PagePublisher.items.subscribe() pour les réponses asynchrones

Scanner une table DynamoDB ou un index secondaire et renvoyer une liste paginée

Fonctionnement DynamoDB : Scan

 
mapper.scan(Customer.class, scanExpression)
mapper.scan(Customer.class, scanExpression, 
                            mapperConfig)
 
table.scan()
table.scan(scanRequest)

Utiliser le renvoi PageIterable.stream() (chargement différé) pour les réponses synchronisées et PagePublisher.subscribe() pour les réponses asynchrones

Scanner une table DynamoDB ou un index secondaire et renvoyer une liste

Fonctionnement DynamoDB : Scan

 
mapper.scanPage(Customer.class, scanExpression)
mapper.scanPage(Customer.class, scanExpression, 
                                mapperConfig)
 
table.scan()
table.scan(scanRequest)

Utiliser le renvoi PageIterable.items() (chargement différé) pour les réponses synchronisées et PagePublisher.items.subscribe() pour les réponses asynchrones

Lire plusieurs éléments de plusieurs tables dans un lot

Fonctionnement DynamoDB : 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.

Écrire plusieurs éléments dans plusieurs tables par lot

Fonctionnement DynamoDB : 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()))

Supprimer plusieurs éléments de plusieurs tables par lot

Fonctionnement DynamoDB : 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()))

Écrivez/supprimez plusieurs éléments dans un lot

Fonctionnement DynamoDB : 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()))

Réaliser une écriture transactionnelle

Fonctionnement DynamoDB : TransactWriteItems

 
mapper.transactionWrite(transactionWriteRequest)
 
enhancedClient.transactWriteItems(transasctWriteItemsRequest)

Réaliser une lecture transactionnelle

Fonctionnement DynamoDB : TransactGetItems

 
mapper.transactionLoad(transactionLoadRequest)
 
enhancedClient.transactGetItems(transactGetItemsRequest)

Obtenir le nombre d'éléments correspondants d'une requête

Fonctionnement DynamoDB : avec 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();

Obtenez le nombre d'éléments correspondants d'un scan

Fonctionnement DynamoDB : avec 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();

Créez une table dans DynamoDB correspondant à la classe POJO

Fonctionnement DynamoDB : CreateTable

 
mapper.generateCreateTableRequest(Customer.class)

L'instruction précédente génère une demande de création de table de bas niveau ; les utilisateurs doivent appeler createTable le client DynamoDB.

 
table.createTable(createTableRequest)

table.createTable(r -> r.provisionedThroughput(defaultThroughput())
    .globalSecondaryIndices(
        EnhancedGlobalSecondaryIndex.builder()
            .indexName("gsi_1")
            .projection(p -> p.projectionType(ProjectionType.ALL))
            .provisionedThroughput(defaultThroughput())
            .build()));

Effectuer un scan parallèle dans DynamoDB

Fonctionnement Scan DynamoDB : avec et paramètres Segment TotalSegments

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

Les utilisateurs sont tenus de gérer les threads de travail et d'appeler scan pour chaque segment :

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

Intégrez Amazon S3 à DynamoDB pour stocker des liens S3 intelligents

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

Non pris en charge car il associe Amazon S3 et DynamoDB.

Classes et propriétés de cartes

Dans les versions V1 et V2, vous mappez des classes à des tables à l'aide d'annotations de style haricot. La V2 propose également d'autres moyens de définir des schémas pour des cas d'utilisation spécifiques, tels que l'utilisation de classes immuables.

Annotations sur les haricots

Le tableau suivant montre les annotations de bean équivalentes pour un cas d'utilisation spécifique qui sont utilisées dans les versions V1 et V2. Un scénario Customer de classe est utilisé pour illustrer les paramètres.

Les annotations, ainsi que les classes et les énumérations, de la version 2 suivent la convention Camel Case et utilisent « », et non « DynamoDB ». DynamoDb

Cas d’utilisation V1 V2
Associer une classe à une table 
@DynamoDBTable (tableName ="CustomerTable")
 
@DynamoDbBean
@DynamoDbBean(converterProviders = {...})
Le nom de la table est défini lors de l'appel de la DynamoDbEnhancedClient#table() méthode.
Désigner un membre de classe comme attribut de table 
@DynamoDBAttribute(attributeName = "customerName")
 
@DynamoDbAttribute("customerName")
Désigner un membre de la classe est hash/partition essentiel 
@DynamoDBHashKey 
@DynamoDbPartitionKey
Désigner un membre de la classe est range/sort essentiel 
@DynamoDBRangeKey 
@DynamoDbSortKey
Désigner un membre de classe comme clé de hachage ou de partition d'index secondaire 
@DynamoDBIndexHashKey 
@DynamoDbSecondaryPartitionKey
Désigner un membre de classe comme plage d'index secondaire/clé de tri 
@DynamoDBIndexRangeKey 
@DynamoDbSecondarySortKey
Ignorer ce membre de classe lors du mappage vers une table 
@DynamoDBIgnore 
@DynamoDbIgnore
Désigner un membre de classe comme attribut clé UUID généré automatiquement 
@DynamoDBAutoGeneratedKey
 
@DynamoDbAutoGeneratedUuid

L'extension qui fournit cela n'est pas chargée par défaut ; vous devez ajouter l'extension au générateur de clients.
Désigner un membre de classe comme attribut d'horodatage généré automatiquement 
@DynamoDBAutoGeneratedTimestamp
 
@DynamoDbAutoGeneratedTimestampAttribute

L'extension qui fournit cela n'est pas chargée par défaut ; vous devez ajouter l'extension au générateur de clients.
Désigner un membre de classe comme attribut de version auto-incrémenté 
@DynamoDBVersionAttribute
 
@DynamoDbVersionAttribute

L'extension qui fournit cela est chargée automatiquement.
Désigner un membre de la classe comme nécessitant une conversion personnalisée 
@DynamoDBTypeConverted
 
@DynamoDbConvertedBy
Désignez un membre de classe à stocker sous un autre type d'attribut 
@DynamoDBTyped(<DynamoDBAttributeType>)

Utilisez une AttributeConverter implémentation. La V2 fournit de nombreux convertisseurs intégrés pour les types Java courants. Vous pouvez également implémenter votre propre personnalisation AttributeConverter ouAttributeConverterProvider. Voir Conversion des attributs de contrôle dans ce guide.
Désignez une classe qui peut être sérialisée dans un document DynamoDB (document de style JSON) ou un sous-document 
@DynamoDBDocument
 Utilisez l'API de document améliorée. Consultez les ressources suivantes :

Annotations supplémentaires V2

Cas d’utilisation V1 V2
Désignez un membre de classe à ne pas stocker en tant qu'attribut NULL si la valeur Java est nulle N/A 
@DynamoDbIgnoreNulls
Désignez un membre de classe comme un objet vide si tous les attributs sont nuls N/A 
@DynamoDbPreserveEmptyObject
Désigner une action de mise à jour spéciale pour un membre du groupe N/A 
@DynamoDbUpdateBehavior
Désigner une classe immuable N/A 
@DynamoDbImmutable
Désigner un membre de classe comme attribut de compteur auto-incrémenté N/A 
@DynamoDbAtomicCounter

L'extension qui fournit cette fonctionnalité est chargée automatiquement.

Configuration

Dans la version 1, vous contrôlez généralement des comportements spécifiques à l'aide d'une instance deDynamoDBMapperConfig. Vous pouvez fournir l'objet de configuration lorsque vous créez le mappeur ou lorsque vous faites une demande. Dans la version 2, la configuration est spécifique à l'objet de demande pour l'opération.

Cas d’utilisation V1 Par défaut dans la V1 V2 
DynamoDBMapperConfig.builder()
Stratégie de load/write nouvelle tentative par lots 
  .withBatchLoadRetryStrategy(loadRetryStrategy)
  .withBatchWriteRetryStrategy(writeRetryStrategy)
 réessayer les articles ayant échoué Configurez la stratégie de nouvelle tentative sur le sous-jacentDynamoDBClient. Voir Configurez le comportement des nouvelles tentatives dans AWS SDK for Java 2.x dans ce guide.
Lectures cohérentes 
  .withConsistentReads(CONSISTENT)
 EVENTUAL Par défaut, les lectures cohérentes ont la valeur false pour les opérations de lecture. Remplacez par .consistentRead(true) sur l'objet de la requête.
Schéma de conversion avec des ensembles de marshallers/unmarshallers 
  .withConversionSchema(conversionSchema)

Les implémentations statiques offrent une rétrocompatibilité avec les anciennes versions.

 V2_COMPATIBLE Non applicable. Il s'agit d'une fonctionnalité héritée qui fait référence à la manière dont les premières versions de DynamoDB (V1) stockaient les types de données. Ce comportement ne sera pas conservé dans le client amélioré. Un exemple de comportement dans DynamoDB V1 consiste à stocker les booléens sous forme de nombre plutôt que sous forme de booléen.
Noms des tables 
  .withObjectTableNameResolver()
  .withTableNameOverride() 
  .withTableNameResolver()

Les implémentations statiques offrent une rétrocompatibilité avec les anciennes versions

 utiliser une annotation ou deviner à partir de la classe

Le nom de la table est défini lors de l'appel de la DynamoDbEnhancedClient#table() méthode.
Stratégie de chargement de pagination 
  .withPaginationLoadingStrategy(strategy)

Les options sont les suivantes : LAZY_LOADING, ou EAGER_LOADING ITERATION_ONLY

 LAZY_LOADING

  • L'itération uniquement est la valeur par défaut. Les autres options V1 ne sont pas prises en charge.

  • Vous pouvez implémenter l'équivalent du chargement rapide dans la version 2 avec ce qui suit : 

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

  • Pour le chargement différé, vous devez implémenter votre propre logique de mise en cache pour les éléments auxquels vous accédez.
Demander la collecte de métriques 
  .withRequestMetricCollector(collector)
 null metricPublisher()À utiliser ClientOverrideConfiguration lors de la création du client DynamoDB standard.
Enregistrer le comportement 
  .withSaveBehavior(SaveBehavior.CLOBBER)

Les options sont UPDATE CLOBBERPUT,APPEND_SET, ouUPDATE_SKIP_NULL_ATTRIBUTES.

 UPDATE

Dans la V2, vous appelez putItem() ou updateItem() explicitement.

CLOBBER or PUT: L'action correspondante dans la version 2 est l'appelputItem(). Il n'existe aucune CLOBBER configuration spécifique.

UPDATE: Correspond à updateItem()

UPDATE_SKIP_NULL_ATTRIBUTES: Correspond àupdateItem(). Contrôlez le comportement des mises à jour à l'aide du paramètre de demande ignoreNulls et de l'DynamoDbUpdateBehaviorannotation/de la balise.

APPEND_SET: Non pris en charge
Type : usine de convertisseurs 
  .withTypeConverterFactory(typeConverterFactory)
convertisseurs de type standard

Fixez le haricot en utilisant

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

Configuration par opération

Dans la version 1, certaines opérations, telles quequery(), sont hautement configurables via un objet « expression » soumis à l'opération. Par exemple :

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

mapper.query(Customer.class, emailBwQueryExpr);

Dans la version 2, au lieu d'utiliser un objet de configuration, vous définissez les paramètres de l'objet de demande à l'aide d'un générateur. Par exemple :

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

customerTable.query(emailBw);

Conditionnels

Dans la version 2, les expressions conditionnelles et filtrantes sont exprimées à l'aide d'un Expression objet qui encapsule la condition et le mappage des noms et des filtres.

Cas d’utilisation Opérations V1 V2
Conditions d'attribut attendues enregistrer (), supprimer (), interroger (), scanner () 
new DynamoDBSaveExpression()
  .withExpected(Collections.singletonMap(
      "otherAttribute", new ExpectedAttributeValue(false)))
  .withConditionalOperator(ConditionalOperator.AND);
 Obsolète ; à utiliser ConditionExpression à la place.
Expression de condition supprimer () 
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();
Expression de filtrage requête (), scan () 
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();
Expression de condition pour la requête requête () 
queryExpression.withKeyConditionExpression()
 
QueryConditional keyEqual = QueryConditional.keyEqualTo(b -> b
                .partitionValue("movie01"));

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

Conversion de type

Convertisseurs par défaut

Dans la version 2, le SDK fournit un ensemble de convertisseurs par défaut pour tous les types courants. Vous pouvez modifier les convertisseurs de type à la fois au niveau global du fournisseur et pour un seul attribut. Vous trouverez une liste des convertisseurs disponibles dans la référence de l'AttributeConverterAPI.

Définir un convertisseur personnalisé pour un attribut

Dans la version 1, vous pouvez annoter une méthode getter @DynamoDBTypeConverted pour spécifier la classe qui effectue la conversion entre le type d'attribut Java et le type d'attribut DynamoDB. Par exemple, une CurrencyFormatConverter conversion entre un Currency type Java et une chaîne DynamoDB peut être appliquée comme indiqué dans l'extrait suivant.

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

L'équivalent V2 de l'extrait précédent est illustré ci-dessous.

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

Dans la version 1, vous pouvez appliquer l'annotation à l'attribut lui-même, à un type ou à une annotation définie par l'utilisateur, tandis que la version 2 prend en charge l'application de l'annotation uniquement au getter.

Ajouter un convertisseur de type, une usine ou un fournisseur

Dans la version 1, vous pouvez fournir votre propre ensemble de convertisseurs de type ou remplacer les types qui vous intéressent en ajoutant une usine de convertisseurs de type à la configuration. La fabrique de convertisseurs de types s'étendDynamoDBTypeConverterFactory, et les remplacements sont effectués en obtenant une référence à l'ensemble par défaut et en l'étendant. L'extrait suivant montre comment procéder.

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

La V2 fournit des fonctionnalités similaires par le biais de l'@DynamoDbBeanannotation. Vous pouvez fournir une commande unique AttributeConverterProvider ou une chaîne de AttributeConverterProvider commandes. Notez que si vous fournissez votre propre chaîne de fournisseurs de convertisseurs d'attributs, vous remplacerez le fournisseur de conversion par défaut et devrez l'inclure dans la chaîne pour utiliser ses convertisseurs d'attributs. 

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

La section de ce guide consacrée à la conversion d'attributs contient un exemple complet pour la version 2.