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.
# Conversion des attributs de contrôle
Par défaut, un schéma de table fournit des convertisseurs pour de nombreux types Java courants via une implémentation par défaut de l'`[AttributeConverterProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverterProvider.html)`interface. Vous pouvez modifier le comportement général par défaut à l’aide d’une implémentation de `AttributeConverterProvider` personnalisée. Vous pouvez également modifier le convertisseur pour un seul attribut.
Pour une liste des convertisseurs disponibles, consultez la documentation Java de [AttributeConverter](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverter.html)l'interface.
## Fournir des fournisseurs de convertisseurs d'attributs personnalisés
Vous pouvez fournir un seul `AttributeConverterProvider` ou une chaîne de `AttributeConverterProvider` s ordonnés par le biais de l'`@DynamoDbBean``(converterProviders = {…})`annotation. Toute personnalisation `AttributeConverterProvider` doit étendre l'`AttributeConverterProvider`interface.
Notez que si vous fournissez votre propre chaîne de fournisseurs de convertisseurs d'attributs, vous remplacerez le fournisseur de conversion par défaut,`DefaultAttributeConverterProvider`. Si vous souhaitez utiliser les fonctionnalités du`DefaultAttributeConverterProvider`, vous devez l'inclure dans la chaîne.
Il est également possible d'annoter le bean avec un tableau `{}` vide. Cela désactive l'utilisation de tous les fournisseurs de convertisseurs d'attributs, y compris le fournisseur par défaut. Dans ce cas, tous les attributs à mapper doivent disposer de leur propre convertisseur d'attributs.
L'extrait suivant montre un fournisseur de conversion unique.
```
@DynamoDbBean(converterProviders = ConverterProvider1.class)
public class Customer {
}
```
L'extrait suivant montre l'utilisation d'une chaîne de fournisseurs de convertisseurs. La valeur par défaut du SDK étant fournie en dernier, elle a la priorité la plus basse.
```
@DynamoDbBean(converterProviders = {
ConverterProvider1.class,
ConverterProvider2.class,
DefaultAttributeConverterProvider.class})
public class Customer {
}
```
Les constructeurs de schémas de tables statiques ont une `attributeConverterProviders()` méthode qui fonctionne de la même manière. Cela est illustré dans l'extrait suivant.
```
private static final StaticTableSchema CUSTOMER_TABLE_SCHEMA =
StaticTableSchema.builder(Customer.class)
.newItemSupplier(Customer::new)
.addAttribute(String.class, a -> a.name("name")
a.getter(Customer::getName)
a.setter(Customer::setName))
.attributeConverterProviders(converterProvider1, converterProvider2)
.build();
```
## Remplacer le mappage d'un seul attribut
Pour modifier la façon dont un seul attribut est mappé, fournissez un `AttributeConverter` pour l'attribut. Cet ajout remplace tous les convertisseurs fournis `AttributeConverterProviders` dans le schéma de table. Cela ajoute un convertisseur personnalisé pour cet attribut uniquement. Les autres attributs, même ceux du même type, n'utiliseront pas ce convertisseur à moins qu'il ne soit explicitement spécifié pour ces autres attributs.
L'`@DynamoDbConvertedBy`annotation est utilisée pour spécifier la `AttributeConverter` classe personnalisée, comme indiqué dans l'extrait de code suivant.
```
@DynamoDbBean
public class Customer {
private String name;
@DynamoDbConvertedBy(CustomAttributeConverter.class)
public String getName() { return this.name; }
public void setName(String name) { this.name = name;}
}
```
Les générateurs de schémas statiques utilisent une `attributeConverter()` méthode de génération d'attributs équivalente. Cette méthode prend une instance d'un `AttributeConverter` comme le montre ce qui suit.
```
private static final StaticTableSchema CUSTOMER_TABLE_SCHEMA =
StaticTableSchema.builder(Customer.class)
.newItemSupplier(Customer::new)
.addAttribute(String.class, a -> a.name("name")
a.getter(Customer::getName)
a.setter(Customer::setName)
a.attributeConverter(customAttributeConverter))
.build();
```
## Exemple
Cet exemple montre une `AttributeConverterProvider` implémentation qui fournit un convertisseur d'attributs pour les [https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/HttpCookie.html](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/HttpCookie.html)objets.
La `SimpleUser` classe suivante contient un attribut nommé `lastUsedCookie` qui est une instance de`HttpCookie`.
Le paramètre des `@DynamoDbBean` annotations répertorie les deux `AttributeConverterProvider` classes qui fournissent des convertisseurs.
------
#### [ Class with annotations ]
```
@DynamoDbBean(converterProviders = {CookieConverterProvider.class, DefaultAttributeConverterProvider.class})
public static final class SimpleUser {
private String name;
private HttpCookie lastUsedCookie;
@DynamoDbPartitionKey
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public HttpCookie getLastUsedCookie() {
return lastUsedCookie;
}
public void setLastUsedCookie(HttpCookie lastUsedCookie) {
this.lastUsedCookie = lastUsedCookie;
}
```
------
#### [ Static table schema ]
```
private static final TableSchema SIMPLE_USER_TABLE_SCHEMA =
TableSchema.builder(SimpleUser.class)
.newItemSupplier(SimpleUser::new)
.attributeConverterProviders(CookieConverterProvider.create(), AttributeConverterProvider.defaultProvider())
.addAttribute(String.class, a -> a.name("name")
.setter(SimpleUser::setName)
.getter(SimpleUser::getName)
.tags(StaticAttributeTags.primaryPartitionKey()))
.addAttribute(HttpCookie.class, a -> a.name("lastUsedCookie")
.setter(SimpleUser::setLastUsedCookie)
.getter(SimpleUser::getLastUsedCookie))
.build();
```
------
`CookieConverterProvider`L'exemple suivant fournit une instance de`HttpCookeConverter`.
```
public static final class CookieConverterProvider implements AttributeConverterProvider {
private final Map, AttributeConverter> converterCache = ImmutableMap.of(
// 1. Add HttpCookieConverter to the internal cache.
EnhancedType.of(HttpCookie.class), new HttpCookieConverter());
public static CookieConverterProvider create() {
return new CookieConverterProvider();
}
// The SDK calls this method to find out if the provider contains a AttributeConverter instance
// for the EnhancedType argument.
@SuppressWarnings("unchecked")
@Override
public AttributeConverter converterFor(EnhancedType enhancedType) {
return (AttributeConverter) converterCache.get(enhancedType);
}
}
```
### Code de conversion
Dans la `transformFrom()` méthode de la `HttpCookieConverter` classe suivante, le code reçoit une `HttpCookie` instance et la transforme en une carte DynamoDB stockée sous forme d'attribut.
La `transformTo()` méthode reçoit un paramètre de carte DynamoDB, puis appelle le constructeur qui a besoin d'un `HttpCookie` nom et d'une valeur.
```
public static final class HttpCookieConverter implements AttributeConverter {
@Override
public AttributeValue transformFrom(HttpCookie httpCookie) {
return AttributeValue.fromM(
Map.of ("cookieName", AttributeValue.fromS(httpCookie.getName()),
"cookieValue", AttributeValue.fromS(httpCookie.getValue()))
);
}
@Override
public HttpCookie transformTo(AttributeValue attributeValue) {
Map map = attributeValue.m();
return new HttpCookie(
map.get("cookieName").s(),
map.get("cookieValue").s());
}
@Override
public EnhancedType type() {
return EnhancedType.of(HttpCookie.class);
}
@Override
public AttributeValueType attributeValueType() {
return AttributeValueType.M;
}
}
```