Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Comience a usar DynamoDB Mapper

En el siguiente tutorial se presentan los componentes básicos de DynamoDB Mapper y se muestra cómo utilizarlos en el código.

agregar dependencias de API

Para empezar a trabajar con DynamoDB Mapper en su proyecto de Gradle, añada un complemento y dos dependencias al archivo. build.gradle.kts

(Puedes navegar hasta el X.Y.Z enlace para ver la última versión disponible).

// build.gradle.kts
val sdkVersion: String = X.Y.Z

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

<Version>*Sustitúyalo por la versión más reciente del SDK. Para encontrar la versión más reciente del SDK, consulta la versión más reciente en GitHub.

Cree y utilice un mapeador

DynamoDB Mapper utiliza el cliente DynamoDB para AWS SDK para Kotlin interactuar con DynamoDB. Debe proporcionar una instancia completamente configurada al crear una DynamoDbClientinstancia de mapper, como se muestra en el siguiente fragmento de código:

import aws.sdk.kotlin.hll.dynamodbmapper.DynamoDbMapper
import aws.sdk.kotlin.services.dynamodb.DynamoDbClient

val client = DynamoDbClient.fromEnvironment()
val mapper = DynamoDbMapper(client)

Una vez que haya creado la instancia del mapeador, puede usarla para obtener la instancia de la tabla, como se muestra a continuación:

val carsTable = mapper.getTable("cars", CarSchema)

El código anterior obtiene una referencia a una tabla DynamoDB nombrada cars con un esquema definido por CarSchema (analizamos los esquemas a continuación). Después de crear una instancia de tabla, puede realizar operaciones con ella. En el siguiente fragmento de código se muestran dos ejemplos de operaciones con la cars tabla:

carsTable.putItem {
    item = Car(make = "Ford", model = "Model T", ...)
}

carsTable
   .queryPaginated {
        keyCondition = KeyFilter(partitionKey = "Peugeot")
   }
   .items()
   .collect { car -> println(car) }

El código anterior crea un elemento nuevo en la cars tabla. El código crea una Car instancia en línea utilizando la Car clase, cuya definición se muestra a continuación. A continuación, el código consulta la cars tabla en busca de elementos cuya clave de partición sea la clave Peugeot y los imprime. Las operaciones se describen con más detalle a continuación.

Defina un esquema con anotaciones de clase

Para una variedad de clases de Kotlin, el SDK puede generar esquemas automáticamente en el momento de la compilación mediante el complemento DynamoDB Mapper Schema Generator para Gradle. Cuando usas el generador de esquemas, el SDK inspecciona tus clases para deducir el esquema, lo que reduce parte del trabajo repetitivo que implica definir esquemas manualmente. Puedes personalizar el esquema que se genera mediante anotaciones y configuraciones adicionales.

Para generar un esquema a partir de anotaciones, primero anota tus clases con @DynamoDbItem y cualquier clave con y. @DynamoDbPartitionKey @DynamoDbSortKey El siguiente código muestra la clase Car anotada:

// The annotations used in the Car class are used by the plugin to generate a schema.
@DynamoDbItem
data class Car(
    @DynamoDbPartitionKey
    val make: String,
    
    @DynamoDbSortKey
    val model: String,
    
    val initialYear: Int
)

Después de la construcción, puede consultar la generada CarSchema automáticamente. Puedes usar la referencia en el getTable método del mapeador para obtener una instancia de tabla, como se muestra a continuación:

import aws.sdk.kotlin.hll.dynamodbmapper.generatedschemas.CarSchema

// `CarSchema` is generated at build time.
val carsTable = mapper.getTable("cars", CarSchema)

Como alternativa, puedes obtener la instancia de la tabla utilizando un método de extensión DynamoDbMapper que se genera automáticamente en el momento de la compilación. Al usar este enfoque, no necesitas referirte al esquema por su nombre. Como se muestra a continuación, el método de getCarsTable extensión generado automáticamente devuelve una referencia a la instancia de la tabla:

val carsTable = mapper.getCarsTable("cars")

Consulte Generar un esquema a partir de anotaciones para obtener más detalles y ejemplos.

Invoca operaciones

DynamoDB Mapper admite un subconjunto de las operaciones disponibles en los SDK. DynamoDbClient Las operaciones de Mapper reciben el mismo nombre que sus homólogas en el cliente del SDK. Muchos request/response miembros del mapeador son los mismos que sus homólogos del cliente del SDK, aunque a algunos se les ha cambiado el nombre, se les ha vuelto a escribir o se han eliminado por completo.

Para invocar una operación en una instancia de tabla, se utiliza una sintaxis de DSL, como se muestra a continuación:

import aws.sdk.kotlin.hll.dynamodbmapper.operations.putItem
import aws.sdk.kotlin.services.dynamodb.model.ReturnConsumedCapacity

val putResponse = carsTable.putItem {
    item = Car(make = "Ford", model = "Model T", ...)
    returnConsumedCapacity = ReturnConsumedCapacity.Total
}

println(putResponse.consumedCapacity)

También puedes invocar una operación mediante un objeto de solicitud explícito:

import aws.sdk.kotlin.hll.dynamodbmapper.operations.PutItemRequest
import aws.sdk.kotlin.services.dynamodb.model.ReturnConsumedCapacity

val putRequest = PutItemRequest<Car> {
    item = Car(make = "Ford", model = "Model T", ...)
    returnConsumedCapacity = ReturnConsumedCapacity.Total
}

val putResponse = carsTable.putItem(putRequest)
println(putResponse.consumedCapacity)

Los dos ejemplos de código anteriores son equivalentes.

Trabaja con respuestas paginadas

Algunas operaciones, como query y scan pueden devolver, recopilaciones de datos que pueden ser demasiado grandes como para devolvérselas en una sola respuesta. Para garantizar que se procesen todos los objetos, DynamoDB Mapper proporciona métodos de paginación, que no llaman a DynamoDB inmediatamente, sino que devuelven Flow un tipo de respuesta a una operación, como se muestra a continuación: Flow<ScanResponse<Car>>

import aws.sdk.kotlin.hll.dynamodbmapper.operations.scanPaginated

val scanResponseFlow = carsTable.scanPaginated { }

scanResponseFlow.collect { response ->
    val items = response.items.orEmpty()
    println("Found page with ${items.size} items:")
    
    items.forEach { car -> println(car) }
}

A menudo, un flujo de objetos es más útil para la lógica empresarial que un flujo de respuestas que contenga objetos. El mapeador proporciona un método de extensión de las respuestas paginadas para acceder al flujo de objetos. Por ejemplo, el código siguiente devuelve un Flow<Car> en lugar de un, Flow<ScanResponse<Car>> como se muestra anteriormente:

import aws.sdk.kotlin.hll.dynamodbmapper.operations.items
import aws.sdk.kotlin.hll.dynamodbmapper.operations.scanPaginated

val carFlow = carsTable
    .scanPaginated { }
    .items()

carFlow.collect { car -> println(car) }