DynamoDB 對應/文檔APIs從版本1到版本2的變更 - AWS SDK for Java 2.x
高階變更匯入相依性API變化對映類別和性質組態有條件類型轉換文件歷史記錄APIFAQ

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

DynamoDB 對應/文檔APIs從版本1到版本2的變更

本主題詳細說明 Amazon DynamoDB SDK 的 Java 高級別APIs從版本 1.x (v1) 到 (v2) 的 AWS SDK for Java 2.x 變更。我們首先介紹了 object-to-table 映射，API然後討論使API用JSON樣式文檔的文檔。

高階變更

每個庫中映射客戶端的名稱在 v1 和 v2 中不同：

  • V1-ð ynamoDBMapper

  • v2-DynamoDB 強型用戶端

您可以使用大致相同的方式與這兩個程式庫互動：具現化對應器/用戶端，然後POJO將 Java 提供給APIs該讀取和寫入這些項目至 DynamoDB 資料表。這兩個程式庫也提供的類別的註解，POJO以指導用戶端如何處理POJO.

當您移動到 v2 時顯著的差異包括：

  • V2 和 v1 針對低層級 DynamoDB 作業使用不同的方法名稱。例如：

    v1 v2
    載入 getItem
    save putItem
    batchLoad batchGetItem

  • V2 提供了多種定義表結構描述和映射POJOs到表的方法。您可以從使用註釋或使用構建器從代碼生成的模式中進行選擇。V2 還提供模式的可變和不可變版本。

  • 使用 v2 時，您可以專門將資料表結構描述建立為第一個步驟之一，而在 v1 中，資料表結構描述是根據需要從註解的類別推斷出來。

  • V2 在增強型用API戶端中包含文件用戶端API，而 v1 使用單獨的API。

  • 所有APIs這些都在 v2 中提供同步和異步版本。

如需 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 和映射/文檔API，而在 v2 中，您可以使用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 中，工廠方法會產生代表遠端 DynamoDB DynamoDbTable 表格的執行個體。table()此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 開發人員指南中討論 v1 query 方法的一節顯示了一個完整的範例。

  1. 使用@DynamoDbSecondaryPartitionKey（對於 a GSI）和@DynamoDbSecondarySortKey（for 和GSI或 LSI）註釋POJO類的屬性。例如 

    @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

POJO將 Java 寫入動 DynamoDB 料表

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

在 v1 中DynamoDBMapperConfig.SaveBehavior，註解會決定將呼叫哪個低階 DynamoDB 方法。在一般情況下UpdateItem，除了使用SaveBehavior.CLOBBER和時調用SaveBehavior.PUT。自動產生的金鑰是一種特殊的使用案例，偶爾都會使用PutItem和UpdateItem。

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

updateItem(updateItemRequest)
table.updateItem(item)
table.updateItemWithResponse(item) //Returns metadata.
將動態資料表中的項目讀取為 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)

createTable上一個陳述式會產生低階建立表格要求；使用者必須呼叫 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()));
在 DynamoDB 中執行 parallel 掃描 
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 中，您可以使用 be樣式註釋將類對應到表格。V2 還提供了其他方法來定義特定用例的結構描述，例如使用不可變類。

豆註釋

下表顯示 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，則指定不要儲存為NULL屬性的類別成員 N/A 
@DynamoDbIgnoreNulls
如果所有屬性均為空，則將類別成員指定為空白物件 N/A 
@DynamoDbPreserveEmptyObject
指定類別成員的特殊更新動作 N/A 
@DynamoDbUpdateBehavior
指定一個不可變的類 N/A 
@DynamoDbImmutable
將類別成員指定為自動遞增的計數器屬性 N/A 
@DynamoDbAtomicCounter

提供此功能的擴充功能會自動載入。

組態

在 v1 中，您通常使用的執行個體來控制特定行為DynamoDBMapperConfig。您可以在建立對應程式或提出要求時提供組態物件。在 v2 中，配置特定於操作的請求對象。

使用案例 v1 第 1 版中的默認 v2 
DynamoDBMapperConfig.builder()
Batch 載入重試策略 
  .withBatchLoadRetryStrategy(batchLoadRetryStrategy)
 重試失敗的項目
Batch 寫入重試策略 
  .withBatchWriteRetryStrategy(batchWriteRetryStrategy)
 重試失敗的項目
一致性讀取 
  .withConsistentReads(CONSISTENT)
 EVENTUAL 默認情況下，讀取操作的一致讀取是假的。用請求.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)

選項有UPDATECLOBBER、PUT、APPEND_SET、或UPDATE_SKIP_NULL_ATTRIBUTES。

 UPDATE

在 V2 中，你打電話putItem()或updateItem()明確。

CLOBBER or PUT：v 2 中的對應動作正在調用putItem()。沒有特定的CLOBBER配置。

UPDATE：對應於 updateItem()

UPDATE_SKIP_NULL_ATTRIBUTES：對應於updateItem()。使用請求設定ignoreNulls和註解DynamoDbUpdateBehavior/標籤控制更新行為。

APPEND_SET：不支援
類型轉換器工廠 
  .withTypeConverterFactory(typeConverterFactory)
標準型轉換器

通過使用設置在豆

@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 屬性類型之間轉換的類別。例如，可以套用CurrencyFormatConverter在 Java Currency 類型和 DynamoDB 字串之間轉換的項目，如下列程式碼片段所示。

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

上一個代碼片段的 v2 等效如下所示。

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

在 v1 中，您可以將註釋應用於屬性本身，類型或用戶定義的註釋，v2 支持將註釋應用於吸氣器。

添加類型轉換器工廠或提供程序

在 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 s。請注意，如果您提供自己的屬性轉換器提供者鏈，則會覆寫預設轉換器提供者，並且必須將其包含在鏈中才能使用其屬性轉換器。

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

本指南中關於屬性轉換的章節包含 v2 的完整範例。

文件歷史記錄API

本文件API支援將樣JSON式文件當作 DynamoDB 表格中的單一項目使用。v1 文件API在 v2 中API具有對應的文件，但 v2 在 DynamoDB 增強型用戶端中併入文件APIAPI功能，而不是在 v1 中使用單獨的用戶端。

在 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 參考 爪哇 爪哇
文件指南 《Amazon DynamoDB 開發人員指南》https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/JavaDocumentAPIItemCRUD.html 增強型文件 API (本指南)

FAQ

問：在 v2 中使用版本號進行樂觀鎖定的工作方式與 v1 中的工作方式相同嗎？

答：行為類似，但 v2 不會自動為刪除操作添加條件。如果您要控制刪除行為，則必須手動新增條件運算式。