ArangoDB : Réussir avec une base de données multivaluée

La manipulation de structures de base de données diverses introduit souvent une complexité significative dans l’architecture du système, surtout lorsque plusieurs instances de base de données sont requises. Cette fragmentation peut compliquer les opérations, augmenter les coûts et réduire l’efficacité. Les bases de données multimodèles telles que ArangoDB fournissent une solution unifiée pour relever ces défis. Elles simplifient l’architecture et rationalisent la gestion des données en prenant en charge plusieurs modèles de données – clé-valeur, document et graphe – au sein d’une seule instance de base de données.

Contrairement aux bases de données relationnelles, les bases de données NoSQL ne respectent pas de norme universelle comme le SQL. Au lieu de cela, elles sont catégorisées en fonction de leur structure de stockage. Parmi les types populaires, on trouve :

• Clé-valeur : Ressemblant à une Map en Java ou à un dictionnaire Python, cette structure récupère des valeurs entières en tant que BLOB à l’aide d’une clé.
• Colonnes larges : Similaire à la clé-valeur mais divise les valeurs en colonnes, offrant une récupération de données plus granulaire.
• Document : Structuré comme JSON ou XML, ce type offre une plus grande souplesse de requête.
• Graphe : Permet la modélisation et l’interrogation de relations complexes en représentant des entités et leurs connexions.

Une base de données multimodèle combine ces capacités dans un seul système. Par exemple, ArangoDB prend en charge les modèles clé-valeur, document et graphe, éliminant le besoin de bases de données séparées.

Cet article démontre comment utiliser ArangoDB pour explorer les modèles clé-valeur et document dans les applications Java en utilisant Jakarta NoSQL.

Configuration d’ArangoDB

Pour commencer avec ArangoDB, Docker fournit un moyen simple de gérer les services tiers. En exécutant la commande suivante, vous pouvez configurer une instance ArangoDB facilement :

docker run -e ARANGO_NO_AUTH=1 -d --name arangodb-instance -p 8529:8529 arangodb/arangodb

Exploration des données clé-valeur

Les bases de données clé-valeur sont idéales pour des modèles de données simples. Créons une application d’exemple pour gérer des données d’aéroport en utilisant les capacités clé-valeur d’ArangoDB. L’entité Airport inclura deux champs : code (ID) et name.

import jakarta.nosql.Column;

import jakarta.nosql.Entity;

import jakarta.nosql.Id;

import net.datafaker.Faker;

import net.datafaker.providers.base.Aviation;

​

import java.util.Objects;

​

@Entity

public class Airport {

​

    @Id

    private String code;

​

    @Column

    private String name;

​

​

    public String getCode() {

        return code;

    }

​

    public String getName() {

        return name;

    }

​

​

    @Override

    public boolean equals(Object o) {

        if (o == null || getClass() != o.getClass()) {

            return false;

        }

        Airport airport = (Airport) o;

        return Objects.equals(code, airport.code);

    }

​

    @Override

    public int hashCode() {

        return Objects.hashCode(code);

    }

​

    @Override

    public String toString() {

        return "Airport{" +

                "code='" + code + '\'' +

                ", name='" + name + '\'' +

                '}';

    }

​

    public static Airport of(Faker faker) {

        Aviation aviation = faker.aviation();

        var airport = new Airport();

        airport.code = aviation.airport();

        airport.name = aviation.airport();

        return airport;

    }

}

​

Avec l’entité définie, vous pouvez utiliser KeyValueTemplate pour interagir avec la base de données. Dans ce tutoriel, nous explorerons davantage la capacité Jakarta NoSQL au-delà des annotations en utilisant Eclipse JNoSQL ; vous pouvez créer le référentiel une fois qu’Eclipse JNoSQL implémente et prend en charge Jakarta Data.

import jakarta.enterprise.inject.se.SeContainer;

import jakarta.enterprise.inject.se.SeContainerInitializer;

import net.datafaker.Faker;

import org.eclipse.jnosql.mapping.keyvalue.KeyValueTemplate;

​

public class App {

​

    public static void main(String[] args) {

        var faker = new Faker();

​

        try (SeContainer container = SeContainerInitializer.newInstance().initialize()) {

            KeyValueTemplate template = container.select(KeyValueTemplate.class).get();

            var airport = template.put(Airport.of(faker));

            System.out.println(template.get(airport.getCode(), Airport.class));

        }

    }

}

​

Ce programme génère un enregistrement aléatoire d’aéroport, l’insère dans la base de données et le récupère. Si vous exécutez localement, vous pouvez vérifier les valeurs dans la base de données en utilisant votre navigateur avec l’URL :

http://localhost:8529/_db/airport/_admin/aardvark/index.html#collections

Travailler avec les données de document

Jakarta NoSQL propose des fonctionnalités riches pour travailler avec des bases de données de documents, y compris le support de l’héritage et de la modélisation des données hiérarchiques. Alors que les bases de données NoSQL ne prennent généralement pas en charge ces fonctionnalités de manière inhérente, Jakarta NoSQL comble ce fossé avec son API. Utilisons Jakarta NoSQL avec ArangoDB pour gérer les données des fournisseurs de cloud, y compris deux spécialisations : Amazon Web Services (AWS) et Azure.

Jakarta NoSQL utilise les annotations @DiscriminatorColumn, @DiscriminatorValue et @Inheritance pour gérer l’héritage dans les bases de données de documents. 

