DynamoDB APIs 映射/文档从版本 1 到版本 2 的更改 - Amazon SDK for Java 2.x
高级别更改导入依赖关系API改变地图类和属性配置条件类型转换文档历史记录APIFAQ
Amazon Web Services 文档中描述的 Amazon Web Services 服务或功能可能因区域而异。要查看适用于中国区域的差异，请参阅 中国的 Amazon Web Services 服务入门 (PDF)。

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

DynamoDB APIs 映射/文档从版本 1 到版本 2 的更改

本主题详细介绍了APIs适用于亚马逊 DynamoDB SDK 的 Java 高级版本从版本 1.x (v1) 到 (v2) 的变化。 Amazon SDK for Java 2.x 我们首先介绍 object-to-table 映射API，然后讨论API用于处理JSON样式文档的文档。

高级别更改

在 v1 和 v2 中，每个库中映射客户端的名称不同：

  • v1-D ynamoDBMapper

  • v2-DynamoDB 增强版客户端

您与这两个库的交互方式大致相同：实例化映射器/客户端，然后提供一个 Java POJO 来读取这些项目并将其写入 Dy APIs namoDB 表。这两个库还为的类提供了注释POJO，以指导客户端如何处理POJO。

迁移到 v2 时的显著区别包括：

  • V2 和 v1 对低级 DynamoDB 操作使用不同的方法名称。例如：

    v1 v2
    load getItem
    save putItem
    batchLoad batchGetItem

  • V2 提供了多种定义表架构和映射POJOs到表格的方法。您可以选择使用注释或使用生成器从代码中生成的架构。V2 还提供架构的可变和不可变版本。

  • 在 v2 中，您专门创建表架构作为第一步，而在 v1 中，表架构是根据需要从带注释的类中推断出来的。

  • V2 在增强版API客户端中包含 Doc ument 客户端API，而 v1 则使用单独的客户端。API

  • 在 v2 中，所有版本APIs均提供同步和异步版本。

有关 v2 增强版客户端的更多详细信息，请参阅本指南中的 DynamoDB 映射部分。

导入依赖关系

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>

* 最新版本。

在 v1 中，单个依赖关系包括低级 DynamoDB API 和映射/文档，而在 v2 中API，您可以使用构件依赖关系来访问映射/文档。dynamodb-enhanced API该dynamodb-enhanced模块包含对低级dynamodb模块的传递依赖关系。

API改变

创建客户端

应用场景 v1 v2

普通实例化

 
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();

最少的实例化

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

使用属性转换器 *

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

* v2 中的扩展与 v1 中的属性转换器大致对应。本使用扩展节包含有关 v2 中扩展的更多信息。

建立到 DynamoDB 表/索引的映射

在 v1 中，您可以通过 Bean 注释指定 DynamoDB 表名。在 v2 中，一种工厂方法table()，会生成一个代表远程 Dynam DynamoDbTable oDB 表的实例。该table()方法的第一个参数是 DynamoDB 表名。

应用场景 v1 v2

将 Java POJO 类映射到 DynamoDB 表

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

映射到 DynamoDB 二级索引

  1. 定义一个表示索引的POJO类。

    • 使用@DynamoDBTable提供索引的表的名称来注释类。

    • 可以选择使用@DynamoDBIndexHashKey和对属性进行注释。@DynamoDBIndexRangeKey

  2. 创建查询表达式。

  3. 使用对表示索引的POJO类的引用进行查询。例如

    mapper.query(IdEmailIndex.class, queryExpression)

    其中IdEmailIndex是索引的映射类。

《DynamoDB 开发者指南》中讨论 query v1 方法的部分显示了一个完整的示例。

  1. 用 (for a GSI) 和 @DynamoDbSecondaryPartitionKey @DynamoDbSecondarySortKey (for and or) 注释POJO类的GSI属性。LSI例如，

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

  2. 检索对索引的引用。例如，

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

  3. 查询索引。

本指南中的使用二级索引部分提供了更多信息。

表操作

本节介绍大多数标准用例中 v1 和 v2 之间存在差异的操作APIs。

在 v2 中，所有涉及单个表的操作都是在DynamoDbTable实例上调用的，而不是在增强型客户端上调用的。增强版客户端包含可以针对多个表的方法。

在下面名为 “表操作” 的表中，POJO实例被称为item或称为特定类型，例如customer1。对于 v2 示例，命名为的实例table是先前调用的结果enhancedClient.table()，它返回了对该DynamoDbTable实例的引用。

请注意，即使未显示，也可以使用流畅的使用者模式调用大多数 v2 操作。例如，

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

对于 v1 操作，该表包含一些常用的表单，而不是所有重载的表单。例如，该load()方法有以下重载：

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)

