Alterações no APIs mapeamento do DynamoDB entre a versão 1 e a versão 2 do SDK for Java - AWS SDK for Java 2.x
Criar um clienteEstabeleça o mapeamento para a tabela/índice do DynamoDBOperações de tabelaClasses e propriedades do mapaConfiguraçãoCondicionaisConversão de tipo

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á.

Alterações no APIs mapeamento do DynamoDB entre a versão 1 e a versão 2 do SDK for Java

Criar um cliente

Caso de uso V1 V2

Instanciação normal

 
AmazonDynamoDB standardClient = AmazonDynamoDBClientBuilder.standard()
    .withCredentials(credentialsProvider)
    .withRegion(Regions.US_EAST_1)
    .build();
DynamoDBMapper mapper = new DynamoDBMapper(standardClient);
 
DynamoDbClient standardClient = DynamoDbClient.builder()
    .credentialsProvider(ProfileCredentialsProvider.create())
    .region(Region.US_EAST_1)
    .build();
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
    .dynamoDbClient(standardClient)
    .build();

Instanciação mínima

 
AmazonDynamoDB standardClient = AmazonDynamoDBClientBuilder.standard();
DynamoDBMapper mapper = new DynamoDBMapper(standardClient);
 
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.create();

Com transformador de atributo *

 
DynamoDBMapper mapper = new DynamoDBMapper(standardClient, 
                        attributeTransformerInstance);
 
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
    .dynamoDbClient(standardClient)
    .extensions(extensionAInstance, extensionBInstance)
    .build();

* As extensões na V2 correspondem aproximadamente aos transformadores de atributos na V1. A Use extensões para personalizar as operações do DynamoDB Enhanced Client seção contém mais informações sobre extensões na V2.

Estabeleça o mapeamento para a tabela/índice do DynamoDB

Na V1, você especifica um nome de tabela do DynamoDB por meio de uma anotação de bean. Na V2, um método de fábrica,table(), produz uma instância DynamoDbTable que representa a tabela remota do DynamoDB. O primeiro parâmetro do table() método é o nome da tabela do DynamoDB.

Caso de uso V1 V2

Mapeie a classe Java POJO para a tabela do DynamoDB

 
@DynamoDBTable(tableName ="Customer")
public class Customer {
  ...
}
 
DynamoDbTable<Customer> customerTable = enhancedClient.table("Customer",
    TableSchema.fromBean(Customer.class));

Mapear para um índice secundário do DynamoDB

  1. Defina uma classe POJO que represente o índice.

    • Anote a classe @DynamoDBTable fornecendo o nome da tabela que tem o índice.

    • Anote as propriedades com @DynamoDBIndexHashKey e opcionalmente. @DynamoDBIndexRangeKey

  2. Crie uma expressão de consulta.

  3. Consulte usando referência à classe POJO que representa o índice. Por exemplo

    mapper.query(IdEmailIndex.class, queryExpression)

    onde IdEmailIndex está a classe de mapeamento para o índice.

A seção do DynamoDB Developer Guide que discute o método query V1 mostra um exemplo completo.

  1. Anote os atributos de uma classe POJO com @DynamoDbSecondaryPartitionKey (para um GSI) e @DynamoDbSecondarySortKey (para e GSI ou LSI). Por exemplo, 

    @DynamoDbSecondarySortKey(indexNames = "IdEmailIndex")
public String getEmail() { return this.email; }

  2. Recupere uma referência ao índice. Por exemplo, 

    DynamoDbIndex<Customer> customerIndex = customerTable.index("IdEmailIndex");

  3. Consulte o índice.

A Usar índices secundários seção deste guia fornece mais informações.

Operações de tabela

Esta seção descreve as operações APIs que diferem entre V1 e V2 na maioria dos casos de uso padrão.

Na V2, todas as operações que envolvem uma única tabela são chamadas na DynamoDbTable instância, não no cliente aprimorado. O cliente aprimorado contém métodos que podem ter como alvo várias tabelas.

