Alterações no APIs mapeamento/documento do DynamoDB da versão 1 para a versão 2 - AWS SDK for Java 2.x
Alterações de alto nívelImportar dependênciasAPImudançasClasses e propriedades do mapaConfiguraçãoCondicionaisConversão de tipoHistórico do documentoAPIFAQ

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/documento do DynamoDB da versão 1 para a versão 2

Este tópico detalha as mudanças no alto nível SDK do Java APIs para o Amazon DynamoDB da versão 1.x (v1) para a (v2). AWS SDK for Java 2.x Primeiro abordamos o object-to-table mapeamento API e, em seguida, discutimos o documento API para trabalhar com documentos JSON no estilo.

Alterações de alto nível

Os nomes do cliente de mapeamento em cada biblioteca diferem em v1 e v2:

  • v1 - D ynamoDBMapper

  • v2 - Cliente aprimorado do DynamoDB

Você interage com as duas bibliotecas da mesma forma: instancia um mapeador/cliente e, em seguida, fornece um Java POJO para APIs que leia e grave esses 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

Diferenças notáveis quando você muda para a v2 incluem:

  • As versões V2 e v1 usam nomes de métodos diferentes para as operações de baixo nível do DynamoDB. Por exemplo: .

    v1 v2
    load getItem
    save putItem
    batchLoad batchGetItem

  • 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 construtor. 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 APIcliente Document no cliente aprimoradoAPI, enquanto a v1 usa um separado. API

  • Todos APIs estão disponíveis nas versões síncrona e assíncrona na v2.

Consulte a seção de mapeamento do DynamoDB neste guia para obter informações mais detalhadas sobre o cliente aprimorado v2.

Importar dependências

v1 v2 
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.amazonaws</groupId>
      <artifactId>aws-java-sdk-bom</artifactId>
      <version>1.X.X</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement> 

<dependencies>
  <dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>aws-java-sdk-dynamodb</artifactId>
  </dependency>
</dependencies>
 
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>bom</artifactId>
      <version>2.X.X*</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement> 

<dependencies>
  <dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>dynamodb-enhanced</artifactId>
  </dependency>
</dependencies>

* Versão mais recente.

Na v1, uma única dependência inclui o DynamoDB API de baixo nível e o mapeamento/documento, enquanto na v2, você usa a dependência do artefato para acessar o API mapeamento/documento. dynamodb-enhanced API O dynamodb-enhanced módulo contém uma dependência transitiva do módulo de baixo níveldynamodb.

APImudanças

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 Usar extensões 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 POJO classe Java 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 POJO classe 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 à POJO classe que representa o índice. Por exemplo

    mapper.query(IdEmailIndex.class, queryExpression)

    onde IdEmailIndex está a classe de mapeamento do í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 POJO classe com @DynamoDbSecondaryPartitionKey (para a 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 POJO instância é 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, a tabela 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)

A tabela mostra os formulários comumente usados:

mapper.load(item)
mapper.load(item, config)
Operações de tabela
Caso de uso v1 Operação do DynamoDB v2

Gravar um Java em uma POJO tabela do DynamoDB

 
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.

 PutItem, UpdateItem 
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 para um Java POJO 
mapper.load(item)
mapper.load(item, config)
 GetItem 
table.getItem(getItemRequest)
table.getItem(item)
table.getItem(key)
table.getItemWithResponse(key) //Returns POJO with metadata.
Excluir um item de uma tabela do DynamoDB 
mapper.delete(item, deleteExpression, config)
 DeleteItem 
table.deleteItem(deleteItemRequest)
table.deleteItem(item)
table.deleteItem(key)
Consulte uma tabela ou índice secundário do DynamoDB e retorne uma lista paginada 
mapper.query(Customer.class, queryExpression)
mapper.query(Customer.class, queryExpression, mapperConfig)
 Query 
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 
mapper.queryPage(Customer.class, queryExpression)
mapper.queryPage(Customer.class, queryExpression, mapperConfig)
 Query 
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 
mapper.scan(Customer.class, scanExpression)
mapper.scan(Customer.class, scanExpression, mapperConfig)
 Scan 
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 
mapper.scanPage(Customer.class, scanExpression)
mapper.scanPage(Customer.class, scanExpression, mapperConfig)
 Scan 
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 
mapper.batchLoad(Arrays.asList(customer1, customer2, book1))
mapper.batchLoad(itemsToGet) // itemsToGet: Map<Class<?>, List<KeyPair>>
 BatchGetItem 
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 
mapper.batchSave(Arrays.asList(customer1, customer2, book1))
BatchWriteItem 
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 
mapper.batchDelete(Arrays.asList(customer1, customer2, book1))
BatchWriteItem 
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 
mapper.batchWrite(Arrays.asList(customer1, book1), Arrays.asList(customer2))
BatchWriteItem 
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 
mapper.transactionWrite(transactionWriteRequest)
 TransactWriteItems 
