Defina esquemas manualmente

Defina un esquema en el código

Para obtener el máximo control y personalización, puede definir y personalizar manualmente los esquemas en el código.

Como se muestra en el siguiente fragmento, es necesario incluir menos dependencias en el build.gradle.kts archivo en comparación con la creación de esquemas basada en anotaciones.

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

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

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

Ten en cuenta que no necesitas el complemento generador de esquemas ni el paquete de anotaciones.

El mapeo entre una clase de Kotlin y un elemento de DynamoDB requiere ItemSchema<T> una implementación, T donde es el tipo de la clase de Kotlin. Un esquema consta de los siguientes elementos:

En el siguiente código, creamos una CarSchema instancia manualmente:

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)

El código anterior crea un convertidor denominadocarConverter, que se define como una implementación anónima deItemConverter<Car>. El convertTo método del convertidor acepta un Car argumento y devuelve una Item instancia que representa las claves y valores literales de los atributos de los elementos de DynamoDB. El convertFrom método del convertidor acepta un Item argumento y devuelve una Car instancia a partir de los valores de atributo del Item argumento.

A continuación, el código crea dos especificaciones clave: una para la clave de partición y otra para la clave de clasificación. Cada tabla o índice de DynamoDB debe tener exactamente una clave de partición y, en consecuencia, también lo debe tener cada definición de esquema de DynamoDB Mapper. Los esquemas también pueden tener una clave de clasificación.

En la última declaración, el código crea un esquema para la tabla de cars DynamoDB a partir del convertidor y de las especificaciones clave.

El esquema resultante es equivalente al esquema basado en anotaciones que generamos en la sección. Defina un esquema con anotaciones de clase Como referencia, la siguiente es la clase anotada que utilizamos:

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

Además de implementar las suyas propiasItemConverter, DynamoDB Mapper incluye varias implementaciones útiles, como: