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 trabalho com o DynamoDB da versão 1 para a versão 2 do AWS SDK para Java **Topics** + [Diferenças da API de mapeamento do DynamoDB entre a versão 1 e a versão 2 do AWS SDK para Java](ddb-mapping.md) + [Documente as diferenças da API entre a versão 1 e a versão 2 do AWS SDK para Java](dynamodb-mapping-document-api.md) + [Migração da biblioteca de criptografia](ddb-encryption-lib-migrate.md) # Diferenças da API de mapeamento do DynamoDB entre a versão 1 e a versão 2 do AWS SDK para Java O APIs mapeamento do DynamoDB mudou significativamente entre a versão 1 e a versão 2 do. AWS SDK para Java Na versão 1, você usa o `DynamoDBMapper` para trabalhar com Java POJOs. Na versão 2, você usa o `DynamoDbEnhancedClient` com nomes de métodos atualizados, opções aprimoradas de definição de esquema e segurança de tipo aprimorada. As principais diferenças incluem: + Novos nomes de métodos (como `getItem` em vez de `load`) + Criação explícita de esquema de tabela + Suporte incorporado para operações síncronas e assíncronas + Mudanças na forma como as strings vazias e a configuração são tratadas Esta seção aborda as alterações da API de mapeamento, as diferenças de anotação, as atualizações de configuração e as diretrizes de migração para ajudar você a fazer a transição de `DynamoDBMapper` v1 para `DynamoDbEnhancedClient` v2. **Contents** + [Alterações de alto nível nas bibliotecas de mapeamento da versão 1 para a versão 2 do SDK para Java](dynamodb-mapping-high-level.md) + [Importar diferenças de dependência](dynamodb-mapping-high-level.md#dynamodb-mapping-deps) + [Alterações no APIs mapeamento do DynamoDB entre a versão 1 e a versão 2 do SDK for Java](dynamodb-mapping-api-changes.md) + [Criar um cliente](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-client) + [Estabelecer o mapeamento para tabela/índice do DynamoDB](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-mapping) + [Operações de tabela](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-tobleops) + [Classes e propriedades de mapa](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas) + [Anotações de bean](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas-annos) + [Anotações adicionais da V2](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas-annos-v2-addnl) + [Configuração](dynamodb-mapping-api-changes.md#dynamodb-mapping-configuration) + [Configuração por operação](dynamodb-mapping-api-changes.md#dynamodb-mapping-configuration-per-op) + [Condicionais](dynamodb-mapping-api-changes.md#dynamodb-mapping-conditionals) + [Conversão de tipo](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv) + [Conversores padrão](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-defaults) + [Definir um conversor personalizado para um atributo](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-anno) + [Adicionar uma fábrica ou fornecedor de conversor de tipo](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-factory) + [Diferenças de gerenciamento de strings entre a versão 1 e a versão 2 do SDK para Java](dynamodb-migration-string-handling.md) + [Diferenças de bloqueio positivo entre a versão 1 e a versão 2 do SDK para Java](dynamodb-migrate-optimstic-locking.md) + [Diferenças de setters fluentes entre a versão 1 e a versão 2 do SDK para Java](dynamodb-migrate-fluent-setters.md) # Alterações de alto nível nas bibliotecas de mapeamento da versão 1 para a versão 2 do SDK para Java Os nomes do cliente de mapeamento em cada biblioteca diferem da V1 para a V2: + V1 - Dínamo DBMapper + V2: Cliente Aprimorado do DynamoDB Você interage com as duas bibliotecas da mesma forma: instancia uma mapper/client e, em seguida, fornece um Java POJO para APIs essa leitura e gravação desses itens nas tabelas do DynamoDB. Ambas as bibliotecas também oferecem anotações para a classe do POJO para direcionar como o cliente lida com o POJO. As principais diferenças quando você muda para a V2 incluem: + A V2 e a V1 usam nomes de métodos diferentes para as operações de baixo nível do DynamoDB. Por exemplo: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/dynamodb-mapping-high-level.html) + A V2 oferece várias maneiras de definir esquemas de tabela e POJOs mapear para tabelas. Você pode escolher entre o uso de anotações ou um esquema gerado a partir do código usando um compilador. A V2 também oferece versões mutáveis e imutáveis dos esquemas. + Com a V2, você cria especificamente o esquema da tabela como uma das primeiras etapas, enquanto na V1, o esquema da tabela é inferido da classe anotada conforme necessário. + A V2 inclui o [cliente da API de documentos](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html) na API de cliente aprimorado, enquanto a V1 usa uma [API separada](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/DynamoDB.html). + Todos APIs estão disponíveis nas versões síncrona e assíncrona na V2. Consulte informações mais detalhadas sobre o cliente aprimorado da V2 na [seção de mapeamento do DynamoDB](dynamodb-enhanced-client.md) deste guia. ## Importar diferenças de dependência | V1 | V2 | | --- | --- | | 

  
    
      com.amazonaws
      aws-java-sdk-bom
      1.X.X
      pom
      import
    
  
 


  
    com.amazonaws
    aws-java-sdk-dynamodb
