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'AttributeConverterProviderinterface. Vous pouvez modifier le comportement général par défaut à l'aide d'une AttributeConverterProvider implémentation personnalisée. Vous pouvez également modifier le convertisseur pour un seul attribut.

Pour une liste des convertisseurs disponibles, consultez la documentation Java de AttributeConverterl'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'AttributeConverterProviderinterface.

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 duDefaultAttributeConverterProvider, 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. Comme la SDK valeur par défaut est 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> 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'@DynamoDbConvertedByannotation 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> 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 java.net.HttpCookieobjets.

La SimpleUser classe suivante contient un attribut nommé lastUsedCookie qui est une instance deHttpCookie.

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<SimpleUser> 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();

CookieConverterProviderL'exemple suivant fournit une instance deHttpCookeConverter.

    public static final class CookieConverterProvider implements AttributeConverterProvider {
        private final Map<EnhancedType<?>, 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<T> argument.
        @SuppressWarnings("unchecked")
        @Override
        public <T> AttributeConverter<T> converterFor(EnhancedType<T> enhancedType) {
            return (AttributeConverter<T>) 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<HttpCookie> {

        @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<String, AttributeValue> map = attributeValue.m();
            return new HttpCookie(
                    map.get("cookieName").s(),
                    map.get("cookieValue").s());
        }

        @Override
        public EnhancedType<HttpCookie> type() {
            return EnhancedType.of(HttpCookie.class);
        }

        @Override
        public AttributeValueType attributeValueType() {
            return AttributeValueType.M;
        }
    }