下表显示了常用的表格：

mapper.load(item)
mapper.load(item, config)
表操作
应用场景 v1 DynamoDB 操作 v2

向 DynamoDB 表写一个 Java POJO

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

在 v1 中，DynamoDBMapperConfig.SaveBehavior注释决定了将调用哪个低级 DynamoDB 方法。通常，UpdateItem除非使用SaveBehavior.CLOBBER和，否则会被调用SaveBehavior.PUT。自动生成的密钥是一种特殊的用例，偶尔会同时使用PutItemUpdateItem和。

 PutItem, UpdateItem 
table.putItem(putItemRequest)
table.putItem(item)
table.putItemWithResponse(item) //Returns metadata.

updateItem(updateItemRequest)
table.updateItem(item)
table.updateItemWithResponse(item) //Returns metadata.
从 DynamoDB 表中读取项目到 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.
从 DynamoDB 表中删除项目 
mapper.delete(item, deleteExpression, config)
 DeleteItem 
table.deleteItem(deleteItemRequest)
table.deleteItem(item)
table.deleteItem(key)
查询 DynamoDB 表或二级索引并返回分页列表 
mapper.query(Customer.class, queryExpression)
mapper.query(Customer.class, queryExpression, mapperConfig)
 Query 
table.query(queryRequest)
table.query(queryConditional)

使用返回的PageIterable.stream()（延迟加载）进行同步响应和PagePublisher.subscribe()异步响应
查询 DynamoDB 表或二级索引并返回列表 
mapper.queryPage(Customer.class, queryExpression)
mapper.queryPage(Customer.class, queryExpression, mapperConfig)
 Query 
table.query(queryRequest)
table.query(queryConditional)

使用返回的PageIterable.items()（延迟加载）进行同步响应和PagePublisher.items.subscribe()异步响应
扫描 DynamoDB 表或二级索引并返回分页列表 
mapper.scan(Customer.class, scanExpression)
mapper.scan(Customer.class, scanExpression, mapperConfig)
 Scan 
table.scan()
table.scan(scanRequest)

使用返回的PageIterable.stream()（延迟加载）进行同步响应和PagePublisher.subscribe()异步响应
扫描 DynamoDB 表或二级索引并返回列表 
mapper.scanPage(Customer.class, scanExpression)
mapper.scanPage(Customer.class, scanExpression, mapperConfig)
 Scan 
table.scan()
table.scan(scanRequest)

使用返回的PageIterable.items()（延迟加载）进行同步响应和PagePublisher.items.subscribe()异步响应
批量读取多个表中的多个项目 
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.
将多个项目批量写入多个表 
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()))
批量删除多个表中的多个项目 
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()))
批量写入/删除多个项目 
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()))
进行交易写作 
mapper.transactionWrite(transactionWriteRequest)
 TransactWriteItems 
enhancedClient.transactWriteItems(transasctWriteItemsRequest)
进行交易性读取 
mapper.transactionLoad(transactionLoadRequest)
 TransactGetItems 
enhancedClient.transactGetItems(transactGetItemsRequest)
获取扫描或查询中匹配项的计数 
mapper.count(Customer.class, queryExpression)
mapper.count(Customer.class, scanExpression)
 Query，Scan与 Select.COUNT 不支持
在 DynamoDB 中创建与该类对应的表 POJO 
mapper.generateCreateTableRequest(Customer.class)

前面的语句生成低级创建表请求；用户必须在 DynamoDB createTable 客户端上调用。

 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()));
在 DynamoDB 中执行并行扫描 
mapper.parallelScan(Customer.class, scanExpression, numTotalSegments)
 Scan使用Segment和TotalSegments参数

用户需要处理工作线程scan并为每个分段调用：

table.scan(r -> r.segment(0).totalSegments(5))
将 Amazon S3 与 DynamoDB 集成以存储智能 S3 链接 
mapper.createS3Link(bucket, key)
mapper.getS3ClientCache()
 -

不支持，因为它将 Amazon S3 和 DynamoDB 结合在一起。

地图类和属性

在 v1 和 v2 中，您都使用豆类样式注释将类映射到表。V2 还提供了其他方法来为特定用例定义架构，例如使用不可变类。

Bean 注释

下表显示了 v1 和 v2 中使用的特定用例的等效 bean 注释。Customer类场景用于说明参数。

v2 中的注释以及类和枚举遵循驼峰大小写惯例，使用 “” 而不是 “DynamoDB”。DynamoDb

应用场景 v1 v2
将类映射到表 
@DynamoDBTable (tableName ="CustomerTable")
 
