Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Definizione manuale degli schemi
****
**DynamoDB Mapper è una versione di anteprima per sviluppatori. Non è completa di funzionalità ed è soggetta a modifiche.**
## Definire uno schema nel codice
Per il massimo controllo e personalizzazione, puoi definire e personalizzare manualmente gli schemi nel codice.
Come illustrato nel seguente frammento, è necessario includere un minor numero di dipendenze nel `build.gradle.kts` file rispetto all'utilizzo della creazione di schemi basata sulle annotazioni.
(È possibile accedere al {{X.Y.Z}} collegamento per visualizzare l'ultima versione disponibile).
```
// 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.
}
```
Nota che non hai bisogno del plugin per il generatore di schemi né del pacchetto di annotazioni.
La mappatura tra una classe Kotlin e un elemento DynamoDB richiede un'`[ItemSchema](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-item-schema/index.html)`implementazione, `T` dov'è il tipo di classe Kotlin. Uno schema è composto dai seguenti elementi:
+ Un convertitore di elementi, che definisce come convertire tra istanze di oggetti Kotlin e elementi DynamoDB.
+ Una specifica della chiave di partizione, che definisce il nome e il tipo dell'attributo della chiave di partizione.
+ Facoltativamente, una specifica della chiave di ordinamento, che definisce il nome e il tipo dell'attributo chiave di ordinamento.
Nel codice seguente creiamo manualmente un'`CarSchema`istanza:
```
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 {
override fun convertTo(from: Car, onlyAttributes: Set?): 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)
```
Il codice precedente crea un convertitore denominato`carConverter`, che è definito come un'implementazione anonima di`ItemConverter`. Il `convertTo` metodo del convertitore accetta un `Car` argomento e restituisce un'`Item`istanza che rappresenta le chiavi e i valori letterali degli attributi degli elementi di DynamoDB. Il `convertFrom` metodo del convertitore accetta un `Item` argomento e restituisce un'`Car`istanza dai valori degli attributi dell'argomento. `Item`
Successivamente il codice crea due specifiche chiave: una per la chiave di partizione e una per la chiave di ordinamento. Ogni tabella o indice DynamoDB deve avere esattamente una chiave di partizione e, di conseguenza, ogni definizione dello schema di DynamoDB Mapper. Gli schemi possono anche avere una chiave di ordinamento.
Nell'ultima istruzione, il codice crea uno schema per la tabella `cars` DynamoDB a partire dal convertitore e dalle specifiche chiave.
Lo schema risultante è equivalente allo schema basato sulle annotazioni che abbiamo generato nella sezione. [Definire uno schema con annotazioni di classe](ddb-mapper-get-started.md#ddb-mapper-gs-anno-schema-def) Per riferimento, la seguente è la classe annotata che abbiamo usato:
### Car class con annotazioni DynamoDB Mapper
```
@DynamoDbItem
data class Car(
@DynamoDbPartitionKey
val make: String,
@DynamoDbSortKey
val model: String,
val initialYear: Int
)
```
Oltre a implementare le proprie`ItemConverter`, DynamoDB Mapper include diverse implementazioni utili come:
+ `[SimpleItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-simple-item-converter/index.html)`: fornisce una logica di conversione semplice utilizzando una classe builder e descrittori di attributi. Vedi l'esempio nella sezione [Definire un convertitore di articoli personalizzato](ddb-mapper-anno-schema-gen.md#ddb-mapper-anno-schema-custom) per scoprire come utilizzare questa implementazione.
+ `[HeterogeneousItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-heterogeneous-item-converter/index.html)`: fornisce una logica di conversione dei tipi polimorfici utilizzando un attributo discriminatore e `ItemConverter` delega istanze per i sottotipi.
+ `[DocumentConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-document-converter/index.html)`: fornisce la logica di conversione per i dati non strutturati negli oggetti. [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)