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
<a name="dynamodb-mapping-api-changes"></a>

## Création d'un client
<a name="dynamodb-mapping-api-changes-client"></a>


****  

| Cas d’utilisation | V1 | V2 | 
| --- | --- | --- | 
|   Instanciation normale  |  <pre>AmazonDynamoDB standardClient = AmazonDynamoDBClientBuilder.standard()<br />    .withCredentials(credentialsProvider)<br />    .withRegion(Regions.US_EAST_1)<br />    .build();<br />DynamoDBMapper mapper = new DynamoDBMapper(standardClient);</pre>  |  <pre>DynamoDbClient standardClient = DynamoDbClient.builder()<br />    .credentialsProvider(ProfileCredentialsProvider.create())<br />    .region(Region.US_EAST_1)<br />    .build();<br />DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()<br />    .dynamoDbClient(standardClient)<br />    .build();</pre>  | 
|   Instanciation minimale  |  <pre>AmazonDynamoDB standardClient = AmazonDynamoDBClientBuilder.standard();<br />DynamoDBMapper mapper = new DynamoDBMapper(standardClient);</pre>  |  <pre>DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.create();</pre>  | 
|   Avec transformateur d'attributs \$1  |  <pre>DynamoDBMapper mapper = new DynamoDBMapper(standardClient, <br />                        attributeTransformerInstance);</pre>  |  <pre>DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()<br />    .dynamoDbClient(standardClient)<br />    .extensions(extensionAInstance, extensionBInstance)<br />    .build();</pre>  | 