| 

  
    
      software.amazon.awssdk
      bom
      2.X.X*
      pom
      import
    
  
 


  
    software.amazon.awssdk
    dynamodb-enhanced
| \$1 [Versão mais recente](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) Na V1, uma única dependência inclui tanto a API de baixo nível do DynamoDB quanto a API, enquanto na V2, você usa mapping/document `dynamodb-enhanced` a dependência do artefato para acessar a API. mapping/document O módulo `dynamodb-enhanced` contém uma dependência transitiva do módulo de baixo nível`dynamodb`. # 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\$1 | 
DynamoDBMapper mapper = new DynamoDBMapper(standardClient, 
                        attributeTransformerInstance);
| 
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
    .dynamoDbClient(standardClient)
    .extensions(extensionAInstance, extensionBInstance)
    .build();
| \$1As extensões na V2 correspondem aproximadamente aos transformadores de atributos na V1. A seção [Usar extensões para personalizar as operações do Cliente Aprimorado do DynamoDB](ddb-en-client-extensions.md) contém mais informações sobre extensões na V2. ## Estabelecer o mapeamento para 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 de `DynamoDbTable` que representa a tabela remota do DynamoDB. O primeiro parâmetro do método `table()` é o nome da tabela do DynamoDB. **** | Caso de uso | V1 | V2 | | --- | --- | --- | | Mapear a classe Java POJO para a tabela do DynamoDB | 
@DynamoDBTable(tableName ="Customer")
public class Customer {
  ...
}
| 
DynamoDbTable customerTable = enhancedClient.table("Customer",
    TableSchema.fromBean(Customer.class));
| | Mapear para um índice secundário do DynamoDB | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) A seção do Guia do desenvolvedor do DynamoDB que discute[ o método `query` da V1](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html#DynamoDBMapper.Methods.query) mostra um exemplo completo. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) A seção [Usar índices secundários](ddb-en-client-use-secindex.md) 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 instância `DynamoDbTable`, não no cliente aprimorado. O cliente aprimorado contém métodos que podem ter como destino várias tabelas. Na tabela chamada *Operações de tabela* abaixo, uma instância POJO é chamada de `item` ou como um tipo específico, como `customer1`. Para os exemplos da V2 de as instâncias nomeadas, `table` é o resultado de uma chamada anterior a `enhancedClient.table()` que retorna uma referência à instância `DynamoDbTable`. Observe que a maioria das operações da 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 da V1, as *Operações de tabela* (abaixo) contêm algumas das formas mais usadas, mas não todas as formas com sobrecargas. Por exemplo, o método `load()` 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 as formas 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, `DynamoDBMapperConfig.SaveBehavior` e anotações determinam qual método de baixo nível do DynamoDB será chamado. Em geral, `UpdateItem` é chamado, exceto quando se usa `SaveBehavior.CLOBBER` e `SaveBehavior.PUT`. As chaves geradas automaticamente são um caso de uso especial e, ocasionalmente, tanto `PutItem` como `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.
| | Ler um item de uma tabela do DynamoDB para 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)
| | Consultar uma tabela ou um índice secundário do DynamoDB e retornar 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)
Usar o `PageIterable.stream()` retornado (carregamento lento) para respostas sincronizadas e `PagePublisher.subscribe()` para respostas assíncronas | | Consultar uma tabela ou um índice secundário do DynamoDB e retornar uma lista **Operação do DynamoDB:** `Query` | 
mapper.queryPage(Customer.class, queryExpression)
mapper.queryPage(Customer.class, queryExpression, 
                                 mapperConfig)
