As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Gere um esquema a partir de anotações
<a name="ddb-mapper-anno-schema-gen"></a>

****  
**O DynamoDB Mapper é uma versão prévia para desenvolvedores. O recurso não está completo e está sujeito a alterações.**

O DynamoDB Mapper depende de esquemas que definem o mapeamento entre suas classes do Kotlin e os itens do DynamoDB. Suas classes Kotlin podem impulsionar a criação de esquemas usando o plug-in Gradle do gerador de esquemas. 

## Aplique o plugin
<a name="ddb-mapper-anno-schema-gen-plugin"></a>

Para começar a gerar esquemas de código para suas classes, aplique o plug-in no script de construção do seu aplicativo e adicione uma dependência no módulo de anotações. O seguinte trecho de script do Gradle mostra a configuração necessária para a geração de código. 

(Você pode navegar até o *X.Y.Z* link para ver a versão mais recente disponível.)

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

## Como configurar o plug-in do
<a name="ddb-mapper-anno-schema-gen-conf-plugin"></a>

O plug-in oferece várias opções de configuração que você pode aplicar usando a extensão do `dynamoDbMapper { ... }` plug-in em seu script de construção: 


| Opção | Descrição da opção | Valores | 
| --- | --- | --- | 
| generateBuilderClasses |  Controla se as classes do construtor no estilo DSL serão geradas para classes anotadas com `@DynamoDbItem`  |  `WHEN_REQUIRED`(padrão): As classes Builder não serão geradas para classes que consistem apenas em membros mutáveis públicos e tenham um construtor de argumento zero `ALWAYS`: As classes Builder sempre serão geradas  | 
| visibility | Controla a visibilidade das classes geradas |  `PUBLIC` (padrão) `INTERNAL`  | 
| destinationPackage | Especifica o nome do pacote para as classes geradas |  `RELATIVE`(padrão): as classes do esquema serão geradas em um subpacote relativo à sua classe anotada. Por padrão, o subpacote é nomeado `dynamodbmapper.generatedschemas` e isso é configurável passando um parâmetro de string `ABSOLUTE`: as classes de esquema serão geradas em um pacote absoluto em relação à raiz do seu aplicativo. Por padrão, o pacote é nomeado `aws.sdk.kotlin.hll.dynamodbmapper.generatedschemas` e isso é configurável passando um parâmetro de string.  | 
| generateGetTableExtension |  Controla se um método `DynamoDbMapper.get${CLASS_NAME}Table` de extensão será gerado  |  `true` (padrão) `false`  | 

**Example Exemplo de configuração de plug-in de geração de código**  
O exemplo a seguir configura o pacote de destino e a visibilidade do esquema gerado:  

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

## Anote as aulas
<a name="ddb-mapper-anno-schema-gen-annotate"></a>

O gerador de esquemas procura anotações de classe para determinar para quais classes gerar esquemas. Para optar por gerar esquemas, anote suas classes com. `@[DynamoDbItem](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-item/index.html)` Você também deve anotar uma propriedade de classe que serve como chave de partição do item com a `@[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)` anotação.

A definição de classe a seguir mostra as anotações minimamente necessárias para a geração do esquema:

**Example**  

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

### Anotações de classe
<a name="ddb-mapper-anno-schema-gen-class-annos"></a>

As anotações a seguir são aplicadas às classes para controlar a geração do esquema:
+ `@DynamoDbItem`: especifica que isso class/interface descreve um tipo de item em uma tabela. Todas as propriedades públicas desse tipo serão mapeadas para atributos, a menos que sejam explicitamente ignoradas. Quando presente, um esquema será gerado para essa classe.
  + `converterName`: um parâmetro opcional que indica que um esquema personalizado deve ser usado em vez daquele criado pelo plug-in gerador de esquema. Esse é o nome totalmente qualificado da `ItemConverter` classe personalizada. A [Definir um conversor de itens personalizado](#ddb-mapper-anno-schema-custom) seção mostra um exemplo de criação e uso de um esquema personalizado.

### Anotações de propriedade
<a name="ddb-mapper-anno-schema-gen-prop-annos"></a>

Você pode aplicar as seguintes anotações às propriedades da classe para controlar a geração do esquema:
+ `@[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)`: especifica a chave de partição do item.
+ `@[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)`: especifica uma chave de classificação opcional para o item.
+ `@[DynamoDbIgnore](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-ignore/index.html)`: especifica que essa propriedade de classe não deve ser convertida em to/from um atributo de item pelo 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)`: especifica um nome de atributo personalizado opcional para essa propriedade de classe.

## Definir um conversor de itens personalizado
<a name="ddb-mapper-anno-schema-custom"></a>

Em alguns casos, talvez você queira definir um conversor de itens personalizado para sua classe. Uma razão para isso seria se sua classe usasse um tipo que não é suportado pelo plug-in gerador de esquema. Usamos a seguinte versão da `Employee` classe como exemplo:

```
import kotlin.uuid.Uuid

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

A `Employee` classe agora usa um `kotlin.uuid.Uuid` tipo, que atualmente não é suportado pelo gerador de esquema. A geração do esquema falha com um erro:`Unsupported attribute type TypeRef(pkg=kotlin.uuid, shortName=Uuid, genericArgs=[], nullable=false)`. Esse erro indica que o plug-in não pode gerar um conversor de itens para essa classe. Portanto, precisamos escrever nossos próprios.

Para fazer isso, implementamos um `[ItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-item-converter/index.html)` para a classe e, em seguida, modificamos a anotação da `@DynamoDbItem` classe especificando o nome totalmente qualificado do novo conversor de itens.

Primeiro, implementamos um `[ValueConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.values/-value-converter/index.html)` para a `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())
}
```

Em seguida, implementamos um `ItemConverter` para nossa `Employee` classe. O `ItemConverter` usa esse novo conversor de valor no descritor de atributo para “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
        )
    ),
)
```

Agora que definimos o conversor de itens, podemos aplicá-lo à nossa classe. Atualizamos a `@[DynamoDbItem](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper-annotations/aws.sdk.kotlin.hll.dynamodbmapper/-dynamo-db-item/index.html)` anotação para referenciar o conversor de itens fornecendo o nome da classe totalmente qualificado, conforme mostrado a seguir:

```
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, podemos começar a usar a classe com o DynamoDB Mapper.