SDK for Java 버전 1과 버전 2 간의 DynamoDB 매핑 API 변경 사항 - AWS SDK for Java 2.x
클라이언트 만들기DynamoDB 테이블/인덱스에 대한 매핑 설정테이블 작업클래스 및 속성 매핑구성조건유형 변환

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

SDK for Java 버전 1과 버전 2 간의 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의 속성 변환기에 해당합니다. 이 확장 프로그램을 사용하여 DynamoDB 향상된 클라이언트 작업 사용자 지정 섹션에는 V2의 확장에 대한 자세한 내용이 포함되어 있습니다.

DynamoDB 테이블/인덱스에 대한 매핑 설정

V1에서는 bean 주석을 통해 DynamoDB 테이블 이름을 지정합니다. V2에서는 팩토리 메서드인 table()이 원격 DynamoDB 테이블을 나타내는 DynamoDbTable의 인스턴스를 생성합니다. 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는 인덱스의 매핑 클래스입니다.

V1 query 메서드에 대해 설명하는 DynamoDB 개발자 안내서의 섹션에는 전체 예제가 나와 있습니다.

  1. @DynamoDbSecondaryPartitionKey(GSI의 경우) 및 @DynamoDbSecondarySortKey(GSI 또는 LSI의 경우)를 사용하여 POJO 클래스의 속성에 주석을 추가합니다. 예: 

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

  2. 인덱스에 대한 참조를 검색합니다. 예: 

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

  3. 인덱스를 쿼리합니다.

이 안내서의 보조 인덱스 사용 섹션에서는 자세한 내용을 제공합니다.

테이블 작업

이 섹션에서는 작업 API를 설명하며, 이는 대부분의 표준 사용 사례에 대한 V1과 V2 간의 차이점이 포함됩니다.

V2에서는 단일 테이블과 관련된 모든 작업이 향상된 클라이언트가 아닌 DynamoDbTable 인스턴스에서 호출됩니다. 향상된 클라이언트에는 여러 테이블을 대상으로 지정할 수 있는 메서드가 포함되어 있습니다.

아래 테이블 작업이라는 테이블에서 POJO 인스턴스를 item 또는 customer1 등의 특정 유형이라고 합니다. V2 예제의 경우 이름이 table인 인스턴스는 DynamoDbTable 인스턴스에 대한 참조를 반환하는 enhancedClient.table()을 이전에 호출한 결과입니다.

대부분의 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 V2

DynamoDB 테이블에 Java POJO 쓰기

DynamoDB 작업: PutItem, UpdateItem 

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

V1에서 DynamoDBMapperConfig.SaveBehavior 및 주석은 호출할 하위 수준 DynamoDB 메서드를 결정합니다. 일반적으로 UpdateItem은 SaveBehavior.CLOBBER 및 SaveBehavior.PUT 코드를 사용할 때를 제외하고 호출됩니다. 자동 생성된 키는 특별한 사용 사례이며 경우에 따라 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로의 항목 읽기

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 작업: Select.COUNT로 Query

 
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 작업: Select.COUNT로 Scan

 
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 작업: Segment 및 TotalSegments 파라미터로 Scan

 
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의 주석, 클래스, 열거는 Camel 대문자 규칙을 따르고 ‘DynamoDB’가 아닌 ‘DynamoDb’를 사용합니다.

사용 사례 V1 V2
클래스를 테이블에 매핑 
@DynamoDBTable (tableName ="CustomerTable")
 
@DynamoDbBean
@DynamoDbBean(converterProviders = {...})
테이블 이름은 DynamoDbEnhancedClient#table() 메서드를 호출할 때 정의됩니다.
클래스 멤버를 테이블 속성으로 지정 
@DynamoDBAttribute(attributeName = "customerName")
 
@DynamoDbAttribute("customerName")
클래스 멤버를 해시/파티션 키로 지정 
@DynamoDBHashKey 
@DynamoDbPartitionKey
클래스 멤버를 범위/정렬 키로 지정 
@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 V2
Java 값이 null인 경우 클래스 멤버를 null 속성으로 저장하지 않도록 지정 N/A 
@DynamoDbIgnoreNulls
모든 속성이 null인 경우 클래스 멤버를 비어 있는 객체로 지정 N/A 
@DynamoDbPreserveEmptyObject
클래스 멤버에 대한 특별 업데이트 작업 지정 N/A 
@DynamoDbUpdateBehavior
변경할 수 없는 클래스 지정 N/A 
@DynamoDbImmutable
클래스 멤버를 자동 증분 카운터 속성으로 지정 N/A 
@DynamoDbAtomicCounter

이 기능을 제공하는 확장 프로그램은 자동으로 로드됩니다.

구성

V1에서는 일반적으로 DynamoDBMapperConfig의 인스턴스를 사용하여 특정 동작을 제어합니다. 매퍼를 만들거나 요청할 때 구성 객체를 제공할 수 있습니다. V2에서 구성은 작업에 대한 요청 객체에 따라 다릅니다.

사용 사례 V1 V1의 기본값 V2 
DynamoDBMapperConfig.builder()
배치 로드/쓰기 재시도 전략 
  .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 표준 DynamoDB 클라이언트를 구축할 때 ClientOverrideConfiguration에서 metricPublisher()를 사용합니다.
동작 저장 
  .withSaveBehavior(SaveBehavior.CLOBBER)

옵션은 UPDATE, CLOBBER, 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)
표준 유형 변환기

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
예상 속성 조건 save(), delete(), query(), scan() 
new DynamoDBSaveExpression()
  .withExpected(Collections.singletonMap(
      "otherAttribute", new ExpectedAttributeValue(false)))
  .withConditionalOperator(ConditionalOperator.AND);
 지원 종료되며 대신 ConditionExpression을 사용합니다.
조건 표현식 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();
필터 표현식 query(), scan() 
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();
쿼리에 대한 키 조건 표현식 query() 
queryExpression.withKeyConditionExpression()
 
QueryConditional keyEqual = QueryConditional.keyEqualTo(b -> b
                .partitionValue("movie01"));

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

유형 변환

기본 변환기

V2에서 SDK는 모든 일반 유형에 대한 기본 변환기 세트를 제공합니다. 전반적 공급자 수준과 단일 속성 모두에서 유형 변환기를 변경할 수 있습니다. AttributeConverter API 참조에서 사용 가능한 변환기 목록을 확인할 수 있습니다.

속성에 대한 사용자 지정 변환기 설정

V1에서는 @DynamoDBTypeConverted로 getter 메서드에 주석을 달아 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를 확장하며, 기본 세트에 대한 참조를 가져와서 확장하면 재정의가 수행됩니다. 다음은 이 작업을 수행하는 방법을 보여주는 Java 코드 조각입니다.

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에 대한 전체 예제가 포함되어 있습니다.