| 
table.query(queryRequest)
table.query(queryConditional)
Usar o `PageIterable.items()` retornado (carregamento lento) para respostas sincronizadas e `PagePublisher.items.subscribe()` para respostas assíncronas | | Verificar uma tabela ou um índice secundário do DynamoDB e retornar uma lista paginada **Operação do DynamoDB:** `Scan` | 
mapper.scan(Customer.class, scanExpression)
mapper.scan(Customer.class, scanExpression, 
                            mapperConfig)
| 
table.scan()
table.scan(scanRequest)
Usar o `PageIterable.stream()` retornado (carregamento lento) para respostas sincronizadas e `PagePublisher.subscribe()` para respostas assíncronas | | Fazer uma varredura de uma tabela ou um índice secundário do DynamoDB e retornar uma lista **Operação do DynamoDB:** `Scan` | 
mapper.scanPage(Customer.class, scanExpression)
mapper.scanPage(Customer.class, scanExpression, 
                                mapperConfig)
| 
table.scan()
table.scan(scanRequest)
Usar o `PageIterable.items()` retornado (carregamento lento) para respostas sincronizadas e `PagePublisher.items.subscribe()` para respostas assíncronas | | Ler 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, List>
| 
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()))
| | Gravar/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()))
| | Fazer uma gravação transacional **Operação do DynamoDB:** `TransactWriteItems` | 
mapper.transactionWrite(transactionWriteRequest)
| 
enhancedClient.transactWriteItems(transasctWriteItemsRequest)
| | Fazer uma leitura transacional **Operação do DynamoDB:** `TransactGetItems` | 
mapper.transactionLoad(transactionLoadRequest)
| 
enhancedClient.transactGetItems(transactGetItemsRequest)
| | Obter uma contagem de itens correspondentes de uma consulta **Operação do DynamoDB:** `Query` com `Select.COUNT` | 
mapper.count(Customer.class, queryExpression)
| 
// Get the count from query results.
PageIterable pageIterable =
    customerTable.query(QueryEnhancedRequest.builder()
        .queryConditional(queryConditional)
        .select(Select.COUNT)
        .build());
Iterator> iterator = pageIterable.iterator();
Page 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();
| | Obter uma contagem de itens correspondentes de uma varredura **Operação do DynamoDB:** `Scan` com `Select.COUNT` | 
mapper.count(Customer.class, scanExpression)
| 
// Get the count from scan results.
PageIterable pageIterable =
    customerTable.scan(ScanEnhancedRequest.builder()
        .filterExpression(filterExpression)
        .select(Select.COUNT)
        .build());
