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 à l'utilisation de DynamoDB entre la version 1 et la version 2 du AWS SDK pour Java **Topics** + [Différences entre les versions 1 et 2 de l'API de mappage DynamoDB AWS SDK pour Java](ddb-mapping.md) + [Différences entre l'API des documents entre la version 1 et la version 2 du AWS SDK pour Java](dynamodb-mapping-document-api.md) + [Migration de bibliothèques de chiffrement](ddb-encryption-lib-migrate.md) # Différences entre les versions 1 et 2 de l'API de mappage DynamoDB AWS SDK pour Java Le APIs mappage DynamoDB a changé de manière significative entre la version 1 et la version 2 du. AWS SDK pour Java Dans la version 1, vous utilisez le `DynamoDBMapper` pour travailler avec Java POJOs. Dans la version 2, vous utilisez le `DynamoDbEnhancedClient` avec des noms de méthodes mis à jour, des options de définition de schéma améliorées et une sécurité de type améliorée. Les principales différences sont les suivantes : + Nouveaux noms de méthodes (par exemple `getItem` au lieu de`load`) + Création d'un schéma de table explicite + Support intégré pour les opérations synchrones et asynchrones + Changements dans la façon dont les chaînes vides et la configuration sont gérées Cette section couvre les modifications de l'API de mappage, les différences d'annotations, les mises à jour de configuration et les conseils de migration pour vous aider à passer de la version v1 `DynamoDBMapper` à la version v2`DynamoDbEnhancedClient`. **Contents** + [Modifications importantes apportées aux bibliothèques de mappage de la version 1 à la version 2 du SDK for Java](dynamodb-mapping-high-level.md) + [Différences de dépendance à l'importation](dynamodb-mapping-high-level.md#dynamodb-mapping-deps) + [Modifications apportées au APIs mappage DynamoDB entre les versions 1 et 2 du SDK for Java](dynamodb-mapping-api-changes.md) + [Création d'un client](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-client) + [Établir le mappage vers la table/l'index DynamoDB](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-mapping) + [Opérations de table](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-tobleops) + [Classes et propriétés de cartes](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas) + [Annotations sur les haricots](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas-annos) + [Annotations supplémentaires V2](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas-annos-v2-addnl) + [Configuration](dynamodb-mapping-api-changes.md#dynamodb-mapping-configuration) + [Configuration par opération](dynamodb-mapping-api-changes.md#dynamodb-mapping-configuration-per-op) + [Conditionnels](dynamodb-mapping-api-changes.md#dynamodb-mapping-conditionals) + [Conversion de type](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv) + [Convertisseurs par défaut](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-defaults) + [Définir un convertisseur personnalisé pour un attribut](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-anno) + [Ajouter un convertisseur de type, une usine ou un fournisseur](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-factory) + [Différences de gestion des chaînes entre la version 1 et la version 2 du SDK for Java](dynamodb-migration-string-handling.md) + [Différences de verrouillage optimistes entre la version 1 et la version 2 du SDK for Java](dynamodb-migrate-optimstic-locking.md) + [Différences entre les versions 1 et 2 du SDK for Java avec Fluent Setters](dynamodb-migrate-fluent-setters.md) # Modifications importantes apportées aux bibliothèques de mappage de la version 1 à la version 2 du SDK for Java Les noms du client de mappage dans chaque bibliothèque diffèrent dans les versions V1 et V2 : + V1 - Dynamo DBMapper + V2 - Client DynamoDB amélioré Vous interagissez avec les deux bibliothèques de la même manière : vous instanciez une, mapper/client puis vous fournissez un POJO Java pour lire et écrire ces APIs éléments dans des tables DynamoDB. Les deux bibliothèques proposent également des annotations pour la classe du POJO afin d'indiquer comment le client gère le POJO. Les différences notables lorsque vous passez à la V2 incluent : + Les versions V2 et V1 utilisent des noms de méthode différents pour les opérations DynamoDB de bas niveau. Par exemple : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-java/latest/developer-guide/dynamodb-mapping-high-level.html) + La V2 propose plusieurs méthodes pour définir des schémas de tables et les POJOs mapper à des tables. Vous pouvez choisir d'utiliser des annotations ou un schéma généré à partir du code à l'aide d'un générateur. La V2 propose également des versions mutables et immuables des schémas. + Avec la V2, vous créez spécifiquement le schéma de table comme l'une des premières étapes, tandis que dans la V1, le schéma de table est déduit de la classe annotée selon les besoins. + La V2 inclut le [client Document API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html) dans l'API client améliorée, tandis que la V1 utilise une [API distincte](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/DynamoDB.html). + Tous APIs sont disponibles en versions synchrone et asynchrone dans la V2. Consultez la section sur le [mappage DynamoDB](dynamodb-enhanced-client.md) de ce guide pour obtenir des informations plus détaillées sur le client amélioré V2. ## Différences de dépendance à l'importation | 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 [Dernière version](https://central.sonatype.com/artifact/software.amazon.awssdk/bom). Dans la version 1, une seule dépendance inclut à la fois l'API DynamoDB de bas niveau et mapping/document l'API, tandis que dans la version 2, vous utilisez la dépendance d'artefact pour accéder à `dynamodb-enhanced` l'API. mapping/document Le `dynamodb-enhanced` module contient une dépendance transitive vis-à-vis du module de bas niveau. `dynamodb` # 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 \$1 | 
DynamoDBMapper mapper = new DynamoDBMapper(standardClient, 
                        attributeTransformerInstance);
| 
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
    .dynamoDbClient(standardClient)
    .extensions(extensionAInstance, extensionBInstance)
    .build();
| \$1 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](ddb-en-client-extensions.md) 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 customerTable = enhancedClient.table("Customer",
    TableSchema.fromBean(Customer.class));
