Generar un esquema a partir de anotaciones

DynamoDB Mapper se basa en esquemas que definen el mapeo entre las clases de Kotlin y los elementos de DynamoDB. Las clases de Kotlin pueden impulsar la creación de esquemas mediante el complemento generador de esquemas de Gradle.

Aplica el complemento

Para empezar a generar código para tus clases, aplica el complemento en el script de compilación de la aplicación y añade una dependencia en el módulo de anotaciones. En el siguiente fragmento de script de Gradle, se muestra la configuración necesaria para la generación de código.

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

Configura el complemento

El complemento ofrece una serie de opciones de configuración que puedes aplicar mediante la extensión del dynamoDbMapper { ... } complemento en tu script de compilación:

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

Anota las clases

El generador de esquemas busca anotaciones de clases para determinar para qué clases generar esquemas. Para optar por la generación de esquemas, anota tus clases con ellas. @DynamoDbItem También debes anotar con la anotación una propiedad de clase que sirva como clave de partición del elemento. @DynamoDbPartitionKey

La siguiente definición de clase muestra las anotaciones mínimas necesarias para la generación del esquema:

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

Anotaciones de clase

Las siguientes anotaciones se aplican a las clases para controlar la generación del esquema:

Anotaciones de propiedades

Puede aplicar las siguientes anotaciones a las propiedades de la clase para controlar la generación del esquema:

Defina un conversor de artículos personalizado

En algunos casos, es posible que desees definir un conversor de artículos personalizado para tu clase. Una razón para ello sería si tu clase usa un tipo que no es compatible con el complemento generador de esquemas. Usamos la siguiente versión de la Employee clase como ejemplo:

import kotlin.uuid.Uuid

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

La Employee clase ahora usa un kotlin.uuid.Uuid tipo, que actualmente no es compatible con el generador de esquemas. La generación del esquema falla y se produce un error:Unsupported attribute type TypeRef(pkg=kotlin.uuid, shortName=Uuid, genericArgs=[], nullable=false). Este error indica que el complemento no puede generar un convertidor de elementos para esta clase. Por lo tanto, necesitamos escribir el nuestro.

Para ello, implementamos una ItemConverter para la clase y, a continuación, modificamos la anotación de la @DynamoDbItem clase especificando el nombre completo del nuevo conversor de elementos.

En primer lugar, implementamos a ValueConverter para la kotlin.uuid.Uuid clase:

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

Luego, implementamos una ItemConverter para nuestra Employee clase. ItemConverterUtiliza este nuevo conversor de valores en el descriptor de atributos de «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
        )
    ),
)

Ahora que hemos definido el conversor de artículos, podemos aplicarlo a nuestra clase. Actualizamos la @DynamoDbItem anotación para hacer referencia al conversor de artículos proporcionando el nombre completo de la clase, tal y como se muestra a continuación:

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
)

Por último, podemos empezar a usar la clase con DynamoDB Mapper.