Na tabela chamada Operações de tabela abaixo, uma instância POJO é chamada de item ou como um tipo específico, comocustomer1. Para os exemplos da V2, as instâncias nomeadas table são o resultado de uma chamada anterior enhancedClient.table() que retorna uma referência à DynamoDbTable instância.

Observe que a maioria das operações V2 pode ser chamada com um padrão de consumidor fluente, mesmo quando não mostrado. Por exemplo,

Customer customer = table.getItem(r → r.key(key));
  or
Customer customer = table.getItem(r → r.key(k -> k.partitionValue("id").sortValue("email")))

Para operações V1, as operações de tabela (abaixo) contêm alguns dos formulários mais usados e nem todos os formulários sobrecarregados. Por exemplo, o load() método tem as seguintes sobrecargas:

mapper.load(Customer.class, hashKey)
mapper.load(Customer.class, hashKey, rangeKey)
mapper.load(Customer.class, hashKey, config)
mapper.load(Customer.class, hashKey, rangeKey, config)
mapper.load(item)
mapper.load(item, config)

As operações de tabela (abaixo) mostram os formulários comumente usados:

mapper.load(item)
mapper.load(item, config)
Operações de tabela
Caso de uso V1 V2

Gravar um Java POJO em uma tabela do DynamoDB

Operação do DynamoDB:, PutItem UpdateItem

 
mapper.save(item)
mapper.save(item, config)
mapper.save(item, saveExpression, config)

Na V1, as anotações DynamoDBMapperConfig.SaveBehavior determinam qual método de baixo nível do DynamoDB será chamado. Em geral, UpdateItem é chamado, exceto quando se usa SaveBehavior.CLOBBER SaveBehavior.PUT e. As chaves geradas automaticamente são um caso de uso especial e, ocasionalmente, ambas PutItem UpdateItem são usadas.

 
table.putItem(putItemRequest)
table.putItem(item)
table.putItemWithResponse(item) //Returns metadata.

updateItem(updateItemRequest)
table.updateItem(item)
table.updateItemWithResponse(item) //Returns metadata.

Leia um item de uma tabela do DynamoDB em um Java POJO

Operação do DynamoDB: GetItem

 
mapper.load(item)
mapper.load(item, config)
 
table.getItem(getItemRequest)
table.getItem(item)
table.getItem(key)
table.getItemWithResponse(key) //Returns POJO with metadata.

Excluir um item de uma tabela do DynamoDB

Operação do DynamoDB: DeleteItem

 
mapper.delete(item, deleteExpression, config)
 
table.deleteItem(deleteItemRequest)
table.deleteItem(item)
table.deleteItem(key)

Consulte uma tabela ou índice secundário do DynamoDB e retorne uma lista paginada

Operação do DynamoDB: Query

 
mapper.query(Customer.class, queryExpression)
mapper.query(Customer.class, queryExpression, 
                             mapperConfig)
 
table.query(queryRequest)
table.query(queryConditional)

Use o retornado PageIterable.stream() (carregamento lento) para respostas sincronizadas e PagePublisher.subscribe() para respostas assíncronas

Consulte uma tabela ou índice secundário do DynamoDB e retorne uma lista

Operação do DynamoDB: Query

 
mapper.queryPage(Customer.class, queryExpression)
mapper.queryPage(Customer.class, queryExpression, 
                                 mapperConfig)
 
table.query(queryRequest)
table.query(queryConditional)

Use o retornado PageIterable.items() (carregamento lento) para respostas sincronizadas e PagePublisher.items.subscribe() para respostas assíncronas

Digitalize uma tabela ou índice secundário do DynamoDB e retorne uma lista paginada

Operação do DynamoDB: Scan

 
mapper.scan(Customer.class, scanExpression)
mapper.scan(Customer.class, scanExpression, 
                            mapperConfig)
 
table.scan()
table.scan(scanRequest)

Use o retornado PageIterable.stream() (carregamento lento) para respostas sincronizadas e PagePublisher.subscribe() para respostas assíncronas

