Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Erste Schritte mit DynamoDB Mapper
<a name="ddb-mapper-get-started"></a>

****  
**DynamoDB Mapper ist eine Developer Preview-Version. Die Funktionen sind noch nicht vollständig und können sich ändern.**

Das folgende Tutorial stellt die grundlegenden Komponenten von DynamoDB Mapper vor und zeigt, wie Sie ihn in Ihrem Code verwenden können.

## Fügen Sie Abhängigkeiten hinzu
<a name="ddb-mapper-get-started-deps"></a>

Um mit der Arbeit mit DynamoDB Mapper in Ihrem Gradle-Projekt zu beginnen, fügen Sie Ihrer Datei ein Plugin und zwei Abhängigkeiten hinzu. `build.gradle.kts`

(Sie können zu dem {{X.Y.Z}} Link navigieren, um die neueste verfügbare Version zu sehen.)

```
// 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")
}
```

{{<Version>}}\*Durch die neueste Version des SDK ersetzen. Die neueste Version des SDK finden Sie [unter GitHub](https://github.com/awslabs/aws-sdk-kotlin/releases/latest).

**Anmerkung**  
Einige dieser Abhängigkeiten sind optional, wenn Sie Schemas manuell definieren möchten. [Schemas manuell definieren](ddb-mapper-code-schemas.md)Weitere Informationen und die reduzierten Abhängigkeiten finden Sie unter.

## Erstellen und verwenden Sie einen Mapper
<a name="ddb-mapper-get-started-mapper"></a>

DynamoDB Mapper verwendet den DynamoDB-Client AWS SDK für Kotlin von für die Interaktion mit DynamoDB. Sie müssen eine vollständig konfigurierte [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)Instanz bereitstellen, wenn Sie eine Mapper-Instanz erstellen, wie im folgenden Codeausschnitt gezeigt:

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

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

**Anmerkung**  
`DynamoDbMapper`unterstützt keine Operationen zur Tabellenerstellung. Verwenden Sie die`DynamoDbClient`, um Tabellen zu erstellen.

Nachdem Sie die Mapper-Instanz erstellt haben, können Sie sie verwenden, um die Tabelleninstanz abzurufen, wie im Folgenden gezeigt:

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

Der vorherige Code ruft einen Verweis auf eine Tabelle in `DynamoDB` named `cars` mit einem Schema ab, das von definiert ist `CarSchema` (Schemas werden weiter unten besprochen). Nachdem Sie eine Tabelleninstanz erstellt haben, können Sie Operationen an ihr ausführen. Der folgende Codeausschnitt zeigt zwei Beispieloperationen für die `cars` Tabelle:

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

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

Der vorherige Code erstellt ein neues Element in der `cars` Tabelle. Der Code erstellt eine `Car` Inline-Instanz unter Verwendung der `Car` Klasse, deren Definition unten gezeigt wird. Als Nächstes fragt der Code die `cars` Tabelle nach Elementen ab, deren Partitionsschlüssel lautet, `Peugeot` und druckt sie aus. Die Operationen werden [im Folgenden ausführlicher beschrieben](#ddb-mapper-gs-invoke-ops).

## Definieren Sie ein Schema mit Klassenanmerkungen
<a name="ddb-mapper-gs-anno-schema-def"></a>

Für eine Vielzahl von Kotlin-Klassen kann das SDK zur Build-Zeit mithilfe des DynamoDB Mapper Schema Generator-Plug-ins für Gradle automatisch Schemas generieren. Wenn Sie den Schema-Generator verwenden, überprüft das SDK Ihre Klassen, um daraus das Schema abzuleiten, wodurch einige der Standardvorgaben, die mit der manuellen Definition von Schemas verbunden sind, vereinfacht werden. [[Sie können das generierte Schema mithilfe zusätzlicher Anmerkungen und Konfigurationen anpassen.](ddb-mapper-anno-schema-gen.md#ddb-mapper-anno-schema-gen-conf-plugin)](ddb-mapper-anno-schema-gen.md#ddb-mapper-anno-schema-gen-annotate)

Um ein Schema aus Anmerkungen zu generieren, kommentieren Sie zunächst Ihre Klassen mit `@[DynamoDbItem](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-item/index.html)` und alle Schlüssel mit und. `@[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)` Der folgende Code zeigt die `Car` annotierte Klasse:

```
// 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
)
```

Nach dem Erstellen können Sie auf die automatisch generierte `CarSchema` Datei zurückgreifen. Sie können die Referenz in der `getTable` Mapper-Methode verwenden, um eine Tabelleninstanz abzurufen, wie im Folgenden gezeigt:

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

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

Alternativ können Sie die Tabelleninstanz abrufen, indem Sie eine Erweiterungsmethode nutzen`[DynamoDbMapper](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-mapper/index.html)`, die beim Erstellen automatisch generiert wird. Wenn Sie diesen Ansatz verwenden, müssen Sie nicht namentlich auf das Schema verweisen. Wie im Folgenden gezeigt, gibt die automatisch generierte `getCarsTable` Erweiterungsmethode einen Verweis auf die Tabelleninstanz zurück:

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

Weitere Einzelheiten und Beispiele finden Sie unter [Generieren Sie ein Schema aus Anmerkungen](ddb-mapper-anno-schema-gen.md).

## Operationen aufrufen
<a name="ddb-mapper-gs-invoke-ops"></a>

DynamoDB Mapper unterstützt eine Teilmenge der in den SDKs verfügbaren Operationen. `DynamoDbClient` Mapper-Operationen werden genauso benannt wie ihre Gegenstücke auf dem SDK-Client. Viele request/response Mapper-Mitglieder sind dieselben wie ihre SDK-Client-Gegenstücke, obwohl einige umbenannt, neu eingegeben oder ganz gelöscht wurden.

Sie rufen einen Vorgang auf einer Tabelleninstanz mithilfe einer DSL-Syntax auf, wie im Folgenden dargestellt:

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

Sie können einen Vorgang auch aufrufen, indem Sie ein explizites Anforderungsobjekt verwenden:

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

Die beiden vorherigen Codebeispiele sind gleichwertig.

### Arbeiten Sie mit paginierten Antworten
<a name="ddb-mapper-gs-pagination"></a>

Bei einigen `query` Vorgängen `scan` können Datensammlungen zurückgegeben werden, die möglicherweise zu umfangreich sind, um sie in einer einzigen Antwort zurückzugeben. Um sicherzustellen, dass alle Objekte verarbeitet werden, bietet DynamoDB Mapper Paginierungsmethoden, die DynamoDB nicht sofort aufrufen, sondern stattdessen a `[Flow](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)` vom Typ Operation Response zurückgeben, wie im Folgenden dargestellt: `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) }
}
```

*Oft ist ein Objektfluss für die Geschäftslogik nützlicher als ein Antwortfluss, der Objekte enthält.* Der Mapper bietet eine Erweiterungsmethode für paginierte Antworten, um auf den Objektfluss zuzugreifen. Der folgende Code gibt beispielsweise a und `Flow<Car>` nicht a zurück, `Flow<ScanResponse<Car>>` wie zuvor gezeigt:

```
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) }
```