适用于 Java 的 SDK 版本 1 和版本 2 之间的 DynamoDB APIs 映射发生了变化 - AWS SDK for Java 2.x
创建客户端建立到 DynamoDB 表/索引的映射表操作地图类和属性配置条件类型转换

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

适用于 Java 的 SDK 版本 1 和版本 2 之间的 DynamoDB APIs 映射发生了变化

创建客户端

应用场景 V1 第 2 版

普通实例化

 
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 中的属性转换器大致对应。本使用扩展程序自定义 DynamoDB 增强型客户端操作节包含有关 V2 中扩展的更多信息。

建立到 DynamoDB 表/索引的映射

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

应用场景 V1 第 2 版

将 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. 使用（对于 GSI）和@DynamoDbSecondaryPartitionKey（for 和 @DynamoDbSecondarySortKeyGSI 或 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 第 2 版

向 DynamoDB 表写一个 Java POJO

DynamoDB 操作：，PutItemUpdateItem

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

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

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

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

从 DynamoDB 表中读取一个项目到 Java POJO

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.

从 DynamoDB 表中删除项目

DynamoDB 操作：DeleteItem

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

查询 DynamoDB 表或二级索引并返回分页列表

DynamoDB 操作：Query

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

使用返回的PageIterable.stream()（延迟加载）进行同步响应和PagePublisher.subscribe()异步响应

查询 DynamoDB 表或二级索引并返回列表

DynamoDB 操作：Query

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

使用返回的PageIterable.items()（延迟加载）进行同步响应和PagePublisher.items.subscribe()异步响应

扫描 DynamoDB 表或二级索引并返回分页列表

DynamoDB 操作：Scan

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

使用返回的PageIterable.stream()（延迟加载）进行同步响应和PagePublisher.subscribe()异步响应

扫描 DynamoDB 表或二级索引并返回列表

DynamoDB 操作：Scan

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

使用返回的PageIterable.items()（延迟加载）进行同步响应和PagePublisher.items.subscribe()异步响应

批量读取多个表中的多个项目

DynamoDB 操作：BatchGetItem

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

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

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

将多个项目批量写入多个表

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

批量删除多个表中的多个项目

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

批量写入/删除多个项目

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

进行交易写作

DynamoDB 操作：TransactWriteItems

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

进行交易性读取

DynamoDB 操作：TransactGetItems

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

获取查询中匹配项的计数

DynamoDB 操作：使用 Query Select.COUNT

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

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

获取扫描中匹配的项目数量

DynamoDB 操作：使用 Scan Select.COUNT

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

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

在 DynamoDB 中创建与 POJO 类对应的表

DynamoDB 操作：CreateTable

 
mapper.generateCreateTableRequest(Customer.class)

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

 
table.createTable(createTableRequest)

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

在 DynamoDB 中执行并行扫描

DynamoDB 操作Scan：使用和参数 Segment TotalSegments

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

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

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

将 Amazon S3 与 DynamoDB 集成以存储智能 S3 链接

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

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

地图类和属性

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

Bean 注释

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

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

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

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

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

提供此功能的扩展程序是自动加载的。
将类成员指定为需要自定义转换 
@DynamoDBTypeConverted
 
@DynamoDbConvertedBy
指定要存储为其他属性类型的类成员 
@DynamoDBTyped(<DynamoDBAttributeType>)

使用AttributeConverter实现。V2 为常见 Java 类型提供了许多内置转换器。您也可以实现自己的自定义AttributeConverter或AttributeConverterProvider. 请参阅本指南中的控制属性转换。
指定一个可以序列化为 DynamoDB 文档（JSON 风格的文档）或子文档的类 
@DynamoDBDocument
 使用增强型文档 API。请参阅以下资源：

V2 附加注释

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

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

配置

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

应用场景 V1 V1 中的默认设置 第 2 版 
DynamoDBMapperConfig.builder()
Batch load/write 重试策略 
  .withBatchLoadRetryStrategy(loadRetryStrategy)
  .withBatchWriteRetryStrategy(writeRetryStrategy)
 重试失败的项目 在底层DynamoDBClient配置重试策略。请参阅本指南中的在中配置重试行为 AWS SDK for Java 2.x。
一致性读取 
  .withConsistentReads(CONSISTENT)
 EVENTUAL 默认情况下，读取操作的一致性读取为 false。在请求对象.consistentRead(true)上使用替换。
包含编组器/解组器集的转换架构 
  .withConversionSchema(conversionSchema)

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

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

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

 使用注释或从课堂上猜测

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

选项有：LAZY_ LOADING、或 EAGER_LOADING ITERATION_ONLY

 LAZY_LOADING

  • 默认为 “仅迭代”。不支持其他 V1 选项。

  • 你可以通过以下方式在 V2 中实现等同于预加载的功能：

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

  • 对于延迟加载，您必须为访问的项目实现自己的缓存逻辑。
请求收集指标 
  .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 第 2 版
预期的属性条件 保存 ()、删除 ()、查询 ()、扫描 () 
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 的完整示例。