Digitalize uma tabela ou índice secundário do DynamoDB e retorne uma lista

Operação do DynamoDB: Scan

 
mapper.scanPage(Customer.class, scanExpression)
mapper.scanPage(Customer.class, scanExpression, 
                                mapperConfig)
 
table.scan()
table.scan(scanRequest)

Use o retornado PageIterable.items() (carregamento lento) para respostas sincronizadas e PagePublisher.items.subscribe() para respostas assíncronas

Leia vários itens de várias tabelas em um lote

Operação do DynamoDB: BatchGetItem

 
mapper.batchLoad(Arrays.asList(customer1, 
                               customer2, 
                               book1))
mapper.batchLoad(itemsToGet) 
           // itemsToGet: Map<Class<?>, List<KeyPair>>
 
enhancedClient.batchGetItem(batchGetItemRequest)

enhancedClient.batchGetItem(r -> r.readBatches(
    ReadBatch.builder(Record1.class)
             .mappedTableResource(mappedTable1)
             .addGetItem(i -> i.key(k -> k.partitionValue(0)))
             .build(),
    ReadBatch.builder(Record2.class)
             .mappedTableResource(mappedTable2)
             .addGetItem(i -> i.key(k -> k.partitionValue(0)))
             .build()))

// Iterate over pages with lazy loading or over all items 
   from the same table.

Gravar vários itens em várias tabelas em um lote

Operação do DynamoDB: BatchWriteItem

 
mapper.batchSave(Arrays.asList(customer1, 
                               customer2, 
                               book1)) 
enhancedClient.batchWriteItem(batchWriteItemRequest)

enhancedClient.batchWriteItem(r -> r.writeBatches(
    WriteBatch.builder(Record1.class)
             .mappedTableResource(mappedTable1)
             .addPutItem(item1)
             .build(),
    WriteBatch.builder(Record2.class)
             .mappedTableResource(mappedTable2)
             .addPutItem(item2)
             .build()))

Excluir vários itens de várias tabelas em um lote

Operação do DynamoDB: BatchWriteItem

 
mapper.batchDelete(Arrays.asList(customer1, 
                                 customer2, 
                                 book1)) 
enhancedClient.batchWriteItem(r -> r.writeBatches(
    WriteBatch.builder(Record1.class)
             .mappedTableResource(mappedTable1)
             .addDeleteItem(item1key)
             .build(),
    WriteBatch.builder(Record2.class)
             .mappedTableResource(mappedTable2)
             .addDeleteItem(item2key)
             .build()))

Escrever/excluir vários itens em um lote

Operação do DynamoDB: BatchWriteItem

 
mapper.batchWrite(Arrays.asList(customer1, book1), 
                  Arrays.asList(customer2)) 
enhancedClient.batchWriteItem(r -> r.writeBatches(
    WriteBatch.builder(Record1.class)
             .mappedTableResource(mappedTable1)
             .addPutItem(item1)
             .build(),
    WriteBatch.builder(Record2.class)
             .mappedTableResource(mappedTable2)
             .addDeleteItem(item2key)
             .build()))

Execute uma gravação transacional

Operação do DynamoDB: TransactWriteItems

 
mapper.transactionWrite(transactionWriteRequest)
 
enhancedClient.transactWriteItems(transasctWriteItemsRequest)

Realizar uma leitura transacional

Operação do DynamoDB: TransactGetItems

 
mapper.transactionLoad(transactionLoadRequest)
 
enhancedClient.transactGetItems(transactGetItemsRequest)

Obter uma contagem dos itens correspondentes de uma consulta

Operação do DynamoDB: com Query Select.COUNT

 
mapper.count(Customer.class, queryExpression)
 
// Get the count from query results.
PageIterable<Customer> pageIterable =
    customerTable.query(QueryEnhancedRequest.builder()
        .queryConditional(queryConditional)
        .select(Select.COUNT)
        .build());