enhancedClient.transactWriteItems(transasctWriteItemsRequest)
Realizar uma leitura transacional 
mapper.transactionLoad(transactionLoadRequest)
 TransactGetItems 
enhancedClient.transactGetItems(transactGetItemsRequest)
Obtenha a contagem dos itens correspondentes de uma digitalização ou consulta 
mapper.count(Customer.class, queryExpression)
mapper.count(Customer.class, scanExpression)
 Query, Scan com Select.COUNT Sem compatibilidade
Crie uma tabela no DynamoDB correspondente à classe POJO 
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.

 CreateTable 
table.createTable(createTableRequest)

table.createTable(r -> r.provisionedThroughput(getDefaultProvisionedThroughput())
        .globalSecondaryIndices(
                EnhancedGlobalSecondaryIndex.builder()
                        .indexName("gsi_1")
                        .projection(p -> p.projectionType(ProjectionType.ALL))
                        .provisionedThroughput(getDefaultProvisionedThroughput())
                        .build()));
Execute uma varredura paralela no DynamoDB 
mapper.parallelScan(Customer.class, scanExpression, numTotalSegments)
 Scancom Segment e TotalSegments parâmetros

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 em v1 e 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 de casos do Camel 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 DynamoDbEDnhancedClient#table() método.
Designar um membro da classe como um atributo da tabela 
@DynamoDBAttribute(attributeName = "customerName")
 
@DynamoDbAttribute("customerName")
Designar um membro da classe é uma chave de hash/partição 
@DynamoDBHashKey 
@DynamoDbPartitionKey
Designar um membro da classe é uma chave de intervalo/classificação 
@DynamoDBHashKey 
@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-chave gerado automaticamente UUID 
@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>)
 Não há equivalente
Designe uma classe que possa ser serializada em um documento (documento em estilo) ou subdocumento do DynamoDB JSON 
@DynamoDBDocument
 Sem anotação equivalente direta. Use o documento aprimoradoAPI.

Anotações adicionais V2

Caso de uso v1 v2
Designe um membro da classe para não ser armazenado como um NULL atributo 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 nova tentativa de carregamento em lote 
  .withBatchLoadRetryStrategy(batchLoadRetryStrategy)
 tente novamente itens com falha
Estratégia de nova tentativa de gravação em lote 
  .withBatchWriteRetryStrategy(batchWriteRetryStrategy)
 tente novamente itens com falha
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 com versões anteriores.

 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 com versões anteriores

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

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

As opções são: LAZY _ LOADINGEAGER_LOADING, ou ITERATION_ONLY

 LAZY_LOADING

Somente a iteração é o padrão. As outras opções v1 não são suportadas.
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
Fábrica de conversão de tipos 
  .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 AttributeConverterAPIreferência.

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, um tipo ou 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.

Histórico do documentoAPI

O documento API permite trabalhar com documentos no JSON estilo -como itens únicos em uma tabela do DynamoDB. O documento v1 API tem uma correspondência API na v2, mas em vez de usar um cliente separado para o documento, API como na v1, a v2 incorpora recursos do documento no cliente aprimorado do API DynamoDB.

Na v1, a Itemclasse representa um registro não estruturado de uma tabela do DynamoDB. Na v2, um registro não estruturado é representado por uma instância da EnhancedDocumentclasse. 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 APIs na v1 e 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<EnhancedDocument> 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 JSON estrutura para usá-la com o documento API 
// 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());
Colocar 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();

APIreferência e guias para o documento APIs

v1 v2
APIreferência Javadoc Javadoc
Guia de documentação Guia do desenvolvedor do Amazon DynamoDB Documento aprimorado API (este guia)

FAQ

P: O bloqueio otimista com um número de versão funciona da mesma forma na v2 e na v1?

R. O comportamento é semelhante, mas a v2 não adiciona automaticamente condições para as operações de exclusão. Você deve adicionar expressões condicionais manualmente se quiser controlar o comportamento de exclusão.