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 de `[AttributeConverterProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverterProvider.html)`. 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 de la [AttributeConverter](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverter.html)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 predeterminado es el último que se proporciona, 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_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_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 [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).
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 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, 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);
}
}
```
### 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 {
@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;
}
}
```