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.
# Découvrez les principes de base de l'API client améliorée DynamoDB
Cette rubrique décrit les fonctionnalités de base de l'API DynamoDB Enhanced Client et les compare à l'API client [DynamoDB standard](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/dynamodb/package-summary.html).
Si vous découvrez l'API DynamoDB Enhanced Client, nous vous recommandons de suivre [le didacticiel d'introduction pour vous familiariser avec les](ddb-en-client-getting-started.md) classes fondamentales.
## Éléments DynamoDB en Java
Les tables DynamoDB stockent des éléments. Selon votre cas d'utilisation, les éléments du côté Java peuvent prendre la forme de données structurées statiquement ou de structures créées dynamiquement.
Si votre cas d'utilisation nécessite des éléments dotés d'un ensemble cohérent d'attributs, utilisez des [classes annotées](ddb-en-client-gs-tableschema.md#ddb-en-client-gs-tableschema-anno-bean) ou utilisez un [générateur](ddb-en-client-gs-tableschema.md#ddb-en-client-gs-tableschema-builder) pour générer le type statique `TableSchema` approprié.
Sinon, si vous devez stocker des éléments composés de différentes structures, créez un`DocumentTableSchema`. `DocumentTableSchema`fait partie de l'[API Enhanced Document](ddb-en-client-doc-api.md) et ne nécessite qu'une clé primaire de type statique et fonctionne avec des `EnhancedDocument` instances pour contenir les éléments de données. L'API de document améliorée est abordée dans une autre [rubrique.](ddb-en-client-doc-api.md)
## Types d'attributs pour les classes de modèles de données
Bien que DynamoDB prenne [en charge un petit nombre de types d'attributs](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes) par rapport au système de types riches de Java, l'API DynamoDB Enhanced Client fournit des mécanismes permettant de convertir les membres d'une classe Java vers et depuis les types d'attributs DynamoDB.
Les types d'attributs (propriétés) de vos classes de données Java doivent être des types d'objets et non des primitives. Par exemple, utilisez toujours des types de données `Long` et des `Integer` objets, `long` et non des `int` primitives.
[Par défaut, l'API DynamoDB Enhanced Client prend en charge les convertisseurs d'attributs pour un grand nombre de types, [tels que](https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html) Integer [[BigDecimal](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/internal/converter/attribute/BigDecimalAttributeConverter.html), String et](https://docs.oracle.com/javase/8/docs/api/java/lang/String.html) Instant.](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/internal/converter/attribute/InstantAsStringAttributeConverter.html) La liste apparaît dans les [classes d'implémentation connues de l' AttributeConverter interface](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverter.html). La liste comprend de nombreux types et collections tels que des cartes, des listes et des ensembles.
Pour stocker les données d'un type d'attribut qui n'est pas pris en charge par défaut ou qui n'est pas conforme à la JavaBean convention, vous pouvez écrire une `AttributeConverter` implémentation personnalisée pour effectuer la conversion. Consultez la section sur la conversion d'attributs pour un [exemple](ddb-en-client-adv-features-conversion.md#ddb-en-client-adv-features-conversion-example).
Pour stocker les données d'un type d'attribut dont la classe est conforme à la spécification Java Beans (ou d'une [classe de données immuable](ddb-en-client-use-immut.md)), vous pouvez adopter deux approches.
+ Si vous avez accès au fichier source, vous pouvez annoter la classe avec `@DynamoDbBean` (ou`@DynamoDbImmutable`). La section qui traite des attributs imbriqués présente des [exemples](ddb-en-client-adv-features-nested.md#ddb-en-client-adv-features-nested-map-anno) d'utilisation de classes annotées.
+ Si vous n'avez pas accès au fichier source de la classe de JavaBean données pour l'attribut (ou si vous ne souhaitez pas annoter le fichier source d'une classe à laquelle vous avez accès), vous pouvez utiliser l'approche du générateur. Cela crée un schéma de table sans définir les clés. Vous pouvez ensuite imbriquer ce schéma de table dans un autre schéma de table pour effectuer le mappage. La section des attributs imbriqués contient un [exemple](ddb-en-client-adv-features-nested.md#ddb-en-client-adv-features-nested-map-builder) illustrant l'utilisation de schémas imbriqués.
### Valeurs nulles
Lorsque vous utilisez `putItem` cette méthode, le client amélioré n'inclut pas les attributs à valeur nulle d'un objet de données mappé dans la demande adressée à DynamoDB.
Le comportement par défaut du SDK pour les `updateItem` demandes supprime les attributs de l'élément de DynamoDB qui sont définis sur null dans l'objet que vous soumettez dans la méthode. `updateItem` Si vous avez l'intention de mettre à jour certaines valeurs d'attributs et de conserver les autres inchangées, deux options s'offrent à vous.
+ Récupérez l'élément (en utilisant`getItem`) avant de modifier les valeurs. En utilisant cette approche, le SDK soumet toutes les valeurs anciennes et mises à jour à DynamoDB.
+ Utilisez le `[IgnoreNullsMode](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/IgnoreNullsMode.html).SCALAR_ONLY` ou `IgnoreNullsMode.MAPS_ONLY` lorsque vous créez la demande pour mettre à jour l'élément. Les deux modes ignorent les propriétés à valeur nulle de l'objet qui représentent des attributs scalaires dans DynamoDB. La [Mettre à jour les éléments contenant des types complexes](ddb-en-client-adv-features-nested.md#ddb-en-client-adv-features-nested-updates) rubrique de ce guide contient plus d'informations sur les `IgnoreNullsMode` valeurs et sur la manière de travailler avec des types complexes.
L'exemple suivant illustre `ignoreNullsMode()` la `updateItem()` méthode.
```
public static void updateItemNullsExample() {
Customer customer = new Customer();
customer.setCustName("CustomerName");
customer.setEmail("email");
customer.setId("1");
customer.setRegistrationDate(Instant.now());
logger.info("Original customer: {}", customer);
// Put item with values for all attributes.
try {
customerAsyncDynamoDbTable.putItem(customer).join();
} catch (RuntimeException rte) {
logger.error("A exception occurred during putItem: {}", rte.getCause().getMessage(), rte);
return;
}
// Create a Customer instance with the same 'id' and 'email' values, but a different 'name' value.
// Do not set the 'registrationDate' attribute.
Customer customerForUpdate = new Customer();
customerForUpdate.setCustName("NewName");
customerForUpdate.setEmail("email");
customerForUpdate.setId("1");
// Update item without setting the 'registrationDate' property and set IgnoreNullsMode to SCALAR_ONLY.
try {
Customer updatedWithNullsIgnored = customerAsyncDynamoDbTable.updateItem(b -> b
.item(customerForUpdate)
.ignoreNullsMode(IgnoreNullsMode.SCALAR_ONLY))
.join();
logger.info("Customer updated with nulls ignored: {}", updatedWithNullsIgnored.toString());
} catch (RuntimeException rte) {
logger.error("An exception occurred during updateItem: {}", rte.getCause().getMessage(), rte);
return;
}
// Update item without setting the registrationDate attribute and not setting ignoreNulls to true.
try {
Customer updatedWithNullsUsed = customerAsyncDynamoDbTable.updateItem(customerForUpdate)
.join();
logger.info("Customer updated with nulls used: {}", updatedWithNullsUsed.toString());
} catch (RuntimeException rte) {
logger.error("An exception occurred during updateItem: {}", rte.getCause().getMessage(), rte);
}
}
// Logged lines.
Original customer: Customer [id=1, name=CustomerName, email=email, regDate=2024-10-11T14:12:30.222858Z]
Customer updated with nulls ignored: Customer [id=1, name=NewName, email=email, regDate=2024-10-11T14:12:30.222858Z]
Customer updated with nulls used: Customer [id=1, name=NewName, email=email, regDate=null]
```
## Méthodes de base du client DynamoDB Enhanced
Les méthodes de base du client amélioré correspondent aux opérations de service DynamoDB dont elles portent le nom. Les exemples suivants montrent la variante la plus simple de chaque méthode. Vous pouvez personnaliser chaque méthode en transmettant un objet de demande amélioré. Les objets de requête améliorés offrent la plupart des fonctionnalités disponibles dans le client DynamoDB standard. Ils sont entièrement documentés dans le Guide de référence des AWS SDK for Java 2.x API.
L'exemple utilise ce qui [classe `Customer`](ddb-en-client-gs-tableschema.md#ddb-en-client-gs-tableschema-anno-bean-cust) est indiqué précédemment.
```
// CreateTable
customerTable.createTable();
// GetItem
Customer customer = customerTable.getItem(Key.builder().partitionValue("a123").build());
// UpdateItem
Customer updatedCustomer = customerTable.updateItem(customer);
// PutItem
customerTable.putItem(customer);
// DeleteItem
Customer deletedCustomer = customerTable.deleteItem(Key.builder().partitionValue("a123").sortValue(456).build());
// Query
PageIterable customers = customerTable.query(keyEqualTo(k -> k.partitionValue("a123")));
// Scan
PageIterable customers = customerTable.scan();
// BatchGetItem
BatchGetResultPageIterable batchResults =
enhancedClient.batchGetItem(r -> r.addReadBatch(ReadBatch.builder(Customer.class)
.mappedTableResource(customerTable)
.addGetItem(key1)
.addGetItem(key2)
.addGetItem(key3)
.build()));
// BatchWriteItem
batchResults = enhancedClient.batchWriteItem(r -> r.addWriteBatch(WriteBatch.builder(Customer.class)
.mappedTableResource(customerTable)
.addPutItem(customer)
.addDeleteItem(key1)
.addDeleteItem(key1)
.build()));
// TransactGetItems
transactResults = enhancedClient.transactGetItems(r -> r.addGetItem(customerTable, key1)
.addGetItem(customerTable, key2));
// TransactWriteItems
enhancedClient.transactWriteItems(r -> r.addConditionCheck(customerTable,
i -> i.key(orderKey)
.conditionExpression(conditionExpression))
.addUpdateItem(customerTable, customer)
.addDeleteItem(customerTable, key));
```
## Comparez le client DynamoDB amélioré au client DynamoDB standard
Les APIs clients DynamoDB (standard [et](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/package-summary.html) amélioré) vous [permettent](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/dynamodb/package-summary.html) de travailler avec des tables DynamoDB pour effectuer des opérations CRUD (création, lecture, mise à jour et suppression) au niveau des données. La différence entre le client APIs réside dans la manière dont cela est accompli. Avec le client standard, vous travaillez directement avec des attributs de données de bas niveau. L'API client améliorée utilise des classes Java familières et correspond à l'API de bas niveau utilisée en arrière-plan.
Bien que les deux clients APIs prennent en charge les opérations au niveau des données, le client DynamoDB standard prend également en charge les opérations au niveau des ressources. Les opérations au niveau des ressources gèrent la base de données, telles que la création de sauvegardes, la liste des tables et la mise à jour des tables. L'API client améliorée prend en charge un certain nombre d'opérations au niveau des ressources, telles que la création, la description et la suppression de tables.
Pour illustrer les différentes approches utilisées par les deux clients APIs, les exemples de code suivants montrent la création de la même `ProductCatalog` table à l'aide du client standard et du client amélioré.
### Comparaison : création d'une table à l'aide du client DynamoDB standard
```
DependencyFactory.dynamoDbClient().createTable(builder -> builder
.tableName(TABLE_NAME)
.attributeDefinitions(
b -> b.attributeName("id").attributeType(ScalarAttributeType.N),
b -> b.attributeName("title").attributeType(ScalarAttributeType.S),
b -> b.attributeName("isbn").attributeType(ScalarAttributeType.S)
)
.keySchema(
builder1 -> builder1.attributeName("id").keyType(KeyType.HASH),
builder2 -> builder2.attributeName("title").keyType(KeyType.RANGE)
)
.globalSecondaryIndexes(builder3 -> builder3
.indexName("products_by_isbn")
.keySchema(builder2 -> builder2
.attributeName("isbn").keyType(KeyType.HASH))
.projection(builder2 -> builder2
.projectionType(ProjectionType.INCLUDE)
.nonKeyAttributes("price", "authors"))
.provisionedThroughput(builder4 -> builder4
.writeCapacityUnits(5L).readCapacityUnits(5L))
)
.provisionedThroughput(builder1 -> builder1
.readCapacityUnits(5L).writeCapacityUnits(5L))
);
```
### Comparaison : création d'une table à l'aide du client DynamoDB Enhanced
```
DynamoDbEnhancedClient enhancedClient = DependencyFactory.enhancedClient();
productCatalog = enhancedClient.table(TABLE_NAME, TableSchema.fromImmutableClass(ProductCatalog.class));
productCatalog.createTable(b -> b
.provisionedThroughput(b1 -> b1.readCapacityUnits(5L).writeCapacityUnits(5L))
.globalSecondaryIndices(b2 -> b2.indexName("products_by_isbn")
.projection(b4 -> b4
.projectionType(ProjectionType.INCLUDE)
.nonKeyAttributes("price", "authors"))
.provisionedThroughput(b3 -> b3.writeCapacityUnits(5L).readCapacityUnits(5L))
)
);
```
Le client amélioré utilise la classe de données annotée suivante. Le client DynamoDB Enhanced fait correspondre les types de données Java aux types de données DynamoDB pour un code moins détaillé et plus facile à suivre. `ProductCatalog`est un exemple d'utilisation d'une classe immuable avec le client DynamoDB Enhanced. L'utilisation de classes immuables pour les classes de données mappées est [abordée plus loin](ddb-en-client-use-immut.md) dans cette rubrique.
### classe `ProductCatalog`
```
package org.example.tests.model;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbIgnore;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbImmutable;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSecondaryPartitionKey;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey;
import java.math.BigDecimal;
import java.util.Objects;
import java.util.Set;
@DynamoDbImmutable(builder = ProductCatalog.Builder.class)
public class ProductCatalog implements Comparable {
private Integer id;
private String title;
private String isbn;
private Set authors;
private BigDecimal price;
private ProductCatalog(Builder builder){
this.authors = builder.authors;
this.id = builder.id;
this.isbn = builder.isbn;
this.price = builder.price;
this.title = builder.title;
}
public static Builder builder(){ return new Builder(); }
@DynamoDbPartitionKey
public Integer id() { return id; }
@DynamoDbSortKey
public String title() { return title; }
@DynamoDbSecondaryPartitionKey(indexNames = "products_by_isbn")
public String isbn() { return isbn; }
public Set authors() { return authors; }
public BigDecimal price() { return price; }
public static final class Builder {
private Integer id;
private String title;
private String isbn;
private Set authors;
private BigDecimal price;
private Builder(){}
public Builder id(Integer id) { this.id = id; return this; }
public Builder title(String title) { this.title = title; return this; }
public Builder isbn(String ISBN) { this.isbn = ISBN; return this; }
public Builder authors(Set authors) { this.authors = authors; return this; }
public Builder price(BigDecimal price) { this.price = price; return this; }
public ProductCatalog build() { return new ProductCatalog(this); }
}
@Override
public String toString() {
final StringBuffer sb = new StringBuffer("ProductCatalog{");
sb.append("id=").append(id);
sb.append(", title='").append(title).append('\'');
sb.append(", isbn='").append(isbn).append('\'');
sb.append(", authors=").append(authors);
sb.append(", price=").append(price);
sb.append('}');
return sb.toString();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ProductCatalog that = (ProductCatalog) o;
return id.equals(that.id) && title.equals(that.title) && Objects.equals(isbn, that.isbn) && Objects.equals(authors, that.authors) && Objects.equals(price, that.price);
}
@Override
public int hashCode() {
return Objects.hash(id, title, isbn, authors, price);
}
@Override
@DynamoDbIgnore
public int compareTo(ProductCatalog other) {
if (this.id.compareTo(other.id) != 0){
return this.id.compareTo(other.id);
} else {
return this.title.compareTo(other.title);
}
}
}
```
Les deux exemples de code suivants illustrant une écriture par lots illustrent le caractère verbeux et le manque de sécurité de type liés à l'utilisation du client standard par opposition au client amélioré.
### Comparaison : écriture par lots à l'aide du client DynamoDB standard
```
public static void batchWriteStandard(DynamoDbClient dynamoDbClient, String tableName) {
Map catalogItem = Map.of(
"authors", AttributeValue.builder().ss("a", "b").build(),
"id", AttributeValue.builder().n("1").build(),
"isbn", AttributeValue.builder().s("1-565-85698").build(),
"title", AttributeValue.builder().s("Title 1").build(),
"price", AttributeValue.builder().n("52.13").build());
Map catalogItem2 = Map.of(
"authors", AttributeValue.builder().ss("a", "b", "c").build(),
"id", AttributeValue.builder().n("2").build(),
"isbn", AttributeValue.builder().s("1-208-98073").build(),
"title", AttributeValue.builder().s("Title 2").build(),
"price", AttributeValue.builder().n("21.99").build());
Map catalogItem3 = Map.of(
"authors", AttributeValue.builder().ss("g", "k", "c").build(),
"id", AttributeValue.builder().n("3").build(),
"isbn", AttributeValue.builder().s("7-236-98618").build(),
"title", AttributeValue.builder().s("Title 3").build(),
"price", AttributeValue.builder().n("42.00").build());
Set writeRequests = Set.of(
WriteRequest.builder().putRequest(b -> b.item(catalogItem)).build(),
WriteRequest.builder().putRequest(b -> b.item(catalogItem2)).build(),
WriteRequest.builder().putRequest(b -> b.item(catalogItem3)).build());
Map> productCatalogItems = Map.of(
"ProductCatalog", writeRequests);
BatchWriteItemResponse response = dynamoDbClient.batchWriteItem(b -> b.requestItems(productCatalogItems));
logger.info("Unprocessed items: " + response.unprocessedItems().size());
}
```
### Comparaison : écriture par lots à l'aide du client DynamoDB Enhanced
```
public static void batchWriteEnhanced(DynamoDbTable productCatalog) {
ProductCatalog prod = ProductCatalog.builder()
.id(1)
.isbn("1-565-85698")
.authors(new HashSet<>(Arrays.asList("a", "b")))
.price(BigDecimal.valueOf(52.13))
.title("Title 1")
.build();
ProductCatalog prod2 = ProductCatalog.builder()
.id(2)
.isbn("1-208-98073")
.authors(new HashSet<>(Arrays.asList("a", "b", "c")))
.price(BigDecimal.valueOf(21.99))
.title("Title 2")
.build();
ProductCatalog prod3 = ProductCatalog.builder()
.id(3)
.isbn("7-236-98618")
.authors(new HashSet<>(Arrays.asList("g", "k", "c")))
.price(BigDecimal.valueOf(42.00))
.title("Title 3")
.build();
BatchWriteResult batchWriteResult = DependencyFactory.enhancedClient()
.batchWriteItem(b -> b.writeBatches(
WriteBatch.builder(ProductCatalog.class)
.mappedTableResource(productCatalog)
.addPutItem(prod).addPutItem(prod2).addPutItem(prod3)
.build()
));
logger.info("Unprocessed items: " + batchWriteResult.unprocessedPutItemsForTable(productCatalog).size());
}
```
# Travaillez avec des classes de données immuables
La fonctionnalité de mappage de l'API DynamoDB Enhanced Client fonctionne avec des classes de données immuables. Une classe immuable ne possède que des méthodes getter et nécessite une classe de générateur que le kit SDK utilise pour créer des instances de la classe. Au lieu d'utiliser l'`@DynamoDbBean`annotation comme indiqué dans la [classe Customer](ddb-en-client-gs-tableschema.md#ddb-en-client-gs-tableschema-anno-bean-cust), les classes immuables utilisent l'`@DynamoDbImmutable`annotation, qui prend un paramètre indiquant la classe de générateur à utiliser.
La classe suivante est une version immuable de. `Customer`
```
package org.example.tests.model.immutable;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbImmutable;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSecondaryPartitionKey;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSecondarySortKey;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey;
import java.time.Instant;
@DynamoDbImmutable(builder = CustomerImmutable.Builder.class)
public class CustomerImmutable {
private final String id;
private final String name;
private final String email;
private final Instant regDate;
private CustomerImmutable(Builder b) {
this.id = b.id;
this.email = b.email;
this.name = b.name;
this.regDate = b.regDate;
}
// This method will be automatically discovered and used by the TableSchema.
public static Builder builder() { return new Builder(); }
@DynamoDbPartitionKey
public String id() { return this.id; }
@DynamoDbSortKey
public String email() { return this.email; }
@DynamoDbSecondaryPartitionKey(indexNames = "customers_by_name")
public String name() { return this.name; }
@DynamoDbSecondarySortKey(indexNames = {"customers_by_date", "customers_by_name"})
public Instant regDate() { return this.regDate; }
public static final class Builder {
private String id;
private String email;
private String name;
private Instant regDate;
// The private Builder constructor is visible to the enclosing CustomerImmutable class.
private Builder() {}
public Builder id(String id) { this.id = id; return this; }
public Builder email(String email) { this.email = email; return this; }
public Builder name(String name) { this.name = name; return this; }
public Builder regDate(Instant regDate) { this.regDate = regDate; return this; }
// This method will be automatically discovered and used by the TableSchema.
public CustomerImmutable build() { return new CustomerImmutable(this); }
}
}
```
Vous devez satisfaire aux exigences suivantes lorsque vous annotez une classe de données avec`@DynamoDbImmutable`.
1. Chaque méthode qui n'est pas une substitution `Object.class` et qui n'a pas été annotée `@DynamoDbIgnore` doit être un getter pour un attribut de la table DynamoDB.
1. Chaque getter doit avoir un setter correspondant distinguant majuscules et minuscules dans la classe de générateur.
1. Seule l'une des conditions de construction suivantes doit être respectée.
+ La classe de générateur doit avoir un constructeur public par défaut.
+ La classe de données doit avoir une méthode statique publique nommée `builder()` qui ne prend aucun paramètre et renvoie une instance de la classe de générateur. Cette option est affichée dans la `Customer` classe immuable.
1. La classe builder doit avoir une méthode publique nommée `build()` qui ne prend aucun paramètre et renvoie une instance de la classe immuable.
Pour créer un `TableSchema` pour votre classe immuable, utilisez la `fromImmutableClass()` méthode on `TableSchema` comme indiqué dans l'extrait suivant.
```
static final TableSchema customerImmutableTableSchema =
TableSchema.fromImmutableClass(CustomerImmutable.class);
```
Tout comme vous pouvez créer une table DynamoDB à partir d'une classe mutable, vous pouvez en créer une à partir d'une classe immuable avec *un* appel unique à of, comme indiqué dans l'exemple `DynamoDbTable` d'`createTable()`extrait de code suivant.
```
static void createTableFromImmutable(DynamoDbEnhancedClient enhancedClient, String tableName, DynamoDbWaiter waiter){
// First, create an in-memory representation of the table using the 'table()' method of the DynamoDb Enhanced Client.
// 'table()' accepts a name for the table and a TableSchema instance that you created previously.
DynamoDbTable customerDynamoDbTable = enhancedClient
.table(tableName, TableSchema.fromImmutableClass(CustomerImmutable.class));
// Second, call the 'createTable()' method on the DynamoDbTable instance.
customerDynamoDbTable.createTable();
waiter.waitUntilTableExists(b -> b.tableName(tableName));
}
```
## Utilisez des bibliothèques tierces, telles que Lombok
Les bibliothèques tierces, telles que [Project Lombok](https://projectlombok.org/), aident à générer du code standard associé à des objets immuables. L'API DynamoDB Enhanced Client fonctionne avec ces bibliothèques tant que les classes de données respectent les conventions détaillées dans cette section.
L'exemple suivant montre la `CustomerImmutable` classe immuable avec les annotations Lombok. Notez comment la `onMethod` fonctionnalité de Lombok copie les annotations DynamoDB basées sur les attributs, telles que, sur le code généré. `@DynamoDbPartitionKey`
```
@Value
@Builder
@DynamoDbImmutable(builder = Customer.CustomerBuilder.class)
public class Customer {
@Getter(onMethod_=@DynamoDbPartitionKey)
private String id;
@Getter(onMethod_=@DynamoDbSortKey)
private String email;
@Getter(onMethod_=@DynamoDbSecondaryPartitionKey(indexNames = "customers_by_name"))
private String name;
@Getter(onMethod_=@DynamoDbSecondarySortKey(indexNames = {"customers_by_date", "customers_by_name"}))
private Instant createdDate;
}
```
# Expressions et conditions d'utilisation
[Les expressions de l'API DynamoDB Enhanced Client sont des représentations Java des expressions DynamoDB.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.html)
L'API client améliorée DynamoDB utilise trois types d'expressions :
[Expression](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/Expression.html)
La `Expression` classe est utilisée lorsque vous définissez des conditions et des filtres.
[https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/QueryConditional.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/QueryConditional.html)
Ce type d'expression représente [les conditions clés](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.KeyConditionExpressions) pour les opérations de requête.
[https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/update/UpdateExpression.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/update/UpdateExpression.html)
Cette classe vous aide à écrire des expressions de [mise à jour DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html) et est actuellement utilisée dans le framework d'extension lorsque vous mettez à jour un élément.
## Anatomie de l'expression
Une expression est composée des éléments suivants :
+ Une expression sous forme de chaîne (obligatoire). La chaîne contient une expression logique DynamoDB avec des noms d'espaces réservés pour les noms d'attributs et les valeurs d'attribut.
+ Une carte des valeurs d'expression (généralement obligatoire).
+ Carte des noms d'expressions (facultatif).
Utilisez un générateur pour générer un `Expression` objet qui prend la forme générale suivante.
```
Expression expression = Expression.builder()
.expression()
.expressionNames(