Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Conversión de atributos de control

De forma predeterminada, un esquema de tabla proporciona convertidores para muchos tipos comunes de Java mediante una implementación predeterminada de la interfaz. AttributeConverterProvider Puede cambiar el comportamiento predeterminado general con una implementación de AttributeConverterProvider personalizada. También puede cambiar el conversor de un solo atributo.

Para obtener una lista de los convertidores disponibles, consulte el documento AttributeConverterde la interfaz Java.

Proporcionar proveedores de convertidores de atributos personalizados

Puede proporcionar una AttributeConverterProvider única o una cadena de AttributeConverterProvider ordenadas a través de la anotación @DynamoDbBean (converterProviders = {…}). Cualquier AttributeConverterProvider personalizada debe extender la interfaz AttributeConverterProvider.

Tenga en cuenta que si suministra su propia cadena de proveedores de convertidores de atributos, anulará el proveedor de convertidores predeterminado DefaultAttributeConverterProvider. Si desea utilizar la funcionalidad del DefaultAttributeConverterProvider, debe incluirlo en la cadena.

También es posible anotar el bean con una matriz vacía {}. Esto deshabilita el uso de cualquier proveedor de conversión de atributos, incluido el predeterminado. En este caso, todos los atributos que se van a asignar deben tener su propio convertidor de atributos.

El fragmento siguiente muestra un único proveedor de convertidores.

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

}

El siguiente fragmento muestra el uso de una cadena de proveedores de convertidores. Como el SDK valor predeterminado se proporciona en último lugar, tiene la prioridad más baja.

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

}

Los creadores de esquemas de tablas estáticas tienen un método attributeConverterProviders() que funciona de la misma manera. Esto se muestra en el siguiente fragmento.

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

Sustituir la asignación de un único atributo

Para sustituir la forma en que se asigna un único atributo, introduzca un AttributeConverter para el atributo. Esto anula los convertidores proporcionados por AttributeConverterProviders en el esquema de la tabla. Esto añade un conversor personalizado solo para ese atributo. Otros atributos, incluso los del mismo tipo, no utilizarán ese convertidor salvo que se especifique explícitamente para esos otros atributos.

La anotación @DynamoDbConvertedBy se usa para especificar la clase AttributeConverter personalizada, como se muestra en el siguiente fragmento.

@DynamoDbBean
public class Customer {
    private String name;

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

Los generadores de esquemas estáticos tienen un método attributeConverter() de creación de atributos equivalente. Este método toma una instancia de un AttributeConverter, como se muestra a continuación.

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

Ejemplo

En este ejemplo, se muestra una implementación de AttributeConverterProvider que proporciona un conversor de atributos para objetos java.net.HttpCookie.

La siguiente clase SimpleUser contiene un nombre de atributo lastUsedCookie que es una instancia de HttpCookie.

El parámetro de las anotaciones de @DynamoDbBean muestra las dos clases de AttributeConverterProvider que proporcionan convertidores.

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

El CookieConverterProvider en el ejemplo siguiente proporciona una instancia de 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);
        }
    }

Conversión de códigos

En el método transformFrom() de la clase HttpCookieConverter siguiente, el código recibe una instancia HttpCookie y la transforma en un mapa de DynamoDB que se almacena como un atributo.

El método transformTo() recibe un parámetro de mapa de DynamoDB y, a continuación, invoca el constructor HttpCookie que requiere un nombre y un 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;
        }
    }