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.

# Schemas manuell definieren
<a name="ddb-mapper-code-schemas"></a>

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

## Definieren Sie ein Schema im Code
<a name="ddb-mapper-gs-manual-schema-def"></a>

Für maximale Kontrolle und Anpassungsfähigkeit können Sie Schemas im Code manuell definieren und anpassen. 

Wie im folgenden Codeausschnitt gezeigt, müssen Sie weniger Abhängigkeiten in Ihre `build.gradle.kts` Datei aufnehmen als bei der Verwendung der annotierungsgesteuerten Schemaerstellung. 

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

dependencies {
    implementation("aws.sdk.kotlin:dynamodb-mapper:$sdkVersion-beta") // For the Developer Preview, use the beta version of the latest SDK.
}
```

Beachten Sie, dass Sie weder das Schema-Generator-Plugin noch das Annotationspaket benötigen.

Die Zuordnung zwischen einer Kotlin-Klasse und einem DynamoDB-Element erfordert eine `[ItemSchema<T>](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-item-schema/index.html)` Implementierung, wobei der Typ der Kotlin-Klasse `T` ist. Ein Schema besteht aus den folgenden Elementen:
+ Ein Elementkonverter, der definiert, wie zwischen Kotlin-Objektinstanzen und DynamoDB-Elementen konvertiert wird.
+ Eine Partitionsschlüsselspezifikation, die den Namen und den Typ des Partitionsschlüsselattributs definiert.
+ Optional eine Sortierschlüsselspezifikation, die den Namen und den Typ des Sortierschlüsselattributs definiert.

Im folgenden Code erstellen wir manuell eine `CarSchema` Instanz:

```
import aws.sdk.kotlin.hll.dynamodbmapper.items.ItemConverter
import aws.sdk.kotlin.hll.dynamodbmapper.items.ItemSchema
import aws.sdk.kotlin.hll.dynamodbmapper.model.itemOf

// We define a schema for this data class.
data class Car(val make: String, val model: String, val initialYear: Int)

// First, define an item converter.
val carConverter = object : ItemConverter<Car> {
    override fun convertTo(from: Car, onlyAttributes: Set<String>?): Item  = itemOf(
        "make" to AttributeValue.S(from.make),
        "model" to AttributeValue.S(from.model),
        "initialYear" to AttributeValue.N(from.initialYear.toString()),
    )

    override fun convertFrom(to: Item): Car = Car(
        make = to["make"]?.asSOrNull() ?: error("Invalid attribute `make`"),
        model = to["model"]?.asSOrNull() ?: error("Invalid attribute `model`"),
        initialYear = to["initialYear"]?.asNOrNull()?.toIntOrNull()
            ?: error("Invalid attribute `initialYear`"),
    )
}

// Next, define the specifications for the partition key and sort key.
val makeKey = KeySpec.String("make")
val modelKey = KeySpec.String("model")

// Finally, create the schema from the converter and key specifications.
// Note that the KeySpec for the partition key comes first in the ItemSchema constructor.
val CarSchema = ItemSchema(carConverter, makeKey, modelKey)
```

Der vorherige Code erstellt einen Konverter mit dem Namen`carConverter`, der als anonyme Implementierung von definiert ist`ItemConverter<Car>`. Die `convertTo` Methode des Konverters akzeptiert ein `Car` Argument und gibt eine `Item` Instanz zurück, die die Literalschlüssel und Werte von DynamoDB-Elementattributen darstellt. Die `convertFrom` Methode des Konverters akzeptiert ein `Item` Argument und gibt anhand der Attributwerte des Arguments eine `Car` Instanz zurück. `Item`

Als Nächstes erstellt der Code zwei Schlüsselspezifikationen: eine für den Partitionsschlüssel und eine für den Sortierschlüssel. Jede DynamoDB-Tabelle oder jeder DynamoDB-Index muss genau einen Partitionsschlüssel haben, und entsprechend muss auch jede DynamoDB-Mapper-Schemadefinition über genau einen Partitionsschlüssel verfügen. Schemas können auch einen Sortierschlüssel haben.

In der letzten Anweisung erstellt der Code anhand des Konverters und der Schlüsselspezifikationen ein Schema für die `cars` DynamoDB-Tabelle.

Das resultierende Schema entspricht dem durch Anmerkungen gesteuerten Schema, das wir in diesem Abschnitt generiert haben. [Definieren Sie ein Schema mit Klassenanmerkungen](ddb-mapper-get-started.md#ddb-mapper-gs-anno-schema-def) Als Referenz ist die folgende Klasse mit Anmerkungen aufgeführt, die wir verwendet haben:

### Autoklasse mit DynamoDB-Mapper-Anmerkungen
<a name="ejd_mxz_ddc"></a>

```
@DynamoDbItem
data class Car(
    @DynamoDbPartitionKey
    val make: String,
    
    @DynamoDbSortKey
    val model: String,
    
    val initialYear: Int
)
```

Neben der Implementierung Ihrer eigenen `ItemConverter` enthält DynamoDB Mapper mehrere hilfreiche Implementierungen wie: 
+ `[SimpleItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-simple-item-converter/index.html)`: bietet eine einfache Konvertierungslogik mithilfe einer Builder-Klasse und Attributdeskriptoren. Sehen Sie sich das Beispiel in der [Definieren Sie einen benutzerdefinierten Artikelkonverter](ddb-mapper-anno-schema-gen.md#ddb-mapper-anno-schema-custom) an, wie Sie diese Implementierung nutzen können.
+ `[HeterogeneousItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-heterogeneous-item-converter/index.html)`: stellt eine polymorphe Typkonvertierungslogik bereit, indem es ein Diskriminatorattribut und `ItemConverter` Delegatinstanzen für Subtypen verwendet.
+ `[DocumentConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-document-converter/index.html)`: bietet Konvertierungslogik für unstrukturierte Daten in Objekten. [https://docs.aws.amazon.com/smithy-kotlin/api/latest/runtime-core/aws.smithy.kotlin.runtime.content/-document.html](https://docs.aws.amazon.com/smithy-kotlin/api/latest/runtime-core/aws.smithy.kotlin.runtime.content/-document.html)