Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Memulai dengan DynamoDB Mapper
<a name="ddb-mapper-get-started"></a>

****  
**DynamoDB Mapper adalah rilis Pratinjau Pengembang. Ini tidak lengkap fitur dan dapat berubah.**

Tutorial berikut memperkenalkan komponen dasar DynamoDB Mapper dan menunjukkan bagaimana menggunakannya dalam kode Anda.

## Tambahkan dependensi
<a name="ddb-mapper-get-started-deps"></a>

Untuk mulai bekerja dengan DynamoDB Mapper dalam proyek Gradle Anda, tambahkan plugin dan dua dependensi ke file Anda. `build.gradle.kts`

(Anda dapat menavigasi ke *X.Y.Z* tautan untuk melihat versi terbaru yang tersedia.)

```
// build.gradle.kts
val sdkVersion: String = [https://github.com/awslabs/aws-sdk-kotlin/releases/latest](https://github.com/awslabs/aws-sdk-kotlin/releases/latest)

plugins {
    id("aws.sdk.kotlin.hll.dynamodbmapper.schema.generator") version "$sdkVersion-beta" // For the Developer Preview, use the beta version of the latest SDK.
}

dependencies {
    implementation("aws.sdk.kotlin:dynamodb-mapper:$sdkVersion-beta")
    implementation("aws.sdk.kotlin:dynamodb-mapper-annotations:$sdkVersion-beta")
}
```