Iterator> iterator = pageIterable.iterator();
Page 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();
| | Criar 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` no 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()));
| | Fazer uma varredura paralela no DynamoDB **Operação do DynamoDB:** `Scan` com parâmetros `Segment` e `TotalSegments` | 
mapper.parallelScan(Customer.class, 
                    scanExpression, 
                    numTotalSegments)
| Os usuários devem gerenciar as threads de operador e chamar `scan` para cada segmento: 
table.scan(r -> r.segment(0).totalSegments(5))
| | Integrar o Amazon S3 com o DynamoDB para armazenar links inteligentes do S3 | 
mapper.createS3Link(bucket, key)
mapper.getS3ClientCache()
| Incompatível porque combina o Amazon S3 e o DynamoDB. | ## Classes e propriedades de 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](ddb-en-client-adv-features.md#ddb-en-client-adv-features-schm-overview) para casos de uso específicos, como trabalhar com classes imutáveis. ### Anotações de 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 de classe `Customer` é 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 classe para tabela | 
@DynamoDBTable (tableName ="CustomerTable")
| 
@DynamoDbBean
@DynamoDbBean(converterProviders = {...})
O nome da tabela é definido ao chamar o método DynamoDbEnhancedClient\$1table(). | | 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 partição/hash de índice secundário | 
@DynamoDBIndexHashKey
| 
@DynamoDbSecondaryPartitionKey
| | Designar um membro da classe é uma chave de classificação/intervalo de índice secundário | 
@DynamoDBIndexRangeKey
| 
@DynamoDbSecondarySortKey
| | Ignorar 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 compilador de cliente. | | Designar um membro da classe como um atributo de carimbo de data e hora gerado automaticamente | 
@DynamoDBAutoGeneratedTimestamp
| 
@DynamoDbAutoGeneratedTimestampAttribute
A extensão que fornece isso não é carregada por padrão; você deve adicionar a extensão ao compilador de cliente. | | Designar um membro da classe como um atributo de versão incrementado automaticamente | 
@DynamoDBVersionAttribute
| 
@DynamoDbVersionAttribute
A extensão que fornece isso é carregada automaticamente. | | Designar 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()
| Use uma implementação `AttributeConverter`. A V2 fornece muitos conversores incorporados para tipos de Java comuns. Você também pode implementar seu próprio `AttributeConverter` ou `AttributeConverterProvider` personalizado. Veja [Conversão de atributo de controle](ddb-en-client-adv-features-conversion.md) neste guia. | | Designar uma classe que possa ser serializada em um documento do DynamoDB (documento no estilo JSON) ou subdocumento | 
@DynamoDBDocument
| Use a API de documento aprimorado. Consulte os recursos a seguir:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) | ### Anotações adicionais da V2 | Caso de uso | V1 | V2 | | --- | --- | --- | | Designar um membro da classe para não ser armazenado como um atributo NULL se o valor Java for nulo | N/D | 
@DynamoDbIgnoreNulls
| | Designar um membro da classe para ser um objeto vazio se todos os atributos forem nulos | N/D | 
@DynamoDbPreserveEmptyObject
| | Designar uma ação especial de atualização para um membro da classe | N/D | 
@DynamoDbUpdateBehavior
| | Designar 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 de `DynamoDBMapperConfig`. 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)
| fazer novas tentativas de itens com falha | Configure a estratégia de novas tentativas no DynamoDBClient subjacente. Veja [Configure o comportamento de repetição no AWS SDK for Java 2.x](retry-strategy.md) 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\$1COMPATIBLE | 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 boolianos como número em vez de boolianos. | | Nomes das tabelas | 
  .withObjectTableNameResolver()
  .withTableNameOverride() 
  .withTableNameResolver()
As implementações estáticas fornecem compatibilidade retroativa com versões mais antigas | usar anotação ou suposição da classe | O nome da tabela é definido ao chamar o método `DynamoDbEnhancedClient#table()`. | | Estratégia de carregamento de paginação | 
  .withPaginationLoadingStrategy(strategy)
As opções são: LAZY\$1`LOADING`, `EAGER_LOADING` ou `ITERATION_ONLY` | LAZY\$1LOADING | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) | | Solicitar coleta de métricas | 
  .withRequestMetricCollector(collector)
| null | Use metricPublisher() em ClientOverrideConfiguration ao criar o cliente padrão do DynamoDB. | | Comportamento de salvamento | 
  .withSaveBehavior(SaveBehavior.CLOBBER)
As opções são `UPDATE`, `CLOBBER`, `PUT`, `APPEND_SET` ou `UPDATE_SKIP_NULL_ATTRIBUTES`. | UPDATE | Na V2, você chama `putItem()` ou `updateItem()` explicitamente. `CLOBBER or PUT`: a ação correspondente na v2 está chamando `putItem()`. Não há configuração `CLOBBER` 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/tag `DynamoDbUpdateBehavior`. `APPEND_SET`: incompatível | | Fábrica de conversão de tipo | 
  .withTypeConverterFactory(typeConverterFactory)
| conversores de tipo padrão | Definir o bean usando 
@DynamoDbBean(converterProviders = {ConverterProvider.class, 
        DefaultAttributeConverterProvider.class})
| ### Configuração por operação Na V1, algumas operações, como `query()`, são altamente configuráveis por meio de um objeto de “expressão” enviado à operação. Por exemplo: ``` DynamoDBQueryExpression emailBwQueryExpr = new DynamoDBQueryExpression() .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 compilador. 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 objeto `Expression`, que encapsula a condição e o mapeamento de nomes e filtros. | Caso de uso | Operações | V1 | V2 | | --- | --- | --- | --- | | Condições de atributo esperadas | save(), delete(), query(), scan() | 
new DynamoDBSaveExpression()
  .withExpected(Collections.singletonMap(
      "otherAttribute", new ExpectedAttributeValue(false)))
  .withConditionalOperator(ConditionalOperator.AND);
| Obsoleto; use ConditionExpression em vez disso. | | Expressão de condição | delete() | 
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 | query(), scan() | 
scanExpression
  .withFilterExpression("#statename = :state")
  .withExpressionAttributeValues(attributeValueMapBuilder.build())
  .withExpressionAttributeNames(attributeNameMapBuilder.build())
