Partager via

Créer une application console Java avec Azure DocumentDB

Dans ce guide, vous développez une application console Java pour vous connecter à un cluster Azure DocumentDB. Le guide inclut les étapes de configuration de votre environnement de développement, l’authentification à l’aide du azure-identity package à partir du Kit de développement logiciel (SDK) Azure pour Java, et l’interaction avec la base de données et la collection pour gérer les documents.

Prerequisites

  • Un abonnement Azure

  • Un cluster Azure DocumentDB existant

    • Si vous n’avez pas de cluster, créez un cluster

Configurer votre application console

Ensuite, créez un projet d’application console et importez les bibliothèques nécessaires pour vous authentifier auprès de votre cluster.

  1. Créez un projet Maven à l’aide des outils en ligne de commande Maven.

    mvn archetype:generate -DgroupId=com.cosmicworks -DartifactId=mongodb-console-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

  2. Accédez au répertoire du projet.

    cd mongodb-console-app

  3. Créez un fichier App.java avec une Main classe dans le répertoire de package approprié.

    mkdir -p src/main/java/com/cosmicworks
touch src/main/java/com/cosmicworks/App.java

  4. Ajoutez la azure-identity dépendance à votre fichier pom.xml .

    <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.15.4</version>
</dependency>

  5. Ajoutez la mongodb-driver-sync dépendance à votre fichier pom.xml .

    <dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver-sync</artifactId>
    <version>5.4.0</version>
</dependency>

Se connecter au cluster

À présent, utilisez la bibliothèque Azure.Identity pour obtenir un TokenCredential à utiliser afin de vous connecter à votre cluster. Le pilote MongoDB officiel a une interface spéciale qui doit être implémentée pour obtenir des jetons de Microsoft Entra à utiliser lors de la connexion au cluster.

  1. Commencez par importer les classes requises en haut de votre fichier de classe Java.

    import java.util.concurrent.TimeUnit;

import org.bson.Document;
import org.bson.conversions.Bson;

import com.azure.core.credential.TokenCredential;
import com.azure.core.credential.TokenRequestContext;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.mongodb.MongoClientSettings;
import com.mongodb.MongoCredential;
import com.mongodb.MongoCredential.OidcCallbackContext;
import com.mongodb.MongoCredential.OidcCallbackResult;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.ReplaceOptions;
import com.mongodb.client.result.UpdateResult;

  2. Dans votre méthode principale, créez une DefaultAzureCredential instance et configurez le rappel OpenID Connect (OIDC) pour récupérer des jetons.

    TokenCredential credential = new DefaultAzureCredentialBuilder().build();

MongoCredential.OidcCallback oidcCallback = new MongoCredential.OidcCallback() {
    @Override
    public OidcCallbackResult onRequest(OidcCallbackContext context) {
        TokenRequestContext tokenRequestContext = new TokenRequestContext()
                .addScopes("https://ossrdbms-aad.database.windows.net/.default");
        String token = credential.getTokenSync(tokenRequestContext).getToken();
        return new OidcCallbackResult(token);
    }
};

  3. Créez une nouvelle instance de MongoCredential en utilisant votre rappel défini précédemment.

    MongoCredential mongoCredential = MongoCredential.createOidcCredential(null)
        .withMechanismProperty("OIDC_CALLBACK", oidcCallback);

  4. Créez des variables pour le nom du cluster et le point de terminaison hôte entier.

    String clusterName = "<azure-documentdb-cluster-name>";
String host = clusterName + ".global.mongocluster.cosmos.azure.com";

  5. Construisez une MongoClientSettings instance à l’aide de l’hôte, des bonnes pratiques de connexion et des informations d’identification.

    MongoClientSettings settings = MongoClientSettings.builder()
        .applyToClusterSettings(builder -> builder
                .srvHost(host))
        .applyToSocketSettings(builder -> builder
                .connectTimeout(2, TimeUnit.MINUTES))
        .applyToSslSettings(builder -> builder
                .enabled(true))
        .retryWrites(true)
        .credential(mongoCredential)
        .build();

  6. Créez un MongoClient à l’aide des paramètres construits.

    MongoClient client = MongoClients.create(settings);

System.out.println("Client created");

Effectuer des opérations courantes

Enfin, utilisez la bibliothèque officielle pour effectuer des tâches courantes avec des bases de données, des collections et des documents. Ici, vous utilisez les mêmes classes et méthodes que celles que vous utiliseriez pour interagir avec MongoDB ou DocumentDB pour gérer vos collections et éléments.

  1. Obtenez des références à vos database et collection.

    MongoDatabase database = client.getDatabase("<database-name>");

System.out.println("Database pointer created");

MongoCollection<Document> collection = database.getCollection("<collection-name>");

System.out.println("Collection pointer created");

  2. Représentez vos documents à l’aide d’une Product classe.

    public class Product {
    private String _id;
    private String category;
    private String name;
    private int quantity;
    private double price;
    private boolean clearance;

    // Getters and setters ommitted for brevity
}

  3. Créez un nouveau document à l'aide de collection.replaceOne avec upsert activé.

    Document document = new Document()
        .append("_id", "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb")
        .append("category", "gear-surf-surfboards")
        .append("name", "Yamba Surfboard")
        .append("quantity", 12)
        .append("price", 850.00)
        .append("clearance", false);

Bson match = Filters.eq("_id", "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb");

ReplaceOptions options = new ReplaceOptions().upsert(true);
UpdateResult result = collection.replaceOne(match, document, options);

System.out.println("Document upserted with _id:\\t" + result.getUpsertedId().asString().getValue());

  4. Effectuez une recherche d'un document unique en utilisant collection.find et l'identificateur unique.

    Bson filter = Filters.eq("_id", "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb");

collection.find(filter).forEach(doc -> {
    System.out.println("Read document _id:\\t" + doc.toJson());
});

  5. Effectuez une requête générale à l’aide d’un filtre JSON binaire (BSON).

    Bson query = Filters.eq("category", "gear-surf-surfboards");

collection.find(query).forEach(doc -> {
    System.out.println("Found document:\\t" + doc.toJson());
});

  6. Suppression de documents à l’aide d’un filtre et collection.deleteMany.

    Bson filter = Filters.eq("clearance", true);
collection.deleteMany(filter);

Contenu connexe

  • Last updated on