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.

# Generieren Sie ein Schema aus Anmerkungen
<a name="ddb-mapper-anno-schema-gen"></a>

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

DynamoDB Mapper stützt sich auf Schemas, die die Zuordnung zwischen Ihren Kotlin-Klassen und DynamoDB-Elementen definieren. Ihre Kotlin-Klassen können die Erstellung von Schemas mithilfe des Gradle-Plug-ins für den Schemagenator vorantreiben. 

## Wenden Sie das Plugin an
<a name="ddb-mapper-anno-schema-gen-plugin"></a>

Um mit der Codegenerierung von Schemas für Ihre Klassen zu beginnen, wenden Sie das Plugin im Build-Skript Ihrer Anwendung an und fügen Sie eine Abhängigkeit vom Annotationsmodul hinzu. Der folgende Gradle-Skriptausschnitt zeigt das notwendige Setup für die Codegenerierung. 

(Sie können zum {{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")
}
```

## Konfigurieren des -Plugins
<a name="ddb-mapper-anno-schema-gen-conf-plugin"></a>

Das Plugin bietet eine Reihe von Konfigurationsoptionen, die Sie mithilfe der `dynamoDbMapper { ... }` Plugin-Erweiterung in Ihrem Build-Skript anwenden können: 


| Option | Beschreibung der Option | Werte | 
| --- | --- | --- | 
| generateBuilderClasses | Steuert, ob Builder-Klassen im DSL-Stil für Klassen generiert werden, die mit annotiert sind `@DynamoDbItem` | `WHEN_REQUIRED`(Standard): Builder-Klassen werden nicht für Klassen generiert, die nur aus öffentlichen, veränderbaren Mitgliedern bestehen und einen Null-Arg-Konstruktor haben<br />`ALWAYS`: Builder-Klassen werden immer generiert | 
| visibility | Steuert die Sichtbarkeit der generierten Klassen | `PUBLIC` (Standard)<br />`INTERNAL` | 
| destinationPackage | Gibt den Paketnamen für generierte Klassen an | `RELATIVE`(Standard): Schemaklassen werden in einem Unterpaket relativ zu Ihrer annotierten Klasse generiert. Standardmäßig hat das Unterpaket einen Namen`dynamodbmapper.generatedschemas`, und dies kann durch Übergabe eines Zeichenkettenparameters konfiguriert werden<br />`ABSOLUTE`: Schemaklassen werden in einem absoluten Paket relativ zum Stamm Ihrer Anwendung generiert. Standardmäßig hat das Paket einen Namen`aws.sdk.kotlin.hll.dynamodbmapper.generatedschemas`, und dies kann durch Übergabe eines Zeichenkettenparameters konfiguriert werden. | 
| generateGetTableExtension | Steuert, ob eine `DynamoDbMapper.get${CLASS_NAME}Table` Erweiterungsmethode generiert wird | `true` (Standard)<br />`false` | 

**Example Beispiel für eine Plugin-Konfiguration zur Codegenerierung**  
Das folgende Beispiel konfiguriert das Zielpaket und die Sichtbarkeit des generierten Schemas:  

```
// build.gradle.kts

import aws.sdk.kotlin.hll.dynamodbmapper.codegen.annotations.DestinationPackage
import aws.sdk.kotlin.hll.dynamodbmapper.codegen.annotations.Visibility
import aws.smithy.kotlin.runtime.ExperimentalApi

@OptIn(ExperimentalApi::class)
dynamoDbMapper {
    destinationPackage = DestinationPackage.RELATIVE("my.configured.package")
    visibility = Visibility.INTERNAL
}
```

## Klassen kommentieren
<a name="ddb-mapper-anno-schema-gen-annotate"></a>

Der Schema-Generator sucht nach Klassenanmerkungen, um zu ermitteln, für welche Klassen Schemas generiert werden sollen. Um sich für die Generierung von Schemas zu entscheiden, kommentieren Sie 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)` Sie müssen auch eine Klasseneigenschaft, die als Partitionsschlüssel des Elements dient, mit der Anmerkung annotieren. `@[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)`

Die folgende Klassendefinition zeigt die minimal erforderlichen Anmerkungen für die Schemagenerierung:

**Example**  

```
@DynamoDbItem
data class Employee(
    @DynamoDbPartitionKey
    val id: Int,
    
    val name: String,
    val role: String,
)
```

### Anmerkungen zur Klasse
<a name="ddb-mapper-anno-schema-gen-class-annos"></a>

Die folgenden Anmerkungen werden auf Klassen angewendet, um die Schemagenerierung zu steuern:
+ `@DynamoDbItem`: Gibt an, dass dies einen Elementtyp in einer Tabelle class/interface beschreibt. Alle öffentlichen Eigenschaften dieses Typs werden Attributen zugeordnet, sofern sie nicht ausdrücklich ignoriert werden. Falls vorhanden, wird ein Schema für diese Klasse generiert.
  + `converterName`: Ein optionaler Parameter, der angibt, dass ein benutzerdefiniertes Schema verwendet werden sollte und nicht das, das vom Schema-Generator-Plugin erstellt wurde. Dies ist der vollständig qualifizierte Name der benutzerdefinierten `ItemConverter` Klasse. Der [Definieren Sie einen benutzerdefinierten Artikelkonverter](#ddb-mapper-anno-schema-custom) Abschnitt zeigt ein Beispiel für die Erstellung und Verwendung eines benutzerdefinierten Schemas.

### Anmerkungen zu Eigenschaften
<a name="ddb-mapper-anno-schema-gen-prop-annos"></a>

Sie können die folgenden Anmerkungen auf Klasseneigenschaften anwenden, um die Schemagenerierung zu steuern:
+ `@[https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-item/index.html](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-item/index.html)`: Gibt den Partitionsschlüssel für das Element an.
+ `@[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)`: Gibt einen optionalen Sortierschlüssel für das Element an.
+ `@[DynamoDbIgnore](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-ignore/index.html)`: Gibt an, dass diese Klasseneigenschaft vom DynamoDB-Mapper nicht in to/from ein Item-Attribut umgewandelt werden soll.
+ `@[DynamoDbAttribute](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-attribute/index.html)`: Gibt einen optionalen benutzerdefinierten Attributnamen für diese Klasseneigenschaft an.

## Definieren Sie einen benutzerdefinierten Artikelkonverter
<a name="ddb-mapper-anno-schema-custom"></a>

In einigen Fällen möchten Sie vielleicht einen benutzerdefinierten Artikelkonverter für Ihre Klasse definieren. Ein Grund dafür wäre, wenn Ihre Klasse einen Typ verwendet, der vom Schema-Generator-Plugin nicht unterstützt wird. Wir verwenden die folgende Version der `Employee` Klasse als Beispiel:

```
import kotlin.uuid.Uuid

@DynamoDbItem
data class Employee(
    @DynamoDbPartitionKey
    var id: Int,
    
    var name: String,
    var role: String,
    var workstationId: Uuid
)
```

Die `Employee` Klasse verwendet jetzt einen `kotlin.uuid.Uuid` Typ, der derzeit vom Schema-Generator nicht unterstützt wird. Die Schemagenerierung schlägt mit einem Fehler fehl:`Unsupported attribute type TypeRef(pkg=kotlin.uuid, shortName=Uuid, genericArgs=[], nullable=false)`. Dieser Fehler weist darauf hin, dass das Plugin keinen Elementkonverter für diese Klasse generieren kann. Deshalb müssen wir unsere eigenen schreiben.

Dazu implementieren wir eine `[ItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-item-converter/index.html)` für die Klasse und ändern dann die Klassenanmerkung, indem wir den vollqualifizierten Namen des neuen Elementkonverters angeben. `@DynamoDbItem`

Zuerst implementieren wir a `[ValueConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.values/-value-converter/index.html)` für die `kotlin.uuid.Uuid` Klasse:

```
import aws.sdk.kotlin.hll.dynamodbmapper.values.ValueConverter
import aws.sdk.kotlin.services.dynamodb.model.AttributeValue
import kotlin.uuid.Uuid

public val UuidValueConverter = object : ValueConverter<Uuid> {
    override fun convertFrom(to: AttributeValue): Uuid = 
        Uuid.parseHex(to.asS())
        
    override fun convertTo(from: Uuid): AttributeValue = 
        AttributeValue.S(from.toHexString())
}
```

Dann implementieren wir an `ItemConverter` für unsere `Employee` Klasse. Der `ItemConverter` verwendet diesen neuen Wertekonverter im Attributdeskriptor für „WorkstationID“:

```
import aws.sdk.kotlin.hll.dynamodbmapper.items.AttributeDescriptor
import aws.sdk.kotlin.hll.dynamodbmapper.items.ItemConverter
import aws.sdk.kotlin.hll.dynamodbmapper.items.SimpleItemConverter
import aws.sdk.kotlin.hll.dynamodbmapper.values.scalars.IntConverter
import aws.sdk.kotlin.hll.dynamodbmapper.values.scalars.StringConverter

public object MyEmployeeConverter : ItemConverter<Employee> by SimpleItemConverter(
    builderFactory = { Employee() },
    build = { this },
    descriptors = arrayOf(
        AttributeDescriptor(
            "id",
            Employee::id,
            Employee::id::set,
            IntConverter,
        ),
        AttributeDescriptor(
            "name",
            Employee::name,
            Employee::name::set,
            StringConverter,
        ),
        AttributeDescriptor(
            "role",
            Employee::role,
            Employee::role::set,
            StringConverter
        ),
        AttributeDescriptor(
            "workstationId",
            Employee::workstationId,
            Employee::workstationId::set,
            UuidValueConverter
        )
    ),
)
```

Nachdem wir den Elementkonverter definiert haben, können wir ihn auf unsere Klasse anwenden. Wir aktualisieren die `@[DynamoDbItem](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-item/index.html)` Anmerkung so, dass sie auf den Elementkonverter verweist, indem wir den vollqualifizierten Klassennamen angeben, wie im Folgenden dargestellt:

```
import kotlin.uuid.Uuid

@DynamoDbItem("my.custom.item.converter.MyEmployeeConverter")
data class Employee(
    @DynamoDbPartitionKey
    var id: Int,
    
    var name: String,
    var role: String,
    var workstationId: Uuid
)
```

Endlich können wir beginnen, die Klasse mit DynamoDB Mapper zu verwenden.