| 
Map 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 | query() | 
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. É possível 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 [AttributeConverter](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverter.html)API. ### Definir um conversor personalizado para um atributo Na V1, é possível e anotar um método getter com `@DynamoDBTypeConverted` para especificar a classe que é convertida entre o tipo de atributo Java e o tipo de atributo do DynamoDB. Por exemplo, um `CurrencyFormatConverter` que converte entre um tipo Java `Currency` 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 da V2 do trecho anterior é mostrado abaixo. ``` @DynamoDbConvertedBy(CurrencyFormatConverter.class) public Currency getCurrency() { return currency; } ``` **nota** Na V1, é possível aplicar a anotação ao próprio atributo, a um tipo ou a uma anotação definida pelo usuário. A V2 permite 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 tipo, ou substituir os tipos que forem importantes para você adicionando uma fábrica de conversores de tipo à configuração. A fábrica do conversor de tipos amplia `DynamoDBTypeConverterFactory` e as substituições são feitas obtendo uma referência ao conjunto padrão e ampliando-o. O trecho a seguir demonstra como fazer isso. ``` DynamoDBTypeConverterFactory typeConverterFactory = DynamoDBTypeConverterFactory.standard().override() .with(String.class, CustomBoolean.class, new DynamoDBTypeConverter() { @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); ``` A V2 fornece funcionalidade semelhante por meio da anotação `@DynamoDbBean`. Você pode fornecer um único `AttributeConverterProvider` ou uma cadeia de `AttributeConverterProvider`s ordenados. Observe que, se fornecer sua própria cadeia de provedores de conversão de atributos, você substituirá o provedor de conversão padrão, e deve incluí-lo na cadeia para usar os conversores de atributos. ``` @DynamoDbBean(converterProviders = { ConverterProvider1.class, ConverterProvider2.class, DefaultAttributeConverterProvider.class}) public class Customer { ... } ``` A seção sobre [conversão de atributos](ddb-en-client-adv-features-conversion.md#ddb-en-client-adv-features-conversion-example) neste guia contém um exemplo completo para a V2. # Diferenças de gerenciamento de strings entre a versão 1 e a versão 2 do SDK para Java A V1 e a V2 gerenciam strings vazias de forma diferente ao enviar dados para o DynamoDB: + **V1**: converte strings vazias em valores nulos antes de enviar para o DynamoDB (resultando em nenhum atributo) + **V2**: envia strings vazias como valores reais de string vazias para o DynamoDB **Importante** Depois de migrar para a V2, se você não quiser que strings vazias sejam armazenadas no DynamoDB, implemente conversores personalizados. Sem conversores personalizados, a V2 armazena strings vazias como atributos reais de string vazias nos itens do DynamoDB, o que difere do comportamento da V1 de omitir totalmente esses atributos. **Example conversor personalizado para V2 que converte um atributo de string vazia em nulo** ``` /** * Custom converter that maintains V1 behavior by converting empty strings to null values * when writing to DynamoDB, ensuring compatibility with existing data. No attribute will be saved to DynamoDB. */ public class NullifyEmptyStringConverter implements AttributeConverter { @Override public AttributeValue transformFrom(String value) { if (value == null || value.isEmpty()) { return AttributeValue.builder().nul(true).build(); } return AttributeValue.builder().s(value).build(); } @Override public String transformTo(AttributeValue attributeValue) { if (attributeValue.nul()) { return null; } return attributeValue.s(); } @Override public EnhancedType type() { return EnhancedType.of(String.class); } @Override public AttributeValueType attributeValueType() { return AttributeValueType.S; } } // V2 usage: @DynamoDbBean public class Customer { private String name; @DynamoDbConvertedBy(NullifyEmptyStringConverter.class) public String getName() { return name; } } ``` # Diferenças de bloqueio positivo entre a versão 1 e a versão 2 do SDK para Java Tanto a V1 quanto a V2 implementam um bloqueio positivo com uma anotação de atributo que marca uma propriedade em sua classe de bean para armazenar o número da versão. **Diferenças no comportamento de bloqueio positivo** | | V1 | V2 | | --- | --- | --- | | Anotação da classe de bean | @DynamoDBVersionAttribute | @DynamoDbVersionAttribute (observe que V2 usa um “b” minúsculo) | | Salvamento inicial | Atributo do número da versão definido como 1. | O valor inicial para o atributo de versão definido com `@DynamoDbVersionAttribute(startAt = X)`. O valor padrão é 0. | | Atualizar | O atributo do número da versão será incrementado em 1 se a verificação condicional confirmar que o número da versão do objeto que está sendo atualizado corresponde ao número no banco de dados. | O atributo do número da versão será incrementado se a verificação condicional confirmar que o número da versão do objeto que está sendo atualizado corresponde ao número no banco de dados. O atributo do número da versão incrementado pela opção `incrementBy` definida com `@DynamoDbVersionAttribute(incrementBy = X)`. O valor padrão é 1. | | Delete | DynamoDBMapper adiciona uma verificação condicional de que o número da versão do objeto que está sendo excluído corresponde ao número da versão no banco de dados. | A V2 não adiciona automaticamente condições para as operações de exclusão. Você deverá adicionar expressões condicionais manualmente se quiser controlar o comportamento de exclusão. No exemplo a seguir, `recordVersion` é o atributo da versão do bean. 
// 1. Read the item and get its current version.
Customer item = customerTable.getItem(Key.builder().partitionValue("someId").build());
AttributeValue currentVersion = item.getRecordVersion();

