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

# Configurar o DynamoDB Mapper
<a name="ddb-mapper-configuration"></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 oferece opções de configuração que você pode usar para personalizar o comportamento da biblioteca de acordo com seu aplicativo.

## Use interceptores
<a name="ddb-mapper-interceptors"></a>

A biblioteca do DynamoDB Mapper define ganchos que você pode usar em estágios críticos do pipeline de solicitações do mapeador. Você pode implementar a `[Interceptor](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.pipeline/-interceptor/index.html)` interface para implementar ganchos para observar ou modificar o processo do mapeador.

Você pode registrar um ou mais interceptores em um único DynamoDB Mapper como opção de configuração. Veja o [exemplo](#ddb-mapper-interceptors-hooks-example-conf) no final desta seção para saber como registrar um interceptor.

### Entenda o pipeline de solicitações
<a name="ddb-mapper-interceptors-pipeline"></a>

O pipeline de solicitações do mapeador consiste nas 5 etapas a seguir:

1. **Inicialização:** configure a operação e reúna o contexto inicial.

1. **Serialização:** converta objetos de solicitação de alto nível em objetos de solicitação de baixo nível. Essa etapa converte objetos Kotlin de alto nível em itens do DynamoDB que consistem em nomes e valores de atributos.

1. **Invocação de baixo nível:** execute uma solicitação no cliente subjacente do DynamoDB.

1. **Desserialização:** converta objetos de resposta de baixo nível em objetos de resposta de alto nível. Essa etapa inclui a conversão de itens do DynamoDB que consistem em nomes e valores de atributos em objetos Kotlin de alto nível.

1. **Conclusão:** finalize a resposta de alto nível para retornar ao chamador. Se uma exceção foi lançada durante a execução do pipeline, essa etapa finaliza a exceção que é lançada para o chamador.

### Hooks
<a name="ddb-mapper-interceptors-hooks"></a>

Ganchos são métodos interceptores que o mapeador invoca antes ou depois de etapas específicas no pipeline. Existem duas variantes de ganchos: *somente leitura e *modificação* (ou leitura* e gravação). Por exemplo, `readBeforeInvocation` é um gancho somente para leitura que o mapeador executa na fase anterior à etapa de invocação de baixo nível.

#### Ganchos somente para leitura
<a name="ddb-mapper-interceptors-hooks-ro"></a>

*O mapeador invoca ganchos somente para leitura antes e depois de cada etapa no pipeline (exceto antes da etapa de *inicialização* e depois da etapa de conclusão).* Os exaustores somente para leitura oferecem uma visão somente para leitura de uma operação de alto nível em andamento. Eles fornecem um mecanismo para examinar o estado de uma operação para registrar, depurar e coletar métricas, por exemplo. Cada gancho somente para leitura recebe um argumento de contexto e retorna. `[Unit](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-unit/)`

O mapeador captura qualquer exceção lançada durante um gancho somente para leitura e a adiciona ao contexto. Em seguida, ele passa o contexto, com exceção dos ganchos interceptores subsequentes na mesma fase. O mapeador lança qualquer exceção para o chamador somente depois de chamar o gancho somente para leitura do último interceptor para a mesma fase. Por exemplo, se um mapeador estiver configurado com dois interceptores `A` e `B` o `readAfterSerialization` gancho `A` de and lançar uma exceção, o mapeador adiciona a exceção ao contexto passado para o gancho. `B` `readAfterSerialization` Depois `B` que o `readAfterSerialization` gancho for concluído, o mapeador devolve a exceção ao chamador. 

#### Modificar ganchos
<a name="ddb-mapper-interceptors-hooks-modify"></a>

*O mapeador invoca os ganchos de modificação antes de cada etapa no pipeline (exceto antes da inicialização).* Os ganchos de modificação oferecem a capacidade de ver e modificar uma operação de alto nível em andamento. Eles podem ser usados para personalizar o comportamento e os dados de uma forma que a configuração do mapeador e os esquemas de itens não fazem. Cada gancho de modificação recebe um argumento de contexto e retorna algum subconjunto desse contexto como resultado — modificado pelo gancho ou transmitido do contexto de entrada.

Se o mapeador detectar alguma exceção ao executar um gancho de modificação, ele não executará nenhum gancho de modificação de outros interceptores na mesma fase. O mapeador adiciona a exceção ao contexto e a passa para o próximo gancho somente para leitura. O mapeador lança qualquer exceção para o chamador somente depois de chamar o gancho somente para leitura dos últimos interceptores para a mesma fase. Por exemplo, se um mapeador estiver configurado com dois interceptores `A` e `B` o `modifyBeforeSerialization` gancho `A` de and gerar uma exceção, `B` o `modifyBeforeSerialization` gancho não será invocado. `A`O `readAfterSerialization` gancho `B'` dos interceptores e s será executado, após o qual a exceção será devolvida ao chamador.

#### Ordem de execução
<a name="ddb-mapper-interceptors-hooks-ex-order"></a>

A ordem na qual os interceptores são definidos na configuração de um mapeador determina a ordem em que o mapeador chama os ganchos:
+ Nas fases *anteriores* à etapa de *invocação de baixo nível*, ele executa os ganchos na *mesma ordem* em que foram adicionados na configuração.
+ Para fases *após* a etapa de *invocação de baixo nível*, ele executa ganchos na *ordem inversa da ordem* em que foram adicionados na configuração.

O diagrama a seguir mostra a ordem de execução dos métodos de gancho:

![\[Fluxograma dos métodos do gancho interceptor.\]](http://docs.aws.amazon.com/pt_br/sdk-for-kotlin/latest/developer-guide/images/KotlinDevGuide-dynamodbMapper-hook-flowchart.png)


##### Descrição em texto da ordem de execução dos métodos de gancho
<a name="ixg_ypr_ddc"></a>

Um mapeador executa os ganchos de um interceptor na seguinte ordem:

1. O DynamoDB Mapper invoca uma solicitação de alto nível

1. Leia antes da execução

1. Modificar antes da serialização

1. Leia antes da serialização

1. O DynamoDB Mapper converte objetos em itens

1. Leia após a serialização

1. Modificar antes da invocação

1. Leia antes da invocação

1. O DynamoDB Mapper invoca a operação de baixo nível

1. Leia após a invocação

1. Modificar antes da desserialização

1. Leia antes da desserialização

1. O DynamoDB Mapper converte itens em objetos

1. Leia após a desserialização

1. Modificar antes da conclusão

1. Leia após a execução

1. O DynamoDB Mapper retorna uma resposta de alto nível

#### Exemplo de configuração
<a name="ddb-mapper-interceptors-hooks-example-conf"></a>

O exemplo a seguir mostra como configurar um interceptor em uma `DynamoDbMapper` instância:

```
import aws.sdk.kotlin.hll.dynamodbmapper.DynamoDbMapper
import aws.sdk.kotlin.hll.dynamodbmapper.operations.ScanRequest
import aws.sdk.kotlin.hll.dynamodbmapper.operations.ScanResponse
import aws.sdk.kotlin.hll.dynamodbmapper.pipeline.Interceptor
import aws.sdk.kotlin.services.dynamodb.DynamoDbClient
import aws.sdk.kotlin.services.dynamodb.model.ScanRequest as LowLevelScanRequest
import aws.sdk.kotlin.services.dynamodb.model.ScanResponse as LowLevelScanResponse

val printingInterceptor = object : Interceptor<User, ScanRequest<User>, LowLevelScanRequest, LowLevelScanResponse, ScanResponse<User>> {
    override fun readBeforeDeserialization(ctx: LResContext<User, ScanRequest<User>, LowLevelScanRequest, LowLevelScanResponse>) {
        println("Scan response contains ${ctx.lowLevelResponse.count} items.")
    }
}

val client = DynamoDbClient.fromEnvironment()

val mapper = DynamoDbMapper(client) {
    interceptors += printingInterceptor
}
```