\$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
<a name="dynamodb-mapping-api-changes-mapping"></a>

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  |  <pre>@DynamoDBTable(tableName ="Customer")<br />public class Customer {<br />  ...<br />}</pre>  |  <pre>DynamoDbTable<Customer> customerTable = enhancedClient.table("Customer",<br />    TableSchema.fromBean(Customer.class));</pre>  | 
|   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
<a name="dynamodb-mapping-api-changes-tobleops"></a>

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`  |  <pre>mapper.save(item)<br />mapper.save(item, config)<br />mapper.save(item, saveExpression, config)</pre> 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.  |  <pre>table.putItem(putItemRequest)<br />table.putItem(item)<br />table.putItemWithResponse(item) //Returns metadata.<br /><br />updateItem(updateItemRequest)<br />table.updateItem(item)<br />table.updateItemWithResponse(item) //Returns metadata.</pre>  | 
|  Lire un élément d'une table DynamoDB dans un POJO Java **Fonctionnement DynamoDB :** `GetItem`  |  <pre>mapper.load(item)<br />mapper.load(item, config)</pre>  |  <pre>table.getItem(getItemRequest)<br />table.getItem(item)<br />table.getItem(key)<br />table.getItemWithResponse(key) //Returns POJO with metadata.</pre>  | 
|  Supprimer un élément d'une table DynamoDB **Fonctionnement DynamoDB :** `DeleteItem`  |  <pre>mapper.delete(item, deleteExpression, config)</pre>  |  <pre>table.deleteItem(deleteItemRequest)<br />table.deleteItem(item)<br />table.deleteItem(key)</pre>  | 
|  Interrogez une table DynamoDB ou un index secondaire et renvoyez une liste paginée **Fonctionnement DynamoDB :** `Query`  |  <pre>mapper.query(Customer.class, queryExpression)<br />mapper.query(Customer.class, queryExpression, <br />                             mapperConfig)</pre>  |  <pre>table.query(queryRequest)<br />table.query(queryConditional)</pre> 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`  |  <pre>mapper.queryPage(Customer.class, queryExpression)<br />mapper.queryPage(Customer.class, queryExpression, <br />                                 mapperConfig)</pre>  |  <pre>table.query(queryRequest)<br />table.query(queryConditional)</pre> 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`  |  <pre>mapper.scan(Customer.class, scanExpression)<br />mapper.scan(Customer.class, scanExpression, <br />                            mapperConfig)</pre>  |  <pre>table.scan()<br />table.scan(scanRequest)</pre> 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`  |  <pre>mapper.scanPage(Customer.class, scanExpression)<br />mapper.scanPage(Customer.class, scanExpression, <br />                                mapperConfig)</pre>  |  <pre>table.scan()<br />table.scan(scanRequest)</pre> 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`  |  <pre>mapper.batchLoad(Arrays.asList(customer1, <br />                               customer2, <br />                               book1))<br />mapper.batchLoad(itemsToGet) <br />           // itemsToGet: Map<Class<?>, List<KeyPair>></pre>  |  <pre>enhancedClient.batchGetItem(batchGetItemRequest)<br /><br />enhancedClient.batchGetItem(r -> r.readBatches(<br />    ReadBatch.builder(Record1.class)<br />             .mappedTableResource(mappedTable1)<br />             .addGetItem(i -> i.key(k -> k.partitionValue(0)))<br />             .build(),<br />    ReadBatch.builder(Record2.class)<br />             .mappedTableResource(mappedTable2)<br />             .addGetItem(i -> i.key(k -> k.partitionValue(0)))<br />             .build()))<br /><br />// Iterate over pages with lazy loading or over all items <br />   from the same table.</pre>  | 
|  Écrire plusieurs éléments dans plusieurs tables par lot **Fonctionnement DynamoDB :** `BatchWriteItem`  |  <pre>mapper.batchSave(Arrays.asList(customer1, <br />                               customer2, <br />                               book1)) </pre>  |  <pre>enhancedClient.batchWriteItem(batchWriteItemRequest)<br /><br />enhancedClient.batchWriteItem(r -> r.writeBatches(<br />    WriteBatch.builder(Record1.class)<br />             .mappedTableResource(mappedTable1)<br />             .addPutItem(item1)<br />             .build(),<br />    WriteBatch.builder(Record2.class)<br />             .mappedTableResource(mappedTable2)<br />             .addPutItem(item2)<br />             .build()))</pre>  | 
|  Supprimer plusieurs éléments de plusieurs tables par lot **Fonctionnement DynamoDB :** `BatchWriteItem`  |  <pre>mapper.batchDelete(Arrays.asList(customer1, <br />                                 customer2, <br />                                 book1)) </pre>  |  <pre>enhancedClient.batchWriteItem(r -> r.writeBatches(<br />    WriteBatch.builder(Record1.class)<br />             .mappedTableResource(mappedTable1)<br />             .addDeleteItem(item1key)<br />             .build(),<br />    WriteBatch.builder(Record2.class)<br />             .mappedTableResource(mappedTable2)<br />             .addDeleteItem(item2key)<br />             .build()))</pre>  | 
|  Écrivez/supprimez plusieurs éléments dans un lot **Fonctionnement DynamoDB :** `BatchWriteItem`  |  <pre>mapper.batchWrite(Arrays.asList(customer1, book1), <br />                  Arrays.asList(customer2)) </pre>  |  <pre>enhancedClient.batchWriteItem(r -> r.writeBatches(<br />    WriteBatch.builder(Record1.class)<br />             .mappedTableResource(mappedTable1)<br />             .addPutItem(item1)<br />             .build(),<br />    WriteBatch.builder(Record2.class)<br />             .mappedTableResource(mappedTable2)<br />             .addDeleteItem(item2key)<br />             .build()))</pre>  | 
|  Réaliser une écriture transactionnelle **Fonctionnement DynamoDB :** `TransactWriteItems`  |  <pre>mapper.transactionWrite(transactionWriteRequest)</pre>  |  <pre>enhancedClient.transactWriteItems(transasctWriteItemsRequest)</pre>  | 
|  Réaliser une lecture transactionnelle **Fonctionnement DynamoDB :** `TransactGetItems`  |  <pre>mapper.transactionLoad(transactionLoadRequest)</pre>  |  <pre>enhancedClient.transactGetItems(transactGetItemsRequest) </pre>  | 
|  Obtenir le nombre d'éléments correspondants d'une requête **Fonctionnement DynamoDB** : avec `Query` `Select.COUNT`  |  <pre>mapper.count(Customer.class, queryExpression)</pre>  |  <pre>// Get the count from query results.<br />PageIterable<Customer> pageIterable =<br />    customerTable.query(QueryEnhancedRequest.builder()<br />        .queryConditional(queryConditional)<br />        .select(Select.COUNT)<br />        .build());<br />Iterator<Page<Customer>> iterator = pageIterable.iterator();<br />Page<Customer> page = iterator.next();<br />int count = page.count();<br /><br />// For a more concise approach, you can chain the method calls:<br />int count = customerTable.query(QueryEnhancedRequest.builder()<br />                .queryConditional(queryConditional)<br />                .select(Select.COUNT)<br />                .build())<br />            .iterator().next().count();</pre>  | 
|  Obtenez le nombre d'éléments correspondants d'un scan **Fonctionnement DynamoDB** : avec `Scan` `Select.COUNT`  |  <pre>mapper.count(Customer.class, scanExpression)</pre>  |  <pre>// Get the count from scan results.<br />PageIterable<Customer> pageIterable =<br />    customerTable.scan(ScanEnhancedRequest.builder()<br />        .filterExpression(filterExpression)<br />        .select(Select.COUNT)<br />        .build());<br />Iterator<Page<Customer>> iterator = pageIterable.iterator();<br />Page<Customer> page = iterator.next();<br />int count = page.count();<br /><br />// For a more concise approach, you can chain the method calls:<br />int count = customerTable.scan(ScanEnhancedRequest.builder()<br />                .filterExpression(filterExpression)<br />                .select(Select.COUNT)<br />                .build())<br />            .iterator().next().count();</pre>  | 
|  Créez une table dans DynamoDB correspondant à la classe POJO **Fonctionnement DynamoDB :** `CreateTable`  |  <pre>mapper.generateCreateTableRequest(Customer.class)</pre> 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.  |  <pre>table.createTable(createTableRequest)<br /><br />table.createTable(r -> r.provisionedThroughput(defaultThroughput())<br />    .globalSecondaryIndices(<br />        EnhancedGlobalSecondaryIndex.builder()<br />            .indexName("gsi_1")<br />            .projection(p -> p.projectionType(ProjectionType.ALL))<br />            .provisionedThroughput(defaultThroughput())<br />            .build()));</pre>  | 
|  Effectuer un scan parallèle dans DynamoDB **Fonctionnement `Scan` DynamoDB** : avec et paramètres `Segment` `TotalSegments`  |  <pre>mapper.parallelScan(Customer.class, <br />                    scanExpression, <br />                    numTotalSegments)</pre>  |  Les utilisateurs sont tenus de gérer les threads de travail et d'appeler `scan` pour chaque segment : <pre>table.scan(r -> r.segment(0).totalSegments(5))</pre>  | 
|  Intégrez Amazon S3 à DynamoDB pour stocker des liens S3 intelligents  |  <pre>mapper.createS3Link(bucket, key)<br />mapper.getS3ClientCache()</pre>  |  Non pris en charge car il associe Amazon S3 et DynamoDB.  | 

## Classes et propriétés de cartes
<a name="dynamodb-mapping-schemas"></a>

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
<a name="dynamodb-mapping-schemas-annos"></a>

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 |  <pre>@DynamoDBTable (tableName ="CustomerTable")</pre>  | <pre>@DynamoDbBean<br />@DynamoDbBean(converterProviders = {...})</pre>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  |  <pre>@DynamoDBAttribute(attributeName = "customerName")</pre>  |  <pre>@DynamoDbAttribute("customerName") </pre>  | 
| Désigner un membre de la classe est hash/partition essentiel |  <pre>@DynamoDBHashKey </pre>  |  <pre>@DynamoDbPartitionKey</pre>  | 
| Désigner un membre de la classe est range/sort essentiel |  <pre>@DynamoDBRangeKey </pre>  |  <pre>@DynamoDbSortKey </pre>  | 
| Désigner un membre de classe comme clé de hachage ou de partition d'index secondaire |  <pre>@DynamoDBIndexHashKey </pre>  |  <pre>@DynamoDbSecondaryPartitionKey </pre>  | 
| Désigner un membre de classe comme plage d'index secondaire/clé de tri |  <pre>@DynamoDBIndexRangeKey </pre>  |  <pre>@DynamoDbSecondarySortKey </pre>  | 
| Ignorer ce membre de classe lors du mappage vers une table |  <pre>@DynamoDBIgnore </pre>  |  <pre>@DynamoDbIgnore</pre>  | 
| Désigner un membre de classe comme attribut clé UUID généré automatiquement |  <pre>@DynamoDBAutoGeneratedKey</pre>  |  <pre>@DynamoDbAutoGeneratedUuid </pre> 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 |  <pre>@DynamoDBAutoGeneratedTimestamp</pre>  |  <pre>@DynamoDbAutoGeneratedTimestampAttribute</pre> 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é |  <pre>@DynamoDBVersionAttribute</pre>  |  <pre>@DynamoDbVersionAttribute</pre> L'extension qui fournit cela est chargée automatiquement.  | 
| Désigner un membre de la classe comme nécessitant une conversion personnalisée |  <pre>@DynamoDBTypeConverted</pre>  |  <pre>@DynamoDbConvertedBy</pre>  | 
| Désignez un membre de classe à stocker sous un autre type d'attribut |  <pre>@DynamoDBTyped(<DynamoDBAttributeType>)</pre>  |  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  |  <pre>@DynamoDBDocument</pre>  | 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
<a name="dynamodb-mapping-schemas-annos-v2-addnl"></a>


| 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 |  <pre>@DynamoDbIgnoreNulls</pre>  | 
| Désignez un membre de classe comme un objet vide si tous les attributs sont nuls | N/A |  <pre>@DynamoDbPreserveEmptyObject</pre>  | 
| Désigner une action de mise à jour spéciale pour un membre du groupe | N/A |  <pre>@DynamoDbUpdateBehavior</pre>  | 
| Désigner une classe immuable | N/A |  <pre>@DynamoDbImmutable</pre>  | 
| Désigner un membre de classe comme attribut de compteur auto-incrémenté | N/A |  <pre>@DynamoDbAtomicCounter</pre> L'extension qui fournit cette fonctionnalité est chargée automatiquement.  | 

## Configuration
<a name="dynamodb-mapping-configuration"></a>

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 | 
| --- | --- | --- | --- | 
|  |  <pre>DynamoDBMapperConfig.builder()</pre>  |  |  | 
| Stratégie de load/write nouvelle tentative par lots |  <pre>  .withBatchLoadRetryStrategy(loadRetryStrategy)</pre> <pre>  .withBatchWriteRetryStrategy(writeRetryStrategy)</pre>  | 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 |  <pre>  .withConsistentReads(CONSISTENT)</pre>  | 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 |  <pre>  .withConversionSchema(conversionSchema)</pre> 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 |  <pre>  .withObjectTableNameResolver()<br />  .withTableNameOverride() <br />  .withTableNameResolver()</pre> 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 |  <pre>  .withPaginationLoadingStrategy(strategy)</pre>  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 |  <pre>  .withRequestMetricCollector(collector)</pre>  | null | metricPublisher()À utiliser ClientOverrideConfiguration lors de la création du client DynamoDB standard.  | 
| Enregistrer le comportement |  <pre>  .withSaveBehavior(SaveBehavior.CLOBBER) </pre> 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 |  <pre>  .withTypeConverterFactory(typeConverterFactory) </pre>  | convertisseurs de type standard |  Fixez le haricot en utilisant <pre>@DynamoDbBean(converterProviders = {ConverterProvider.class, <br />        DefaultAttributeConverterProvider.class})</pre>  | 

### Configuration par opération
<a name="dynamodb-mapping-configuration-per-op"></a>

Dans la version 1, certaines opérations, telles que`query()`, 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
<a name="dynamodb-mapping-conditionals"></a>

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 () |  <pre>new DynamoDBSaveExpression()<br />  .withExpected(Collections.singletonMap(<br />      "otherAttribute", new ExpectedAttributeValue(false)))<br />  .withConditionalOperator(ConditionalOperator.AND);</pre>  | Obsolète ; à utiliser ConditionExpression à la place. | 
| Expression de condition | supprimer () |  <pre>deleteExpression.setConditionExpression("zipcode = :zipcode")<br />deleteExpression.setExpressionAttributeValues(...)<br /></pre>  |  <pre>Expression conditionExpression =<br />    Expression.builder()<br />        .expression("#key = :value OR #key1 = :value1")<br />        .putExpressionName("#key", "attribute")<br />        .putExpressionName("#key1", "attribute3")<br />        .putExpressionValue(":value", AttributeValues.stringValue("wrong"))<br />        .putExpressionValue(":value1", AttributeValues.stringValue("three"))<br />        .build();<br /><br />DeleteItemEnhancedRequest request = DeleteItemEnhancedRequest.builder()<br />         .conditionExpression(conditionExpression).build();</pre>  | 
| Expression de filtre | requête (), scan () |  <pre>scanExpression<br />  .withFilterExpression("#statename = :state")<br />  .withExpressionAttributeValues(attributeValueMapBuilder.build())<br />  .withExpressionAttributeNames(attributeNameMapBuilder.build())<br /></pre>  |  <pre>Map<String, AttributeValue> values = singletonMap(":key", stringValue("value"));<br />Expression filterExpression =<br />    Expression.builder()<br />        .expression("name = :key")<br />        .expressionValues(values)<br />        .build();<br />QueryEnhancedRequest request = QueryEnhancedRequest.builder()<br />    .filterExpression(filterExpression).build();<br /></pre>  | 
| Expression de condition pour la requête | requête () |  <pre>queryExpression.withKeyConditionExpression()</pre>  |  <pre>QueryConditional keyEqual = QueryConditional.keyEqualTo(b -> b<br />                .partitionValue("movie01"));<br /><br />QueryEnhancedRequest tableQuery = QueryEnhancedRequest.builder()<br />                .queryConditional(keyEqual)<br />                .build();</pre>  | 

## Conversion de type
<a name="dynamodb-mapping-type-conv"></a>

### Convertisseurs par défaut
<a name="dynamodb-mapping-type-conv-defaults"></a>

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
<a name="dynamodb-mapping-type-conv-anno"></a>

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
<a name="dynamodb-mapping-type-conv-factory"></a>

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<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'`@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.