Iterator<Page<Customer>> iterator = pageIterable.iterator();
Page<Customer> page = iterator.next();
int count = page.count();

// For a more concise approach, you can chain the method calls:
int count = customerTable.query(QueryEnhancedRequest.builder()
                .queryConditional(queryConditional)
                .select(Select.COUNT)
                .build())
            .iterator().next().count();

Obtenha uma contagem dos itens correspondentes de uma digitalização

Operação do DynamoDB: com Scan Select.COUNT

 
mapper.count(Customer.class, scanExpression)
 
// Get the count from scan results.
PageIterable<Customer> pageIterable =
    customerTable.scan(ScanEnhancedRequest.builder()
        .filterExpression(filterExpression)
        .select(Select.COUNT)
        .build());
Iterator<Page<Customer>> iterator = pageIterable.iterator();
Page<Customer> page = iterator.next();
int count = page.count();

// For a more concise approach, you can chain the method calls:
int count = customerTable.scan(ScanEnhancedRequest.builder()
                .filterExpression(filterExpression)
                .select(Select.COUNT)
                .build())
            .iterator().next().count();

Crie uma tabela no DynamoDB correspondente à classe POJO

Operação do DynamoDB: CreateTable

 
mapper.generateCreateTableRequest(Customer.class)

A declaração anterior gera uma solicitação de criação de tabela de baixo nível; os usuários devem chamar createTable o cliente do DynamoDB.

 
table.createTable(createTableRequest)

table.createTable(r -> r.provisionedThroughput(defaultThroughput())
    .globalSecondaryIndices(
        EnhancedGlobalSecondaryIndex.builder()
            .indexName("gsi_1")
            .projection(p -> p.projectionType(ProjectionType.ALL))
            .provisionedThroughput(defaultThroughput())
            .build()));

Execute uma varredura paralela no DynamoDB

Operação Scan do DynamoDB: com parâmetros e Segment TotalSegments

 
mapper.parallelScan(Customer.class, 
                    scanExpression, 
                    numTotalSegments)

Os usuários devem lidar com os encadeamentos de trabalho e ligar scan para cada segmento:

table.scan(r -> r.segment(0).totalSegments(5))

Integre o Amazon S3 com o DynamoDB para armazenar links inteligentes do S3

 
mapper.createS3Link(bucket, key)
mapper.getS3ClientCache()

Não é compatível porque combina o Amazon S3 e o DynamoDB.

Classes e propriedades do mapa

Tanto na V1 quanto na V2, você mapeia classes para tabelas usando anotações no estilo bean. A V2 também oferece outras formas de definir esquemas para casos de uso específicos, como trabalhar com classes imutáveis.

Anotações do Bean

A tabela a seguir mostra as anotações de bean equivalentes para um caso de uso específico que são usadas na V1 e na V2. Um cenário Customer de classe é usado para ilustrar os parâmetros.

As anotações, assim como as classes e enumerações, na V2 seguem a convenção camel case e usam '', não 'DynamoDB'. DynamoDb

Caso de uso V1 V2
Mapear a classe para a tabela 
@DynamoDBTable (tableName ="CustomerTable")
 
@DynamoDbBean
@DynamoDbBean(converterProviders = {...})
O nome da tabela é definido ao chamar o DynamoDbEnhancedClient#table() método.
Designar um membro da classe como um atributo da tabela 
@DynamoDBAttribute(attributeName = "customerName")
 
@DynamoDbAttribute("customerName")
Designar um membro da classe é fundamental hash/partition 
@DynamoDBHashKey 
@DynamoDbPartitionKey
Designar um membro da classe é fundamental range/sort 
@DynamoDBRangeKey 
@DynamoDbSortKey
Designar um membro da classe é uma chave de hash/partição de índice secundário 
@DynamoDBIndexHashKey 
@DynamoDbSecondaryPartitionKey
Designar um membro da classe é um intervalo de índice/chave de classificação secundário 
@DynamoDBIndexRangeKey 
@DynamoDbSecondarySortKey
Ignore esse membro da classe ao mapear para uma tabela 
@DynamoDBIgnore 
@DynamoDbIgnore
Designar um membro da classe como um atributo de chave UUID gerado automaticamente 
@DynamoDBAutoGeneratedKey
 
