Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Controlla la conversione degli attributi

Per impostazione predefinita, uno schema tabellare fornisce convertitori per molti tipi Java comuni tramite un'implementazione predefinita dell'AttributeConverterProviderinterfaccia. È possibile modificare il comportamento predefinito generale con un'AttributeConverterProviderimplementazione personalizzata. È inoltre possibile modificare il convertitore per un singolo attributo.

Per un elenco dei convertitori disponibili, consulta l'AttributeConverterinterfaccia Java doc.

Fornisci fornitori di convertitori di attributi personalizzati

È possibile fornire una singola AttributeConverterProvider o una catena di messaggi ordinati AttributeConverterProvider tramite l'@DynamoDbBean(converterProviders = {…})annotazione. Qualsiasi personalizzazione AttributeConverterProvider deve estendere l'AttributeConverterProviderinterfaccia.

Tieni presente che se fornisci la tua catena di fornitori di convertitori di attributi, sostituirai il provider di convertitori predefinito,DefaultAttributeConverterProvider. Se si desidera utilizzare la funzionalità diDefaultAttributeConverterProvider, è necessario includerla nella catena.

È anche possibile annotare il bean con un array {} vuoto. Ciò disabilita l'uso di qualsiasi fornitore di convertitori di attributi, incluso quello predefinito. In questo caso tutti gli attributi che devono essere mappati devono avere un proprio convertitore di attributi.

Il frammento seguente mostra un singolo fornitore di convertitori.

@DynamoDbBean(converterProviders = ConverterProvider1.class)
public class Customer {

}

Il seguente frammento mostra l'uso di una catena di fornitori di convertitori. Poiché l'SDKimpostazione predefinita viene fornita per ultima, ha la priorità più bassa.

@DynamoDbBean(converterProviders = {
   ConverterProvider1.class, 
   ConverterProvider2.class,
   DefaultAttributeConverterProvider.class})
public class Customer {

}

I generatori di schemi di tabelle statiche hanno un attributeConverterProviders() metodo che funziona allo stesso modo. Questo è mostrato nel frammento seguente.

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

Sovrascrivi la mappatura di un singolo attributo

Per sovrascrivere il modo in cui viene mappato un singolo attributo, fornisci un AttributeConverter per l'attributo. Questa aggiunta sostituisce tutti i convertitori forniti AttributeConverterProviders nello schema della tabella. Questo aggiunge un convertitore personalizzato solo per quell'attributo. Altri attributi, anche quelli dello stesso tipo, non utilizzeranno quel convertitore a meno che non sia specificato esplicitamente per quegli altri attributi.

L'@DynamoDbConvertedByannotazione viene utilizzata per specificare la AttributeConverter classe personalizzata, come mostrato nel frammento seguente.

@DynamoDbBean
public class Customer {
    private String name;

    @DynamoDbConvertedBy(CustomAttributeConverter.class)
    public String getName() { return this.name; }
    public void setName(String name) { this.name = name;}
}

I costruttori di schemi statici hanno un metodo di creazione di attributi equivalente. attributeConverter() Questo metodo accetta un'istanza di an AttributeConverter come illustrato di seguito.

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

Esempio

Questo esempio mostra un'AttributeConverterProviderimplementazione che fornisce un convertitore di attributi per java.net.HttpCookiegli oggetti.

La SimpleUser classe seguente contiene un attributo denominato lastUsedCookie che è un'istanza diHttpCookie.

Il parametro delle @DynamoDbBean annotazioni elenca le due AttributeConverterProvider classi che forniscono convertitori.

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

CookieConverterProviderNell'esempio seguente viene fornita un'istanza di un. HttpCookeConverter

    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);
        }
    }

Codice di conversione

Nel transformFrom() metodo della HttpCookieConverter classe seguente, il codice riceve un'HttpCookieistanza e la trasforma in una mappa DynamoDB memorizzata come attributo.

Il transformTo() metodo riceve un parametro di mappa DynamoDB, quindi richiama HttpCookie il costruttore che richiede un nome e un valore.

    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;
        }
    }