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.
# Classe Dynamo DBMapper
La classe `DynamoDBMapper` est le point d’entrée d’Amazon DynamoDB. Elle donne accès à un point de terminaison DynamoDB et vous permet d’accéder à vos données dans différentes tables. Elle vous permet également d’effectuer diverses opérations de création, de lecture, de mise à jour et de suppression (opérations CRUD) sur des éléments, ainsi que d’exécuter des requêtes et analyses sur des tables. Cette classe fournit les méthodes suivantes utiliser DynamoDB.
*Pour consulter la documentation Javadoc correspondante, consultez [Dynamo DBMapper](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html) dans le manuel de référence des AWS SDK pour Java API.*
**Topics**
+ [enregistrer](#DynamoDBMapper.Methods.save)
+ [charge](#DynamoDBMapper.Methods.load)
+ [supprimer](#DynamoDBMapper.Methods.delete)
+ [query](#DynamoDBMapper.Methods.query)
+ [queryPage](#DynamoDBMapper.Methods.queryPage)
+ [scan](#DynamoDBMapper.Methods.scan)
+ [scanPage](#DynamoDBMapper.Methods.scanPage)
+ [parallelScan](#DynamoDBMapper.Methods.parallelScan)
+ [batchSave](#DynamoDBMapper.Methods.batchSave)
+ [batchLoad](#DynamoDBMapper.Methods.batchLoad)
+ [batchDelete](#DynamoDBMapper.Methods.batchDelete)
+ [batchWrite](#DynamoDBMapper.Methods.batchWrite)
+ [transactionWrite](#DynamoDBMapper.Methods.transactionWrite)
+ [transactionLoad](#DynamoDBMapper.Methods.transactionLoad)
+ [count](#DynamoDBMapper.Methods.count)
+ [generateCreateTableDemande](#DynamoDBMapper.Methods.generateCreateTableRequest)
+ [createS3Link](#DynamoDBMapper.Methods.createS3Link)
+ [Obtient S3 ClientCache](#DynamoDBMapper.Methods.getS3ClientCache)
## enregistrer
Enregistre l’objet spécifié dans la table. L’objet que vous voulez enregistrer est le seul paramètre requis pour cette méthode. Vous pouvez fournir des paramètres de configuration facultatifs en utilisant l’objet `DynamoDBMapperConfig`.
Si un élément qui a la même clé primaire n’existe pas, cette méthode crée un nouvel élément dans la table. Si un élément qui a la même clé primaire existe, elle met à jour l’élément existant. Si la clé de partition et la clé de tri sont de type String, et annotées avec `@DynamoDBAutoGeneratedKey`, alors elles reçoivent un identificateur unique universel (UUID) aléatoire en cas de défaut d’initialisation. Les champs de version qui sont annotés avec `@DynamoDBVersionAttribute` seront incrémentés d’un niveau. En outre, si un champ de version est mis à jour ou généré par une clé, l’objet adopté est mis à jour à la suite de l’opération.
Par défaut, seuls les attributs correspondants aux propriétés de classes mappées sont mis à jour. Tous les attributs supplémentaires existant sur un élément ne sont pas affectés. Toutefois, si vous spécifiez `SaveBehavior.CLOBBER`, vous pouvez forcer le remplacement complet de l’élément.
```
DynamoDBMapperConfig config = DynamoDBMapperConfig.builder()
.withSaveBehavior(DynamoDBMapperConfig.SaveBehavior.CLOBBER).build();
mapper.save(item, config);
```
Si vous avez activé le contrôle de version, alors les versions d’élément côté client et côté serveur doivent correspondre. Toutefois, la version n’a pas besoin de correspondre si l’option `SaveBehavior.CLOBBER` est utilisée. Pour plus d’informations sur la gestion des versions, consultez [DynamoDB et verrouillage optimiste avec numéro de version](DynamoDBMapper.OptimisticLocking.md).
## charge
Récupère un élément dans une table. Vous devez fournir la clé primaire de l’élément que vous voulez récupérer. Vous pouvez fournir des paramètres de configuration facultatifs en utilisant l’objet `DynamoDBMapperConfig`. Par exemple, vous pouvez demander le cas échéant des lectures fortement cohérentes afin de garantir que cette méthode récupère uniquement les dernières valeurs d’élément comme indiqué dans l’instruction Java suivante.
```
DynamoDBMapperConfig config = DynamoDBMapperConfig.builder()
.withConsistentReads(DynamoDBMapperConfig.ConsistentReads.CONSISTENT).build();
CatalogItem item = mapper.load(CatalogItem.class, item.getId(), config);
```
Par défaut, DynamoDB renvoie l’élément ayant des valeurs éventuellement cohérentes. Pour plus d’informations sur le modèle de cohérence éventuelle de DynamoDB, consultez [Cohérence en lecture DynamoDB](HowItWorks.ReadConsistency.md).
## supprimer
Supprime un élément de la table. Vous devez communiquer une instance d’objet de la classe mappée.
Si vous avez activé le contrôle de version, alors les versions d’élément côté client et côté serveur doivent correspondre. Toutefois, la version n’a pas besoin de correspondre si l’option `SaveBehavior.CLOBBER` est utilisée. Pour plus d’informations sur la gestion des versions, consultez [DynamoDB et verrouillage optimiste avec numéro de version](DynamoDBMapper.OptimisticLocking.md).
## query
Interroge une table ou un index secondaire.
Supposons que vous ayez une table, `Reply`, qui stocke des réponses de threads de forum. Chaque objet thread peut avoir zéro ou plusieurs réponses. La clé primaire de la table `Reply` se compose des champs `Id` et `ReplyDateTime`, où `Id` est la clé de partition et `ReplyDateTime` est la clé de tri de la clé primaire.
```
Reply ( Id, ReplyDateTime, ... )
```
Supposons que vous ayez créé un mappage entre une classe `Reply` et la table `Reply` correspondante dans DynamoDB. L’exemple de code Java suivant utilise `DynamoDBMapper` pour trouver toutes les réponses au cours des deux dernières semaines pour un objet thread spécifique.
**Example**
```
String forumName = "&DDB;";
String forumSubject = "&DDB; Thread 1";
String partitionKey = forumName + "#" + forumSubject;
long twoWeeksAgoMilli = (new Date()).getTime() - (14L*24L*60L*60L*1000L);
Date twoWeeksAgo = new Date();
twoWeeksAgo.setTime(twoWeeksAgoMilli);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
String twoWeeksAgoStr = df.format(twoWeeksAgo);
Map eav = new HashMap();
eav.put(":v1", new AttributeValue().withS(partitionKey));
eav.put(":v2",new AttributeValue().withS(twoWeeksAgoStr.toString()));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withKeyConditionExpression("Id = :v1 and ReplyDateTime > :v2")
.withExpressionAttributeValues(eav);
List latestReplies = mapper.query(Reply.class, queryExpression);
```
La requête renvoie un ensemble d’objets `Reply`.
Par défaut, la méthode `query` renvoie une collection « avec chargement différé ». Elle ne renvoie initialement qu’une seule page de résultats puis effectue un appel de service pour la page suivante si nécessaire. Pour obtenir tous les éléments correspondants, itérez sur la collection `latestReplies`.
Notez que l’appel de la méthode `size()` sur la collection chargera chaque résultat afin de fournir un décompte précis. Cela peut entraîner la consommation d’un débit alloué élevé et, sur une très grande table, pourrait même épuiser toute la mémoire de votre JVM.
Pour interroger un index, vous devez tout d’abord affecter un modèle à l’index en tant que classe d’outil de mappage. Supposons que la `Reply` table possède un index secondaire global nommé *PostedBy-Message-Index*. La clé de partition de cet index est `PostedBy`, et la clé de tri est `Message`. La définition de classe d’un élément dans l’index se présenterait comme suit :
```
@DynamoDBTable(tableName="Reply")
public class PostedByMessage {
private String postedBy;
private String message;
@DynamoDBIndexHashKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "PostedBy")
public String getPostedBy() { return postedBy; }
public void setPostedBy(String postedBy) { this.postedBy = postedBy; }
@DynamoDBIndexRangeKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "Message")
public String getMessage() { return message; }
public void setMessage(String message) { this.message = message; }
// Additional properties go here.
}
```
L’annotation `@DynamoDBTable` indique que cet index est associé à la table `Reply`. L'`@DynamoDBIndexHashKey`annotation indique la clé de partition (*PostedBy*) de l'index et `@DynamoDBIndexRangeKey` la clé de tri (*Message*) de l'index.
Vous pouvez maintenant utiliser `DynamoDBMapper` pour interroger l’index, en récupérant un sous-ensemble de messages qui ont été publiés par un utilisateur particulier. Il n’est pas nécessaire de spécifier le nom de l’index si vous n’avez pas de mappages contradictoires entre les tables et les index et si les mappages sont déjà établis dans l’outil de mappage. L’outil de mappage déduit en fonction de la clé primaire et de la clé de tri. L’exemple de code suivant interroge un index secondaire global. Étant donné que les index globaux secondaires (gsi) prennent en charge des lectures cohérentes à terme, mais pas des lectures fortement cohérentes, vous devez spécifier `withConsistentRead(false)`.
```
HashMap eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("User A"));
eav.put(":v2", new AttributeValue().withS("DynamoDB"));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false)
.withKeyConditionExpression("PostedBy = :v1 and begins_with(Message, :v2)")
.withExpressionAttributeValues(eav);
List iList = mapper.query(PostedByMessage.class, queryExpression);
```
La requête renvoie un ensemble d’objets `PostedByMessage`.
## queryPage
Interroge une table ou un index secondaire, et renvoie une seule page de résultats correspondants. Comme avec la méthode `query`, vous devez spécifier une valeur de clé de partition et un filtre de requête qui est appliqué à l’attribut de clé de tri. Toutefois, `queryPage` renvoie uniquement la première « page » de données, c’est-à-dire la quantité de données pouvant tenir dans 1 Mo
## scan
Analyse une table ou un index secondaire entiers. Vous pouvez spécifier le cas échéant un `FilterExpression` pour filtrer l’ensemble de résultats.
Supposons que vous ayez une table, `Reply`, qui stocke des réponses de threads de forum. Chaque objet thread peut avoir zéro ou plusieurs réponses. La clé primaire de la table `Reply` se compose des champs `Id` et `ReplyDateTime`, où `Id` est la clé de partition et `ReplyDateTime` est la clé de tri de la clé primaire.
```
Reply ( Id, ReplyDateTime, ... )
```
Si vous avez mappé une classe Java à la table `Reply`, vous pouvez utiliser le `DynamoDBMapper` pour analyser la table. Par exemple, le code Java suivant analyse l’ensemble de la table `Reply`, en renvoyant uniquement les réponses pour une année donnée.
**Example**
```
HashMap eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("2015"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("begins_with(ReplyDateTime,:v1)")
.withExpressionAttributeValues(eav);
List replies = mapper.scan(Reply.class, scanExpression);
```
Par défaut, la méthode `scan` renvoie une collection « avec chargement différé ». Elle ne renvoie initialement qu’une seule page de résultats puis effectue un appel de service pour la page suivante si nécessaire. Pour obtenir tous les éléments correspondants, itérez sur la collection `replies`.
Notez que l’appel de la méthode `size()` sur la collection chargera chaque résultat afin de fournir un décompte précis. Cela peut entraîner la consommation d’un débit alloué élevé et, sur une très grande table, pourrait même épuiser toute la mémoire de votre JVM.
Pour analyser un index, vous devez tout d’abord affecter un modèle à l’index en tant que classe d’outil de mappage. Supposons que la table `Reply` a un index secondaire global nommé `PostedBy-Message-Index`. La clé de partition de cet index est `PostedBy`, et la clé de tri est `Message`. Une classe d’outil de mappage pour cet index est disponible dans la section [query](#DynamoDBMapper.Methods.query). Elle utilise les annotations `@DynamoDBIndexHashKey` et `@DynamoDBIndexRangeKey` pour spécifier la clé de partition et la clé de tri de l’index.
L’exemple de code suivant présente analyse `PostedBy-Message-Index`. Il n’utilise pas un filtre d’analyse. Ainsi, tous les éléments dans l’index vous sont renvoyés.
```
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false);
List iList = mapper.scan(PostedByMessage.class, scanExpression);
Iterator indexItems = iList.iterator();
```
## scanPage
Analyse une table ou un index secondaire, et renvoie une seule page de résultats correspondants. Comme avec la méthode `scan`, vous pouvez spécifier le cas échéant un `FilterExpression` pour filtrer le jeu de résultats. Toutefois, `scanPage` renvoie uniquement la première « page » de données, c’est-à-dire la quantité de données pouvant tenir dans 1 Mo.
## parallelScan
Effectue une analyse parallèle d’une table ou d’un index secondaire entiers. Vous spécifiez un certain nombre de segments logiques pour la table, avec une expression d’analyse pour filtrer les résultats. Le `parallelScan` répartit la tâche d’analyse entre plusieurs instances de travail, une pour chaque segment logique ; les instances de travail traitent les données en parallèle et renvoient les résultats.
L’exemple de code Java suivant effectue une analyse parallèle sur la table `Product`.
```
int numberOfThreads = 4;
Map eav = new HashMap();
eav.put(":n", new AttributeValue().withN("100"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("Price <= :n")
.withExpressionAttributeValues(eav);
List scanResult = mapper.parallelScan(Product.class, scanExpression, numberOfThreads);
```
## batchSave
Enregistre des objets dans une ou plusieurs tables à l’aide d’un ou de plusieurs appels à la méthode `AmazonDynamoDB.batchWriteItem`. Cette méthode n’offre pas de garanties de transaction.
Le code Java enregistre deux éléments (livres) dans la table `ProductCatalog`.
```
Book book1 = new Book();
book1.setId(901);
book1.setProductCategory("Book");
book1.setTitle("Book 901 Title");
Book book2 = new Book();
book2.setId(902);
book2.setProductCategory("Book");
book2.setTitle("Book 902 Title");
mapper.batchSave(Arrays.asList(book1, book2));
```
## batchLoad
Récupère plusieurs éléments d’une ou de plusieurs tables en utilisant leurs clés primaires.
Le code Java suivant récupère deux éléments dans deux tables différentes.
```
ArrayList