Creare un'app console Java con Azure DocumentDB

• .NET
• Python
• Node.js
• Java
• Go
• Rust

In questa guida si sviluppa un'applicazione console Java per connettersi a un cluster Azure DocumentDB. La guida include i passaggi per configurare l'ambiente di sviluppo, eseguire l'autenticazione usando il azure-identity pacchetto di Azure SDK per Java e interagire con il database e la raccolta per gestire i documenti.

Prerequisiti

• Una sottoscrizione di Azure

  • Se non hai un abbonamento Azure, crea un account gratuito

• Un cluster Di Azure DocumentDB esistente

  • Se non si ha un cluster, creare un nuovo cluster

• È possibile utilizzare l'ambiente Bash in Azure Cloud Shell. Per altre informazioni, vedere Introduzione ad Azure Cloud Shell.

  

• Se preferisci eseguire localmente i comandi di riferimento della CLI, installa l'Azure CLI. Per l'esecuzione in Windows o macOS, è consigliabile eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker. Per altre informazioni, vedere Come eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker.

  • Se usi un'installazione locale, accedi all'interfaccia della riga di comando di Azure usando il comando az login. Per completare il processo di autenticazione, seguire la procedura visualizzata nel terminale. Per altre opzioni di accesso, vedere Eseguire l'autenticazione ad Azure con l'interfaccia della riga di comando di Azure.

  • Quando ti viene richiesto, installa l'estensione Azure CLI al primo utilizzo. Per altre informazioni sulle estensioni, vedere Usare e gestire le estensioni con l'interfaccia della riga di comando di Azure.

  • Esegui az version per trovare la versione e le librerie dipendenti installate. Per eseguire l'aggiornamento alla versione più recente, avviare az upgrade.

• Autenticazione di Microsoft Entra configurata per il cluster con il ruolo root concesso all'identità dell'utente.

  • Per abilitare l'autenticazione di Microsoft Entra, vedere la guida alla configurazione.

• Versione più recente di Java.

Configurare l'applicazione console

Creare quindi un nuovo progetto di applicazione console e importare le librerie necessarie per l'autenticazione nel cluster.

1. Creare un nuovo progetto Maven usando gli strumenti da riga di comando Maven.

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

2. Passare alla directory del progetto.

   cd mongodb-console-app
   

3. Creare un nuovo file App.java con una Main classe nella directory del pacchetto appropriata.

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

4. Aggiungi la azure-identity dipendenza al file pom.xml.

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

5. Aggiungi la mongodb-driver-sync dipendenza al file pom.xml.

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

Connettersi al cluster

Ora, utilizza la libreria Azure.Identity per ottenere un TokenCredential da utilizzare per connetterti al cluster. Il driver Ufficiale di MongoDB ha un'interfaccia speciale che deve essere implementata per ottenere i token da Microsoft Entra per l'uso durante la connessione al cluster.

1. Per iniziare, importare le classi necessarie nella parte superiore del file di 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. Nel metodo Main, è necessario creare un'istanza di DefaultAzureCredential e impostare il callback OpenID Connect (OIDC) per recuperare i token.

   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. Creare una nuova istanza di MongoCredential usando il callback definito in precedenza.

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

4. Creare variabili per il nome del cluster e l'intero endpoint host.

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

5. Creare un'istanza MongoClientSettings usando l'host, le procedure consigliate per la connessione e le credenziali.

   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. Creare un nuovo MongoClient oggetto usando le impostazioni costruite.

   MongoClient client = MongoClients.create(settings);
   
   System.out.println("Client created");
   

Eseguire operazioni comuni

Infine, usare la libreria ufficiale per eseguire attività comuni con database, raccolte e documenti. In questo caso si usano le stesse classi e metodi usati per interagire con MongoDB o DocumentDB per gestire le raccolte e gli elementi.

1. Ottenere i riferimenti a database e 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. Rappresentare i documenti usando una 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. Creare un nuovo documento usando collection.replaceOne con upsert abilitato.

   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. Eseguire una ricerca di un singolo documento usando collection.find e l'identificatore univoco.

   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. Eseguire una query generale usando un filtro JSON binario (BSON).

   Bson query = Filters.eq("category", "gear-surf-surfboards");
   
   collection.find(query).forEach(doc -> {
       System.out.println("Found document:\\t" + doc.toJson());
   });
   

6. Eliminazione di documenti tramite un filtro e collection.deleteMany.

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

Contenuti correlati

• Panoramica dell'autenticazione di Microsoft Entra
• Configurazione di Microsoft Entra per il cluster