@DynamoDbAutoGeneratedUuid

A extensão que fornece isso não é carregada por padrão; você deve adicionar a extensão ao Client Builder.
Designar um membro da classe como um atributo de carimbo de data/hora gerado automaticamente 
@DynamoDBAutoGeneratedTimestamp
 
@DynamoDbAutoGeneratedTimestampAttribute

A extensão que fornece isso não é carregada por padrão; você deve adicionar a extensão ao Client Builder.
Designar um membro da classe como um atributo de versão incrementado automaticamente 
@DynamoDBVersionAttribute
 
@DynamoDbVersionAttribute

A extensão que fornece isso é carregada automaticamente.
Designe um membro da classe como solicitando uma conversão personalizada 
@DynamoDBTypeConverted
 
@DynamoDbConvertedBy
Designar um membro da classe para ser armazenado como um tipo de atributo diferente 
@DynamoDBTyped(<DynamoDBAttributeType>)

Use uma AttributeConverter implementação. A V2 fornece muitos conversores integrados para tipos comuns de Java. Você também pode implementar seu próprio AttributeConverter ou personalizadoAttributeConverterProvider. Veja Conversão de atributo de controle neste guia.
Designe uma classe que possa ser serializada em um documento do DynamoDB (documento no estilo JSON) ou subdocumento 
@DynamoDBDocument
 Use a API de documentos aprimorada. Consulte os recursos a seguir:

Anotações adicionais V2

Caso de uso V1 V2
Designe um membro da classe para não ser armazenado como um atributo NULL se o valor Java for nulo N/D 
@DynamoDbIgnoreNulls
Designe um membro da classe para ser um objeto vazio se todos os atributos forem nulos N/D 
@DynamoDbPreserveEmptyObject
Designe uma ação especial de atualização para um membro da classe N/D 
@DynamoDbUpdateBehavior
Designe uma classe imutável N/D 
@DynamoDbImmutable
Designar um membro da classe como um atributo de contador incrementado automaticamente N/D 
@DynamoDbAtomicCounter

A extensão que fornece essa funcionalidade é carregada automaticamente.

Configuração

Na V1, você geralmente controla comportamentos específicos usando uma instância deDynamoDBMapperConfig. Você pode fornecer o objeto de configuração ao criar o mapeador ou ao fazer uma solicitação. Na V2, a configuração é específica para o objeto de solicitação da operação.

Caso de uso V1 Padrão na V1 V2 
DynamoDBMapperConfig.builder()
Estratégia de load/write repetição em lote 
  .withBatchLoadRetryStrategy(loadRetryStrategy)
  .withBatchWriteRetryStrategy(writeRetryStrategy)
 tente novamente itens com falha Configure a estratégia de repetição no subjacenteDynamoDBClient. Veja Configure o comportamento de repetição no AWS SDK for Java 2.x neste guia.
Leituras consistentes 
  .withConsistentReads(CONSISTENT)
 EVENTUAL Por padrão, leituras consistentes são falsas para operações de leitura. Substitua por .consistentRead(true) no objeto de solicitação.
Esquema de conversão com conjuntos de marshallers/unmarshallers 
  .withConversionSchema(conversionSchema)

As implementações estáticas fornecem compatibilidade retroativa com versões mais antigas.

 V2_COMPATIBLE Não aplicável. Esse é um recurso legado que se refere à forma como as versões mais antigas do DynamoDB (V1) armazenavam os tipos de dados, e esse comportamento não será preservado no cliente aprimorado. Um exemplo de comportamento no DynamoDB V1 é armazenar booleanos como número em vez de booleanos.
Nomes das tabelas 
  .withObjectTableNameResolver()
  .withTableNameOverride() 
  .withTableNameResolver()

