Conversão de atributo de controle

Por padrão, um esquema de tabela fornece conversores para muitos tipos comuns de Java por meio de uma implementação padrão da AttributeConverterProvider interface. Você pode alterar o comportamento padrão geral com uma implementação AttributeConverterProvider personalizada. Você também pode alterar o conversor para um único atributo.

Para obter uma lista dos conversores disponíveis, consulte a AttributeConverterinterface Java doc.

Forneça provedores de conversão de atributos personalizados

Você pode fornecer um único AttributeConverterProvider ou uma cadeia de AttributeConverterProviders ordenados por meio da anotação @DynamoDbBean (converterProviders = {…}). Qualquer personalização do AttributeConverterProvider deve estender a interface do AttributeConverterProvider.

Observe que, se fornecer sua própria cadeia de provedores de conversão de atributos, você substituirá o provedor de conversão padrão, DefaultAttributeConverterProvider. Se quiser usar a funcionalidade do DefaultAttributeConverterProvider, você deverá incluí-la na cadeia.

Também é possível anotar o bean com uma matriz vazia {}. Isso desativa o uso de qualquer provedor de conversão de atributos, incluindo o padrão. Nesse caso, todos os atributos a serem mapeados devem ter seu próprio conversor de atributos.

O trecho a seguir mostra um único provedor de conversor.

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

}

O trecho a seguir mostra o uso de uma cadeia de provedores de conversores. Como o SDK padrão é fornecido por último, ele tem a menor prioridade.

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

}

Os criadores de esquemas de tabelas estáticas têm um método attributeConverterProviders() que funciona da mesma maneira. Isso é mostrado no trecho a seguir.

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

Substituir o mapeamento de um único atributo

Para substituir a forma como um único atributo é mapeado, forneça um AttributeConverter para o atributo. Essa adição substitui todos os conversores fornecidos pelo AttributeConverterProviders no esquema da tabela. A ação adiciona um conversor personalizado somente para esse atributo. Outros atributos, mesmo aqueles do mesmo tipo, não usarão esse conversor, a menos que ele seja explicitamente especificado para esses outros atributos.

A anotação @DynamoDbConvertedBy é usada para especificar a classe AttributeConverter personalizada, conforme mostrado no trecho a seguir.

@DynamoDbBean
public class Customer {
    private String name;

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

Os construtores de esquemas estáticos têm um método construtor de atributos attributeConverter() equivalente. Esse método usa uma instância de um AttributeConverter, conforme mostrado a seguir.

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

Exemplo

Este exemplo mostra uma implementação AttributeConverterProvider que fornece um conversor de atributos para objetos java.net.HttpCookie.

A classe SimpleUser a seguir contém um atributo chamado lastUsedCookie que é uma instância de HttpCookie.

O parâmetro para as anotações @DynamoDbBean lista as duas classes AttributeConverterProvider que fornecem conversores.

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

O CookieConverterProvider no exemplo a seguir fornece uma instância de um 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);
        }
    }

Código de conversão

No método transformFrom() da classe HttpCookieConverter a seguir, o código recebe uma instância HttpCookie e a transforma em um mapa do DynamoDB que é armazenado como um atributo.

O método transformTo() recebe um parâmetro de mapa do DynamoDB e, em seguida, invoca o construtor HttpCookie que exige um nome e um valor.

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