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

# Defina esquemas manualmente
<a name="ddb-mapper-code-schemas"></a>

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

## Definir um esquema no código
<a name="ddb-mapper-gs-manual-schema-def"></a>

Para obter o máximo de controle e personalização, você pode definir e personalizar manualmente os esquemas no código. 

Conforme mostrado no trecho a seguir, você precisa incluir menos dependências em seu `build.gradle.kts` arquivo em comparação com o uso da criação de esquemas orientados por anotações. 

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

dependencies {
    implementation("aws.sdk.kotlin:dynamodb-mapper:$sdkVersion-beta") // For the Developer Preview, use the beta version of the latest SDK.
}
```

Observe que você não precisa do plug-in gerador de esquemas nem do pacote de anotações.

O mapeamento entre uma classe Kotlin e um item do DynamoDB requer uma `[ItemSchema<T>](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-item-schema/index.html)` implementação, onde `T` está o tipo da classe Kotlin. Um esquema consiste nos seguintes elementos:
+ Um conversor de itens, que define como converter entre instâncias de objetos Kotlin e itens do DynamoDB.
+ Uma especificação de chave de partição, que define o nome e o tipo do atributo da chave de partição.
+ Opcionalmente, uma especificação de chave de classificação, que define o nome e o tipo do atributo da chave de classificação.

No código a seguir, criamos manualmente uma `CarSchema` instância:

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

O código anterior cria um conversor chamado`carConverter`, que é definido como uma implementação anônima de`ItemConverter<Car>`. O `convertTo` método do conversor aceita um `Car` argumento e retorna uma `Item` instância representando as chaves e valores literais dos atributos de itens do DynamoDB. O `convertFrom` método do conversor aceita um `Item` argumento e retorna uma `Car` instância dos valores dos atributos do `Item` argumento.

Em seguida, o código cria duas especificações principais: uma para a chave de partição e outra para a chave de classificação. Cada tabela ou índice do DynamoDB deve ter exatamente uma chave de partição e, da mesma forma, cada definição de esquema do DynamoDB Mapper. Os esquemas também podem ter uma chave de classificação.

Na última declaração, o código cria um esquema para a tabela do `cars` DynamoDB a partir do conversor e das principais especificações.

O esquema resultante é equivalente ao esquema baseado em anotações que geramos na seção. [Defina um esquema com anotações de classe](ddb-mapper-get-started.md#ddb-mapper-gs-anno-schema-def) Para referência, a seguir está a classe anotada que usamos:

### Classe Car com anotações do DynamoDB Mapper
<a name="ejd_mxz_ddc"></a>

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

Além de implementar sua própria`ItemConverter`, o DynamoDB Mapper inclui várias implementações úteis, como: 
+ `[SimpleItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-simple-item-converter/index.html)`: fornece uma lógica de conversão simples usando uma classe construtora e descritores de atributos. Veja o exemplo em [Definir um conversor de itens personalizado](ddb-mapper-anno-schema-gen.md#ddb-mapper-anno-schema-custom) para saber como você pode usar essa implementação.
+ `[HeterogeneousItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-heterogeneous-item-converter/index.html)`: fornece lógica de conversão de tipos polimórficos usando um atributo discriminador e instâncias delegadas `ItemConverter` para subtipos.
+ `[DocumentConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-document-converter/index.html)`: fornece lógica de conversão para dados não estruturados em [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)objetos.