Implementações estáticas fornecem compatibilidade retroativa com versões mais antigas

 use anotação ou suposição da classe

O nome da tabela é definido ao chamar o DynamoDbEnhancedClient#table() método.
Estratégia de carregamento de paginação 
  .withPaginationLoadingStrategy(strategy)

As opções são: LAZY_LOADING,, ou EAGER_LOADING ITERATION_ONLY

 LAZY_LOADING

  • Somente a iteração é o padrão. As outras opções da V1 não são suportadas.

  • Você pode implementar o equivalente ao carregamento antecipado na V2 com o seguinte: 

    List<Customer> allItems = 
    customerTable.scan().items().stream().collect(Collectors.toList());

  • Para carregamento lento, você deve implementar sua própria lógica de armazenamento em cache para itens acessados.
Solicitar coleta de métricas 
  .withRequestMetricCollector(collector)
 null Use metricPublisher() in ClientOverrideConfiguration ao criar o cliente padrão do DynamoDB.
Salvar comportamento 
  .withSaveBehavior(SaveBehavior.CLOBBER)

As opções são UPDATECLOBBER,PUT,APPEND_SET, ouUPDATE_SKIP_NULL_ATTRIBUTES.

 UPDATE

Na V2, você liga putItem() ou updateItem() explicitamente.

CLOBBER or PUT: A ação correspondente na v 2 está chamandoputItem(). Não há CLOBBER configuração específica.

UPDATE: Corresponde a updateItem()

UPDATE_SKIP_NULL_ATTRIBUTES: Corresponde updateItem() a. Controle o comportamento da atualização com a configuração da solicitação ignoreNulls e a anotação/tagDynamoDbUpdateBehavior.

APPEND_SET: Não suportado
Tipo de fábrica de conversores 
  .withTypeConverterFactory(typeConverterFactory)
conversores de tipo padrão

Defina o feijão usando

@DynamoDbBean(converterProviders = {ConverterProvider.class, 
        DefaultAttributeConverterProvider.class})

Configuração por operação

Na V1, algumas operações, comoquery(), são altamente configuráveis por meio de um objeto de “expressão” enviado à operação. Por exemplo:

DynamoDBQueryExpression<Customer> emailBwQueryExpr = new DynamoDBQueryExpression<Customer>()
    .withRangeKeyCondition("Email",
        new Condition()
            .withComparisonOperator(ComparisonOperator.BEGINS_WITH)
            .withAttributeValueList(
                new AttributeValue().withS("my")));

mapper.query(Customer.class, emailBwQueryExpr);

Na V2, em vez de usar um objeto de configuração, você define parâmetros no objeto de solicitação usando um construtor. Por exemplo:

QueryEnhancedRequest emailBw = QueryEnhancedRequest.builder()
    .queryConditional(QueryConditional
        .sortBeginsWith(kb -> kb
            .sortValue("my"))).build();

customerTable.query(emailBw);

Condicionais

Na V2, as expressões condicionais e de filtragem são expressas usando um Expression objeto, que encapsula a condição e o mapeamento de nomes e filtros.

Caso de uso Operações V1 V2
Condições de atributo esperadas salvar (), excluir (), consultar (), escanear () 
new DynamoDBSaveExpression()
  .withExpected(Collections.singletonMap(
      "otherAttribute", new ExpectedAttributeValue(false)))
  .withConditionalOperator(ConditionalOperator.AND);
 Obsoleto; use em vez disso. ConditionExpression
Expressão de condição excluir () 
deleteExpression.setConditionExpression("zipcode = :zipcode")
deleteExpression.setExpressionAttributeValues(...)

Expression conditionExpression =
    Expression.builder()
        .expression("#key = :value OR #key1 = :value1")
        .putExpressionName("#key", "attribute")
        .putExpressionName("#key1", "attribute3")
        .putExpressionValue(":value", AttributeValues.stringValue("wrong"))
        .putExpressionValue(":value1", AttributeValues.stringValue("three"))
        .build();