\$1Ganti *<Version>* dengan rilis SDK terbaru. Untuk menemukan versi terbaru SDK, periksa [rilis terbaru di GitHub](https://github.com/awslabs/aws-sdk-kotlin/releases/latest).

**catatan**  
Beberapa dependensi ini bersifat opsional jika Anda berencana untuk mendefinisikan skema secara manual. Lihat [Tentukan skema secara manual](ddb-mapper-code-schemas.md) untuk informasi lebih lanjut dan kumpulan dependensi yang dikurangi.

## Membuat dan menggunakan mapper
<a name="ddb-mapper-get-started-mapper"></a>

DynamoDB Mapper menggunakan klien DynamoDB untuk AWS SDK untuk Kotlin berinteraksi dengan DynamoDB. Anda perlu menyediakan instance yang sepenuhnya dikonfigurasi saat membuat [https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb/aws.sdk.kotlin.services.dynamodb/-dynamo-db-client/index.html](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb/aws.sdk.kotlin.services.dynamodb/-dynamo-db-client/index.html)instance mapper seperti yang ditunjukkan pada cuplikan kode berikut:

```
import aws.sdk.kotlin.hll.dynamodbmapper.DynamoDbMapper
import aws.sdk.kotlin.services.dynamodb.DynamoDbClient

val client = DynamoDbClient.fromEnvironment()
val mapper = DynamoDbMapper(client)
```

**catatan**  
`DynamoDbMapper`tidak mendukung operasi pembuatan tabel. Gunakan `DynamoDbClient` untuk membuat tabel.

Setelah Anda membuat instance mapper, Anda dapat menggunakannya untuk mendapatkan contoh tabel seperti yang ditunjukkan berikut:

```
val carsTable = mapper.getTable("cars", CarSchema)
```

Kode sebelumnya mendapat referensi ke tabel `DynamoDB` bernama `cars` dengan skema yang ditentukan oleh `CarSchema` (kita membahas skema di bawah). Setelah Anda membuat instance tabel, Anda dapat melakukan operasi terhadapnya. Cuplikan kode berikut menunjukkan dua contoh operasi terhadap tabel`cars`:

```
carsTable.putItem {
    item = Car(make = "Ford", model = "Model T", ...)
}

carsTable
   .queryPaginated {
        keyCondition = KeyFilter(partitionKey = "Peugeot")
   }
   .items()
   .collect { car -> println(car) }
```

Kode sebelumnya membuat item baru dalam `cars` tabel. Kode membuat `Car` instance inline menggunakan `Car` kelas, yang definisinya ditunjukkan di bawah ini. Selanjutnya, kode menanyakan `cars` tabel untuk item yang kunci partisi `Peugeot` dan mencetaknya. Operasi [dijelaskan secara lebih rinci di bawah ini](#ddb-mapper-gs-invoke-ops).

## Tentukan skema dengan anotasi kelas
<a name="ddb-mapper-gs-anno-schema-def"></a>

Untuk berbagai class Kotlin, SDK dapat secara otomatis menghasilkan skema pada waktu pembuatan dengan menggunakan plugin DynamoDB Mapper Schema Generator untuk Gradle. Saat Anda menggunakan generator skema, SDK akan memeriksa kelas Anda untuk menyimpulkan skema, yang mengurangi beberapa boilerplate yang terlibat dalam mendefinisikan skema secara manual. [Anda dapat menyesuaikan skema yang dihasilkan dengan menggunakan [anotasi dan konfigurasi](ddb-mapper-anno-schema-gen.md#ddb-mapper-anno-schema-gen-annotate) tambahan.](ddb-mapper-anno-schema-gen.md#ddb-mapper-anno-schema-gen-conf-plugin)

Untuk menghasilkan skema dari anotasi, pertama-tama beri anotasi pada kelas Anda dengan dan kunci apa pun dengan `@[DynamoDbItem](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-item/index.html)` dan. `@[DynamoDbPartitionKey](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-partition-key/index.html)` `@[DynamoDbSortKey](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-sort-key/index.html)` Kode berikut menunjukkan kelas beranotasi`Car`:

```
// The annotations used in the Car class are used by the plugin to generate a schema.
@DynamoDbItem
data class Car(
    @DynamoDbPartitionKey
    val make: String,
    
    @DynamoDbSortKey
    val model: String,
    
    val initialYear: Int
)
```

Setelah membangun, Anda dapat merujuk ke yang dihasilkan secara otomatis`CarSchema`. Anda dapat menggunakan referensi dalam `getTable` metode mapper untuk mendapatkan contoh tabel seperti yang ditunjukkan dalam berikut ini:

```
import aws.sdk.kotlin.hll.dynamodbmapper.generatedschemas.CarSchema

// `CarSchema` is generated at build time.
val carsTable = mapper.getTable("cars", CarSchema)
```

Atau, Anda bisa mendapatkan instance tabel dengan memanfaatkan metode ekstensi `[DynamoDbMapper](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-mapper/index.html)` yang dibuat secara otomatis pada waktu pembuatan. Dengan menggunakan pendekatan ini, Anda tidak perlu merujuk ke skema dengan nama. Seperti yang ditunjukkan dalam berikut ini, metode `getCarsTable` ekstensi yang dihasilkan secara otomatis mengembalikan referensi ke contoh tabel:

```
val carsTable = mapper.getCarsTable("cars")
```

Lihat [Hasilkan skema dari anotasi](ddb-mapper-anno-schema-gen.md) untuk detail dan contoh selengkapnya.

## Memanggil operasi
<a name="ddb-mapper-gs-invoke-ops"></a>

DynamoDB Mapper mendukung subset operasi yang tersedia di SDK. `DynamoDbClient` Operasi mapper diberi nama sama dengan rekan-rekan mereka pada klien SDK. Banyak request/response anggota mapper sama dengan rekan klien SDK mereka, meskipun beberapa telah diganti namanya, diketik ulang, atau dihapus sama sekali.

Anda memanggil operasi pada instance tabel menggunakan sintaks DSL seperti yang ditunjukkan dalam berikut ini:

```
import aws.sdk.kotlin.hll.dynamodbmapper.operations.putItem
import aws.sdk.kotlin.services.dynamodb.model.ReturnConsumedCapacity

val putResponse = carsTable.putItem {
    item = Car(make = "Ford", model = "Model T", ...)
    returnConsumedCapacity = ReturnConsumedCapacity.Total
}

println(putResponse.consumedCapacity)
```

Anda juga dapat memanggil operasi dengan menggunakan objek permintaan eksplisit:

```
import aws.sdk.kotlin.hll.dynamodbmapper.operations.PutItemRequest
import aws.sdk.kotlin.services.dynamodb.model.ReturnConsumedCapacity

val putRequest = PutItemRequest<Car> {
    item = Car(make = "Ford", model = "Model T", ...)
    returnConsumedCapacity = ReturnConsumedCapacity.Total
}

val putResponse = carsTable.putItem(putRequest)
println(putResponse.consumedCapacity)
```

Dua contoh kode sebelumnya setara.

### Bekerja dengan tanggapan berhalaman
<a name="ddb-mapper-gs-pagination"></a>

Beberapa operasi seperti `query` dan `scan` dapat mengembalikan koleksi data yang mungkin terlalu besar untuk dikembalikan dalam satu respons. Untuk memastikan bahwa semua objek diproses, DynamoDB Mapper menyediakan metode paginating, yang tidak segera memanggil DynamoDB, tetapi mengembalikan tipe respons operasi, seperti `[Flow](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)` yang ditunjukkan dalam berikut ini: `Flow<ScanResponse<Car>>`

```
import aws.sdk.kotlin.hll.dynamodbmapper.operations.scanPaginated

val scanResponseFlow = carsTable.scanPaginated { }

scanResponseFlow.collect { response ->
    val items = response.items.orEmpty()
    println("Found page with ${items.size} items:")
    
    items.forEach { car -> println(car) }
}
```

Seringkali, aliran objek lebih berguna untuk logika bisnis daripada aliran respons yang *mengandung* objek. Mapper menyediakan metode ekstensi pada respons paginasi untuk mengakses aliran objek. Misalnya, kode berikut mengembalikan `Flow<Car>` bukan `Flow<ScanResponse<Car>>` seperti yang ditunjukkan sebelumnya:

```
import aws.sdk.kotlin.hll.dynamodbmapper.operations.items
import aws.sdk.kotlin.hll.dynamodbmapper.operations.scanPaginated

val carFlow = carsTable
    .scanPaginated { }
    .items()

carFlow.collect { car -> println(car) }
```