@DynamoDbBean
@DynamoDbBean(converterProviders = {...})
表名是在调用DynamoDbEDnhancedClient#table()方法时定义的。
将类成员指定为表属性 
@DynamoDBAttribute(attributeName = "customerName")
 
@DynamoDbAttribute("customerName")
将类成员指定为哈希键/分区键 
@DynamoDBHashKey 
@DynamoDbPartitionKey
将类成员指定为范围/排序键 
@DynamoDBHashKey 
@DynamoDbSortKey
将类成员指定为二级索引哈希/分区键 
@DynamoDBIndexHashKey 
@DynamoDbSecondaryPartitionKey
将类成员指定为二级索引范围/排序键 
@DynamoDBIndexRangeKey 
@DynamoDbSecondarySortKey
映射到表时忽略该类成员 
@DynamoDBIgnore 
@DynamoDbIgnore
将类成员指定为自动生成的UUID键属性 
@DynamoDBAutoGeneratedKey
 
@DynamoDbAutoGeneratedUuid

默认情况下，不加载提供此功能的扩展；您必须将扩展程序添加到客户端生成器中。
将类成员指定为自动生成的时间戳属性 
@DynamoDBAutoGeneratedTimestamp
 
@DynamoDbAutoGeneratedTimestampAttribute

默认情况下，不加载提供此功能的扩展；您必须将扩展程序添加到客户端生成器中。
将类成员指定为自动递增的版本属性 
@DynamoDBVersionAttribute
 
@DynamoDbVersionAttribute

提供此功能的扩展程序是自动加载的。
将类成员指定为需要自定义转换 
@DynamoDBTypeConverted
 
@DynamoDbConvertedBy
指定要存储为其他属性类型的类成员 
@DynamoDBTyped(<DynamoDBAttributeType>)
 无等效函数
指定可以序列化为 DynamoDB 文档JSON（样式文档）或子文档的类 
@DynamoDBDocument
 没有直接的等效注释。使用增强版文档API。

V2 附加注释

应用场景 v1 v2
如果 Java 值为空，则指定不作为NULL属性存储的类成员 不适用 
@DynamoDbIgnoreNulls
如果所有属性都为空，则将类成员指定为空对象 不适用 
@DynamoDbPreserveEmptyObject
为班级成员指定特殊更新操作 不适用 
@DynamoDbUpdateBehavior
指定一个不可变的类 不适用 
@DynamoDbImmutable
将类成员指定为自动递增的计数器属性 不适用 
@DynamoDbAtomicCounter

提供此功能的扩展程序是自动加载的。

配置

在 v1 中，您通常使用实例来控制特定的行为。DynamoDBMapperConfig您可以在创建映射器时或在发出请求时提供配置对象。在 v2 中，配置特定于操作的请求对象。

应用场景 v1 v1 中的默认值 v2 
DynamoDBMapperConfig.builder()
Batch 加载重试策略 
  .withBatchLoadRetryStrategy(batchLoadRetryStrategy)
 重试失败的项目
Batch 写入重试策略 
  .withBatchWriteRetryStrategy(batchWriteRetryStrategy)
 重试失败的项目
一致性读取 
  .withConsistentReads(CONSISTENT)
 EVENTUAL 默认情况下，读取操作的一致性读取为 false。在请求对象.consistentRead(true)上使用替换。
包含编组器/解组器集的转换架构 
  .withConversionSchema(conversionSchema)

静态实现提供了与旧版本的向后兼容性。

 V2_COMPATIBLE 不适用。这是一项传统功能，指的是最早版本的 DynamoDB (v1) 如何存储数据类型，增强版客户端中不会保留此行为。DynamoDB v1 中的一个行为示例是将布尔值存储为数字而不是布尔值。
表名称 
  .withObjectTableNameResolver()
  .withTableNameOverride() 
  .withTableNameResolver()

静态实现提供了与旧版本的向后兼容性

 使用注释或从课堂上猜测

表名是在调用DynamoDbEDnhancedClient#table()方法时定义的。
分页加载策略 
  .withPaginationLoadingStrategy(strategy)

选项有：LAZY_ LOADING EAGER_LOADING、或 ITERATION_ONLY

 LAZY_LOADING

默认为 “仅迭代”。不支持其他 v1 选项。
请求收集指标 
  .withRequestMetricCollector(collector)
 null metricPublisher()在构建标准 DynamoDB 客户端ClientOverrideConfiguration时使用。
保存行为 
  .withSaveBehavior(SaveBehavior.CLOBBER)

选项为UPDATE、CLOBBERPUT、APPEND_SET、或UPDATE_SKIP_NULL_ATTRIBUTES。

 UPDATE

在 v2 中，您可以updateItem()显式调用putItem()或。