// 2. Create conditional delete with the `currentVersion` value.
DeleteItemEnhancedRequest deleteItemRequest =
    DeleteItemEnhancedRequest.builder()
       .key(KEY)
       .conditionExpression(Expression.builder()
           .expression("recordVersion = :current_version_value")
           .putExpressionValue(":current_version_value", currentVersion)
           .build()).build();

customerTable.deleteItem(deleteItemRequest);
| | Gravação transacional com verificação de condição | Você não pode usar uma classe de bean que esteja anotada com @DynamoDBVersionAttribute em um método addConditionCheck. | Você pode usar uma classe de bean com a anotação @DynamoDbVersionAttribute em um método de compilador addConditionCheck para uma solicitação transactWriteItems. | | Disable (Desabilitar) | Desabilite o bloqueio positivo alterando o valor da enumeração DynamoDBMapperConfig.SaveBehavior de UPDATE para CLOBBER. | Não use a anotação `@DynamoDbVersionAttribute`. | # Diferenças de setters fluentes entre a versão 1 e a versão 2 do SDK para Java Você pode usar POJOs com configuradores fluentes na API de mapeamento do DynamoDB para V1 e com V2 desde a versão 2.30.29. Por exemplo, o POJO a seguir retorna uma instância `Customer` do método `setName`: ``` // V1 @DynamoDBTable(tableName ="Customer") public class Customer{ private String name; // Other attributes and methods not shown. public Customer setName(String name){ this.name = name; return this; } } ``` No entanto, se você usar uma versão da V2 anterior à 2.30.29, `setName` retornará uma instância `Customer` com um valor `name` de `null`. ``` // V2 prior to version 2.30.29. @DynamoDbBean public class Customer{ private String name; // Other attributes and methods not shown. public Customer setName(String name){ this.name = name; return this; // Bug: returns this instance with a `name` value of `null`. } } ``` ``` // Available in V2 since version 2.30.29. @DynamoDbBean public class Customer{ private String name; // Other attributes and methods not shown. public Customer setName(String name){ this.name = name; return this; // Returns this instance for method chaining with the `name` value set. } } ``` # Documente as diferenças da API entre a versão 1 e a versão 2 do AWS SDK para Java A API de documentos é compatível com o trabalho com documentos no estilo JSON como itens únicos em uma tabela do DynamoDB. A API de documentos da V1 tem uma API correspondente na V2, mas em vez de usar um cliente separado para a API de documentos, como na V1, a V2 incorpora recursos dessa API no cliente aprimorado do DynamoDB. Na V1, a classe [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Item.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Item.html) representa um registro não estruturado de uma tabela do DynamoDB. Na V2, um registro não estruturado é representado por uma instância da classe [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html). Observe que as chaves primárias são definidas no esquema da tabela para a V2 e no próprio item na V1. A tabela abaixo compara as diferenças entre o documento na V1 e APIs na V2. | Caso de uso | V1 | V2 | | --- |--- |--- | | Crie um cliente de documentos | 
AmazonDynamoDB client = ... //Create a client.
DynamoDB documentClient = new DynamoDB(client);
| 
// The V2 Document API uses the same DynamoDbEnhancedClient
// that is used for mapping POJOs.
DynamoDbClient standardClient = ... //Create a standard client.
DynamoDbEnhancedClient enhancedClient = ... // Create an enhanced client.
| | Faça referência a uma tabela | 
Table documentTable = docClient.documentClient("Person");
| 
DynamoDbTable documentTable = enhancedClient.table("Person",  
        TableSchema.documentSchemaBuilder()
              .addIndexPartitionKey(TableMetadata.primaryIndexName(),"id", AttributeValueType.S)
              .attributeConverterProviders(AttributeConverterProvider.defaultProvider())
              .build());
