As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# 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 interface `[AttributeConverterProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverterProvider.html)`. 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 [AttributeConverter](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverter.html)interface Java doc.
## Forneça provedores de conversão de atributos personalizados
Você pode fornecer um único `AttributeConverterProvider` ou uma cadeia de `AttributeConverterProvider`s 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_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_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 [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).
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 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, 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);
}
}
```
### 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 {
@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;
}
}
```