CLOBBER or PUT: v 2 中的相应动作正在调用putItem()。没有特定的CLOBBER配置。

UPDATE: 对应于 updateItem()

UPDATE_SKIP_NULL_ATTRIBUTES: 对应于updateItem()。使用请求设置ignoreNulls和注释 DynamoDbUpdateBehavior /标签控制更新行为。

APPEND_SET: 不支持
类型转换器工厂 
  .withTypeConverterFactory(typeConverterFactory)
标准型转换器

使用在 bean 上设置

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

每个操作的配置

在 v1 中，某些操作（例如query()）可以通过提交给操作的 “表达式” 对象进行高度配置。例如：

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

mapper.query(Customer.class, emailBwQueryExpr);

在 v2 中，您不是使用配置对象，而是使用生成器在请求对象上设置参数。例如：

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

customerTable.query(emailBw);

条件

在 v2 中，条件表达式和筛选表达式使用Expression对象来表达，该对象封装了条件以及名称和过滤器的映射。

应用场景 操作 v1 v2
预期的属性条件 保存 ()、删除 ()、查询 ()、扫描 () 
new DynamoDBSaveExpression()
  .withExpected(Collections.singletonMap(
      "otherAttribute", new ExpectedAttributeValue(false)))
  .withConditionalOperator(ConditionalOperator.AND);
 已弃用；ConditionExpression改用。
条件表达式 删除 () 
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();
筛选表达式 查询 ()、扫描 () 
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();
查询条件表达式 查询 () 
queryExpression.withKeyConditionExpression()
 
QueryConditional keyEqual = QueryConditional.keyEqualTo(b -> b
                .partitionValue("movie01"));

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

类型转换

默认转换器

在 v2 中，为所有常见类型SDK提供了一组默认转换器。既可以在整体提供程序级别上更改类型转换器，也可以在单个属性上更改类型转换器。您可以在AttributeConverterAPI参考资料中找到可用转换器的列表。

为属性设置自定义转换器

在 v1 中，您可以使用对 getter 方法进行注释，@DynamoDBTypeConverted以指定在 Java 属性类型和 DynamoDB 属性类型之间进行转换的类。例如，可以应用在 Java Currency 类型和 DynamoDB 字符串之间进行转换的，如以下代码段所示。CurrencyFormatConverter

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

下面显示了上一个代码段的 v2 等效版本。

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

在 v1 中，您可以将注释应用于属性本身、类型或用户定义的注释，v2 仅支持将注释应用于 getter。

添加类型转换器工厂或提供商

在 v1 中，您可以提供自己的类型转换器集，也可以通过在配置中添加类型转换器工厂来覆盖您关心的类型。类型转换器出厂扩展DynamoDBTypeConverterFactory，覆盖是通过获取对默认集的引用并对其进行扩展来完成的。以下片段演示了如何执行此操作。

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);

V2 通过@DynamoDbBean注解提供了类似的功能。您可以提供单个AttributeConverterProvider或一系列订购AttributeConverterProvider的。请注意，如果您提供自己的属性转换器提供程序链，则将覆盖默认的转换器提供程序，并且必须将其包含在链中才能使用其属性转换器。

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

本指南中关于属性转换的部分包含了 v2 的完整示例。

文档历史记录API

该文档API支持在 DynamoDB 表中将JSON样式文档作为单个项目处理。v1 文档API在 v2 API 中有对应的，但是 v2 没有像 v1 API 那样为文档使用单独的客户端，而是在 DynamoDB 增强版客户端API中整合了文档功能。

在 v1 中，该Item类代表来自 DynamoDB 表的非结构化记录。在 v2 中，非结构化记录由该EnhancedDocument类的实例表示。请注意，主键是在 v2 的表架构中定义的，在 v1 的项目本身上定义的。

下表比较了 v1 和 v2 APIs 中文档之间的差异。

应用场景 v1 v2
创建文档客户端 
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.
引用表格 
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
放置项目 
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);
获取项目 
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
转换JSON结构以将其与文档一起使用 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());
放 JSON 
documentTable.putItem(item)
 
documentTable.putItem(document);
阅读 JSON 
GetItemOutcome outcome = //Get item.
String jsonPerson = outcome.getItem().toJSON();
 
String jsonPerson = documentTable.getItem(Key.builder()
        .partitionValue(50).build())
        .fromJson();

API文档参考和指南 APIs

v1 v2
API参考 Javadoc Javadoc
文档指南 Amazon DynamoDB 开发人员指南 增强文档 API（本指南）

FAQ

问：使用版本号进行乐观锁定在 v2 和 v1 中的工作方式是否相同？

答：行为类似，但是 v2 不会自动为删除操作添加条件。如果要控制删除行为，则必须手动添加条件表达式。