• L’annotation @DiscriminatorColumn spécifie le champ utilisé pour identifier un type d’entité dans le document de la base de données. 
• L’annotation @DiscriminatorValue définit la valeur spécifique pour chaque sous-classe, garantissant qu’elles sont correctement identifiées.
• L’annotation @Inheritance indique que la hiérarchie de classes sera mappée dans la base de données.

Tout d’abord, définissons la classe de base pour les fournisseurs de cloud :

@Entity

@Inheritance

@DiscriminatorColumn("type")

public class CloudProvider {

​

    @Id

    protected String id;

​

    @Column

    protected String region;

}

Ensuite, nous introduisons les classes spécialisées de fournisseurs de cloud. Ces exemples montrent comment Jakarta NoSQL utilise les annotations @DiscriminatorValue pour distinguer entre différents types de documents. Chaque spécialisation — AWS et Azure — hérite de la classe de base CloudProvider, tout en définissant des attributs uniques à chaque fournisseur. De plus, des méthodes de fabrique (of) sont fournies pour générer des données d’exemple à des fins de démonstration.

AWSCloudProvider

import jakarta.nosql.Column;

import jakarta.nosql.DiscriminatorValue;

import jakarta.nosql.Entity;

import net.datafaker.Faker;

​

import java.util.UUID;

​

@Entity

@DiscriminatorValue("AWS")

public class AWSCloudProvider extends CloudProvider {

​

​

    @Column

    private String accountId;

​

    public String getAccountId() {

        return accountId;

    }

​

    @Override

    public String toString() {

        return "AWSCloudProvider{" +

                "accountId='" + accountId + '\'' +

                ", id='" + id + '\'' +

                ", region='" + region + '\'' +

                '}';

    }

​

    public static AWSCloudProvider of(Faker faker) {

        var aws = faker.aws();

        var cloudProvider = new AWSCloudProvider();

        cloudProvider.region = aws.region();

        cloudProvider.region = aws.region();

        cloudProvider.id = UUID.randomUUID().toString();

        cloudProvider.accountId = aws.accountId();

        return cloudProvider;

    }

​

​

}

​

FournisseurCloudAzure

package org.soujava.demos.arangodb.document;

​

import jakarta.nosql.Column;

import jakarta.nosql.DiscriminatorValue;

import jakarta.nosql.Entity;

import net.datafaker.Faker;

​

import java.util.UUID;

​

@Entity

@DiscriminatorValue("AZURE")

public class AzureCloudProvider extends CloudProvider {

​

​

    @Column

    private String tenantId;

​

    public String getTenantId() {

        return tenantId;

    }

​

    @Override

    public String toString() {

        return "AzureCloudProvider{" +

                "tenantId='" + tenantId + '\'' +

                ", id='" + id + '\'' +

                ", region='" + region + '\'' +

                '}';

    }

​

    public static AzureCloudProvider of(Faker faker) {

        var azure = faker.azure();

        var cloudProvider = new AzureCloudProvider();

        cloudProvider.region = azure.region();

        cloudProvider.region = azure.region();

        cloudProvider.id = UUID.randomUUID().toString();

        cloudProvider.tenantId = azure.tenantId();

        return cloudProvider;

    }

}

Enfin, voyons comment utiliser le DocumentTemplate pour interagir avec la base de données. Ce code démontre la création d’instances de fournisseurs AWS et Azure, leur insertion dans la base de données et leur récupération. L’implémentation s’appuie sur l’API Jakarta NoSQL pour gérer la persistance des données, garantissant que l’héritage et la logique de discriminateur sont appliqués de manière transparente lors du stockage et de la récupération.

import jakarta.enterprise.inject.se.SeContainer;

import jakarta.enterprise.inject.se.SeContainerInitializer;

import net.datafaker.Faker;

import org.eclipse.jnosql.mapping.document.DocumentTemplate;

​

import java.util.List;

import java.util.logging.Logger;

​

​

public class App {

​

    private static final Logger LOGGER = Logger.getLogger(App.class.getName());

​

    public static void main(String[] args) {

        var faker = new Faker();

        LOGGER.info("Starting the application");

        try (SeContainer container = SeContainerInitializer.newInstance().initialize()) {

            var template = container.select(DocumentTemplate.class).get();

            LOGGER.info("Creating 10 documents");

            for (int index = 0; index < 5; index++) {

                template.insert(List.of(AWSCloudProvider.of(faker), AzureCloudProvider.of(faker)));

            }

​

            System.out.println("The cloud providers here");

            template.select(CloudProvider.class).stream().forEach(System.out::println);

​

            System.out.println("The AWS cloud providers here");

            template.select(AWSCloudProvider.class).stream().forEach(System.out::println);

​

            System.out.println("The Azure cloud providers here");

            template.select(AzureCloudProvider.class).stream().forEach(System.out::println);

        }

    }

​

    private App() {

    }

}

​

Conclusion

Les capacités multimodèles d’ArangoDB en font un choix polyvalent pour les applications modernes. La combinaison de modèles clé-valeur et de documents dans une seule base de données simplifie votre architecture de données tout en conservant la flexibilité. Avec Jakarta NoSQL, l’intégration d’ArangoDB dans les applications Java devient fluide, tirant parti d’annotations et de paradigmes de programmation familiers.

Pour le code complet, visitez le Dépôt GitHub.