Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Définition manuelle de schémas
<a name="ddb-mapper-code-schemas"></a>

****  
**DynamoDB Mapper est une version préliminaire pour les développeurs. Les fonctionnalités ne sont pas complètes et sont susceptibles d'être modifiées.**

## Définir un schéma dans le code
<a name="ddb-mapper-gs-manual-schema-def"></a>

Pour un contrôle et une personnalisation optimaux, vous pouvez définir et personnaliser manuellement les schémas dans le code. 

Comme indiqué dans l'extrait suivant, vous devez inclure moins de dépendances dans votre `build.gradle.kts` fichier par rapport à la création de schéma pilotée par des annotations. 

(Vous pouvez accéder au {{X.Y.Z}} lien pour voir la dernière version disponible.)

```
// 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.
}
```

Notez que vous n'avez pas besoin du plugin générateur de schéma ni du package d'annotations.

Le mappage entre une classe Kotlin et un élément DynamoDB nécessite `[ItemSchema<T>](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-item-schema/index.html)` une implémentation, `T` où est le type de la classe Kotlin. Un schéma comprend les éléments suivants :
+ Un convertisseur d'éléments, qui définit comment convertir entre les instances d'objets Kotlin et les éléments DynamoDB.
+ Spécification de clé de partition, qui définit le nom et le type de l'attribut de clé de partition.
+ Facultativement, une spécification de clé de tri, qui définit le nom et le type de l'attribut de clé de tri.

Dans le code suivant, nous créons manuellement une `CarSchema` instance :

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

Le code précédent crée un convertisseur nommé`carConverter`, qui est défini comme une implémentation anonyme de`ItemConverter<Car>`. La `convertTo` méthode du convertisseur accepte un `Car` argument et renvoie une `Item` instance représentant les clés littérales et les valeurs des attributs des éléments DynamoDB. La `convertFrom` méthode du convertisseur accepte un `Item` argument et renvoie une `Car` instance à partir des valeurs d'attribut de l'`Item`argument.

Le code crée ensuite deux spécifications clés : une pour la clé de partition et une pour la clé de tri. Chaque table ou index DynamoDB doit avoir exactement une clé de partition, de même que chaque définition de schéma DynamoDB Mapper. Les schémas peuvent également avoir une clé de tri.

Dans la dernière instruction, le code crée un schéma pour la table `cars` DynamoDB à partir du convertisseur et des spécifications clés.

Le schéma obtenu est équivalent au schéma piloté par les annotations que nous avons généré dans la [Définir un schéma avec des annotations de classe](ddb-mapper-get-started.md#ddb-mapper-gs-anno-schema-def) section. À titre de référence, voici la classe annotée que nous avons utilisée :

### Classe de véhicule avec annotations DynamoDB Mapper
<a name="ejd_mxz_ddc"></a>

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

Outre l'implémentation de la vôtre`ItemConverter`, DynamoDB Mapper inclut plusieurs implémentations utiles, telles que : 
+ `[SimpleItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-simple-item-converter/index.html)`: fournit une logique de conversion simple en utilisant une classe de générateur et des descripteurs d'attributs. Consultez l'exemple ci-dessous [Définition d'un convertisseur d'articles personnalisé](ddb-mapper-anno-schema-gen.md#ddb-mapper-anno-schema-custom) pour savoir comment utiliser cette implémentation.
+ `[HeterogeneousItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-heterogeneous-item-converter/index.html)`: fournit une logique de conversion de type polymorphe en utilisant un attribut discriminateur et en `ItemConverter` déléguant des instances pour les sous-types.
+ `[DocumentConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-document-converter/index.html)`: fournit une logique de conversion pour les données non structurées contenues dans des [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)objets.