| | **Work with semi-structured data** | | --- | | Colocar item | 
Item item = new Item()
      .withPrimaryKey("id", 50)
      .withString("firstName", "Shirley");
PutItemOutcome outcome = documentTable.putItem(item);
| 
EnhancedDocument personDocument = EnhancedDocument.builder()
        .putNumber("id", 50)
        .putString("firstName", "Shirley")
        .build();
documentTable.putItem(personDocument);
| | Obter item | 
GetItemOutcome outcome = documentTable.getItemOutcome( "id", 50);
Item personDocFromDb = outcome.getItem();
String firstName = personDocFromDb.getString("firstName");
| 
EnhancedDocument personDocFromDb = documentTable
        .getItem(Key.builder()
            .partitionValue(50)
            .build()); 
String firstName = personDocFromDb.getString("firstName");
| | **Work with JSON items** | | --- | | Converter uma estrutura JSON para usá-la com a API Document | 
// The 'jsonPerson' identifier is a JSON string. 
Item item = new Item().fromJSON(jsonPerson);
| 
// The 'jsonPerson' identifier is a JSON string.
EnhancedDocument document = EnhancedDocument.builder()
        .json(jsonPerson).build());
| | Coloque JSON | 
documentTable.putItem(item)
| 
documentTable.putItem(document);
| | Leia JSON | 
GetItemOutcome outcome = //Get item.
String jsonPerson = outcome.getItem().toJSON();
| 
String jsonPerson = documentTable.getItem(Key.builder()
        .partitionValue(50).build())
        .fromJson();
| ## Referência de API e guias para documentos APIs | | V1 | V2 | | --- | --- | --- | | Referência de API | [Referência de API](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/package-summary.html) | [Referência de API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/package-summary.html) | | Guia de documentação | [Guia do desenvolvedor do Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/JavaDocumentAPIItemCRUD.html) | [API de documentos aprimorados](ddb-en-client-doc-api.md) (este guia) | # API Xpec da V1 para API de expressões da V2 A API de especificação de expressão (Xspec) disponível na V1, que ajuda a criar expressões para trabalhar com dados orientados a documentos, não está disponível na V2. A V2 usa a API Expression, que funciona com dados orientados a documentos e object-to-item dados mapeados. **** | | V1 | V2 | | --- | --- | --- | | Nome da API | API de especificação de expressão (Xspec) | API de expressão | | Funciona com | Métodos da classe [Table](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Table.html) da API de documentos, como [updateItem](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Table.html#updateItem-java.lang.String-java.lang.Object-com.amazonaws.services.dynamodbv2.xspec.UpdateItemExpressionSpec-) e [scan](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Table.html#scan-com.amazonaws.services.dynamodbv2.xspec.ScanExpressionSpec-) | Ambos APIs do DynamoDB Enhanced Client: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/ddb-v1-xspec-migrate.html) Para os dois tipos de APIs, depois de adquirir uma [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbTable.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbTable.html)instância: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/ddb-v1-xspec-migrate.html) você usa expressões em métodos `DynamoDbTable` ao criar objetos de solicitação. Por exemplo, no método `filterExpression` do [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/QueryEnhancedRequest.Builder.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/QueryEnhancedRequest.Builder.html) | | Recursos | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/ddb-v1-xspec-migrate.html) | [Informações sobre expressões](ddb-en-client-expressions.md) neste Guia do desenvolvedor do Java | # Migração da biblioteca de criptografia Consulte informações sobre a migração da biblioteca de criptografia do DynamoDB para trabalhar com a V2 do Java SDK no [Guia do desenvolvedor do Amazon DynamoDB Encryption Client](https://docs.aws.amazon.com/database-encryption-sdk/latest/devguide/ddb-java-migrate.html).