DeleteItemEnhancedRequest request = DeleteItemEnhancedRequest.builder()
         .conditionExpression(conditionExpression).build();
Expressão de filtro consulta (), digitalização () 
scanExpression
  .withFilterExpression("#statename = :state")
  .withExpressionAttributeValues(attributeValueMapBuilder.build())
  .withExpressionAttributeNames(attributeNameMapBuilder.build())

Map<String, AttributeValue> values = singletonMap(":key", stringValue("value"));
Expression filterExpression =
    Expression.builder()
        .expression("name = :key")
        .expressionValues(values)
        .build();
QueryEnhancedRequest request = QueryEnhancedRequest.builder()
    .filterExpression(filterExpression).build();
Expressão de condição para consulta consulta () 
queryExpression.withKeyConditionExpression()
 
QueryConditional keyEqual = QueryConditional.keyEqualTo(b -> b
                .partitionValue("movie01"));

QueryEnhancedRequest tableQuery = QueryEnhancedRequest.builder()
                .queryConditional(keyEqual)
                .build();

Conversão de tipo

Conversores padrão

Na V2, o SDK fornece um conjunto de conversores padrão para todos os tipos comuns. Você pode alterar os conversores de tipo tanto no nível geral do provedor quanto em um único atributo. Você pode encontrar uma lista dos conversores disponíveis na referência da AttributeConverterAPI.

Definir um conversor personalizado para um atributo

Na V1, você pode anotar um método getter @DynamoDBTypeConverted para especificar a classe que é convertida entre o tipo de atributo Java e o tipo de atributo do DynamoDB. Por exemplo, uma CurrencyFormatConverter que converte entre um Currency tipo Java e uma string do DynamoDB pode ser aplicada conforme mostrado no trecho a seguir.

@DynamoDBTypeConverted(converter = CurrencyFormatConverter.class)
public Currency getCurrency() { return currency; }

O equivalente V2 do trecho anterior é mostrado abaixo.

@DynamoDbConvertedBy(CurrencyFormatConverter.class)
public Currency getCurrency() { return currency; }
nota

Na V1, você pode aplicar a anotação ao próprio atributo, a um tipo ou a uma anotação definida pelo usuário. A V2 suporta a aplicação da anotação somente ao getter.

Adicionar uma fábrica ou fornecedor de conversor de tipo

Na V1, você pode fornecer seu próprio conjunto de conversores de tipos ou substituir os tipos que lhe interessam adicionando uma fábrica de conversores de tipos à configuração. A fábrica do conversor de tipos se estende DynamoDBTypeConverterFactory e as substituições são feitas obtendo uma referência ao conjunto padrão e estendendo-o. O trecho a seguir demonstra como fazer isso.

DynamoDBTypeConverterFactory typeConverterFactory =
    DynamoDBTypeConverterFactory.standard().override()
        .with(String.class, CustomBoolean.class, new DynamoDBTypeConverter<String, CustomBoolean>() {
            @Override
            public String convert(CustomBoolean bool) {
                return String.valueOf(bool.getValue());
            }
            @Override
            public CustomBoolean unconvert(String string) {
                return new CustomBoolean(Boolean.valueOf(string));
            }}).build();
DynamoDBMapperConfig config =
    DynamoDBMapperConfig.builder()
        .withTypeConverterFactory(typeConverterFactory)
        .build();
DynamoDBMapper mapperWithTypeConverterFactory = new DynamoDBMapper(dynamo, config);

O V2 fornece funcionalidade semelhante por meio da @DynamoDbBean anotação. Você pode fornecer um único AttributeConverterProvider ou uma cadeia de AttributeConverterProvider s pedidos. Observe que, se você fornecer sua própria cadeia de provedores de conversão de atributos, substituirá o provedor de conversão padrão e deverá incluí-lo na cadeia para usar seus conversores de atributos. 

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

A seção sobre conversão de atributos neste guia contém um exemplo completo para a V2.