| | Mapper vers un index secondaire DynamoDB | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) La section du Guide du développeur DynamoDB qui [décrit la méthode `query` V1](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html#DynamoDBMapper.Methods.query) présente un exemple complet. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) La [Utiliser des indices secondaires](ddb-en-client-use-secindex.md) 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'`DynamoDbTable`instance, 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 que`customer1`. 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'`DynamoDbTable`instance. 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` et`SaveBehavior.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, 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.
| | É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 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();
| | 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 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();
| | 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](ddb-en-client-adv-features.md#ddb-en-client-adv-features-schm-overview) 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\$1table() 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()
| 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` ou`AttributeConverterProvider`. Voir [Conversion des attributs de contrôle](ddb-en-client-adv-features-conversion.md) 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 :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) | ### 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 de`DynamoDBMapperConfig`. 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](retry-strategy.md) 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\$1COMPATIBLE | 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 : LAZY\$1`LOADING`, ou `EAGER_LOADING` `ITERATION_ONLY` | LAZY\$1LOADING | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) | | 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``CLOBBER`,`PUT`,`APPEND_SET`, ou`UPDATE_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'appel`putItem()`. 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'`DynamoDbUpdateBehavior`annotation/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 que`query()`, sont hautement configurables via un objet « expression » soumis à l'opération. Par exemple : ``` DynamoDBQueryExpression emailBwQueryExpr = new DynamoDBQueryExpression() .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 filtre | requête (), scan () | 
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();
| | 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'[AttributeConverter](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverter.html)API. ### 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'étend`DynamoDBTypeConverterFactory`, 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() { @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'`@DynamoDbBean`annotation. 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](ddb-en-client-adv-features-conversion.md#ddb-en-client-adv-features-conversion-example) contient un exemple complet pour la version 2. # Différences de gestion des chaînes entre la version 1 et la version 2 du SDK for Java Les versions V1 et V2 traitent différemment les chaînes vides lors de l'envoi de données vers DynamoDB : + **V1** : Convertit les chaînes vides en valeurs nulles avant de les envoyer à DynamoDB (aucun attribut n'est donc créé) + **V2** : envoie des chaînes vides sous forme de valeurs de chaînes vides réelles à DynamoDB **Important** Après la migration vers la version V2, si vous ne souhaitez pas que des chaînes vides soient stockées dans DynamoDB, vous devez implémenter des convertisseurs personnalisés. Sans convertisseurs personnalisés, la V2 stocke les chaînes vides en tant qu'attributs de chaînes vides réels dans vos éléments DynamoDB, ce qui est différent du comportement de la V1 qui consiste à omettre complètement ces attributs. **Example convertisseur personnalisé pour V2 qui convertit un attribut de chaîne vide en null** ``` /** * 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; } } ``` # Différences de verrouillage optimistes entre la version 1 et la version 2 du SDK for Java Les versions V1 et V2 implémentent un verrouillage optimiste avec une annotation d'attribut qui marque une propriété de votre classe de bean pour stocker le numéro de version. **Différences entre les comportements de verrouillage optimistes** | | V1 | V2 | | --- | --- | --- | | Annotation de classe Bean | @DynamoDBVersionAttribute | @DynamoDbVersionAttribute(notez que la V2 utilise un « b » minuscule) | | Sauvegarde initiale | Attribut du numéro de version défini sur 1. | La valeur de départ de l'attribut de version défini avec`@DynamoDbVersionAttribute(startAt = X)`. La valeur par défaut est 0. | | Mettre à jour | L'attribut du numéro de version est incrémenté de 1 si le contrôle conditionnel vérifie que le numéro de version de l'objet mis à jour correspond au numéro de la base de données. | L'attribut du numéro de version est incrémenté si le contrôle conditionnel vérifie que le numéro de version de l'objet mis à jour correspond au numéro de la base de données. L'attribut du numéro de version incrémenté par l'`incrementBy`option définie avec`@DynamoDbVersionAttribute(incrementBy = X)`. La valeur par défaut est 1. | | Suppression | DynamoDBMapperajoute une vérification conditionnelle pour vérifier que le numéro de version de l'objet supprimé correspond au numéro de version de la base de données. | La V2 n'ajoute pas automatiquement de conditions pour les opérations de suppression. Vous devez ajouter des expressions de condition manuellement si vous souhaitez contrôler le comportement de suppression. Dans l'exemple suivant, `recordVersion` il s'agit de l'attribut version du bean. 
// 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);
| | Rédaction transactionnelle avec vérification des conditions | Vous ne pouvez pas utiliser une classe de bean annotée @DynamoDBVersionAttribute dans une addConditionCheck méthode. | Vous pouvez utiliser une classe de bean avec l'@DynamoDbVersionAttributeannotation dans une addConditionCheck méthode de création pour une transactWriteItems demande. | | Désactiver | Désactivez le verrouillage optimiste en modifiant la valeur de l' DynamoDBMapperConfig.SaveBehaviorénumération de UPDATE àCLOBBER. | N'utilisez pas l'`@DynamoDbVersionAttribute`annotation. | # Différences entre les versions 1 et 2 du SDK for Java avec Fluent Setters Vous pouvez l'utiliser POJOs avec des setters fluides dans l'API de mappage DynamoDB pour la version V1 et avec la version V2 depuis la version 2.30.29. Par exemple, le POJO suivant renvoie une `Customer` instance à partir de la `setName` méthode : ``` // 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; } } ``` Toutefois, si vous utilisez une version de V2 antérieure à la version 2.30.29, `setName` renvoie une `Customer` instance avec une `name` valeur de. `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. } } ``` # Différences entre l'API des documents entre la version 1 et la version 2 du AWS SDK pour Java L'API Document permet de travailler avec des documents de style JSON sous forme d'éléments uniques dans une table DynamoDB. L'API de document V1 possède une API correspondante dans la version V2, mais au lieu d'utiliser un client distinct pour l'API de document comme dans la version V1, la version V2 intègre les fonctionnalités de l'API de document dans le client amélioré DynamoDB. Dans la version 1, la [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)classe représente un enregistrement non structuré d'une table DynamoDB. Dans la version 2, un enregistrement non structuré est représenté par une instance de la [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)classe. Notez que les clés primaires sont définies dans le schéma de table pour la version 2 et sur l'élément lui-même dans la version 1. Le tableau ci-dessous compare les différences entre le document APIs de la version 1 et de la version 2. | Cas d’utilisation | V1 | V2 | | --- |--- |--- | | Création d'un client de documents | 
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.
| | Référencer un tableau | 
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** | | --- | | Mettre un élément | 
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);
| | Obtenir un élément | 
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** | | --- | | Convertir une structure JSON pour l'utiliser avec l'API Document | 
// 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());
| | Mettez JSON | 
documentTable.putItem(item)
| 
documentTable.putItem(document);
| | Lire le JSON | 
GetItemOutcome outcome = //Get item.
String jsonPerson = outcome.getItem().toJSON();
| 
String jsonPerson = documentTable.getItem(Key.builder()
        .partitionValue(50).build())
        .fromJson();
| ## Référence de l'API et guides pour le document APIs | | V1 | V2 | | --- | --- | --- | | Référence des API | [Référence d’API](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/package-summary.html) | [Référence d’API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/package-summary.html) | | Guide de documentation | [Guide du développeur Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/JavaDocumentAPIItemCRUD.html) | [API de documents améliorée](ddb-en-client-doc-api.md) (ce guide) | # API Xpec V1 vers API d'expressions V2 L'API Expression Specification (Xspec) disponible dans la version 1 qui permet de créer des expressions destinées à fonctionner avec des données orientées document n'est pas disponible dans la version 2. La V2 utilise l'API Expression, qui fonctionne à la fois avec des données orientées document et des données object-to-item mappées. **** | | V1 | V2 | | --- | --- | --- | | Nom de l’API | API de spécification d'expression (Xspec) | API d'expression | | Fonctionne avec | [Méthodes de la classe Document API [Table](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Table.html), telles que [UpdateItem et 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-) | Les deux APIs versions du client DynamoDB Enhanced : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-java/latest/developer-guide/ddb-v1-xspec-migrate.html) Pour les deux types de APIs, après avoir acquis une [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)instance : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-java/latest/developer-guide/ddb-v1-xspec-migrate.html) vous utilisez des expressions dans `DynamoDbTable` les méthodes lorsque vous créez des objets de demande. Par exemple, dans la `filterExpression` méthode du [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) | | Ressources | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-java/latest/developer-guide/ddb-v1-xspec-migrate.html) | [Informations sur les expressions](ddb-en-client-expressions.md) contenues dans ce guide du développeur Java | # Migration de bibliothèques de chiffrement Pour plus d'informations sur la migration de la bibliothèque de chiffrement pour que DynamoDB fonctionne avec la version V2 du SDK Java, consultez le guide du développeur du client de chiffrement Amazon [DynamoDB](https://docs.aws.amazon.com/database-encryption-sdk/latest/devguide/ddb-java-migrate.html).