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.
# Présentation de la prise en charge du AWS SDK pour DynamoDB
Le schéma suivant fournit une présentation générale de la programmation d'applications Amazon DynamoDB à l'aide du. AWS SDKs
![\[Modèle de programmation pour utiliser DynamoDB avec. AWS SDKs\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/images/SDKSupport.png)
1. Vous écrivez une application à l'aide d'un AWS SDK pour votre langage de programmation.
1. Chaque AWS SDK fournit une ou plusieurs interfaces de programmation permettant d'utiliser DynamoDB. Les interfaces spécifiques disponibles dépendent du langage de programmation et du AWS SDK que vous utilisez. Voici les options :
+ [Interfaces de bas niveau compatibles avec DynamoDB](Programming.SDKs.Interfaces.md#Programming.SDKs.Interfaces.LowLevel)
+ [Interfaces de document compatibles avec DynamoDB](Programming.SDKs.Interfaces.md#Programming.SDKs.Interfaces.Document)
+ [Interfaces de persistance d’objets compatibles avec DynamoDB](Programming.SDKs.Interfaces.md#Programming.SDKs.Interfaces.Mapper)
+ [Interfaces de haut niveau](HigherLevelInterfaces.md)
1. Le AWS SDK crée des requêtes HTTP (S) à utiliser avec l'API DynamoDB de bas niveau.
1. Le AWS SDK envoie la demande au point de terminaison DynamoDB.
1. DynamoDB exécute la demande. Si la demande aboutit, DynamoDB renvoie un code de réponse HTTP 200 (OK). Si la demande échoue, DynamoDB renvoie un code d’erreur HTTP et un message d’erreur.
1. Le AWS SDK traite la réponse et la retransmet à votre application.
Chacun d'entre eux AWS SDKs fournit des services importants à votre application, notamment les suivants :
+ Mise en forme des demandes HTTP(S) et sérialisation des paramètres de demande.
+ Génération d’une signature de chiffrement pour chaque demande.
+ Transfert des demandes vers un point de terminaison DynamoDB et réception des réponses de DynamoDB.
+ Extraction des résultats de ces réponses.
+ Implémentation d’une logique de nouvelle tentative de base en cas d’erreurs.
Vous n’avez besoin d’écrire de code pour aucune de ces tâches.
**Note**
Pour plus d'informations AWS SDKs, y compris les instructions d'installation et la documentation, consultez la section [Outils pour Amazon Web Services](https://aws.amazon.com/tools).
## Support du SDK pour les terminaux basés sur des AWS comptes
AWS déploie la prise en charge du SDK pour les AWS points de terminaison basés sur un compte pour DynamoDB, en commençant par le SDK pour AWS Java V1 le 4 septembre 2024. Ces nouveaux terminaux contribuent AWS à garantir des performances et une évolutivité élevées. La mise à jour SDKs utilisera automatiquement les nouveaux points de terminaison, qui ont le format`https://(account-id).ddb.(region).amazonaws.com`.
Si vous utilisez une seule instance d’un client SDK pour envoyer des demandes à plusieurs comptes, votre application aura moins de possibilités de réutiliser les connexions. AWS recommande de modifier vos applications afin de vous connecter à un moins grand nombre de comptes par instance client SDK. Une autre solution consiste à configurer votre client SDK pour qu'il continue à utiliser les points de terminaison régionaux à l'aide du `ACCOUNT_ID_ENDPOINT_MODE` paramètre, comme indiqué dans le guide de [https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html).
# Interfaces de programmation compatibles avec DynamoDB
Chaque [kit SDK AWS](https://aws.amazon.com/tools) fournit une ou plusieurs interfaces de programmation utilisables avec Amazon DynamoDB. Ces interfaces vont de simples encapsuleurs DynamoDB de bas niveau à des couches de persistance orientées objet. Les interfaces disponibles varient en fonction du AWS SDK et du langage de programmation que vous utilisez.
![\[Différentes interfaces de programmation sont disponibles AWS SDKs pour travailler avec DynamoDB.\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/images/SDKSupport.SDKInterfaces.png)
La section suivante met en évidence certaines des interfaces disponibles, en utilisant l’ AWS SDK pour Java en guise d’exemple (Toutes les interfaces ne sont pas toutes disponibles AWS SDKs.)
**Topics**
+ [Interfaces de bas niveau compatibles avec DynamoDB](#Programming.SDKs.Interfaces.LowLevel)
+ [Interfaces de document compatibles avec DynamoDB](#Programming.SDKs.Interfaces.Document)
+ [Interfaces de persistance d’objets compatibles avec DynamoDB](#Programming.SDKs.Interfaces.Mapper)
## Interfaces de bas niveau compatibles avec DynamoDB
Chaque AWS SDK spécifique à un langage fournit une interface de bas niveau pour Amazon DynamoDB, avec des méthodes qui ressemblent étroitement aux requêtes d'API DynamoDB de bas niveau.
Dans certains cas, vous devrez identifier les types de données des attributs en utilisant des [Descripteurs de type de données](Programming.LowLevelAPI.md#Programming.LowLevelAPI.DataTypeDescriptors), tels que `S` pour String (chaîne) ou `N` pour Number (nombre).
**Note**
Une interface de bas niveau est disponible dans chaque kit SDK AWS spécifique d’un langage.
Le programme Java suivant utilise l’interface de bas niveau de l’ AWS SDK pour Java.
### Exemple d’interface de bas niveau
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* To get an item from an Amazon DynamoDB table using the AWS SDK for Java V2,
* its better practice to use the
* Enhanced Client, see the EnhancedGetItem example.
*/
public class GetItem {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table from which an item is retrieved (for example, Music3).\s
key - The key used in the Amazon DynamoDB table (for example, Artist).\s
keyval - The key value that represents the item to get (for example, Famous Band).
""";
if (args.length != 3) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
String keyVal = args[2];
System.out.format("Retrieving item \"%s\" from \"%s\"\n", keyVal, tableName);
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
getDynamoDBItem(ddb, tableName, key, keyVal);
ddb.close();
}
public static void getDynamoDBItem(DynamoDbClient ddb, String tableName, String key, String keyVal) {
HashMap keyToGet = new HashMap<>();
keyToGet.put(key, AttributeValue.builder()
.s(keyVal)
.build());
GetItemRequest request = GetItemRequest.builder()
.key(keyToGet)
.tableName(tableName)
.build();
try {
// If there is no matching item, GetItem does not return any data.
Map returnedItem = ddb.getItem(request).item();
if (returnedItem.isEmpty())
System.out.format("No item found with the key %s!\n", key);
else {
Set keys = returnedItem.keySet();
System.out.println("Amazon DynamoDB table attributes: \n");
for (String key1 : keys) {
System.out.format("%s: %s\n", key1, returnedItem.get(key1).toString());
}
}
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
```
## Interfaces de document compatibles avec DynamoDB
Beaucoup AWS SDKs proposent une interface documentaire qui vous permet d'effectuer des opérations de plan de données (création, lecture, mise à jour, suppression) sur les tables et les index. Avec une interface de document, vous n’avez pas besoin de spécifier [Descripteurs de type de données](Programming.LowLevelAPI.md#Programming.LowLevelAPI.DataTypeDescriptors). Les types de données découlent de la sémantique des données proprement dites. Ils fournissent AWS SDKs également des méthodes permettant de convertir facilement des documents JSON vers et depuis des types de données Amazon DynamoDB natifs.
**Note**
Les interfaces de document sont disponibles dans [Java](https://aws.amazon.com/sdk-for-java), [.NET](https://aws.amazon.com/sdk-for-net), [Node.js](https://aws.amazon.com/sdk-for-node-js) et [JavaScriptSDK](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/). AWS SDKs
Le programme Java suivant utilise l’interface de document de l’ AWS SDK pour Java. Le programme crée un objet `Table` qui représente la table `Music`, puis demande à cet objet d’utiliser `GetItem` pour extraire une chanson. Le programme affiche ensuite l’année de sortie de la chanson.
La classe `software.amazon.dynamodb.document.DynamoDB` implémente l’interface de document de DynamoDB. Observez la manière dont `DynamoDB` agit en tant qu’encapsuleur autour du client de bas niveau (`AmazonDynamoDB`).
### Exemple d’interface de document
```
package com.amazonaws.codesamples.gsg;
import software.amazon.dynamodb.AmazonDynamoDB;
import software.amazon.dynamodb.AmazonDynamoDBClientBuilder;
import software.amazon.dynamodb.document.DynamoDB;
import software.amazon.dynamodb.document.GetItemOutcome;
import software.amazon.dynamodb.document.Table;
public class MusicDocumentDemo {
public static void main(String[] args) {
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB docClient = new DynamoDB(client);
Table table = docClient.getTable("Music");
GetItemOutcome outcome = table.getItemOutcome(
"Artist", "No One You Know",
"SongTitle", "Call Me Today");
int year = outcome.getItem().getInt("Year");
System.out.println("The song was released in " + year);
}
}
```
## Interfaces de persistance d’objets compatibles avec DynamoDB
Certains AWS SDKs proposent une interface de persistance des objets dans laquelle vous n'effectuez pas directement d'opérations sur le plan de données. Au lieu de cela, vous créez des objets représentant des éléments dans des tables et index Amazon DynamoDB, et interagissez uniquement avec ces objets. Cela vous permet d’écrire du code orienté objet plutôt que du code orienté base de données.
**Note**
Les interfaces de persistance des objets sont disponibles AWS SDKs pour Java et .NET. Pour plus d’informations, consultez [Interfaces de programmation de niveau supérieur pour DynamoDB](HigherLevelInterfaces.md) pour DynamoDB.
### Exemple d’interface de persistance des objets
```
import com.example.dynamodb.Customer;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
import software.amazon.awssdk.enhanced.dynamodb.model.GetItemEnhancedRequest;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
```
```
import com.example.dynamodb.Customer;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
import software.amazon.awssdk.enhanced.dynamodb.model.GetItemEnhancedRequest;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
/*
* Before running this code example, create an Amazon DynamoDB table named Customer with these columns:
* - id - the id of the record that is the key. Be sure one of the id values is `id101`
* - custName - the customer name
* - email - the email value
* - registrationDate - an instant value when the item was added to the table. These values
* need to be in the form of `YYYY-MM-DDTHH:mm:ssZ`, such as 2022-07-11T00:00:00Z
*
* Also, ensure that you have set up your development environment, including your credentials.
*
* For information, see this documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class EnhancedGetItem {
public static void main(String[] args) {
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
getItem(enhancedClient);
ddb.close();
}
public static String getItem(DynamoDbEnhancedClient enhancedClient) {
Customer result = null;
try {
DynamoDbTable table = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
Key key = Key.builder()
.partitionValue("id101").sortValue("tred@noserver.com")
.build();
// Get the item by using the key.
result = table.getItem(
(GetItemEnhancedRequest.Builder requestBuilder) -> requestBuilder.key(key));
System.out.println("******* The description value is " + result.getCustName());
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
return result.getCustName();
}
}
```
# Interfaces de programmation de niveau supérieur pour DynamoDB
Ils AWS SDKs fournissent aux applications des interfaces de bas niveau pour travailler avec Amazon DynamoDB. Ces classes et méthodes côté client correspondent directement à l'API DynamoDB de bas niveau. Cependant, de nombreux développeurs sont confrontés à un sentiment de déconnexion ou à une *discordance d'impédance* quand ils doivent mapper des types de données complexes à des éléments dans une table de base de données. Avec une interface de base de données de bas niveau, les développeurs doivent écrire des méthodes pour lire ou écrire des données d'objet dans des tables de base de données, et inversement. La quantité de code supplémentaire requise pour chaque combinaison de type d'objet et de table de base de données peut sembler écrasante.
Pour simplifier le développement, les interfaces AWS SDKs pour Java et .NET fournissent des interfaces supplémentaires avec des niveaux d'abstraction plus élevés. Les interfaces de niveau supérieur pour DynamoDB vous permettent de définir les relations entre les objets dans votre programme et les tables de base de données qui stockent les données de ces objets. Après avoir défini ce mappage, vous appelez des méthodes d'objet simples telles que `save`, `load` ou `delete`, et les opérations DynamoDB de bas niveau sous-jacentes sont appelées automatiquement pour vous. Cela vous permet d'écrire du code orienté objet plutôt que du code orienté base de données.
Les interfaces de programmation de niveau supérieur pour DynamoDB sont disponibles pour Java et .NET. AWS SDKs
**Java**
+ [Java 1.x : Dynamo DBMapper](DynamoDBMapper.md)
+ [Java 2.x : client amélioré DynamoDB](DynamoDBEnhanced.md)
**.NET**
+ [Utilisation du modèle de document .NET dans DynamoDB](DotNetSDKMidLevel.md)
+ [Utilisation du modèle de persistance des objets .NET et de DynamoDB](DotNetSDKHighLevel.md)
# Java 1.x : Dynamo DBMapper
**Note**
Le kit SDK pour Java est disponible en deux versions : 1.x et 2.x. Le end-of-support for 1.x a été [annoncé](https://aws.amazon.com/blogs/developer/announcing-end-of-support-for-aws-sdk-for-java-v1-x-on-december-31-2025/) le 12 janvier 2024. Il le sera et end-of-support doit être remis le 31 décembre 2025. Pour les nouveaux développements, nous vous recommandons vivement d’utiliser la version 2.x.
AWS SDK pour Java fournit une `DynamoDBMapper` classe qui vous permet de mapper vos classes côté client aux tables Amazon DynamoDB. Pour utiliser `DynamoDBMapper`, vous définissez la relation entre éléments d’une table DynamoDB et leurs instances d’objet correspondantes dans votre code. La classe `DynamoDBMapper` vous permet 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.
**Topics**
+ [Classe Dynamo DBMapper](DynamoDBMapper.Methods.md)
+ [Types de données pris en charge pour Dynamo DBMapper pour Java](DynamoDBMapper.DataTypes.md)
+ [Annotations Java pour DynamoDB](DynamoDBMapper.Annotations.md)
+ [Paramètres de configuration facultatifs pour Dynamo DBMapper](DynamoDBMapper.OptionalConfig.md)
+ [DynamoDB et verrouillage optimiste avec numéro de version](DynamoDBMapper.OptimisticLocking.md)
+ [Mappage des données arbitraires dans DynamoDB](DynamoDBMapper.ArbitraryDataMapping.md)
+ [Exemples DynamoDBMapper](DynamoDBMapper.Examples.md)
**Note**
La classe `DynamoDBMapper` ne vous permet pas de créer, de mettre à jour ou de supprimer des tables. Pour effectuer ces tâches, utilisez plutôt l’interface du kit SDK de bas niveau pour Java.
Le kit SDK pour Java fournit un ensemble de types d’annotations qui vous permettent de mapper vos classes à des tables. Par exemple, imaginons une table `ProductCatalog` ayant `Id` en tant que clé de partition.
```
ProductCatalog(Id, ...)
```
Vous pouvez mapper une classe de votre application client à la table `ProductCatalog`, comme illustré dans le code Java suivant. Cet exemple de code définit un objet Java ancien brut (Plain Old Java Object, POJO) nommé `CatalogItem` qui utilise des annotations pour mapper des champs d’objet à des noms d’attribut DynamoDB.
**Example**
```
package com.amazonaws.codesamples;
import java.util.Set;
import software.amazon.dynamodb.datamodeling.DynamoDBAttribute;
import software.amazon.dynamodb.datamodeling.DynamoDBHashKey;
import software.amazon.dynamodb.datamodeling.DynamoDBIgnore;
import software.amazon.dynamodb.datamodeling.DynamoDBTable;
@DynamoDBTable(tableName="ProductCatalog")
public class CatalogItem {
private Integer id;
private String title;
private String ISBN;
private Set bookAuthors;
private String someProp;
@DynamoDBHashKey(attributeName="Id")
public Integer getId() { return id; }
public void setId(Integer id) {this.id = id; }
@DynamoDBAttribute(attributeName="Title")
public String getTitle() {return title; }
public void setTitle(String title) { this.title = title; }
@DynamoDBAttribute(attributeName="ISBN")
public String getISBN() { return ISBN; }
public void setISBN(String ISBN) { this.ISBN = ISBN; }
@DynamoDBAttribute(attributeName="Authors")
public Set getBookAuthors() { return bookAuthors; }
public void setBookAuthors(Set bookAuthors) { this.bookAuthors = bookAuthors; }
@DynamoDBIgnore
public String getSomeProp() { return someProp; }
public void setSomeProp(String someProp) { this.someProp = someProp; }
}
```
Dans le code précédent, l’annotation `@DynamoDBTable` mappe la classe `CatalogItem` à la table `ProductCatalog`. Vous pouvez stocker des instances de classe individuelles en tant qu’éléments dans la table. Dans la définition de classe, l’annotation `@DynamoDBHashKey` mappe l’`Id` de propriété à la clé primaire.
Par défaut, les propriétés de classe mappent avec les mêmes attributs de nom dans la table. Les propriétés `Title` et `ISBN` mappent avec les mêmes attributs de nom dans la table.
L’annotation `@DynamoDBAttribute` est facultative si le nom de l’attribut DynamoDB correspond au nom de la propriété déclarée dans la classe. Si les noms diffèrent, utilisez cette annotation avec le paramètre `attributeName` pour spécifier l’attribut DynamoDB auquel cette propriété correspond.
Dans l’exemple précédent, l’annotation `@DynamoDBAttribute` est ajoutée à chaque propriété afin de garantir que les noms de propriété correspondent exactement aux tables créées au cours d’une étape précédente et d’assurer la cohérence avec les noms d’attributs utilisés dans d’autres exemples de code dans ce guide.
Votre définition de classe peut avoir des propriétés qui ne mappent avec aucun attribut de la table. Vous identifiez ces propriétés en ajoutant l’annotation `@DynamoDBIgnore`. Dans l’exemple précédent, la propriété `SomeProp` est marquée avec l’annotation `@DynamoDBIgnore`. Lorsque vous téléchargez une instance `CatalogItem` vers la table, votre instance `DynamoDBMapper` n’inclut pas de propriété `SomeProp`. En outre, l’outil de mappage ne retourne pas cet attribut lorsque vous récupérez un élément de la table.
Une fois que vous avez défini votre classe de mappage, vous pouvez utiliser des méthodes `DynamoDBMapper` pour écrire une instance de cette classe d’un élément correspondant dans la table `Catalog`. L’exemple de code suivant illustre cette technique.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDBMapper mapper = new DynamoDBMapper(client);
CatalogItem item = new CatalogItem();
item.setId(102);
item.setTitle("Book 102 Title");
item.setISBN("222-2222222222");
item.setBookAuthors(new HashSet(Arrays.asList("Author 1", "Author 2")));
item.setSomeProp("Test");
mapper.save(item);
```
L’exemple de code suivant montre comment récupérer l’élément et accéder à certains de ses attributs :
```
CatalogItem partitionKey = new CatalogItem();
partitionKey.setId(102);
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withHashKeyValues(partitionKey);
List itemList = mapper.query(CatalogItem.class, queryExpression);
for (int i = 0; i < itemList.size(); i++) {
System.out.println(itemList.get(i).getTitle());
System.out.println(itemList.get(i).getBookAuthors());
}
```
`DynamoDBMapper` offre un moyen intuitif, naturel d’utiliser des données DynamoDB dans Java. Il offre aussi différentes fonctionnalités intégrées telles que le verrouillage optimiste, les transactions ACID, les valeurs de clé de tri et de clé de partition générées automatiquement et la gestion des versions d’objet.
# 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