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à.

# Genera uno schema dalle annotazioni
<a name="ddb-mapper-anno-schema-gen"></a>

****  
**DynamoDB Mapper è una versione di anteprima per sviluppatori. Non è completa di funzionalità ed è soggetta a modifiche.**

DynamoDB Mapper si basa su schemi che definiscono la mappatura tra le classi Kotlin e gli elementi DynamoDB. Le tue classi Kotlin possono guidare la creazione di schemi utilizzando il plugin Gradle per il generatore di schemi. 

## Applica il plugin
<a name="ddb-mapper-anno-schema-gen-plugin"></a>

Per iniziare a generare schemi di codice per le tue classi, applica il plugin nello script di compilazione dell'applicazione e aggiungi una dipendenza dal modulo annotations. Il seguente frammento di script Gradle mostra la configurazione necessaria per la generazione del codice. 

(Puoi accedere al *X.Y.Z* link per vedere 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) 

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

## Configurare il plugin
<a name="ddb-mapper-anno-schema-gen-conf-plugin"></a>

Il plugin offre una serie di opzioni di configurazione che puoi applicare utilizzando l'estensione del `dynamoDbMapper { ... }` plugin nello script di compilazione: 


| Opzione | Descrizione dell'opzione | Valori | 
| --- | --- | --- | 
| generateBuilderClasses |  Controlla se le classi builder in stile DSL verranno generate per le classi annotate con `@DynamoDbItem`  |  `WHEN_REQUIRED`(impostazione predefinita): le classi Builder non verranno generate per le classi che consistono solo di membri mutabili pubblici e hanno un costruttore a zero arg `ALWAYS`: Le classi Builder verranno sempre generate  | 
| visibility | Controlla la visibilità delle classi generate |  `PUBLIC` (predefinito) `INTERNAL`  | 
| destinationPackage | Specifica il nome del pacchetto per le classi generate |  `RELATIVE`(impostazione predefinita): le classi dello schema verranno generate in un sottopacchetto relativo alla classe annotata. Per impostazione predefinita, il sottopacchetto è denominato `dynamodbmapper.generatedschemas` e questo è configurabile passando un parametro di stringa `ABSOLUTE`: le classi di schema verranno generate in un pacchetto assoluto relativo alla radice dell'applicazione. Per impostazione predefinita, il pacchetto ha un nome `aws.sdk.kotlin.hll.dynamodbmapper.generatedschemas` e questo è configurabile passando un parametro di stringa.  | 
| generateGetTableExtension |  Controlla se verrà `DynamoDbMapper.get${CLASS_NAME}Table` generato un metodo di estensione  |  `true` (predefinito) `false`  | 

**Example Esempio di configurazione del plug-in per la generazione di codice**  
L'esempio seguente configura il pacchetto di destinazione e la visibilità dello schema generato:  

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

## Annota le classi
<a name="ddb-mapper-anno-schema-gen-annotate"></a>

Il generatore di schemi cerca le annotazioni di classe per determinare per quali classi generare schemi. Per attivare la generazione di schemi, annota le tue classi. `@[DynamoDbItem](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-item/index.html)` È inoltre necessario annotare una proprietà di classe che funge da chiave di partizione dell'elemento con l'annotazione. `@[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)`

La seguente definizione di classe mostra le annotazioni minime richieste per la generazione dello schema:

**Example**  

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

### Annotazioni di classe
<a name="ddb-mapper-anno-schema-gen-class-annos"></a>

Le seguenti annotazioni vengono applicate alle classi per controllare la generazione dello schema:
+ `@DynamoDbItem`: specifica che class/interface descrive un tipo di elemento in una tabella. Tutte le proprietà pubbliche di questo tipo verranno mappate agli attributi a meno che non vengano ignorate esplicitamente. Se presente, verrà generato uno schema per questa classe.
  + `converterName`: È necessario utilizzare un parametro opzionale che indica uno schema personalizzato anziché quello creato dal plug-in del generatore di schemi. Questo è il nome completo della `ItemConverter` classe personalizzata. La [Definire un convertitore di articoli personalizzato](#ddb-mapper-anno-schema-custom) sezione mostra un esempio di creazione e utilizzo di uno schema personalizzato.

### Annotazioni sulle proprietà
<a name="ddb-mapper-anno-schema-gen-prop-annos"></a>

È possibile applicare le seguenti annotazioni alle proprietà delle classi per controllare la generazione dello schema:
+ `@[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)`: specifica la chiave di partizione per l'elemento.
+ `@[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)`: specifica una chiave di ordinamento opzionale per l'elemento.
+ `@[DynamoDbIgnore](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-ignore/index.html)`: specifica che questa proprietà di classe non deve essere convertita in to/from un attributo Item da DynamoDB Mapper.
+ `@[DynamoDbAttribute](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-attribute/index.html)`: specifica un nome di attributo personalizzato opzionale per questa proprietà di classe.

## Definire un convertitore di articoli personalizzato
<a name="ddb-mapper-anno-schema-custom"></a>

In alcuni casi, potresti voler definire un convertitore di articoli personalizzato per la tua classe. Uno dei motivi potrebbe essere se la tua classe utilizza un tipo che non è supportato dal plug-in del generatore di schemi. Usiamo la seguente versione della `Employee` classe come esempio:

```
import kotlin.uuid.Uuid

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

La `Employee` classe ora utilizza un `kotlin.uuid.Uuid` tipo, che attualmente non è supportato dal generatore di schemi. La generazione dello schema fallisce con un errore:`Unsupported attribute type TypeRef(pkg=kotlin.uuid, shortName=Uuid, genericArgs=[], nullable=false)`. Questo errore indica che il plugin non può generare un convertitore di elementi per questa classe. Pertanto, dobbiamo scrivere il nostro.

Per fare ciò, implementiamo un `[ItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-item-converter/index.html)` per la classe, quindi modifichiamo l'annotazione della `@DynamoDbItem` classe specificando il nome completo del nuovo convertitore di articoli.

Innanzitutto, implementiamo a `[ValueConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.values/-value-converter/index.html)` per la `kotlin.uuid.Uuid` classe:

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

Quindi, implementiamo un `ItemConverter` per la nostra `Employee` classe. `ItemConverter`Utilizza questo nuovo convertitore di valori nel descrittore di attributi per «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
        )
    ),
)
```

Ora che abbiamo definito il convertitore di elementi, possiamo applicarlo alla nostra classe. Aggiorniamo l'`@[DynamoDbItem](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-item/index.html)`annotazione per fare riferimento al convertitore di articoli fornendo il nome completo della classe, come mostrato di seguito:

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

Finalmente possiamo iniziare a utilizzare la classe con DynamoDB Mapper.