Travaillez avec des classes de données immuables

La fonctionnalité de mappage de l'API DynamoDB Enhanced Client fonctionne avec des classes de données immuables. Une classe immuable ne possède que des getters et nécessite une classe de générateur que le SDK utilise pour créer des instances de la classe. Au lieu d'utiliser l'@DynamoDbBeanannotation comme indiqué dans la classe Customer, les classes immuables utilisent l'@DynamoDbImmutableannotation, qui prend un paramètre indiquant la classe de générateur à utiliser.

La classe suivante est une version immuable de. Customer

package org.example.tests.model.immutable;

import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbImmutable;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSecondaryPartitionKey;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSecondarySortKey;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey;

import java.time.Instant;

@DynamoDbImmutable(builder = CustomerImmutable.Builder.class)
public class CustomerImmutable {
    private final String id;
    private final String name;
    private final String email;
    private final Instant regDate;

    private CustomerImmutable(Builder b) {
        this.id = b.id;
        this.email = b.email;
        this.name = b.name;
        this.regDate = b.regDate;
    }

    // This method will be automatically discovered and used by the TableSchema.
    public static Builder builder() { return new Builder(); }

    @DynamoDbPartitionKey
    public String id() { return this.id; }

    @DynamoDbSortKey
    public String email() { return this.email; }

    @DynamoDbSecondaryPartitionKey(indexNames = "customers_by_name")
    public String name() { return this.name; }

    @DynamoDbSecondarySortKey(indexNames = {"customers_by_date", "customers_by_name"})
    public Instant regDate() { return this.regDate; }

    public static final class Builder {
        private String id;
        private String email;
        private String name;
        private Instant regDate;

        // The private Builder constructor is visible to the enclosing CustomerImmutable class.
        private Builder() {}

        public Builder id(String id) { this.id = id; return this; }
        public Builder email(String email) { this.email = email; return this; }
        public Builder name(String name) { this.name = name; return this; }
        public Builder regDate(Instant regDate) { this.regDate = regDate; return this; }

        // This method will be automatically discovered and used by the TableSchema.
        public CustomerImmutable build() { return new CustomerImmutable(this); }
    }
}

Vous devez satisfaire aux exigences suivantes lorsque vous annotez une classe de données avec@DynamoDbImmutable.

1. Chaque méthode qui n'est pas une substitution Object.class et qui n'a pas été annotée @DynamoDbIgnore doit être un getter pour un attribut de la table DynamoDB.

2. Chaque getter doit avoir un setter correspondant distinguant majuscules et minuscules dans la classe de générateur.

3. Seule l'une des conditions de construction suivantes doit être respectée.

   • La classe de générateur doit avoir un constructeur public par défaut.

   • La classe de données doit avoir une méthode statique publique nommée builder() qui ne prend aucun paramètre et renvoie une instance de la classe de générateur. Cette option est affichée dans la Customer classe immuable.

4. La classe builder doit avoir une méthode publique nommée build() qui ne prend aucun paramètre et renvoie une instance de la classe immuable.

Pour créer un TableSchema pour votre classe immuable, utilisez la fromImmutableClass() méthode on TableSchema comme indiqué dans l'extrait suivant.

static final TableSchema<CustomerImmutable> customerImmutableTableSchema = 
                         TableSchema.fromImmutableClass(CustomerImmutable.class);

Tout comme vous pouvez créer une table DynamoDB à partir d'une classe mutable, vous pouvez en créer une à partir d'une classe immuable avec un appel unique à of, comme indiqué dans l'exemple DynamoDbTable d'createTable()extrait de code suivant.

static void createTableFromImmutable(DynamoDbEnhancedClient enhancedClient, String tableName, DynamoDbWaiter waiter){
    // First, create an in-memory representation of the table using the 'table()' method of the DynamoDb Enhanced Client.
    // 'table()' accepts a name for the table and a TableSchema instance that you created previously.
    DynamoDbTable<CustomerImmutable> customerDynamoDbTable = enhancedClient
            .table(tableName, TableSchema.fromImmutableClass(CustomerImmutable.class));
        
    // Second, call the 'createTable()' method on the DynamoDbTable instance.
    customerDynamoDbTable.createTable();
    waiter.waitUntilTableExists(b -> b.tableName(tableName));
}

Utilisez des bibliothèques tierces, telles que Lombok

Les bibliothèques tierces, telles que Project Lombok, aident à générer du code standard associé à des objets immuables. L'API DynamoDB Enhanced Client fonctionne avec ces bibliothèques tant que les classes de données respectent les conventions détaillées dans cette section.

L'exemple suivant montre la CustomerImmutable classe immuable avec les annotations Lombok. Notez comment la onMethod fonctionnalité de Lombok copie les annotations DynamoDB basées sur les attributs, telles que, sur le code généré. @DynamoDbPartitionKey

@Value
@Builder
@DynamoDbImmutable(builder = Customer.CustomerBuilder.class)
public class Customer {
    @Getter(onMethod_=@DynamoDbPartitionKey)
    private String id;

    @Getter(onMethod_=@DynamoDbSortKey)
    private String email;

    @Getter(onMethod_=@DynamoDbSecondaryPartitionKey(indexNames = "customers_by_name"))
    private String name;

    @Getter(onMethod_=@DynamoDbSecondarySortKey(indexNames = {"customers_by_date", "customers_by_name"}))
    private Instant createdDate;
}